X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fdevice.c;h=64b21903edd848f185f745bd5f58b94d44b23a09;hp=a196a982a02c153582938ac78f3881329d8786b8;hb=7a6000a68241d23c9f6f6bde47b2cfa9c18189da;hpb=ee6cb28869d94f25a79f2c7cd29f1574c590036c diff --git a/src/device.c b/src/device.c index a196a982a..64b21903e 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, @@ -65,10 +66,13 @@ static void device_init(Unit *u) { /* 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; + + d->meta.ignore_on_isolate = true; + d->meta.ignore_on_snapshot = true; } static void device_done(Unit *u) { @@ -92,7 +96,7 @@ static void device_set_state(Device *d, DeviceState state) { 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,11 +192,8 @@ 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; @@ -307,6 +308,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 +317,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); } @@ -391,6 +405,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 +472,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 +530,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 +556,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; @@ -519,11 +584,7 @@ DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState); const UnitVTable device_vtable = { .suffix = ".device", - .no_requires = true, .no_instances = true, - .no_snapshots = true, - .no_isolate = true, - .no_alias = true, .init = device_init, @@ -536,9 +597,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