1/******************************************************************************
2 * Talks to Xen Store to figure out what devices we have.
3 *
4 * Copyright (C) 2009, 2010 Spectra Logic Corporation
5 * Copyright (C) 2008 Doug Rabson
6 * Copyright (C) 2005 Rusty Russell, IBM Corporation
7 * Copyright (C) 2005 Mike Wray, Hewlett-Packard
8 * Copyright (C) 2005 XenSource Ltd
9 *
10 * This file may be distributed separately from the Linux kernel, or
11 * incorporated into other software packages, subject to the following license:
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a copy
14 * of this source file (the "Software"), to deal in the Software without
15 * restriction, including without limitation the rights to use, copy, modify,
16 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
17 * and to permit persons to whom the Software is furnished to do so, subject to
18 * the following conditions:
19 *
20 * The above copyright notice and this permission notice shall be included in
21 * all copies or substantial portions of the Software.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
26 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
29 * IN THE SOFTWARE.
30 */
31
32/**
33 * \file xenbusb_back.c
34 *
35 * XenBus management of the NewBus bus containing the backend instances of
36 * Xen split devices.
37 */
38#include <sys/cdefs.h>
39__FBSDID("$FreeBSD$");
40
41#include <sys/param.h>
42#include <sys/bus.h>
43#include <sys/kernel.h>
44#include <sys/lock.h>
45#include <sys/malloc.h>
46#include <sys/module.h>
47#include <sys/sbuf.h>
48#include <sys/sysctl.h>
49#include <sys/syslog.h>
50#include <sys/systm.h>
51#include <sys/sx.h>
52#include <sys/taskqueue.h>
53
54#include <machine/xen/xen-os.h>
55#include <machine/stdarg.h>
56
57#include <xen/gnttab.h>
58#include <xen/xenbus/xenbusvar.h>
59#include <xen/xenbus/xenbusb.h>
60
61
62/*------------------ Private Device Attachment Functions  --------------------*/
63/**
64 * \brief Probe for the existance of the XenBus back bus.
65 *
66 * \param dev  NewBus device_t for this XenBus back bus instance.
67 *
68 * \return  Always returns 0 indicating success.
69 */
70static int
71xenbusb_back_probe(device_t dev)
72{
73	device_set_desc(dev, "Xen Backend Devices");
74
75	return (0);
76}
77
78/**
79 * \brief Attach the XenBus back bus.
80 *
81 * \param dev  NewBus device_t for this XenBus back bus instance.
82 *
83 * \return  On success, 0. Otherwise an errno value indicating the
84 *          type of failure.
85 */
86static int
87xenbusb_back_attach(device_t dev)
88{
89	struct xenbusb_softc *xbs;
90	int error;
91
92	xbs = device_get_softc(dev);
93	error = xenbusb_attach(dev, "backend", /*id_components*/2);
94
95	/*
96	 * Backend devices operate to serve other domains,
97	 * so there is no need to hold up boot processing
98	 * while connections to foreign domains are made.
99	 */
100	mtx_lock(&xbs->xbs_lock);
101	if ((xbs->xbs_flags & XBS_ATTACH_CH_ACTIVE) != 0) {
102		xbs->xbs_flags &= ~XBS_ATTACH_CH_ACTIVE;
103		mtx_unlock(&xbs->xbs_lock);
104		config_intrhook_disestablish(&xbs->xbs_attach_ch);
105	} else {
106		mtx_unlock(&xbs->xbs_lock);
107	}
108
109	return (error);
110}
111
112/**
113 * \brief Enumerate all devices of the given type on this bus.
114 *
115 * \param dev   NewBus device_t for this XenBus backend bus instance.
116 * \param type  String indicating the device sub-tree (e.g. "vfb", "vif")
117 *              to enumerate.
118 *
119 * \return  On success, 0. Otherwise an errno value indicating the
120 *          type of failure.
121 *
122 * Devices that are found are entered into the NewBus hierarchy via
123 * xenbusb_add_device().  xenbusb_add_device() ignores duplicate detects
124 * and ignores duplicate devices, so it can be called unconditionally
125 * for any device found in the XenStore.
126 *
127 * The backend XenStore hierarchy has the following format:
128 *
129 *     backend/<device type>/<frontend vm id>/<device id>
130 *
131 */
132static int
133xenbusb_back_enumerate_type(device_t dev, const char *type)
134{
135	struct xenbusb_softc *xbs;
136	const char **vms;
137	u_int vm_idx;
138	u_int vm_count;
139	int error;
140
141	xbs = device_get_softc(dev);
142	error = xs_directory(XST_NIL, xbs->xbs_node, type, &vm_count, &vms);
143	if (error)
144		return (error);
145	for (vm_idx = 0; vm_idx < vm_count; vm_idx++) {
146		struct sbuf *vm_path;
147		const char *vm;
148		const char **devs;
149		u_int dev_idx;
150		u_int dev_count;
151
152		vm = vms[vm_idx];
153
154		vm_path = xs_join(type, vm);
155		error = xs_directory(XST_NIL, xbs->xbs_node, sbuf_data(vm_path),
156		    &dev_count, &devs);
157		sbuf_delete(vm_path);
158		if (error)
159			break;
160
161		for (dev_idx = 0; dev_idx < dev_count; dev_idx++) {
162			const char *dev_num;
163			struct sbuf *id;
164
165			dev_num = devs[dev_idx];
166			id = xs_join(vm, dev_num);
167			xenbusb_add_device(dev, type, sbuf_data(id));
168			sbuf_delete(id);
169		}
170		free(devs, M_XENSTORE);
171	}
172
173	free(vms, M_XENSTORE);
174
175	return (0);
176}
177
178/**
179 * \brief Determine and store the XenStore path for the other end of
180 *        a split device whose local end is represented by ivars.
181 *
182 * \param dev    NewBus device_t for this XenBus backend bus instance.
183 * \param ivars  Instance variables from the XenBus child device for
184 *               which to perform this function.
185 *
186 * \return  On success, 0. Otherwise an errno value indicating the
187 *          type of failure.
188 *
189 * If successful, the xd_otherend_path field of the child's instance
190 * variables will be updated.
191 *
192 */
193static int
194xenbusb_back_get_otherend_node(device_t dev, struct xenbus_device_ivars *ivars)
195{
196	char *otherend_path;
197	int error;
198
199	if (ivars->xd_otherend_path != NULL) {
200		free(ivars->xd_otherend_path, M_XENBUS);
201		ivars->xd_otherend_path = NULL;
202	}
203
204	error = xs_gather(XST_NIL, ivars->xd_node,
205	    "frontend-id", "%i", &ivars->xd_otherend_id,
206	    "frontend", NULL, &otherend_path,
207	    NULL);
208
209	if (error == 0) {
210		ivars->xd_otherend_path = strdup(otherend_path, M_XENBUS);
211		ivars->xd_otherend_path_len = strlen(otherend_path);
212		free(otherend_path, M_XENSTORE);
213	}
214	return (error);
215}
216
217/**
218 * \brief Backend XenBus method implementing responses to peer state changes.
219 *
220 * \param bus       The XenBus bus parent of child.
221 * \param child     The XenBus child whose peer stat has changed.
222 * \param state     The current state of the peer.
223 */
224static void
225xenbusb_back_otherend_changed(device_t bus, device_t child,
226			      enum xenbus_state peer_state)
227{
228	/* Perform default processing of state. */
229	xenbusb_otherend_changed(bus, child, peer_state);
230
231	/*
232	 * "Online" devices are never fully detached in the
233	 * newbus sense.  Only the front<->back connection is
234	 * torn down.  If the front returns to the initialising
235	 * state after closing a previous connection, signal
236	 * our willingness to reconnect and that all necessary
237	 * XenStore data for feature negotiation is present.
238	 */
239	if (peer_state == XenbusStateInitialising
240	 && xenbus_dev_is_online(child) != 0
241	 && xenbus_get_state(child) == XenbusStateClosed)
242		xenbus_set_state(child, XenbusStateInitWait);
243}
244
245/**
246 * \brief Backend XenBus method implementing responses to local
247 *        XenStore changes.
248 *
249 * \param bus    The XenBus bus parent of child.
250 * \param child  The XenBus child whose peer stat has changed.
251 * \param_path   The tree relative sub-path to the modified node.  The empty
252 *               string indicates the root of the tree was destroyed.
253 */
254static void
255xenbusb_back_localend_changed(device_t bus, device_t child, const char *path)
256{
257
258	xenbusb_localend_changed(bus, child, path);
259
260	if (strcmp(path, "/state") != 0
261	 && strcmp(path, "/online") != 0)
262		return;
263
264	if (xenbus_get_state(child) != XenbusStateClosed
265	 || xenbus_dev_is_online(child) != 0)
266		return;
267
268	/*
269	 * Cleanup the hotplug entry in the XenStore if
270	 * present.  The control domain expects any userland
271	 * component associated with this device to destroy
272	 * this node in order to signify it is safe to
273	 * teardown the device.  However, not all backends
274	 * rely on userland components, and those that
275	 * do should either use a communication channel
276	 * other than the XenStore, or ensure the hotplug
277	 * data is already cleaned up.
278	 *
279	 * This removal ensures that no matter what path
280	 * is taken to mark a back-end closed, the control
281	 * domain will understand that it is closed.
282	 */
283	xs_rm(XST_NIL, xenbus_get_node(child), "hotplug-status");
284}
285
286/*-------------------- Private Device Attachment Data  -----------------------*/
287static device_method_t xenbusb_back_methods[] = {
288	/* Device interface */
289	DEVMETHOD(device_identify,	xenbusb_identify),
290	DEVMETHOD(device_probe,         xenbusb_back_probe),
291	DEVMETHOD(device_attach,        xenbusb_back_attach),
292	DEVMETHOD(device_detach,        bus_generic_detach),
293	DEVMETHOD(device_shutdown,      bus_generic_shutdown),
294	DEVMETHOD(device_suspend,       bus_generic_suspend),
295	DEVMETHOD(device_resume,        xenbusb_resume),
296
297	/* Bus Interface */
298	DEVMETHOD(bus_print_child,      xenbusb_print_child),
299	DEVMETHOD(bus_read_ivar,        xenbusb_read_ivar),
300	DEVMETHOD(bus_write_ivar,       xenbusb_write_ivar),
301	DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
302	DEVMETHOD(bus_release_resource, bus_generic_release_resource),
303	DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
304	DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
305
306	/* XenBus Bus Interface */
307	DEVMETHOD(xenbusb_enumerate_type, xenbusb_back_enumerate_type),
308	DEVMETHOD(xenbusb_get_otherend_node, xenbusb_back_get_otherend_node),
309	DEVMETHOD(xenbusb_otherend_changed, xenbusb_back_otherend_changed),
310	DEVMETHOD(xenbusb_localend_changed, xenbusb_back_localend_changed),
311	{ 0, 0 }
312};
313
314DEFINE_CLASS_0(xenbusb_back, xenbusb_back_driver, xenbusb_back_methods,
315	       sizeof(struct xenbusb_softc));
316devclass_t xenbusb_back_devclass;
317
318DRIVER_MODULE(xenbusb_back, xenstore, xenbusb_back_driver,
319	      xenbusb_back_devclass, 0, 0);
320