Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2de06cc1 authored by Ian Campbell's avatar Ian Campbell Committed by Konrad Rzeszutek Wilk
Browse files

xen: separate out frontend xenbus 



Impact: refactor

Make a distinct frontend xenbus, in preparation for adding a backend xenbus.

Signed-off-by: default avatarIan Campbell <ian.campbell@citrix.com>
Signed-off-by: default avatarJeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
[corresponds to 2fd433a4188f in git://git.kernel.org/pub/scm/linux/kernel/git/jeremy/xen.git


 with adjustments to reflect changes in the code which is moved]
Signed-off-by: default avatarKonrad Rzeszutek Wilk <konrad.wilk@oracle.com>
parent cf7d7e5a

drivers/block/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -464,6 +464,7 @@ config XEN_BLKDEV_FRONTEND 
	tristate "Xen virtual block device support"

	depends on XEN

	default y

	select XEN_XENBUS_FRONTEND

	help

	  This driver implements the front-end of the Xen virtual

	  block device driver.  It communicates with a back-end driver

drivers/xen/Kconfig

+3 −0
Original line number Diff line number Diff line
@@ -62,6 +62,9 @@ config XEN_SYS_HYPERVISOR 
	 virtual environment, /sys/hypervisor will still be present,

	 but will have no xen contents.



config XEN_XENBUS_FRONTEND

       tristate

	  

config XEN_PLATFORM_PCI

	tristate "xen platform pci device driver"

	depends on XEN_PVHVM

drivers/xen/xenbus/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -5,3 +5,5 @@ xenbus-objs += xenbus_client.o 
xenbus-objs += xenbus_comms.o

xenbus-objs += xenbus_xs.o

xenbus-objs += xenbus_probe.o



obj-$(CONFIG_XEN_XENBUS_FRONTEND) += xenbus_probe_frontend.o

drivers/xen/xenbus/xenbus_probe.c

+71 −290
Original line number Diff line number Diff line
@@ -56,7 +56,6 @@ 
#include <xen/events.h>

#include <xen/page.h>



#include <xen/platform_pci.h>

#include <xen/hvm.h>



#include "xenbus_comms.h"
@@ -73,15 +72,6 @@ static unsigned long xen_store_mfn; 


static BLOCKING_NOTIFIER_HEAD(xenstore_chain);



static void wait_for_devices(struct xenbus_driver *xendrv);



static int xenbus_probe_frontend(const char *type, const char *name);



static void xenbus_dev_shutdown(struct device *_dev);



static int xenbus_dev_suspend(struct device *dev, pm_message_t state);

static int xenbus_dev_resume(struct device *dev);



/* If something in array of ids matches this device, return it. */

static const struct xenbus_device_id *

match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev)
@@ -102,8 +92,10 @@ int xenbus_match(struct device *_dev, struct device_driver *_drv) 


	return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;

}

EXPORT_SYMBOL_GPL(xenbus_match);





static int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env)

int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env)

{

	struct xenbus_device *dev = to_xenbus_device(_dev);
@@ -112,25 +104,7 @@ static int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env) 


	return 0;

}



/* 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) {

		printk(KERN_WARNING "XENBUS: bad frontend %s\n", nodename);

		return -EINVAL;

	}



	strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);

	if (!strchr(bus_id, '/')) {

		printk(KERN_WARNING "XENBUS: bus_id %s no slash\n", bus_id);

		return -EINVAL;

	}

	*strchr(bus_id, '/') = '-';

	return 0;

}



EXPORT_SYMBOL_GPL(xenbus_uevent);



static void free_otherend_details(struct xenbus_device *dev)

{
@@ -149,7 +123,28 @@ static void free_otherend_watch(struct xenbus_device *dev) 
}





int read_otherend_details(struct xenbus_device *xendev,

static int talk_to_otherend(struct xenbus_device *dev)

{

	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);



	free_otherend_watch(dev);

	free_otherend_details(dev);



	return drv->read_otherend_details(dev);

}







static int watch_otherend(struct xenbus_device *dev)

{

	struct xen_bus_type *bus = container_of(dev->dev.bus, struct xen_bus_type, bus);



	return xenbus_watch_pathfmt(dev, &dev->otherend_watch, bus->otherend_changed,

				    "%s/%s", dev->otherend, "state");

}





int xenbus_read_otherend_details(struct xenbus_device *xendev,

				 char *id_node, char *path_node)

{

	int err = xenbus_gather(XBT_NIL, xendev->nodename,
@@ -174,39 +169,11 @@ int read_otherend_details(struct xenbus_device *xendev, 


	return 0;

}

EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);





static int read_backend_details(struct xenbus_device *xendev)

{

	return read_otherend_details(xendev, "backend-id", "backend");

}



static struct device_attribute xenbus_dev_attrs[] = {

	__ATTR_NULL

};



/* Bus type for frontend drivers. */

