[linux-block.git] / drivers / xen / xenbus / xenbus_probe_frontend.c

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#define DPRINTK(fmt, ...)				\
	pr_debug("(%s:%d) " fmt "\n",			\
		 __func__, __LINE__, ##__VA_ARGS__)

#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
#include <linux/notifier.h>
#include <linux/kthread.h>
#include <linux/mutex.h>
#include <linux/io.h>
#include <linux/module.h>

#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/xen/hypervisor.h>
#include <xen/xenbus.h>
#include <xen/events.h>
#include <xen/page.h>
#include <xen/xen.h>

#include <xen/platform_pci.h>

#include "xenbus_comms.h"
#include "xenbus_probe.h"


/* device/<type>/<id> => <type>-<id> */
static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename)
{
	nodename = strchr(nodename, '/');
	if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) {
		pr_warn("bad frontend %s\n", nodename);
		return -EINVAL;
	}

	strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);
	if (!strchr(bus_id, '/')) {
		pr_warn("bus_id %s no slash\n", bus_id);
		return -EINVAL;
	}
	*strchr(bus_id, '/') = '-';
	return 0;
}

/* device/<typename>/<name> */
static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type,
				 const char *name)
{
	char *nodename;
	int err;

	/* ignore console/0 */
	if (!strncmp(type, "console", 7) && !strncmp(name, "0", 1)) {
		DPRINTK("Ignoring buggy device entry console/0");
		return 0;
	}

	nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, name);
	if (!nodename)
		return -ENOMEM;

	DPRINTK("%s", nodename);

	err = xenbus_probe_node(bus, type, nodename);
	kfree(nodename);
	return err;
}

static int xenbus_uevent_frontend(struct device *_dev,
				  struct kobj_uevent_env *env)
{
	struct xenbus_device *dev = to_xenbus_device(_dev);

	if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
		return -ENOMEM;

	return 0;
}


static void backend_changed(struct xenbus_watch *watch,
			    const char **vec, unsigned int len)
{
	xenbus_otherend_changed(watch, vec, len, 1);
}

static void xenbus_frontend_delayed_resume(struct work_struct *w)
{
	struct xenbus_device *xdev = container_of(w, struct xenbus_device, work);

	xenbus_dev_resume(&xdev->dev);
}

static int xenbus_frontend_dev_resume(struct device *dev)
{
	/*
	 * If xenstored is running in this domain, we cannot access the backend
	 * state at the moment, so we need to defer xenbus_dev_resume
	 */
	if (xen_store_domain_type == XS_LOCAL) {
		struct xenbus_device *xdev = to_xenbus_device(dev);

		schedule_work(&xdev->work);

		return 0;
	}

	return xenbus_dev_resume(dev);
}

static int xenbus_frontend_dev_probe(struct device *dev)
{
	if (xen_store_domain_type == XS_LOCAL) {
		struct xenbus_device *xdev = to_xenbus_device(dev);
		INIT_WORK(&xdev->work, xenbus_frontend_delayed_resume);
	}

	return xenbus_dev_probe(dev);
}

static const struct dev_pm_ops xenbus_pm_ops = {
	.suspend	= xenbus_dev_suspend,
	.resume		= xenbus_frontend_dev_resume,
	.freeze		= xenbus_dev_suspend,
	.thaw		= xenbus_dev_cancel,
	.restore	= xenbus_dev_resume,
};

static struct xen_bus_type xenbus_frontend = {
	.root = "device",
	.levels = 2,		/* device/type/<id> */
	.get_bus_id = frontend_bus_id,
	.probe = xenbus_probe_frontend,
	.otherend_changed = backend_changed,
	.bus = {
		.name		= "xen",
		.match		= xenbus_match,
		.uevent		= xenbus_uevent_frontend,
		.probe		= xenbus_frontend_dev_probe,
		.remove		= xenbus_dev_remove,
		.shutdown	= xenbus_dev_shutdown,
		.dev_groups	= xenbus_dev_groups,

		.pm		= &xenbus_pm_ops,
	},
};

static void frontend_changed(struct xenbus_watch *watch,
			     const char **vec, unsigned int len)
{
	DPRINTK("");

	xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
}


/* We watch for devices appearing and vanishing. */
static struct xenbus_watch fe_watch = {
	.node = "device",
	.callback = frontend_changed,
};

static int read_backend_details(struct xenbus_device *xendev)
{
	return xenbus_read_otherend_details(xendev, "backend-id", "backend");
}

