1 /******************************************************************************
2 * Client-facing interface for the Xenbus driver. In other words, the
3 * interface between the Xenbus and the device-specific code, be it the
4 * frontend or the backend of that driver.
6 * Copyright (C) 2005 XenSource Ltd
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version 2
10 * as published by the Free Software Foundation; or, when distributed
11 * separately from the Linux kernel or incorporated into other
12 * software packages, subject to the following license:
14 * Permission is hereby granted, free of charge, to any person obtaining a copy
15 * of this source file (the "Software"), to deal in the Software without
16 * restriction, including without limitation the rights to use, copy, modify,
17 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
18 * and to permit persons to whom the Software is furnished to do so, subject to
19 * the following conditions:
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
33 #include <xen/evtchn.h>
34 #include <xen/gnttab.h>
35 #include <xen/xenbus.h>
36 #include <xen/driver_util.h>
39 extern char *kasprintf(const char *fmt, ...);
41 #define DPRINTK(fmt, args...) \
42 pr_debug("xenbus_client (%s:%d) " fmt ".\n", __FUNCTION__, __LINE__, ##args)
44 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
45 struct xenbus_watch *watch,
46 void (*callback)(struct xenbus_watch *,
47 const char **, unsigned int))
52 watch->callback = callback;
54 err = register_xenbus_watch(watch);
58 watch->callback = NULL;
59 xenbus_dev_fatal(dev, err, "adding watch on %s", path);
64 EXPORT_SYMBOL_GPL(xenbus_watch_path);
67 int xenbus_watch_path2(struct xenbus_device *dev, const char *path,
68 const char *path2, struct xenbus_watch *watch,
69 void (*callback)(struct xenbus_watch *,
70 const char **, unsigned int))
73 char *state = kasprintf("%s/%s", path, path2);
75 xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
78 err = xenbus_watch_path(dev, state, watch, callback);
84 EXPORT_SYMBOL_GPL(xenbus_watch_path2);
87 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
89 /* We check whether the state is currently set to the given value, and
90 if not, then the state is set. We don't want to unconditionally
91 write the given state, because we don't want to fire watches
92 unnecessarily. Furthermore, if the node has gone, we don't write
93 to it, as the device will be tearing down, and we don't want to
94 resurrect that directory.
96 Note that, because of this cached value of our state, this function
97 will not work inside a Xenstore transaction (something it was
98 trying to in the past) because dev->state would not get reset if
99 the transaction was aborted.
106 if (state == dev->state)
109 err = xenbus_scanf(XBT_NIL, dev->nodename, "state", "%d",
114 err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%d", state);
116 if (state != XenbusStateClosing) /* Avoid looping */
117 xenbus_dev_fatal(dev, err, "writing new state");
125 EXPORT_SYMBOL_GPL(xenbus_switch_state);
129 * Return the path to the error node for the given device, or NULL on failure.
130 * If the value returned is non-NULL, then it is the caller's to kfree.
132 static char *error_path(struct xenbus_device *dev)
134 return kasprintf("error/%s", dev->nodename);
138 void _dev_error(struct xenbus_device *dev, int err, const char *fmt,
143 char *printf_buffer = NULL, *path_buffer = NULL;
145 #define PRINTF_BUFFER_SIZE 4096
146 printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
147 if (printf_buffer == NULL)
150 len = sprintf(printf_buffer, "%i ", -err);
151 ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
153 BUG_ON(len + ret > PRINTF_BUFFER_SIZE-1);
155 dev_err(&dev->dev, "%s\n", printf_buffer);
157 path_buffer = error_path(dev);
159 if (path_buffer == NULL) {
160 printk("xenbus: failed to write error node for %s (%s)\n",
161 dev->nodename, printf_buffer);
165 if (xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer) != 0) {
166 printk("xenbus: failed to write error node for %s (%s)\n",
167 dev->nodename, printf_buffer);
173 kfree(printf_buffer);
179 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt,
185 _dev_error(dev, err, fmt, ap);
188 EXPORT_SYMBOL_GPL(xenbus_dev_error);
191 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt,
197 _dev_error(dev, err, fmt, ap);
200 xenbus_switch_state(dev, XenbusStateClosing);
202 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
205 int xenbus_grant_ring(struct xenbus_device *dev, unsigned long ring_mfn)
207 int err = gnttab_grant_foreign_access(dev->otherend_id, ring_mfn, 0);
209 xenbus_dev_fatal(dev, err, "granting access to ring page");
212 EXPORT_SYMBOL_GPL(xenbus_grant_ring);
215 int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port)
217 struct evtchn_alloc_unbound alloc_unbound;
220 alloc_unbound.dom = DOMID_SELF;
221 alloc_unbound.remote_dom = dev->otherend_id;
223 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
226 xenbus_dev_fatal(dev, err, "allocating event channel");
228 *port = alloc_unbound.port;
232 EXPORT_SYMBOL_GPL(xenbus_alloc_evtchn);
235 int xenbus_bind_evtchn(struct xenbus_device *dev, int remote_port, int *port)
237 struct evtchn_bind_interdomain bind_interdomain;
240 bind_interdomain.remote_dom = dev->otherend_id;
241 bind_interdomain.remote_port = remote_port,
243 err = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
246 xenbus_dev_fatal(dev, err,
247 "binding to event channel %d from domain %d",
248 remote_port, dev->otherend_id);
250 *port = bind_interdomain.local_port;
254 EXPORT_SYMBOL_GPL(xenbus_bind_evtchn);
257 int xenbus_free_evtchn(struct xenbus_device *dev, int port)
259 struct evtchn_close close;
264 err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
266 xenbus_dev_error(dev, err, "freeing event channel %d", port);
272 enum xenbus_state xenbus_read_driver_state(const char *path)
274 enum xenbus_state result;
275 int err = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
277 result = XenbusStateClosed;
281 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);