static struct xen_bus_type xenbus_frontend = {

	.root = "device",

	.levels = 2, 		/* device/type/<id> */

	.get_bus_id = frontend_bus_id,

	.probe = xenbus_probe_frontend,

	.bus = {

		.name      = "xen",

		.match     = xenbus_match,

		.uevent    = xenbus_uevent,

		.probe     = xenbus_dev_probe,

		.remove    = xenbus_dev_remove,

		.shutdown  = xenbus_dev_shutdown,

		.dev_attrs = xenbus_dev_attrs,



		.suspend   = xenbus_dev_suspend,

		.resume    = xenbus_dev_resume,

	},

};



static void otherend_changed(struct xenbus_watch *watch,

			     const char **vec, unsigned int len)

void xenbus_otherend_changed(struct xenbus_watch *watch,

			     const char **vec, unsigned int len,

			     int ignore_on_shutdown)

{

	struct xenbus_device *dev =

		container_of(watch, struct xenbus_device, otherend_watch);
@@ -234,11 +201,7 @@ static void otherend_changed(struct xenbus_watch *watch, 
	 * work that can fail e.g., when the rootfs is gone.

	 */

	if (system_state > SYSTEM_RUNNING) {

		struct xen_bus_type *bus = bus;

		bus = container_of(dev->dev.bus, struct xen_bus_type, bus);

		/* If we're frontend, drive the state machine to Closed. */

		/* This should cause the backend to release our resources. */

		if ((bus == &xenbus_frontend) && (state == XenbusStateClosing))

		if (ignore_on_shutdown && (state == XenbusStateClosing))

			xenbus_frontend_closed(dev);

		return;

	}
@@ -246,25 +209,7 @@ static void otherend_changed(struct xenbus_watch *watch, 
	if (drv->otherend_changed)

		drv->otherend_changed(dev, state);

}





static int talk_to_otherend(struct xenbus_device *dev)

{

	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);



	free_otherend_watch(dev);

	free_otherend_details(dev);



	return drv->read_otherend_details(dev);

}





static int watch_otherend(struct xenbus_device *dev)

{

	return xenbus_watch_pathfmt(dev, &dev->otherend_watch, otherend_changed,

				    "%s/%s", dev->otherend, "state");

}



EXPORT_SYMBOL_GPL(xenbus_otherend_changed);



int xenbus_dev_probe(struct device *_dev)

{
@@ -310,6 +255,7 @@ int xenbus_dev_probe(struct device *_dev) 
	xenbus_switch_state(dev, XenbusStateClosed);

	return -ENODEV;

}

EXPORT_SYMBOL_GPL(xenbus_dev_probe);



int xenbus_dev_remove(struct device *_dev)

{
@@ -327,8 +273,9 @@ int xenbus_dev_remove(struct device *_dev) 
	xenbus_switch_state(dev, XenbusStateClosed);

	return 0;

}

EXPORT_SYMBOL_GPL(xenbus_dev_remove);



static void xenbus_dev_shutdown(struct device *_dev)

void xenbus_dev_shutdown(struct device *_dev)

{

	struct xenbus_device *dev = to_xenbus_device(_dev);

	unsigned long timeout = 5*HZ;
@@ -349,6 +296,7 @@ static void xenbus_dev_shutdown(struct device *_dev) 
 out:

	put_device(&dev->dev);

}

EXPORT_SYMBOL_GPL(xenbus_dev_shutdown);



int xenbus_register_driver_common(struct xenbus_driver *drv,

				  struct xen_bus_type *bus,
@@ -362,25 +310,7 @@ int xenbus_register_driver_common(struct xenbus_driver *drv, 


	return driver_register(&drv->driver);

}



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);

EXPORT_SYMBOL_GPL(xenbus_register_driver_common);



void xenbus_unregister_driver(struct xenbus_driver *drv)

{
@@ -551,24 +481,7 @@ int xenbus_probe_node(struct xen_bus_type *bus, 
	kfree(xendev);

	return err;

}



/* device/<typename>/<name> */

static int xenbus_probe_frontend(const char *type, const char *name)

{

	char *nodename;

	int err;



	nodename = kasprintf(GFP_KERNEL, "%s/%s/%s",

			     xenbus_frontend.root, type, name);

	if (!nodename)

		return -ENOMEM;



	DPRINTK("%s", nodename);



	err = xenbus_probe_node(&xenbus_frontend, type, nodename);

	kfree(nodename);

	return err;

}

EXPORT_SYMBOL_GPL(xenbus_probe_node);



static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)

{
@@ -577,15 +490,23 @@ static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type) 
	unsigned int dir_n = 0;

	int i;



	printk(KERN_CRIT "%s type %s\n", __func__, type);



	dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n);

	if (IS_ERR(dir))

	if (IS_ERR(dir)) {

		printk(KERN_CRIT "%s failed xenbus_directory\n", __func__);

		return PTR_ERR(dir);

	}



	for (i = 0; i < dir_n; i++) {

		err = bus->probe(type, dir[i]);

		if (err)

		printk(KERN_CRIT "%s %d/%d %s\n", __func__, i+1,dir_n, dir[i]);

		err = bus->probe(bus, type, dir[i]);

		if (err) {

			printk(KERN_CRIT "%s failed\n", __func__);

			break;

		}

	}

	printk("%s done\n", __func__);

	kfree(dir);

	return err;

}
@@ -596,18 +517,27 @@ int xenbus_probe_devices(struct xen_bus_type *bus) 
	char **dir;

	unsigned int i, dir_n;



	printk(KERN_CRIT "%s %s\n", __func__, bus->root);



	dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n);

	if (IS_ERR(dir))

	if (IS_ERR(dir)) {

		printk(KERN_CRIT "%s failed xenbus_directory\n", __func__);

		return PTR_ERR(dir);

	}



	for (i = 0; i < dir_n; i++) {

		printk(KERN_CRIT "%s %d/%d %s\n", __func__, i+1,dir_n, dir[i]);

		err = xenbus_probe_device_type(bus, dir[i]);

		if (err)

		if (err) {

			printk(KERN_CRIT "%s failed\n", __func__);

			break;

		}

	}

	printk("%s done\n", __func__);

	kfree(dir);

	return err;

}