static int is_device_connecting(struct device *dev, void *data, bool ignore_nonessential)
{
	struct xenbus_device *xendev = to_xenbus_device(dev);
	struct device_driver *drv = data;
	struct xenbus_driver *xendrv;

	/*
	 * A device with no driver will never connect. We care only about
	 * devices which should currently be in the process of connecting.
	 */
	if (!dev->driver)
		return 0;

	/* Is this search limited to a particular driver? */
	if (drv && (dev->driver != drv))
		return 0;

	if (ignore_nonessential) {
		/* With older QEMU, for PVonHVM guests the guest config files
		 * could contain: vfb = [ 'vnc=1, vnclisten=0.0.0.0']
		 * which is nonsensical as there is no PV FB (there can be
		 * a PVKB) running as HVM guest. */

		if ((strncmp(xendev->nodename, "device/vkbd", 11) == 0))
			return 0;

		if ((strncmp(xendev->nodename, "device/vfb", 10) == 0))
			return 0;
	}
	xendrv = to_xenbus_driver(dev->driver);
	return (xendev->state < XenbusStateConnected ||
		(xendev->state == XenbusStateConnected &&
		 xendrv->is_ready && !xendrv->is_ready(xendev)));
}
static int essential_device_connecting(struct device *dev, void *data)
{
	return is_device_connecting(dev, data, true /* ignore PV[KBB+FB] */);
}
static int non_essential_device_connecting(struct device *dev, void *data)
{
	return is_device_connecting(dev, data, false);
}

static int exists_essential_connecting_device(struct device_driver *drv)
{
	return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
				essential_device_connecting);
}
static int exists_non_essential_connecting_device(struct device_driver *drv)
{
	return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
				non_essential_device_connecting);
}

static int print_device_status(struct device *dev, void *data)
{
	struct xenbus_device *xendev = to_xenbus_device(dev);
	struct device_driver *drv = data;

	/* Is this operation limited to a particular driver? */
	if (drv && (dev->driver != drv))
		return 0;

	if (!dev->driver) {
		/* Information only: is this too noisy? */
		pr_info("Device with no driver: %s\n", xendev->nodename);
	} else if (xendev->state < XenbusStateConnected) {
		enum xenbus_state rstate = XenbusStateUnknown;
		if (xendev->otherend)
			rstate = xenbus_read_driver_state(xendev->otherend);
		pr_warn("Timeout connecting to device: %s (local state %d, remote state %d)\n",
			xendev->nodename, xendev->state, rstate);
	}

	return 0;
}

/* We only wait for device setup after most initcalls have run. */
static int ready_to_wait_for_devices;

static bool wait_loop(unsigned long start, unsigned int max_delay,
		     unsigned int *seconds_waited)
{
	if (time_after(jiffies, start + (*seconds_waited+5)*HZ)) {
		if (!*seconds_waited)
			pr_warn("Waiting for devices to initialise: ");
		*seconds_waited += 5;
		pr_cont("%us...", max_delay - *seconds_waited);
		if (*seconds_waited == max_delay) {
			pr_cont("\n");
			return true;
		}
	}

	schedule_timeout_interruptible(HZ/10);

	return false;
}
/*
 * On a 5-minute timeout, wait for all devices currently configured.  We need
 * to do this to guarantee that the filesystems and / or network devices
 * needed for boot are available, before we can allow the boot to proceed.
 *
 * This needs to be on a late_initcall, to happen after the frontend device
 * drivers have been initialised, but before the root fs is mounted.
 *
 * A possible improvement here would be to have the tools add a per-device
 * flag to the store entry, indicating whether it is needed at boot time.
 * This would allow people who knew what they were doing to accelerate their
 * boot slightly, but of course needs tools or manual intervention to set up
 * those flags correctly.
 */
static void wait_for_devices(struct xenbus_driver *xendrv)
{
	unsigned long start = jiffies;
	struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
	unsigned int seconds_waited = 0;

	if (!ready_to_wait_for_devices || !xen_domain())
		return;

	while (exists_non_essential_connecting_device(drv))
		if (wait_loop(start, 30, &seconds_waited))
			break;

	/* Skips PVKB and PVFB check.*/
	while (exists_essential_connecting_device(drv))
		if (wait_loop(start, 270, &seconds_waited))
			break;

	if (seconds_waited)
		printk("\n");

	bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
			 print_device_status);
}

int __xenbus_register_frontend(struct xenbus_driver *drv, struct module *owner,
			       const char *mod_name)
{
	int ret;

	drv->read_otherend_details = read_backend_details;

	ret = xenbus_register_driver_common(drv, &xenbus_frontend,
					    owner, mod_name);
	if (ret)
		return ret;

	/* If this driver is loaded as a module wait for devices to attach. */
	wait_for_devices(drv);

	return 0;
}
EXPORT_SYMBOL_GPL(__xenbus_register_frontend);

