#include <sys/epoll.h>
#include <libudev.h>
-#include "unit.h"
-#include "device.h"
#include "strv.h"
#include "log.h"
#include "unit-name.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,
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);
/* 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);
+ 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;
* indefinitely for plugged in devices, something which cannot
* happen for the other units since their operations time out
* anyway. */
- UNIT(d)->job_timeout = u->manager->default_timeout_start_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) {
d->state = state;
if (state != old_state)
- log_debug_unit(UNIT(d)->id,
+ log_unit_debug(UNIT(d)->id,
"%s changed %s -> %s", UNIT(d)->id,
device_state_to_string(old_state),
device_state_to_string(state));
return 0;
}
+static int device_make_description(Unit *u, struct udev_device *dev, const char *path) {
+ const char *model;
+
+ assert(u);
+ assert(dev);
+ assert(path);
+
+ model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE");
+ if (!model)
+ model = udev_device_get_property_value(dev, "ID_MODEL");
+
+ if (model) {
+ const char *label;
+
+ /* Try to concatenate the device model string with a label, if there is one */
+ label = udev_device_get_property_value(dev, "ID_FS_LABEL");
+ if (!label)
+ label = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME");
+ if (!label)
+ label = udev_device_get_property_value(dev, "ID_PART_ENTRY_NUMBER");
+
+ if (label) {
+ _cleanup_free_ char *j;
+
+ j = strjoin(model, " ", label, NULL);
+ if (j)
+ return unit_set_description(u, j);
+ }
+
+ return unit_set_description(u, model);
+ }
+
+ return unit_set_description(u, path);
+}
+
+static int device_add_udev_wants(Unit *u, struct udev_device *dev) {
+ const char *wants;
+ const char *word, *state;
+ size_t l;
+ int r;
+ const char *property;
+
+ assert(u);
+ assert(dev);
+
+ property = u->manager->running_as == SYSTEMD_USER ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
+ wants = udev_device_get_property_value(dev, property);
+ if (!wants)
+ return 0;
+
+ FOREACH_WORD_QUOTED(word, l, wants, state) {
+ _cleanup_free_ char *n = NULL;
+ char e[l+1];
+
+ memcpy(e, word, l);
+ e[l] = 0;
+
+ n = unit_name_mangle(e, MANGLE_NOGLOB);
+ if (!n)
+ return -ENOMEM;
+
+ r = unit_add_dependency_by_name(u, UNIT_WANTS, n, NULL, true);
+ if (r < 0)
+ return r;
+ }
+ if (!isempty(state))
+ log_unit_warning(u->id, "Property %s on %s has trailing garbage, ignoring.",
+ property, strna(udev_device_get_syspath(dev)));
+
+ return 0;
+}
+
static int device_update_unit(Manager *m, struct udev_device *dev, const char *path, bool main) {
- const char *sysfs, *model;
+ const char *sysfs;
Unit *u = NULL;
- int r;
bool delete;
+ int r;
assert(m);
+ assert(dev);
+ assert(path);
sysfs = udev_device_get_syspath(dev);
if (!sysfs)
- return -ENOMEM;
+ return 0;
r = device_find_escape_name(m, path, &u);
if (r < 0)
u = unit_new(m, sizeof(Device));
if (!u)
- return -ENOMEM;
+ return log_oom();
r = device_add_escaped_name(u, path);
if (r < 0)
goto fail;
}
- r = hashmap_ensure_allocated(&m->devices_by_sysfs, string_hash_func, string_compare_func);
+ r = hashmap_ensure_allocated(&m->devices_by_sysfs, &string_hash_ops);
if (r < 0)
goto fail;
goto fail;
}
- if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) ||
- (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;
+ device_make_description(u, dev, path);
if (main) {
/* 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) {
- _cleanup_free_ char *e;
-
- e = strndup(w, l);
- if (!e) {
- r = -ENOMEM;
- goto fail;
- }
-
- if (is_path(e))
- device_update_unit(m, dev, e, false);
- else
- log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, e);
- }
- }
- 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) {
- _cleanup_free_ char *e, *n = NULL;
-
- e = strndup(w, l);
- if (!e) {
- r = -ENOMEM;
- goto fail;
- }
-
- n = unit_name_mangle(e);
- if (!n) {
- r = -ENOMEM;
- goto fail;
- }
-
- r = unit_add_dependency_by_name(u, UNIT_WANTS, n, NULL, true);
- if (r < 0)
- goto fail;
- }
- }
+ r = device_add_udev_wants(u, dev);
+ 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;
fail:
- log_warning("Failed to load device unit: %s", strerror(-r));
+ log_warning_errno(r, "Failed to load device unit: %m");
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;
+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;
sysfs = udev_device_get_syspath(dev);
if (!sysfs)
- return -ENOMEM;
+ return 0;
/* Add the main unit named after the sysfs path */
r = device_update_unit(m, dev, sysfs, true);
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 */
* 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*/
+ * 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))
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) {
+ const char *word, *state;
+ size_t l;
- manager_dispatch_load_queue(m);
+ FOREACH_WORD_QUOTED(word, l, alias, state) {
+ char e[l+1];
- l = hashmap_get(m->devices_by_sysfs, sysfs);
- LIST_FOREACH(same_sysfs, d, l)
- device_set_state(d, DEVICE_PLUGGED);
+ memcpy(e, word, l);
+ e[l] = 0;
+
+ 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);
+ }
+ if (!isempty(state))
+ log_warning("SYSTEMD_ALIAS for %s has trailing garbage, ignoring.", sysfs);
}
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);
- dev = udev_device_new_from_syspath(m->udev, path);
- if (!dev) {
- 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) {
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 */
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;
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);
+ 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;
}
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;
}
assert(m);
- if (!m->udev) {
- m->udev = udev_new();
- if (!m->udev)
- return -ENOMEM;
-
+ if (!m->udev_monitor) {
m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
if (!m->udev_monitor) {
r = -ENOMEM;
if (r < 0)
goto fail;
- r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_monitor), EPOLLIN, device_dispatch_io, m, &m->udev_event_source);
+ r = sd_event_add_io(m->event, &m->udev_event_source, udev_monitor_get_fd(m->udev_monitor), EPOLLIN, device_dispatch_io, m);
if (r < 0)
goto fail;
}
if (r < 0)
goto fail;
+ r = udev_enumerate_add_match_is_initialized(e);
+ if (r < 0)
+ goto fail;
+
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));
return 0;
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;
- const char *action, *ready;
Manager *m = userdata;
+ const char *action;
int r;
assert(m);
static RATELIMIT_DEFINE(limit, 10*USEC_PER_SEC, 5);
if (!ratelimit_test(&limit))
- log_error("Failed to get udev event: %m");
+ log_error_errno(errno, "Failed to get udev event: %m");
if (!(revents & EPOLLIN))
return 0;
}
return 0;
}
- ready = udev_device_get_property_value(dev, "SYSTEMD_READY");
-
- if (streq(action, "remove") || (ready && parse_boolean(ready) == 0)) {
+ if (streq(action, "remove") || !device_is_ready(dev)) {
r = device_process_removed_device(m, dev);
if (r < 0)
- log_error("Failed to process udev device event: %s", strerror(-r));
+ log_error_errno(r, "Failed to process device remove event: %m");
+
+ r = swap_process_removed_device(m, dev);
+ if (r < 0)
+ log_error_errno(r, "Failed to process swap device remove event: %m");
+
} else {
- r = device_process_new_device(m, dev, true);
+ r = device_process_new_device(m, dev);
if (r < 0)
- log_error("Failed to process udev device event: %s", strerror(-r));
+ log_error_errno(r, "Failed to process device new event: %m");
+
+ r = swap_process_new_device(m, dev);
+ if (r < 0)
+ log_error_errno(r, "Failed to process swap device new event: %m");
+
+ manager_dispatch_load_queue(m);
+
+ device_set_path_plugged(m, dev);
}
return 0;
}
+static bool device_supported(Manager *m) {
+ static int read_only = -1;
+ assert(m);
+
+ /* If /sys is read-only we don't support device units, and any
+ * attempts to start one should fail immediately. */
+
+ if (read_only < 0)
+ read_only = path_is_read_only_fs("/sys");
+
+ return read_only <= 0;
+}
+
static const char* const device_state_table[_DEVICE_STATE_MAX] = {
[DEVICE_DEAD] = "dead",
[DEVICE_PLUGGED] = "plugged"
.sub_state_to_string = device_sub_state_to_string,
.bus_interface = "org.freedesktop.systemd1.Device",
- .bus_changing_properties = bus_device_changing_properties,
.bus_vtable = bus_device_vtable,
.following = device_following,
.enumerate = device_enumerate,
.shutdown = device_shutdown,
+ .supported = device_supported,
.status_message_formats = {
.starting_stopping = {
~ianmdlvl / elogind.git / blobdiff