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=526e7143785b8d684e2b53faec475dcbc6459f80;hb=fb0864e7b9c6d26269ccea6ec5c0fd921c029781;hpb=8fe914ec81d9f57bcc083036f528b00119ed2e3b diff --git a/src/device.c b/src/device.c index 526e71437..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, @@ -40,36 +41,38 @@ static void device_unset_sysfs(Device *d) { assert(d); - if (d->sysfs) { - /* 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); - LIST_REMOVE(Device, same_sysfs, first, d); + if (!d->sysfs) + return; - if (first) - hashmap_remove_and_replace(d->meta.manager->devices_by_sysfs, d->sysfs, first->sysfs, first); - else - hashmap_remove(d->meta.manager->devices_by_sysfs, d->sysfs); + /* Remove this unit from the chain of devices which share the + * same sysfs path. */ + first = hashmap_get(UNIT(d)->manager->devices_by_sysfs, d->sysfs); + LIST_REMOVE(Device, same_sysfs, first, d); - free(d->sysfs); - d->sysfs = NULL; - } + if (first) + hashmap_remove_and_replace(UNIT(d)->manager->devices_by_sysfs, d->sysfs, first->sysfs, first); + else + hashmap_remove(UNIT(d)->manager->devices_by_sysfs, d->sysfs); - d->meta.following = NULL; + free(d->sysfs); + d->sysfs = NULL; } 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) { @@ -89,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) { @@ -189,29 +192,36 @@ 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) { - Device *first; 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); + } else + delete = false; + + /* If this was created via some dependency and has not + * actually been seen yet ->sysfs will not be + * initialized. Hence initialize it if necessary. */ + + if (!DEVICE(u)->sysfs) { + Device *first; + if (!(DEVICE(u)->sysfs = strdup(sysfs))) { r = -ENOMEM; goto fail; } - unit_add_to_load_queue(u); - if (!m->devices_by_sysfs) if (!(m->devices_by_sysfs = hashmap_new(string_hash_func, string_compare_func))) { r = -ENOMEM; @@ -223,9 +233,7 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p if ((r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first)) < 0) goto fail; - - } else - delete = false; + } if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) || (model = udev_device_get_property_value(dev, "ID_MODEL"))) { @@ -268,10 +276,7 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p goto fail; } } - - u->meta.following = NULL; - } else - device_find_escape_name(m, sysfs, &u->meta.following); + } unit_add_to_dbus_queue(u); return 0; @@ -305,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); @@ -313,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); } @@ -365,6 +383,63 @@ static int device_process_removed_device(Manager *m, struct udev_device *dev) { return 0; } +static Unit *device_following(Unit *u) { + Device *d = DEVICE(u); + Device *other, *first = NULL; + + assert(d); + + 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(UNIT(other)->id, "sys-")) + return UNIT(other); + + for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) { + if (startswith(UNIT(other)->id, "sys-")) + return UNIT(other); + + first = other; + } + + 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); @@ -399,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; @@ -452,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; } @@ -467,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; @@ -492,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, @@ -510,7 +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