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
68static int xs_init_irq = -1;
69int xen_store_evtchn;
70EXPORT_SYMBOL_GPL(xen_store_evtchn);
71
72struct xenstore_domain_interface *xen_store_interface;
73EXPORT_SYMBOL_GPL(xen_store_interface);
74
75#define XS_INTERFACE_READY \
76	((xen_store_interface != NULL) && \
77	 (xen_store_interface->connection == XENSTORE_CONNECTED))
78
79enum xenstore_init xen_store_domain_type;
80EXPORT_SYMBOL_GPL(xen_store_domain_type);
81
82static unsigned long xen_store_gfn;
83
84static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
85
86/* If something in array of ids matches this device, return it. */
87static const struct xenbus_device_id *
88match_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
97int xenbus_match(struct device *_dev, struct device_driver *_drv)
98{
99	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}
106EXPORT_SYMBOL_GPL(xenbus_match);
107
108
109static void free_otherend_details(struct xenbus_device *dev)
110{
111	kfree(dev->otherend);
112	dev->otherend = NULL;
113}
114
115
116static 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
126static 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
138static 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
150int 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}
175EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);
176
177void 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}
212EXPORT_SYMBOL_GPL(xenbus_otherend_changed);
213
214#define XENBUS_SHOW_STAT(name)						\
215static 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}									\
223static DEVICE_ATTR_RO(name)
224
225XENBUS_SHOW_STAT(event_channels);
226XENBUS_SHOW_STAT(events);
227XENBUS_SHOW_STAT(spurious_events);
228XENBUS_SHOW_STAT(jiffies_eoi_delayed);
229
230static 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
239static 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
256static DEVICE_ATTR_RW(spurious_threshold);
257
258static 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
267static const struct attribute_group xenbus_group = {
268	.name = "xenbus",
269	.attrs = xenbus_attrs,
270};
271
272int 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;
325fail_put:
326	module_put(drv->driver.owner);
327fail:
328	xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename);
329	return err;
330}
331EXPORT_SYMBOL_GPL(xenbus_dev_probe);
332
333void 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}
364EXPORT_SYMBOL_GPL(xenbus_dev_remove);
365
366int 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}
377EXPORT_SYMBOL_GPL(xenbus_register_driver_common);
378
379void xenbus_unregister_driver(struct xenbus_driver *drv)
380{
381	driver_unregister(&drv->driver);
382}
383EXPORT_SYMBOL_GPL(xenbus_unregister_driver);
384
385struct xb_find_info {
386	struct xenbus_device *dev;
387	const char *nodename;
388};
389
390static 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
403static 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
412static 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
433static 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
447static void xenbus_dev_release(struct device *dev)
448{
449	if (dev)
450		kfree(to_xenbus_device(dev));
451}
452
453static 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}
458static DEVICE_ATTR_RO(nodename);
459
460static 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}
465static DEVICE_ATTR_RO(devtype);
466
467static 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}
473static DEVICE_ATTR_RO(modalias);
474
475static 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}
481static DEVICE_ATTR_RO(state);
482
483static 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
491static const struct attribute_group xenbus_dev_group = {
492	.attrs = xenbus_dev_attrs,
493};
494
495const struct attribute_group *xenbus_dev_groups[] = {
496	&xenbus_dev_group,
497	NULL,
498};
499EXPORT_SYMBOL_GPL(xenbus_dev_groups);
500
501int 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;
556fail:
557	kfree(xendev);
558	return err;
559}
560EXPORT_SYMBOL_GPL(xenbus_probe_node);
561
562static 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
583int 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}
602EXPORT_SYMBOL_GPL(xenbus_probe_devices);
603
604static 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
614static 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
627void 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}
663EXPORT_SYMBOL_GPL(xenbus_dev_changed);
664
665int 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}
683EXPORT_SYMBOL_GPL(xenbus_dev_suspend);
684
685int 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}
721EXPORT_SYMBOL_GPL(xenbus_dev_resume);
722
723int xenbus_dev_cancel(struct device *dev)
724{
725	/* Do nothing */
726	DPRINTK("cancel");
727	return 0;
728}
729EXPORT_SYMBOL_GPL(xenbus_dev_cancel);
730
731/* A flag to determine if xenstored is 'ready' (i.e. has started) */
732int xenstored_ready;
733
734
735int 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}
746EXPORT_SYMBOL_GPL(register_xenstore_notifier);
747
748void unregister_xenstore_notifier(struct notifier_block *nb)
749{
750	blocking_notifier_chain_unregister(&xenstore_chain, nb);
751}
752EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
753
754static 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 */
789static 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
799static 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
816static 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}
848device_initcall(xenbus_probe_initcall);
849
850int 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}
872EXPORT_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 */
877static 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
910static 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
930static struct notifier_block xenbus_resume_nb = {
931	.notifier_call = xenbus_resume_cb,
932};
933
934static 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
948static 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
1075out_error:
1076	xen_store_domain_type = XS_UNKNOWN;
1077	return err;
1078}
1079
1080postcore_initcall(xenbus_init);
1081
1082MODULE_LICENSE("GPL");
1083