drivers/xen/xenbus/xenbus_xs.c

   1 /******************************************************************************
   2  * xenbus_xs.c
   3  *
   4  * This is the kernel equivalent of the "xs" library.  We don't need everything
   5  * and we use xenbus_comms for communication.
   6  *
   7  * Copyright (C) 2005 Rusty Russell, IBM Corporation
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License version 2
  11  * as published by the Free Software Foundation; or, when distributed
  12  * separately from the Linux kernel or incorporated into other
  13  * software packages, subject to the following license:
  14  *
  15  * Permission is hereby granted, free of charge, to any person obtaining a copy
  16  * of this source file (the "Software"), to deal in the Software without
  17  * restriction, including without limitation the rights to use, copy, modify,
  18  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  19  * and to permit persons to whom the Software is furnished to do so, subject to
  20  * the following conditions:
  21  *
  22  * The above copyright notice and this permission notice shall be included in
  23  * all copies or substantial portions of the Software.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  28  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  29  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  30  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  31  * IN THE SOFTWARE.
  32  */
  33
  34 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  35
  36 #include <linux/unistd.h>
  37 #include <linux/errno.h>
  38 #include <linux/types.h>
  39 #include <linux/uio.h>
  40 #include <linux/kernel.h>
  41 #include <linux/string.h>
  42 #include <linux/err.h>
  43 #include <linux/slab.h>
  44 #include <linux/fcntl.h>
  45 #include <linux/kthread.h>
  46 #include <linux/reboot.h>
  47 #include <linux/rwsem.h>
  48 #include <linux/mutex.h>
  49 #include <asm/xen/hypervisor.h>
  50 #include <xen/xenbus.h>
  51 #include <xen/xen.h>
  52 #include "xenbus.h"
  53
  54 /*
  55  * Framework to protect suspend/resume handling against normal Xenstore
  56  * message handling:
  57  * During suspend/resume there must be no open transaction and no pending
  58  * Xenstore request.
  59  * New watch events happening in this time can be ignored by firing all watches
  60  * after resume.
  61  */
  62
  63 /* Lock protecting enter/exit critical region. */
  64 static DEFINE_SPINLOCK(xs_state_lock);
  65 /* Number of users in critical region (protected by xs_state_lock). */
  66 static unsigned int xs_state_users;
  67 /* Suspend handler waiting or already active (protected by xs_state_lock)? */
  68 static int xs_suspend_active;
  69 /* Unique Xenstore request id (protected by xs_state_lock). */
  70 static uint32_t xs_request_id;
  71
  72 /* Wait queue for all callers waiting for critical region to become usable. */
  73 static DECLARE_WAIT_QUEUE_HEAD(xs_state_enter_wq);
  74 /* Wait queue for suspend handling waiting for critical region being empty. */
  75 static DECLARE_WAIT_QUEUE_HEAD(xs_state_exit_wq);
  76
  77 /* List of registered watches, and a lock to protect it. */
  78 static LIST_HEAD(watches);
  79 static DEFINE_SPINLOCK(watches_lock);
  80
  81 /* List of pending watch callback events, and a lock to protect it. */
  82 static LIST_HEAD(watch_events);
  83 static DEFINE_SPINLOCK(watch_events_lock);
  84
  85 /* Protect watch (de)register against save/restore. */
  86 static DECLARE_RWSEM(xs_watch_rwsem);
  87
  88 /*
  89  * Details of the xenwatch callback kernel thread. The thread waits on the
  90  * watch_events_waitq for work to do (queued on watch_events list). When it
  91  * wakes up it acquires the xenwatch_mutex before reading the list and
  92  * carrying out work.
  93  */
  94 static pid_t xenwatch_pid;
  95 static DEFINE_MUTEX(xenwatch_mutex);
  96 static DECLARE_WAIT_QUEUE_HEAD(watch_events_waitq);
  97
  98 static void xs_suspend_enter(void)
  99 {
 100         spin_lock(&xs_state_lock);
 101         xs_suspend_active++;
 102         spin_unlock(&xs_state_lock);
 103         wait_event(xs_state_exit_wq, xs_state_users == 0);
 104 }
 105
 106 static void xs_suspend_exit(void)
 107 {
 108         spin_lock(&xs_state_lock);
 109         xs_suspend_active--;
 110         spin_unlock(&xs_state_lock);
 111         wake_up_all(&xs_state_enter_wq);
 112 }
 113
 114 static uint32_t xs_request_enter(struct xb_req_data *req)
 115 {
 116         uint32_t rq_id;
 117
 118         req->type = req->msg.type;
 119
 120         spin_lock(&xs_state_lock);
 121
 122         while (!xs_state_users && xs_suspend_active) {
 123                 spin_unlock(&xs_state_lock);
 124                 wait_event(xs_state_enter_wq, xs_suspend_active == 0);
 125                 spin_lock(&xs_state_lock);
 126         }
 127
 128         if (req->type == XS_TRANSACTION_START)
 129                 xs_state_users++;
 130         xs_state_users++;
 131         rq_id = xs_request_id++;
 132
 133         spin_unlock(&xs_state_lock);
 134
 135         return rq_id;
 136 }
 137
 138 void xs_request_exit(struct xb_req_data *req)
 139 {
 140         spin_lock(&xs_state_lock);
 141         xs_state_users--;
 142         if ((req->type == XS_TRANSACTION_START && req->msg.type == XS_ERROR) ||
 143             (req->type == XS_TRANSACTION_END &&
 144              !WARN_ON_ONCE(req->msg.type == XS_ERROR &&
 145                            !strcmp(req->body, "ENOENT"))))
 146                 xs_state_users--;
 147         spin_unlock(&xs_state_lock);
 148
 149         if (xs_suspend_active && !xs_state_users)
 150                 wake_up(&xs_state_exit_wq);
 151 }
 152
 153 static int get_error(const char *errorstring)
 154 {
 155         unsigned int i;
 156
 157         for (i = 0; strcmp(errorstring, xsd_errors[i].errstring) != 0; i++) {
 158                 if (i == ARRAY_SIZE(xsd_errors) - 1) {
 159                         pr_warn("xen store gave: unknown error %s\n",
 160                                 errorstring);
 161                         return EINVAL;
 162                 }
 163         }
 164         return xsd_errors[i].errnum;
 165 }
 166
 167 static bool xenbus_ok(void)
 168 {
 169         switch (xen_store_domain_type) {
 170         case XS_LOCAL:
 171                 switch (system_state) {
 172                 case SYSTEM_POWER_OFF:
 173                 case SYSTEM_RESTART:
 174                 case SYSTEM_HALT:
 175                         return false;
 176                 default:
 177                         break;
 178                 }
 179                 return true;
 180         case XS_PV:
 181         case XS_HVM:
 182                 /* FIXME: Could check that the remote domain is alive,
 183                  * but it is normally initial domain. */
 184                 return true;
 185         default:
 186                 break;
 187         }
 188         return false;
 189 }
 190
 191 static bool test_reply(struct xb_req_data *req)
 192 {
 193         if (req->state == xb_req_state_got_reply || !xenbus_ok())
 194                 return true;
 195
 196         /* Make sure to reread req->state each time. */
 197         barrier();
 198
 199         return false;
 200 }
 201
 202 static void *read_reply(struct xb_req_data *req)
 203 {
 204         while (req->state != xb_req_state_got_reply) {
 205                 wait_event(req->wq, test_reply(req));
 206
 207                 if (!xenbus_ok())
 208                         /*
 209                          * If we are in the process of being shut-down there is
 210                          * no point of trying to contact XenBus - it is either
 211                          * killed (xenstored application) or the other domain
 212                          * has been killed or is unreachable.
 213                          */
 214                         return ERR_PTR(-EIO);
 215                 if (req->err)
 216                         return ERR_PTR(req->err);
 217
 218         }
 219
 220         return req->body;
 221 }
 222
 223 static void xs_send(struct xb_req_data *req, struct xsd_sockmsg *msg)
 224 {
 225         bool notify;
 226
 227         req->msg = *msg;
 228         req->err = 0;
 229         req->state = xb_req_state_queued;
 230         init_waitqueue_head(&req->wq);
 231
 232         /* Save the caller req_id and restore it later in the reply */
 233         req->caller_req_id = req->msg.req_id;
 234         req->msg.req_id = xs_request_enter(req);
 235
 236         mutex_lock(&xb_write_mutex);
 237         list_add_tail(&req->list, &xb_write_list);
 238         notify = list_is_singular(&xb_write_list);
 239         mutex_unlock(&xb_write_mutex);
 240
 241         if (notify)
 242                 wake_up(&xb_waitq);
 243 }
 244
 245 static void *xs_wait_for_reply(struct xb_req_data *req, struct xsd_sockmsg *msg)
 246 {
 247         void *ret;
 248
 249         ret = read_reply(req);
 250
 251         xs_request_exit(req);
 252
 253         msg->type = req->msg.type;
 254         msg->len = req->msg.len;
 255
 256         mutex_lock(&xb_write_mutex);
 257         if (req->state == xb_req_state_queued ||
 258             req->state == xb_req_state_wait_reply)
 259                 req->state = xb_req_state_aborted;
 260         else
 261                 kfree(req);
 262         mutex_unlock(&xb_write_mutex);
 263
 264         return ret;
 265 }
 266
 267 static void xs_wake_up(struct xb_req_data *req)
 268 {
 269         wake_up(&req->wq);
 270 }
 271
 272 int xenbus_dev_request_and_reply(struct xsd_sockmsg *msg, void *par)
 273 {
 274         struct xb_req_data *req;
 275         struct kvec *vec;
 276
 277         req = kmalloc(sizeof(*req) + sizeof(*vec), GFP_KERNEL);
 278         if (!req)
 279                 return -ENOMEM;
 280
 281         vec = (struct kvec *)(req + 1);
 282         vec->iov_len = msg->len;
 283         vec->iov_base = msg + 1;
 284
 285         req->vec = vec;
 286         req->num_vecs = 1;
 287         req->cb = xenbus_dev_queue_reply;
 288         req->par = par;
 289
 290         xs_send(req, msg);
 291
 292         return 0;
 293 }
 294 EXPORT_SYMBOL(xenbus_dev_request_and_reply);
 295
 296 /* Send message to xs, get kmalloc'ed reply.  ERR_PTR() on error. */
 297 static void *xs_talkv(struct xenbus_transaction t,
 298                       enum xsd_sockmsg_type type,
 299                       const struct kvec *iovec,
 300                       unsigned int num_vecs,
 301                       unsigned int *len)
 302 {
 303         struct xb_req_data *req;
 304         struct xsd_sockmsg msg;
 305         void *ret = NULL;
 306         unsigned int i;
 307         int err;
 308
 309         req = kmalloc(sizeof(*req), GFP_NOIO | __GFP_HIGH);
 310         if (!req)
 311                 return ERR_PTR(-ENOMEM);
 312
 313         req->vec = iovec;
 314         req->num_vecs = num_vecs;
 315         req->cb = xs_wake_up;
 316
 317         msg.req_id = 0;
 318         msg.tx_id = t.id;
 319         msg.type = type;
 320         msg.len = 0;
 321         for (i = 0; i < num_vecs; i++)
 322                 msg.len += iovec[i].iov_len;
 323
 324         xs_send(req, &msg);
 325
 326         ret = xs_wait_for_reply(req, &msg);
 327         if (len)
 328                 *len = msg.len;
 329
 330         if (IS_ERR(ret))
 331                 return ret;
 332
 333         if (msg.type == XS_ERROR) {
 334                 err = get_error(ret);
 335                 kfree(ret);
 336                 return ERR_PTR(-err);
 337         }
 338
 339         if (msg.type != type) {
 340                 pr_warn_ratelimited("unexpected type [%d], expected [%d]\n",
 341                                     msg.type, type);
 342                 kfree(ret);
 343                 return ERR_PTR(-EINVAL);
 344         }
 345         return ret;
 346 }
 347
 348 /* Simplified version of xs_talkv: single message. */
 349 static void *xs_single(struct xenbus_transaction t,
 350                        enum xsd_sockmsg_type type,
 351                        const char *string,
 352                        unsigned int *len)
 353 {
 354         struct kvec iovec;
 355
 356         iovec.iov_base = (void *)string;
 357         iovec.iov_len = strlen(string) + 1;
 358         return xs_talkv(t, type, &iovec, 1, len);
 359 }
 360
 361 /* Many commands only need an ack, don't care what it says. */
 362 static int xs_error(char *reply)
 363 {
 364         if (IS_ERR(reply))
 365                 return PTR_ERR(reply);
 366         kfree(reply);
 367         return 0;
 368 }
 369
 370 static unsigned int count_strings(const char *strings, unsigned int len)
 371 {
 372         unsigned int num;
 373         const char *p;
 374
 375         for (p = strings, num = 0; p < strings + len; p += strlen(p) + 1)
 376                 num++;
 377
 378         return num;
 379 }
 380
 381 /* Return the path to dir with /name appended. Buffer must be kfree()'ed. */
 382 static char *join(const char *dir, const char *name)
 383 {
 384         char *buffer;
 385
 386         if (strlen(name) == 0)
 387                 buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s", dir);
 388         else
 389                 buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/%s", dir, name);
 390         return (!buffer) ? ERR_PTR(-ENOMEM) : buffer;
 391 }
 392
 393 static char **split(char *strings, unsigned int len, unsigned int *num)
 394 {
 395         char *p, **ret;
 396
 397         /* Count the strings. */
 398         *num = count_strings(strings, len);
 399
 400         /* Transfer to one big alloc for easy freeing. */
 401         ret = kmalloc(*num * sizeof(char *) + len, GFP_NOIO | __GFP_HIGH);
 402         if (!ret) {
 403                 kfree(strings);
 404                 return ERR_PTR(-ENOMEM);
 405         }
 406         memcpy(&ret[*num], strings, len);
 407         kfree(strings);
 408
 409         strings = (char *)&ret[*num];
 410         for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
 411                 ret[(*num)++] = p;
 412
 413         return ret;
 414 }
 415
 416 char **xenbus_directory(struct xenbus_transaction t,
 417                         const char *dir, const char *node, unsigned int *num)
 418 {
 419         char *strings, *path;
 420         unsigned int len;
 421
 422         path = join(dir, node);
 423         if (IS_ERR(path))
 424                 return (char **)path;
 425
 426         strings = xs_single(t, XS_DIRECTORY, path, &len);
 427         kfree(path);
 428         if (IS_ERR(strings))
 429                 return (char **)strings;
 430
 431         return split(strings, len, num);
 432 }
 433 EXPORT_SYMBOL_GPL(xenbus_directory);
 434
 435 /* Check if a path exists. Return 1 if it does. */
 436 int xenbus_exists(struct xenbus_transaction t,
 437                   const char *dir, const char *node)
 438 {
 439         char **d;
 440         int dir_n;
 441
 442         d = xenbus_directory(t, dir, node, &dir_n);
 443         if (IS_ERR(d))
 444                 return 0;
 445         kfree(d);
 446         return 1;
 447 }
 448 EXPORT_SYMBOL_GPL(xenbus_exists);
 449
 450 /* Get the value of a single file.
 451  * Returns a kmalloced value: call free() on it after use.
 452  * len indicates length in bytes.
 453  */
 454 void *xenbus_read(struct xenbus_transaction t,
 455                   const char *dir, const char *node, unsigned int *len)
 456 {
 457         char *path;
 458         void *ret;
 459
 460         path = join(dir, node);
 461         if (IS_ERR(path))
 462                 return (void *)path;
 463
 464         ret = xs_single(t, XS_READ, path, len);
 465         kfree(path);
 466         return ret;
 467 }
 468 EXPORT_SYMBOL_GPL(xenbus_read);
 469
 470 /* Write the value of a single file.
 471  * Returns -err on failure.
 472  */
 473 int xenbus_write(struct xenbus_transaction t,
 474                  const char *dir, const char *node, const char *string)
 475 {
 476         const char *path;
 477         struct kvec iovec[2];
 478         int ret;
 479
 480         path = join(dir, node);
 481         if (IS_ERR(path))
 482                 return PTR_ERR(path);
 483
 484         iovec[0].iov_base = (void *)path;
 485         iovec[0].iov_len = strlen(path) + 1;
 486         iovec[1].iov_base = (void *)string;
 487         iovec[1].iov_len = strlen(string);
 488
 489         ret = xs_error(xs_talkv(t, XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL));
 490         kfree(path);
 491         return ret;
 492 }
 493 EXPORT_SYMBOL_GPL(xenbus_write);
 494
 495 /* Create a new directory. */
 496 int xenbus_mkdir(struct xenbus_transaction t,
 497                  const char *dir, const char *node)
 498 {
 499         char *path;
 500         int ret;
 501
 502         path = join(dir, node);
 503         if (IS_ERR(path))
 504                 return PTR_ERR(path);
 505
 506         ret = xs_error(xs_single(t, XS_MKDIR, path, NULL));
 507         kfree(path);
 508         return ret;
 509 }
 510 EXPORT_SYMBOL_GPL(xenbus_mkdir);
 511
 512 /* Destroy a file or directory (directories must be empty). */
 513 int xenbus_rm(struct xenbus_transaction t, const char *dir, const char *node)
 514 {
 515         char *path;
 516         int ret;
 517
 518         path = join(dir, node);
 519         if (IS_ERR(path))
 520                 return PTR_ERR(path);
 521
 522         ret = xs_error(xs_single(t, XS_RM, path, NULL));
 523         kfree(path);
 524         return ret;
 525 }
 526 EXPORT_SYMBOL_GPL(xenbus_rm);
 527
 528 /* Start a transaction: changes by others will not be seen during this
 529  * transaction, and changes will not be visible to others until end.
 530  */
 531 int xenbus_transaction_start(struct xenbus_transaction *t)
 532 {
 533         char *id_str;
 534
 535         id_str = xs_single(XBT_NIL, XS_TRANSACTION_START, "", NULL);
 536         if (IS_ERR(id_str))
 537                 return PTR_ERR(id_str);
 538
 539         t->id = simple_strtoul(id_str, NULL, 0);
 540         kfree(id_str);
 541         return 0;
 542 }
 543 EXPORT_SYMBOL_GPL(xenbus_transaction_start);
 544
 545 /* End a transaction.
 546  * If abandon is true, transaction is discarded instead of committed.
 547  */
 548 int xenbus_transaction_end(struct xenbus_transaction t, int abort)
 549 {
 550         char abortstr[2];
 551
 552         if (abort)
 553                 strcpy(abortstr, "F");
 554         else
 555                 strcpy(abortstr, "T");
 556
 557         return xs_error(xs_single(t, XS_TRANSACTION_END, abortstr, NULL));
 558 }
 559 EXPORT_SYMBOL_GPL(xenbus_transaction_end);
 560
 561 /* Single read and scanf: returns -errno or num scanned. */
 562 int xenbus_scanf(struct xenbus_transaction t,
 563                  const char *dir, const char *node, const char *fmt, ...)
 564 {
 565         va_list ap;
 566         int ret;
 567         char *val;
 568
 569         val = xenbus_read(t, dir, node, NULL);
 570         if (IS_ERR(val))
 571                 return PTR_ERR(val);
 572
 573         va_start(ap, fmt);
 574         ret = vsscanf(val, fmt, ap);
 575         va_end(ap);
 576         kfree(val);
 577         /* Distinctive errno. */
 578         if (ret == 0)
 579                 return -ERANGE;
 580         return ret;
 581 }
 582 EXPORT_SYMBOL_GPL(xenbus_scanf);
 583
 584 /* Read an (optional) unsigned value. */
 585 unsigned int xenbus_read_unsigned(const char *dir, const char *node,
 586                                   unsigned int default_val)
 587 {
 588         unsigned int val;
 589         int ret;
 590
 591         ret = xenbus_scanf(XBT_NIL, dir, node, "%u", &val);
 592         if (ret <= 0)
 593                 val = default_val;
 594
 595         return val;
 596 }
 597 EXPORT_SYMBOL_GPL(xenbus_read_unsigned);
 598
 599 /* Single printf and write: returns -errno or 0. */
 600 int xenbus_printf(struct xenbus_transaction t,
 601                   const char *dir, const char *node, const char *fmt, ...)
 602 {
 603         va_list ap;
 604         int ret;
 605         char *buf;
 606
 607         va_start(ap, fmt);
 608         buf = kvasprintf(GFP_NOIO | __GFP_HIGH, fmt, ap);
 609         va_end(ap);
 610
 611         if (!buf)
 612                 return -ENOMEM;
 613
 614         ret = xenbus_write(t, dir, node, buf);
 615
 616         kfree(buf);
 617
 618         return ret;
 619 }
 620 EXPORT_SYMBOL_GPL(xenbus_printf);
 621
 622 /* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
 623 int xenbus_gather(struct xenbus_transaction t, const char *dir, ...)
 624 {
 625         va_list ap;
 626         const char *name;
 627         int ret = 0;
 628
 629         va_start(ap, dir);
 630         while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
 631                 const char *fmt = va_arg(ap, char *);
 632                 void *result = va_arg(ap, void *);
 633                 char *p;
 634
 635                 p = xenbus_read(t, dir, name, NULL);
 636                 if (IS_ERR(p)) {
 637                         ret = PTR_ERR(p);
 638                         break;
 639                 }
 640                 if (fmt) {
 641                         if (sscanf(p, fmt, result) == 0)
 642                                 ret = -EINVAL;
 643                         kfree(p);
 644                 } else
 645                         *(char **)result = p;
 646         }
 647         va_end(ap);
 648         return ret;
 649 }
 650 EXPORT_SYMBOL_GPL(xenbus_gather);
 651
 652 static int xs_watch(const char *path, const char *token)
 653 {
 654         struct kvec iov[2];
 655
 656         iov[0].iov_base = (void *)path;
 657         iov[0].iov_len = strlen(path) + 1;
 658         iov[1].iov_base = (void *)token;
 659         iov[1].iov_len = strlen(token) + 1;
 660
 661         return xs_error(xs_talkv(XBT_NIL, XS_WATCH, iov,
 662                                  ARRAY_SIZE(iov), NULL));
 663 }
 664
 665 static int xs_unwatch(const char *path, const char *token)
 666 {
 667         struct kvec iov[2];
 668
 669         iov[0].iov_base = (char *)path;
 670         iov[0].iov_len = strlen(path) + 1;
 671         iov[1].iov_base = (char *)token;
 672         iov[1].iov_len = strlen(token) + 1;
 673
 674         return xs_error(xs_talkv(XBT_NIL, XS_UNWATCH, iov,
 675                                  ARRAY_SIZE(iov), NULL));
 676 }
 677
 678 static struct xenbus_watch *find_watch(const char *token)
 679 {
 680         struct xenbus_watch *i, *cmp;
 681
 682         cmp = (void *)simple_strtoul(token, NULL, 16);
 683
 684         list_for_each_entry(i, &watches, list)
 685                 if (i == cmp)
 686                         return i;
 687
 688         return NULL;
 689 }
 690
 691 int xs_watch_msg(struct xs_watch_event *event)
 692 {
 693         if (count_strings(event->body, event->len) != 2) {
 694                 kfree(event);
 695                 return -EINVAL;
 696         }
 697         event->path = (const char *)event->body;
 698         event->token = (const char *)strchr(event->body, '\0') + 1;
 699
 700         spin_lock(&watches_lock);
 701         event->handle = find_watch(event->token);
 702         if (event->handle != NULL) {
 703                 spin_lock(&watch_events_lock);
 704                 list_add_tail(&event->list, &watch_events);
 705                 wake_up(&watch_events_waitq);
 706                 spin_unlock(&watch_events_lock);
 707         } else
 708                 kfree(event);
 709         spin_unlock(&watches_lock);
 710
 711         return 0;
 712 }
 713
 714 /*
 715  * Certain older XenBus toolstack cannot handle reading values that are
 716  * not populated. Some Xen 3.4 installation are incapable of doing this
 717  * so if we are running on anything older than 4 do not attempt to read
 718  * control/platform-feature-xs_reset_watches.
 719  */
 720 static bool xen_strict_xenbus_quirk(void)
 721 {
 722 #ifdef CONFIG_X86
 723         uint32_t eax, ebx, ecx, edx, base;
 724
 725         base = xen_cpuid_base();
 726         cpuid(base + 1, &eax, &ebx, &ecx, &edx);
 727
 728         if ((eax >> 16) < 4)
 729                 return true;
 730 #endif
 731         return false;
 732
 733 }
 734 static void xs_reset_watches(void)
 735 {
 736         int err;
 737
 738         if (!xen_hvm_domain() || xen_initial_domain())
 739                 return;
 740
 741         if (xen_strict_xenbus_quirk())
 742                 return;
 743
 744         if (!xenbus_read_unsigned("control",
 745                                   "platform-feature-xs_reset_watches", 0))
 746                 return;
 747
 748         err = xs_error(xs_single(XBT_NIL, XS_RESET_WATCHES, "", NULL));
 749         if (err && err != -EEXIST)
 750                 pr_warn("xs_reset_watches failed: %d\n", err);
 751 }
 752
 753 /* Register callback to watch this node. */
 754 int register_xenbus_watch(struct xenbus_watch *watch)
 755 {
 756         /* Pointer in ascii is the token. */
 757         char token[sizeof(watch) * 2 + 1];
 758         int err;
 759
 760         sprintf(token, "%lX", (long)watch);
 761
 762         down_read(&xs_watch_rwsem);
 763
 764         spin_lock(&watches_lock);
 765         BUG_ON(find_watch(token));
 766         list_add(&watch->list, &watches);
 767         spin_unlock(&watches_lock);
 768
 769         err = xs_watch(watch->node, token);
 770
 771         if (err) {
 772                 spin_lock(&watches_lock);
 773                 list_del(&watch->list);
 774                 spin_unlock(&watches_lock);
 775         }
 776
 777         up_read(&xs_watch_rwsem);
 778
 779         return err;
 780 }
 781 EXPORT_SYMBOL_GPL(register_xenbus_watch);
 782
 783 void unregister_xenbus_watch(struct xenbus_watch *watch)
 784 {
 785         struct xs_watch_event *event, *tmp;
 786         char token[sizeof(watch) * 2 + 1];
 787         int err;
 788
 789         sprintf(token, "%lX", (long)watch);
 790
 791         down_read(&xs_watch_rwsem);
 792
 793         spin_lock(&watches_lock);
 794         BUG_ON(!find_watch(token));
 795         list_del(&watch->list);
 796         spin_unlock(&watches_lock);
 797
 798         err = xs_unwatch(watch->node, token);
 799         if (err)
 800                 pr_warn("Failed to release watch %s: %i\n", watch->node, err);
 801
 802         up_read(&xs_watch_rwsem);
 803
 804         /* Make sure there are no callbacks running currently (unless
 805            its us) */
 806         if (current->pid != xenwatch_pid)
 807                 mutex_lock(&xenwatch_mutex);
 808
 809         /* Cancel pending watch events. */
 810         spin_lock(&watch_events_lock);
 811         list_for_each_entry_safe(event, tmp, &watch_events, list) {
 812                 if (event->handle != watch)
 813                         continue;
 814                 list_del(&event->list);
 815                 kfree(event);
 816         }
 817         spin_unlock(&watch_events_lock);
 818
 819         if (current->pid != xenwatch_pid)
 820                 mutex_unlock(&xenwatch_mutex);
 821 }
 822 EXPORT_SYMBOL_GPL(unregister_xenbus_watch);
 823
 824 void xs_suspend(void)
 825 {
 826         xs_suspend_enter();
 827
 828         down_write(&xs_watch_rwsem);
 829         mutex_lock(&xs_response_mutex);
 830 }
 831
 832 void xs_resume(void)
 833 {
 834         struct xenbus_watch *watch;
 835         char token[sizeof(watch) * 2 + 1];
 836
 837         xb_init_comms();
 838
 839         mutex_unlock(&xs_response_mutex);
 840
 841         xs_suspend_exit();
 842
 843         /* No need for watches_lock: the xs_watch_rwsem is sufficient. */
 844         list_for_each_entry(watch, &watches, list) {
 845                 sprintf(token, "%lX", (long)watch);
 846                 xs_watch(watch->node, token);
 847         }
 848
 849         up_write(&xs_watch_rwsem);
 850 }
 851
 852 void xs_suspend_cancel(void)
 853 {
 854         mutex_unlock(&xs_response_mutex);
 855         up_write(&xs_watch_rwsem);
 856
 857         xs_suspend_exit();
 858 }
 859
 860 static int xenwatch_thread(void *unused)
 861 {
 862         struct list_head *ent;
 863         struct xs_watch_event *event;
 864
 865         xenwatch_pid = current->pid;
 866
 867         for (;;) {
 868                 wait_event_interruptible(watch_events_waitq,
 869                                          !list_empty(&watch_events));
 870
 871                 if (kthread_should_stop())
 872                         break;
 873
 874                 mutex_lock(&xenwatch_mutex);
 875
 876                 spin_lock(&watch_events_lock);
 877                 ent = watch_events.next;
 878                 if (ent != &watch_events)
 879                         list_del(ent);
 880                 spin_unlock(&watch_events_lock);
 881
 882                 if (ent != &watch_events) {
 883                         event = list_entry(ent, struct xs_watch_event, list);
 884                         event->handle->callback(event->handle, event->path,
 885                                                 event->token);
 886                         kfree(event);
 887                 }
 888
 889                 mutex_unlock(&xenwatch_mutex);
 890         }
 891
 892         return 0;
 893 }
 894
 895 /*
 896  * Wake up all threads waiting for a xenstore reply. In case of shutdown all
 897  * pending replies will be marked as "aborted" in order to let the waiters
 898  * return in spite of xenstore possibly no longer being able to reply. This
 899  * will avoid blocking shutdown by a thread waiting for xenstore but being
 900  * necessary for shutdown processing to proceed.
 901  */
 902 static int xs_reboot_notify(struct notifier_block *nb,
 903                             unsigned long code, void *unused)
 904 {
 905         struct xb_req_data *req;
 906
 907         mutex_lock(&xb_write_mutex);
 908         list_for_each_entry(req, &xs_reply_list, list)
 909                 wake_up(&req->wq);
 910         list_for_each_entry(req, &xb_write_list, list)
 911                 wake_up(&req->wq);
 912         mutex_unlock(&xb_write_mutex);
 913         return NOTIFY_DONE;
 914 }
 915
 916 static struct notifier_block xs_reboot_nb = {
 917         .notifier_call = xs_reboot_notify,
 918 };
 919
 920 int xs_init(void)
 921 {
 922         int err;
 923         struct task_struct *task;
 924
 925         register_reboot_notifier(&xs_reboot_nb);
 926
 927         /* Initialize the shared memory rings to talk to xenstored */
 928         err = xb_init_comms();
 929         if (err)
 930                 return err;
 931
 932         task = kthread_run(xenwatch_thread, NULL, "xenwatch");
 933         if (IS_ERR(task))
 934                 return PTR_ERR(task);
 935
 936         /* shutdown watches for kexec boot */
 937         xs_reset_watches();
 938
 939         return 0;
 940 }