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