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