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