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