EXPORT_SYMBOL_GPL(xenbus_probe_devices);



static unsigned int char_count(const char *str, char c)

{
@@ -670,32 +600,17 @@ void xenbus_dev_changed(const char *node, struct xen_bus_type *bus) 
}

EXPORT_SYMBOL_GPL(xenbus_dev_changed);



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 xenbus_dev_suspend(struct device *dev, pm_message_t state)

int xenbus_dev_suspend(struct device *dev, pm_message_t state)

{

	int err = 0;

	struct xenbus_driver *drv;

	struct xenbus_device *xdev;

	struct xenbus_device *xdev = container_of(dev, struct xenbus_device, dev);



	DPRINTK("");

	DPRINTK("%s", xdev->nodename);



	if (dev->driver == NULL)

		return 0;

	drv = to_xenbus_driver(dev->driver);

	xdev = container_of(dev, struct xenbus_device, dev);

	if (drv->suspend)

		err = drv->suspend(xdev, state);

	if (err)
@@ -703,21 +618,19 @@ static int xenbus_dev_suspend(struct device *dev, pm_message_t state) 
		       "xenbus: suspend %s failed: %i\n", dev_name(dev), err);

	return 0;

}

EXPORT_SYMBOL_GPL(xenbus_dev_suspend);



static int xenbus_dev_resume(struct device *dev)

int xenbus_dev_resume(struct device *dev)

