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