consolidate and simplify struct xenbus_driver instantiation The 'name' and 'owner' members are redundant with the identically named fields in the 'driver' sub-structure. Rather than switching each instance to specify these fields explicitly, introduce a macro to simplify this (and at once to abstract out - for the unmodified drivers build - the absence of the 'owner' field in Linux prior to 2.6.10). Also add a module alias for the vtpm frontend driver (overlooked in 141:5e294e29a43e). v2: Eliminate further redundancy by allowing the drvname argument to DEFINE_XENBUS_DRIVER() to be blank (in which case the first entry from the ID table will be used for .driver.name). Signed-off-by: Jan Beulich --- a/drivers/char/tpm/tpm_xen.c +++ b/drivers/char/tpm/tpm_xen.c @@ -475,26 +475,24 @@ static int tpmif_connect(struct xenbus_d return 0; } -static struct xenbus_device_id tpmfront_ids[] = { +static const struct xenbus_device_id tpmfront_ids[] = { { "vtpm" }, { "" } }; +MODULE_ALIAS("xen:vtpm"); -static struct xenbus_driver tpmfront = { - .name = "vtpm", - .owner = THIS_MODULE, - .ids = tpmfront_ids, +static DEFINE_XENBUS_DRIVER(tpmfront, , .probe = tpmfront_probe, .remove = tpmfront_remove, .resume = tpmfront_resume, .otherend_changed = backend_changed, .suspend = tpmfront_suspend, .suspend_cancel = tpmfront_suspend_cancel, -}; +); static void __init init_tpm_xenbus(void) { - xenbus_register_frontend(&tpmfront); + xenbus_register_frontend(&tpmfront_driver); } static int tpmif_allocate_tx_buffers(struct tpm_private *tp) --- a/drivers/xen/blkback/xenbus.c +++ b/drivers/xen/blkback/xenbus.c @@ -542,18 +542,14 @@ static const struct xenbus_device_id blk { "" } }; - -static struct xenbus_driver blkback = { - .name = "vbd", - .owner = THIS_MODULE, - .ids = blkback_ids, +static DEFINE_XENBUS_DRIVER(blkback, , .probe = blkback_probe, .remove = blkback_remove, .otherend_changed = frontend_changed -}; +); void blkif_xenbus_init(void) { - xenbus_register_backend(&blkback); + xenbus_register_backend(&blkback_driver); } --- a/drivers/xen/blkfront/blkfront.c +++ b/drivers/xen/blkfront/blkfront.c @@ -934,16 +934,13 @@ static const struct xenbus_device_id blk }; MODULE_ALIAS("xen:vbd"); -static struct xenbus_driver blkfront = { - .name = "vbd", - .owner = THIS_MODULE, - .ids = blkfront_ids, +static DEFINE_XENBUS_DRIVER(blkfront, , .probe = blkfront_probe, .remove = blkfront_remove, .resume = blkfront_resume, .otherend_changed = backend_changed, .is_ready = blkfront_is_ready, -}; +); static int __init xlblk_init(void) @@ -951,14 +948,14 @@ static int __init xlblk_init(void) if (!is_running_on_xen()) return -ENODEV; - return xenbus_register_frontend(&blkfront); + return xenbus_register_frontend(&blkfront_driver); } module_init(xlblk_init); static void __exit xlblk_exit(void) { - return xenbus_unregister_driver(&blkfront); + return xenbus_unregister_driver(&blkfront_driver); } module_exit(xlblk_exit); --- a/drivers/xen/blktap/xenbus.c +++ b/drivers/xen/blktap/xenbus.c @@ -490,18 +490,14 @@ static const struct xenbus_device_id blk { "" } }; - -static struct xenbus_driver blktap = { - .name = "tap", - .owner = THIS_MODULE, - .ids = blktap_ids, +static DEFINE_XENBUS_DRIVER(blktap, , .probe = blktap_probe, .remove = blktap_remove, .otherend_changed = tap_frontend_changed -}; +); void tap_blkif_xenbus_init(void) { - xenbus_register_backend(&blktap); + xenbus_register_backend(&blktap_driver); } --- a/drivers/xen/fbfront/xenfb.c +++ b/drivers/xen/fbfront/xenfb.c @@ -857,15 +857,12 @@ static const struct xenbus_device_id xen }; MODULE_ALIAS("xen:vfb"); -static struct xenbus_driver xenfb_driver = { - .name = "vfb", - .owner = THIS_MODULE, - .ids = xenfb_ids, +static DEFINE_XENBUS_DRIVER(xenfb, , .probe = xenfb_probe, .remove = xenfb_remove, .resume = xenfb_resume, .otherend_changed = xenfb_backend_changed, -}; +); static int __init xenfb_init(void) { --- a/drivers/xen/fbfront/xenkbd.c +++ b/drivers/xen/fbfront/xenkbd.c @@ -335,15 +335,12 @@ static const struct xenbus_device_id xen }; MODULE_ALIAS("xen:vkbd"); -static struct xenbus_driver xenkbd_driver = { - .name = "vkbd", - .owner = THIS_MODULE, - .ids = xenkbd_ids, +static DEFINE_XENBUS_DRIVER(xenkbd, , .probe = xenkbd_probe, .remove = xenkbd_remove, .resume = xenkbd_resume, .otherend_changed = xenkbd_backend_changed, -}; +); static int __init xenkbd_init(void) { --- a/drivers/xen/netback/xenbus.c +++ b/drivers/xen/netback/xenbus.c @@ -437,19 +437,15 @@ static const struct xenbus_device_id net { "" } }; - -static struct xenbus_driver netback = { - .name = "vif", - .owner = THIS_MODULE, - .ids = netback_ids, +static DEFINE_XENBUS_DRIVER(netback, , .probe = netback_probe, .remove = netback_remove, .uevent = netback_uevent, .otherend_changed = frontend_changed, -}; +); void netif_xenbus_init(void) { - xenbus_register_backend(&netback); + xenbus_register_backend(&netback_driver); } --- a/drivers/xen/netfront/netfront.c +++ b/drivers/xen/netfront/netfront.c @@ -2197,18 +2197,14 @@ static const struct xenbus_device_id net }; MODULE_ALIAS("xen:vif"); - -static struct xenbus_driver netfront_driver = { - .name = "vif", - .owner = THIS_MODULE, - .ids = netfront_ids, +static DEFINE_XENBUS_DRIVER(netfront, , .probe = netfront_probe, .remove = __devexit_p(netfront_remove), .suspend = netfront_suspend, .suspend_cancel = netfront_suspend_cancel, .resume = netfront_resume, .otherend_changed = backend_changed, -}; +); static int __init netif_init(void) --- a/drivers/xen/pciback/xenbus.c +++ b/drivers/xen/pciback/xenbus.c @@ -676,19 +676,16 @@ static int pciback_xenbus_remove(struct return 0; } -static const struct xenbus_device_id xenpci_ids[] = { +static const struct xenbus_device_id pciback_ids[] = { {"pci"}, {{0}}, }; -static struct xenbus_driver xenbus_pciback_driver = { - .name = "pciback", - .owner = THIS_MODULE, - .ids = xenpci_ids, +static DEFINE_XENBUS_DRIVER(pciback, "pciback", .probe = pciback_xenbus_probe, .remove = pciback_xenbus_remove, .otherend_changed = pciback_frontend_changed, -}; +); int __init pciback_xenbus_register(void) { @@ -700,11 +697,11 @@ int __init pciback_xenbus_register(void) "pciback_workqueue failed\n"); return -EFAULT; } - return xenbus_register_backend(&xenbus_pciback_driver); + return xenbus_register_backend(&pciback_driver); } void __exit pciback_xenbus_unregister(void) { destroy_workqueue(pciback_wq); - xenbus_unregister_driver(&xenbus_pciback_driver); + xenbus_unregister_driver(&pciback_driver); } --- a/drivers/xen/pcifront/xenbus.c +++ b/drivers/xen/pcifront/xenbus.c @@ -456,27 +456,24 @@ static int pcifront_xenbus_remove(struct return 0; } -static const struct xenbus_device_id xenpci_ids[] = { +static const struct xenbus_device_id pcifront_ids[] = { {"pci"}, {{0}}, }; MODULE_ALIAS("xen:pci"); -static struct xenbus_driver xenbus_pcifront_driver = { - .name = "pcifront", - .owner = THIS_MODULE, - .ids = xenpci_ids, +static DEFINE_XENBUS_DRIVER(pcifront, "pcifront", .probe = pcifront_xenbus_probe, .remove = pcifront_xenbus_remove, .otherend_changed = pcifront_backend_changed, -}; +); static int __init pcifront_init(void) { if (!is_running_on_xen()) return -ENODEV; - return xenbus_register_frontend(&xenbus_pcifront_driver); + return xenbus_register_frontend(&pcifront_driver); } /* Initialize after the Xen PCI Frontend Stub is initialized */ --- a/drivers/xen/scsiback/xenbus.c +++ b/drivers/xen/scsiback/xenbus.c @@ -352,26 +352,23 @@ fail: } -static struct xenbus_device_id scsiback_ids[] = { +static const struct xenbus_device_id scsiback_ids[] = { { "vscsi" }, { "" } }; -static struct xenbus_driver scsiback = { - .name = "vscsi", - .owner = THIS_MODULE, - .ids = scsiback_ids, +static DEFINE_XENBUS_DRIVER(scsiback, , .probe = scsiback_probe, .remove = scsiback_remove, .otherend_changed = scsiback_frontend_changed -}; +); int scsiback_xenbus_init(void) { - return xenbus_register_backend(&scsiback); + return xenbus_register_backend(&scsiback_driver); } void scsiback_xenbus_unregister(void) { - xenbus_unregister_driver(&scsiback); + xenbus_unregister_driver(&scsiback_driver); } --- a/drivers/xen/scsifront/xenbus.c +++ b/drivers/xen/scsifront/xenbus.c @@ -398,21 +398,18 @@ static void scsifront_backend_changed(st } -static struct xenbus_device_id scsifront_ids[] = { +static const struct xenbus_device_id scsifront_ids[] = { { "vscsi" }, { "" } }; MODULE_ALIAS("xen:vscsi"); -static struct xenbus_driver scsifront_driver = { - .name = "vscsi", - .owner = THIS_MODULE, - .ids = scsifront_ids, +static DEFINE_XENBUS_DRIVER(scsifront, , .probe = scsifront_probe, .remove = scsifront_remove, /* .resume = scsifront_resume, */ .otherend_changed = scsifront_backend_changed, -}; +); int scsifront_xenbus_init(void) { --- a/drivers/xen/tpmback/xenbus.c +++ b/drivers/xen/tpmback/xenbus.c @@ -251,23 +251,19 @@ static const struct xenbus_device_id tpm { "" } }; - -static struct xenbus_driver tpmback = { - .name = "vtpm", - .owner = THIS_MODULE, - .ids = tpmback_ids, +static DEFINE_XENBUS_DRIVER(tpmback, , .probe = tpmback_probe, .remove = tpmback_remove, .otherend_changed = frontend_changed, -}; +); void tpmif_xenbus_init(void) { - xenbus_register_backend(&tpmback); + xenbus_register_backend(&tpmback_driver); } void tpmif_xenbus_exit(void) { - xenbus_unregister_driver(&tpmback); + xenbus_unregister_driver(&tpmback_driver); } --- a/drivers/xen/usbback/xenbus.c +++ b/drivers/xen/usbback/xenbus.c @@ -317,14 +317,11 @@ static const struct xenbus_device_id usb { "" }, }; -static struct xenbus_driver usbback_driver = { - .name = "vusb", - .owner = THIS_MODULE, - .ids = usbback_ids, +static DEFINE_XENBUS_DRIVER(usbback, , .probe = usbback_probe, .otherend_changed = frontend_changed, .remove = usbback_remove, -}; +); int __init usbback_xenbus_init(void) { --- a/drivers/xen/usbfront/xenbus.c +++ b/drivers/xen/usbfront/xenbus.c @@ -379,14 +379,11 @@ static const struct xenbus_device_id usb }; MODULE_ALIAS("xen:vusb"); -static struct xenbus_driver usbfront_driver = { - .name = "vusb", - .owner = THIS_MODULE, - .ids = usbfront_ids, +static DEFINE_XENBUS_DRIVER(usbfront, , .probe = usbfront_probe, .otherend_changed = backend_changed, .remove = usbfront_remove, -}; +); static int __init usbfront_init(void) { --- a/drivers/xen/xenbus/xenbus_probe.c +++ b/drivers/xen/xenbus/xenbus_probe.c @@ -382,11 +382,7 @@ int xenbus_register_driver_common(struct if (bus->error) return bus->error; - drv->driver.name = drv->name; drv->driver.bus = &bus->bus; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) - drv->driver.owner = drv->owner; -#endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) drv->driver.probe = xenbus_dev_probe; drv->driver.remove = xenbus_dev_remove; --- a/include/xen/xenbus.h +++ b/include/xen/xenbus.h @@ -40,6 +40,7 @@ #include #include #include +#include #include #include #include @@ -93,8 +94,6 @@ struct xenbus_device_id /* A xenbus driver. */ struct xenbus_driver { - char *name; - struct module *owner; const struct xenbus_device_id *ids; int (*probe)(struct xenbus_device *dev, const struct xenbus_device_id *id); @@ -110,6 +109,19 @@ struct xenbus_driver { int (*is_ready)(struct xenbus_device *dev); }; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) +# define XENBUS_DRIVER_SET_OWNER(mod) .driver.owner = mod, +#else +# define XENBUS_DRIVER_SET_OWNER(mod) +#endif + +#define DEFINE_XENBUS_DRIVER(var, drvname, methods...) \ +struct xenbus_driver var ## _driver = { \ + .driver.name = drvname + 0 ?: var ## _ids->devicetype, \ + XENBUS_DRIVER_SET_OWNER(THIS_MODULE) \ + .ids = var ## _ids, ## methods \ +} + static inline struct xenbus_driver *to_xenbus_driver(struct device_driver *drv) { return container_of(drv, struct xenbus_driver, driver);