xref: /linux/drivers/xen/xenbus/xenbus_probe.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 /******************************************************************************
2  * Talks to Xen Store to figure out what devices we have.
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  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version 2
10  * as published by the Free Software Foundation; or, when distributed
11  * separately from the Linux kernel or incorporated into other
12  * software packages, subject to the following license:
13  *
14  * Permission is hereby granted, free of charge, to any person obtaining a copy
15  * of this source file (the "Software"), to deal in the Software without
16  * restriction, including without limitation the rights to use, copy, modify,
17  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
18  * and to permit persons to whom the Software is furnished to do so, subject to
19  * the following conditions:
20  *
21  * The above copyright notice and this permission notice shall be included in
22  * all copies or substantial portions of the Software.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
30  * IN THE SOFTWARE.
31  */
32 
33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34 #define dev_fmt pr_fmt
35 
36 #define DPRINTK(fmt, args...)				\
37 	pr_debug("xenbus_probe (%s:%d) " fmt ".\n",	\
38 		 __func__, __LINE__, ##args)
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/proc_fs.h>
47 #include <linux/notifier.h>
48 #include <linux/kthread.h>
49 #include <linux/mutex.h>
50 #include <linux/io.h>
51 #include <linux/slab.h>
52 #include <linux/module.h>
53 
54 #include <asm/page.h>
55 #include <asm/xen/hypervisor.h>
56 
57 #include <xen/xen.h>
58 #include <xen/xenbus.h>
59 #include <xen/events.h>
60 #include <xen/xen-ops.h>
61 #include <xen/page.h>
62 
63 #include <xen/hvm.h>
64 
65 #include "xenbus.h"
66 
67 
68 static int xs_init_irq = -1;
69 int xen_store_evtchn;
70 EXPORT_SYMBOL_GPL(xen_store_evtchn);
71 
72 struct xenstore_domain_interface *xen_store_interface;
73 EXPORT_SYMBOL_GPL(xen_store_interface);
74 
75 #define XS_INTERFACE_READY \
76 	((xen_store_interface != NULL) && \
77 	 (xen_store_interface->connection == XENSTORE_CONNECTED))
78 
79 enum xenstore_init xen_store_domain_type;
80 EXPORT_SYMBOL_GPL(xen_store_domain_type);
81 
82 static unsigned long xen_store_gfn;
83 
84 static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
85 
86 /* If something in array of ids matches this device, return it. */
87 static const struct xenbus_device_id *
match_device(const struct xenbus_device_id * arr,struct xenbus_device * dev)88 match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev)
89 {
90 	for (; *arr->devicetype != '\0'; arr++) {
91 		if (!strcmp(arr->devicetype, dev->devicetype))
92 			return arr;
93 	}
94 	return NULL;
95 }
96 
xenbus_match(struct device * _dev,const struct device_driver * _drv)97 int xenbus_match(struct device *_dev, const struct device_driver *_drv)
98 {
99 	const struct xenbus_driver *drv = to_xenbus_driver(_drv);
100 
101 	if (!drv->ids)
102 		return 0;
103 
104 	return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;
105 }
106 EXPORT_SYMBOL_GPL(xenbus_match);
107 
108 
free_otherend_details(struct xenbus_device * dev)109 static void free_otherend_details(struct xenbus_device *dev)
110 {
111 	kfree(dev->otherend);
112 	dev->otherend = NULL;
113 }
114 
115 
free_otherend_watch(struct xenbus_device * dev)116 static void free_otherend_watch(struct xenbus_device *dev)
117 {
118 	if (dev->otherend_watch.node) {
119 		unregister_xenbus_watch(&dev->otherend_watch);
120 		kfree(dev->otherend_watch.node);
121 		dev->otherend_watch.node = NULL;
122 	}
123 }
124 
125 
talk_to_otherend(struct xenbus_device * dev)126 static int talk_to_otherend(struct xenbus_device *dev)
127 {
128 	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
129 
130 	free_otherend_watch(dev);
131 	free_otherend_details(dev);
132 
133 	return drv->read_otherend_details(dev);
134 }
135 
136 
137 
watch_otherend(struct xenbus_device * dev)138 static int watch_otherend(struct xenbus_device *dev)
139 {
140 	struct xen_bus_type *bus =
141 		container_of(dev->dev.bus, struct xen_bus_type, bus);
142 
143 	return xenbus_watch_pathfmt(dev, &dev->otherend_watch,
144 				    bus->otherend_will_handle,
145 				    bus->otherend_changed,
146 				    "%s/%s", dev->otherend, "state");
147 }
148 
149 
xenbus_read_otherend_details(struct xenbus_device * xendev,char * id_node,char * path_node)150 int xenbus_read_otherend_details(struct xenbus_device *xendev,
151 				 char *id_node, char *path_node)
152 {
153 	int err = xenbus_gather(XBT_NIL, xendev->nodename,
154 				id_node, "%i", &xendev->otherend_id,
155 				path_node, NULL, &xendev->otherend,
156 				NULL);
157 	if (err) {
158 		xenbus_dev_fatal(xendev, err,
159 				 "reading other end details from %s",
160 				 xendev->nodename);
161 		return err;
162 	}
163 	if (strlen(xendev->otherend) == 0 ||
164 	    !xenbus_exists(XBT_NIL, xendev->otherend, "")) {
165 		xenbus_dev_fatal(xendev, -ENOENT,
166 				 "unable to read other end from %s.  "
167 				 "missing or inaccessible.",
168 				 xendev->nodename);
169 		free_otherend_details(xendev);
170 		return -ENOENT;
171 	}
172 
173 	return 0;
174 }
175 EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);
176 
xenbus_otherend_changed(struct xenbus_watch * watch,const char * path,const char * token,int ignore_on_shutdown)177 void xenbus_otherend_changed(struct xenbus_watch *watch,
178 			     const char *path, const char *token,
179 			     int ignore_on_shutdown)
180 {
181 	struct xenbus_device *dev =
182 		container_of(watch, struct xenbus_device, otherend_watch);
183 	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
184 	enum xenbus_state state;
185 
186 	/* Protect us against watches firing on old details when the otherend
187 	   details change, say immediately after a resume. */
188 	if (!dev->otherend ||
189 	    strncmp(dev->otherend, path, strlen(dev->otherend))) {
190 		dev_dbg(&dev->dev, "Ignoring watch at %s\n", path);
191 		return;
192 	}
193 
194 	state = xenbus_read_driver_state(dev->otherend);
195 
196 	dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n",
197 		state, xenbus_strstate(state), dev->otherend_watch.node, path);
198 
199 	/*
200 	 * Ignore xenbus transitions during shutdown. This prevents us doing
201 	 * work that can fail e.g., when the rootfs is gone.
202 	 */
203 	if (system_state > SYSTEM_RUNNING) {
204 		if (ignore_on_shutdown && (state == XenbusStateClosing))
205 			xenbus_frontend_closed(dev);
206 		return;
207 	}
208 
209 	if (drv->otherend_changed)
210 		drv->otherend_changed(dev, state);
211 }
212 EXPORT_SYMBOL_GPL(xenbus_otherend_changed);
213 
214 #define XENBUS_SHOW_STAT(name)						\
215 static ssize_t name##_show(struct device *_dev,				\
216 			   struct device_attribute *attr,		\
217 			   char *buf)					\
218 {									\
219 	struct xenbus_device *dev = to_xenbus_device(_dev);		\
220 									\
221 	return sprintf(buf, "%d\n", atomic_read(&dev->name));		\
222 }									\
223 static DEVICE_ATTR_RO(name)
224 
225 XENBUS_SHOW_STAT(event_channels);
226 XENBUS_SHOW_STAT(events);
227 XENBUS_SHOW_STAT(spurious_events);
228 XENBUS_SHOW_STAT(jiffies_eoi_delayed);
229 
spurious_threshold_show(struct device * _dev,struct device_attribute * attr,char * buf)230 static ssize_t spurious_threshold_show(struct device *_dev,
231 				       struct device_attribute *attr,
232 				       char *buf)
233 {
234 	struct xenbus_device *dev = to_xenbus_device(_dev);
235 
236 	return sprintf(buf, "%d\n", dev->spurious_threshold);
237 }
238 
spurious_threshold_store(struct device * _dev,struct device_attribute * attr,const char * buf,size_t count)239 static ssize_t spurious_threshold_store(struct device *_dev,
240 					struct device_attribute *attr,
241 					const char *buf, size_t count)
242 {
243 	struct xenbus_device *dev = to_xenbus_device(_dev);
244 	unsigned int val;
245 	ssize_t ret;
246 
247 	ret = kstrtouint(buf, 0, &val);
248 	if (ret)
249 		return ret;
250 
251 	dev->spurious_threshold = val;
252 
253 	return count;
254 }
255 
256 static DEVICE_ATTR_RW(spurious_threshold);
257 
258 static struct attribute *xenbus_attrs[] = {
259 	&dev_attr_event_channels.attr,
260 	&dev_attr_events.attr,
261 	&dev_attr_spurious_events.attr,
262 	&dev_attr_jiffies_eoi_delayed.attr,
263 	&dev_attr_spurious_threshold.attr,
264 	NULL
265 };
266 
267 static const struct attribute_group xenbus_group = {
268 	.name = "xenbus",
269 	.attrs = xenbus_attrs,
270 };
271 
xenbus_dev_probe(struct device * _dev)272 int xenbus_dev_probe(struct device *_dev)
273 {
274 	struct xenbus_device *dev = to_xenbus_device(_dev);
275 	struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);
276 	const struct xenbus_device_id *id;
277 	int err;
278 
279 	DPRINTK("%s", dev->nodename);
280 
281 	if (!drv->probe) {
282 		err = -ENODEV;
283 		goto fail;
284 	}
285 
286 	id = match_device(drv->ids, dev);
287 	if (!id) {
288 		err = -ENODEV;
289 		goto fail;
290 	}
291 
292 	err = talk_to_otherend(dev);
293 	if (err) {
294 		dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n",
295 			 dev->nodename);
296 		return err;
297 	}
298 
299 	if (!try_module_get(drv->driver.owner)) {
300 		dev_warn(&dev->dev, "failed to acquire module reference on '%s'\n",
301 			 drv->driver.name);
302 		err = -ESRCH;
303 		goto fail;
304 	}
305 
306 	down(&dev->reclaim_sem);
307 	err = drv->probe(dev, id);
308 	up(&dev->reclaim_sem);
309 	if (err)
310 		goto fail_put;
311 
312 	err = watch_otherend(dev);
313 	if (err) {
314 		dev_warn(&dev->dev, "watch_otherend on %s failed.\n",
315 		       dev->nodename);
316 		return err;
317 	}
318 
319 	dev->spurious_threshold = 1;
320 	if (sysfs_create_group(&dev->dev.kobj, &xenbus_group))
321 		dev_warn(&dev->dev, "sysfs_create_group on %s failed.\n",
322 			 dev->nodename);
323 
324 	return 0;
325 fail_put:
326 	module_put(drv->driver.owner);
327 fail:
328 	xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename);
329 	return err;
330 }
331 EXPORT_SYMBOL_GPL(xenbus_dev_probe);
332 
xenbus_dev_remove(struct device * _dev)333 void xenbus_dev_remove(struct device *_dev)
334 {
335 	struct xenbus_device *dev = to_xenbus_device(_dev);
336 	struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);
337 
338 	DPRINTK("%s", dev->nodename);
339 
340 	sysfs_remove_group(&dev->dev.kobj, &xenbus_group);
341 
342 	free_otherend_watch(dev);
343 
344 	if (drv->remove) {
345 		down(&dev->reclaim_sem);
346 		drv->remove(dev);
347 		up(&dev->reclaim_sem);
348 	}
349 
350 	module_put(drv->driver.owner);
351 
352 	free_otherend_details(dev);
353 
354 	/*
355 	 * If the toolstack has forced the device state to closing then set
356 	 * the state to closed now to allow it to be cleaned up.
357 	 * Similarly, if the driver does not support re-bind, set the
358 	 * closed.
359 	 */
360 	if (!drv->allow_rebind ||
361 	    xenbus_read_driver_state(dev->nodename) == XenbusStateClosing)
362 		xenbus_switch_state(dev, XenbusStateClosed);
363 }
364 EXPORT_SYMBOL_GPL(xenbus_dev_remove);
365 
xenbus_register_driver_common(struct xenbus_driver * drv,struct xen_bus_type * bus,struct module * owner,const char * mod_name)366 int xenbus_register_driver_common(struct xenbus_driver *drv,
367 				  struct xen_bus_type *bus,
368 				  struct module *owner, const char *mod_name)
369 {
370 	drv->driver.name = drv->name ? drv->name : drv->ids[0].devicetype;
371 	drv->driver.bus = &bus->bus;
372 	drv->driver.owner = owner;
373 	drv->driver.mod_name = mod_name;
374 
375 	return driver_register(&drv->driver);
376 }
377 EXPORT_SYMBOL_GPL(xenbus_register_driver_common);
378 
xenbus_unregister_driver(struct xenbus_driver * drv)379 void xenbus_unregister_driver(struct xenbus_driver *drv)
380 {
381 	driver_unregister(&drv->driver);
382 }
383 EXPORT_SYMBOL_GPL(xenbus_unregister_driver);
384 
385 struct xb_find_info {
386 	struct xenbus_device *dev;
387 	const char *nodename;
388 };
389 
cmp_dev(struct device * dev,void * data)390 static int cmp_dev(struct device *dev, void *data)
391 {
392 	struct xenbus_device *xendev = to_xenbus_device(dev);
393 	struct xb_find_info *info = data;
394 
395 	if (!strcmp(xendev->nodename, info->nodename)) {
396 		info->dev = xendev;
397 		get_device(dev);
398 		return 1;
399 	}
400 	return 0;
401 }
402 
xenbus_device_find(const char * nodename,struct bus_type * bus)403 static struct xenbus_device *xenbus_device_find(const char *nodename,
404 						struct bus_type *bus)
405 {
406 	struct xb_find_info info = { .dev = NULL, .nodename = nodename };
407 
408 	bus_for_each_dev(bus, NULL, &info, cmp_dev);
409 	return info.dev;
410 }
411 
cleanup_dev(struct device * dev,void * data)412 static int cleanup_dev(struct device *dev, void *data)
413 {
414 	struct xenbus_device *xendev = to_xenbus_device(dev);
415 	struct xb_find_info *info = data;
416 	int len = strlen(info->nodename);
417 
418 	DPRINTK("%s", info->nodename);
419 
420 	/* Match the info->nodename path, or any subdirectory of that path. */
421 	if (strncmp(xendev->nodename, info->nodename, len))
422 		return 0;
423 
424 	/* If the node name is longer, ensure it really is a subdirectory. */
425 	if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/'))
426 		return 0;
427 
428 	info->dev = xendev;
429 	get_device(dev);
430 	return 1;
431 }
432 
xenbus_cleanup_devices(const char * path,struct bus_type * bus)433 static void xenbus_cleanup_devices(const char *path, struct bus_type *bus)
434 {
435 	struct xb_find_info info = { .nodename = path };
436 
437 	do {
438 		info.dev = NULL;
439 		bus_for_each_dev(bus, NULL, &info, cleanup_dev);
440 		if (info.dev) {
441 			device_unregister(&info.dev->dev);
442 			put_device(&info.dev->dev);
443 		}
444 	} while (info.dev);
445 }
446 
xenbus_dev_release(struct device * dev)447 static void xenbus_dev_release(struct device *dev)
448 {
449 	if (dev)
450 		kfree(to_xenbus_device(dev));
451 }
452 
nodename_show(struct device * dev,struct device_attribute * attr,char * buf)453 static ssize_t nodename_show(struct device *dev,
454 			     struct device_attribute *attr, char *buf)
455 {
456 	return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);
457 }
458 static DEVICE_ATTR_RO(nodename);
459 
devtype_show(struct device * dev,struct device_attribute * attr,char * buf)460 static ssize_t devtype_show(struct device *dev,
461 			    struct device_attribute *attr, char *buf)
462 {
463 	return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);
464 }
465 static DEVICE_ATTR_RO(devtype);
466 
modalias_show(struct device * dev,struct device_attribute * attr,char * buf)467 static ssize_t modalias_show(struct device *dev,
468 			     struct device_attribute *attr, char *buf)
469 {
470 	return sprintf(buf, "%s:%s\n", dev->bus->name,
471 		       to_xenbus_device(dev)->devicetype);
472 }
473 static DEVICE_ATTR_RO(modalias);
474 
state_show(struct device * dev,struct device_attribute * attr,char * buf)475 static ssize_t state_show(struct device *dev,
476 			    struct device_attribute *attr, char *buf)
477 {
478 	return sprintf(buf, "%s\n",
479 			xenbus_strstate(to_xenbus_device(dev)->state));
480 }
481 static DEVICE_ATTR_RO(state);
482 
483 static struct attribute *xenbus_dev_attrs[] = {
484 	&dev_attr_nodename.attr,
485 	&dev_attr_devtype.attr,
486 	&dev_attr_modalias.attr,
487 	&dev_attr_state.attr,
488 	NULL,
489 };
490 
491 static const struct attribute_group xenbus_dev_group = {
492 	.attrs = xenbus_dev_attrs,
493 };
494 
495 const struct attribute_group *xenbus_dev_groups[] = {
496 	&xenbus_dev_group,
497 	NULL,
498 };
499 EXPORT_SYMBOL_GPL(xenbus_dev_groups);
500 
xenbus_probe_node(struct xen_bus_type * bus,const char * type,const char * nodename)501 int xenbus_probe_node(struct xen_bus_type *bus,
502 		      const char *type,
503 		      const char *nodename)
504 {
505 	char devname[XEN_BUS_ID_SIZE];
506 	int err;
507 	struct xenbus_device *xendev;
508 	size_t stringlen;
509 	char *tmpstring;
510 
511 	enum xenbus_state state = xenbus_read_driver_state(nodename);
512 
513 	if (state != XenbusStateInitialising) {
514 		/* Device is not new, so ignore it.  This can happen if a
515 		   device is going away after switching to Closed.  */
516 		return 0;
517 	}
518 
519 	stringlen = strlen(nodename) + 1 + strlen(type) + 1;
520 	xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL);
521 	if (!xendev)
522 		return -ENOMEM;
523 
524 	xendev->state = XenbusStateInitialising;
525 
526 	/* Copy the strings into the extra space. */
527 
528 	tmpstring = (char *)(xendev + 1);
529 	strcpy(tmpstring, nodename);
530 	xendev->nodename = tmpstring;
531 
532 	tmpstring += strlen(tmpstring) + 1;
533 	strcpy(tmpstring, type);
534 	xendev->devicetype = tmpstring;
535 	init_completion(&xendev->down);
536 
537 	xendev->dev.bus = &bus->bus;
538 	xendev->dev.release = xenbus_dev_release;
539 
540 	err = bus->get_bus_id(devname, xendev->nodename);
541 	if (err)
542 		goto fail;
543 
544 	dev_set_name(&xendev->dev, "%s", devname);
545 	sema_init(&xendev->reclaim_sem, 1);
546 
547 	/* Register with generic device framework. */
548 	err = device_register(&xendev->dev);
549 	if (err) {
550 		put_device(&xendev->dev);
551 		xendev = NULL;
552 		goto fail;
553 	}
554 
555 	return 0;
556 fail:
557 	kfree(xendev);
558 	return err;
559 }
560 EXPORT_SYMBOL_GPL(xenbus_probe_node);
561 
xenbus_probe_device_type(struct xen_bus_type * bus,const char * type)562 static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)
563 {
564 	int err = 0;
565 	char **dir;
566 	unsigned int dir_n = 0;
567 	int i;
568 
569 	dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n);
570 	if (IS_ERR(dir))
571 		return PTR_ERR(dir);
572 
573 	for (i = 0; i < dir_n; i++) {
574 		err = bus->probe(bus, type, dir[i]);
575 		if (err)
576 			break;
577 	}
578 
579 	kfree(dir);
580 	return err;
581 }
582 
xenbus_probe_devices(struct xen_bus_type * bus)583 int xenbus_probe_devices(struct xen_bus_type *bus)
584 {
585 	int err = 0;
586 	char **dir;
587 	unsigned int i, dir_n;
588 
589 	dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n);
590 	if (IS_ERR(dir))
591 		return PTR_ERR(dir);
592 
593 	for (i = 0; i < dir_n; i++) {
594 		err = xenbus_probe_device_type(bus, dir[i]);
595 		if (err)
596 			break;
597 	}
598 
599 	kfree(dir);
600 	return err;
601 }
602 EXPORT_SYMBOL_GPL(xenbus_probe_devices);
603 
char_count(const char * str,char c)604 static unsigned int char_count(const char *str, char c)
605 {
606 	unsigned int i, ret = 0;
607 
608 	for (i = 0; str[i]; i++)
609 		if (str[i] == c)
610 			ret++;
611 	return ret;
612 }
613 
strsep_len(const char * str,char c,unsigned int len)614 static int strsep_len(const char *str, char c, unsigned int len)
615 {
616 	unsigned int i;
617 
618 	for (i = 0; str[i]; i++)
619 		if (str[i] == c) {
620 			if (len == 0)
621 				return i;
622 			len--;
623 		}
624 	return (len == 0) ? i : -ERANGE;
625 }
626 
xenbus_dev_changed(const char * node,struct xen_bus_type * bus)627 void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
628 {
629 	int exists, rootlen;
630 	struct xenbus_device *dev;
631 	char type[XEN_BUS_ID_SIZE];
632 	const char *p, *root;
633 
634 	if (char_count(node, '/') < 2)
635 		return;
636 
637 	exists = xenbus_exists(XBT_NIL, node, "");
638 	if (!exists) {
639 		xenbus_cleanup_devices(node, &bus->bus);
640 		return;
641 	}
642 
643 	/* backend/<type>/... or device/<type>/... */
644 	p = strchr(node, '/') + 1;
645 	snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p);
646 	type[XEN_BUS_ID_SIZE-1] = '\0';
647 
648 	rootlen = strsep_len(node, '/', bus->levels);
649 	if (rootlen < 0)
650 		return;
651 	root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node);
652 	if (!root)
653 		return;
654 
655 	dev = xenbus_device_find(root, &bus->bus);
656 	if (!dev)
657 		xenbus_probe_node(bus, type, root);
658 	else
659 		put_device(&dev->dev);
660 
661 	kfree(root);
662 }
663 EXPORT_SYMBOL_GPL(xenbus_dev_changed);
664 
xenbus_dev_suspend(struct device * dev)665 int xenbus_dev_suspend(struct device *dev)
666 {
667 	int err = 0;
668 	struct xenbus_driver *drv;
669 	struct xenbus_device *xdev
670 		= container_of(dev, struct xenbus_device, dev);
671 
672 	DPRINTK("%s", xdev->nodename);
673 
674 	if (dev->driver == NULL)
675 		return 0;
676 	drv = to_xenbus_driver(dev->driver);
677 	if (drv->suspend)
678 		err = drv->suspend(xdev);
679 	if (err)
680 		dev_warn(dev, "suspend failed: %i\n", err);
681 	return 0;
682 }
683 EXPORT_SYMBOL_GPL(xenbus_dev_suspend);
684 
xenbus_dev_resume(struct device * dev)685 int xenbus_dev_resume(struct device *dev)
686 {
687 	int err;
688 	struct xenbus_driver *drv;
689 	struct xenbus_device *xdev
690 		= container_of(dev, struct xenbus_device, dev);
691 
692 	DPRINTK("%s", xdev->nodename);
693 
694 	if (dev->driver == NULL)
695 		return 0;
696 	drv = to_xenbus_driver(dev->driver);
697 	err = talk_to_otherend(xdev);
698 	if (err) {
699 		dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err);
700 		return err;
701 	}
702 
703 	xdev->state = XenbusStateInitialising;
704 
705 	if (drv->resume) {
706 		err = drv->resume(xdev);
707 		if (err) {
708 			dev_warn(dev, "resume failed: %i\n", err);
709 			return err;
710 		}
711 	}
712 
713 	err = watch_otherend(xdev);
714 	if (err) {
715 		dev_warn(dev, "resume (watch_otherend) failed: %d\n", err);
716 		return err;
717 	}
718 
719 	return 0;
720 }
721 EXPORT_SYMBOL_GPL(xenbus_dev_resume);
722 
xenbus_dev_cancel(struct device * dev)723 int xenbus_dev_cancel(struct device *dev)
724 {
725 	/* Do nothing */
726 	DPRINTK("cancel");
727 	return 0;
728 }
729 EXPORT_SYMBOL_GPL(xenbus_dev_cancel);
730 
731 /* A flag to determine if xenstored is 'ready' (i.e. has started) */
732 int xenstored_ready;
733 
734 
register_xenstore_notifier(struct notifier_block * nb)735 int register_xenstore_notifier(struct notifier_block *nb)
736 {
737 	int ret = 0;
738 
739 	if (xenstored_ready > 0)
740 		ret = nb->notifier_call(nb, 0, NULL);
741 	else
742 		blocking_notifier_chain_register(&xenstore_chain, nb);
743 
744 	return ret;
745 }
746 EXPORT_SYMBOL_GPL(register_xenstore_notifier);
747 
unregister_xenstore_notifier(struct notifier_block * nb)748 void unregister_xenstore_notifier(struct notifier_block *nb)
749 {
750 	blocking_notifier_chain_unregister(&xenstore_chain, nb);
751 }
752 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
753 
xenbus_probe(void)754 static void xenbus_probe(void)
755 {
756 	xenstored_ready = 1;
757 
758 	if (!xen_store_interface)
759 		xen_store_interface = memremap(xen_store_gfn << XEN_PAGE_SHIFT,
760 					       XEN_PAGE_SIZE, MEMREMAP_WB);
761 	/*
762 	 * Now it is safe to free the IRQ used for xenstore late
763 	 * initialization. No need to unbind: it is about to be
764 	 * bound again from xb_init_comms. Note that calling
765 	 * unbind_from_irqhandler now would result in xen_evtchn_close()
766 	 * being called and the event channel not being enabled again
767 	 * afterwards, resulting in missed event notifications.
768 	 */
769 	if (xs_init_irq >= 0)
770 		free_irq(xs_init_irq, &xb_waitq);
771 
772 	/*
773 	 * In the HVM case, xenbus_init() deferred its call to
774 	 * xs_init() in case callbacks were not operational yet.
775 	 * So do it now.
776 	 */
777 	if (xen_store_domain_type == XS_HVM)
778 		xs_init();
779 
780 	/* Notify others that xenstore is up */
781 	blocking_notifier_call_chain(&xenstore_chain, 0, NULL);
782 }
783 
784 /*
785  * Returns true when XenStore init must be deferred in order to
786  * allow the PCI platform device to be initialised, before we
787  * can actually have event channel interrupts working.
788  */
xs_hvm_defer_init_for_callback(void)789 static bool xs_hvm_defer_init_for_callback(void)
790 {
791 #ifdef CONFIG_XEN_PVHVM
792 	return xen_store_domain_type == XS_HVM &&
793 		!xen_have_vector_callback;
794 #else
795 	return false;
796 #endif
797 }
798 
xenbus_probe_thread(void * unused)799 static int xenbus_probe_thread(void *unused)
800 {
801 	DEFINE_WAIT(w);
802 
803 	/*
804 	 * We actually just want to wait for *any* trigger of xb_waitq,
805 	 * and run xenbus_probe() the moment it occurs.
806 	 */
807 	prepare_to_wait(&xb_waitq, &w, TASK_INTERRUPTIBLE);
808 	schedule();
809 	finish_wait(&xb_waitq, &w);
810 
811 	DPRINTK("probing");
812 	xenbus_probe();
813 	return 0;
814 }
815 
xenbus_probe_initcall(void)816 static int __init xenbus_probe_initcall(void)
817 {
818 	if (!xen_domain())
819 		return -ENODEV;
820 
821 	/*
822 	 * Probe XenBus here in the XS_PV case, and also XS_HVM unless we
823 	 * need to wait for the platform PCI device to come up or
824 	 * xen_store_interface is not ready.
825 	 */
826 	if (xen_store_domain_type == XS_PV ||
827 	    (xen_store_domain_type == XS_HVM &&
828 	     !xs_hvm_defer_init_for_callback() &&
829 	     XS_INTERFACE_READY))
830 		xenbus_probe();
831 
832 	/*
833 	 * For XS_LOCAL or when xen_store_interface is not ready, spawn a
834 	 * thread which will wait for xenstored or a xenstore-stubdom to be
835 	 * started, then probe.  It will be triggered when communication
836 	 * starts happening, by waiting on xb_waitq.
837 	 */
838 	if (xen_store_domain_type == XS_LOCAL || !XS_INTERFACE_READY) {
839 		struct task_struct *probe_task;
840 
841 		probe_task = kthread_run(xenbus_probe_thread, NULL,
842 					 "xenbus_probe");
843 		if (IS_ERR(probe_task))
844 			return PTR_ERR(probe_task);
845 	}
846 	return 0;
847 }
848 device_initcall(xenbus_probe_initcall);
849 
xen_set_callback_via(uint64_t via)850 int xen_set_callback_via(uint64_t via)
851 {
852 	struct xen_hvm_param a;
853 	int ret;
854 
855 	a.domid = DOMID_SELF;
856 	a.index = HVM_PARAM_CALLBACK_IRQ;
857 	a.value = via;
858 
859 	ret = HYPERVISOR_hvm_op(HVMOP_set_param, &a);
860 	if (ret)
861 		return ret;
862 
863 	/*
864 	 * If xenbus_probe_initcall() deferred the xenbus_probe()
865 	 * due to the callback not functioning yet, we can do it now.
866 	 */
867 	if (!xenstored_ready && xs_hvm_defer_init_for_callback())
868 		xenbus_probe();
869 
870 	return ret;
871 }
872 EXPORT_SYMBOL_GPL(xen_set_callback_via);
873 
874 /* Set up event channel for xenstored which is run as a local process
875  * (this is normally used only in dom0)
876  */
xenstored_local_init(void)877 static int __init xenstored_local_init(void)
878 {
879 	int err = -ENOMEM;
880 	unsigned long page = 0;
881 	struct evtchn_alloc_unbound alloc_unbound;
882 
883 	/* Allocate Xenstore page */
884 	page = get_zeroed_page(GFP_KERNEL);
885 	if (!page)
886 		goto out_err;
887 
888 	xen_store_gfn = virt_to_gfn((void *)page);
889 
890 	/* Next allocate a local port which xenstored can bind to */
891 	alloc_unbound.dom        = DOMID_SELF;
892 	alloc_unbound.remote_dom = DOMID_SELF;
893 
894 	err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
895 					  &alloc_unbound);
896 	if (err == -ENOSYS)
897 		goto out_err;
898 
899 	BUG_ON(err);
900 	xen_store_evtchn = alloc_unbound.port;
901 
902 	return 0;
903 
904  out_err:
905 	if (page != 0)
906 		free_page(page);
907 	return err;
908 }
909 
xenbus_resume_cb(struct notifier_block * nb,unsigned long action,void * data)910 static int xenbus_resume_cb(struct notifier_block *nb,
911 			    unsigned long action, void *data)
912 {
913 	int err = 0;
914 
915 	if (xen_hvm_domain()) {
916 		uint64_t v = 0;
917 
918 		err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);
919 		if (!err && v)
920 			xen_store_evtchn = v;
921 		else
922 			pr_warn("Cannot update xenstore event channel: %d\n",
923 				err);
924 	} else
925 		xen_store_evtchn = xen_start_info->store_evtchn;
926 
927 	return err;
928 }
929 
930 static struct notifier_block xenbus_resume_nb = {
931 	.notifier_call = xenbus_resume_cb,
932 };
933 
xenbus_late_init(int irq,void * unused)934 static irqreturn_t xenbus_late_init(int irq, void *unused)
935 {
936 	int err;
937 	uint64_t v = 0;
938 
939 	err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v);
940 	if (err || !v || !~v)
941 		return IRQ_HANDLED;
942 	xen_store_gfn = (unsigned long)v;
943 
944 	wake_up(&xb_waitq);
945 	return IRQ_HANDLED;
946 }
947 
xenbus_init(void)948 static int __init xenbus_init(void)
949 {
950 	int err;
951 	uint64_t v = 0;
952 	bool wait = false;
953 	xen_store_domain_type = XS_UNKNOWN;
954 
955 	if (!xen_domain())
956 		return -ENODEV;
957 
958 	xenbus_ring_ops_init();
959 
960 	if (xen_pv_domain())
961 		xen_store_domain_type = XS_PV;
962 	if (xen_hvm_domain())
963 		xen_store_domain_type = XS_HVM;
964 	if (xen_hvm_domain() && xen_initial_domain())
965 		xen_store_domain_type = XS_LOCAL;
966 	if (xen_pv_domain() && !xen_start_info->store_evtchn)
967 		xen_store_domain_type = XS_LOCAL;
968 	if (xen_pv_domain() && xen_start_info->store_evtchn)
969 		xenstored_ready = 1;
970 
971 	switch (xen_store_domain_type) {
972 	case XS_LOCAL:
973 		err = xenstored_local_init();
974 		if (err)
975 			goto out_error;
976 		xen_store_interface = gfn_to_virt(xen_store_gfn);
977 		break;
978 	case XS_PV:
979 		xen_store_evtchn = xen_start_info->store_evtchn;
980 		xen_store_gfn = xen_start_info->store_mfn;
981 		xen_store_interface = gfn_to_virt(xen_store_gfn);
982 		break;
983 	case XS_HVM:
984 		err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);
985 		if (err)
986 			goto out_error;
987 		xen_store_evtchn = (int)v;
988 		err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v);
989 		if (err)
990 			goto out_error;
991 		/*
992 		 * Uninitialized hvm_params are zero and return no error.
993 		 * Although it is theoretically possible to have
994 		 * HVM_PARAM_STORE_PFN set to zero on purpose, in reality it is
995 		 * not zero when valid. If zero, it means that Xenstore hasn't
996 		 * been properly initialized. Instead of attempting to map a
997 		 * wrong guest physical address return error.
998 		 *
999 		 * Also recognize all bits set as an invalid/uninitialized value.
1000 		 */
1001 		if (!v) {
1002 			err = -ENOENT;
1003 			goto out_error;
1004 		}
1005 		if (v == ~0ULL) {
1006 			wait = true;
1007 		} else {
1008 			/* Avoid truncation on 32-bit. */
1009 #if BITS_PER_LONG == 32
1010 			if (v > ULONG_MAX) {
1011 				pr_err("%s: cannot handle HVM_PARAM_STORE_PFN=%llx > ULONG_MAX\n",
1012 				       __func__, v);
1013 				err = -EINVAL;
1014 				goto out_error;
1015 			}
1016 #endif
1017 			xen_store_gfn = (unsigned long)v;
1018 			xen_store_interface =
1019 				memremap(xen_store_gfn << XEN_PAGE_SHIFT,
1020 					 XEN_PAGE_SIZE, MEMREMAP_WB);
1021 			if (!xen_store_interface) {
1022 				pr_err("%s: cannot map HVM_PARAM_STORE_PFN=%llx\n",
1023 				       __func__, v);
1024 				err = -EINVAL;
1025 				goto out_error;
1026 			}
1027 			if (xen_store_interface->connection != XENSTORE_CONNECTED)
1028 				wait = true;
1029 		}
1030 		if (wait) {
1031 			err = bind_evtchn_to_irqhandler(xen_store_evtchn,
1032 							xenbus_late_init,
1033 							0, "xenstore_late_init",
1034 							&xb_waitq);
1035 			if (err < 0) {
1036 				pr_err("xenstore_late_init couldn't bind irq err=%d\n",
1037 				       err);
1038 				goto out_error;
1039 			}
1040 
1041 			xs_init_irq = err;
1042 		}
1043 		break;
1044 	default:
1045 		pr_warn("Xenstore state unknown\n");
1046 		break;
1047 	}
1048 
1049 	/*
1050 	 * HVM domains may not have a functional callback yet. In that
1051 	 * case let xs_init() be called from xenbus_probe(), which will
1052 	 * get invoked at an appropriate time.
1053 	 */
1054 	if (xen_store_domain_type != XS_HVM) {
1055 		err = xs_init();
1056 		if (err) {
1057 			pr_warn("Error initializing xenstore comms: %i\n", err);
1058 			goto out_error;
1059 		}
1060 	}
1061 
1062 	if ((xen_store_domain_type != XS_LOCAL) &&
1063 	    (xen_store_domain_type != XS_UNKNOWN))
1064 		xen_resume_notifier_register(&xenbus_resume_nb);
1065 
1066 #ifdef CONFIG_XEN_COMPAT_XENFS
1067 	/*
1068 	 * Create xenfs mountpoint in /proc for compatibility with
1069 	 * utilities that expect to find "xenbus" under "/proc/xen".
1070 	 */
1071 	proc_create_mount_point("xen");
1072 #endif
1073 	return 0;
1074 
1075 out_error:
1076 	xen_store_domain_type = XS_UNKNOWN;
1077 	return err;
1078 }
1079 
1080 postcore_initcall(xenbus_init);
1081 
1082 MODULE_LICENSE("GPL");
1083