Commit | Line | Data |
---|---|---|
df660251 IC |
1 | /****************************************************************************** |
2 | * Talks to Xen Store to figure out what devices we have (backend half). | |
3 | * | |
4 | * Copyright (C) 2005 Rusty Russell, IBM Corporation | |
5 | * Copyright (C) 2005 Mike Wray, Hewlett-Packard | |
6 | * Copyright (C) 2005, 2006 XenSource Ltd | |
7 | * Copyright (C) 2007 Solarflare Communications, Inc. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License version 2 | |
11 | * as published by the Free Software Foundation; or, when distributed | |
12 | * separately from the Linux kernel or incorporated into other | |
13 | * software packages, subject to the following license: | |
14 | * | |
15 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
16 | * of this source file (the "Software"), to deal in the Software without | |
17 | * restriction, including without limitation the rights to use, copy, modify, | |
18 | * merge, publish, distribute, sublicense, and/or sell copies of the Software, | |
19 | * and to permit persons to whom the Software is furnished to do so, subject to | |
20 | * the following conditions: | |
21 | * | |
22 | * The above copyright notice and this permission notice shall be included in | |
23 | * all copies or substantial portions of the Software. | |
24 | * | |
25 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
26 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
27 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
28 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
29 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
30 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
31 | * IN THE SOFTWARE. | |
32 | */ | |
33 | ||
283c0972 JP |
34 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
35 | ||
36 | #define DPRINTK(fmt, ...) \ | |
37 | pr_debug("(%s:%d) " fmt "\n", \ | |
38 | __func__, __LINE__, ##__VA_ARGS__) | |
df660251 IC |
39 | |
40 | #include <linux/kernel.h> | |
41 | #include <linux/err.h> | |
42 | #include <linux/string.h> | |
43 | #include <linux/ctype.h> | |
44 | #include <linux/fcntl.h> | |
45 | #include <linux/mm.h> | |
46 | #include <linux/notifier.h> | |
63c9744b | 47 | #include <linux/export.h> |
df660251 IC |
48 | |
49 | #include <asm/page.h> | |
50 | #include <asm/pgtable.h> | |
51 | #include <asm/xen/hypervisor.h> | |
52 | #include <asm/hypervisor.h> | |
53 | #include <xen/xenbus.h> | |
df660251 IC |
54 | #include <xen/features.h> |
55 | ||
332f791d | 56 | #include "xenbus.h" |
df660251 IC |
57 | |
58 | /* backend/<type>/<fe-uuid>/<id> => <type>-<fe-domid>-<id> */ | |
59 | static int backend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename) | |
60 | { | |
61 | int domid, err; | |
62 | const char *devid, *type, *frontend; | |
63 | unsigned int typelen; | |
64 | ||
65 | type = strchr(nodename, '/'); | |
66 | if (!type) | |
67 | return -EINVAL; | |
68 | type++; | |
69 | typelen = strcspn(type, "/"); | |
70 | if (!typelen || type[typelen] != '/') | |
71 | return -EINVAL; | |
72 | ||
73 | devid = strrchr(nodename, '/') + 1; | |
74 | ||
75 | err = xenbus_gather(XBT_NIL, nodename, "frontend-id", "%i", &domid, | |
76 | "frontend", NULL, &frontend, | |
77 | NULL); | |
78 | if (err) | |
79 | return err; | |
80 | if (strlen(frontend) == 0) | |
81 | err = -ERANGE; | |
82 | if (!err && !xenbus_exists(XBT_NIL, frontend, "")) | |
83 | err = -ENOENT; | |
84 | kfree(frontend); | |
85 | ||
86 | if (err) | |
87 | return err; | |
88 | ||
6bac7f9f IC |
89 | if (snprintf(bus_id, XEN_BUS_ID_SIZE, "%.*s-%i-%s", |
90 | typelen, type, domid, devid) >= XEN_BUS_ID_SIZE) | |
df660251 IC |
91 | return -ENOSPC; |
92 | return 0; | |
93 | } | |
94 | ||
95 | static int xenbus_uevent_backend(struct device *dev, | |
96 | struct kobj_uevent_env *env) | |
97 | { | |
98 | struct xenbus_device *xdev; | |
99 | struct xenbus_driver *drv; | |
100 | struct xen_bus_type *bus; | |
101 | ||
102 | DPRINTK(""); | |
103 | ||
104 | if (dev == NULL) | |
105 | return -ENODEV; | |
106 | ||
107 | xdev = to_xenbus_device(dev); | |
108 | bus = container_of(xdev->dev.bus, struct xen_bus_type, bus); | |
df660251 | 109 | |
149bb2fa BB |
110 | if (add_uevent_var(env, "MODALIAS=xen-backend:%s", xdev->devicetype)) |
111 | return -ENOMEM; | |
112 | ||
df660251 IC |
113 | /* stuff we want to pass to /sbin/hotplug */ |
114 | if (add_uevent_var(env, "XENBUS_TYPE=%s", xdev->devicetype)) | |
115 | return -ENOMEM; | |
116 | ||
117 | if (add_uevent_var(env, "XENBUS_PATH=%s", xdev->nodename)) | |
118 | return -ENOMEM; | |
119 | ||
120 | if (add_uevent_var(env, "XENBUS_BASE_PATH=%s", bus->root)) | |
121 | return -ENOMEM; | |
122 | ||
123 | if (dev->driver) { | |
124 | drv = to_xenbus_driver(dev->driver); | |
125 | if (drv && drv->uevent) | |
126 | return drv->uevent(xdev, env); | |
127 | } | |
128 | ||
129 | return 0; | |
130 | } | |
131 | ||
132 | /* backend/<typename>/<frontend-uuid>/<name> */ | |
133 | static int xenbus_probe_backend_unit(struct xen_bus_type *bus, | |
134 | const char *dir, | |
135 | const char *type, | |
136 | const char *name) | |
137 | { | |
138 | char *nodename; | |
139 | int err; | |
140 | ||
141 | nodename = kasprintf(GFP_KERNEL, "%s/%s", dir, name); | |
142 | if (!nodename) | |
143 | return -ENOMEM; | |
144 | ||
145 | DPRINTK("%s\n", nodename); | |
146 | ||
147 | err = xenbus_probe_node(bus, type, nodename); | |
148 | kfree(nodename); | |
149 | return err; | |
150 | } | |
151 | ||
152 | /* backend/<typename>/<frontend-domid> */ | |
6bac7f9f IC |
153 | static int xenbus_probe_backend(struct xen_bus_type *bus, const char *type, |
154 | const char *domid) | |
df660251 IC |
155 | { |
156 | char *nodename; | |
157 | int err = 0; | |
158 | char **dir; | |
159 | unsigned int i, dir_n = 0; | |
160 | ||
161 | DPRINTK(""); | |
162 | ||
163 | nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, domid); | |
164 | if (!nodename) | |
165 | return -ENOMEM; | |
166 | ||
167 | dir = xenbus_directory(XBT_NIL, nodename, "", &dir_n); | |
168 | if (IS_ERR(dir)) { | |
169 | kfree(nodename); | |
170 | return PTR_ERR(dir); | |
171 | } | |
172 | ||
173 | for (i = 0; i < dir_n; i++) { | |
174 | err = xenbus_probe_backend_unit(bus, nodename, type, dir[i]); | |
175 | if (err) | |
176 | break; | |
177 | } | |
178 | kfree(dir); | |
179 | kfree(nodename); | |
180 | return err; | |
181 | } | |
182 | ||
183 | static void frontend_changed(struct xenbus_watch *watch, | |
5584ea25 | 184 | const char *path, const char *token) |
df660251 | 185 | { |
5584ea25 | 186 | xenbus_otherend_changed(watch, path, token, 0); |
df660251 IC |
187 | } |
188 | ||
df660251 IC |
189 | static struct xen_bus_type xenbus_backend = { |
190 | .root = "backend", | |
6bac7f9f | 191 | .levels = 3, /* backend/type/<frontend>/<id> */ |
df660251 IC |
192 | .get_bus_id = backend_bus_id, |
193 | .probe = xenbus_probe_backend, | |
194 | .otherend_changed = frontend_changed, | |
195 | .bus = { | |
6bac7f9f IC |
196 | .name = "xen-backend", |
197 | .match = xenbus_match, | |
198 | .uevent = xenbus_uevent_backend, | |
199 | .probe = xenbus_dev_probe, | |
200 | .remove = xenbus_dev_remove, | |
201 | .shutdown = xenbus_dev_shutdown, | |
85dd9268 | 202 | .dev_groups = xenbus_dev_groups, |
df660251 IC |
203 | }, |
204 | }; | |
205 | ||
206 | static void backend_changed(struct xenbus_watch *watch, | |
5584ea25 | 207 | const char *path, const char *token) |
df660251 IC |
208 | { |
209 | DPRINTK(""); | |
210 | ||
5584ea25 | 211 | xenbus_dev_changed(path, &xenbus_backend); |
df660251 IC |
212 | } |
213 | ||
214 | static struct xenbus_watch be_watch = { | |
215 | .node = "backend", | |
216 | .callback = backend_changed, | |
217 | }; | |
218 | ||
219 | static int read_frontend_details(struct xenbus_device *xendev) | |
220 | { | |
221 | return xenbus_read_otherend_details(xendev, "frontend-id", "frontend"); | |
222 | } | |
223 | ||
df660251 IC |
224 | int xenbus_dev_is_online(struct xenbus_device *dev) |
225 | { | |
999c9af9 | 226 | return !!xenbus_read_unsigned(dev->nodename, "online", 0); |
df660251 IC |
227 | } |
228 | EXPORT_SYMBOL_GPL(xenbus_dev_is_online); | |
229 | ||
95afae48 DV |
230 | int __xenbus_register_backend(struct xenbus_driver *drv, struct module *owner, |
231 | const char *mod_name) | |
df660251 IC |
232 | { |
233 | drv->read_otherend_details = read_frontend_details; | |
234 | ||
95afae48 DV |
235 | return xenbus_register_driver_common(drv, &xenbus_backend, |
236 | owner, mod_name); | |
df660251 | 237 | } |
95afae48 | 238 | EXPORT_SYMBOL_GPL(__xenbus_register_backend); |
df660251 IC |
239 | |
240 | static int backend_probe_and_watch(struct notifier_block *notifier, | |
241 | unsigned long event, | |
242 | void *data) | |
243 | { | |
244 | /* Enumerate devices in xenstore and watch for changes. */ | |
245 | xenbus_probe_devices(&xenbus_backend); | |
df660251 | 246 | register_xenbus_watch(&be_watch); |
b5d33d08 | 247 | |
df660251 IC |
248 | return NOTIFY_DONE; |
249 | } | |
250 | ||
251 | static int __init xenbus_probe_backend_init(void) | |
252 | { | |
253 | static struct notifier_block xenstore_notifier = { | |
254 | .notifier_call = backend_probe_and_watch | |
255 | }; | |
256 | int err; | |
257 | ||
258 | DPRINTK(""); | |
259 | ||
260 | /* Register ourselves with the kernel bus subsystem */ | |
261 | err = bus_register(&xenbus_backend.bus); | |
b5d33d08 | 262 | if (err) |
df660251 | 263 | return err; |
df660251 IC |
264 | |
265 | register_xenstore_notifier(&xenstore_notifier); | |
266 | ||
267 | return 0; | |
268 | } | |
c3676e84 | 269 | subsys_initcall(xenbus_probe_backend_init); |