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
68int xen_store_evtchn;
69EXPORT_SYMBOL_GPL(xen_store_evtchn);
70
71struct xenstore_domain_interface *xen_store_interface;
72EXPORT_SYMBOL_GPL(xen_store_interface);
73
74enum xenstore_init xen_store_domain_type;
75EXPORT_SYMBOL_GPL(xen_store_domain_type);
76
77static unsigned long xen_store_gfn;
78
79static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
80
81/* If something in array of ids matches this device, return it. */
82static const struct xenbus_device_id *
83match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev)
84{
85	for (; *arr->devicetype != '\0'; arr++) {
86		if (!strcmp(arr->devicetype, dev->devicetype))
87			return arr;
88	}
89	return NULL;
90}
91
92int xenbus_match(struct device *_dev, struct device_driver *_drv)
93{
94	struct xenbus_driver *drv = to_xenbus_driver(_drv);
95
96	if (!drv->ids)
97		return 0;
98
99	return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;
100}
101EXPORT_SYMBOL_GPL(xenbus_match);
102
103
104static void free_otherend_details(struct xenbus_device *dev)
105{
106	kfree(dev->otherend);
107	dev->otherend = NULL;
108}
109
110
111static void free_otherend_watch(struct xenbus_device *dev)
112{
113	if (dev->otherend_watch.node) {
114		unregister_xenbus_watch(&dev->otherend_watch);
115		kfree(dev->otherend_watch.node);
116		dev->otherend_watch.node = NULL;
117	}
118}
119
120
121static int talk_to_otherend(struct xenbus_device *dev)
122{
123	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
124
125	free_otherend_watch(dev);
126	free_otherend_details(dev);
127
128	return drv->read_otherend_details(dev);
129}
130
131
132
133static int watch_otherend(struct xenbus_device *dev)
134{
135	struct xen_bus_type *bus =
136		container_of(dev->dev.bus, struct xen_bus_type, bus);
137
138	return xenbus_watch_pathfmt(dev, &dev->otherend_watch,
139				    bus->otherend_will_handle,
140				    bus->otherend_changed,
141				    "%s/%s", dev->otherend, "state");
142}
143
144
145int xenbus_read_otherend_details(struct xenbus_device *xendev,
146				 char *id_node, char *path_node)
147{
148	int err = xenbus_gather(XBT_NIL, xendev->nodename,
149				id_node, "%i", &xendev->otherend_id,
150				path_node, NULL, &xendev->otherend,
151				NULL);
152	if (err) {
153		xenbus_dev_fatal(xendev, err,
154				 "reading other end details from %s",
155				 xendev->nodename);
156		return err;
157	}
158	if (strlen(xendev->otherend) == 0 ||
159	    !xenbus_exists(XBT_NIL, xendev->otherend, "")) {
160		xenbus_dev_fatal(xendev, -ENOENT,
161				 "unable to read other end from %s.  "
162				 "missing or inaccessible.",
163				 xendev->nodename);
164		free_otherend_details(xendev);
165		return -ENOENT;
166	}
167
168	return 0;
169}
170EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);
171
172void xenbus_otherend_changed(struct xenbus_watch *watch,
173			     const char *path, const char *token,
174			     int ignore_on_shutdown)
175{
176	struct xenbus_device *dev =
177		container_of(watch, struct xenbus_device, otherend_watch);
178	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
179	enum xenbus_state state;
180
181	/* Protect us against watches firing on old details when the otherend
182	   details change, say immediately after a resume. */
183	if (!dev->otherend ||
184	    strncmp(dev->otherend, path, strlen(dev->otherend))) {
185		dev_dbg(&dev->dev, "Ignoring watch at %s\n", path);
186		return;
187	}
188
189	state = xenbus_read_driver_state(dev->otherend);
190
191	dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n",
192		state, xenbus_strstate(state), dev->otherend_watch.node, path);
193
194	/*
195	 * Ignore xenbus transitions during shutdown. This prevents us doing
196	 * work that can fail e.g., when the rootfs is gone.
197	 */
198	if (system_state > SYSTEM_RUNNING) {
199		if (ignore_on_shutdown && (state == XenbusStateClosing))
200			xenbus_frontend_closed(dev);
201		return;
202	}
203
204	if (drv->otherend_changed)
205		drv->otherend_changed(dev, state);
206}
207EXPORT_SYMBOL_GPL(xenbus_otherend_changed);
208
209int xenbus_dev_probe(struct device *_dev)
210{
211	struct xenbus_device *dev = to_xenbus_device(_dev);
212	struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);
213	const struct xenbus_device_id *id;
214	int err;
215
216	DPRINTK("%s", dev->nodename);
217
218	if (!drv->probe) {
219		err = -ENODEV;
220		goto fail;
221	}
222
223	id = match_device(drv->ids, dev);
224	if (!id) {
225		err = -ENODEV;
226		goto fail;
227	}
228
229	err = talk_to_otherend(dev);
230	if (err) {
231		dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n",
232			 dev->nodename);
233		return err;
234	}
235
236	if (!try_module_get(drv->driver.owner)) {
237		dev_warn(&dev->dev, "failed to acquire module reference on '%s'\n",
238			 drv->driver.name);
239		err = -ESRCH;
240		goto fail;
241	}
242
243	down(&dev->reclaim_sem);
244	err = drv->probe(dev, id);
245	up(&dev->reclaim_sem);
246	if (err)
247		goto fail_put;
248
249	err = watch_otherend(dev);
250	if (err) {
251		dev_warn(&dev->dev, "watch_otherend on %s failed.\n",
252		       dev->nodename);
253		return err;
254	}
255
256	return 0;
257fail_put:
258	module_put(drv->driver.owner);
259fail:
260	xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename);
261	return err;
262}
263EXPORT_SYMBOL_GPL(xenbus_dev_probe);
264
265int xenbus_dev_remove(struct device *_dev)
266{
267	struct xenbus_device *dev = to_xenbus_device(_dev);
268	struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);
269
270	DPRINTK("%s", dev->nodename);
271
272	free_otherend_watch(dev);
273
274	if (drv->remove) {
275		down(&dev->reclaim_sem);
276		drv->remove(dev);
277		up(&dev->reclaim_sem);
278	}
279
280	module_put(drv->driver.owner);
281
282	free_otherend_details(dev);
283
284	/*
285	 * If the toolstack has forced the device state to closing then set
286	 * the state to closed now to allow it to be cleaned up.
287	 * Similarly, if the driver does not support re-bind, set the
288	 * closed.
289	 */
290	if (!drv->allow_rebind ||
291	    xenbus_read_driver_state(dev->nodename) == XenbusStateClosing)
292		xenbus_switch_state(dev, XenbusStateClosed);
293
294	return 0;
295}
296EXPORT_SYMBOL_GPL(xenbus_dev_remove);
297
298int xenbus_register_driver_common(struct xenbus_driver *drv,
299				  struct xen_bus_type *bus,
300				  struct module *owner, const char *mod_name)
301{
302	drv->driver.name = drv->name ? drv->name : drv->ids[0].devicetype;
303	drv->driver.bus = &bus->bus;
304	drv->driver.owner = owner;
305	drv->driver.mod_name = mod_name;
306
307	return driver_register(&drv->driver);
308}
309EXPORT_SYMBOL_GPL(xenbus_register_driver_common);
310
311void xenbus_unregister_driver(struct xenbus_driver *drv)
312{
313	driver_unregister(&drv->driver);
314}
315EXPORT_SYMBOL_GPL(xenbus_unregister_driver);
316
317struct xb_find_info {
318	struct xenbus_device *dev;
319	const char *nodename;
320};
321
322static int cmp_dev(struct device *dev, void *data)
323{
324	struct xenbus_device *xendev = to_xenbus_device(dev);
325	struct xb_find_info *info = data;
326
327	if (!strcmp(xendev->nodename, info->nodename)) {
328		info->dev = xendev;
329		get_device(dev);
330		return 1;
331	}
332	return 0;
333}
334
335static struct xenbus_device *xenbus_device_find(const char *nodename,
336						struct bus_type *bus)
337{
338	struct xb_find_info info = { .dev = NULL, .nodename = nodename };
339
340	bus_for_each_dev(bus, NULL, &info, cmp_dev);
341	return info.dev;
342}
343
344static int cleanup_dev(struct device *dev, void *data)
345{
346	struct xenbus_device *xendev = to_xenbus_device(dev);
347	struct xb_find_info *info = data;
348	int len = strlen(info->nodename);
349
350	DPRINTK("%s", info->nodename);
351
352	/* Match the info->nodename path, or any subdirectory of that path. */
353	if (strncmp(xendev->nodename, info->nodename, len))
354		return 0;
355
356	/* If the node name is longer, ensure it really is a subdirectory. */
357	if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/'))
358		return 0;
359
360	info->dev = xendev;
361	get_device(dev);
362	return 1;
363}
364
365static void xenbus_cleanup_devices(const char *path, struct bus_type *bus)
366{
367	struct xb_find_info info = { .nodename = path };
368
369	do {
370		info.dev = NULL;
371		bus_for_each_dev(bus, NULL, &info, cleanup_dev);
372		if (info.dev) {
373			device_unregister(&info.dev->dev);
374			put_device(&info.dev->dev);
375		}
376	} while (info.dev);
377}
378
379static void xenbus_dev_release(struct device *dev)
380{
381	if (dev)
382		kfree(to_xenbus_device(dev));
383}
384
385static ssize_t nodename_show(struct device *dev,
386			     struct device_attribute *attr, char *buf)
387{
388	return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);
389}
390static DEVICE_ATTR_RO(nodename);
391
392static ssize_t devtype_show(struct device *dev,
393			    struct device_attribute *attr, char *buf)
394{
395	return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);
396}
397static DEVICE_ATTR_RO(devtype);
398
399static ssize_t modalias_show(struct device *dev,
400			     struct device_attribute *attr, char *buf)
401{
402	return sprintf(buf, "%s:%s\n", dev->bus->name,
403		       to_xenbus_device(dev)->devicetype);
404}
405static DEVICE_ATTR_RO(modalias);
406
407static ssize_t state_show(struct device *dev,
408			    struct device_attribute *attr, char *buf)
409{
410	return sprintf(buf, "%s\n",
411			xenbus_strstate(to_xenbus_device(dev)->state));
412}
413static DEVICE_ATTR_RO(state);
414
415static struct attribute *xenbus_dev_attrs[] = {
416	&dev_attr_nodename.attr,
417	&dev_attr_devtype.attr,
418	&dev_attr_modalias.attr,
419	&dev_attr_state.attr,
420	NULL,
421};
422
423static const struct attribute_group xenbus_dev_group = {
424	.attrs = xenbus_dev_attrs,
425};
426
427const struct attribute_group *xenbus_dev_groups[] = {
428	&xenbus_dev_group,
429	NULL,
430};
431EXPORT_SYMBOL_GPL(xenbus_dev_groups);
432
433int xenbus_probe_node(struct xen_bus_type *bus,
434		      const char *type,
435		      const char *nodename)
436{
437	char devname[XEN_BUS_ID_SIZE];
438	int err;
439	struct xenbus_device *xendev;
440	size_t stringlen;
441	char *tmpstring;
442
443	enum xenbus_state state = xenbus_read_driver_state(nodename);
444
445	if (state != XenbusStateInitialising) {
446		/* Device is not new, so ignore it.  This can happen if a
447		   device is going away after switching to Closed.  */
448		return 0;
449	}
450
451	stringlen = strlen(nodename) + 1 + strlen(type) + 1;
452	xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL);
453	if (!xendev)
454		return -ENOMEM;
455
456	xendev->state = XenbusStateInitialising;
457
458	/* Copy the strings into the extra space. */
459
460	tmpstring = (char *)(xendev + 1);
461	strcpy(tmpstring, nodename);
462	xendev->nodename = tmpstring;
463
464	tmpstring += strlen(tmpstring) + 1;
465	strcpy(tmpstring, type);
466	xendev->devicetype = tmpstring;
467	init_completion(&xendev->down);
468
469	xendev->dev.bus = &bus->bus;
470	xendev->dev.release = xenbus_dev_release;
471
472	err = bus->get_bus_id(devname, xendev->nodename);
473	if (err)
474		goto fail;
475
476	dev_set_name(&xendev->dev, "%s", devname);
477	sema_init(&xendev->reclaim_sem, 1);
478
479	/* Register with generic device framework. */
480	err = device_register(&xendev->dev);
481	if (err) {
482		put_device(&xendev->dev);
483		xendev = NULL;
484		goto fail;
485	}
486
487	return 0;
488fail:
489	kfree(xendev);
490	return err;
491}
492EXPORT_SYMBOL_GPL(xenbus_probe_node);
493
494static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)
495{
496	int err = 0;
497	char **dir;
498	unsigned int dir_n = 0;
499	int i;
500
501	dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n);
502	if (IS_ERR(dir))
503		return PTR_ERR(dir);
504
505	for (i = 0; i < dir_n; i++) {
506		err = bus->probe(bus, type, dir[i]);
507		if (err)
508			break;
509	}
510
511	kfree(dir);
512	return err;
513}
514
515int xenbus_probe_devices(struct xen_bus_type *bus)
516{
517	int err = 0;
518	char **dir;
519	unsigned int i, dir_n;
520
521	dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n);
522	if (IS_ERR(dir))
523		return PTR_ERR(dir);
524
525	for (i = 0; i < dir_n; i++) {
526		err = xenbus_probe_device_type(bus, dir[i]);
527		if (err)
528			break;
529	}
530
531	kfree(dir);
532	return err;
533}
534EXPORT_SYMBOL_GPL(xenbus_probe_devices);
535
536static unsigned int char_count(const char *str, char c)
537{
538	unsigned int i, ret = 0;
539
540	for (i = 0; str[i]; i++)
541		if (str[i] == c)
542			ret++;
543	return ret;
544}
545
546static int strsep_len(const char *str, char c, unsigned int len)
547{
548	unsigned int i;
549
550	for (i = 0; str[i]; i++)
551		if (str[i] == c) {
552			if (len == 0)
553				return i;
554			len--;
555		}
556	return (len == 0) ? i : -ERANGE;
557}
558
559void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
560{
561	int exists, rootlen;
562	struct xenbus_device *dev;
563	char type[XEN_BUS_ID_SIZE];
564	const char *p, *root;
565
566	if (char_count(node, '/') < 2)
567		return;
568
569	exists = xenbus_exists(XBT_NIL, node, "");
570	if (!exists) {
571		xenbus_cleanup_devices(node, &bus->bus);
572		return;
573	}
574
575	/* backend/<type>/... or device/<type>/... */
576	p = strchr(node, '/') + 1;
577	snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p);
578	type[XEN_BUS_ID_SIZE-1] = '\0';
579
580	rootlen = strsep_len(node, '/', bus->levels);
581	if (rootlen < 0)
582		return;
583	root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node);
584	if (!root)
585		return;
586
587	dev = xenbus_device_find(root, &bus->bus);
588	if (!dev)
589		xenbus_probe_node(bus, type, root);
590	else
591		put_device(&dev->dev);
592
593	kfree(root);
594}
595EXPORT_SYMBOL_GPL(xenbus_dev_changed);
596
597int xenbus_dev_suspend(struct device *dev)
598{
599	int err = 0;
600	struct xenbus_driver *drv;
601	struct xenbus_device *xdev
602		= container_of(dev, struct xenbus_device, dev);
603
604	DPRINTK("%s", xdev->nodename);
605
606	if (dev->driver == NULL)
607		return 0;
608	drv = to_xenbus_driver(dev->driver);
609	if (drv->suspend)
610		err = drv->suspend(xdev);
611	if (err)
612		dev_warn(dev, "suspend failed: %i\n", err);
613	return 0;
614}
615EXPORT_SYMBOL_GPL(xenbus_dev_suspend);
616
617int xenbus_dev_resume(struct device *dev)
618{
619	int err;
620	struct xenbus_driver *drv;
621	struct xenbus_device *xdev
622		= container_of(dev, struct xenbus_device, dev);
623
624	DPRINTK("%s", xdev->nodename);
625
626	if (dev->driver == NULL)
627		return 0;
628	drv = to_xenbus_driver(dev->driver);
629	err = talk_to_otherend(xdev);
630	if (err) {
631		dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err);
632		return err;
633	}
634
635	xdev->state = XenbusStateInitialising;
636
637	if (drv->resume) {
638		err = drv->resume(xdev);
639		if (err) {
640			dev_warn(dev, "resume failed: %i\n", err);
641			return err;
642		}
643	}
644
645	err = watch_otherend(xdev);
646	if (err) {
647		dev_warn(dev, "resume (watch_otherend) failed: %d\n", err);
648		return err;
649	}
650
651	return 0;
652}
653EXPORT_SYMBOL_GPL(xenbus_dev_resume);
654
655int xenbus_dev_cancel(struct device *dev)
656{
657	/* Do nothing */
658	DPRINTK("cancel");
659	return 0;
660}
661EXPORT_SYMBOL_GPL(xenbus_dev_cancel);
662
663/* A flag to determine if xenstored is 'ready' (i.e. has started) */
664int xenstored_ready;
665
666
667int register_xenstore_notifier(struct notifier_block *nb)
668{
669	int ret = 0;
670
671	if (xenstored_ready > 0)
672		ret = nb->notifier_call(nb, 0, NULL);
673	else
674		blocking_notifier_chain_register(&xenstore_chain, nb);
675
676	return ret;
677}
678EXPORT_SYMBOL_GPL(register_xenstore_notifier);
679
680void unregister_xenstore_notifier(struct notifier_block *nb)
681{
682	blocking_notifier_chain_unregister(&xenstore_chain, nb);
683}
684EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
685
686static void xenbus_probe(void)
687{
688	xenstored_ready = 1;
689
690	/*
691	 * In the HVM case, xenbus_init() deferred its call to
692	 * xs_init() in case callbacks were not operational yet.
693	 * So do it now.
694	 */
695	if (xen_store_domain_type == XS_HVM)
696		xs_init();
697
698	/* Notify others that xenstore is up */
699	blocking_notifier_call_chain(&xenstore_chain, 0, NULL);
700}
701
702/*
703 * Returns true when XenStore init must be deferred in order to
704 * allow the PCI platform device to be initialised, before we
705 * can actually have event channel interrupts working.
706 */
707static bool xs_hvm_defer_init_for_callback(void)
708{
709#ifdef CONFIG_XEN_PVHVM
710	return xen_store_domain_type == XS_HVM &&
711		!xen_have_vector_callback;
712#else
713	return false;
714#endif
715}
716
717static int xenbus_probe_thread(void *unused)
718{
719	DEFINE_WAIT(w);
720
721	/*
722	 * We actually just want to wait for *any* trigger of xb_waitq,
723	 * and run xenbus_probe() the moment it occurs.
724	 */
725	prepare_to_wait(&xb_waitq, &w, TASK_INTERRUPTIBLE);
726	schedule();
727	finish_wait(&xb_waitq, &w);
728
729	DPRINTK("probing");
730	xenbus_probe();
731	return 0;
732}
733
734static int __init xenbus_probe_initcall(void)
735{
736	/*
737	 * Probe XenBus here in the XS_PV case, and also XS_HVM unless we
738	 * need to wait for the platform PCI device to come up.
739	 */
740	if (xen_store_domain_type == XS_PV ||
741	    (xen_store_domain_type == XS_HVM &&
742	     !xs_hvm_defer_init_for_callback()))
743		xenbus_probe();
744
745	/*
746	 * For XS_LOCAL, spawn a thread which will wait for xenstored
747	 * or a xenstore-stubdom to be started, then probe. It will be
748	 * triggered when communication starts happening, by waiting
749	 * on xb_waitq.
750	 */
751	if (xen_store_domain_type == XS_LOCAL) {
752		struct task_struct *probe_task;
753
754		probe_task = kthread_run(xenbus_probe_thread, NULL,
755					 "xenbus_probe");
756		if (IS_ERR(probe_task))
757			return PTR_ERR(probe_task);
758	}
759	return 0;
760}
761device_initcall(xenbus_probe_initcall);
762
763int xen_set_callback_via(uint64_t via)
764{
765	struct xen_hvm_param a;
766	int ret;
767
768	a.domid = DOMID_SELF;
769	a.index = HVM_PARAM_CALLBACK_IRQ;
770	a.value = via;
771
772	ret = HYPERVISOR_hvm_op(HVMOP_set_param, &a);
773	if (ret)
774		return ret;
775
776	/*
777	 * If xenbus_probe_initcall() deferred the xenbus_probe()
778	 * due to the callback not functioning yet, we can do it now.
779	 */
780	if (!xenstored_ready && xs_hvm_defer_init_for_callback())
781		xenbus_probe();
782
783	return ret;
784}
785EXPORT_SYMBOL_GPL(xen_set_callback_via);
786
787/* Set up event channel for xenstored which is run as a local process
788 * (this is normally used only in dom0)
789 */
790static int __init xenstored_local_init(void)
791{
792	int err = -ENOMEM;
793	unsigned long page = 0;
794	struct evtchn_alloc_unbound alloc_unbound;
795
796	/* Allocate Xenstore page */
797	page = get_zeroed_page(GFP_KERNEL);
798	if (!page)
799		goto out_err;
800
801	xen_store_gfn = virt_to_gfn((void *)page);
802
803	/* Next allocate a local port which xenstored can bind to */
804	alloc_unbound.dom        = DOMID_SELF;
805	alloc_unbound.remote_dom = DOMID_SELF;
806
807	err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
808					  &alloc_unbound);
809	if (err == -ENOSYS)
810		goto out_err;
811
812	BUG_ON(err);
813	xen_store_evtchn = alloc_unbound.port;
814
815	return 0;
816
817 out_err:
818	if (page != 0)
819		free_page(page);
820	return err;
821}
822
823static int xenbus_resume_cb(struct notifier_block *nb,
824			    unsigned long action, void *data)
825{
826	int err = 0;
827
828	if (xen_hvm_domain()) {
829		uint64_t v = 0;
830
831		err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);
832		if (!err && v)
833			xen_store_evtchn = v;
834		else
835			pr_warn("Cannot update xenstore event channel: %d\n",
836				err);
837	} else
838		xen_store_evtchn = xen_start_info->store_evtchn;
839
840	return err;
841}
842
843static struct notifier_block xenbus_resume_nb = {
844	.notifier_call = xenbus_resume_cb,
845};
846
847static int __init xenbus_init(void)
848{
849	int err;
850	uint64_t v = 0;
851	xen_store_domain_type = XS_UNKNOWN;
852
853	if (!xen_domain())
854		return -ENODEV;
855
856	xenbus_ring_ops_init();
857
858	if (xen_pv_domain())
859		xen_store_domain_type = XS_PV;
860	if (xen_hvm_domain())
861		xen_store_domain_type = XS_HVM;
862	if (xen_hvm_domain() && xen_initial_domain())
863		xen_store_domain_type = XS_LOCAL;
864	if (xen_pv_domain() && !xen_start_info->store_evtchn)
865		xen_store_domain_type = XS_LOCAL;
866	if (xen_pv_domain() && xen_start_info->store_evtchn)
867		xenstored_ready = 1;
868
869	switch (xen_store_domain_type) {
870	case XS_LOCAL:
871		err = xenstored_local_init();
872		if (err)
873			goto out_error;
874		xen_store_interface = gfn_to_virt(xen_store_gfn);
875		break;
876	case XS_PV:
877		xen_store_evtchn = xen_start_info->store_evtchn;
878		xen_store_gfn = xen_start_info->store_mfn;
879		xen_store_interface = gfn_to_virt(xen_store_gfn);
880		break;
881	case XS_HVM:
882		err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);
883		if (err)
884			goto out_error;
885		xen_store_evtchn = (int)v;
886		err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v);
887		if (err)
888			goto out_error;
889		/*
890		 * Uninitialized hvm_params are zero and return no error.
891		 * Although it is theoretically possible to have
892		 * HVM_PARAM_STORE_PFN set to zero on purpose, in reality it is
893		 * not zero when valid. If zero, it means that Xenstore hasn't
894		 * been properly initialized. Instead of attempting to map a
895		 * wrong guest physical address return error.
896		 *
897		 * Also recognize all bits set as an invalid value.
898		 */
899		if (!v || !~v) {
900			err = -ENOENT;
901			goto out_error;
902		}
903		/* Avoid truncation on 32-bit. */
904#if BITS_PER_LONG == 32
905		if (v > ULONG_MAX) {
906			pr_err("%s: cannot handle HVM_PARAM_STORE_PFN=%llx > ULONG_MAX\n",
907			       __func__, v);
908			err = -EINVAL;
909			goto out_error;
910		}
911#endif
912		xen_store_gfn = (unsigned long)v;
913		xen_store_interface =
914			xen_remap(xen_store_gfn << XEN_PAGE_SHIFT,
915				  XEN_PAGE_SIZE);
916		break;
917	default:
918		pr_warn("Xenstore state unknown\n");
919		break;
920	}
921
922	/*
923	 * HVM domains may not have a functional callback yet. In that
924	 * case let xs_init() be called from xenbus_probe(), which will
925	 * get invoked at an appropriate time.
926	 */
927	if (xen_store_domain_type != XS_HVM) {
928		err = xs_init();
929		if (err) {
930			pr_warn("Error initializing xenstore comms: %i\n", err);
931			goto out_error;
932		}
933	}
934
935	if ((xen_store_domain_type != XS_LOCAL) &&
936	    (xen_store_domain_type != XS_UNKNOWN))
937		xen_resume_notifier_register(&xenbus_resume_nb);
938
939#ifdef CONFIG_XEN_COMPAT_XENFS
940	/*
941	 * Create xenfs mountpoint in /proc for compatibility with
942	 * utilities that expect to find "xenbus" under "/proc/xen".
943	 */
944	proc_create_mount_point("xen");
945#endif
946	return 0;
947
948out_error:
949	xen_store_domain_type = XS_UNKNOWN;
950	return err;
951}
952
953postcore_initcall(xenbus_init);
954
955MODULE_LICENSE("GPL");
956