1 /******************************************************************************
2 * Copyright (C) 2005 XenSource Ltd
4 * This file may be distributed separately from the Linux kernel, or
5 * incorporated into other software packages, subject to the following license:
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this source file (the "Software"), to deal in the Software without
9 * restriction, including without limitation the rights to use, copy, modify,
10 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
11 * and to permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
29 * \brief Client-facing interface for the Xenbus driver.
31 * In other words, the interface between the Xenbus and the device-specific
32 * code, be it the frontend or the backend of that driver.
36 #define DPRINTK(fmt, args...) \
37 printk("xenbus_client (%s:%d) " fmt ".\n", __FUNCTION__, __LINE__, ##args)
39 #define DPRINTK(fmt, args...) ((void)0)
42 #include <sys/cdefs.h>
43 __FBSDID("$FreeBSD$");
45 #include <sys/cdefs.h>
46 #include <sys/param.h>
47 #include <sys/kernel.h>
48 #include <sys/types.h>
49 #include <sys/malloc.h>
50 #include <sys/libkern.h>
53 #include <xen/xen-os.h>
54 #include <xen/hypervisor.h>
55 #include <xen/evtchn.h>
56 #include <xen/gnttab.h>
57 #include <xen/xenbus/xenbusvar.h>
59 #include <machine/stdarg.h>
61 MALLOC_DEFINE(M_XENBUS, "xenbus", "XenBus Support");
63 /*------------------------- Private Functions --------------------------------*/
65 * \brief Construct the error path corresponding to the given XenBus
68 * \param dev The XenBus device for which we are constructing an error path.
70 * \return On success, the contructed error path. Otherwise NULL.
72 * It is the caller's responsibility to free any returned error path
73 * node using the M_XENBUS malloc type.
76 error_path(device_t dev)
78 char *path_buffer = malloc(strlen("error/")
79 + strlen(xenbus_get_node(dev)) + 1,M_XENBUS, M_WAITOK);
81 strcpy(path_buffer, "error/");
82 strcpy(path_buffer + strlen("error/"), xenbus_get_node(dev));
87 /*--------------------------- Public Functions -------------------------------*/
88 /*-------- API comments for these methods can be found in xenbusvar.h --------*/
90 xenbus_strstate(XenbusState state)
92 static const char *const name[] = {
93 [ XenbusStateUnknown ] = "Unknown",
94 [ XenbusStateInitialising ] = "Initialising",
95 [ XenbusStateInitWait ] = "InitWait",
96 [ XenbusStateInitialised ] = "Initialised",
97 [ XenbusStateConnected ] = "Connected",
98 [ XenbusStateClosing ] = "Closing",
99 [ XenbusStateClosed ] = "Closed",
102 return ((state < (XenbusStateClosed + 1)) ? name[state] : "INVALID");
106 xenbus_watch_path(device_t dev, char *path, struct xs_watch *watch,
107 xs_watch_cb_t *callback, uintptr_t callback_data)
112 watch->callback = callback;
113 watch->callback_data = callback_data;
115 error = xs_register_watch(watch);
119 watch->callback = NULL;
120 xenbus_dev_fatal(dev, error, "adding watch on %s", path);
127 xenbus_watch_path2(device_t dev, const char *path,
128 const char *path2, struct xs_watch *watch,
129 xs_watch_cb_t *callback, uintptr_t callback_data)
132 char *state = malloc(strlen(path) + 1 + strlen(path2) + 1,
137 strcat(state, path2);
139 error = xenbus_watch_path(dev, state, watch, callback, callback_data);
141 free(state,M_XENBUS);
148 xenbus_dev_verror(device_t dev, int err, const char *fmt, va_list ap)
152 char *printf_buffer = NULL, *path_buffer = NULL;
154 #define PRINTF_BUFFER_SIZE 4096
155 printf_buffer = malloc(PRINTF_BUFFER_SIZE,M_XENBUS, M_WAITOK);
157 len = sprintf(printf_buffer, "%i ", err);
158 ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
160 KASSERT(len + ret <= PRINTF_BUFFER_SIZE-1, ("xenbus error message too big"));
161 device_printf(dev, "Error %s\n", printf_buffer);
162 path_buffer = error_path(dev);
164 if (path_buffer == NULL) {
165 printf("xenbus: failed to write error node for %s (%s)\n",
166 xenbus_get_node(dev), printf_buffer);
170 if (xs_write(XST_NIL, path_buffer, "error", printf_buffer) != 0) {
171 printf("xenbus: failed to write error node for %s (%s)\n",
172 xenbus_get_node(dev), printf_buffer);
178 free(printf_buffer,M_XENBUS);
180 free(path_buffer,M_XENBUS);
184 xenbus_dev_error(device_t dev, int err, const char *fmt, ...)
189 xenbus_dev_verror(dev, err, fmt, ap);
194 xenbus_dev_vfatal(device_t dev, int err, const char *fmt, va_list ap)
196 xenbus_dev_verror(dev, err, fmt, ap);
197 device_printf(dev, "Fatal error. Transitioning to Closing State\n");
198 xenbus_set_state(dev, XenbusStateClosing);
202 xenbus_dev_fatal(device_t dev, int err, const char *fmt, ...)
207 xenbus_dev_vfatal(dev, err, fmt, ap);
212 xenbus_grant_ring(device_t dev, unsigned long ring_mfn, grant_ref_t *refp)
216 error = gnttab_grant_foreign_access(
217 xenbus_get_otherend_id(dev), ring_mfn, 0, refp);
219 xenbus_dev_fatal(dev, error, "granting access to ring page");
227 xenbus_read_driver_state(const char *path)
232 error = xs_gather(XST_NIL, path, "state", "%d", &result, NULL);
234 result = XenbusStateClosed;
240 xenbus_dev_is_online(device_t dev)
246 path = xenbus_get_node(dev);
247 error = xs_gather(XST_NIL, path, "online", "%d", &value, NULL);
249 /* Default to not online. */
257 xenbus_localend_changed(device_t dev, const char *path)