X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fdevice.c;h=2cbb81aebdfb4dfb9e4e95242eb59b6215114bc1;hp=e67d0a6c2d71e1d2ec83db8e3fcdc854dd2e41e4;hb=f031e85fc0a11636445e0bf50493c705942dd03f;hpb=e99e38bbdcca3fe5956823bdb3d38544ccf93221 diff --git a/src/device.c b/src/device.c index e67d0a6c2..2cbb81aeb 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. @@ -32,18 +32,53 @@ static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = { [DEVICE_DEAD] = UNIT_INACTIVE, - [DEVICE_AVAILABLE] = UNIT_ACTIVE + [DEVICE_PLUGGED] = UNIT_ACTIVE }; -static void device_done(Unit *u) { - Device *d = DEVICE(u); +static void device_unset_sysfs(Device *d) { + Device *first; assert(d); + if (!d->sysfs) + return; + + /* 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 (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); + 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); + + /* 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 + * happen for the other units since their operations time out + * anyway. */ + d->meta.job_timeout = DEFAULT_TIMEOUT_USEC; +} + +static void device_done(Unit *u) { + Device *d = DEVICE(u); + + assert(d); + + device_unset_sysfs(d); +} + static void device_set_state(Device *d, DeviceState state) { DeviceState old_state; assert(d); @@ -53,7 +88,7 @@ static void device_set_state(Device *d, DeviceState state) { if (state != old_state) log_debug("%s changed %s -> %s", - UNIT(d)->meta.id, + d->meta.id, device_state_to_string(old_state), device_state_to_string(state)); @@ -67,7 +102,7 @@ static int device_coldplug(Unit *u) { assert(d->state == DEVICE_DEAD); if (d->sysfs) - device_set_state(d, DEVICE_AVAILABLE); + device_set_state(d, DEVICE_PLUGGED); return 0; } @@ -96,7 +131,7 @@ static const char *device_sub_state_to_string(Unit *u) { return device_state_to_string(DEVICE(u)->state); } -static int device_add_escaped_name(Unit *u, const char *dn, bool make_id) { +static int device_add_escaped_name(Unit *u, const char *dn) { char *e; int r; @@ -108,10 +143,6 @@ static int device_add_escaped_name(Unit *u, const char *dn, bool make_id) { return -ENOMEM; r = unit_add_name(u, e); - - if (r >= 0 && make_id) - unit_choose_id(u, e); - free(e); if (r < 0 && r != -EEXIST) @@ -143,74 +174,26 @@ static int device_find_escape_name(Manager *m, const char *dn, Unit **_u) { return 0; } -static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) { - const char *dn, *wants, *sysfs, *expose, *model, *alias; +static int device_update_unit(Manager *m, struct udev_device *dev, const char *path, bool main) { + const char *sysfs, *model; Unit *u = NULL; int r; - char *w, *state; - size_t l; bool delete; - struct udev_list_entry *item = NULL, *first = NULL; - int b; assert(m); if (!(sysfs = udev_device_get_syspath(dev))) return -ENOMEM; - if (!(expose = udev_device_get_property_value(dev, "SYSTEMD_EXPOSE"))) - return 0; - - if ((b = parse_boolean(expose)) < 0) { - log_error("Failed to parse SYSTEMD_EXPOSE udev property for device %s: %s", sysfs, expose); - return 0; - } - - if (!b) - return 0; - - /* Check whether this entry is even relevant for us. */ - dn = udev_device_get_devnode(dev); - wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS"); - alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS"); - - /* We allow exactly one alias to be configured a this time and - * it must be a path */ - - if (alias && !is_path(alias)) { - log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, alias); - alias = NULL; - } - - if ((r = device_find_escape_name(m, sysfs, &u)) < 0) + if ((r = device_find_escape_name(m, path, &u)) < 0) return r; - if (r == 0 && dn) - if ((r = device_find_escape_name(m, dn, &u)) < 0) - return r; - - if (r == 0) { - first = udev_device_get_devlinks_list_entry(dev); - udev_list_entry_foreach(item, first) { - if ((r = device_find_escape_name(m, udev_list_entry_get_name(item), &u)) < 0) - return r; - - if (r > 0) - break; - } - } - - if (r == 0 && alias) - if ((r = device_find_escape_name(m, alias, &u)) < 0) - return r; - - /* FIXME: this needs proper merging */ - - assert((r > 0) == !!u); - - /* If this is a different unit, then let's not merge things */ + /* If a different unit already claimed this name then let's do + * nothing. This can happen for example when two disks with + * the same label are plugged in, and which hence try to get + * conflicting symlinks in /dev/disk/by-label/xxxx */ if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs)) - u = NULL; + return -EEXIST; if (!u) { delete = true; @@ -218,75 +201,150 @@ static int device_process_new_device(Manager *m, struct udev_device *dev, bool u if (!(u = unit_new(m))) return -ENOMEM; - if ((r = device_add_escaped_name(u, sysfs, true)) < 0) + if ((r = device_add_escaped_name(u, path)) < 0) goto fail; unit_add_to_load_queue(u); } else delete = false; - if (!(DEVICE(u)->sysfs)) + /* 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; } - if (alias) - if ((r = device_add_escaped_name(u, alias, true)) < 0) - goto fail; + if (!m->devices_by_sysfs) + if (!(m->devices_by_sysfs = hashmap_new(string_hash_func, string_compare_func))) { + r = -ENOMEM; + goto fail; + } - if (dn) - if ((r = device_add_escaped_name(u, dn, true)) < 0) - goto fail; + first = hashmap_get(m->devices_by_sysfs, sysfs); + LIST_PREPEND(Device, same_sysfs, first, DEVICE(u)); - first = udev_device_get_devlinks_list_entry(dev); - udev_list_entry_foreach(item, first) - if ((r = device_add_escaped_name(u, udev_list_entry_get_name(item), false)) < 0) + if ((r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first)) < 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 (dn) { - if ((r = unit_set_description(u, dn)) < 0) - goto fail; } else - if ((r = unit_set_description(u, sysfs)) < 0) + if ((r = unit_set_description(u, path)) < 0) goto fail; - if (wants) { - FOREACH_WORD(w, l, wants, state) { - char *e; - - if (!(e = strndup(w, l))) { - r = -ENOMEM; - goto fail; + if (main) { + /* The additional systemd udev properties we only + * interpret for the main object */ + const char *wants, *alias; + + if ((alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS"))) { + if (!is_path(alias)) + log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, alias); + else { + if ((r = device_add_escaped_name(u, alias)) < 0) + goto fail; } + } - r = unit_add_dependency_by_name(u, UNIT_WANTS, NULL, e, true); - free(e); + if ((wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS"))) { + char *state, *w; + size_t l; - if (r < 0) - goto fail; - } - } + FOREACH_WORD_QUOTED(w, l, wants, state) { + char *e; - if (update_state) { - manager_dispatch_load_queue(u->meta.manager); - device_set_state(DEVICE(u), DEVICE_AVAILABLE); + if (!(e = strndup(w, l))) { + r = -ENOMEM; + goto fail; + } + + r = unit_add_dependency_by_name(u, UNIT_WANTS, e, NULL, true); + free(e); + + if (r < 0) + goto fail; + } + } } unit_add_to_dbus_queue(u); - return 0; fail: + log_warning("Failed to load device unit: %s", strerror(-r)); + if (delete && u) unit_free(u); + return r; } +static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) { + const char *sysfs, *dn; + struct udev_list_entry *item = NULL, *first = NULL; + + assert(m); + + if (!(sysfs = udev_device_get_syspath(dev))) + return -ENOMEM; + + /* Add the main unit named after the sysfs path */ + device_update_unit(m, dev, sysfs, true); + + /* Add an additional unit for the device node */ + if ((dn = udev_device_get_devnode(dev))) + device_update_unit(m, dev, dn, false); + + /* Add additional units for all symlinks */ + 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); + + if (path_startswith(p, "/dev/block/") || + 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); + } + + if (update_state) { + Device *d, *l; + + manager_dispatch_load_queue(m); + + l = hashmap_get(m->devices_by_sysfs, sysfs); + LIST_FOREACH(same_sysfs, d, l) + device_set_state(d, DEVICE_PLUGGED); + } + + return 0; +} + static int device_process_path(Manager *m, const char *path, bool update_state) { int r; struct udev_device *dev; @@ -306,8 +364,6 @@ static int device_process_path(Manager *m, const char *path, bool update_state) static int device_process_removed_device(Manager *m, struct udev_device *dev) { const char *sysfs; - char *e; - Unit *u; Device *d; assert(m); @@ -316,22 +372,37 @@ static int device_process_removed_device(Manager *m, struct udev_device *dev) { if (!(sysfs = udev_device_get_syspath(dev))) return -ENOMEM; - assert(sysfs[0] == '/'); - if (!(e = unit_name_from_path(sysfs, ".device"))) - return -ENOMEM; + /* Remove all units of this sysfs path */ + while ((d = hashmap_get(m->devices_by_sysfs, sysfs))) { + device_unset_sysfs(d); + device_set_state(d, DEVICE_DEAD); + } - u = manager_get_unit(m, e); - free(e); + return 0; +} - if (!u) - return 0; +static Unit *device_following(Unit *u) { + Device *d = DEVICE(u); + Device *other, *first = NULL; - d = DEVICE(u); - free(d->sysfs); - d->sysfs = NULL; + assert(d); - device_set_state(d, DEVICE_DEAD); - return 0; + if (startswith(u->meta.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-")) + return UNIT(other); + + for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) { + if (startswith(other->meta.id, "sys-")) + return UNIT(other); + + first = other; + } + + return UNIT(first); } static void device_shutdown(Manager *m) { @@ -346,6 +417,9 @@ static void device_shutdown(Manager *m) { udev_unref(m->udev); m->udev = NULL; } + + hashmap_free(m->devices_by_sysfs); + m->devices_by_sysfs = NULL; } static int device_enumerate(Manager *m) { @@ -365,6 +439,11 @@ static int device_enumerate(Manager *m) { goto fail; } + if (udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd") < 0) { + r = -ENOMEM; + goto fail; + } + if (udev_monitor_enable_receiving(m->udev_monitor) < 0) { r = -EIO; goto fail; @@ -385,6 +464,10 @@ static int device_enumerate(Manager *m) { r = -ENOMEM; goto fail; } + if (udev_enumerate_add_match_tag(e, "systemd") < 0) { + r = -EIO; + goto fail; + } if (udev_enumerate_scan_devices(e) < 0) { r = -EIO; @@ -442,7 +525,7 @@ fail: static const char* const device_state_table[_DEVICE_STATE_MAX] = { [DEVICE_DEAD] = "dead", - [DEVICE_AVAILABLE] = "available" + [DEVICE_PLUGGED] = "plugged" }; DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState); @@ -455,6 +538,8 @@ const UnitVTable device_vtable = { .no_snapshots = true, .no_isolate = true, + .init = device_init, + .load = unit_load_fragment_and_dropin_optional, .done = device_done, .coldplug = device_coldplug, @@ -464,7 +549,11 @@ 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, .enumerate = device_enumerate, .shutdown = device_shutdown