X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fudev.c;h=45a8b56b05dd3847b9face8e6dec0f401e3081f6;hp=6cc718ea4614f9da6e7110fd9901144c5f37fb7c;hb=9a5c9c9331f0c0c539cad423a4654015598b0d9d;hpb=5acb43464206348b7cced9508852fdd2989aea58 diff --git a/discover/udev.c b/discover/udev.c index 6cc718e..45a8b56 100644 --- a/discover/udev.c +++ b/discover/udev.c @@ -19,6 +19,7 @@ #include #include #include +#include #include "event.h" #include "udev.h" @@ -26,6 +27,7 @@ #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 @@ -70,9 +72,26 @@ 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("%s: Failed to execute vgscan\n", __func__); + + if (process_run_simple(handler, pb_system_apps.vgchange, "-ay", "-qq", + NULL)) + pb_log("%s: Failed to execute vgchange\n", __func__); +} + 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; @@ -85,7 +104,6 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, const char *ignored_types[] = { "linux_raid_member", "swap", - "LVM2_member", NULL, }; bool cdrom, usb; @@ -124,10 +142,9 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, } } - /* If our environment's udev can recognise them explictly skip any - * device mapper devices we encounter */ + /* Ignore any device mapper devices that aren't logical volumes */ devname = udev_device_get_property_value(dev, "DM_NAME"); - if (devname) { + if (devname && ! udev_device_get_property_value(dev, "DM_LV_NAME")) { pb_debug("SKIP: dm-device %s\n", devname); return 0; } @@ -146,6 +163,12 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, 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"); @@ -158,9 +181,31 @@ 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); @@ -176,10 +221,9 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, udev_setup_device_params(dev, ddev); - /* Create a snapshot for all disks, unless it is an assembled RAID array */ + /* Create a snapshot for all disk devices */ if ((ddev->device->type == DEVICE_TYPE_DISK || - ddev->device->type == DEVICE_TYPE_USB) && - !udev_device_get_property_value(dev, "MD_LEVEL")) + ddev->device->type == DEVICE_TYPE_USB)) devmapper_init_snapshot(udev->handler, ddev); device_handler_discover(udev->handler, ddev); @@ -187,6 +231,69 @@ static int udev_handle_block_add(struct pb_udev *udev, struct udev_device *dev, 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, *name_path, *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; + } + + name_path = udev_device_get_property_value(dev, "ID_NET_NAME_PATH"); + 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 (!name_path || !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; @@ -204,6 +311,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; @@ -245,13 +356,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 @@ -260,7 +370,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) @@ -283,10 +392,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); @@ -351,6 +466,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"); @@ -408,6 +529,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) { @@ -451,6 +580,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) @@ -458,6 +588,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) @@ -478,7 +609,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)