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.
5 *
6 * Copyright (C) 2005 XenSource Ltd
7 *
8 * This file may be distributed separately from the Linux kernel, or
9 * incorporated into other software packages, subject to the following license:
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 * of this source file (the "Software"), to deal in the Software without
13 * restriction, including without limitation the rights to use, copy, modify,
14 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
15 * and to permit persons to whom the Software is furnished to do so, subject to
16 * the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
27 * IN THE SOFTWARE.
28 */
29
30
31 #if 0
32 #define DPRINTK(fmt, args...) \
33 printk("xenbus_client (%s:%d) " fmt ".\n", __FUNCTION__, __LINE__, ##args)
34 #else
35 #define DPRINTK(fmt, args...) ((void)0)
36 #endif
37
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD: releng/8.1/sys/xen/xenbus/xenbus_client.c 186557 2008-12-29 06:31:03Z kmacy $");
40
41 #include <sys/cdefs.h>
42 #include <sys/types.h>
43 #include <sys/malloc.h>
44 #include <sys/libkern.h>
45
46 #include <machine/xen/xen-os.h>
47 #include <xen/hypervisor.h>
48 #include <xen/evtchn.h>
49 #include <xen/gnttab.h>
50 #include <xen/xenbus/xenbusvar.h>
51 #include <machine/stdarg.h>
52
53 const char *
54 xenbus_strstate(XenbusState state)
55 {
56 static const char *const name[] = {
57 [ XenbusStateUnknown ] = "Unknown",
58 [ XenbusStateInitialising ] = "Initialising",
59 [ XenbusStateInitWait ] = "InitWait",
60 [ XenbusStateInitialised ] = "Initialised",
61 [ XenbusStateConnected ] = "Connected",
62 [ XenbusStateClosing ] = "Closing",
63 [ XenbusStateClosed ] = "Closed",
64 };
65
66 return ((state < (XenbusStateClosed + 1)) ? name[state] : "INVALID");
67 }
68
69 int
70 xenbus_watch_path(device_t dev, char *path, struct xenbus_watch *watch,
71 void (*callback)(struct xenbus_watch *, const char **, unsigned int))
72 {
73 int error;
74
75 watch->node = path;
76 watch->callback = callback;
77
78 error = register_xenbus_watch(watch);
79
80 if (error) {
81 watch->node = NULL;
82 watch->callback = NULL;
83 xenbus_dev_fatal(dev, error, "adding watch on %s", path);
84 }
85
86 return (error);
87 }
88
89 int
90 xenbus_watch_path2(device_t dev, const char *path,
91 const char *path2, struct xenbus_watch *watch,
92 void (*callback)(struct xenbus_watch *, const char **, unsigned int))
93 {
94 int error;
95 char *state = malloc(strlen(path) + 1 + strlen(path2) + 1,
96 M_DEVBUF, M_WAITOK);
97
98 strcpy(state, path);
99 strcat(state, "/");
100 strcat(state, path2);
101
102 error = xenbus_watch_path(dev, state, watch, callback);
103 if (error) {
104 free(state, M_DEVBUF);
105 }
106
107 return (error);
108 }
109
110 /**
111 * Return the path to the error node for the given device, or NULL on failure.
112 * If the value returned is non-NULL, then it is the caller's to kfree.
113 */
114 static char *
115 error_path(device_t dev)
116 {
117 char *path_buffer = malloc(strlen("error/")
118 + strlen(xenbus_get_node(dev)) + 1, M_DEVBUF, M_WAITOK);
119
120 strcpy(path_buffer, "error/");
121 strcpy(path_buffer + strlen("error/"), xenbus_get_node(dev));
122
123 return (path_buffer);
124 }
125
126
127 static void
128 _dev_error(device_t dev, int err, const char *fmt, va_list ap)
129 {
130 int ret;
131 unsigned int len;
132 char *printf_buffer = NULL, *path_buffer = NULL;
133
134 #define PRINTF_BUFFER_SIZE 4096
135 printf_buffer = malloc(PRINTF_BUFFER_SIZE, M_DEVBUF, M_WAITOK);
136
137 len = sprintf(printf_buffer, "%i ", err);
138 ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
139
140 KASSERT(len + ret <= PRINTF_BUFFER_SIZE-1, ("xenbus error message too big"));
141 #if 0
142 dev_err(&dev->dev, "%s\n", printf_buffer);
143 #endif
144 path_buffer = error_path(dev);
145
146 if (path_buffer == NULL) {
147 printf("xenbus: failed to write error node for %s (%s)\n",
148 xenbus_get_node(dev), printf_buffer);
149 goto fail;
150 }
151
152 if (xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer) != 0) {
153 printf("xenbus: failed to write error node for %s (%s)\n",
154 xenbus_get_node(dev), printf_buffer);
155 goto fail;
156 }
157
158 fail:
159 if (printf_buffer)
160 free(printf_buffer, M_DEVBUF);
161 if (path_buffer)
162 free(path_buffer, M_DEVBUF);
163 }
164
165 void
166 xenbus_dev_error(device_t dev, int err, const char *fmt, ...)
167 {
168 va_list ap;
169
170 va_start(ap, fmt);
171 _dev_error(dev, err, fmt, ap);
172 va_end(ap);
173 }
174
175 void
176 xenbus_dev_fatal(device_t dev, int err, const char *fmt, ...)
177 {
178 va_list ap;
179
180 va_start(ap, fmt);
181 _dev_error(dev, err, fmt, ap);
182 va_end(ap);
183
184 xenbus_set_state(dev, XenbusStateClosing);
185 }
186
187 int
188 xenbus_grant_ring(device_t dev, unsigned long ring_mfn, int *refp)
189 {
190 int error;
191 grant_ref_t ref;
192
193 error = gnttab_grant_foreign_access(
194 xenbus_get_otherend_id(dev), ring_mfn, 0, &ref);
195 if (error) {
196 xenbus_dev_fatal(dev, error, "granting access to ring page");
197 return (error);
198 }
199
200 *refp = ref;
201 return (0);
202 }
203
204 int
205 xenbus_alloc_evtchn(device_t dev, int *port)
206 {
207 struct evtchn_alloc_unbound alloc_unbound;
208 int err;
209
210 alloc_unbound.dom = DOMID_SELF;
211 alloc_unbound.remote_dom = xenbus_get_otherend_id(dev);
212
213 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
214 &alloc_unbound);
215
216 if (err) {
217 xenbus_dev_fatal(dev, -err, "allocating event channel");
218 return (-err);
219 }
220 *port = alloc_unbound.port;
221 return (0);
222 }
223
224 int
225 xenbus_free_evtchn(device_t dev, int port)
226 {
227 struct evtchn_close close;
228 int err;
229
230 close.port = port;
231
232 err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
233 if (err) {
234 xenbus_dev_error(dev, -err, "freeing event channel %d", port);
235 return (-err);
236 }
237 return (0);
238 }
239
240 XenbusState
241 xenbus_read_driver_state(const char *path)
242 {
243 XenbusState result;
244 int error;
245
246 error = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
247 if (error)
248 result = XenbusStateClosed;
249
250 return (result);
251 }
Cache object: c230d57d7383dbfba32e515a3b2dee72
|