xenbus_probe_frontend.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301
  1. #define DPRINTK(fmt, args...) \
  2. pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \
  3. __func__, __LINE__, ##args)
  4. #include <linux/kernel.h>
  5. #include <linux/err.h>
  6. #include <linux/string.h>
  7. #include <linux/ctype.h>
  8. #include <linux/fcntl.h>
  9. #include <linux/mm.h>
  10. #include <linux/proc_fs.h>
  11. #include <linux/notifier.h>
  12. #include <linux/kthread.h>
  13. #include <linux/mutex.h>
  14. #include <linux/io.h>
  15. #include <asm/page.h>
  16. #include <asm/pgtable.h>
  17. #include <asm/xen/hypervisor.h>
  18. #include <xen/xenbus.h>
  19. #include <xen/events.h>
  20. #include <xen/page.h>
  21. #include <xen/platform_pci.h>
  22. #include "xenbus_comms.h"
  23. #include "xenbus_probe.h"
  24. /* device/<type>/<id> => <type>-<id> */
  25. static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename)
  26. {
  27. nodename = strchr(nodename, '/');
  28. if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) {
  29. printk(KERN_WARNING "XENBUS: bad frontend %s\n", nodename);
  30. return -EINVAL;
  31. }
  32. strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);
  33. if (!strchr(bus_id, '/')) {
  34. printk(KERN_WARNING "XENBUS: bus_id %s no slash\n", bus_id);
  35. return -EINVAL;
  36. }
  37. *strchr(bus_id, '/') = '-';
  38. return 0;
  39. }
  40. /* device/<typename>/<name> */
  41. static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type,
  42. const char *name)
  43. {
  44. char *nodename;
  45. int err;
  46. nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, name);
  47. if (!nodename)
  48. return -ENOMEM;
  49. DPRINTK("%s", nodename);
  50. err = xenbus_probe_node(bus, type, nodename);
  51. kfree(nodename);
  52. return err;
  53. }
  54. static int xenbus_uevent_frontend(struct device *_dev,
  55. struct kobj_uevent_env *env)
  56. {
  57. struct xenbus_device *dev = to_xenbus_device(_dev);
  58. if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
  59. return -ENOMEM;
  60. return 0;
  61. }
  62. static void backend_changed(struct xenbus_watch *watch,
  63. const char **vec, unsigned int len)
  64. {
  65. xenbus_otherend_changed(watch, vec, len, 1);
  66. }
  67. static struct device_attribute xenbus_frontend_dev_attrs[] = {
  68. __ATTR_NULL
  69. };
  70. static const struct dev_pm_ops xenbus_pm_ops = {
  71. .suspend = xenbus_dev_suspend,
  72. .resume = xenbus_dev_resume,
  73. .freeze = xenbus_dev_suspend,
  74. .thaw = xenbus_dev_cancel,
  75. .restore = xenbus_dev_resume,
  76. };
  77. static struct xen_bus_type xenbus_frontend = {
  78. .root = "device",
  79. .levels = 2, /* device/type/<id> */
  80. .get_bus_id = frontend_bus_id,
  81. .probe = xenbus_probe_frontend,
  82. .otherend_changed = backend_changed,
  83. .bus = {
  84. .name = "xen",
  85. .match = xenbus_match,
  86. .uevent = xenbus_uevent_frontend,
  87. .probe = xenbus_dev_probe,
  88. .remove = xenbus_dev_remove,
  89. .shutdown = xenbus_dev_shutdown,
  90. .dev_attrs = xenbus_frontend_dev_attrs,
  91. .pm = &xenbus_pm_ops,
  92. },
  93. };
  94. static void frontend_changed(struct xenbus_watch *watch,
  95. const char **vec, unsigned int len)
  96. {
  97. DPRINTK("");
  98. xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
  99. }
  100. /* We watch for devices appearing and vanishing. */
  101. static struct xenbus_watch fe_watch = {
  102. .node = "device",
  103. .callback = frontend_changed,
  104. };
  105. static int read_backend_details(struct xenbus_device *xendev)
  106. {
  107. return xenbus_read_otherend_details(xendev, "backend-id", "backend");
  108. }
  109. static int is_device_connecting(struct device *dev, void *data)
  110. {
  111. struct xenbus_device *xendev = to_xenbus_device(dev);
  112. struct device_driver *drv = data;
  113. struct xenbus_driver *xendrv;
  114. /*
  115. * A device with no driver will never connect. We care only about
  116. * devices which should currently be in the process of connecting.
  117. */
  118. if (!dev->driver)
  119. return 0;
  120. /* Is this search limited to a particular driver? */
  121. if (drv && (dev->driver != drv))
  122. return 0;
  123. xendrv = to_xenbus_driver(dev->driver);
  124. return (xendev->state < XenbusStateConnected ||
  125. (xendev->state == XenbusStateConnected &&
  126. xendrv->is_ready && !xendrv->is_ready(xendev)));
  127. }
  128. static int exists_connecting_device(struct device_driver *drv)
  129. {
  130. return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
  131. is_device_connecting);
  132. }
  133. static int print_device_status(struct device *dev, void *data)
  134. {
  135. struct xenbus_device *xendev = to_xenbus_device(dev);
  136. struct device_driver *drv = data;
  137. /* Is this operation limited to a particular driver? */
  138. if (drv && (dev->driver != drv))
  139. return 0;
  140. if (!dev->driver) {
  141. /* Information only: is this too noisy? */
  142. printk(KERN_INFO "XENBUS: Device with no driver: %s\n",
  143. xendev->nodename);
  144. } else if (xendev->state < XenbusStateConnected) {
  145. enum xenbus_state rstate = XenbusStateUnknown;
  146. if (xendev->otherend)
  147. rstate = xenbus_read_driver_state(xendev->otherend);
  148. printk(KERN_WARNING "XENBUS: Timeout connecting "
  149. "to device: %s (local state %d, remote state %d)\n",
  150. xendev->nodename, xendev->state, rstate);
  151. }
  152. return 0;
  153. }
  154. /* We only wait for device setup after most initcalls have run. */
  155. static int ready_to_wait_for_devices;
  156. /*
  157. * On a 5-minute timeout, wait for all devices currently configured. We need
  158. * to do this to guarantee that the filesystems and / or network devices
  159. * needed for boot are available, before we can allow the boot to proceed.
  160. *
  161. * This needs to be on a late_initcall, to happen after the frontend device
  162. * drivers have been initialised, but before the root fs is mounted.
  163. *
  164. * A possible improvement here would be to have the tools add a per-device
  165. * flag to the store entry, indicating whether it is needed at boot time.
  166. * This would allow people who knew what they were doing to accelerate their
  167. * boot slightly, but of course needs tools or manual intervention to set up
  168. * those flags correctly.
  169. */
  170. static void wait_for_devices(struct xenbus_driver *xendrv)
  171. {
  172. unsigned long start = jiffies;
  173. struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
  174. unsigned int seconds_waited = 0;
  175. if (!ready_to_wait_for_devices || !xen_domain())
  176. return;
  177. while (exists_connecting_device(drv)) {
  178. if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
  179. if (!seconds_waited)
  180. printk(KERN_WARNING "XENBUS: Waiting for "
  181. "devices to initialise: ");
  182. seconds_waited += 5;
  183. printk("%us...", 300 - seconds_waited);
  184. if (seconds_waited == 300)
  185. break;
  186. }
  187. schedule_timeout_interruptible(HZ/10);
  188. }
  189. if (seconds_waited)
  190. printk("\n");
  191. bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
  192. print_device_status);
  193. }
  194. int __xenbus_register_frontend(struct xenbus_driver *drv,
  195. struct module *owner, const char *mod_name)
  196. {
  197. int ret;
  198. drv->read_otherend_details = read_backend_details;
  199. ret = xenbus_register_driver_common(drv, &xenbus_frontend,
  200. owner, mod_name);
  201. if (ret)
  202. return ret;
  203. /* If this driver is loaded as a module wait for devices to attach. */
  204. wait_for_devices(drv);
  205. return 0;
  206. }
  207. EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
  208. static int frontend_probe_and_watch(struct notifier_block *notifier,
  209. unsigned long event,
  210. void *data)
  211. {
  212. /* Enumerate devices in xenstore and watch for changes. */
  213. xenbus_probe_devices(&xenbus_frontend);
  214. register_xenbus_watch(&fe_watch);
  215. return NOTIFY_DONE;
  216. }
  217. static int __init xenbus_probe_frontend_init(void)
  218. {
  219. static struct notifier_block xenstore_notifier = {
  220. .notifier_call = frontend_probe_and_watch
  221. };
  222. int err;
  223. DPRINTK("");
  224. /* Register ourselves with the kernel bus subsystem */
  225. err = bus_register(&xenbus_frontend.bus);
  226. if (err)
  227. return err;
  228. register_xenstore_notifier(&xenstore_notifier);
  229. return 0;
  230. }
  231. subsys_initcall(xenbus_probe_frontend_init);
  232. #ifndef MODULE
  233. static int __init boot_wait_for_devices(void)
  234. {
  235. if (xen_hvm_domain() && !xen_platform_pci_unplug)
  236. return -ENODEV;
  237. ready_to_wait_for_devices = 1;
  238. wait_for_devices(NULL);
  239. return 0;
  240. }
  241. late_initcall(boot_wait_for_devices);
  242. #endif
  243. MODULE_LICENSE("GPL");