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                 xs_state_users--;
 145         spin_unlock(&xs_state_lock);
 146
 147         if (xs_suspend_active && !xs_state_users)
 148                 wake_up(&xs_state_exit_wq);
 149 }
 150
 151 static int get_error(const char *errorstring)
 152 {
 153         unsigned int i;
 154
 155         for (i = 0; strcmp(errorstring, xsd_errors[i].errstring) != 0; i++) {
 156                 if (i == ARRAY_SIZE(xsd_errors) - 1) {
 157                         pr_warn("xen store gave: unknown error %s\n",
 158                                 errorstring);
 159                         return EINVAL;
 160                 }
 161         }
 162         return xsd_errors[i].errnum;
 163 }
 164
 165 static bool xenbus_ok(void)
 166 {
 167         switch (xen_store_domain_type) {
 168         case XS_LOCAL:
 169                 switch (system_state) {
 170                 case SYSTEM_POWER_OFF:
 171                 case SYSTEM_RESTART:
 172                 case SYSTEM_HALT:
 173                         return false;
 174                 default:
 175                         break;
 176                 }
 177                 return true;
 178         case XS_PV:
 179         case XS_HVM:
 180                 /* FIXME: Could check that the remote domain is alive,
 181                  * but it is normally initial domain. */
 182                 return true;
 183         default:
 184                 break;
 185         }
 186         return false;
 187 }
 188
 189 static bool test_reply(struct xb_req_data *req)
 190 {
 191         if (req->state == xb_req_state_got_reply || !xenbus_ok()) {
 192                 /* read req->state before all other fields */
 193                 virt_rmb();
 194                 return true;
 195         }
 196
 197         /* Make sure to reread req->state each time. */
 198         barrier();
 199
 200         return false;
 201 }
 202
 203 static void *read_reply(struct xb_req_data *req)
 204 {
 205         do {
 206                 wait_event(req->wq, test_reply(req));
 207
 208                 if (!xenbus_ok())
 209                         /*
 210                          * If we are in the process of being shut-down there is
 211                          * no point of trying to contact XenBus - it is either
 212                          * killed (xenstored application) or the other domain
 213                          * has been killed or is unreachable.
 214                          */
 215                         return ERR_PTR(-EIO);
 216                 if (req->err)
 217                         return ERR_PTR(req->err);
 218
 219         } while (req->state != xb_req_state_got_reply);
 220
 221         return req->body;
 222 }
 223
 224 static void xs_send(struct xb_req_data *req, struct xsd_sockmsg *msg)
 225 {
 226         bool notify;
 227
 228         req->msg = *msg;
 229         req->err = 0;
 230         req->state = xb_req_state_queued;
 231         init_waitqueue_head(&req->wq);
 232
 233         /* Save the caller req_id and restore it later in the reply */
 234         req->caller_req_id = req->msg.req_id;
 235         req->msg.req_id = xs_request_enter(req);
 236
 237         mutex_lock(&xb_write_mutex);
 238         list_add_tail(&req->list, &xb_write_list);
 239         notify = list_is_singular(&xb_write_list);
 240         mutex_unlock(&xb_write_mutex);
 241
 242         if (notify)
 243                 wake_up(&xb_waitq);
 244 }
 245
 246 static void *xs_wait_for_reply(struct xb_req_data *req, struct xsd_sockmsg *msg)
 247 {
 248         void *ret;
 249
 250         ret = read_reply(req);
 251
 252         xs_request_exit(req);
 253
 254         msg->type = req->msg.type;
 255         msg->len = req->msg.len;
 256
 257         mutex_lock(&xb_write_mutex);
 258         if (req->state == xb_req_state_queued ||
 259             req->state == xb_req_state_wait_reply)
 260                 req->state = xb_req_state_aborted;
 261         else
 262                 kfree(req);
 263         mutex_unlock(&xb_write_mutex);
 264
 265         return ret;
 266 }
 267
 268 static void xs_wake_up(struct xb_req_data *req)
 269 {
 270         wake_up(&req->wq);
 271 }
 272
 273 int xenbus_dev_request_and_reply(struct xsd_sockmsg *msg, void *par)
 274 {
 275         struct xb_req_data *req;
 276         struct kvec *vec;
 277
 278         req = kmalloc(sizeof(*req) + sizeof(*vec), GFP_KERNEL);
 279         if (!req)
 280                 return -ENOMEM;
 281
 282         vec = (struct kvec *)(req + 1);
 283         vec->iov_len = msg->len;
 284         vec->iov_base = msg + 1;
 285
 286         req->vec = vec;
 287         req->num_vecs = 1;
 288         req->cb = xenbus_dev_queue_reply;
 289         req->par = par;
 290
 291         xs_send(req, msg);
 292
 293         return 0;
 294 }
 295 EXPORT_SYMBOL(xenbus_dev_request_and_reply);
 296
 297 /* Send message to xs, get kmalloc'ed reply.  ERR_PTR() on error. */
 298 static void *xs_talkv(struct xenbus_transaction t,
 299                       enum xsd_sockmsg_type type,
 300                       const struct kvec *iovec,
 301                       unsigned int num_vecs,
 302                       unsigned int *len)
 303 {
 304         struct xb_req_data *req;
 305         struct xsd_sockmsg msg;
 306         void *ret = NULL;
 307         unsigned int i;
 308         int err;
 309
 310         req = kmalloc(sizeof(*req), GFP_NOIO | __GFP_HIGH);
 311         if (!req)
 312                 return ERR_PTR(-ENOMEM);
 313
 314         req->vec = iovec;
 315         req->num_vecs = num_vecs;
 316         req->cb = xs_wake_up;
 317
 318         msg.req_id = 0;
 319         msg.tx_id = t.id;
 320         msg.type = type;
 321         msg.len = 0;
 322         for (i = 0; i < num_vecs; i++)
 323                 msg.len += iovec[i].iov_len;
 324
 325         xs_send(req, &msg);
 326
 327         ret = xs_wait_for_reply(req, &msg);
 328         if (len)
 329                 *len = msg.len;
 330
 331         if (IS_ERR(ret))
 332                 return ret;
 333
 334         if (msg.type == XS_ERROR) {
 335                 err = get_error(ret);
 336                 kfree(ret);
 337                 return ERR_PTR(-err);
 338         }
 339
 340         if (msg.type != type) {
 341                 pr_warn_ratelimited("unexpected type [%d], expected [%d]\n",
 342                                     msg.type, type);
 343                 kfree(ret);
 344                 return ERR_PTR(-EINVAL);
 345         }
 346         return ret;
 347 }
 348
 349 /* Simplified version of xs_talkv: single message. */
 350 static void *xs_single(struct xenbus_transaction t,
 351                        enum xsd_sockmsg_type type,
 352                        const char *string,
 353                        unsigned int *len)
 354 {
 355         struct kvec iovec;
 356
 357         iovec.iov_base = (void *)string;
 358         iovec.iov_len = strlen(string) + 1;
 359         return xs_talkv(t, type, &iovec, 1, len);
 360 }
 361
 362 /* Many commands only need an ack, don't care what it says. */
 363 static int xs_error(char *reply)
 364 {
 365         if (IS_ERR(reply))
 366                 return PTR_ERR(reply);
 367         kfree(reply);
 368         return 0;
 369 }
 370
 371 static unsigned int count_strings(const char *strings, unsigned int len)
 372 {
 373         unsigned int num;
 374         const char *p;
 375
 376         for (p = strings, num = 0; p < strings + len; p += strlen(p) + 1)
 377                 num++;
 378
 379         return num;
 380 }
 381
 382 /* Return the path to dir with /name appended. Buffer must be kfree()'ed. */
 383 static char *join(const char *dir, const char *name)
 384 {
 385         char *buffer;
 386
 387         if (strlen(name) == 0)
 388                 buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s", dir);
 389         else
 390                 buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/%s", dir, name);
 391         return (!buffer) ? ERR_PTR(-ENOMEM) : buffer;
 392 }
 393
 394 static char **split(char *strings, unsigned int len, unsigned int *num)
 395 {
 396         char *p, **ret;
 397
 398         /* Count the strings. */
 399         *num = count_strings(strings, len);
 400
 401         /* Transfer to one big alloc for easy freeing. */
 402         ret = kmalloc(*num * sizeof(char *) + len, GFP_NOIO | __GFP_HIGH);
 403         if (!ret) {
 404                 kfree(strings);
 405                 return ERR_PTR(-ENOMEM);
 406         }
 407         memcpy(&ret[*num], strings, len);
 408         kfree(strings);
 409
 410         strings = (char *)&ret[*num];
 411         for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
 412                 ret[(*num)++] = p;
 413
 414         return ret;
 415 }
 416
 417 char **xenbus_directory(struct xenbus_transaction t,
 418                         const char *dir, const char *node, unsigned int *num)
 419 {
 420         char *strings, *path;
 421         unsigned int len;
 422
 423         path = join(dir, node);
 424         if (IS_ERR(path))
 425                 return (char **)path;
 426
 427         strings = xs_single(t, XS_DIRECTORY, path, &len);
 428         kfree(path);
 429         if (IS_ERR(strings))
 430                 return (char **)strings;
 431
 432         return split(strings, len, num);
 433 }
 434 EXPORT_SYMBOL_GPL(xenbus_directory);
 435
 436 /* Check if a path exists. Return 1 if it does. */
 437 int xenbus_exists(struct xenbus_transaction t,
 438                   const char *dir, const char *node)
 439 {
 440         char **d;
 441         int dir_n;
 442
 443         d = xenbus_directory(t, dir, node, &dir_n);
 444         if (IS_ERR(d))
 445                 return 0;
 446         kfree(d);
 447         return 1;
 448 }
 449 EXPORT_SYMBOL_GPL(xenbus_exists);
 450
 451 /* Get the value of a single file.
 452  * Returns a kmalloced value: call free() on it after use.
 453  * len indicates length in bytes.
 454  */
 455 void *xenbus_read(struct xenbus_transaction t,
 456                   const char *dir, const char *node, unsigned int *len)
 457 {
 458         char *path;
 459         void *ret;
 460
 461         path = join(dir, node);
 462         if (IS_ERR(path))
 463                 return (void *)path;
 464
 465         ret = xs_single(t, XS_READ, path, len);
 466         kfree(path);
 467         return ret;
 468 }
 469 EXPORT_SYMBOL_GPL(xenbus_read);
 470
 471 /* Write the value of a single file.
 472  * Returns -err on failure.
 473  */
 474 int xenbus_write(struct xenbus_transaction t,
 475                  const char *dir, const char *node, const char *string)
 476 {
 477         const char *path;
 478         struct kvec iovec[2];
 479         int ret;
 480
 481         path = join(dir, node);
 482         if (IS_ERR(path))
 483                 return PTR_ERR(path);
 484
 485         iovec[0].iov_base = (void *)path;
 486         iovec[0].iov_len = strlen(path) + 1;
 487         iovec[1].iov_base = (void *)string;
 488         iovec[1].iov_len = strlen(string);
 489
 490         ret = xs_error(xs_talkv(t, XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL));
 491         kfree(path);
 492         return ret;
 493 }
 494 EXPORT_SYMBOL_GPL(xenbus_write);
 495
 496 /* Create a new directory. */
 497 int xenbus_mkdir(struct xenbus_transaction t,
 498                  const char *dir, const char *node)
 499 {
 500         char *path;
 501         int ret;
 502
 503         path = join(dir, node);
 504         if (IS_ERR(path))
 505                 return PTR_ERR(path);
 506
 507         ret = xs_error(xs_single(t, XS_MKDIR, path, NULL));
 508         kfree(path);
 509         return ret;
 510 }
 511 EXPORT_SYMBOL_GPL(xenbus_mkdir);
 512
 513 /* Destroy a file or directory (directories must be empty). */
 514 int xenbus_rm(struct xenbus_transaction t, const char *dir, const char *node)
 515 {
 516         char *path;
 517         int ret;
 518
 519         path = join(dir, node);
 520         if (IS_ERR(path))
 521                 return PTR_ERR(path);
 522
 523         ret = xs_error(xs_single(t, XS_RM, path, NULL));
 524         kfree(path);
 525         return ret;
 526 }
 527 EXPORT_SYMBOL_GPL(xenbus_rm);
 528
 529 /* Start a transaction: changes by others will not be seen during this
 530  * transaction, and changes will not be visible to others until end.
 531  */
 532 int xenbus_transaction_start(struct xenbus_transaction *t)
 533 {
 534         char *id_str;
 535
 536         id_str = xs_single(XBT_NIL, XS_TRANSACTION_START, "", NULL);
 537         if (IS_ERR(id_str))
 538                 return PTR_ERR(id_str);
 539
 540         t->id = simple_strtoul(id_str, NULL, 0);
 541         kfree(id_str);
 542         return 0;
 543 }
 544 EXPORT_SYMBOL_GPL(xenbus_transaction_start);
 545
 546 /* End a transaction.
 547  * If abandon is true, transaction is discarded instead of committed.
 548  */
 549 int xenbus_transaction_end(struct xenbus_transaction t, int abort)
 550 {
 551         char abortstr[2];
 552
 553         if (abort)
 554                 strcpy(abortstr, "F");
 555         else
 556                 strcpy(abortstr, "T");
 557
 558         return xs_error(xs_single(t, XS_TRANSACTION_END, abortstr, NULL));
 559 }
 560 EXPORT_SYMBOL_GPL(xenbus_transaction_end);
 561
 562 /* Single read and scanf: returns -errno or num scanned. */
 563 int xenbus_scanf(struct xenbus_transaction t,
 564                  const char *dir, const char *node, const char *fmt, ...)
 565 {
 566         va_list ap;
 567         int ret;
 568         char *val;
 569
 570         val = xenbus_read(t, dir, node, NULL);
 571         if (IS_ERR(val))
 572                 return PTR_ERR(val);
 573
 574         va_start(ap, fmt);
 575         ret = vsscanf(val, fmt, ap);
 576         va_end(ap);
 577         kfree(val);
 578         /* Distinctive errno. */
 579         if (ret == 0)
 580                 return -ERANGE;
 581         return ret;
 582 }
 583 EXPORT_SYMBOL_GPL(xenbus_scanf);
 584
 585 /* Read an (optional) unsigned value. */
 586 unsigned int xenbus_read_unsigned(const char *dir, const char *node,
 587                                   unsigned int default_val)
 588 {
 589         unsigned int val;
 590         int ret;
 591
 592         ret = xenbus_scanf(XBT_NIL, dir, node, "%u", &val);
 593         if (ret <= 0)
 594                 val = default_val;
 595
 596         return val;
 597 }
 598 EXPORT_SYMBOL_GPL(xenbus_read_unsigned);
 599
 600 /* Single printf and write: returns -errno or 0. */
 601 int xenbus_printf(struct xenbus_transaction t,
 602                   const char *dir, const char *node, const char *fmt, ...)
 603 {
 604         va_list ap;
 605         int ret;
 606         char *buf;
 607
 608         va_start(ap, fmt);
 609         buf = kvasprintf(GFP_NOIO | __GFP_HIGH, fmt, ap);
 610         va_end(ap);
 611
 612         if (!buf)
 613                 return -ENOMEM;
 614
 615         ret = xenbus_write(t, dir, node, buf);
 616
 617         kfree(buf);
 618
 619         return ret;
 620 }
 621 EXPORT_SYMBOL_GPL(xenbus_printf);
 622
 623 /* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
 624 int xenbus_gather(struct xenbus_transaction t, const char *dir, ...)
 625 {
 626         va_list ap;
 627         const char *name;
 628         int ret = 0;
 629
 630         va_start(ap, dir);
 631         while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
 632                 const char *fmt = va_arg(ap, char *);
 633                 void *result = va_arg(ap, void *);
 634                 char *p;
 635
 636                 p = xenbus_read(t, dir, name, NULL);
 637                 if (IS_ERR(p)) {
 638                         ret = PTR_ERR(p);
 639                         break;
 640                 }
 641                 if (fmt) {
 642                         if (sscanf(p, fmt, result) == 0)
 643                                 ret = -EINVAL;
 644                         kfree(p);
 645                 } else
 646                         *(char **)result = p;
 647         }
 648         va_end(ap);
 649         return ret;
 650 }
 651 EXPORT_SYMBOL_GPL(xenbus_gather);
 652
 653 static int xs_watch(const char *path, const char *token)
 654 {
 655         struct kvec iov[2];
 656
 657         iov[0].iov_base = (void *)path;
 658         iov[0].iov_len = strlen(path) + 1;
 659         iov[1].iov_base = (void *)token;
 660         iov[1].iov_len = strlen(token) + 1;
 661
 662         return xs_error(xs_talkv(XBT_NIL, XS_WATCH, iov,
 663                                  ARRAY_SIZE(iov), NULL));
 664 }
 665
 666 static int xs_unwatch(const char *path, const char *token)
 667 {
 668         struct kvec iov[2];
 669
 670         iov[0].iov_base = (char *)path;
 671         iov[0].iov_len = strlen(path) + 1;
 672         iov[1].iov_base = (char *)token;
 673         iov[1].iov_len = strlen(token) + 1;
 674
 675         return xs_error(xs_talkv(XBT_NIL, XS_UNWATCH, iov,
 676                                  ARRAY_SIZE(iov), NULL));
 677 }
 678
 679 static struct xenbus_watch *find_watch(const char *token)
 680 {
 681         struct xenbus_watch *i, *cmp;
 682
 683         cmp = (void *)simple_strtoul(token, NULL, 16);
 684
 685         list_for_each_entry(i, &watches, list)
 686                 if (i == cmp)
 687                         return i;
 688
 689         return NULL;
 690 }
 691
 692 int xs_watch_msg(struct xs_watch_event *event)
 693 {
 694         if (count_strings(event->body, event->len) != 2) {
 695                 kfree(event);
 696                 return -EINVAL;
 697         }
 698         event->path = (const char *)event->body;
 699         event->token = (const char *)strchr(event->body, '\0') + 1;
 700
 701         spin_lock(&watches_lock);
 702         event->handle = find_watch(event->token);
 703         if (event->handle != NULL &&
 704                         (!event->handle->will_handle ||
 705                          event->handle->will_handle(event->handle,
 706                                  event->path, event->token))) {
 707                 spin_lock(&watch_events_lock);
 708                 list_add_tail(&event->list, &watch_events);
 709                 event->handle->nr_pending++;
 710                 wake_up(&watch_events_waitq);
 711                 spin_unlock(&watch_events_lock);
 712         } else
 713                 kfree(event);
 714         spin_unlock(&watches_lock);
 715
 716         return 0;
 717 }
 718
 719 /*
 720  * Certain older XenBus toolstack cannot handle reading values that are
 721  * not populated. Some Xen 3.4 installation are incapable of doing this
 722  * so if we are running on anything older than 4 do not attempt to read
 723  * control/platform-feature-xs_reset_watches.
 724  */
 725 static bool xen_strict_xenbus_quirk(void)
 726 {
 727 #ifdef CONFIG_X86
 728         uint32_t eax, ebx, ecx, edx, base;
 729
 730         base = xen_cpuid_base();
 731         cpuid(base + 1, &eax, &ebx, &ecx, &edx);
 732
 733         if ((eax >> 16) < 4)
 734                 return true;
 735 #endif
 736         return false;
 737
 738 }
 739 static void xs_reset_watches(void)
 740 {
 741         int err;
 742
 743         if (!xen_hvm_domain() || xen_initial_domain())
 744                 return;
 745
 746         if (xen_strict_xenbus_quirk())
 747                 return;
 748
 749         if (!xenbus_read_unsigned("control",
 750                                   "platform-feature-xs_reset_watches", 0))
 751                 return;
 752
 753         err = xs_error(xs_single(XBT_NIL, XS_RESET_WATCHES, "", NULL));
 754         if (err && err != -EEXIST)
 755                 pr_warn("xs_reset_watches failed: %d\n", err);
 756 }
 757
 758 /* Register callback to watch this node. */
 759 int register_xenbus_watch(struct xenbus_watch *watch)
 760 {
 761         /* Pointer in ascii is the token. */
 762         char token[sizeof(watch) * 2 + 1];
 763         int err;
 764
 765         sprintf(token, "%lX", (long)watch);
 766
 767         watch->nr_pending = 0;
 768
 769         down_read(&xs_watch_rwsem);
 770
 771         spin_lock(&watches_lock);
 772         BUG_ON(find_watch(token));
 773         list_add(&watch->list, &watches);
 774         spin_unlock(&watches_lock);
 775
 776         err = xs_watch(watch->node, token);
 777
 778         if (err) {
 779                 spin_lock(&watches_lock);
 780                 list_del(&watch->list);
 781                 spin_unlock(&watches_lock);
 782         }
 783
 784         up_read(&xs_watch_rwsem);
 785
 786         return err;
 787 }
 788 EXPORT_SYMBOL_GPL(register_xenbus_watch);
 789
 790 void unregister_xenbus_watch(struct xenbus_watch *watch)
 791 {
 792         struct xs_watch_event *event, *tmp;
 793         char token[sizeof(watch) * 2 + 1];
 794         int err;
 795
 796         sprintf(token, "%lX", (long)watch);
 797
 798         down_read(&xs_watch_rwsem);
 799
 800         spin_lock(&watches_lock);
 801         BUG_ON(!find_watch(token));
 802         list_del(&watch->list);
 803         spin_unlock(&watches_lock);
 804
 805         err = xs_unwatch(watch->node, token);
 806         if (err)
 807                 pr_warn("Failed to release watch %s: %i\n", watch->node, err);
 808
 809         up_read(&xs_watch_rwsem);
 810
 811         /* Make sure there are no callbacks running currently (unless
 812            its us) */
 813         if (current->pid != xenwatch_pid)
 814                 mutex_lock(&xenwatch_mutex);
 815
 816         /* Cancel pending watch events. */
 817         spin_lock(&watch_events_lock);
 818         if (watch->nr_pending) {
 819                 list_for_each_entry_safe(event, tmp, &watch_events, list) {
 820                         if (event->handle != watch)
 821                                 continue;
 822                         list_del(&event->list);
 823                         kfree(event);
 824                 }
 825                 watch->nr_pending = 0;
 826         }
 827         spin_unlock(&watch_events_lock);
 828
 829         if (current->pid != xenwatch_pid)
 830                 mutex_unlock(&xenwatch_mutex);
 831 }
 832 EXPORT_SYMBOL_GPL(unregister_xenbus_watch);
 833
 834 void xs_suspend(void)
 835 {
 836         xs_suspend_enter();
 837
 838         down_write(&xs_watch_rwsem);
 839         mutex_lock(&xs_response_mutex);
 840 }
 841
 842 void xs_resume(void)
 843 {
 844         struct xenbus_watch *watch;
 845         char token[sizeof(watch) * 2 + 1];
 846
 847         xb_init_comms();
 848
 849         mutex_unlock(&xs_response_mutex);
 850
 851         xs_suspend_exit();
 852
 853         /* No need for watches_lock: the xs_watch_rwsem is sufficient. */
 854         list_for_each_entry(watch, &watches, list) {
 855                 sprintf(token, "%lX", (long)watch);
 856                 xs_watch(watch->node, token);
 857         }
 858
 859         up_write(&xs_watch_rwsem);
 860 }
 861
 862 void xs_suspend_cancel(void)
 863 {
 864         mutex_unlock(&xs_response_mutex);
 865         up_write(&xs_watch_rwsem);
 866
 867         xs_suspend_exit();
 868 }
 869
 870 static int xenwatch_thread(void *unused)
 871 {
 872         struct xs_watch_event *event;
 873
 874         xenwatch_pid = current->pid;
 875
 876         for (;;) {
 877                 wait_event_interruptible(watch_events_waitq,
 878                                          !list_empty(&watch_events));
 879
 880                 if (kthread_should_stop())
 881                         break;
 882
 883                 mutex_lock(&xenwatch_mutex);
 884
 885                 spin_lock(&watch_events_lock);
 886                 event = list_first_entry_or_null(&watch_events,
 887                                 struct xs_watch_event, list);
 888                 if (event) {
 889                         list_del(&event->list);
 890                         event->handle->nr_pending--;
 891                 }
 892                 spin_unlock(&watch_events_lock);
 893
 894                 if (event) {
 895                         event->handle->callback(event->handle, event->path,
 896                                                 event->token);
 897                         kfree(event);
 898                 }
 899
 900                 mutex_unlock(&xenwatch_mutex);
 901         }
 902
 903         return 0;
 904 }
 905
 906 /*
 907  * Wake up all threads waiting for a xenstore reply. In case of shutdown all
 908  * pending replies will be marked as "aborted" in order to let the waiters
 909  * return in spite of xenstore possibly no longer being able to reply. This
 910  * will avoid blocking shutdown by a thread waiting for xenstore but being
 911  * necessary for shutdown processing to proceed.
 912  */
 913 static int xs_reboot_notify(struct notifier_block *nb,
 914                             unsigned long code, void *unused)
 915 {
 916         struct xb_req_data *req;
 917
 918         mutex_lock(&xb_write_mutex);
 919         list_for_each_entry(req, &xs_reply_list, list)
 920                 wake_up(&req->wq);
 921         list_for_each_entry(req, &xb_write_list, list)
 922                 wake_up(&req->wq);
 923         mutex_unlock(&xb_write_mutex);
 924         return NOTIFY_DONE;
 925 }
 926
 927 static struct notifier_block xs_reboot_nb = {
 928         .notifier_call = xs_reboot_notify,
 929 };
 930
 931 int xs_init(void)
 932 {
 933         int err;
 934         struct task_struct *task;
 935
 936         register_reboot_notifier(&xs_reboot_nb);
 937
 938         /* Initialize the shared memory rings to talk to xenstored */
 939         err = xb_init_comms();
 940         if (err)
 941                 return err;
 942
 943         task = kthread_run(xenwatch_thread, NULL, "xenwatch");
 944         if (IS_ERR(task))
 945                 return PTR_ERR(task);
 946
 947         /* shutdown watches for kexec boot */
 948         xs_reset_watches();
 949
 950         return 0;
 951 }