1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
3 | |
4 | #define DPRINTK(fmt, ...) \ |
5 | pr_debug("(%s:%d) " fmt "\n", \ |
6 | __func__, __LINE__, ##__VA_ARGS__) |
7 | |
8 | #include <linux/kernel.h> |
9 | #include <linux/err.h> |
10 | #include <linux/string.h> |
11 | #include <linux/ctype.h> |
12 | #include <linux/fcntl.h> |
13 | #include <linux/mm.h> |
14 | #include <linux/proc_fs.h> |
15 | #include <linux/notifier.h> |
16 | #include <linux/kthread.h> |
17 | #include <linux/mutex.h> |
18 | #include <linux/io.h> |
19 | #include <linux/module.h> |
20 | |
21 | #include <asm/page.h> |
22 | #include <asm/xen/hypervisor.h> |
23 | #include <xen/xenbus.h> |
24 | #include <xen/events.h> |
25 | #include <xen/page.h> |
26 | #include <xen/xen.h> |
27 | |
28 | #include <xen/platform_pci.h> |
29 | |
30 | #include "xenbus.h" |
31 | |
32 | |
33 | |
34 | /* device/<type>/<id> => <type>-<id> */ |
35 | static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename) |
36 | { |
37 | nodename = strchr(nodename, '/'); |
38 | if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) { |
39 | pr_warn("bad frontend %s\n" , nodename); |
40 | return -EINVAL; |
41 | } |
42 | |
43 | strscpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE); |
44 | if (!strchr(bus_id, '/')) { |
45 | pr_warn("bus_id %s no slash\n" , bus_id); |
46 | return -EINVAL; |
47 | } |
48 | *strchr(bus_id, '/') = '-'; |
49 | return 0; |
50 | } |
51 | |
52 | /* device/<typename>/<name> */ |
53 | static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type, |
54 | const char *name) |
55 | { |
56 | char *nodename; |
57 | int err; |
58 | |
59 | /* ignore console/0 */ |
60 | if (!strncmp(type, "console" , 7) && !strncmp(name, "0" , 1)) { |
61 | DPRINTK("Ignoring buggy device entry console/0" ); |
62 | return 0; |
63 | } |
64 | |
65 | nodename = kasprintf(GFP_KERNEL, fmt: "%s/%s/%s" , bus->root, type, name); |
66 | if (!nodename) |
67 | return -ENOMEM; |
68 | |
69 | DPRINTK("%s" , nodename); |
70 | |
71 | err = xenbus_probe_node(bus, type, nodename); |
72 | kfree(objp: nodename); |
73 | return err; |
74 | } |
75 | |
76 | static int xenbus_uevent_frontend(const struct device *_dev, |
77 | struct kobj_uevent_env *env) |
78 | { |
79 | const struct xenbus_device *dev = to_xenbus_device(_dev); |
80 | |
81 | if (add_uevent_var(env, format: "MODALIAS=xen:%s" , dev->devicetype)) |
82 | return -ENOMEM; |
83 | |
84 | return 0; |
85 | } |
86 | |
87 | |
88 | static void backend_changed(struct xenbus_watch *watch, |
89 | const char *path, const char *token) |
90 | { |
91 | xenbus_otherend_changed(watch, path, token, ignore_on_shutdown: 1); |
92 | } |
93 | |
94 | static void xenbus_frontend_delayed_resume(struct work_struct *w) |
95 | { |
96 | struct xenbus_device *xdev = container_of(w, struct xenbus_device, work); |
97 | |
98 | xenbus_dev_resume(dev: &xdev->dev); |
99 | } |
100 | |
101 | static int xenbus_frontend_dev_resume(struct device *dev) |
102 | { |
103 | /* |
104 | * If xenstored is running in this domain, we cannot access the backend |
105 | * state at the moment, so we need to defer xenbus_dev_resume |
106 | */ |
107 | if (xen_store_domain_type == XS_LOCAL) { |
108 | struct xenbus_device *xdev = to_xenbus_device(dev); |
109 | |
110 | schedule_work(work: &xdev->work); |
111 | |
112 | return 0; |
113 | } |
114 | |
115 | return xenbus_dev_resume(dev); |
116 | } |
117 | |
118 | static int xenbus_frontend_dev_probe(struct device *dev) |
119 | { |
120 | if (xen_store_domain_type == XS_LOCAL) { |
121 | struct xenbus_device *xdev = to_xenbus_device(dev); |
122 | INIT_WORK(&xdev->work, xenbus_frontend_delayed_resume); |
123 | } |
124 | |
125 | return xenbus_dev_probe(dev: dev); |
126 | } |
127 | |
128 | static void xenbus_frontend_dev_shutdown(struct device *_dev) |
129 | { |
130 | struct xenbus_device *dev = to_xenbus_device(_dev); |
131 | unsigned long timeout = 5*HZ; |
132 | |
133 | DPRINTK("%s" , dev->nodename); |
134 | |
135 | get_device(dev: &dev->dev); |
136 | if (dev->state != XenbusStateConnected) { |
137 | pr_info("%s: %s: %s != Connected, skipping\n" , |
138 | __func__, dev->nodename, xenbus_strstate(dev->state)); |
139 | goto out; |
140 | } |
141 | xenbus_switch_state(dev, new_state: XenbusStateClosing); |
142 | timeout = wait_for_completion_timeout(x: &dev->down, timeout); |
143 | if (!timeout) |
144 | pr_info("%s: %s timeout closing device\n" , |
145 | __func__, dev->nodename); |
146 | out: |
147 | put_device(dev: &dev->dev); |
148 | } |
149 | |
150 | static const struct dev_pm_ops xenbus_pm_ops = { |
151 | .suspend = xenbus_dev_suspend, |
152 | .resume = xenbus_frontend_dev_resume, |
153 | .freeze = xenbus_dev_suspend, |
154 | .thaw = xenbus_dev_cancel, |
155 | .restore = xenbus_dev_resume, |
156 | }; |
157 | |
158 | static struct xen_bus_type xenbus_frontend = { |
159 | .root = "device" , |
160 | .levels = 2, /* device/type/<id> */ |
161 | .get_bus_id = frontend_bus_id, |
162 | .probe = xenbus_probe_frontend, |
163 | .otherend_changed = backend_changed, |
164 | .bus = { |
165 | .name = "xen" , |
166 | .match = xenbus_match, |
167 | .uevent = xenbus_uevent_frontend, |
168 | .probe = xenbus_frontend_dev_probe, |
169 | .remove = xenbus_dev_remove, |
170 | .shutdown = xenbus_frontend_dev_shutdown, |
171 | .dev_groups = xenbus_dev_groups, |
172 | |
173 | .pm = &xenbus_pm_ops, |
174 | }, |
175 | }; |
176 | |
177 | static void frontend_changed(struct xenbus_watch *watch, |
178 | const char *path, const char *token) |
179 | { |
180 | DPRINTK("" ); |
181 | |
182 | xenbus_dev_changed(node: path, bus: &xenbus_frontend); |
183 | } |
184 | |
185 | |
186 | /* We watch for devices appearing and vanishing. */ |
187 | static struct xenbus_watch fe_watch = { |
188 | .node = "device" , |
189 | .callback = frontend_changed, |
190 | }; |
191 | |
192 | static int read_backend_details(struct xenbus_device *xendev) |
193 | { |
194 | return xenbus_read_otherend_details(xendev, id_node: "backend-id" , path_node: "backend" ); |
195 | } |
196 | |
197 | static int is_device_connecting(struct device *dev, void *data, bool ignore_nonessential) |
198 | { |
199 | struct xenbus_device *xendev = to_xenbus_device(dev); |
200 | struct device_driver *drv = data; |
201 | struct xenbus_driver *xendrv; |
202 | |
203 | /* |
204 | * A device with no driver will never connect. We care only about |
205 | * devices which should currently be in the process of connecting. |
206 | */ |
207 | if (!dev->driver) |
208 | return 0; |
209 | |
210 | /* Is this search limited to a particular driver? */ |
211 | if (drv && (dev->driver != drv)) |
212 | return 0; |
213 | |
214 | xendrv = to_xenbus_driver(drv: dev->driver); |
215 | |
216 | if (ignore_nonessential && xendrv->not_essential) |
217 | return 0; |
218 | |
219 | return (xendev->state < XenbusStateConnected || |
220 | (xendev->state == XenbusStateConnected && |
221 | xendrv->is_ready && !xendrv->is_ready(xendev))); |
222 | } |
223 | static int essential_device_connecting(struct device *dev, void *data) |
224 | { |
225 | return is_device_connecting(dev, data, ignore_nonessential: true /* ignore PV[KBB+FB] */); |
226 | } |
227 | static int non_essential_device_connecting(struct device *dev, void *data) |
228 | { |
229 | return is_device_connecting(dev, data, ignore_nonessential: false); |
230 | } |
231 | |
232 | static int exists_essential_connecting_device(struct device_driver *drv) |
233 | { |
234 | return bus_for_each_dev(bus: &xenbus_frontend.bus, NULL, data: drv, |
235 | fn: essential_device_connecting); |
236 | } |
237 | static int exists_non_essential_connecting_device(struct device_driver *drv) |
238 | { |
239 | return bus_for_each_dev(bus: &xenbus_frontend.bus, NULL, data: drv, |
240 | fn: non_essential_device_connecting); |
241 | } |
242 | |
243 | static int print_device_status(struct device *dev, void *data) |
244 | { |
245 | struct xenbus_device *xendev = to_xenbus_device(dev); |
246 | struct device_driver *drv = data; |
247 | |
248 | /* Is this operation limited to a particular driver? */ |
249 | if (drv && (dev->driver != drv)) |
250 | return 0; |
251 | |
252 | if (!dev->driver) { |
253 | /* Information only: is this too noisy? */ |
254 | pr_info("Device with no driver: %s\n" , xendev->nodename); |
255 | } else if (xendev->state < XenbusStateConnected) { |
256 | enum xenbus_state rstate = XenbusStateUnknown; |
257 | if (xendev->otherend) |
258 | rstate = xenbus_read_driver_state(path: xendev->otherend); |
259 | pr_warn("Timeout connecting to device: %s (local state %d, remote state %d)\n" , |
260 | xendev->nodename, xendev->state, rstate); |
261 | } |
262 | |
263 | return 0; |
264 | } |
265 | |
266 | /* We only wait for device setup after most initcalls have run. */ |
267 | static int ready_to_wait_for_devices; |
268 | |
269 | static bool wait_loop(unsigned long start, unsigned int max_delay, |
270 | unsigned int *seconds_waited) |
271 | { |
272 | if (time_after(jiffies, start + (*seconds_waited+5)*HZ)) { |
273 | if (!*seconds_waited) |
274 | pr_warn("Waiting for devices to initialise: " ); |
275 | *seconds_waited += 5; |
276 | pr_cont("%us..." , max_delay - *seconds_waited); |
277 | if (*seconds_waited == max_delay) { |
278 | pr_cont("\n" ); |
279 | return true; |
280 | } |
281 | } |
282 | |
283 | schedule_timeout_interruptible(HZ/10); |
284 | |
285 | return false; |
286 | } |
287 | /* |
288 | * On a 5-minute timeout, wait for all devices currently configured. We need |
289 | * to do this to guarantee that the filesystems and / or network devices |
290 | * needed for boot are available, before we can allow the boot to proceed. |
291 | * |
292 | * This needs to be on a late_initcall, to happen after the frontend device |
293 | * drivers have been initialised, but before the root fs is mounted. |
294 | * |
295 | * A possible improvement here would be to have the tools add a per-device |
296 | * flag to the store entry, indicating whether it is needed at boot time. |
297 | * This would allow people who knew what they were doing to accelerate their |
298 | * boot slightly, but of course needs tools or manual intervention to set up |
299 | * those flags correctly. |
300 | */ |
301 | static void wait_for_devices(struct xenbus_driver *xendrv) |
302 | { |
303 | unsigned long start = jiffies; |
304 | struct device_driver *drv = xendrv ? &xendrv->driver : NULL; |
305 | unsigned int seconds_waited = 0; |
306 | |
307 | if (!ready_to_wait_for_devices || !xen_domain()) |
308 | return; |
309 | |
310 | while (exists_non_essential_connecting_device(drv)) |
311 | if (wait_loop(start, max_delay: 30, seconds_waited: &seconds_waited)) |
312 | break; |
313 | |
314 | /* Skips PVKB and PVFB check.*/ |
315 | while (exists_essential_connecting_device(drv)) |
316 | if (wait_loop(start, max_delay: 270, seconds_waited: &seconds_waited)) |
317 | break; |
318 | |
319 | if (seconds_waited) |
320 | printk("\n" ); |
321 | |
322 | bus_for_each_dev(bus: &xenbus_frontend.bus, NULL, data: drv, |
323 | fn: print_device_status); |
324 | } |
325 | |
326 | int __xenbus_register_frontend(struct xenbus_driver *drv, struct module *owner, |
327 | const char *mod_name) |
328 | { |
329 | int ret; |
330 | |
331 | drv->read_otherend_details = read_backend_details; |
332 | |
333 | ret = xenbus_register_driver_common(drv, bus: &xenbus_frontend, |
334 | owner, mod_name); |
335 | if (ret) |
336 | return ret; |
337 | |
338 | /* If this driver is loaded as a module wait for devices to attach. */ |
339 | wait_for_devices(xendrv: drv); |
340 | |
341 | return 0; |
342 | } |
343 | EXPORT_SYMBOL_GPL(__xenbus_register_frontend); |
344 | |
345 | static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq); |
346 | static int backend_state; |
347 | |
348 | static void xenbus_reset_backend_state_changed(struct xenbus_watch *w, |
349 | const char *path, const char *token) |
350 | { |
351 | if (xenbus_scanf(XBT_NIL, dir: path, node: "" , fmt: "%i" , |
352 | &backend_state) != 1) |
353 | backend_state = XenbusStateUnknown; |
354 | printk(KERN_DEBUG "XENBUS: backend %s %s\n" , |
355 | path, xenbus_strstate(backend_state)); |
356 | wake_up(&backend_state_wq); |
357 | } |
358 | |
359 | static void xenbus_reset_wait_for_backend(char *be, int expected) |
360 | { |
361 | long timeout; |
362 | timeout = wait_event_interruptible_timeout(backend_state_wq, |
363 | backend_state == expected, 5 * HZ); |
364 | if (timeout <= 0) |
365 | pr_info("backend %s timed out\n" , be); |
366 | } |
367 | |
368 | /* |
369 | * Reset frontend if it is in Connected or Closed state. |
370 | * Wait for backend to catch up. |
371 | * State Connected happens during kdump, Closed after kexec. |
372 | */ |
373 | static void xenbus_reset_frontend(char *fe, char *be, int be_state) |
374 | { |
375 | struct xenbus_watch be_watch; |
376 | |
377 | printk(KERN_DEBUG "XENBUS: backend %s %s\n" , |
378 | be, xenbus_strstate(be_state)); |
379 | |
380 | memset(&be_watch, 0, sizeof(be_watch)); |
381 | be_watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, fmt: "%s/state" , be); |
382 | if (!be_watch.node) |
383 | return; |
384 | |
385 | be_watch.callback = xenbus_reset_backend_state_changed; |
386 | backend_state = XenbusStateUnknown; |
387 | |
388 | pr_info("triggering reconnect on %s\n" , be); |
389 | register_xenbus_watch(watch: &be_watch); |
390 | |
391 | /* fall through to forward backend to state XenbusStateInitialising */ |
392 | switch (be_state) { |
393 | case XenbusStateConnected: |
394 | xenbus_printf(XBT_NIL, dir: fe, node: "state" , fmt: "%d" , XenbusStateClosing); |
395 | xenbus_reset_wait_for_backend(be, XenbusStateClosing); |
396 | fallthrough; |
397 | |
398 | case XenbusStateClosing: |
399 | xenbus_printf(XBT_NIL, fe, "state" , "%d" , XenbusStateClosed); |
400 | xenbus_reset_wait_for_backend(be, XenbusStateClosed); |
401 | fallthrough; |
402 | |
403 | case XenbusStateClosed: |
404 | xenbus_printf(XBT_NIL, fe, "state" , "%d" , XenbusStateInitialising); |
405 | xenbus_reset_wait_for_backend(be, XenbusStateInitWait); |
406 | } |
407 | |
408 | unregister_xenbus_watch(&be_watch); |
409 | pr_info("reconnect done on %s\n" , be); |
410 | kfree(be_watch.node); |
411 | } |
412 | |
413 | static void xenbus_check_frontend(char *class, char *dev) |
414 | { |
415 | int be_state, fe_state, err; |
416 | char *backend, *frontend; |
417 | |
418 | frontend = kasprintf(GFP_NOIO | __GFP_HIGH, fmt: "device/%s/%s" , class, dev); |
419 | if (!frontend) |
420 | return; |
421 | |
422 | err = xenbus_scanf(XBT_NIL, dir: frontend, node: "state" , fmt: "%i" , &fe_state); |
423 | if (err != 1) |
424 | goto out; |
425 | |
426 | switch (fe_state) { |
427 | case XenbusStateConnected: |
428 | case XenbusStateClosed: |
429 | printk(KERN_DEBUG "XENBUS: frontend %s %s\n" , |
430 | frontend, xenbus_strstate(fe_state)); |
431 | backend = xenbus_read(XBT_NIL, frontend, "backend" , NULL); |
432 | if (IS_ERR_OR_NULL(backend)) |
433 | goto out; |
434 | err = xenbus_scanf(XBT_NIL, backend, "state" , "%i" , &be_state); |
435 | if (err == 1) |
436 | xenbus_reset_frontend(frontend, backend, be_state); |
437 | kfree(backend); |
438 | break; |
439 | default: |
440 | break; |
441 | } |
442 | out: |
443 | kfree(frontend); |
444 | } |
445 | |
446 | static void xenbus_reset_state(void) |
447 | { |
448 | char **devclass, **dev; |
449 | int devclass_n, dev_n; |
450 | int i, j; |
451 | |
452 | devclass = xenbus_directory(XBT_NIL, dir: "device" , node: "" , num: &devclass_n); |
453 | if (IS_ERR(devclass)) |
454 | return; |
455 | |
456 | for (i = 0; i < devclass_n; i++) { |
457 | dev = xenbus_directory(XBT_NIL, "device" , devclass[i], &dev_n); |
458 | if (IS_ERR(dev)) |
459 | continue; |
460 | for (j = 0; j < dev_n; j++) |
461 | xenbus_check_frontend(devclass[i], dev[j]); |
462 | kfree(dev); |
463 | } |
464 | kfree(devclass); |
465 | } |
466 | |
467 | static int frontend_probe_and_watch(struct notifier_block *notifier, |
468 | unsigned long event, |
469 | void *data) |
470 | { |
471 | /* reset devices in Connected or Closed state */ |
472 | if (xen_hvm_domain()) |
473 | xenbus_reset_state(); |
474 | /* Enumerate devices in xenstore and watch for changes. */ |
475 | xenbus_probe_devices(bus: &xenbus_frontend); |
476 | register_xenbus_watch(watch: &fe_watch); |
477 | |
478 | return NOTIFY_DONE; |
479 | } |
480 | |
481 | |
482 | static int __init xenbus_probe_frontend_init(void) |
483 | { |
484 | static struct notifier_block xenstore_notifier = { |
485 | .notifier_call = frontend_probe_and_watch |
486 | }; |
487 | int err; |
488 | |
489 | DPRINTK("" ); |
490 | |
491 | /* Register ourselves with the kernel bus subsystem */ |
492 | err = bus_register(bus: &xenbus_frontend.bus); |
493 | if (err) |
494 | return err; |
495 | |
496 | register_xenstore_notifier(nb: &xenstore_notifier); |
497 | |
498 | return 0; |
499 | } |
500 | subsys_initcall(xenbus_probe_frontend_init); |
501 | |
502 | #ifndef MODULE |
503 | static int __init boot_wait_for_devices(void) |
504 | { |
505 | if (!xen_has_pv_devices()) |
506 | return -ENODEV; |
507 | |
508 | ready_to_wait_for_devices = 1; |
509 | wait_for_devices(NULL); |
510 | return 0; |
511 | } |
512 | |
513 | late_initcall(boot_wait_for_devices); |
514 | #endif |
515 | |
516 | MODULE_LICENSE("GPL" ); |
517 | |