X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fudev.c;h=fa5d4b417a0f7f2164b6f4245bcf20e09f52ab2e;hp=6ccb8d4ba42917aed8669cf4e78bff03cc500a6e;hb=c78f9ec47ba92b74698dacdae963dbbefd9b676f;hpb=b6ee414890fcd582a96f4d89e648cff5dacb1cb9 diff --git a/discover/udev.c b/discover/udev.c index 6ccb8d4..fa5d4b4 100644 --- a/discover/udev.c +++ b/discover/udev.c @@ -19,12 +19,15 @@ #include #include #include +#include #include "event.h" #include "udev.h" #include "pb-discover.h" #include "device-handler.h" #include "cdrom.h" +#include "devmapper.h" +#include "network.h" /* We set a default monitor buffer size, as we may not process monitor * events while performing device discvoery. systemd uses a 128M buffer, so @@ -69,17 +72,41 @@ static void udev_setup_device_params(struct udev_device *udev, udev_list_entry_get_value(entry)); } +/* + * Search for LVM logical volumes. If any exist they should be recognised + * by udev as normal. + * Normally this is handled in an init script, but on some platforms + * disks are slow enough to come up that we need to check again. + */ +static void lvm_vg_search(struct device_handler *handler) +{ + if (process_run_simple(handler, pb_system_apps.vgscan, "-qq", NULL)) + pb_log_fn("Failed to execute vgscan\n"); + + if (process_run_simple(handler, pb_system_apps.vgchange, "-ay", "-qq", + NULL)) + pb_log_fn("Failed to execute vgchange\n"); +} + static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, const char *name) { + char *devlinks = NULL, *link, *saveptr = NULL; struct discover_device *ddev; + unsigned int i = 0; const char *typestr; const char *uuid; const char *path; const char *node; const char *prop; const char *type; - bool cdrom; + const char *devname; + const char *ignored_types[] = { + "linux_raid_member", + "swap", + NULL, + }; + bool cdrom, usb; typestr = udev_device_get_devtype(dev); if (!typestr) { @@ -94,12 +121,16 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, node = udev_device_get_devnode(dev); path = udev_device_get_devpath(dev); - if (path && (strstr(path, "virtual/block/loop") - || strstr(path, "virtual/block/ram"))) { + if (path && strstr(path, "virtual/block/loop")) { pb_log("SKIP: %s: ignored (path=%s)\n", name, path); return 0; } + if (path && strstr(path, "virtual/block/ram")) { + device_handler_add_ramdisk(udev->handler, node); + return 0; + } + cdrom = node && !!udev_device_get_property_value(dev, "ID_CDROM"); if (cdrom) { /* CDROMs require a little initialisation, to get @@ -111,12 +142,33 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, } } + /* Ignore any device mapper devices that aren't logical volumes */ + devname = udev_device_get_property_value(dev, "DM_NAME"); + if (devname && ! udev_device_get_property_value(dev, "DM_LV_NAME")) { + pb_debug("SKIP: dm-device %s\n", devname); + return 0; + } + type = udev_device_get_property_value(dev, "ID_FS_TYPE"); if (!type) { pb_log("SKIP: %s: no ID_FS_TYPE property\n", name); return 0; } + while (ignored_types[i]) { + if (!strncmp(type, ignored_types[i], strlen(ignored_types[i]))) { + pb_log("SKIP: %s: ignore '%s' filesystem\n", name, type); + return 0; + } + i++; + } + + /* Search for LVM logical volumes if we see an LVM member */ + if (strncmp(type, "LVM2_member", strlen("LVM2_member")) == 0) { + lvm_vg_search(udev->handler); + return 0; + } + /* We may see multipath devices; they'll have the same uuid as an * existing device, so only parse the first. */ uuid = udev_device_get_property_value(dev, "ID_FS_UUID"); @@ -129,24 +181,118 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, } } - ddev = discover_device_create(udev->handler, name); + /* Use DM_NAME for logical volumes, or the device name otherwise */ + ddev = discover_device_create(udev->handler, uuid, devname ?: name); + + if (devname) { + /* + * For logical volumes udev_device_get_devnode() returns a path + * of the form "/dev/dm-xx". These nodes names are not + * persistent and are opaque to the user. Instead use the more + * recognisable "/dev/mapper/lv-name" node if it is available. + */ + devlinks = talloc_strdup(ddev, + udev_device_get_property_value(dev, "DEVLINKS")); + link = devlinks ? strtok_r(devlinks, " ", &saveptr) : NULL; + while (link) { + if (strncmp(link, "/dev/mapper/", + strlen("/dev/mapper/")) == 0) { + node = link; + break; + } + link = strtok_r(NULL, " ", &saveptr); + } + } ddev->device_path = talloc_strdup(ddev, node); + talloc_free(devlinks); if (uuid) ddev->uuid = talloc_strdup(ddev, uuid); prop = udev_device_get_property_value(dev, "ID_FS_LABEL"); if (prop) ddev->label = talloc_strdup(ddev, prop); - ddev->device->type = cdrom ? DEVICE_TYPE_OPTICAL : DEVICE_TYPE_DISK; + + usb = !!udev_device_get_property_value(dev, "ID_USB_DRIVER"); + if (cdrom) + ddev->device->type = DEVICE_TYPE_OPTICAL; + else + ddev->device->type = usb ? DEVICE_TYPE_USB : DEVICE_TYPE_DISK; udev_setup_device_params(dev, ddev); + /* Create a snapshot for all disk devices */ + if ((ddev->device->type == DEVICE_TYPE_DISK || + ddev->device->type == DEVICE_TYPE_USB)) + devmapper_init_snapshot(udev->handler, ddev); + device_handler_discover(udev->handler, ddev); return 0; } +/* + * Mark valid interfaces as 'ready'. + * The udev_enumerate_add_match_is_initialized() filter in udev_enumerate() + * ensures that any device we see is properly initialized by udev (eg. interface + * names); here we check that the properties are sane and mark the interface + * as ready for configuration in discover/network. + */ +static int udev_check_interface_ready(struct device_handler *handler, + struct udev_device *dev) +{ + const char *name, *ifindex, *interface, *mac_name; + uint8_t *mac; + char byte[3]; + unsigned int i, j; + + + name = udev_device_get_sysname(dev); + if (!name) { + pb_debug("udev_device_get_sysname failed\n"); + return -1; + } + + ifindex = udev_device_get_property_value(dev, "IFINDEX"); + interface = udev_device_get_property_value(dev, "INTERFACE"); + mac_name = udev_device_get_property_value(dev, "ID_NET_NAME_MAC"); + + /* Physical interfaces should have all of these properties */ + if (!ifindex || !interface || !mac_name) { + pb_debug("%s: interface %s missing properties\n", + __func__, name); + return -1; + } + + /* ID_NET_NAME_MAC format is enxMACADDR */ + if (strlen(mac_name) < 15) { + pb_debug("%s: Unexpected MAC format: %s\n", + __func__, mac_name); + return -1; + } + + mac = talloc_array(handler, uint8_t, HWADDR_SIZE); + if (!mac) + return -1; + + /* + * ID_NET_NAME_MAC is not a conventionally formatted MAC + * string - convert it before passing it to network.c + */ + byte[2] = '\0'; + for (i = strlen("enx"), j = 0; + i < strlen(mac_name) && j < HWADDR_SIZE; i += 2) { + memcpy(byte, &mac_name[i], 2); + mac[j++] = strtoul(byte, NULL, 16); + } + + network_mark_interface_ready(handler, + atoi(ifindex), interface, mac, HWADDR_SIZE); + + talloc_free(mac); + return 0; +} + static int udev_handle_dev_add(struct pb_udev *udev, struct udev_device *dev) { const char *subsys; @@ -164,6 +310,10 @@ static int udev_handle_dev_add(struct pb_udev *udev, struct udev_device *dev) return -1; } + /* If we see a net device, check if it is ready to be used */ + if (!strncmp(subsys, "net", strlen("net"))) + return udev_check_interface_ready(udev->handler, dev); + if (device_lookup_by_id(udev->handler, name)) { pb_debug("device %s is already present?\n", name); return -1; @@ -205,13 +355,12 @@ static bool udev_handle_cdrom_events(struct pb_udev *udev, struct udev_device *dev, struct discover_device *ddev) { const char *node; + bool eject = false; node = udev_device_get_devnode(dev); /* handle CDROM eject requests */ if (udev_device_get_property_value(dev, "DISK_EJECT_REQUEST")) { - bool eject = false; - pb_debug("udev: eject request\n"); /* If the device is mounted, cdrom_id's own eject request may @@ -220,7 +369,6 @@ static bool udev_handle_cdrom_events(struct pb_udev *udev, if (ddev) { eject = ddev->mounted; udev_handle_dev_remove(udev, dev); - return false; } if (eject) @@ -243,10 +391,16 @@ static bool udev_handle_cdrom_events(struct pb_udev *udev, static int udev_handle_dev_change(struct pb_udev *udev, struct udev_device *dev) { struct discover_device *ddev; + const char *subsys; const char *name; int rc = 0; name = udev_device_get_sysname(dev); + subsys = udev_device_get_subsystem(dev); + + /* If we see a net device, check if it is ready to be used */ + if (!strncmp(subsys, "net", strlen("net"))) + return udev_check_interface_ready(udev->handler, dev); ddev = device_lookup_by_id(udev->handler, name); @@ -311,6 +465,12 @@ static int udev_enumerate(struct udev *udev) goto fail; } + result = udev_enumerate_add_match_subsystem(enumerate, "net"); + if (result) { + pb_log("udev_enumerate_add_match_subsystem failed\n"); + goto fail; + } + result = udev_enumerate_add_match_is_initialized(enumerate); if (result) { pb_log("udev_enumerate_add_match_is_initialised failed\n"); @@ -368,6 +528,14 @@ static int udev_setup_monitor(struct udev *udev, struct udev_monitor **monitor) goto out_err; } + result = udev_monitor_filter_add_match_subsystem_devtype(m, "net", + NULL); + + if (result) { + pb_log("udev_monitor_filter_add_match_subsystem_devtype failed\n"); + goto out_err; + } + result = udev_monitor_enable_receiving(m); if (result) { @@ -411,6 +579,7 @@ static int udev_process(void *arg) return 0; } +#ifdef UDEV_LOGGING static void udev_log_fn(struct udev __attribute__((unused)) *udev, int __attribute__((unused)) priority, const char *file, int line, const char *fn, const char *format, va_list args) @@ -418,6 +587,7 @@ static void udev_log_fn(struct udev __attribute__((unused)) *udev, pb_log("libudev: %s %s:%d: ", fn, file, line); vfprintf(pb_log_get_stream(), format, args); } +#endif struct pb_udev *udev_init(struct device_handler *handler, struct waitset *waitset) @@ -438,7 +608,9 @@ struct pb_udev *udev_init(struct device_handler *handler, udev_set_userdata(udev->udev, udev); +#ifdef UDEV_LOGGING udev_set_log_fn(udev->udev, udev_log_fn); +#endif result = udev_setup_monitor(udev->udev, &udev->monitor); if (result)