X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fcore%2Fdevice.c;h=4ff7c37238a566b641e0ae87bb9f300dc6a156f7;hp=0b01718ad4bc0ada8f79aa56f51b201319ba6c89;hb=9670d583d381d4c2c7f4d80de63bee7ad54fef44;hpb=f274ece0f76b5709408821e317e87aef76123db6 diff --git a/src/core/device.c b/src/core/device.c index 0b01718ad..4ff7c3723 100644 --- a/src/core/device.c +++ b/src/core/device.c @@ -23,21 +23,26 @@ #include #include -#include "unit.h" -#include "device.h" #include "strv.h" #include "log.h" #include "unit-name.h" #include "dbus-device.h" #include "def.h" #include "path-util.h" +#include "udev-util.h" +#include "unit.h" +#include "swap.h" +#include "device.h" static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = { [DEVICE_DEAD] = UNIT_INACTIVE, [DEVICE_PLUGGED] = UNIT_ACTIVE }; +static int device_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata); + static void device_unset_sysfs(Device *d) { + Hashmap *devices; Device *first; assert(d); @@ -47,13 +52,14 @@ static void device_unset_sysfs(Device *d) { /* 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); + devices = UNIT(d)->manager->devices_by_sysfs; + first = hashmap_get(devices, d->sysfs); + LIST_REMOVE(same_sysfs, first, d); if (first) - hashmap_remove_and_replace(UNIT(d)->manager->devices_by_sysfs, d->sysfs, first->sysfs, first); + hashmap_remove_and_replace(devices, d->sysfs, first->sysfs, first); else - hashmap_remove(UNIT(d)->manager->devices_by_sysfs, d->sysfs); + hashmap_remove(devices, d->sysfs); free(d->sysfs); d->sysfs = NULL; @@ -70,10 +76,10 @@ static void device_init(Unit *u) { * indefinitely for plugged in devices, something which cannot * happen for the other units since their operations time out * anyway. */ - UNIT(d)->job_timeout = DEFAULT_TIMEOUT_USEC; + u->job_timeout = u->manager->default_timeout_start_usec; - UNIT(d)->ignore_on_isolate = true; - UNIT(d)->ignore_on_snapshot = true; + u->ignore_on_isolate = true; + u->ignore_on_snapshot = true; } static void device_done(Unit *u) { @@ -124,20 +130,20 @@ static void device_dump(Unit *u, FILE *f, const char *prefix) { prefix, strna(d->sysfs)); } -static UnitActiveState device_active_state(Unit *u) { +_pure_ static UnitActiveState device_active_state(Unit *u) { assert(u); return state_translation_table[DEVICE(u)->state]; } -static const char *device_sub_state_to_string(Unit *u) { +_pure_ static const char *device_sub_state_to_string(Unit *u) { assert(u); return device_state_to_string(DEVICE(u)->state); } static int device_add_escaped_name(Unit *u, const char *dn) { - char *e; + _cleanup_free_ char *e = NULL; int r; assert(u); @@ -149,8 +155,6 @@ static int device_add_escaped_name(Unit *u, const char *dn) { return -ENOMEM; r = unit_add_name(u, e); - free(e); - if (r < 0 && r != -EEXIST) return r; @@ -158,7 +162,7 @@ static int device_add_escaped_name(Unit *u, const char *dn) { } static int device_find_escape_name(Manager *m, const char *dn, Unit **_u) { - char *e; + _cleanup_free_ char *e = NULL; Unit *u; assert(m); @@ -171,8 +175,6 @@ static int device_find_escape_name(Manager *m, const char *dn, Unit **_u) { return -ENOMEM; u = manager_get_unit(m, e); - free(e); - if (u) { *_u = u; return 1; @@ -189,10 +191,12 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p assert(m); - if (!(sysfs = udev_device_get_syspath(dev))) - return -ENOMEM; + sysfs = udev_device_get_syspath(dev); + if (!sysfs) + return 0; - if ((r = device_find_escape_name(m, path, &u)) < 0) + r = device_find_escape_name(m, path, &u); + if (r < 0) return r; if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs)) @@ -203,7 +207,7 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p u = unit_new(m, sizeof(Device)); if (!u) - return -ENOMEM; + return log_oom(); r = device_add_escaped_name(u, path); if (r < 0) @@ -220,83 +224,66 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p if (!DEVICE(u)->sysfs) { Device *first; - if (!(DEVICE(u)->sysfs = strdup(sysfs))) { + DEVICE(u)->sysfs = strdup(sysfs); + if (!DEVICE(u)->sysfs) { r = -ENOMEM; goto fail; } - if (!m->devices_by_sysfs) - if (!(m->devices_by_sysfs = hashmap_new(string_hash_func, string_compare_func))) { - r = -ENOMEM; - goto fail; - } + r = hashmap_ensure_allocated(&m->devices_by_sysfs, string_hash_func, string_compare_func); + if (r < 0) + goto fail; first = hashmap_get(m->devices_by_sysfs, sysfs); - LIST_PREPEND(Device, same_sysfs, first, DEVICE(u)); + LIST_PREPEND(same_sysfs, first, DEVICE(u)); - if ((r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first)) < 0) + r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first); + if (r < 0) goto fail; } if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) || - (model = udev_device_get_property_value(dev, "ID_MODEL"))) { - if ((r = unit_set_description(u, model)) < 0) - goto fail; - } else - if ((r = unit_set_description(u, path)) < 0) - goto fail; + (model = udev_device_get_property_value(dev, "ID_MODEL"))) + r = unit_set_description(u, model); + else + r = unit_set_description(u, path); + if (r < 0) + goto fail; if (main) { + const char *wants; + /* The additional systemd udev properties we only * interpret for the main object */ - const char *wants, *alias; - - alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS"); - if (alias) { - char *state, *w; - size_t l; - - FOREACH_WORD_QUOTED(w, l, alias, state) { - char *e; - - e = strndup(w, l); - if (!e) { - r = -ENOMEM; - goto fail; - } - - if (!is_path(e)) { - log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, e); - free(e); - } else { - device_update_unit(m, dev, e, false); - free(e); - } - } - } - wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS"); + wants = udev_device_get_property_value(dev, m->running_as == SYSTEMD_USER ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS"); if (wants) { char *state, *w; size_t l; FOREACH_WORD_QUOTED(w, l, wants, state) { - char *e; + _cleanup_free_ char *n = NULL; + char e[l+1]; - e = strndup(w, l); - if (!e) { + memcpy(e, w, l); + e[l] = 0; + + n = unit_name_mangle(e); + if (!n) { r = -ENOMEM; goto fail; } - r = unit_add_dependency_by_name(u, UNIT_WANTS, e, NULL, true); - free(e); + r = unit_add_dependency_by_name(u, UNIT_WANTS, n, NULL, true); if (r < 0) goto fail; } } } + /* Note that this won't dispatch the load queue, the caller + * has to do that if needed and appropriate */ + unit_add_to_dbus_queue(u); return 0; @@ -309,20 +296,25 @@ fail: return r; } -static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) { - const char *sysfs, *dn; +static int device_process_new_device(Manager *m, struct udev_device *dev) { + const char *sysfs, *dn, *alias; struct udev_list_entry *item = NULL, *first = NULL; + int r; assert(m); - if (!(sysfs = udev_device_get_syspath(dev))) - return -ENOMEM; + sysfs = udev_device_get_syspath(dev); + if (!sysfs) + return 0; /* Add the main unit named after the sysfs path */ - device_update_unit(m, dev, sysfs, true); + r = device_update_unit(m, dev, sysfs, true); + if (r < 0) + return r; /* Add an additional unit for the device node */ - if ((dn = udev_device_get_devnode(dev))) + dn = udev_device_get_devnode(dev); + if (dn) device_update_unit(m, dev, dn, false); /* Add additional units for all symlinks */ @@ -353,34 +345,43 @@ static int device_process_new_device(Manager *m, struct udev_device *dev, bool u device_update_unit(m, dev, p, false); } - if (update_state) { - Device *d, *l; + /* Add additional units for all explicitly configured + * aliases */ + alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS"); + if (alias) { + char *state, *w; + size_t l; - manager_dispatch_load_queue(m); + FOREACH_WORD_QUOTED(w, l, alias, state) { + char e[l+1]; + + memcpy(e, w, l); + e[l] = 0; - l = hashmap_get(m->devices_by_sysfs, sysfs); - LIST_FOREACH(same_sysfs, d, l) - device_set_state(d, DEVICE_PLUGGED); + if (path_is_absolute(e)) + device_update_unit(m, dev, e, false); + else + log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs, e); + } } return 0; } -static int device_process_path(Manager *m, const char *path, bool update_state) { - int r; - struct udev_device *dev; +static void device_set_path_plugged(Manager *m, struct udev_device *dev) { + const char *sysfs; + Device *d, *l; assert(m); - assert(path); + assert(dev); - if (!(dev = udev_device_new_from_syspath(m->udev, path))) { - log_warning("Failed to get udev device object from udev for path %s.", path); - return -ENOMEM; - } + sysfs = udev_device_get_syspath(dev); + if (!sysfs) + return; - r = device_process_new_device(m, dev, update_state); - udev_device_unref(dev); - return r; + l = hashmap_get(m->devices_by_sysfs, sysfs); + LIST_FOREACH(same_sysfs, d, l) + device_set_state(d, DEVICE_PLUGGED); } static int device_process_removed_device(Manager *m, struct udev_device *dev) { @@ -390,7 +391,8 @@ static int device_process_removed_device(Manager *m, struct udev_device *dev) { assert(m); assert(dev); - if (!(sysfs = udev_device_get_syspath(dev))) + sysfs = udev_device_get_syspath(dev); + if (!sysfs) return -ENOMEM; /* Remove all units of this sysfs path */ @@ -402,6 +404,34 @@ static int device_process_removed_device(Manager *m, struct udev_device *dev) { return 0; } +static bool device_is_ready(struct udev_device *dev) { + const char *ready; + + assert(dev); + + ready = udev_device_get_property_value(dev, "SYSTEMD_READY"); + if (!ready) + return true; + + return parse_boolean(ready) != 0; +} + +static int device_process_new_path(Manager *m, const char *path) { + _cleanup_udev_device_unref_ struct udev_device *dev = NULL; + + assert(m); + assert(path); + + dev = udev_device_new_from_syspath(m->udev, path); + if (!dev) + return log_oom(); + + if (!device_is_ready(dev)) + return 0; + + return device_process_new_device(m, dev); +} + static Unit *device_following(Unit *u) { Device *d = DEVICE(u); Device *other, *first = NULL; @@ -426,69 +456,67 @@ 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; +static int device_following_set(Unit *u, Set **_set) { + Device *d = DEVICE(u), *other; + Set *set; int r; assert(d); - assert(_s); + assert(_set); - if (!d->same_sysfs_prev && !d->same_sysfs_next) { - *_s = NULL; + if (LIST_JUST_US(same_sysfs, d)) { + *_set = NULL; return 0; } - if (!(s = set_new(NULL, NULL))) + set = set_new(NULL, NULL); + if (!set) return -ENOMEM; - for (other = d->same_sysfs_next; other; other = other->same_sysfs_next) - if ((r = set_put(s, other)) < 0) + LIST_FOREACH_AFTER(same_sysfs, other, d) { + r = set_put(set, other); + if (r < 0) goto fail; + } - for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) - if ((r = set_put(s, other)) < 0) + LIST_FOREACH_BEFORE(same_sysfs, other, d) { + r = set_put(set, other); + if (r < 0) goto fail; + } - *_s = s; + *_set = set; return 1; fail: - set_free(s); + set_free(set); return r; } static void device_shutdown(Manager *m) { assert(m); + m->udev_event_source = sd_event_source_unref(m->udev_event_source); + if (m->udev_monitor) { udev_monitor_unref(m->udev_monitor); m->udev_monitor = NULL; } - if (m->udev) { - udev_unref(m->udev); - m->udev = NULL; - } - hashmap_free(m->devices_by_sysfs); m->devices_by_sysfs = NULL; } static int device_enumerate(Manager *m) { - struct epoll_event ev; - int r; - struct udev_enumerate *e = NULL; + _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL; struct udev_list_entry *item = NULL, *first = NULL; + int r; assert(m); - if (!m->udev) { - if (!(m->udev = udev_new())) - return -ENOMEM; - - if (!(m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev"))) { + if (!m->udev_monitor) { + m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev"); + if (!m->udev_monitor) { r = -ENOMEM; goto fail; } @@ -498,101 +526,99 @@ static int device_enumerate(Manager *m) { * 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; + r = udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd"); + if (r < 0) goto fail; - } - if (udev_monitor_enable_receiving(m->udev_monitor) < 0) { - r = -EIO; + r = udev_monitor_enable_receiving(m->udev_monitor); + if (r < 0) goto fail; - } - - m->udev_watch.type = WATCH_UDEV; - m->udev_watch.fd = udev_monitor_get_fd(m->udev_monitor); - - zero(ev); - ev.events = EPOLLIN; - ev.data.ptr = &m->udev_watch; - if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_watch.fd, &ev) < 0) - return -errno; + r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_monitor), EPOLLIN, device_dispatch_io, m, &m->udev_event_source); + if (r < 0) + goto fail; } - if (!(e = udev_enumerate_new(m->udev))) { + e = udev_enumerate_new(m->udev); + if (!e) { r = -ENOMEM; goto fail; } - if (udev_enumerate_add_match_tag(e, "systemd") < 0) { - r = -EIO; + + r = udev_enumerate_add_match_tag(e, "systemd"); + if (r < 0) goto fail; - } - if (udev_enumerate_scan_devices(e) < 0) { - r = -EIO; + r = udev_enumerate_scan_devices(e); + if (r < 0) goto fail; - } first = udev_enumerate_get_list_entry(e); udev_list_entry_foreach(item, first) - device_process_path(m, udev_list_entry_get_name(item), false); + device_process_new_path(m, udev_list_entry_get_name(item)); - udev_enumerate_unref(e); return 0; fail: - if (e) - udev_enumerate_unref(e); - device_shutdown(m); return r; } -void device_fd_event(Manager *m, int events) { - struct udev_device *dev; +static int device_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) { + _cleanup_udev_device_unref_ struct udev_device *dev = NULL; + Manager *m = userdata; + const char *action; int r; - const char *action, *ready; assert(m); - if (events != EPOLLIN) { + if (revents != 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 (!(revents & EPOLLIN)) + return 0; } - if (!(dev = udev_monitor_receive_device(m->udev_monitor))) { - /* - * libudev might filter-out devices which pass the bloom filter, - * so getting NULL here is not necessarily an error - */ - return; - } + /* + * libudev might filter-out devices which pass the bloom + * filter, so getting NULL here is not necessarily an error. + */ + dev = udev_monitor_receive_device(m->udev_monitor); + if (!dev) + return 0; - if (!(action = udev_device_get_action(dev))) { + action = udev_device_get_action(dev); + if (!action) { log_error("Failed to get udev action string."); - goto fail; + return 0; } - ready = udev_device_get_property_value(dev, "SYSTEMD_READY"); + if (streq(action, "remove") || !device_is_ready(dev)) { + r = device_process_removed_device(m, dev); + if (r < 0) + log_error("Failed to process device remove event: %s", strerror(-r)); + + r = swap_process_removed_device(m, dev); + if (r < 0) + log_error("Failed to process swap device remove event: %s", strerror(-r)); - 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; - } } else { - if ((r = device_process_new_device(m, dev, true)) < 0) { - log_error("Failed to process udev device event: %s", strerror(-r)); - goto fail; - } + r = device_process_new_device(m, dev); + if (r < 0) + log_error("Failed to process device new event: %s", strerror(-r)); + + r = swap_process_new_device(m, dev); + if (r < 0) + log_error("Failed to process swap device new event: %s", strerror(-r)); + + manager_dispatch_load_queue(m); + + device_set_path_plugged(m, dev); } -fail: - udev_device_unref(dev); + return 0; } static const char* const device_state_table[_DEVICE_STATE_MAX] = { @@ -612,9 +638,9 @@ const UnitVTable device_vtable = { .no_instances = true, .init = device_init, - - .load = unit_load_fragment_and_dropin_optional, .done = device_done, + .load = unit_load_fragment_and_dropin_optional, + .coldplug = device_coldplug, .dump = device_dump, @@ -623,8 +649,8 @@ const UnitVTable device_vtable = { .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, + .bus_changing_properties = bus_device_changing_properties, + .bus_vtable = bus_device_vtable, .following = device_following, .following_set = device_following_set,