xref: /netbsd-src/sys/arch/xen/xenbus/xenbus_client.c (revision b95803dc6bc74fded327c6183611d21456253da8)
1 /* $NetBSD: xenbus_client.c,v 1.17 2020/04/07 15:16:52 jdolecek Exp $ */
2 /******************************************************************************
3  * Client-facing interface for the Xenbus driver.  In other words, the
4  * interface between the Xenbus and the device-specific code, be it the
5  * frontend or the backend of that driver.
6  *
7  * Copyright (C) 2005 XenSource Ltd
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 __KERNEL_RCSID(0, "$NetBSD: xenbus_client.c,v 1.17 2020/04/07 15:16:52 jdolecek Exp $");
33 
34 #if 0
35 #define DPRINTK(fmt, args...) \
36     printk("xenbus_client (%s:%d) " fmt ".\n", __func__, __LINE__, ##args)
37 #else
38 #define DPRINTK(fmt, args...) ((void)0)
39 #endif
40 
41 #include <sys/types.h>
42 #include <sys/null.h>
43 #include <sys/errno.h>
44 #include <sys/kmem.h>
45 #include <sys/systm.h>
46 
47 #include <xen/xen.h>
48 #include <xen/hypervisor.h>
49 #include <xen/evtchn.h>
50 #include <xen/xenbus.h>
51 #include <xen/granttables.h>
52 
53 int
xenbus_watch_path2(struct xenbus_device * dev,const char * path,const char * path2,struct xenbus_watch * watch,void (* callback)(struct xenbus_watch *,const char **,unsigned int))54 xenbus_watch_path2(struct xenbus_device *dev, const char *path,
55 		       const char *path2, struct xenbus_watch *watch,
56 		       void (*callback)(struct xenbus_watch *,
57 					const char **, unsigned int))
58 {
59 	int err;
60 	char *state;
61 
62 	DPRINTK("xenbus_watch_path2 path %s path2 %s\n", path, path2);
63 
64 	watch->node_sz = strlen(path) + 1 + strlen(path2) + 1;
65 	state = kmem_alloc(watch->node_sz, KM_SLEEP);
66 	strcpy(state, path);
67 	strcat(state, "/");
68 	strcat(state, path2);
69 
70 	watch->node = state;
71 	watch->xbw_callback = callback;
72 
73 	err = register_xenbus_watch(watch);
74 
75 	if (err) {
76 		watch->node = NULL;
77 		watch->node_sz = 0;
78 		watch->xbw_callback = NULL;
79 		xenbus_dev_fatal(dev, err, "adding watch on %s", state);
80 		kmem_free(state, watch->node_sz);
81 	}
82 	return err;
83 }
84 
85 void
xenbus_unwatch_path(struct xenbus_watch * watch)86 xenbus_unwatch_path(struct xenbus_watch *watch)
87 {
88 	if (watch->node != NULL) {
89 		unregister_xenbus_watch(watch);
90 		kmem_free(watch->node, watch->node_sz);
91 		watch->node = NULL;
92 	}
93 }
94 
95 int
xenbus_switch_state(struct xenbus_device * dev,struct xenbus_transaction * xbt,XenbusState state)96 xenbus_switch_state(struct xenbus_device *dev,
97 			struct xenbus_transaction *xbt,
98 			XenbusState state)
99 {
100 	/* We check whether the state is currently set to the given value, and
101 	   if not, then the state is set.  We don't want to unconditionally
102 	   write the given state, because we don't want to fire watches
103 	   unnecessarily.  Furthermore, if the node has gone, we don't write
104 	   to it, as the device will be tearing down, and we don't want to
105 	   resurrect that directory.
106 	 */
107 
108 	u_long current_state;
109 
110 	int err = xenbus_read_ul(xbt, dev->xbusd_path, "state",
111 	    &current_state, 10);
112 	if (err)
113 		return 0;
114 
115 	if ((XenbusState)current_state == state)
116 		return 0;
117 
118 	err = xenbus_printf(xbt, dev->xbusd_path, "state", "%d", state);
119 	if (err) {
120 		xenbus_dev_fatal(dev, err, "writing new state");
121 		return err;
122 	}
123 	return 0;
124 }
125 
126 /**
127  * Return the path to the error node for the given device, or NULL on failure.
128  * If the value returned is non-NULL, then it is the caller's to kfree.
129  */
130 static char *
error_path(struct xenbus_device * dev,size_t * len)131 error_path(struct xenbus_device *dev, size_t *len)
132 {
133 	*len = strlen("error/") + strlen(dev->xbusd_path) + 1;
134 	char *path_buffer = kmem_alloc(*len, KM_NOSLEEP);
135 	if (path_buffer == NULL)
136 		return NULL;
137 
138 	strcpy(path_buffer, "error/");
139 	strcpy(path_buffer + strlen("error/"), dev->xbusd_path);
140 
141 	return path_buffer;
142 }
143 
144 
145 static void
_dev_error(struct xenbus_device * dev,int err,const char * fmt,va_list ap)146 _dev_error(struct xenbus_device *dev, int err, const char *fmt,
147 		va_list ap)
148 {
149 	int ret __diagused;
150 	unsigned int len;
151 	char *printf_buffer = NULL, *path_buffer = NULL;
152 	size_t path_buffer_sz = 0;
153 
154 #define PRINTF_BUFFER_SIZE 4096
155 	printf_buffer = kmem_alloc(PRINTF_BUFFER_SIZE, KM_NOSLEEP);
156 	if (printf_buffer == NULL)
157 		goto fail;
158 
159 	len = snprintf(printf_buffer, PRINTF_BUFFER_SIZE, "%i ", -err);
160 	KASSERT(len < PRINTF_BUFFER_SIZE);
161 	ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
162 	KASSERT(len + ret < PRINTF_BUFFER_SIZE);
163 	dev->xbusd_has_error = 1;
164 
165 	path_buffer = error_path(dev, &path_buffer_sz);
166 	if (path_buffer == NULL) {
167 		printk("xenbus: failed to write error node for %s (%s)\n",
168 		       dev->xbusd_path, printf_buffer);
169 		goto fail;
170 	}
171 
172 	if (xenbus_write(NULL, path_buffer, "error", printf_buffer) != 0) {
173 		printk("xenbus: failed to write error node for %s (%s)\n",
174 		       dev->xbusd_path, printf_buffer);
175 		goto fail;
176 	}
177 
178 fail:
179 	if (printf_buffer)
180 		kmem_free(printf_buffer, PRINTF_BUFFER_SIZE);
181 	if (path_buffer)
182 		kmem_free(path_buffer, path_buffer_sz);
183 }
184 
185 
186 void
xenbus_dev_error(struct xenbus_device * dev,int err,const char * fmt,...)187 xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt,
188 		      ...)
189 {
190 	va_list ap;
191 
192 	va_start(ap, fmt);
193 	_dev_error(dev, err, fmt, ap);
194 	va_end(ap);
195 }
196 
197 
198 void
xenbus_dev_fatal(struct xenbus_device * dev,int err,const char * fmt,...)199 xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt,
200 		      ...)
201 {
202 	va_list ap;
203 
204 	va_start(ap, fmt);
205 	_dev_error(dev, err, fmt, ap);
206 	va_end(ap);
207 
208 	xenbus_switch_state(dev, NULL, XenbusStateClosing);
209 }
210 
211 
212 int
xenbus_grant_ring(struct xenbus_device * dev,paddr_t ring_pa,grant_ref_t * entryp)213 xenbus_grant_ring(struct xenbus_device *dev, paddr_t ring_pa,
214     grant_ref_t *entryp)
215 {
216 	int err = xengnt_grant_access(dev->xbusd_otherend_id, ring_pa,
217 	    0, entryp);
218 	if (err != 0)
219 		xenbus_dev_fatal(dev, err, "granting access to ring page");
220 	return err;
221 }
222 
223 
224 int
xenbus_alloc_evtchn(struct xenbus_device * dev,int * port)225 xenbus_alloc_evtchn(struct xenbus_device *dev, int *port)
226 {
227 	evtchn_op_t op = {
228 		.cmd = EVTCHNOP_alloc_unbound,
229 		.u.alloc_unbound = {
230 			.dom = DOMID_SELF,
231 			.remote_dom = dev->xbusd_otherend_id,
232 			.port = 0
233 		}
234 	};
235 
236 	int err = HYPERVISOR_event_channel_op(&op);
237 	if (err)
238 		xenbus_dev_fatal(dev, err, "allocating event channel");
239 	else
240 		*port = op.u.alloc_unbound.port;
241 	return err;
242 }
243 
244 
245 XenbusState
xenbus_read_driver_state(const char * path)246 xenbus_read_driver_state(const char *path)
247 {
248 	u_long result;
249 
250 	int err = xenbus_read_ul(NULL, path, "state", &result, 10);
251 	if (err)
252 		result = XenbusStateClosed;
253 
254 	return result;
255 }
256 
257 
258 /*
259  * Local variables:
260  *  c-file-style: "linux"
261  *  indent-tabs-mode: t
262  *  c-indent-level: 8
263  *  c-basic-offset: 8
264  *  tab-width: 8
265  * End:
266  */
267