static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq);
static int backend_state;

static void xenbus_reset_backend_state_changed(struct xenbus_watch *w,
					const char **v, unsigned int l)
{
	if (xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i",
			 &backend_state) != 1)
		backend_state = XenbusStateUnknown;
	printk(KERN_DEBUG "XENBUS: backend %s %s\n",
			v[XS_WATCH_PATH], xenbus_strstate(backend_state));
	wake_up(&backend_state_wq);
}

static void xenbus_reset_wait_for_backend(char *be, int expected)
{
	long timeout;
	timeout = wait_event_interruptible_timeout(backend_state_wq,
			backend_state == expected, 5 * HZ);
	if (timeout <= 0)
		pr_info("backend %s timed out\n", be);
}

/*
 * Reset frontend if it is in Connected or Closed state.
 * Wait for backend to catch up.
 * State Connected happens during kdump, Closed after kexec.
 */
static void xenbus_reset_frontend(char *fe, char *be, int be_state)
{
	struct xenbus_watch be_watch;

	printk(KERN_DEBUG "XENBUS: backend %s %s\n",
			be, xenbus_strstate(be_state));

	memset(&be_watch, 0, sizeof(be_watch));
	be_watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", be);
	if (!be_watch.node)
		return;

	be_watch.callback = xenbus_reset_backend_state_changed;
	backend_state = XenbusStateUnknown;

	pr_info("triggering reconnect on %s\n", be);
	register_xenbus_watch(&be_watch);

	/* fall through to forward backend to state XenbusStateInitialising */
	switch (be_state) {
	case XenbusStateConnected:
		xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosing);
		xenbus_reset_wait_for_backend(be, XenbusStateClosing);

	case XenbusStateClosing:
		xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosed);
		xenbus_reset_wait_for_backend(be, XenbusStateClosed);

	case XenbusStateClosed:
		xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateInitialising);
		xenbus_reset_wait_for_backend(be, XenbusStateInitWait);
	}

	unregister_xenbus_watch(&be_watch);
	pr_info("reconnect done on %s\n", be);
	kfree(be_watch.node);
}

static void xenbus_check_frontend(char *class, char *dev)
{
	int be_state, fe_state, err;
	char *backend, *frontend;

	frontend = kasprintf(GFP_NOIO | __GFP_HIGH, "device/%s/%s", class, dev);
	if (!frontend)
		return;

	err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &fe_state);
	if (err != 1)
		goto out;

	switch (fe_state) {
	case XenbusStateConnected:
	case XenbusStateClosed:
		printk(KERN_DEBUG "XENBUS: frontend %s %s\n",
				frontend, xenbus_strstate(fe_state));
		backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
		if (!backend || IS_ERR(backend))
			goto out;
		err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &be_state);
		if (err == 1)
			xenbus_reset_frontend(frontend, backend, be_state);
		kfree(backend);
		break;
	default:
		break;
	}
out:
	kfree(frontend);
}

static void xenbus_reset_state(void)
{
	char **devclass, **dev;
	int devclass_n, dev_n;
	int i, j;

	devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
	if (IS_ERR(devclass))
		return;

	for (i = 0; i < devclass_n; i++) {
		dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
		if (IS_ERR(dev))
			continue;
		for (j = 0; j < dev_n; j++)
			xenbus_check_frontend(devclass[i], dev[j]);
		kfree(dev);
	}
	kfree(devclass);
}

static int frontend_probe_and_watch(struct notifier_block *notifier,
				   unsigned long event,
				   void *data)
{
	/* reset devices in Connected or Closed state */
	if (xen_hvm_domain())
		xenbus_reset_state();
	/* Enumerate devices in xenstore and watch for changes. */
	xenbus_probe_devices(&xenbus_frontend);
	register_xenbus_watch(&fe_watch);

	return NOTIFY_DONE;
}


static int __init xenbus_probe_frontend_init(void)
{
	static struct notifier_block xenstore_notifier = {
		.notifier_call = frontend_probe_and_watch
	};
	int err;

	DPRINTK("");

	/* Register ourselves with the kernel bus subsystem */
	err = bus_register(&xenbus_frontend.bus);
	if (err)
		return err;

	register_xenstore_notifier(&xenstore_notifier);

	return 0;
}
subsys_initcall(xenbus_probe_frontend_init);

#ifndef MODULE
static int __init boot_wait_for_devices(void)
{
	if (!xen_has_pv_devices())
		return -ENODEV;

	ready_to_wait_for_devices = 1;
	wait_for_devices(NULL);
	return 0;
}

late_initcall(boot_wait_for_devices);
#endif

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