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                 if (msg->u.watch.handle != NULL) {
 660                         mtx_lock(&xs.watch_events_lock);
 661                         TAILQ_INSERT_TAIL(&xs.watch_events, msg, list);
 662                         wakeup(&xs.watch_events);
 663                         mtx_unlock(&xs.watch_events_lock);
 664                 } else {
 665                         free(msg->u.watch.vec, M_XENSTORE);
 666                         free(msg, M_XENSTORE);
 667                 }
 668                 mtx_unlock(&xs.registered_watches_lock);
 669         } else {
 670                 msg->u.reply.body = body;
 671                 mtx_lock(&xs.reply_lock);
 672                 TAILQ_INSERT_TAIL(&xs.reply_list, msg, list);
 673                 wakeup(&xs.reply_list);
 674                 mtx_unlock(&xs.reply_lock);
 675         }
 676
 677         return (0);
 678 }
 679
 680 /**
 681  * Thread body of the XenStore receive thread.
 682  *
 683  * This thread blocks waiting for data from the XenStore service
 684  * and processes and received messages.
 685  */
 686 static void
 687 xs_rcv_thread(void *arg __unused)
 688 {
 689         int error;
 690         enum xsd_sockmsg_type type;
 691
 692         for (;;) {
 693                 error = xs_process_msg(&type);
 694                 if (error)
 695                         printf("XENSTORE error %d while reading message\n",
 696                             error);
 697         }
 698 }
 699
 700 /*---------------- XenStore Message Request/Reply Processing -----------------*/
 701 #define xsd_error_count (sizeof(xsd_errors) / sizeof(xsd_errors[0]))
 702
 703 /**
 704  * Convert a XenStore error string into an errno number.
 705  *
 706  * \param errorstring  The error string to convert.
 707  *
 708  * \return  The errno best matching the input string.
 709  *
 710  * \note Unknown error strings are converted to EINVAL.
 711  */
 712 static int
 713 xs_get_error(const char *errorstring)
 714 {
 715         u_int i;
 716
 717         for (i = 0; i < xsd_error_count; i++) {
 718                 if (!strcmp(errorstring, xsd_errors[i].errstring))
 719                         return (xsd_errors[i].errnum);
 720         }
 721         log(LOG_WARNING, "XENSTORE xen store gave: unknown error %s",
 722             errorstring);
 723         return (EINVAL);
 724 }
 725
 726 /**
 727  * Block waiting for a reply to a message request.
 728  *
 729  * \param type    The returned type of the reply.
 730  * \param len     The returned body length of the reply.
 731  * \param result  The returned body of the reply.
 732  *
 733  * \return  0 on success.  Otherwise an errno indicating the
 734  *          cause of failure.
 735  */
 736 static int
 737 xs_read_reply(enum xsd_sockmsg_type *type, u_int *len, void **result)
 738 {
 739         struct xs_stored_msg *msg;
 740         char *body;
 741         int error;
 742
 743         mtx_lock(&xs.reply_lock);
 744         while (TAILQ_EMPTY(&xs.reply_list)) {
 745                 error = mtx_sleep(&xs.reply_list, &xs.reply_lock, 0, "xswait",
 746                     hz/10);
 747                 if (error && error != EWOULDBLOCK) {
 748                         mtx_unlock(&xs.reply_lock);
 749                         return (error);
 750                 }
 751         }
 752         msg = TAILQ_FIRST(&xs.reply_list);
 753         TAILQ_REMOVE(&xs.reply_list, msg, list);
 754         mtx_unlock(&xs.reply_lock);
 755
 756         *type = msg->hdr.type;
 757         if (len)
 758                 *len = msg->hdr.len;
 759         body = msg->u.reply.body;
 760
 761         free(msg, M_XENSTORE);
 762         *result = body;
 763         return (0);
 764 }
 765
 766 /**
 767  * Pass-thru interface for XenStore access by userland processes
 768  * via the XenStore device.
 769  *
 770  * Reply type and length data are returned by overwriting these
 771  * fields in the passed in request message.
 772  *
 773  * \param msg     A properly formatted message to transmit to
 774  *                the XenStore service.
 775  * \param result  The returned body of the reply.
 776  *
 777  * \return  0 on success.  Otherwise an errno indicating the cause
 778  *          of failure.
 779  *
 780  * \note The returned result is provided in malloced storage and thus
 781  *       must be free'd by the caller with 'free(result, M_XENSTORE);
 782  */
 783 int
 784 xs_dev_request_and_reply(struct xsd_sockmsg *msg, void **result)
 785 {
 786         uint32_t request_type;
 787         int error;
 788
 789         request_type = msg->type;
 790
 791         sx_xlock(&xs.request_mutex);
 792         if ((error = xs_write_store(msg, sizeof(*msg) + msg->len)) == 0)
 793                 error = xs_read_reply(&msg->type, &msg->len, result);
 794         sx_xunlock(&xs.request_mutex);
 795
 796         return (error);
 797 }
 798
 799 /**
 800  * Send a message with an optionally muti-part body to the XenStore service.
 801  *
 802  * \param t              The transaction to use for this request.
 803  * \param request_type   The type of message to send.
 804  * \param iovec          Pointers to the body sections of the request.
 805  * \param num_vecs       The number of body sections in the request.
 806  * \param len            The returned length of the reply.
 807  * \param result         The returned body of the reply.
 808  *
 809  * \return  0 on success.  Otherwise an errno indicating
 810  *          the cause of failure.
 811  *
 812  * \note The returned result is provided in malloced storage and thus
 813  *       must be free'd by the caller with 'free(*result, M_XENSTORE);
 814  */
 815 static int
 816 xs_talkv(struct xs_transaction t, enum xsd_sockmsg_type request_type,
 817     const struct iovec *iovec, u_int num_vecs, u_int *len, void **result)
 818 {
 819         struct xsd_sockmsg msg;
 820         void *ret = NULL;
 821         u_int i;
 822         int error;
 823
 824         msg.tx_id = t.id;
 825         msg.req_id = 0;
 826         msg.type = request_type;
 827         msg.len = 0;
 828         for (i = 0; i < num_vecs; i++)
 829                 msg.len += iovec[i].iov_len;
 830
 831         sx_xlock(&xs.request_mutex);
 832         error = xs_write_store(&msg, sizeof(msg));
 833         if (error) {
 834                 printf("xs_talkv failed %d\n", error);
 835                 goto error_lock_held;
 836         }
 837
 838         for (i = 0; i < num_vecs; i++) {
 839                 error = xs_write_store(iovec[i].iov_base, iovec[i].iov_len);
 840                 if (error) {
 841                         printf("xs_talkv failed %d\n", error);
 842                         goto error_lock_held;
 843                 }
 844         }
 845
 846         error = xs_read_reply(&msg.type, len, &ret);
 847
 848 error_lock_held:
 849         sx_xunlock(&xs.request_mutex);
 850         if (error)
 851                 return (error);
 852
 853         if (msg.type == XS_ERROR) {
 854                 error = xs_get_error(ret);
 855                 free(ret, M_XENSTORE);
 856                 return (error);
 857         }
 858
 859         /* Reply is either error or an echo of our request message type. */
 860         KASSERT(msg.type == request_type, ("bad xenstore message type"));
 861
 862         if (result)
 863                 *result = ret;
 864         else
 865                 free(ret, M_XENSTORE);
 866
 867         return (0);
 868 }
 869
 870 /**
 871  * Wrapper for xs_talkv allowing easy transmission of a message with
 872  * a single, contiguous, message body.
 873  *
 874  * \param t              The transaction to use for this request.
 875  * \param request_type   The type of message to send.
 876  * \param body           The body of the request.
 877  * \param len            The returned length of the reply.
 878  * \param result         The returned body of the reply.
 879  *
 880  * \return  0 on success.  Otherwise an errno indicating
 881  *          the cause of failure.
 882  *
 883  * \note The returned result is provided in malloced storage and thus
 884  *       must be free'd by the caller with 'free(*result, M_XENSTORE);
 885  */
 886 static int
 887 xs_single(struct xs_transaction t, enum xsd_sockmsg_type request_type,
 888     const char *body, u_int *len, void **result)
 889 {
 890         struct iovec iovec;
 891
 892         iovec.iov_base = (void *)(uintptr_t)body;
 893         iovec.iov_len = strlen(body) + 1;
 894
 895         return (xs_talkv(t, request_type, &iovec, 1, len, result));
 896 }
 897
 898 /*------------------------- XenStore Watch Support ---------------------------*/
 899 /**
 900  * Transmit a watch request to the XenStore service.
 901  *
 902  * \param path    The path in the XenStore to watch.
 903  * \param tocken  A unique identifier for this watch.
 904  *
 905  * \return  0 on success.  Otherwise an errno indicating the
 906  *          cause of failure.
 907  */
 908 static int
 909 xs_watch(const char *path, const char *token)
 910 {
 911         struct iovec iov[2];
 912
 913         iov[0].iov_base = (void *)(uintptr_t) path;
 914         iov[0].iov_len = strlen(path) + 1;
 915         iov[1].iov_base = (void *)(uintptr_t) token;
 916         iov[1].iov_len = strlen(token) + 1;
 917
 918         return (xs_talkv(XST_NIL, XS_WATCH, iov, 2, NULL, NULL));
 919 }
 920
 921 /**
 922  * Transmit an uwatch request to the XenStore service.
 923  *
 924  * \param path    The path in the XenStore to watch.
 925  * \param tocken  A unique identifier for this watch.
 926  *
 927  * \return  0 on success.  Otherwise an errno indicating the
 928  *          cause of failure.
 929  */
 930 static int
 931 xs_unwatch(const char *path, const char *token)
 932 {
 933         struct iovec iov[2];
 934
 935         iov[0].iov_base = (void *)(uintptr_t) path;
 936         iov[0].iov_len = strlen(path) + 1;
 937         iov[1].iov_base = (void *)(uintptr_t) token;
 938         iov[1].iov_len = strlen(token) + 1;
 939
 940         return (xs_talkv(XST_NIL, XS_UNWATCH, iov, 2, NULL, NULL));
 941 }
 942
 943 /**
 944  * Convert from watch token (unique identifier) to the associated
 945  * internal tracking structure for this watch.
 946  *
 947  * \param tocken  The unique identifier for the watch to find.
 948  *
 949  * \return  A pointer to the found watch structure or NULL.
 950  */
 951 static struct xs_watch *
 952 find_watch(const char *token)
 953 {
 954         struct xs_watch *i, *cmp;
 955
 956         cmp = (void *)strtoul(token, NULL, 16);
 957
 958         LIST_FOREACH(i, &xs.registered_watches, list)
 959                 if (i == cmp)
 960                         return (i);
 961
 962         return (NULL);
 963 }
 964
 965 /**
 966  * Thread body of the XenStore watch event dispatch thread.
 967  */
 968 static void
 969 xenwatch_thread(void *unused)
 970 {
 971         struct xs_stored_msg *msg;
 972
 973         for (;;) {
 974
 975                 mtx_lock(&xs.watch_events_lock);
 976                 while (TAILQ_EMPTY(&xs.watch_events))
 977                         mtx_sleep(&xs.watch_events,
 978                             &xs.watch_events_lock,
 979                             PWAIT | PCATCH, "waitev", hz/10);
 980
 981                 mtx_unlock(&xs.watch_events_lock);
 982                 sx_xlock(&xs.xenwatch_mutex);
 983
 984                 mtx_lock(&xs.watch_events_lock);
 985                 msg = TAILQ_FIRST(&xs.watch_events);
 986                 if (msg)
 987                         TAILQ_REMOVE(&xs.watch_events, msg, list);
 988                 mtx_unlock(&xs.watch_events_lock);
 989
 990                 if (msg != NULL) {
 991                         /*
 992                          * XXX There are messages coming in with a NULL
 993                          * XXX callback.  This deserves further investigation;
 994                          * XXX the workaround here simply prevents the kernel
 995                          * XXX from panic'ing on startup.
 996                          */
 997                         if (msg->u.watch.handle->callback != NULL)
 998                                 msg->u.watch.handle->callback(
 999                                         msg->u.watch.handle,
1000                                         (const char **)msg->u.watch.vec,
1001                                         msg->u.watch.vec_size);
1002                         free(msg->u.watch.vec, M_XENSTORE);
1003                         free(msg, M_XENSTORE);
1004                 }
1005
1006                 sx_xunlock(&xs.xenwatch_mutex);
1007         }
1008 }
1009
1010 /*----------- XenStore Configuration, Initialization, and Control ------------*/
1011 /**
1012  * Setup communication channels with the XenStore service.
1013  *
1014  * \return  On success, 0. Otherwise an errno value indicating the
1015  *          type of failure.
1016  */
1017 static int
1018 xs_init_comms(void)
1019 {
1020         int error;
1021
1022         if (xen_store->rsp_prod != xen_store->rsp_cons) {
1023                 log(LOG_WARNING, "XENSTORE response ring is not quiescent "
1024                     "(%08x:%08x): fixing up\n",
1025                     xen_store->rsp_cons, xen_store->rsp_prod);
1026                 xen_store->rsp_cons = xen_store->rsp_prod;
1027         }
1028
1029         xen_intr_unbind(&xs.xen_intr_handle);
1030
1031         error = xen_intr_bind_local_port(xs.xs_dev, xs.evtchn,
1032             /*filter*/NULL, xs_intr, /*arg*/NULL, INTR_TYPE_NET|INTR_MPSAFE,
1033             &xs.xen_intr_handle);
1034         if (error) {
1035                 log(LOG_WARNING, "XENSTORE request irq failed %i\n", error);
1036                 return (error);
1037         }
1038
1039         return (0);
1040 }
1041
1042 /*------------------ Private Device Attachment Functions  --------------------*/
1043 static void
1044 xs_identify(driver_t *driver, device_t parent)
1045 {
1046
1047         BUS_ADD_CHILD(parent, 0, "xenstore", 0);
1048 }
1049
1050 /**
1051  * Probe for the existence of the XenStore.
1052  *
1053  * \param dev
1054  */
1055 static int
1056 xs_probe(device_t dev)
1057 {
1058         /*
1059          * We are either operating within a PV kernel or being probed
1060          * as the child of the successfully attached xenpci device.
1061          * Thus we are in a Xen environment and there will be a XenStore.
1062          * Unconditionally return success.
1063          */
1064         device_set_desc(dev, "XenStore");
1065         return (BUS_PROBE_NOWILDCARD);
1066 }
1067
1068 static void
1069 xs_attach_deferred(void *arg)
1070 {
1071
1072         bus_generic_probe(xs.xs_dev);
1073         bus_generic_attach(xs.xs_dev);
1074
1075         config_intrhook_disestablish(&xs.xs_attachcb);
1076 }
1077
1078 static void
1079 xs_attach_late(void *arg, int pending)
1080 {
1081
1082         KASSERT((pending == 1), ("xs late attach queued several times"));
1083         bus_generic_probe(xs.xs_dev);
1084         bus_generic_attach(xs.xs_dev);
1085 }
1086
1087 /**
1088  * Attach to the XenStore.
1089  *
1090  * This routine also prepares for the probe/attach of drivers that rely
1091  * on the XenStore.
1092  */
1093 static int
1094 xs_attach(device_t dev)
1095 {
1096         int error;
1097
1098         /* Allow us to get device_t from softc and vice-versa. */
1099         xs.xs_dev = dev;
1100         device_set_softc(dev, &xs);
1101
1102         /* Initialize the interface to xenstore. */
1103         struct proc *p;
1104
1105         xs.initialized = false;
1106         xs.evtchn = xen_get_xenstore_evtchn();
1107         if (xs.evtchn == 0) {
1108                 struct evtchn_alloc_unbound alloc_unbound;
1109
1110                 /* Allocate a local event channel for xenstore */
1111                 alloc_unbound.dom = DOMID_SELF;
1112                 alloc_unbound.remote_dom = DOMID_SELF;
1113                 error = HYPERVISOR_event_channel_op(
1114                     EVTCHNOP_alloc_unbound, &alloc_unbound);
1115                 if (error != 0)
1116                         panic(
1117                            "unable to alloc event channel for Dom0: %d",
1118                             error);
1119
1120                 xs.evtchn = alloc_unbound.port;
1121
1122                 /* Allocate memory for the xs shared ring */
1123                 xen_store = malloc(PAGE_SIZE, M_XENSTORE, M_WAITOK | M_ZERO);
1124                 xs.gpfn = atop(pmap_kextract((vm_offset_t)xen_store));
1125         } else {
1126                 xs.gpfn = xen_get_xenstore_mfn();
1127                 xen_store = pmap_mapdev_attr(ptoa(xs.gpfn), PAGE_SIZE,
1128                     PAT_WRITE_BACK);
1129                 xs.initialized = true;
1130         }
1131
1132         TAILQ_INIT(&xs.reply_list);
1133         TAILQ_INIT(&xs.watch_events);
1134
1135         mtx_init(&xs.ring_lock, "ring lock", NULL, MTX_DEF);
1136         mtx_init(&xs.reply_lock, "reply lock", NULL, MTX_DEF);
1137         sx_init(&xs.xenwatch_mutex, "xenwatch");
1138         sx_init(&xs.request_mutex, "xenstore request");
1139         mtx_init(&xs.registered_watches_lock, "watches", NULL, MTX_DEF);
1140         mtx_init(&xs.watch_events_lock, "watch events", NULL, MTX_DEF);
1141
1142         /* Initialize the shared memory rings to talk to xenstored */
1143         error = xs_init_comms();
1144         if (error)
1145                 return (error);
1146
1147         error = kproc_create(xenwatch_thread, NULL, &p, RFHIGHPID,
1148             0, "xenwatch");
1149         if (error)
1150                 return (error);
1151         xs.xenwatch_pid = p->p_pid;
1152
1153         error = kproc_create(xs_rcv_thread, NULL, NULL,
1154             RFHIGHPID, 0, "xenstore_rcv");
1155
1156         xs.xs_attachcb.ich_func = xs_attach_deferred;
1157         xs.xs_attachcb.ich_arg = NULL;
1158         if (xs.initialized) {
1159                 config_intrhook_establish(&xs.xs_attachcb);
1160         } else {
1161                 TASK_INIT(&xs.xs_late_init, 0, xs_attach_late, NULL);
1162         }
1163
1164         return (error);
1165 }
1166
1167 /**
1168  * Prepare for suspension of this VM by halting XenStore access after
1169  * all transactions and individual requests have completed.
1170  */
1171 static int
1172 xs_suspend(device_t dev)
1173 {
1174         int error;
1175
1176         /* Suspend child Xen devices. */
1177         error = bus_generic_suspend(dev);
1178         if (error != 0)
1179                 return (error);
1180
1181         sx_xlock(&xs.request_mutex);
1182
1183         return (0);
1184 }
1185
1186 /**
1187  * Resume XenStore operations after this VM is resumed.
1188  */
1189 static int
1190 xs_resume(device_t dev __unused)
1191 {
1192         struct xs_watch *watch;
1193         char token[sizeof(watch) * 2 + 1];
1194
1195         xs_init_comms();
1196
1197         sx_xunlock(&xs.request_mutex);
1198
1199         /*
1200          * NB: since xenstore childs have not been resumed yet, there's
1201          * no need to hold any watch mutex. Having clients try to add or
1202          * remove watches at this point (before xenstore is resumed) is
1203          * clearly a violantion of the resume order.
1204          */
1205         LIST_FOREACH(watch, &xs.registered_watches, list) {
1206                 sprintf(token, "%lX", (long)watch);
1207                 xs_watch(watch->node, token);
1208         }
1209
1210         /* Resume child Xen devices. */
1211         bus_generic_resume(dev);
1212
1213         return (0);
1214 }
1215
1216 /*-------------------- Private Device Attachment Data  -----------------------*/
1217 static device_method_t xenstore_methods[] = {
1218         /* Device interface */
1219         DEVMETHOD(device_identify,      xs_identify),
1220         DEVMETHOD(device_probe,         xs_probe),
1221         DEVMETHOD(device_attach,        xs_attach),
1222         DEVMETHOD(device_detach,        bus_generic_detach),
1223         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
1224         DEVMETHOD(device_suspend,       xs_suspend),
1225         DEVMETHOD(device_resume,        xs_resume),
1226
1227         /* Bus interface */
1228         DEVMETHOD(bus_add_child,        bus_generic_add_child),
1229         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
1230         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
1231         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
1232         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
1233
1234         DEVMETHOD_END
1235 };
1236
1237 DEFINE_CLASS_0(xenstore, xenstore_driver, xenstore_methods, 0);
1238 static devclass_t xenstore_devclass;
1239
1240 DRIVER_MODULE(xenstore, xenpv, xenstore_driver, xenstore_devclass, 0, 0);
1241
1242 /*------------------------------- Sysctl Data --------------------------------*/
1243 /* XXX Shouldn't the node be somewhere else? */
1244 SYSCTL_NODE(_dev, OID_AUTO, xen, CTLFLAG_RD, NULL, "Xen");
1245 SYSCTL_INT(_dev_xen, OID_AUTO, xsd_port, CTLFLAG_RD, &xs.evtchn, 0, "");
1246 SYSCTL_ULONG(_dev_xen, OID_AUTO, xsd_kva, CTLFLAG_RD, (u_long *) &xen_store, 0, "");
1247
1248 /*-------------------------------- Public API --------------------------------*/
1249 /*------- API comments for these methods can be found in xenstorevar.h -------*/
1250 bool
1251 xs_initialized(void)
1252 {
1253
1254         return (xs.initialized);
1255 }
1256
1257 evtchn_port_t
1258 xs_evtchn(void)
1259 {
1260
1261     return (xs.evtchn);
1262 }
1263
1264 vm_paddr_t
1265 xs_address(void)
1266 {
1267
1268     return (ptoa(xs.gpfn));
1269 }
1270
1271 int
1272 xs_directory(struct xs_transaction t, const char *dir, const char *node,
1273     u_int *num, const char ***result)
1274 {
1275         struct sbuf *path;
1276         char *strings;
1277         u_int len = 0;
1278         int error;
1279
1280         path = xs_join(dir, node);
1281         error = xs_single(t, XS_DIRECTORY, sbuf_data(path), &len,
1282             (void **)&strings);
1283         sbuf_delete(path);
1284         if (error)
1285                 return (error);
1286
1287         *result = split(strings, len, num);
1288
1289         return (0);
1290 }
1291
1292 int
1293 xs_exists(struct xs_transaction t, const char *dir, const char *node)
1294 {
1295         const char **d;
1296         int error, dir_n;
1297
1298         error = xs_directory(t, dir, node, &dir_n, &d);
1299         if (error)
1300                 return (0);
1301         free(d, M_XENSTORE);
1302         return (1);
1303 }
1304
1305 int
1306 xs_read(struct xs_transaction t, const char *dir, const char *node,
1307     u_int *len, void **result)
1308 {
1309         struct sbuf *path;
1310         void *ret;
1311         int error;
1312
1313         path = xs_join(dir, node);
1314         error = xs_single(t, XS_READ, sbuf_data(path), len, &ret);
1315         sbuf_delete(path);
1316         if (error)
1317                 return (error);
1318         *result = ret;
1319         return (0);
1320 }
1321
1322 int
1323 xs_write(struct xs_transaction t, const char *dir, const char *node,
1324     const char *string)
1325 {
1326         struct sbuf *path;
1327         struct iovec iovec[2];
1328         int error;
1329
1330         path = xs_join(dir, node);
1331
1332         iovec[0].iov_base = (void *)(uintptr_t) sbuf_data(path);
1333         iovec[0].iov_len = sbuf_len(path) + 1;
1334         iovec[1].iov_base = (void *)(uintptr_t) string;
1335         iovec[1].iov_len = strlen(string);
1336
1337         error = xs_talkv(t, XS_WRITE, iovec, 2, NULL, NULL);
1338         sbuf_delete(path);
1339
1340         return (error);
1341 }
1342
1343 int
1344 xs_mkdir(struct xs_transaction t, const char *dir, const char *node)
1345 {
1346         struct sbuf *path;
1347         int ret;
1348
1349         path = xs_join(dir, node);
1350         ret = xs_single(t, XS_MKDIR, sbuf_data(path), NULL, NULL);
1351         sbuf_delete(path);
1352
1353         return (ret);
1354 }
1355
1356 int
1357 xs_rm(struct xs_transaction t, const char *dir, const char *node)
1358 {
1359         struct sbuf *path;
1360         int ret;
1361
1362         path = xs_join(dir, node);
1363         ret = xs_single(t, XS_RM, sbuf_data(path), NULL, NULL);
1364         sbuf_delete(path);
1365
1366         return (ret);
1367 }
1368
1369 int
1370 xs_rm_tree(struct xs_transaction xbt, const char *base, const char *node)
1371 {
1372         struct xs_transaction local_xbt;
1373         struct sbuf *root_path_sbuf;
1374         struct sbuf *cur_path_sbuf;
1375         char *root_path;
1376         char *cur_path;
1377         const char **dir;
1378         int error;
1379
1380 retry:
1381         root_path_sbuf = xs_join(base, node);
1382         cur_path_sbuf  = xs_join(base, node);
1383         root_path      = sbuf_data(root_path_sbuf);
1384         cur_path       = sbuf_data(cur_path_sbuf);
1385         dir            = NULL;
1386         local_xbt.id   = 0;
1387
1388         if (xbt.id == 0) {
1389                 error = xs_transaction_start(&local_xbt);
1390                 if (error != 0)
1391                         goto out;
1392                 xbt = local_xbt;
1393         }
1394
1395         while (1) {
1396                 u_int count;
1397                 u_int i;
1398
1399                 error = xs_directory(xbt, cur_path, "", &count, &dir);
1400                 if (error)
1401                         goto out;
1402
1403                 for (i = 0; i < count; i++) {
1404                         error = xs_rm(xbt, cur_path, dir[i]);
1405                         if (error == ENOTEMPTY) {
1406                                 struct sbuf *push_dir;
1407
1408                                 /*
1409                                  * Descend to clear out this sub directory.
1410                                  * We'll return to cur_dir once push_dir
1411                                  * is empty.
1412                                  */
1413                                 push_dir = xs_join(cur_path, dir[i]);
1414                                 sbuf_delete(cur_path_sbuf);
1415                                 cur_path_sbuf = push_dir;
1416                                 cur_path = sbuf_data(cur_path_sbuf);
1417                                 break;
1418                         } else if (error != 0) {
1419                                 goto out;
1420                         }
1421                 }
1422
1423                 free(dir, M_XENSTORE);
1424                 dir = NULL;
1425
1426                 if (i == count) {
1427                         char *last_slash;
1428
1429                         /* Directory is empty.  It is now safe to remove. */
1430                         error = xs_rm(xbt, cur_path, "");
1431                         if (error != 0)
1432                                 goto out;
1433
1434                         if (!strcmp(cur_path, root_path))
1435                                 break;
1436
1437                         /* Return to processing the parent directory. */
1438                         last_slash = strrchr(cur_path, '/');
1439                         KASSERT(last_slash != NULL,
1440                                 ("xs_rm_tree: mangled path %s", cur_path));
1441                         *last_slash = '\0';
1442                 }
1443         }
1444
1445 out:
1446         sbuf_delete(cur_path_sbuf);
1447         sbuf_delete(root_path_sbuf);
1448         if (dir != NULL)
1449                 free(dir, M_XENSTORE);
1450
1451         if (local_xbt.id != 0) {
1452                 int terror;
1453
1454                 terror = xs_transaction_end(local_xbt, /*abort*/error != 0);
1455                 xbt.id = 0;
1456                 if (terror == EAGAIN && error == 0)
1457                         goto retry;
1458         }
1459         return (error);
1460 }
1461
1462 int
1463 xs_transaction_start(struct xs_transaction *t)
1464 {
1465         char *id_str;
1466         int error;
1467
1468         error = xs_single(XST_NIL, XS_TRANSACTION_START, "", NULL,
1469             (void **)&id_str);
1470         if (error == 0) {
1471                 t->id = strtoul(id_str, NULL, 0);
1472                 free(id_str, M_XENSTORE);
1473         }
1474         return (error);
1475 }
1476
1477 int
1478 xs_transaction_end(struct xs_transaction t, int abort)
1479 {
1480         char abortstr[2];
1481
1482         if (abort)
1483                 strcpy(abortstr, "F");
1484         else
1485                 strcpy(abortstr, "T");
1486
1487         return (xs_single(t, XS_TRANSACTION_END, abortstr, NULL, NULL));
1488 }
1489
1490 int
1491 xs_scanf(struct xs_transaction t, const char *dir, const char *node,
1492      int *scancountp, const char *fmt, ...)
1493 {
1494         va_list ap;
1495         int error, ns;
1496         char *val;
1497
1498         error = xs_read(t, dir, node, NULL, (void **) &val);
1499         if (error)
1500                 return (error);
1501
1502         va_start(ap, fmt);
1503         ns = vsscanf(val, fmt, ap);
1504         va_end(ap);
1505         free(val, M_XENSTORE);
1506         /* Distinctive errno. */
1507         if (ns == 0)
1508                 return (ERANGE);
1509         if (scancountp)
1510                 *scancountp = ns;
1511         return (0);
1512 }
1513
1514 int
1515 xs_vprintf(struct xs_transaction t,
1516     const char *dir, const char *node, const char *fmt, va_list ap)
1517 {
1518         struct sbuf *sb;
1519         int error;
1520
1521         sb = sbuf_new_auto();
1522         sbuf_vprintf(sb, fmt, ap);
1523         sbuf_finish(sb);
1524         error = xs_write(t, dir, node, sbuf_data(sb));
1525         sbuf_delete(sb);
1526
1527         return (error);
1528 }
1529
1530 int
1531 xs_printf(struct xs_transaction t, const char *dir, const char *node,
1532      const char *fmt, ...)
1533 {
1534         va_list ap;
1535         int error;
1536
1537         va_start(ap, fmt);
1538         error = xs_vprintf(t, dir, node, fmt, ap);
1539         va_end(ap);
1540
1541         return (error);
1542 }
1543
1544 int
1545 xs_gather(struct xs_transaction t, const char *dir, ...)
1546 {
1547         va_list ap;
1548         const char *name;
1549         int error;
1550
1551         va_start(ap, dir);
1552         error = 0;
1553         while (error == 0 && (name = va_arg(ap, char *)) != NULL) {
1554                 const char *fmt = va_arg(ap, char *);
1555                 void *result = va_arg(ap, void *);
1556                 char *p;
1557
1558                 error = xs_read(t, dir, name, NULL, (void **) &p);
1559                 if (error)
1560                         break;
1561
1562                 if (fmt) {
1563                         if (sscanf(p, fmt, result) == 0)
1564                                 error = EINVAL;
1565                         free(p, M_XENSTORE);
1566                 } else
1567                         *(char **)result = p;
1568         }
1569         va_end(ap);
1570
1571         return (error);
1572 }
1573
1574 int
1575 xs_register_watch(struct xs_watch *watch)
1576 {
1577         /* Pointer in ascii is the token. */
1578         char token[sizeof(watch) * 2 + 1];
1579         int error;
1580
1581         sprintf(token, "%lX", (long)watch);
1582
1583         mtx_lock(&xs.registered_watches_lock);
1584         KASSERT(find_watch(token) == NULL, ("watch already registered"));
1585         LIST_INSERT_HEAD(&xs.registered_watches, watch, list);
1586         mtx_unlock(&xs.registered_watches_lock);
1587
1588         error = xs_watch(watch->node, token);
1589
1590         /* Ignore errors due to multiple registration. */
1591         if (error == EEXIST)
1592                 error = 0;
1593
1594         if (error != 0) {
1595                 mtx_lock(&xs.registered_watches_lock);
1596                 LIST_REMOVE(watch, list);
1597                 mtx_unlock(&xs.registered_watches_lock);
1598         }
1599
1600         return (error);
1601 }
1602
1603 void
1604 xs_unregister_watch(struct xs_watch *watch)
1605 {
1606         struct xs_stored_msg *msg, *tmp;
1607         char token[sizeof(watch) * 2 + 1];
1608         int error;
1609
1610         sprintf(token, "%lX", (long)watch);
1611
1612         mtx_lock(&xs.registered_watches_lock);
1613         if (find_watch(token) == NULL) {
1614                 mtx_unlock(&xs.registered_watches_lock);
1615                 return;
1616         }
1617         LIST_REMOVE(watch, list);
1618         mtx_unlock(&xs.registered_watches_lock);
1619
1620         error = xs_unwatch(watch->node, token);
1621         if (error)
1622                 log(LOG_WARNING, "XENSTORE Failed to release watch %s: %i\n",
1623                     watch->node, error);
1624
1625         /* Cancel pending watch events. */
1626         mtx_lock(&xs.watch_events_lock);
1627         TAILQ_FOREACH_SAFE(msg, &xs.watch_events, list, tmp) {
1628                 if (msg->u.watch.handle != watch)
1629                         continue;
1630                 TAILQ_REMOVE(&xs.watch_events, msg, list);
1631                 free(msg->u.watch.vec, M_XENSTORE);
1632                 free(msg, M_XENSTORE);
1633         }
1634         mtx_unlock(&xs.watch_events_lock);
1635
1636         /* Flush any currently-executing callback, unless we are it. :-) */
1637         if (curproc->p_pid != xs.xenwatch_pid) {
1638                 sx_xlock(&xs.xenwatch_mutex);
1639                 sx_xunlock(&xs.xenwatch_mutex);
1640         }
1641 }
1642
1643 void
1644 xs_lock(void)
1645 {
1646
1647         sx_xlock(&xs.request_mutex);
1648         return;
1649 }
1650
1651 void
1652 xs_unlock(void)
1653 {
1654
1655         sx_xunlock(&xs.request_mutex);
1656         return;
1657 }
1658