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