/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see .
***/
#include
#include
#include "libudev.h"
#include "alloc-util.h"
#include "dbus-device.h"
#include "device.h"
#include "log.h"
#include "parse-util.h"
#include "path-util.h"
#include "stat-util.h"
#include "string-util.h"
#include "swap.h"
#include "udev-util.h"
#include "unit-name.h"
#include "unit.h"
static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = {
[DEVICE_DEAD] = UNIT_INACTIVE,
[DEVICE_TENTATIVE] = UNIT_ACTIVATING,
[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);
if (!d->sysfs)
return;
/* Remove this unit from the chain of devices which share the
* same sysfs path. */
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(devices, d->sysfs, first->sysfs, first);
else
hashmap_remove(devices, d->sysfs);
d->sysfs = mfree(d->sysfs);
}
static int device_set_sysfs(Device *d, const char *sysfs) {
Device *first;
char *copy;
int r;
assert(d);
if (streq_ptr(d->sysfs, sysfs))
return 0;
r = hashmap_ensure_allocated(&UNIT(d)->manager->devices_by_sysfs, &string_hash_ops);
if (r < 0)
return r;
copy = strdup(sysfs);
if (!copy)
return -ENOMEM;
device_unset_sysfs(d);
first = hashmap_get(UNIT(d)->manager->devices_by_sysfs, sysfs);
LIST_PREPEND(same_sysfs, first, d);
r = hashmap_replace(UNIT(d)->manager->devices_by_sysfs, copy, first);
if (r < 0) {
LIST_REMOVE(same_sysfs, first, d);
free(copy);
return r;
}
d->sysfs = copy;
return 0;
}
static void device_init(Unit *u) {
Device *d = DEVICE(u);
assert(d);
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
* indefinitely for plugged in devices, something which cannot
* happen for the other units since their operations time out
* anyway. */
u->job_timeout = u->manager->default_timeout_start_usec;
u->ignore_on_isolate = true;
}
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);
old_state = d->state;
d->state = state;
if (state != old_state)
log_unit_debug(UNIT(d), "Changed %s -> %s", device_state_to_string(old_state), device_state_to_string(state));
unit_notify(UNIT(d), state_translation_table[old_state], state_translation_table[state], true);
}
static int device_coldplug(Unit *u) {
Device *d = DEVICE(u);
assert(d);
assert(d->state == DEVICE_DEAD);
if (d->found & DEVICE_FOUND_UDEV)
/* If udev says the device is around, it's around */
device_set_state(d, DEVICE_PLUGGED);
else if (d->found != DEVICE_NOT_FOUND && d->deserialized_state != DEVICE_PLUGGED)
/* If a device is found in /proc/self/mountinfo or
* /proc/swaps, and was not yet announced via udev,
* it's "tentatively" around. */
device_set_state(d, DEVICE_TENTATIVE);
return 0;
}
static int device_serialize(Unit *u, FILE *f, FDSet *fds) {
Device *d = DEVICE(u);
assert(u);
assert(f);
assert(fds);
unit_serialize_item(u, f, "state", device_state_to_string(d->state));
return 0;
}
static int device_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
Device *d = DEVICE(u);
assert(u);
assert(key);
assert(value);
assert(fds);
if (streq(key, "state")) {
DeviceState state;
state = device_state_from_string(value);
if (state < 0)
log_unit_debug(u, "Failed to parse state value: %s", value);
else
d->deserialized_state = state;
} else
log_unit_debug(u, "Unknown serialization key: %s", key);
return 0;
}
static void device_dump(Unit *u, FILE *f, const char *prefix) {
Device *d = DEVICE(u);
assert(d);
fprintf(f,
"%sDevice State: %s\n"
"%sSysfs Path: %s\n",
prefix, device_state_to_string(d->state),
prefix, strna(d->sysfs));
}
_pure_ static UnitActiveState device_active_state(Unit *u) {
assert(u);
return state_translation_table[DEVICE(u)->state];
}
_pure_ static const char *device_sub_state_to_string(Unit *u) {
assert(u);
return device_state_to_string(DEVICE(u)->state);
}
static int device_update_description(Unit *u, struct udev_device *dev, const char *path) {
const char *model;
int r;
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);
if (j)
r = unit_set_description(u, j);
else
r = -ENOMEM;
} else
r = unit_set_description(u, model);
} else
r = unit_set_description(u, path);
if (r < 0)
log_unit_error_errno(u, r, "Failed to set device description: %m");
return r;
}
static int device_add_udev_wants(Unit *u, struct udev_device *dev) {
const char *wants, *property, *p;
int r;
assert(u);
assert(dev);
property = MANAGER_IS_USER(u->manager) ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
wants = udev_device_get_property_value(dev, property);
for (p = wants;;) {
_cleanup_free_ char *word = NULL, *k = NULL;
r = extract_first_word(&p, &word, NULL, EXTRACT_QUOTES);
if (r == 0)
return 0;
if (r == -ENOMEM)
return log_oom();
if (r < 0)
return log_unit_error_errno(u, r, "Failed to add parse %s: %m", property);
r = unit_name_mangle(word, UNIT_NAME_NOGLOB, &k);
if (r < 0)
return log_unit_error_errno(u, r, "Failed to mangle unit name \"%s\": %m", word);
r = unit_add_dependency_by_name(u, UNIT_WANTS, k, NULL, true);
if (r < 0)
return log_unit_error_errno(u, r, "Failed to add wants dependency: %m");
}
}
static bool device_is_bound_by_mounts(Unit *d, struct udev_device *dev) {
const char *bound_by;
int r = false;
assert(d);
assert(dev);
bound_by = udev_device_get_property_value(dev, "SYSTEMD_MOUNT_DEVICE_BOUND");
if (bound_by)
r = parse_boolean(bound_by) > 0;
DEVICE(d)->bind_mounts = r;
return r;
}
static int device_upgrade_mount_deps(Unit *u) {
Unit *other;
Iterator i;
int r;
SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i) {
if (other->type != UNIT_MOUNT)
continue;
r = unit_add_dependency(other, UNIT_BINDS_TO, u, true);
if (r < 0)
return r;
}
return 0;
}
static int device_setup_unit(Manager *m, struct udev_device *dev, const char *path, bool main) {
_cleanup_free_ char *e = NULL;
const char *sysfs = NULL;
Unit *u = NULL;
bool delete;
int r;
assert(m);
assert(path);
if (dev) {
sysfs = udev_device_get_syspath(dev);
if (!sysfs)
return 0;
}
r = unit_name_from_path(path, ".device", &e);
if (r < 0)
return log_error_errno(r, "Failed to generate unit name from device path: %m");
u = manager_get_unit(m, e);
/* The device unit can still be present even if the device was
* unplugged: a mount unit can reference it hence preventing
* the GC to have garbaged it. That's desired since the device
* unit may have a dependency on the mount unit which was
* added during the loading of the later. */
if (dev && u && DEVICE(u)->state == DEVICE_PLUGGED) {
/* This unit is in plugged state: we're sure it's
* attached to a device. */
if (!path_equal(DEVICE(u)->sysfs, sysfs)) {
log_unit_debug(u, "Dev %s appeared twice with different sysfs paths %s and %s",
e, DEVICE(u)->sysfs, sysfs);
return -EEXIST;
}
}
if (!u) {
delete = true;
r = unit_new_for_name(m, sizeof(Device), e, &u);
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 (sysfs) {
r = device_set_sysfs(DEVICE(u), sysfs);
if (r < 0)
goto fail;
(void) device_update_description(u, dev, path);
/* The additional systemd udev properties we only interpret
* for the main object */
if (main)
(void) device_add_udev_wants(u, dev);
}
/* So the user wants the mount units to be bound to the device but a
* mount unit might has been seen by systemd before the device appears
* on its radar. In this case the device unit is partially initialized
* and includes the deps on the mount unit but at that time the "bind
* mounts" flag wasn't not present. Fix this up now. */
if (device_is_bound_by_mounts(u, dev))
device_upgrade_mount_deps(u);
/* 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_unit_warning_errno(u, r, "Failed to set up device unit: %m");
if (delete)
unit_free(u);
return r;
}
static int device_process_new(Manager *m, struct udev_device *dev) {
const char *sysfs, *dn, *alias;
struct udev_list_entry *item = NULL, *first = NULL;
int r;
assert(m);
sysfs = udev_device_get_syspath(dev);
if (!sysfs)
return 0;
/* Add the main unit named after the sysfs path */
r = device_setup_unit(m, dev, sysfs, true);
if (r < 0)
return r;
/* Add an additional unit for the device node */
dn = udev_device_get_devnode(dev);
if (dn)
(void) device_setup_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;
(void) device_setup_unit(m, dev, p, false);
}
/* Add additional units for all explicitly configured
* aliases */
alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS");
for (;;) {
_cleanup_free_ char *word = NULL;
r = extract_first_word(&alias, &word, NULL, EXTRACT_QUOTES);
if (r == 0)
return 0;
if (r == -ENOMEM)
return log_oom();
if (r < 0)
return log_warning_errno(r, "Failed to add parse SYSTEMD_ALIAS for %s: %m", sysfs);
if (path_is_absolute(word))
(void) device_setup_unit(m, dev, word, false);
else
log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs, word);
}
}
static void device_update_found_one(Device *d, bool add, DeviceFound found, bool now) {
DeviceFound n, previous;
assert(d);
n = add ? (d->found | found) : (d->found & ~found);
if (n == d->found)
return;
previous = d->found;
d->found = n;
if (!now)
return;
/* Didn't exist before, but does now? if so, generate a new invocation ID for it */
if (previous == DEVICE_NOT_FOUND && d->found != DEVICE_NOT_FOUND)
(void) unit_acquire_invocation_id(UNIT(d));
if (d->found & DEVICE_FOUND_UDEV)
/* When the device is known to udev we consider it
* plugged. */
device_set_state(d, DEVICE_PLUGGED);
else if (d->found != DEVICE_NOT_FOUND && (previous & DEVICE_FOUND_UDEV) == 0)
/* If the device has not been seen by udev yet, but is
* now referenced by the kernel, then we assume the
* kernel knows it now, and udev might soon too. */
device_set_state(d, DEVICE_TENTATIVE);
else
/* If nobody sees the device, or if the device was
* previously seen by udev and now is only referenced
* from the kernel, then we consider the device is
* gone, the kernel just hasn't noticed it yet. */
device_set_state(d, DEVICE_DEAD);
}
static int device_update_found_by_sysfs(Manager *m, const char *sysfs, bool add, DeviceFound found, bool now) {
Device *d, *l;
assert(m);
assert(sysfs);
if (found == DEVICE_NOT_FOUND)
return 0;
l = hashmap_get(m->devices_by_sysfs, sysfs);
LIST_FOREACH(same_sysfs, d, l)
device_update_found_one(d, add, found, now);
return 0;
}
static int device_update_found_by_name(Manager *m, const char *path, bool add, DeviceFound found, bool now) {
_cleanup_free_ char *e = NULL;
Unit *u;
int r;
assert(m);
assert(path);
if (found == DEVICE_NOT_FOUND)
return 0;
r = unit_name_from_path(path, ".device", &e);
if (r < 0)
return log_error_errno(r, "Failed to generate unit name from device path: %m");
u = manager_get_unit(m, e);
if (!u)
return 0;
device_update_found_one(DEVICE(u), add, found, now);
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 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 **_set) {
Device *d = DEVICE(u), *other;
Set *set;
int r;
assert(d);
assert(_set);
if (LIST_JUST_US(same_sysfs, d)) {
*_set = NULL;
return 0;
}
set = set_new(NULL);
if (!set)
return -ENOMEM;
LIST_FOREACH_AFTER(same_sysfs, other, d) {
r = set_put(set, other);
if (r < 0)
goto fail;
}
LIST_FOREACH_BEFORE(same_sysfs, other, d) {
r = set_put(set, other);
if (r < 0)
goto fail;
}
*_set = set;
return 1;
fail:
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;
}
m->devices_by_sysfs = hashmap_free(m->devices_by_sysfs);
}
static void device_enumerate(Manager *m) {
_cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
struct udev_list_entry *item = NULL, *first = NULL;
int r;
assert(m);
if (!m->udev_monitor) {
m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
if (!m->udev_monitor) {
log_oom();
goto fail;
}
/* This will fail if we are unprivileged, but that
* should not matter much, as user instances won't run
* during boot. */
(void) udev_monitor_set_receive_buffer_size(m->udev_monitor, 128*1024*1024);
r = udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd");
if (r < 0) {
log_error_errno(r, "Failed to add udev tag match: %m");
goto fail;
}
r = udev_monitor_enable_receiving(m->udev_monitor);
if (r < 0) {
log_error_errno(r, "Failed to enable udev event reception: %m");
goto fail;
}
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) {
log_error_errno(r, "Failed to watch udev file descriptor: %m");
goto fail;
}
(void) sd_event_source_set_description(m->udev_event_source, "device");
}
e = udev_enumerate_new(m->udev);
if (!e) {
log_oom();
goto fail;
}
r = udev_enumerate_add_match_tag(e, "systemd");
if (r < 0) {
log_error_errno(r, "Failed to create udev tag enumeration: %m");
goto fail;
}
r = udev_enumerate_add_match_is_initialized(e);
if (r < 0) {
log_error_errno(r, "Failed to install initialization match into enumeration: %m");
goto fail;
}
r = udev_enumerate_scan_devices(e);
if (r < 0) {
log_error_errno(r, "Failed to enumerate devices: %m");
goto fail;
}
first = udev_enumerate_get_list_entry(e);
udev_list_entry_foreach(item, first) {
_cleanup_udev_device_unref_ struct udev_device *dev = NULL;
const char *sysfs;
sysfs = udev_list_entry_get_name(item);
dev = udev_device_new_from_syspath(m->udev, sysfs);
if (!dev) {
log_oom();
continue;
}
if (!device_is_ready(dev))
continue;
(void) device_process_new(m, dev);
device_update_found_by_sysfs(m, sysfs, true, DEVICE_FOUND_UDEV, false);
}
return;
fail:
device_shutdown(m);
}
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, *sysfs;
int r;
assert(m);
if (revents != EPOLLIN) {
static RATELIMIT_DEFINE(limit, 10*USEC_PER_SEC, 5);
if (!ratelimit_test(&limit))
log_error_errno(errno, "Failed to get udev event: %m");
if (!(revents & EPOLLIN))
return 0;
}
/*
* 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;
sysfs = udev_device_get_syspath(dev);
if (!sysfs) {
log_error("Failed to get udev sys path.");
return 0;
}
action = udev_device_get_action(dev);
if (!action) {
log_error("Failed to get udev action string.");
return 0;
}
if (streq(action, "remove")) {
r = swap_process_device_remove(m, dev);
if (r < 0)
log_error_errno(r, "Failed to process swap device remove event: %m");
/* If we get notified that a device was removed by
* udev, then it's completely gone, hence unset all
* found bits */
device_update_found_by_sysfs(m, sysfs, false, DEVICE_FOUND_UDEV|DEVICE_FOUND_MOUNT|DEVICE_FOUND_SWAP, true);
} else if (device_is_ready(dev)) {
(void) device_process_new(m, dev);
r = swap_process_device_new(m, dev);
if (r < 0)
log_error_errno(r, "Failed to process swap device new event: %m");
manager_dispatch_load_queue(m);
/* The device is found now, set the udev found bit */
device_update_found_by_sysfs(m, sysfs, true, DEVICE_FOUND_UDEV, true);
} else {
/* The device is nominally around, but not ready for
* us. Hence unset the udev bit, but leave the rest
* around. */
device_update_found_by_sysfs(m, sysfs, false, DEVICE_FOUND_UDEV, true);
}
return 0;
}
static bool device_supported(void) {
static int read_only = -1;
/* 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;
}
int device_found_node(Manager *m, const char *node, bool add, DeviceFound found, bool now) {
_cleanup_udev_device_unref_ struct udev_device *dev = NULL;
struct stat st;
assert(m);
assert(node);
if (!device_supported())
return 0;
/* This is called whenever we find a device referenced in
* /proc/swaps or /proc/self/mounts. Such a device might be
* mounted/enabled at a time where udev has not finished
* probing it yet, and we thus haven't learned about it
* yet. In this case we will set the device unit to
* "tentative" state. */
if (add) {
if (!path_startswith(node, "/dev"))
return 0;
/* We make an extra check here, if the device node
* actually exists. If it's missing, then this is an
* indication that device was unplugged but is still
* referenced in /proc/swaps or
* /proc/self/mountinfo. Note that this check doesn't
* really cover all cases where a device might be gone
* away, since drives that can have a medium inserted
* will still have a device node even when the medium
* is not there... */
if (stat(node, &st) >= 0) {
if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
return 0;
dev = udev_device_new_from_devnum(m->udev, S_ISBLK(st.st_mode) ? 'b' : 'c', st.st_rdev);
if (!dev && errno != ENOENT)
return log_error_errno(errno, "Failed to get udev device from devnum %u:%u: %m", major(st.st_rdev), minor(st.st_rdev));
} else if (errno != ENOENT)
return log_error_errno(errno, "Failed to stat device node file %s: %m", node);
/* If the device is known in the kernel and newly
* appeared, then we'll create a device unit for it,
* under the name referenced in /proc/swaps or
* /proc/self/mountinfo. */
(void) device_setup_unit(m, dev, node, false);
}
/* Update the device unit's state, should it exist */
return device_update_found_by_name(m, node, add, found, now);
}
bool device_shall_be_bound_by(Unit *device, Unit *u) {
if (u->type != UNIT_MOUNT)
return false;
return DEVICE(device)->bind_mounts;
}
const UnitVTable device_vtable = {
.object_size = sizeof(Device),
.sections =
"Unit\0"
"Device\0"
"Install\0",
.gc_jobs = true,
.init = device_init,
.done = device_done,
.load = unit_load_fragment_and_dropin_optional,
.coldplug = device_coldplug,
.serialize = device_serialize,
.deserialize_item = device_deserialize_item,
.dump = device_dump,
.active_state = device_active_state,
.sub_state_to_string = device_sub_state_to_string,
.bus_vtable = bus_device_vtable,
.following = device_following,
.following_set = device_following_set,
.enumerate = device_enumerate,
.shutdown = device_shutdown,
.supported = device_supported,
.status_message_formats = {
.starting_stopping = {
[0] = "Expecting device %s...",
},
.finished_start_job = {
[JOB_DONE] = "Found device %s.",
[JOB_TIMEOUT] = "Timed out waiting for device %s.",
},
},
};