]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/xen/xenbus/xenbusb_back.c
amd64: use register macros for gdb_cpu_getreg()
[FreeBSD/FreeBSD.git] / sys / xen / xenbus / xenbusb_back.c
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 /*------------------ Private Device Attachment Functions  --------------------*/
62 /**
63  * \brief Probe for the existance of the XenBus back bus.
64  *
65  * \param dev  NewBus device_t for this XenBus back bus instance.
66  *
67  * \return  Always returns 0 indicating success.
68  */
69 static int 
70 xenbusb_back_probe(device_t dev)
71 {
72         device_set_desc(dev, "Xen Backend Devices");
73
74         return (0);
75 }
76
77 /**
78  * \brief Attach the XenBus back bus.
79  *
80  * \param dev  NewBus device_t for this XenBus back bus instance.
81  *
82  * \return  On success, 0. Otherwise an errno value indicating the
83  *          type of failure.
84  */
85 static int
86 xenbusb_back_attach(device_t dev)
87 {
88         struct xenbusb_softc *xbs;
89         int error;
90
91         xbs = device_get_softc(dev);
92         error = xenbusb_attach(dev, "backend", /*id_components*/2);
93
94         /*
95          * Backend devices operate to serve other domains,
96          * so there is no need to hold up boot processing
97          * while connections to foreign domains are made.
98          */
99         mtx_lock(&xbs->xbs_lock);
100         if ((xbs->xbs_flags & XBS_ATTACH_CH_ACTIVE) != 0) {
101                 xbs->xbs_flags &= ~XBS_ATTACH_CH_ACTIVE;
102                 mtx_unlock(&xbs->xbs_lock);
103                 config_intrhook_disestablish(&xbs->xbs_attach_ch);
104         } else {
105                 mtx_unlock(&xbs->xbs_lock);
106         }
107
108         return (error);
109 }
110
111 /**
112  * \brief Enumerate all devices of the given type on this bus.
113  *
114  * \param dev   NewBus device_t for this XenBus backend bus instance.
115  * \param type  String indicating the device sub-tree (e.g. "vfb", "vif")
116  *              to enumerate. 
117  *
118  * \return  On success, 0. Otherwise an errno value indicating the
119  *          type of failure.
120  *
121  * Devices that are found are entered into the NewBus hierarchy via
122  * xenbusb_add_device().  xenbusb_add_device() ignores duplicate detects
123  * and ignores duplicate devices, so it can be called unconditionally
124  * for any device found in the XenStore.
125  *
126  * The backend XenStore hierarchy has the following format:
127  *
128  *     backend/<device type>/<frontend vm id>/<device id>
129  *
130  */
131 static int
132 xenbusb_back_enumerate_type(device_t dev, const char *type)
133 {
134         struct xenbusb_softc *xbs;
135         const char **vms;
136         u_int vm_idx;
137         u_int vm_count;
138         int error;
139
140         xbs = device_get_softc(dev);
141         error = xs_directory(XST_NIL, xbs->xbs_node, type, &vm_count, &vms);
142         if (error)
143                 return (error);
144         for (vm_idx = 0; vm_idx < vm_count; vm_idx++) {
145                 struct sbuf *vm_path;
146                 const char *vm;
147                 const char **devs;
148                 u_int dev_idx;
149                 u_int dev_count;
150
151                 vm = vms[vm_idx];
152
153                 vm_path = xs_join(type, vm);
154                 error = xs_directory(XST_NIL, xbs->xbs_node, sbuf_data(vm_path),
155                     &dev_count, &devs);
156                 sbuf_delete(vm_path);
157                 if (error)
158                         break;
159
160                 for (dev_idx = 0; dev_idx < dev_count; dev_idx++) {
161                         const char *dev_num;
162                         struct sbuf *id;
163                         
164                         dev_num = devs[dev_idx];
165                         id = xs_join(vm, dev_num);
166                         xenbusb_add_device(dev, type, sbuf_data(id));
167                         sbuf_delete(id);
168                 }
169                 free(devs, M_XENSTORE);
170         }
171
172         free(vms, M_XENSTORE);
173
174         return (0);
175 }
176
177 /**
178  * \brief Determine and store the XenStore path for the other end of
179  *        a split device whose local end is represented by ivars.
180  *
181  * \param dev    NewBus device_t for this XenBus backend bus instance.
182  * \param ivars  Instance variables from the XenBus child device for
183  *               which to perform this function.
184  *
185  * \return  On success, 0. Otherwise an errno value indicating the
186  *          type of failure.
187  *
188  * If successful, the xd_otherend_path field of the child's instance
189  * variables will be updated.
190  *
191  */
192 static int
193 xenbusb_back_get_otherend_node(device_t dev, struct xenbus_device_ivars *ivars)
194 {
195         char *otherend_path;
196         int error;
197
198         if (ivars->xd_otherend_path != NULL) {
199                 free(ivars->xd_otherend_path, M_XENBUS);
200                 ivars->xd_otherend_path = NULL;
201         }
202                 
203         error = xs_gather(XST_NIL, ivars->xd_node,
204             "frontend-id", "%i", &ivars->xd_otherend_id,
205             "frontend", NULL, &otherend_path,
206             NULL);
207
208         if (error == 0) {
209                 ivars->xd_otherend_path = strdup(otherend_path, M_XENBUS);
210                 ivars->xd_otherend_path_len = strlen(otherend_path);
211                 free(otherend_path, M_XENSTORE);
212         }
213         return (error);
214 }
215
216 /**
217  * \brief Backend XenBus method implementing responses to peer state changes.
218  * 
219  * \param bus       The XenBus bus parent of child.
220  * \param child     The XenBus child whose peer stat has changed.
221  * \param state     The current state of the peer.
222  */
223 static void
224 xenbusb_back_otherend_changed(device_t bus, device_t child,
225                               enum xenbus_state peer_state)
226 {
227         /* Perform default processing of state. */
228         xenbusb_otherend_changed(bus, child, peer_state);
229
230         /*
231          * "Online" devices are never fully detached in the
232          * newbus sense.  Only the front<->back connection is
233          * torn down.  If the front returns to the initialising
234          * state after closing a previous connection, signal
235          * our willingness to reconnect and that all necessary
236          * XenStore data for feature negotiation is present.
237          */
238         if (peer_state == XenbusStateInitialising
239          && xenbus_dev_is_online(child) != 0
240          && xenbus_get_state(child) == XenbusStateClosed)
241                 xenbus_set_state(child, XenbusStateInitWait);
242 }
243
244 /**
245  * \brief Backend XenBus method implementing responses to local
246  *        XenStore changes.
247  * 
248  * \param bus    The XenBus bus parent of child.
249  * \param child  The XenBus child whose peer stat has changed.
250  * \param_path   The tree relative sub-path to the modified node.  The empty
251  *               string indicates the root of the tree was destroyed.
252  */
253 static void
254 xenbusb_back_localend_changed(device_t bus, device_t child, const char *path)
255 {
256
257         xenbusb_localend_changed(bus, child, path);
258
259         if (strcmp(path, "/state") != 0
260          && strcmp(path, "/online") != 0)
261                 return;
262
263         if (xenbus_get_state(child) != XenbusStateClosed
264          || xenbus_dev_is_online(child) != 0)
265                 return;
266
267         /*
268          * Cleanup the hotplug entry in the XenStore if
269          * present.  The control domain expects any userland
270          * component associated with this device to destroy
271          * this node in order to signify it is safe to 
272          * teardown the device.  However, not all backends
273          * rely on userland components, and those that
274          * do should either use a communication channel
275          * other than the XenStore, or ensure the hotplug
276          * data is already cleaned up.
277          *
278          * This removal ensures that no matter what path
279          * is taken to mark a back-end closed, the control
280          * domain will understand that it is closed.
281          */
282         xs_rm(XST_NIL, xenbus_get_node(child), "hotplug-status");
283 }
284
285 /*-------------------- Private Device Attachment Data  -----------------------*/
286 static device_method_t xenbusb_back_methods[] = { 
287         /* Device interface */ 
288         DEVMETHOD(device_identify,      xenbusb_identify),
289         DEVMETHOD(device_probe,         xenbusb_back_probe), 
290         DEVMETHOD(device_attach,        xenbusb_back_attach), 
291         DEVMETHOD(device_detach,        bus_generic_detach), 
292         DEVMETHOD(device_shutdown,      bus_generic_shutdown), 
293         DEVMETHOD(device_suspend,       bus_generic_suspend), 
294         DEVMETHOD(device_resume,        xenbusb_resume), 
295
296         /* Bus Interface */ 
297         DEVMETHOD(bus_print_child,      xenbusb_print_child),
298         DEVMETHOD(bus_read_ivar,        xenbusb_read_ivar), 
299         DEVMETHOD(bus_write_ivar,       xenbusb_write_ivar), 
300         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
301         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
302         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
303         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
304
305         /* XenBus Bus Interface */
306         DEVMETHOD(xenbusb_enumerate_type, xenbusb_back_enumerate_type),
307         DEVMETHOD(xenbusb_get_otherend_node, xenbusb_back_get_otherend_node),
308         DEVMETHOD(xenbusb_otherend_changed, xenbusb_back_otherend_changed),
309         DEVMETHOD(xenbusb_localend_changed, xenbusb_back_localend_changed),
310         { 0, 0 } 
311 }; 
312
313 DEFINE_CLASS_0(xenbusb_back, xenbusb_back_driver, xenbusb_back_methods,
314                sizeof(struct xenbusb_softc));
315 devclass_t xenbusb_back_devclass; 
316
317 DRIVER_MODULE(xenbusb_back, xenstore, xenbusb_back_driver,
318               xenbusb_back_devclass, 0, 0);