-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
#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,
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(d->meta.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(d->meta.manager->devices_by_sysfs, d->sysfs, first->sysfs, first);
+ else
+ hashmap_remove(d->meta.manager->devices_by_sysfs, d->sysfs);
- d->meta.following = NULL;
+ free(d->sysfs);
+ d->sysfs = NULL;
}
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) {
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) {
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)))
if ((r = device_add_escaped_name(u, path)) < 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;
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"))) {
goto fail;
}
}
-
- u->meta.following = NULL;
- } else
- device_find_escape_name(m, sysfs, &u->meta.following);
+ }
unit_add_to_dbus_queue(u);
return 0;
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);
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);
}
return 0;
}
+static Unit *device_following(Unit *u) {
+ Device *d = DEVICE(u);
+ Device *other, *first = NULL;
+
+ assert(d);
+
+ 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 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);
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;
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;
}
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;
const UnitVTable device_vtable = {
.suffix = ".device",
- .no_requires = true,
.no_instances = true,
- .no_snapshots = true,
- .no_isolate = true,
- .no_alias = true,
.init = device_init,
.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