{

	int err;

	struct xenbus_driver *drv;

	struct xenbus_device *xdev;

	struct xenbus_device *xdev = container_of(dev, struct xenbus_device, dev);



	DPRINTK("");

	DPRINTK("%s", xdev->nodename);



	if (dev->driver == NULL)

		return 0;



	drv = to_xenbus_driver(dev->driver);

	xdev = container_of(dev, struct xenbus_device, dev);



	err = talk_to_otherend(xdev);

	if (err) {

		printk(KERN_WARNING
@@ -748,6 +661,7 @@ static int xenbus_dev_resume(struct device *dev) 


	return 0;

}

EXPORT_SYMBOL_GPL(xenbus_dev_resume);



/* A flag to determine if xenstored is 'ready' (i.e. has started) */

int xenstored_ready = 0;
@@ -776,11 +690,6 @@ void xenbus_probe(struct work_struct *unused) 
{

	xenstored_ready = 1;



	/* Enumerate devices in xenstore and watch for changes. */

	xenbus_probe_devices(&xenbus_frontend);

	register_xenbus_watch(&fe_watch);

	xenbus_backend_probe_and_watch();



	/* Notify others that xenstore is up */

	blocking_notifier_call_chain(&xenstore_chain, 0, NULL);

}
@@ -811,15 +720,6 @@ static int __init xenbus_init(void) 
	if (!xen_domain())

		goto out_error;



	/* Register ourselves with the kernel bus subsystem */

	err = bus_register(&xenbus_frontend.bus);

	if (err)

		goto out_error;



	err = xenbus_backend_bus_register();

	if (err)

		goto out_unreg_front;



	/*

	 * Domain0 doesn't have a store_evtchn or store_mfn yet.

	 */
@@ -874,7 +774,7 @@ static int __init xenbus_init(void) 
	if (err) {

		printk(KERN_WARNING

		       "XENBUS: Error initializing xenstore comms: %i\n", err);

		goto out_unreg_back;

		goto out_error;

	}



#ifdef CONFIG_XEN_COMPAT_XENFS
@@ -885,135 +785,16 @@ static int __init xenbus_init(void) 
	proc_mkdir("xen", NULL);

#endif



	printk(KERN_CRIT "%s ok\n", __func__);

	return 0;



  out_unreg_back:

	xenbus_backend_bus_unregister();



  out_unreg_front:

	bus_unregister(&xenbus_frontend.bus);



  out_error:

	if (page != 0)

		free_page(page);



	return err;

}



postcore_initcall(xenbus_init);



MODULE_LICENSE("GPL");
 


static int is_device_connecting(struct device *dev, void *data)

{

	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;



	xendrv = to_xenbus_driver(dev->driver);

	return (xendev->state < XenbusStateConnected ||

		(xendev->state == XenbusStateConnected &&

		 xendrv->is_ready && !xendrv->is_ready(xendev)));

}



static int exists_connecting_device(struct device_driver *drv)

{

	return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,

				is_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? */

		printk(KERN_INFO "XENBUS: 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);

		printk(KERN_WARNING "XENBUS: 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;



/*

 * 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_connecting_device(drv)) {

		if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {

			if (!seconds_waited)

				printk(KERN_WARNING "XENBUS: Waiting for "

				       "devices to initialise: ");

			seconds_waited += 5;

			printk("%us...", 300 - seconds_waited);

			if (seconds_waited == 300)

				break;

		}



		schedule_timeout_interruptible(HZ/10);

	}



	if (seconds_waited)

		printk("\n");



	bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,

			 print_device_status);

}



#ifndef MODULE

static int __init boot_wait_for_devices(void)

{

	if (xen_hvm_domain() && !xen_platform_pci_unplug)

		return -ENODEV;



	ready_to_wait_for_devices = 1;

	wait_for_devices(NULL);

	return 0;

}



late_initcall(boot_wait_for_devices);

#endif

drivers/xen/xenbus/xenbus_probe.h

+15 −15
Original line number Diff line number Diff line
@@ -36,26 +36,13 @@ 


#define XEN_BUS_ID_SIZE			20



#ifdef CONFIG_XEN_BACKEND

extern void xenbus_backend_suspend(int (*fn)(struct device *, void *));

extern void xenbus_backend_resume(int (*fn)(struct device *, void *));

extern void xenbus_backend_probe_and_watch(void);

extern int xenbus_backend_bus_register(void);

extern void xenbus_backend_bus_unregister(void);

#else

static inline void xenbus_backend_suspend(int (*fn)(struct device *, void *)) {}

static inline void xenbus_backend_resume(int (*fn)(struct device *, void *)) {}

static inline void xenbus_backend_probe_and_watch(void) {}

static inline int xenbus_backend_bus_register(void) { return 0; }

static inline void xenbus_backend_bus_unregister(void) {}

#endif



struct xen_bus_type

{

	char *root;

	unsigned int levels;

	int (*get_bus_id)(char bus_id[XEN_BUS_ID_SIZE], const char *nodename);

	int (*probe)(const char *type, const char *dir);

	int (*probe)(struct xen_bus_type *bus, const char *type, const char *dir);

	void (*otherend_changed)(struct xenbus_watch *watch, const char **vec, unsigned int len);

	struct bus_type bus;

};
@@ -73,4 +60,17 @@ extern int xenbus_probe_devices(struct xen_bus_type *bus); 


extern void xenbus_dev_changed(const char *node, struct xen_bus_type *bus);



extern int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env);

extern void xenbus_dev_shutdown(struct device *_dev);



extern int xenbus_dev_suspend(struct device *dev, pm_message_t state);

extern int xenbus_dev_resume(struct device *dev);



extern void xenbus_otherend_changed(struct xenbus_watch *watch,

				    const char **vec, unsigned int len,

				    int ignore_on_shutdown);



extern int xenbus_read_otherend_details(struct xenbus_device *xendev,

					char *id_node, char *path_node);



#endif