sys/dev/xen/xenstore/xenstore.c

   1 /******************************************************************************
   2  * xenstore.c
   3  *
   4  * Low-level kernel interface to the XenStore.
   5  *
   6  * Copyright (C) 2005 Rusty Russell, IBM Corporation
   7  * Copyright (C) 2009,2010 Spectra Logic Corporation
   8  *
   9  * This file may be distributed separately from the Linux kernel, or
  10  * incorporated into other software packages, subject to the following license:
  11  *
  12  * Permission is hereby granted, free of charge, to any person obtaining a copy
  13  * of this source file (the "Software"), to deal in the Software without
  14  * restriction, including without limitation the rights to use, copy, modify,
  15  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  16  * and to permit persons to whom the Software is furnished to do so, subject to
  17  * the following conditions:
  18  *
  19  * The above copyright notice and this permission notice shall be included in
  20  * all copies or substantial portions of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  23  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  25  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  26  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  27  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  28  * IN THE SOFTWARE.
  29  */
  30
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/bus.h>
  37 #include <sys/kernel.h>
  38 #include <sys/lock.h>
  39 #include <sys/module.h>
  40 #include <sys/mutex.h>
  41 #include <sys/sx.h>
  42 #include <sys/syslog.h>
  43 #include <sys/malloc.h>
  44 #include <sys/systm.h>
  45 #include <sys/proc.h>
  46 #include <sys/kthread.h>
  47 #include <sys/sbuf.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/uio.h>
  50 #include <sys/unistd.h>
  51 #include <sys/queue.h>
  52 #include <sys/taskqueue.h>
  53
  54 #include <machine/stdarg.h>
  55
  56 #include <xen/xen-os.h>
  57 #include <xen/hypervisor.h>
  58 #include <xen/xen_intr.h>
  59
  60 #include <xen/interface/hvm/params.h>
  61 #include <xen/hvm.h>
  62
  63 #include <xen/xenstore/xenstorevar.h>
  64 #include <xen/xenstore/xenstore_internal.h>
  65
  66 #include <vm/vm.h>
  67 #include <vm/pmap.h>
  68
  69 /**
  70  * \file xenstore.c
  71  * \brief XenStore interface
  72  *
  73  * The XenStore interface is a simple storage system that is a means of
  74  * communicating state and configuration data between the Xen Domain 0
  75  * and the various guest domains.  All configuration data other than
  76  * a small amount of essential information required during the early
  77  * boot process of launching a Xen aware guest, is managed using the
  78  * XenStore.
  79  *
  80  * The XenStore is ASCII string based, and has a structure and semantics
  81  * similar to a filesystem.  There are files and directories, the directories
  82  * able to contain files or other directories.  The depth of the hierarchy
  83  * is only limited by the XenStore's maximum path length.
  84  *
  85  * The communication channel between the XenStore service and other
  86  * domains is via two, guest specific, ring buffers in a shared memory
  87  * area.  One ring buffer is used for communicating in each direction.
  88  * The grant table references for this shared memory are given to the
  89  * guest either via the xen_start_info structure for a fully para-
  90  * virtualized guest, or via HVM hypercalls for a hardware virtualized
  91  * guest.
  92  *
  93  * The XenStore communication relies on an event channel and thus
  94  * interrupts.  For this reason, the attachment of the XenStore
  95  * relies on an interrupt driven configuration hook to hold off
  96  * boot processing until communication with the XenStore service
  97  * can be established.
  98  *
  99  * Several Xen services depend on the XenStore, most notably the
 100  * XenBus used to discover and manage Xen devices.  These services
 101  * are implemented as NewBus child attachments to a bus exported
 102  * by this XenStore driver.
 103  */
 104
 105 static struct xs_watch *find_watch(const char *token);
 106
 107 MALLOC_DEFINE(M_XENSTORE, "xenstore", "XenStore data and results");
 108
 109 /**
 110  * Pointer to shared memory communication structures allowing us
 111  * to communicate with the XenStore service.
 112  *
 113  * When operating in full PV mode, this pointer is set early in kernel
 114  * startup from within xen_machdep.c.  In HVM mode, we use hypercalls
 115  * to get the guest frame number for the shared page and then map it
 116  * into kva.  See xs_init() for details.
 117  */
 118 static struct xenstore_domain_interface *xen_store;
 119
 120 /*-------------------------- Private Data Structures ------------------------*/
 121
 122 /**
 123  * Structure capturing messages received from the XenStore service.
 124  */
 125 struct xs_stored_msg {
 126         TAILQ_ENTRY(xs_stored_msg) list;
 127
 128         struct xsd_sockmsg hdr;
 129
 130         union {
 131                 /* Queued replies. */
 132                 struct {
 133                         char *body;
 134                 } reply;
 135
 136                 /* Queued watch events. */
 137                 struct {
 138                         struct xs_watch *handle;
 139                         const char **vec;
 140                         u_int vec_size;
 141                 } watch;
 142         } u;
 143 };
 144 TAILQ_HEAD(xs_stored_msg_list, xs_stored_msg);
 145
 146 /**
 147  * Container for all XenStore related state.
 148  */
 149 struct xs_softc {
 150         /** Newbus device for the XenStore. */
 151         device_t xs_dev;
 152
 153         /**
 154          * Lock serializing access to ring producer/consumer
 155          * indexes.  Use of this lock guarantees that wakeups
 156          * of blocking readers/writers are not missed due to
 157          * races with the XenStore service.
 158          */
 159         struct mtx ring_lock;
 160
 161         /*
 162          * Mutex used to insure exclusive access to the outgoing
 163          * communication ring.  We use a lock type that can be
 164          * held while sleeping so that xs_write() can block waiting
 165          * for space in the ring to free up, without allowing another
 166          * writer to come in and corrupt a partial message write.
 167          */
 168         struct sx request_mutex;
 169
 170         /**
 171          * A list of replies to our requests.
 172          *
 173          * The reply list is filled by xs_rcv_thread().  It
 174          * is consumed by the context that issued the request
 175          * to which a reply is made.  The requester blocks in
 176          * xs_read_reply().
 177          *
 178          * /note Only one requesting context can be active at a time.
 179          *       This is guaranteed by the request_mutex and insures
 180          *       that the requester sees replies matching the order
 181          *       of its requests.
 182          */
 183         struct xs_stored_msg_list reply_list;
 184
 185         /** Lock protecting the reply list. */
 186         struct mtx reply_lock;
 187
 188         /**
 189          * List of registered watches.
 190          */
 191         struct xs_watch_list  registered_watches;
 192
 193         /** Lock protecting the registered watches list. */
 194         struct mtx registered_watches_lock;
 195
 196         /**
 197          * List of pending watch callback events.
 198          */
 199         struct xs_stored_msg_list watch_events;
 200
 201         /** Lock protecting the watch calback list. */
 202         struct mtx watch_events_lock;
 203
 204         /**
 205          * The processid of the xenwatch thread.
 206          */
 207         pid_t xenwatch_pid;
 208
 209         /**
 210          * Sleepable mutex used to gate the execution of XenStore
 211          * watch event callbacks.
 212          *
 213          * xenwatch_thread holds an exclusive lock on this mutex
 214          * while delivering event callbacks, and xenstore_unregister_watch()
 215          * uses an exclusive lock of this mutex to guarantee that no
 216          * callbacks of the just unregistered watch are pending
 217          * before returning to its caller.
 218          */
 219         struct sx xenwatch_mutex;
 220
 221         /**
 222          * The HVM guest pseudo-physical frame number.  This is Xen's mapping
 223          * of the true machine frame number into our "physical address space".
 224          */
 225         unsigned long gpfn;
 226
 227         /**
 228          * The event channel for communicating with the
 229          * XenStore service.
 230          */
 231         int evtchn;
 232
 233         /** Handle for XenStore interrupts. */
 234         xen_intr_handle_t xen_intr_handle;
 235
 236         /**
 237          * Interrupt driven config hook allowing us to defer
 238          * attaching children until interrupts (and thus communication
 239          * with the XenStore service) are available.
 240          */
 241         struct intr_config_hook xs_attachcb;
 242
 243         /**
 244          * Xenstore is a user-space process that usually runs in Dom0,
 245          * so if this domain is booting as Dom0, xenstore wont we accessible,
 246          * and we have to defer the initialization of xenstore related
 247          * devices to later (when xenstore is started).
 248          */
 249         bool initialized;
 250
 251         /**
 252          * Task to run when xenstore is initialized (Dom0 only), will
 253          * take care of attaching xenstore related devices.
 254          */
 255         struct task xs_late_init;
 256 };
 257
 258 /*-------------------------------- Global Data ------------------------------*/
 259 static struct xs_softc xs;
 260
 261 /*------------------------- Private Utility Functions -----------------------*/
 262
 263 /**
 264  * Count and optionally record pointers to a number of NUL terminated
 265  * strings in a buffer.
 266  *
 267  * \param strings  A pointer to a contiguous buffer of NUL terminated strings.
 268  * \param dest     An array to store pointers to each string found in strings.
 269  * \param len      The length of the buffer pointed to by strings.
 270  *
 271  * \return  A count of the number of strings found.
 272  */
 273 static u_int
 274 extract_strings(const char *strings, const char **dest, u_int len)
 275 {
 276         u_int num;
 277         const char *p;
 278
 279         for (p = strings, num = 0; p < strings + len; p += strlen(p) + 1) {
 280                 if (dest != NULL)
 281                         *dest++ = p;
 282                 num++;
 283         }
 284
 285         return (num);
 286 }
 287
 288 /**
 289  * Convert a contiguous buffer containing a series of NUL terminated
 290  * strings into an array of pointers to strings.
 291  *
 292  * The returned pointer references the array of string pointers which
 293  * is followed by the storage for the string data.  It is the client's
 294  * responsibility to free this storage.
 295  *
 296  * The storage addressed by strings is free'd prior to split returning.
 297  *
 298  * \param strings  A pointer to a contiguous buffer of NUL terminated strings.
 299  * \param len      The length of the buffer pointed to by strings.
 300  * \param num      The number of strings found and returned in the strings
 301  *                 array.
 302  *
 303  * \return  An array of pointers to the strings found in the input buffer.
 304  */
 305 static const char **
 306 split(char *strings, u_int len, u_int *num)
 307 {
 308         const char **ret;
 309
 310         /* Protect against unterminated buffers. */
 311         if (len > 0)
 312                 strings[len - 1] = '\0';
 313
 314         /* Count the strings. */
 315         *num = extract_strings(strings, /*dest*/NULL, len);
 316
 317         /* Transfer to one big alloc for easy freeing by the caller. */
 318         ret = malloc(*num * sizeof(char *) + len, M_XENSTORE, M_WAITOK);
 319         memcpy(&ret[*num], strings, len);
 320         free(strings, M_XENSTORE);
 321
 322         /* Extract pointers to newly allocated array. */
 323         strings = (char *)&ret[*num];
 324         (void)extract_strings(strings, /*dest*/ret, len);
 325
 326         return (ret);
 327 }
 328
 329 /*------------------------- Public Utility Functions -------------------------*/
 330 /*------- API comments for these methods can be found in xenstorevar.h -------*/
 331 struct sbuf *
 332 xs_join(const char *dir, const char *name)
 333 {
 334         struct sbuf *sb;
 335
 336         sb = sbuf_new_auto();
 337         sbuf_cat(sb, dir);
 338         if (name[0] != '\0') {
 339                 sbuf_putc(sb, '/');
 340                 sbuf_cat(sb, name);
 341         }
 342         sbuf_finish(sb);
 343
 344         return (sb);
 345 }
 346
 347 /*-------------------- Low Level Communication Management --------------------*/
 348 /**
 349  * Interrupt handler for the XenStore event channel.
 350  *
 351  * XenStore reads and writes block on "xen_store" for buffer
 352  * space.  Wakeup any blocking operations when the XenStore
 353  * service has modified the queues.
 354  */
 355 static void
 356 xs_intr(void * arg __unused /*__attribute__((unused))*/)
 357 {
 358
 359         /* If xenstore has not been initialized, initialize it now */
 360         if (!xs.initialized) {
 361                 xs.initialized = true;
 362                 /*
 363                  * Since this task is probing and attaching devices we
 364                  * have to hold the Giant lock.
 365                  */
 366                 taskqueue_enqueue(taskqueue_swi_giant, &xs.xs_late_init);
 367         }
 368
 369         /*
 370          * Hold ring lock across wakeup so that clients
 371          * cannot miss a wakeup.
 372          */
 373         mtx_lock(&xs.ring_lock);
 374         wakeup(xen_store);
 375         mtx_unlock(&xs.ring_lock);
 376 }
 377
 378 /**
 379  * Verify that the indexes for a ring are valid.
 380  *
 381  * The difference between the producer and consumer cannot
 382  * exceed the size of the ring.
 383  *
 384  * \param cons  The consumer index for the ring to test.
 385  * \param prod  The producer index for the ring to test.
 386  *
 387  * \retval 1  If indexes are in range.
 388  * \retval 0  If the indexes are out of range.
 389  */
 390 static int
 391 xs_check_indexes(XENSTORE_RING_IDX cons, XENSTORE_RING_IDX prod)
 392 {
 393
 394         return ((prod - cons) <= XENSTORE_RING_SIZE);
 395 }
 396
 397 /**
 398  * Return a pointer to, and the length of, the contiguous
 399  * free region available for output in a ring buffer.
 400  *
 401  * \param cons  The consumer index for the ring.
 402  * \param prod  The producer index for the ring.
 403  * \param buf   The base address of the ring's storage.
 404  * \param len   The amount of contiguous storage available.
 405  *
 406  * \return  A pointer to the start location of the free region.
 407  */
 408 static void *
 409 xs_get_output_chunk(XENSTORE_RING_IDX cons, XENSTORE_RING_IDX prod,
 410     char *buf, uint32_t *len)
 411 {
 412
 413         *len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod);
 414         if ((XENSTORE_RING_SIZE - (prod - cons)) < *len)
 415                 *len = XENSTORE_RING_SIZE - (prod - cons);
 416         return (buf + MASK_XENSTORE_IDX(prod));
 417 }
 418
 419 /**
 420  * Return a pointer to, and the length of, the contiguous
 421  * data available to read from a ring buffer.
 422  *
 423  * \param cons  The consumer index for the ring.
 424  * \param prod  The producer index for the ring.
 425  * \param buf   The base address of the ring's storage.
 426  * \param len   The amount of contiguous data available to read.
 427  *
 428  * \return  A pointer to the start location of the available data.
 429  */
 430 static const void *
 431 xs_get_input_chunk(XENSTORE_RING_IDX cons, XENSTORE_RING_IDX prod,
 432     const char *buf, uint32_t *len)
 433 {
 434
 435         *len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(cons);
 436         if ((prod - cons) < *len)
 437                 *len = prod - cons;
 438         return (buf + MASK_XENSTORE_IDX(cons));
 439 }
 440
 441 /**
 442  * Transmit data to the XenStore service.
 443  *
 444  * \param tdata  A pointer to the contiguous data to send.
 445  * \param len    The amount of data to send.
 446  *
 447  * \return  On success 0, otherwise an errno value indicating the
 448  *          cause of failure.
 449  *
 450  * \invariant  Called from thread context.
 451  * \invariant  The buffer pointed to by tdata is at least len bytes
 452  *             in length.
 453  * \invariant  xs.request_mutex exclusively locked.
 454  */
 455 static int
 456 xs_write_store(const void *tdata, unsigned len)
 457 {
 458         XENSTORE_RING_IDX cons, prod;
 459         const char *data = (const char *)tdata;
 460         int error;
 461
 462         sx_assert(&xs.request_mutex, SX_XLOCKED);
 463         while (len != 0) {
 464                 void *dst;
 465                 u_int avail;
 466
 467                 /* Hold lock so we can't miss wakeups should we block. */
 468                 mtx_lock(&xs.ring_lock);
 469                 cons = xen_store->req_cons;
 470                 prod = xen_store->req_prod;
 471                 if ((prod - cons) == XENSTORE_RING_SIZE) {
 472                         /*
 473                          * Output ring is full. Wait for a ring event.
 474                          *
 475                          * Note that the events from both queues
 476                          * are combined, so being woken does not
 477                          * guarantee that data exist in the read
 478                          * ring.
 479                          *
 480                          * To simplify error recovery and the retry,
 481                          * we specify PDROP so our lock is *not* held
 482                          * when msleep returns.
 483                          */
 484                         error = msleep(xen_store, &xs.ring_lock, PCATCH|PDROP,
 485                              "xbwrite", /*timeout*/0);
 486                         if (error && error != EWOULDBLOCK)
 487                                 return (error);
 488
 489                         /* Try again. */
 490                         continue;
 491                 }
 492                 mtx_unlock(&xs.ring_lock);
 493
 494                 /* Verify queue sanity. */
 495                 if (!xs_check_indexes(cons, prod)) {
 496                         xen_store->req_cons = xen_store->req_prod = 0;
 497                         return (EIO);
 498                 }
 499
 500                 dst = xs_get_output_chunk(cons, prod, xen_store->req, &avail);
 501                 if (avail > len)
 502                         avail = len;
 503
 504                 memcpy(dst, data, avail);
 505                 data += avail;
 506                 len -= avail;
 507
 508                 /*
 509                  * The store to the producer index, which indicates
 510                  * to the other side that new data has arrived, must
 511                  * be visible only after our copy of the data into the
 512                  * ring has completed.
 513                  */
 514                 wmb();
 515                 xen_store->req_prod += avail;
 516
 517                 /*
 518                  * xen_intr_signal() implies mb(). The other side will see
 519                  * the change to req_prod at the time of the interrupt.
 520                  */
 521                 xen_intr_signal(xs.xen_intr_handle);
 522         }
 523
 524         return (0);
 525 }
 526
 527 /**
 528  * Receive data from the XenStore service.
 529  *
 530  * \param tdata  A pointer to the contiguous buffer to receive the data.
 531  * \param len    The amount of data to receive.
 532  *
 533  * \return  On success 0, otherwise an errno value indicating the
 534  *          cause of failure.
 535  *
 536  * \invariant  Called from thread context.
 537  * \invariant  The buffer pointed to by tdata is at least len bytes
 538  *             in length.
 539  *
 540  * \note xs_read does not perform any internal locking to guarantee
 541  *       serial access to the incoming ring buffer.  However, there
 542  *       is only one context processing reads: xs_rcv_thread().
 543  */
 544 static int
 545 xs_read_store(void *tdata, unsigned len)
 546 {
 547         XENSTORE_RING_IDX cons, prod;
 548         char *data = (char *)tdata;
 549         int error;
 550
 551         while (len != 0) {
 552                 u_int avail;
 553                 const char *src;
 554
 555                 /* Hold lock so we can't miss wakeups should we block. */
 556                 mtx_lock(&xs.ring_lock);
 557                 cons = xen_store->rsp_cons;
 558                 prod = xen_store->rsp_prod;
 559                 if (cons == prod) {
 560                         /*
 561                          * Nothing to read. Wait for a ring event.
 562                          *
 563                          * Note that the events from both queues
 564                          * are combined, so being woken does not
 565                          * guarantee that data exist in the read
 566                          * ring.
 567                          *
 568                          * To simplify error recovery and the retry,
 569                          * we specify PDROP so our lock is *not* held
 570                          * when msleep returns.
 571                          */
 572                         error = msleep(xen_store, &xs.ring_lock, PCATCH|PDROP,
 573                             "xbread", /*timeout*/0);
 574                         if (error && error != EWOULDBLOCK)
 575                                 return (error);
 576                         continue;
 577                 }
 578                 mtx_unlock(&xs.ring_lock);
 579
 580                 /* Verify queue sanity. */
 581                 if (!xs_check_indexes(cons, prod)) {
 582                         xen_store->rsp_cons = xen_store->rsp_prod = 0;
 583                         return (EIO);
 584                 }
 585
 586                 src = xs_get_input_chunk(cons, prod, xen_store->rsp, &avail);
 587                 if (avail > len)
 588                         avail = len;
 589
 590                 /*
 591                  * Insure the data we read is related to the indexes
 592                  * we read above.
 593                  */
 594                 rmb();
 595
 596                 memcpy(data, src, avail);
 597                 data += avail;
 598                 len -= avail;
 599
 600                 /*
 601                  * Insure that the producer of this ring does not see
 602                  * the ring space as free until after we have copied it
 603                  * out.
 604                  */
 605                 mb();
 606                 xen_store->rsp_cons += avail;
 607
 608                 /*
 609                  * xen_intr_signal() implies mb(). The producer will see
 610                  * the updated consumer index when the event is delivered.
 611                  */
 612                 xen_intr_signal(xs.xen_intr_handle);
 613         }
 614
 615         return (0);
 616 }
 617
 618 /*----------------------- Received Message Processing ------------------------*/
 619 /**
 620  * Block reading the next message from the XenStore service and
 621  * process the result.
 622  *
 623  * \param type  The returned type of the XenStore message received.
 624  *
 625  * \return  0 on success.  Otherwise an errno value indicating the
 626  *          type of failure encountered.
 627  */
 628 static int
 629 xs_process_msg(enum xsd_sockmsg_type *type)
 630 {
 631         struct xs_stored_msg *msg;
 632         char *body;
 633         int error;
 634
 635         msg = malloc(sizeof(*msg), M_XENSTORE, M_WAITOK);
 636         error = xs_read_store(&msg->hdr, sizeof(msg->hdr));
 637         if (error) {
 638                 free(msg, M_XENSTORE);
 639                 return (error);
 640         }
 641
 642         body = malloc(msg->hdr.len + 1, M_XENSTORE, M_WAITOK);
 643         error = xs_read_store(body, msg->hdr.len);
 644         if (error) {
 645                 free(body, M_XENSTORE);
 646                 free(msg, M_XENSTORE);
 647                 return (error);
 648         }
 649         body[msg->hdr.len] = '\0';
 650
 651         *type = msg->hdr.type;
 652         if (msg->hdr.type == XS_WATCH_EVENT) {
 653                 msg->u.watch.vec = split(body, msg->hdr.len,
 654                     &msg->u.watch.vec_size);
 655
 656                 mtx_lock(&xs.registered_watches_lock);
 657                 msg->u.watch.handle = find_watch(
 658                     msg->u.watch.vec[XS_WATCH_TOKEN]);
 659                 mtx_lock(&xs.watch_events_lock);
 660                 if (msg->u.watch.handle != NULL &&
 661                     (!msg->u.watch.handle->max_pending ||
 662                     msg->u.watch.handle->pending <
 663                     msg->u.watch.handle->max_pending)) {
 664                         msg->u.watch.handle->pending++;
 665                         TAILQ_INSERT_TAIL(&xs.watch_events, msg, list);
 666                         wakeup(&xs.watch_events);
 667                         mtx_unlock(&xs.watch_events_lock);
 668                 } else {
 669                         mtx_unlock(&xs.watch_events_lock);
 670                         free(msg->u.watch.vec, M_XENSTORE);
 671                         free(msg, M_XENSTORE);
 672                 }
 673                 mtx_unlock(&xs.registered_watches_lock);
 674         } else {
 675                 msg->u.reply.body = body;
 676                 mtx_lock(&xs.reply_lock);
 677                 TAILQ_INSERT_TAIL(&xs.reply_list, msg, list);
 678                 wakeup(&xs.reply_list);
 679                 mtx_unlock(&xs.reply_lock);
 680         }
 681
 682         return (0);
 683 }
 684
 685 /**
 686  * Thread body of the XenStore receive thread.
 687  *
 688  * This thread blocks waiting for data from the XenStore service
 689  * and processes and received messages.
 690  */
 691 static void
 692 xs_rcv_thread(void *arg __unused)
 693 {
 694         int error;
 695         enum xsd_sockmsg_type type;
 696
 697         for (;;) {
 698                 error = xs_process_msg(&type);
 699                 if (error)
 700                         printf("XENSTORE error %d while reading message\n",
 701                             error);
 702         }
 703 }
 704
 705 /*---------------- XenStore Message Request/Reply Processing -----------------*/
 706 #define xsd_error_count (sizeof(xsd_errors) / sizeof(xsd_errors[0]))
 707
 708 /**
 709  * Convert a XenStore error string into an errno number.
 710  *
 711  * \param errorstring  The error string to convert.
 712  *
 713  * \return  The errno best matching the input string.
 714  *
 715  * \note Unknown error strings are converted to EINVAL.
 716  */
 717 static int
 718 xs_get_error(const char *errorstring)
 719 {
 720         u_int i;
 721
 722         for (i = 0; i < xsd_error_count; i++) {
 723                 if (!strcmp(errorstring, xsd_errors[i].errstring))
 724                         return (xsd_errors[i].errnum);
 725         }
 726         log(LOG_WARNING, "XENSTORE xen store gave: unknown error %s",
 727             errorstring);
 728         return (EINVAL);
 729 }
 730
 731 /**
 732  * Block waiting for a reply to a message request.
 733  *
 734  * \param type    The returned type of the reply.
 735  * \param len     The returned body length of the reply.
 736  * \param result  The returned body of the reply.
 737  *
 738  * \return  0 on success.  Otherwise an errno indicating the
 739  *          cause of failure.
 740  */
 741 static int
 742 xs_read_reply(enum xsd_sockmsg_type *type, u_int *len, void **result)
 743 {
 744         struct xs_stored_msg *msg;
 745         char *body;
 746         int error;
 747
 748         mtx_lock(&xs.reply_lock);
 749         while (TAILQ_EMPTY(&xs.reply_list)) {
 750                 error = mtx_sleep(&xs.reply_list, &xs.reply_lock, 0, "xswait",
 751                     hz/10);
 752                 if (error && error != EWOULDBLOCK) {
 753                         mtx_unlock(&xs.reply_lock);
 754                         return (error);
 755                 }
 756         }
 757         msg = TAILQ_FIRST(&xs.reply_list);
 758         TAILQ_REMOVE(&xs.reply_list, msg, list);
 759         mtx_unlock(&xs.reply_lock);
 760
 761         *type = msg->hdr.type;
 762         if (len)
 763                 *len = msg->hdr.len;
 764         body = msg->u.reply.body;
 765
 766         free(msg, M_XENSTORE);
 767         *result = body;
 768         return (0);
 769 }
 770
 771 /**
 772  * Pass-thru interface for XenStore access by userland processes
 773  * via the XenStore device.
 774  *
 775  * Reply type and length data are returned by overwriting these
 776  * fields in the passed in request message.
 777  *
 778  * \param msg     A properly formatted message to transmit to
 779  *                the XenStore service.
 780  * \param result  The returned body of the reply.
 781  *
 782  * \return  0 on success.  Otherwise an errno indicating the cause
 783  *          of failure.
 784  *
 785  * \note The returned result is provided in malloced storage and thus
 786  *       must be free'd by the caller with 'free(result, M_XENSTORE);
 787  */
 788 int
 789 xs_dev_request_and_reply(struct xsd_sockmsg *msg, void **result)
 790 {
 791         uint32_t request_type;
 792         int error;
 793
 794         request_type = msg->type;
 795
 796         sx_xlock(&xs.request_mutex);
 797         if ((error = xs_write_store(msg, sizeof(*msg) + msg->len)) == 0)
 798                 error = xs_read_reply(&msg->type, &msg->len, result);
 799         sx_xunlock(&xs.request_mutex);
 800
 801         return (error);
 802 }
 803
 804 /**
 805  * Send a message with an optionally muti-part body to the XenStore service.
 806  *
 807  * \param t              The transaction to use for this request.
 808  * \param request_type   The type of message to send.
 809  * \param iovec          Pointers to the body sections of the request.
 810  * \param num_vecs       The number of body sections in the request.
 811  * \param len            The returned length of the reply.
 812  * \param result         The returned body of the reply.
 813  *
 814  * \return  0 on success.  Otherwise an errno indicating
 815  *          the cause of failure.
 816  *
 817  * \note The returned result is provided in malloced storage and thus
 818  *       must be free'd by the caller with 'free(*result, M_XENSTORE);
 819  */
 820 static int
 821 xs_talkv(struct xs_transaction t, enum xsd_sockmsg_type request_type,
 822     const struct iovec *iovec, u_int num_vecs, u_int *len, void **result)
 823 {
 824         struct xsd_sockmsg msg;
 825         void *ret = NULL;
 826         u_int i;
 827         int error;
 828
 829         msg.tx_id = t.id;
 830         msg.req_id = 0;
 831         msg.type = request_type;
 832         msg.len = 0;
 833         for (i = 0; i < num_vecs; i++)
 834                 msg.len += iovec[i].iov_len;
 835
 836         sx_xlock(&xs.request_mutex);
 837         error = xs_write_store(&msg, sizeof(msg));
 838         if (error) {
 839                 printf("xs_talkv failed %d\n", error);
 840                 goto error_lock_held;
 841         }
 842
 843         for (i = 0; i < num_vecs; i++) {
 844                 error = xs_write_store(iovec[i].iov_base, iovec[i].iov_len);
 845                 if (error) {
 846                         printf("xs_talkv failed %d\n", error);
 847                         goto error_lock_held;
 848                 }
 849         }
 850
 851         error = xs_read_reply(&msg.type, len, &ret);
 852
 853 error_lock_held:
 854         sx_xunlock(&xs.request_mutex);
 855         if (error)
 856                 return (error);
 857
 858         if (msg.type == XS_ERROR) {
 859                 error = xs_get_error(ret);
 860                 free(ret, M_XENSTORE);
 861                 return (error);
 862         }
 863
 864         /* Reply is either error or an echo of our request message type. */
 865         KASSERT(msg.type == request_type, ("bad xenstore message type"));
 866
 867         if (result)
 868                 *result = ret;
 869         else
 870                 free(ret, M_XENSTORE);
 871
 872         return (0);
 873 }
 874
 875 /**
 876  * Wrapper for xs_talkv allowing easy transmission of a message with
 877  * a single, contiguous, message body.
 878  *
 879  * \param t              The transaction to use for this request.
 880  * \param request_type   The type of message to send.
 881  * \param body           The body of the request.
 882  * \param len            The returned length of the reply.
 883  * \param result         The returned body of the reply.
 884  *
 885  * \return  0 on success.  Otherwise an errno indicating
 886  *          the cause of failure.
 887  *
 888  * \note The returned result is provided in malloced storage and thus
 889  *       must be free'd by the caller with 'free(*result, M_XENSTORE);
 890  */
 891 static int
 892 xs_single(struct xs_transaction t, enum xsd_sockmsg_type request_type,
 893     const char *body, u_int *len, void **result)
 894 {
 895         struct iovec iovec;
 896
 897         iovec.iov_base = (void *)(uintptr_t)body;
 898         iovec.iov_len = strlen(body) + 1;
 899
 900         return (xs_talkv(t, request_type, &iovec, 1, len, result));
 901 }
 902
 903 /*------------------------- XenStore Watch Support ---------------------------*/
 904 /**
 905  * Transmit a watch request to the XenStore service.
 906  *
 907  * \param path    The path in the XenStore to watch.
 908  * \param tocken  A unique identifier for this watch.
 909  *
 910  * \return  0 on success.  Otherwise an errno indicating the
 911  *          cause of failure.
 912  */
 913 static int
 914 xs_watch(const char *path, const char *token)
 915 {
 916         struct iovec iov[2];
 917
 918         iov[0].iov_base = (void *)(uintptr_t) path;
 919         iov[0].iov_len = strlen(path) + 1;
 920         iov[1].iov_base = (void *)(uintptr_t) token;
 921         iov[1].iov_len = strlen(token) + 1;
 922
 923         return (xs_talkv(XST_NIL, XS_WATCH, iov, 2, NULL, NULL));
 924 }
 925
 926 /**
 927  * Transmit an uwatch request to the XenStore service.
 928  *
 929  * \param path    The path in the XenStore to watch.
 930  * \param tocken  A unique identifier for this watch.
 931  *
 932  * \return  0 on success.  Otherwise an errno indicating the
 933  *          cause of failure.
 934  */
 935 static int
 936 xs_unwatch(const char *path, const char *token)
 937 {
 938         struct iovec iov[2];
 939
 940         iov[0].iov_base = (void *)(uintptr_t) path;
 941         iov[0].iov_len = strlen(path) + 1;
 942         iov[1].iov_base = (void *)(uintptr_t) token;
 943         iov[1].iov_len = strlen(token) + 1;
 944
 945         return (xs_talkv(XST_NIL, XS_UNWATCH, iov, 2, NULL, NULL));
 946 }
 947
 948 /**
 949  * Convert from watch token (unique identifier) to the associated
 950  * internal tracking structure for this watch.
 951  *
 952  * \param tocken  The unique identifier for the watch to find.
 953  *
 954  * \return  A pointer to the found watch structure or NULL.
 955  */
 956 static struct xs_watch *
 957 find_watch(const char *token)
 958 {
 959         struct xs_watch *i, *cmp;
 960
 961         cmp = (void *)strtoul(token, NULL, 16);
 962
 963         LIST_FOREACH(i, &xs.registered_watches, list)
 964                 if (i == cmp)
 965                         return (i);
 966
 967         return (NULL);
 968 }
 969
 970 /**
 971  * Thread body of the XenStore watch event dispatch thread.
 972  */
 973 static void
 974 xenwatch_thread(void *unused)
 975 {
 976         struct xs_stored_msg *msg;
 977
 978         for (;;) {
 979
 980                 mtx_lock(&xs.watch_events_lock);
 981                 while (TAILQ_EMPTY(&xs.watch_events))
 982                         mtx_sleep(&xs.watch_events,
 983                             &xs.watch_events_lock,
 984                             PWAIT | PCATCH, "waitev", hz/10);
 985
 986                 mtx_unlock(&xs.watch_events_lock);
 987                 sx_xlock(&xs.xenwatch_mutex);
 988
 989                 mtx_lock(&xs.watch_events_lock);
 990                 msg = TAILQ_FIRST(&xs.watch_events);
 991                 if (msg) {
 992                         TAILQ_REMOVE(&xs.watch_events, msg, list);
 993                         msg->u.watch.handle->pending--;
 994                 }
 995                 mtx_unlock(&xs.watch_events_lock);
 996
 997                 if (msg != NULL) {
 998                         /*
 999                          * XXX There are messages coming in with a NULL
1000                          * XXX callback.  This deserves further investigation;
1001                          * XXX the workaround here simply prevents the kernel
1002                          * XXX from panic'ing on startup.
1003                          */
1004                         if (msg->u.watch.handle->callback != NULL)
1005                                 msg->u.watch.handle->callback(
1006                                         msg->u.watch.handle,
1007                                         (const char **)msg->u.watch.vec,
1008                                         msg->u.watch.vec_size);
1009                         free(msg->u.watch.vec, M_XENSTORE);
1010                         free(msg, M_XENSTORE);
1011                 }
1012
1013                 sx_xunlock(&xs.xenwatch_mutex);
1014         }
1015 }
1016
1017 /*----------- XenStore Configuration, Initialization, and Control ------------*/
1018 /**
1019  * Setup communication channels with the XenStore service.
1020  *
1021  * \return  On success, 0. Otherwise an errno value indicating the
1022  *          type of failure.
1023  */
1024 static int
1025 xs_init_comms(void)
1026 {
1027         int error;
1028
1029         if (xen_store->rsp_prod != xen_store->rsp_cons) {
1030                 log(LOG_WARNING, "XENSTORE response ring is not quiescent "
1031                     "(%08x:%08x): fixing up\n",
1032                     xen_store->rsp_cons, xen_store->rsp_prod);
1033                 xen_store->rsp_cons = xen_store->rsp_prod;
1034         }
1035
1036         xen_intr_unbind(&xs.xen_intr_handle);
1037
1038         error = xen_intr_bind_local_port(xs.xs_dev, xs.evtchn,
1039             /*filter*/NULL, xs_intr, /*arg*/NULL, INTR_TYPE_NET|INTR_MPSAFE,
1040             &xs.xen_intr_handle);
1041         if (error) {
1042                 log(LOG_WARNING, "XENSTORE request irq failed %i\n", error);
1043                 return (error);
1044         }
1045
1046         return (0);
1047 }
1048
1049 /*------------------ Private Device Attachment Functions  --------------------*/
1050 static void
1051 xs_identify(driver_t *driver, device_t parent)
1052 {
1053
1054         BUS_ADD_CHILD(parent, 0, "xenstore", 0);
1055 }
1056
1057 /**
1058  * Probe for the existence of the XenStore.
1059  *
1060  * \param dev
1061  */
1062 static int
1063 xs_probe(device_t dev)
1064 {
1065         /*
1066          * We are either operating within a PV kernel or being probed
1067          * as the child of the successfully attached xenpci device.
1068          * Thus we are in a Xen environment and there will be a XenStore.
1069          * Unconditionally return success.
1070          */
1071         device_set_desc(dev, "XenStore");
1072         return (BUS_PROBE_NOWILDCARD);
1073 }
1074
1075 static void
1076 xs_attach_deferred(void *arg)
1077 {
1078
1079         bus_generic_probe(xs.xs_dev);
1080         bus_generic_attach(xs.xs_dev);
1081
1082         config_intrhook_disestablish(&xs.xs_attachcb);
1083 }
1084
1085 static void
1086 xs_attach_late(void *arg, int pending)
1087 {
1088
1089         KASSERT((pending == 1), ("xs late attach queued several times"));
1090         bus_generic_probe(xs.xs_dev);
1091         bus_generic_attach(xs.xs_dev);
1092 }
1093
1094 /**
1095  * Attach to the XenStore.
1096  *
1097  * This routine also prepares for the probe/attach of drivers that rely
1098  * on the XenStore.
1099  */
1100 static int
1101 xs_attach(device_t dev)
1102 {
1103         int error;
1104
1105         /* Allow us to get device_t from softc and vice-versa. */
1106         xs.xs_dev = dev;
1107         device_set_softc(dev, &xs);
1108
1109         /* Initialize the interface to xenstore. */
1110         struct proc *p;
1111
1112         xs.initialized = false;
1113         xs.evtchn = xen_get_xenstore_evtchn();
1114         if (xs.evtchn == 0) {
1115                 struct evtchn_alloc_unbound alloc_unbound;
1116
1117                 /* Allocate a local event channel for xenstore */
1118                 alloc_unbound.dom = DOMID_SELF;
1119                 alloc_unbound.remote_dom = DOMID_SELF;
1120                 error = HYPERVISOR_event_channel_op(
1121                     EVTCHNOP_alloc_unbound, &alloc_unbound);
1122                 if (error != 0)
1123                         panic(
1124                            "unable to alloc event channel for Dom0: %d",
1125                             error);
1126
1127                 xs.evtchn = alloc_unbound.port;
1128
1129                 /* Allocate memory for the xs shared ring */
1130                 xen_store = malloc(PAGE_SIZE, M_XENSTORE, M_WAITOK | M_ZERO);
1131                 xs.gpfn = atop(pmap_kextract((vm_offset_t)xen_store));
1132         } else {
1133                 xs.gpfn = xen_get_xenstore_mfn();
1134                 xen_store = pmap_mapdev_attr(ptoa(xs.gpfn), PAGE_SIZE,
1135                     PAT_WRITE_BACK);
1136                 xs.initialized = true;
1137         }
1138
1139         TAILQ_INIT(&xs.reply_list);
1140         TAILQ_INIT(&xs.watch_events);
1141
1142         mtx_init(&xs.ring_lock, "ring lock", NULL, MTX_DEF);
1143         mtx_init(&xs.reply_lock, "reply lock", NULL, MTX_DEF);
1144         sx_init(&xs.xenwatch_mutex, "xenwatch");
1145         sx_init(&xs.request_mutex, "xenstore request");
1146         mtx_init(&xs.registered_watches_lock, "watches", NULL, MTX_DEF);
1147         mtx_init(&xs.watch_events_lock, "watch events", NULL, MTX_DEF);
1148
1149         /* Initialize the shared memory rings to talk to xenstored */
1150         error = xs_init_comms();
1151         if (error)
1152                 return (error);
1153
1154         error = kproc_create(xenwatch_thread, NULL, &p, RFHIGHPID,
1155             0, "xenwatch");
1156         if (error)
1157                 return (error);
1158         xs.xenwatch_pid = p->p_pid;
1159
1160         error = kproc_create(xs_rcv_thread, NULL, NULL,
1161             RFHIGHPID, 0, "xenstore_rcv");
1162
1163         xs.xs_attachcb.ich_func = xs_attach_deferred;
1164         xs.xs_attachcb.ich_arg = NULL;
1165         if (xs.initialized) {
1166                 config_intrhook_establish(&xs.xs_attachcb);
1167         } else {
1168                 TASK_INIT(&xs.xs_late_init, 0, xs_attach_late, NULL);
1169         }
1170
1171         return (error);
1172 }
1173
1174 /**
1175  * Prepare for suspension of this VM by halting XenStore access after
1176  * all transactions and individual requests have completed.
1177  */
1178 static int
1179 xs_suspend(device_t dev)
1180 {
1181         int error;
1182
1183         /* Suspend child Xen devices. */
1184         error = bus_generic_suspend(dev);
1185         if (error != 0)
1186                 return (error);
1187
1188         sx_xlock(&xs.request_mutex);
1189
1190         return (0);
1191 }
1192
1193 /**
1194  * Resume XenStore operations after this VM is resumed.
1195  */
1196 static int
1197 xs_resume(device_t dev __unused)
1198 {
1199         struct xs_watch *watch;
1200         char token[sizeof(watch) * 2 + 1];
1201
1202         xs_init_comms();
1203
1204         sx_xunlock(&xs.request_mutex);
1205
1206         /*
1207          * NB: since xenstore childs have not been resumed yet, there's
1208          * no need to hold any watch mutex. Having clients try to add or
1209          * remove watches at this point (before xenstore is resumed) is
1210          * clearly a violantion of the resume order.
1211          */
1212         LIST_FOREACH(watch, &xs.registered_watches, list) {
1213                 sprintf(token, "%lX", (long)watch);
1214                 xs_watch(watch->node, token);
1215         }
1216
1217         /* Resume child Xen devices. */
1218         bus_generic_resume(dev);
1219
1220         return (0);
1221 }
1222
1223 /*-------------------- Private Device Attachment Data  -----------------------*/
1224 static device_method_t xenstore_methods[] = {
1225         /* Device interface */
1226         DEVMETHOD(device_identify,      xs_identify),
1227         DEVMETHOD(device_probe,         xs_probe),
1228         DEVMETHOD(device_attach,        xs_attach),
1229         DEVMETHOD(device_detach,        bus_generic_detach),
1230         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
1231         DEVMETHOD(device_suspend,       xs_suspend),
1232         DEVMETHOD(device_resume,        xs_resume),
1233
1234         /* Bus interface */
1235         DEVMETHOD(bus_add_child,        bus_generic_add_child),
1236         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
1237         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
1238         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
1239         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
1240
1241         DEVMETHOD_END
1242 };
1243
1244 DEFINE_CLASS_0(xenstore, xenstore_driver, xenstore_methods, 0);
1245 static devclass_t xenstore_devclass;
1246
1247 DRIVER_MODULE(xenstore, xenpv, xenstore_driver, xenstore_devclass, 0, 0);
1248
1249 /*------------------------------- Sysctl Data --------------------------------*/
1250 /* XXX Shouldn't the node be somewhere else? */
1251 SYSCTL_NODE(_dev, OID_AUTO, xen, CTLFLAG_RD, NULL, "Xen");
1252 SYSCTL_INT(_dev_xen, OID_AUTO, xsd_port, CTLFLAG_RD, &xs.evtchn, 0, "");
1253 SYSCTL_ULONG(_dev_xen, OID_AUTO, xsd_kva, CTLFLAG_RD, (u_long *) &xen_store, 0, "");
1254
1255 /*-------------------------------- Public API --------------------------------*/
1256 /*------- API comments for these methods can be found in xenstorevar.h -------*/
1257 bool
1258 xs_initialized(void)
1259 {
1260
1261         return (xs.initialized);
1262 }
1263
1264 evtchn_port_t
1265 xs_evtchn(void)
1266 {
1267
1268     return (xs.evtchn);
1269 }
1270
1271 vm_paddr_t
1272 xs_address(void)
1273 {
1274
1275     return (ptoa(xs.gpfn));
1276 }
1277
1278 int
1279 xs_directory(struct xs_transaction t, const char *dir, const char *node,
1280     u_int *num, const char ***result)
1281 {
1282         struct sbuf *path;
1283         char *strings;
1284         u_int len = 0;
1285         int error;
1286
1287         path = xs_join(dir, node);
1288         error = xs_single(t, XS_DIRECTORY, sbuf_data(path), &len,
1289             (void **)&strings);
1290         sbuf_delete(path);
1291         if (error)
1292                 return (error);
1293
1294         *result = split(strings, len, num);
1295
1296         return (0);
1297 }
1298
1299 int
1300 xs_exists(struct xs_transaction t, const char *dir, const char *node)
1301 {
1302         const char **d;
1303         int error, dir_n;
1304
1305         error = xs_directory(t, dir, node, &dir_n, &d);
1306         if (error)
1307                 return (0);
1308         free(d, M_XENSTORE);
1309         return (1);
1310 }
1311
1312 int
1313 xs_read(struct xs_transaction t, const char *dir, const char *node,
1314     u_int *len, void **result)
1315 {
1316         struct sbuf *path;
1317         void *ret;
1318         int error;
1319
1320         path = xs_join(dir, node);
1321         error = xs_single(t, XS_READ, sbuf_data(path), len, &ret);
1322         sbuf_delete(path);
1323         if (error)
1324                 return (error);
1325         *result = ret;
1326         return (0);
1327 }
1328
1329 int
1330 xs_write(struct xs_transaction t, const char *dir, const char *node,
1331     const char *string)
1332 {
1333         struct sbuf *path;
1334         struct iovec iovec[2];
1335         int error;
1336
1337         path = xs_join(dir, node);
1338
1339         iovec[0].iov_base = (void *)(uintptr_t) sbuf_data(path);
1340         iovec[0].iov_len = sbuf_len(path) + 1;
1341         iovec[1].iov_base = (void *)(uintptr_t) string;
1342         iovec[1].iov_len = strlen(string);
1343
1344         error = xs_talkv(t, XS_WRITE, iovec, 2, NULL, NULL);
1345         sbuf_delete(path);
1346
1347         return (error);
1348 }
1349
1350 int
1351 xs_mkdir(struct xs_transaction t, const char *dir, const char *node)
1352 {
1353         struct sbuf *path;
1354         int ret;
1355
1356         path = xs_join(dir, node);
1357         ret = xs_single(t, XS_MKDIR, sbuf_data(path), NULL, NULL);
1358         sbuf_delete(path);
1359
1360         return (ret);
1361 }
1362
1363 int
1364 xs_rm(struct xs_transaction t, const char *dir, const char *node)
1365 {
1366         struct sbuf *path;
1367         int ret;
1368
1369         path = xs_join(dir, node);
1370         ret = xs_single(t, XS_RM, sbuf_data(path), NULL, NULL);
1371         sbuf_delete(path);
1372
1373         return (ret);
1374 }
1375
1376 int
1377 xs_rm_tree(struct xs_transaction xbt, const char *base, const char *node)
1378 {
1379         struct xs_transaction local_xbt;
1380         struct sbuf *root_path_sbuf;
1381         struct sbuf *cur_path_sbuf;
1382         char *root_path;
1383         char *cur_path;
1384         const char **dir;
1385         int error;
1386
1387 retry:
1388         root_path_sbuf = xs_join(base, node);
1389         cur_path_sbuf  = xs_join(base, node);
1390         root_path      = sbuf_data(root_path_sbuf);
1391         cur_path       = sbuf_data(cur_path_sbuf);
1392         dir            = NULL;
1393         local_xbt.id   = 0;
1394
1395         if (xbt.id == 0) {
1396                 error = xs_transaction_start(&local_xbt);
1397                 if (error != 0)
1398                         goto out;
1399                 xbt = local_xbt;
1400         }
1401
1402         while (1) {
1403                 u_int count;
1404                 u_int i;
1405
1406                 error = xs_directory(xbt, cur_path, "", &count, &dir);
1407                 if (error)
1408                         goto out;
1409
1410                 for (i = 0; i < count; i++) {
1411                         error = xs_rm(xbt, cur_path, dir[i]);
1412                         if (error == ENOTEMPTY) {
1413                                 struct sbuf *push_dir;
1414
1415                                 /*
1416                                  * Descend to clear out this sub directory.
1417                                  * We'll return to cur_dir once push_dir
1418                                  * is empty.
1419                                  */
1420                                 push_dir = xs_join(cur_path, dir[i]);
1421                                 sbuf_delete(cur_path_sbuf);
1422                                 cur_path_sbuf = push_dir;
1423                                 cur_path = sbuf_data(cur_path_sbuf);
1424                                 break;
1425                         } else if (error != 0) {
1426                                 goto out;
1427                         }
1428                 }
1429
1430                 free(dir, M_XENSTORE);
1431                 dir = NULL;
1432
1433                 if (i == count) {
1434                         char *last_slash;
1435
1436                         /* Directory is empty.  It is now safe to remove. */
1437                         error = xs_rm(xbt, cur_path, "");
1438                         if (error != 0)
1439                                 goto out;
1440
1441                         if (!strcmp(cur_path, root_path))
1442                                 break;
1443
1444                         /* Return to processing the parent directory. */
1445                         last_slash = strrchr(cur_path, '/');
1446                         KASSERT(last_slash != NULL,
1447                                 ("xs_rm_tree: mangled path %s", cur_path));
1448                         *last_slash = '\0';
1449                 }
1450         }
1451
1452 out:
1453         sbuf_delete(cur_path_sbuf);
1454         sbuf_delete(root_path_sbuf);
1455         if (dir != NULL)
1456                 free(dir, M_XENSTORE);
1457
1458         if (local_xbt.id != 0) {
1459                 int terror;
1460
1461                 terror = xs_transaction_end(local_xbt, /*abort*/error != 0);
1462                 xbt.id = 0;
1463                 if (terror == EAGAIN && error == 0)
1464                         goto retry;
1465         }
1466         return (error);
1467 }
1468
1469 int
1470 xs_transaction_start(struct xs_transaction *t)
1471 {
1472         char *id_str;
1473         int error;
1474
1475         error = xs_single(XST_NIL, XS_TRANSACTION_START, "", NULL,
1476             (void **)&id_str);
1477         if (error == 0) {
1478                 t->id = strtoul(id_str, NULL, 0);
1479                 free(id_str, M_XENSTORE);
1480         }
1481         return (error);
1482 }
1483
1484 int
1485 xs_transaction_end(struct xs_transaction t, int abort)
1486 {
1487         char abortstr[2];
1488
1489         if (abort)
1490                 strcpy(abortstr, "F");
1491         else
1492                 strcpy(abortstr, "T");
1493
1494         return (xs_single(t, XS_TRANSACTION_END, abortstr, NULL, NULL));
1495 }
1496
1497 int
1498 xs_scanf(struct xs_transaction t, const char *dir, const char *node,
1499      int *scancountp, const char *fmt, ...)
1500 {
1501         va_list ap;
1502         int error, ns;
1503         char *val;
1504
1505         error = xs_read(t, dir, node, NULL, (void **) &val);
1506         if (error)
1507                 return (error);
1508
1509         va_start(ap, fmt);
1510         ns = vsscanf(val, fmt, ap);
1511         va_end(ap);
1512         free(val, M_XENSTORE);
1513         /* Distinctive errno. */
1514         if (ns == 0)
1515                 return (ERANGE);
1516         if (scancountp)
1517                 *scancountp = ns;
1518         return (0);
1519 }
1520
1521 int
1522 xs_vprintf(struct xs_transaction t,
1523     const char *dir, const char *node, const char *fmt, va_list ap)
1524 {
1525         struct sbuf *sb;
1526         int error;
1527
1528         sb = sbuf_new_auto();
1529         sbuf_vprintf(sb, fmt, ap);
1530         sbuf_finish(sb);
1531         error = xs_write(t, dir, node, sbuf_data(sb));
1532         sbuf_delete(sb);
1533
1534         return (error);
1535 }
1536
1537 int
1538 xs_printf(struct xs_transaction t, const char *dir, const char *node,
1539      const char *fmt, ...)
1540 {
1541         va_list ap;
1542         int error;
1543
1544         va_start(ap, fmt);
1545         error = xs_vprintf(t, dir, node, fmt, ap);
1546         va_end(ap);
1547
1548         return (error);
1549 }
1550
1551 int
1552 xs_gather(struct xs_transaction t, const char *dir, ...)
1553 {
1554         va_list ap;
1555         const char *name;
1556         int error;
1557
1558         va_start(ap, dir);
1559         error = 0;
1560         while (error == 0 && (name = va_arg(ap, char *)) != NULL) {
1561                 const char *fmt = va_arg(ap, char *);
1562                 void *result = va_arg(ap, void *);
1563                 char *p;
1564
1565                 error = xs_read(t, dir, name, NULL, (void **) &p);
1566                 if (error)
1567                         break;
1568
1569                 if (fmt) {
1570                         if (sscanf(p, fmt, result) == 0)
1571                                 error = EINVAL;
1572                         free(p, M_XENSTORE);
1573                 } else
1574                         *(char **)result = p;
1575         }
1576         va_end(ap);
1577
1578         return (error);
1579 }
1580
1581 int
1582 xs_register_watch(struct xs_watch *watch)
1583 {
1584         /* Pointer in ascii is the token. */
1585         char token[sizeof(watch) * 2 + 1];
1586         int error;
1587
1588         watch->pending = 0;
1589         sprintf(token, "%lX", (long)watch);
1590
1591         mtx_lock(&xs.registered_watches_lock);
1592         KASSERT(find_watch(token) == NULL, ("watch already registered"));
1593         LIST_INSERT_HEAD(&xs.registered_watches, watch, list);
1594         mtx_unlock(&xs.registered_watches_lock);
1595
1596         error = xs_watch(watch->node, token);
1597
1598         /* Ignore errors due to multiple registration. */
1599         if (error == EEXIST)
1600                 error = 0;
1601
1602         if (error != 0) {
1603                 mtx_lock(&xs.registered_watches_lock);
1604                 LIST_REMOVE(watch, list);
1605                 mtx_unlock(&xs.registered_watches_lock);
1606         }
1607
1608         return (error);
1609 }
1610
1611 void
1612 xs_unregister_watch(struct xs_watch *watch)
1613 {
1614         struct xs_stored_msg *msg, *tmp;
1615         char token[sizeof(watch) * 2 + 1];
1616         int error;
1617
1618         sprintf(token, "%lX", (long)watch);
1619
1620         mtx_lock(&xs.registered_watches_lock);
1621         if (find_watch(token) == NULL) {
1622                 mtx_unlock(&xs.registered_watches_lock);
1623                 return;
1624         }
1625         LIST_REMOVE(watch, list);
1626         mtx_unlock(&xs.registered_watches_lock);
1627
1628         error = xs_unwatch(watch->node, token);
1629         if (error)
1630                 log(LOG_WARNING, "XENSTORE Failed to release watch %s: %i\n",
1631                     watch->node, error);
1632
1633         /* Cancel pending watch events. */
1634         mtx_lock(&xs.watch_events_lock);
1635         TAILQ_FOREACH_SAFE(msg, &xs.watch_events, list, tmp) {
1636                 if (msg->u.watch.handle != watch)
1637                         continue;
1638                 TAILQ_REMOVE(&xs.watch_events, msg, list);
1639                 free(msg->u.watch.vec, M_XENSTORE);
1640                 free(msg, M_XENSTORE);
1641         }
1642         mtx_unlock(&xs.watch_events_lock);
1643
1644         /* Flush any currently-executing callback, unless we are it. :-) */
1645         if (curproc->p_pid != xs.xenwatch_pid) {
1646                 sx_xlock(&xs.xenwatch_mutex);
1647                 sx_xunlock(&xs.xenwatch_mutex);
1648         }
1649 }
1650
1651 void
1652 xs_lock(void)
1653 {
1654
1655         sx_xlock(&xs.request_mutex);
1656         return;
1657 }
1658
1659 void
1660 xs_unlock(void)
1661 {
1662
1663         sx_xunlock(&xs.request_mutex);
1664         return;
1665 }
1666