c69182961b
Instead of generic "Starting..." and "Started" messages for all unit use type-dependent messages. For example, mounts will announce "Mounting..." and "Mounted". Add status messages to units of types that used to be entirely silent (automounts, sockets, targets, devices). For unit types whose jobs are instantaneous, report only the job completion, not the starting event. Socket units with non-instantaneous jobs are rare (Exec*= is not used often in socket units), so I chose not to print the starting messages for them either. This will hopefully give people better understanding of the boot.
628 lines
18 KiB
C
628 lines
18 KiB
C
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
/***
|
|
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 <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include <errno.h>
|
|
#include <sys/epoll.h>
|
|
#include <libudev.h>
|
|
|
|
#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"
|
|
|
|
static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = {
|
|
[DEVICE_DEAD] = UNIT_INACTIVE,
|
|
[DEVICE_PLUGGED] = UNIT_ACTIVE
|
|
};
|
|
|
|
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(UNIT(d)->manager->devices_by_sysfs, d->sysfs);
|
|
LIST_REMOVE(Device, same_sysfs, first, d);
|
|
|
|
if (first)
|
|
hashmap_remove_and_replace(UNIT(d)->manager->devices_by_sysfs, d->sysfs, first->sysfs, first);
|
|
else
|
|
hashmap_remove(UNIT(d)->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(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. */
|
|
UNIT(d)->job_timeout = DEFAULT_TIMEOUT_USEC;
|
|
|
|
UNIT(d)->ignore_on_isolate = true;
|
|
UNIT(d)->ignore_on_snapshot = 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_debug("%s changed %s -> %s",
|
|
UNIT(d)->id,
|
|
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->sysfs)
|
|
device_set_state(d, DEVICE_PLUGGED);
|
|
|
|
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));
|
|
}
|
|
|
|
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) {
|
|
assert(u);
|
|
|
|
return device_state_to_string(DEVICE(u)->state);
|
|
}
|
|
|
|
static int device_add_escaped_name(Unit *u, const char *dn) {
|
|
char *e;
|
|
int r;
|
|
|
|
assert(u);
|
|
assert(dn);
|
|
assert(dn[0] == '/');
|
|
|
|
if (!(e = unit_name_from_path(dn, ".device")))
|
|
return -ENOMEM;
|
|
|
|
r = unit_add_name(u, e);
|
|
free(e);
|
|
|
|
if (r < 0 && r != -EEXIST)
|
|
return r;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int device_find_escape_name(Manager *m, const char *dn, Unit **_u) {
|
|
char *e;
|
|
Unit *u;
|
|
|
|
assert(m);
|
|
assert(dn);
|
|
assert(dn[0] == '/');
|
|
assert(_u);
|
|
|
|
if (!(e = unit_name_from_path(dn, ".device")))
|
|
return -ENOMEM;
|
|
|
|
u = manager_get_unit(m, e);
|
|
free(e);
|
|
|
|
if (u) {
|
|
*_u = u;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
bool delete;
|
|
|
|
assert(m);
|
|
|
|
if (!(sysfs = udev_device_get_syspath(dev)))
|
|
return -ENOMEM;
|
|
|
|
if ((r = device_find_escape_name(m, path, &u)) < 0)
|
|
return r;
|
|
|
|
if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs))
|
|
return -EEXIST;
|
|
|
|
if (!u) {
|
|
delete = true;
|
|
|
|
u = unit_new(m, sizeof(Device));
|
|
if (!u)
|
|
return -ENOMEM;
|
|
|
|
r = device_add_escaped_name(u, path);
|
|
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 (!DEVICE(u)->sysfs) {
|
|
Device *first;
|
|
|
|
if (!(DEVICE(u)->sysfs = strdup(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;
|
|
}
|
|
|
|
first = hashmap_get(m->devices_by_sysfs, sysfs);
|
|
LIST_PREPEND(Device, same_sysfs, first, DEVICE(u));
|
|
|
|
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 ((r = unit_set_description(u, path)) < 0)
|
|
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;
|
|
}
|
|
}
|
|
|
|
if ((wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS"))) {
|
|
char *state, *w;
|
|
size_t l;
|
|
|
|
FOREACH_WORD_QUOTED(w, l, wants, state) {
|
|
char *e;
|
|
|
|
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;
|
|
|
|
assert(m);
|
|
assert(path);
|
|
|
|
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;
|
|
}
|
|
|
|
r = device_process_new_device(m, dev, update_state);
|
|
udev_device_unref(dev);
|
|
return r;
|
|
}
|
|
|
|
static int device_process_removed_device(Manager *m, struct udev_device *dev) {
|
|
const char *sysfs;
|
|
Device *d;
|
|
|
|
assert(m);
|
|
assert(dev);
|
|
|
|
if (!(sysfs = udev_device_get_syspath(dev)))
|
|
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);
|
|
}
|
|
|
|
return 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 **_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);
|
|
|
|
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;
|
|
struct udev_list_entry *item = NULL, *first = NULL;
|
|
|
|
assert(m);
|
|
|
|
if (!m->udev) {
|
|
if (!(m->udev = udev_new()))
|
|
return -ENOMEM;
|
|
|
|
if (!(m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev"))) {
|
|
r = -ENOMEM;
|
|
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;
|
|
}
|
|
|
|
if (udev_monitor_enable_receiving(m->udev_monitor) < 0) {
|
|
r = -EIO;
|
|
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;
|
|
}
|
|
|
|
if (!(e = udev_enumerate_new(m->udev))) {
|
|
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;
|
|
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);
|
|
|
|
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;
|
|
int r;
|
|
const char *action, *ready;
|
|
|
|
assert(m);
|
|
|
|
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))) {
|
|
/*
|
|
* libudev might filter-out devices which pass the bloom filter,
|
|
* so getting NULL here is not necessarily an error
|
|
*/
|
|
return;
|
|
}
|
|
|
|
if (!(action = udev_device_get_action(dev))) {
|
|
log_error("Failed to get udev action string.");
|
|
goto fail;
|
|
}
|
|
|
|
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;
|
|
}
|
|
} else {
|
|
if ((r = device_process_new_device(m, dev, true)) < 0) {
|
|
log_error("Failed to process udev device event: %s", strerror(-r));
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
fail:
|
|
udev_device_unref(dev);
|
|
}
|
|
|
|
static const char* const device_state_table[_DEVICE_STATE_MAX] = {
|
|
[DEVICE_DEAD] = "dead",
|
|
[DEVICE_PLUGGED] = "plugged"
|
|
};
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState);
|
|
|
|
const UnitVTable device_vtable = {
|
|
.suffix = ".device",
|
|
.object_size = sizeof(Device),
|
|
.sections =
|
|
"Unit\0"
|
|
"Device\0"
|
|
"Install\0",
|
|
|
|
.no_instances = true,
|
|
|
|
.init = device_init,
|
|
|
|
.load = unit_load_fragment_and_dropin_optional,
|
|
.done = device_done,
|
|
.coldplug = device_coldplug,
|
|
|
|
.dump = device_dump,
|
|
|
|
.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,
|
|
|
|
.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.",
|
|
},
|
|
},
|
|
};
|