X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fdevice.c;h=0575379d800151ec002f93690442759b14c76a17;hp=a196a982a02c153582938ac78f3881329d8786b8;hb=fb0864e7b9c6d26269ccea6ec5c0fd921c029781;hpb=ee6cb28869d94f25a79f2c7cd29f1574c590036c diff --git a/src/device.c b/src/device.c index a196a982a..0575379d8 100644 --- a/src/device.c +++ b/src/device.c @@ -1,4 +1,4 @@ -/*-*- Mode: C; c-basic-offset: 8 -*-*/ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ /*** This file is part of systemd. @@ -29,6 +29,7 @@ #include "log.h" #include "unit-name.h" #include "dbus-device.h" +#include "def.h" static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = { [DEVICE_DEAD] = UNIT_INACTIVE, @@ -45,13 +46,13 @@ static void device_unset_sysfs(Device *d) { /* Remove this unit from the chain of devices which share the * same sysfs path. */ - first = hashmap_get(d->meta.manager->devices_by_sysfs, d->sysfs); + first = hashmap_get(UNIT(d)->manager->devices_by_sysfs, d->sysfs); LIST_REMOVE(Device, same_sysfs, first, d); if (first) - hashmap_remove_and_replace(d->meta.manager->devices_by_sysfs, d->sysfs, first->sysfs, first); + hashmap_remove_and_replace(UNIT(d)->manager->devices_by_sysfs, d->sysfs, first->sysfs, first); else - hashmap_remove(d->meta.manager->devices_by_sysfs, d->sysfs); + hashmap_remove(UNIT(d)->manager->devices_by_sysfs, d->sysfs); free(d->sysfs); d->sysfs = NULL; @@ -61,14 +62,17 @@ static void device_init(Unit *u) { Device *d = DEVICE(u); assert(d); - assert(d->meta.load_state == UNIT_STUB); + assert(UNIT(d)->load_state == UNIT_STUB); /* In contrast to all other unit types we timeout jobs waiting * for devices by default. This is because they otherwise wait - * indefinetely for plugged in devices, something which cannot + * indefinitely for plugged in devices, something which cannot * happen for the other units since their operations time out * anyway. */ - d->meta.job_timeout = DEFAULT_TIMEOUT_USEC; + UNIT(d)->job_timeout = DEFAULT_TIMEOUT_USEC; + + UNIT(d)->ignore_on_isolate = true; + UNIT(d)->ignore_on_snapshot = true; } static void device_done(Unit *u) { @@ -88,11 +92,11 @@ static void device_set_state(Device *d, DeviceState state) { if (state != old_state) log_debug("%s changed %s -> %s", - d->meta.id, + UNIT(d)->id, device_state_to_string(old_state), device_state_to_string(state)); - unit_notify(UNIT(d), state_translation_table[old_state], state_translation_table[state]); + unit_notify(UNIT(d), state_translation_table[old_state], state_translation_table[state], true); } static int device_coldplug(Unit *u) { @@ -188,19 +192,18 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p if ((r = device_find_escape_name(m, path, &u)) < 0) return r; - /* If this is a different unit, then let's not merge things */ - if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs)) { - log_error("Hmm, something's broken. Asked to create two devices with same name but different sysfs paths."); + if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs)) return -EEXIST; - } if (!u) { delete = true; - if (!(u = unit_new(m))) + u = unit_new(m, sizeof(Device)); + if (!u) return -ENOMEM; - if ((r = device_add_escaped_name(u, path)) < 0) + r = device_add_escaped_name(u, path); + if (r < 0) goto fail; unit_add_to_load_queue(u); @@ -307,6 +310,7 @@ static int device_process_new_device(Manager *m, struct udev_device *dev, bool u first = udev_device_get_devlinks_list_entry(dev); udev_list_entry_foreach(item, first) { const char *p; + struct stat st; /* Don't bother with the /dev/block links */ p = udev_list_entry_get_name(item); @@ -315,6 +319,18 @@ static int device_process_new_device(Manager *m, struct udev_device *dev, bool u path_startswith(p, "/dev/char/")) continue; + /* Verify that the symlink in the FS actually belongs + * to this device. This is useful to deal with + * conflicting devices, e.g. when two disks want the + * same /dev/disk/by-label/xxx link because they have + * the same label. We want to make sure that the same + * device that won the symlink wins in systemd, so we + * check the device node major/minor*/ + if (stat(p, &st) >= 0) + if ((!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode)) || + st.st_rdev != udev_device_get_devnum(dev)) + continue; + device_update_unit(m, dev, p, false); } @@ -373,16 +389,16 @@ static Unit *device_following(Unit *u) { assert(d); - if (startswith(u->meta.id, "sys-")) + if (startswith(u->id, "sys-")) return NULL; /* Make everybody follow the unit that's named after the sysfs path */ for (other = d->same_sysfs_next; other; other = other->same_sysfs_next) - if (startswith(other->meta.id, "sys-")) + if (startswith(UNIT(other)->id, "sys-")) return UNIT(other); for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) { - if (startswith(other->meta.id, "sys-")) + if (startswith(UNIT(other)->id, "sys-")) return UNIT(other); first = other; @@ -391,6 +407,39 @@ static Unit *device_following(Unit *u) { return UNIT(first); } +static int device_following_set(Unit *u, Set **_s) { + Device *d = DEVICE(u); + Device *other; + Set *s; + int r; + + assert(d); + assert(_s); + + if (!d->same_sysfs_prev && !d->same_sysfs_next) { + *_s = NULL; + return 0; + } + + if (!(s = set_new(NULL, NULL))) + return -ENOMEM; + + for (other = d->same_sysfs_next; other; other = other->same_sysfs_next) + if ((r = set_put(s, other)) < 0) + goto fail; + + for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) + if ((r = set_put(s, other)) < 0) + goto fail; + + *_s = s; + return 1; + +fail: + set_free(s); + return r; +} + static void device_shutdown(Manager *m) { assert(m); @@ -425,6 +474,11 @@ static int device_enumerate(Manager *m) { goto fail; } + /* This will fail if we are unprivileged, but that + * should not matter much, as user instances won't run + * during boot. */ + udev_monitor_set_receive_buffer_size(m->udev_monitor, 128*1024*1024); + if (udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd") < 0) { r = -ENOMEM; goto fail; @@ -478,13 +532,24 @@ fail: void device_fd_event(Manager *m, int events) { struct udev_device *dev; int r; - const char *action; + const char *action, *ready; assert(m); - assert(events == EPOLLIN); + + if (events != EPOLLIN) { + static RATELIMIT_DEFINE(limit, 10*USEC_PER_SEC, 5); + + if (!ratelimit_test(&limit)) + log_error("Failed to get udev event: %m"); + if (!(events & EPOLLIN)) + return; + } if (!(dev = udev_monitor_receive_device(m->udev_monitor))) { - log_error("Failed to receive device."); + /* + * libudev might filter-out devices which pass the bloom filter, + * so getting NULL here is not necessarily an error + */ return; } @@ -493,7 +558,9 @@ void device_fd_event(Manager *m, int events) { goto fail; } - if (streq(action, "remove")) { + ready = udev_device_get_property_value(dev, "SYSTEMD_READY"); + + if (streq(action, "remove") || (ready && parse_boolean(ready) == 0)) { if ((r = device_process_removed_device(m, dev)) < 0) { log_error("Failed to process udev device event: %s", strerror(-r)); goto fail; @@ -518,12 +585,13 @@ DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState); const UnitVTable device_vtable = { .suffix = ".device", + .object_size = sizeof(Device), + .sections = + "Unit\0" + "Device\0" + "Install\0", - .no_requires = true, .no_instances = true, - .no_snapshots = true, - .no_isolate = true, - .no_alias = true, .init = device_init, @@ -536,9 +604,12 @@ const UnitVTable device_vtable = { .active_state = device_active_state, .sub_state_to_string = device_sub_state_to_string, + .bus_interface = "org.freedesktop.systemd1.Device", .bus_message_handler = bus_device_message_handler, + .bus_invalidating_properties = bus_device_invalidating_properties, .following = device_following, + .following_set = device_following_set, .enumerate = device_enumerate, .shutdown = device_shutdown