1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 #include <sys/epoll.h>
30 #include "unit-name.h"
31 #include "dbus-device.h"
33 #include "path-util.h"
35 static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = {
36 [DEVICE_DEAD] = UNIT_INACTIVE,
37 [DEVICE_PLUGGED] = UNIT_ACTIVE
40 static void device_unset_sysfs(Device *d) {
48 /* Remove this unit from the chain of devices which share the
50 first = hashmap_get(UNIT(d)->manager->devices_by_sysfs, d->sysfs);
51 LIST_REMOVE(Device, same_sysfs, first, d);
54 hashmap_remove_and_replace(UNIT(d)->manager->devices_by_sysfs, d->sysfs, first->sysfs, first);
56 hashmap_remove(UNIT(d)->manager->devices_by_sysfs, d->sysfs);
62 static void device_init(Unit *u) {
63 Device *d = DEVICE(u);
66 assert(UNIT(d)->load_state == UNIT_STUB);
68 /* In contrast to all other unit types we timeout jobs waiting
69 * for devices by default. This is because they otherwise wait
70 * indefinitely for plugged in devices, something which cannot
71 * happen for the other units since their operations time out
73 UNIT(d)->job_timeout = DEFAULT_TIMEOUT_USEC;
75 UNIT(d)->ignore_on_isolate = true;
76 UNIT(d)->ignore_on_snapshot = true;
79 static void device_done(Unit *u) {
80 Device *d = DEVICE(u);
84 device_unset_sysfs(d);
87 static void device_set_state(Device *d, DeviceState state) {
88 DeviceState old_state;
94 if (state != old_state)
95 log_debug_unit(UNIT(d)->id,
96 "%s changed %s -> %s", UNIT(d)->id,
97 device_state_to_string(old_state),
98 device_state_to_string(state));
100 unit_notify(UNIT(d), state_translation_table[old_state], state_translation_table[state], true);
103 static int device_coldplug(Unit *u) {
104 Device *d = DEVICE(u);
107 assert(d->state == DEVICE_DEAD);
110 device_set_state(d, DEVICE_PLUGGED);
115 static void device_dump(Unit *u, FILE *f, const char *prefix) {
116 Device *d = DEVICE(u);
121 "%sDevice State: %s\n"
122 "%sSysfs Path: %s\n",
123 prefix, device_state_to_string(d->state),
124 prefix, strna(d->sysfs));
127 _pure_ static UnitActiveState device_active_state(Unit *u) {
130 return state_translation_table[DEVICE(u)->state];
133 _pure_ static const char *device_sub_state_to_string(Unit *u) {
136 return device_state_to_string(DEVICE(u)->state);
139 static int device_add_escaped_name(Unit *u, const char *dn) {
145 assert(dn[0] == '/');
147 e = unit_name_from_path(dn, ".device");
151 r = unit_add_name(u, e);
154 if (r < 0 && r != -EEXIST)
160 static int device_find_escape_name(Manager *m, const char *dn, Unit **_u) {
166 assert(dn[0] == '/');
169 e = unit_name_from_path(dn, ".device");
173 u = manager_get_unit(m, e);
184 static int device_update_unit(Manager *m, struct udev_device *dev, const char *path, bool main) {
185 const char *sysfs, *model;
192 if (!(sysfs = udev_device_get_syspath(dev)))
195 if ((r = device_find_escape_name(m, path, &u)) < 0)
198 if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs))
204 u = unit_new(m, sizeof(Device));
208 r = device_add_escaped_name(u, path);
212 unit_add_to_load_queue(u);
216 /* If this was created via some dependency and has not
217 * actually been seen yet ->sysfs will not be
218 * initialized. Hence initialize it if necessary. */
220 if (!DEVICE(u)->sysfs) {
223 if (!(DEVICE(u)->sysfs = strdup(sysfs))) {
228 if (!m->devices_by_sysfs)
229 if (!(m->devices_by_sysfs = hashmap_new(string_hash_func, string_compare_func))) {
234 first = hashmap_get(m->devices_by_sysfs, sysfs);
235 LIST_PREPEND(Device, same_sysfs, first, DEVICE(u));
237 if ((r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first)) < 0)
241 if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) ||
242 (model = udev_device_get_property_value(dev, "ID_MODEL"))) {
243 if ((r = unit_set_description(u, model)) < 0)
246 if ((r = unit_set_description(u, path)) < 0)
250 /* The additional systemd udev properties we only
251 * interpret for the main object */
252 const char *wants, *alias;
254 alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS");
259 FOREACH_WORD_QUOTED(w, l, alias, state) {
269 log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, e);
272 device_update_unit(m, dev, e, false);
278 wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS");
283 FOREACH_WORD_QUOTED(w, l, wants, state) {
291 n = unit_name_mangle(e);
298 r = unit_add_dependency_by_name(u, UNIT_WANTS, n, NULL, true);
306 unit_add_to_dbus_queue(u);
310 log_warning("Failed to load device unit: %s", strerror(-r));
318 static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) {
319 const char *sysfs, *dn;
320 struct udev_list_entry *item = NULL, *first = NULL;
325 if (!(sysfs = udev_device_get_syspath(dev)))
328 /* Add the main unit named after the sysfs path */
329 r = device_update_unit(m, dev, sysfs, true);
333 /* Add an additional unit for the device node */
334 if ((dn = udev_device_get_devnode(dev)))
335 device_update_unit(m, dev, dn, false);
337 /* Add additional units for all symlinks */
338 first = udev_device_get_devlinks_list_entry(dev);
339 udev_list_entry_foreach(item, first) {
343 /* Don't bother with the /dev/block links */
344 p = udev_list_entry_get_name(item);
346 if (path_startswith(p, "/dev/block/") ||
347 path_startswith(p, "/dev/char/"))
350 /* Verify that the symlink in the FS actually belongs
351 * to this device. This is useful to deal with
352 * conflicting devices, e.g. when two disks want the
353 * same /dev/disk/by-label/xxx link because they have
354 * the same label. We want to make sure that the same
355 * device that won the symlink wins in systemd, so we
356 * check the device node major/minor*/
357 if (stat(p, &st) >= 0)
358 if ((!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode)) ||
359 st.st_rdev != udev_device_get_devnum(dev))
362 device_update_unit(m, dev, p, false);
368 manager_dispatch_load_queue(m);
370 l = hashmap_get(m->devices_by_sysfs, sysfs);
371 LIST_FOREACH(same_sysfs, d, l)
372 device_set_state(d, DEVICE_PLUGGED);
378 static int device_process_path(Manager *m, const char *path, bool update_state) {
380 struct udev_device *dev;
385 if (!(dev = udev_device_new_from_syspath(m->udev, path))) {
386 log_warning("Failed to get udev device object from udev for path %s.", path);
390 r = device_process_new_device(m, dev, update_state);
391 udev_device_unref(dev);
395 static int device_process_removed_device(Manager *m, struct udev_device *dev) {
402 if (!(sysfs = udev_device_get_syspath(dev)))
405 /* Remove all units of this sysfs path */
406 while ((d = hashmap_get(m->devices_by_sysfs, sysfs))) {
407 device_unset_sysfs(d);
408 device_set_state(d, DEVICE_DEAD);
414 static Unit *device_following(Unit *u) {
415 Device *d = DEVICE(u);
416 Device *other, *first = NULL;
420 if (startswith(u->id, "sys-"))
423 /* Make everybody follow the unit that's named after the sysfs path */
424 for (other = d->same_sysfs_next; other; other = other->same_sysfs_next)
425 if (startswith(UNIT(other)->id, "sys-"))
428 for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) {
429 if (startswith(UNIT(other)->id, "sys-"))
438 static int device_following_set(Unit *u, Set **_s) {
439 Device *d = DEVICE(u);
447 if (!d->same_sysfs_prev && !d->same_sysfs_next) {
452 if (!(s = set_new(NULL, NULL)))
455 for (other = d->same_sysfs_next; other; other = other->same_sysfs_next)
456 if ((r = set_put(s, other)) < 0)
459 for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev)
460 if ((r = set_put(s, other)) < 0)
471 static void device_shutdown(Manager *m) {
474 if (m->udev_monitor) {
475 udev_monitor_unref(m->udev_monitor);
476 m->udev_monitor = NULL;
484 hashmap_free(m->devices_by_sysfs);
485 m->devices_by_sysfs = NULL;
488 static int device_enumerate(Manager *m) {
490 struct udev_enumerate *e = NULL;
491 struct udev_list_entry *item = NULL, *first = NULL;
496 struct epoll_event ev;
498 if (!(m->udev = udev_new()))
501 if (!(m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev"))) {
506 /* This will fail if we are unprivileged, but that
507 * should not matter much, as user instances won't run
509 udev_monitor_set_receive_buffer_size(m->udev_monitor, 128*1024*1024);
511 if (udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd") < 0) {
516 if (udev_monitor_enable_receiving(m->udev_monitor) < 0) {
521 m->udev_watch.type = WATCH_UDEV;
522 m->udev_watch.fd = udev_monitor_get_fd(m->udev_monitor);
526 ev.data.ptr = &m->udev_watch;
528 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_watch.fd, &ev) < 0)
532 if (!(e = udev_enumerate_new(m->udev))) {
536 if (udev_enumerate_add_match_tag(e, "systemd") < 0) {
541 if (udev_enumerate_scan_devices(e) < 0) {
546 first = udev_enumerate_get_list_entry(e);
547 udev_list_entry_foreach(item, first)
548 device_process_path(m, udev_list_entry_get_name(item), false);
550 udev_enumerate_unref(e);
555 udev_enumerate_unref(e);
561 void device_fd_event(Manager *m, int events) {
562 struct udev_device *dev;
564 const char *action, *ready;
568 if (events != EPOLLIN) {
569 static RATELIMIT_DEFINE(limit, 10*USEC_PER_SEC, 5);
571 if (!ratelimit_test(&limit))
572 log_error("Failed to get udev event: %m");
573 if (!(events & EPOLLIN))
577 if (!(dev = udev_monitor_receive_device(m->udev_monitor))) {
579 * libudev might filter-out devices which pass the bloom filter,
580 * so getting NULL here is not necessarily an error
585 if (!(action = udev_device_get_action(dev))) {
586 log_error("Failed to get udev action string.");
590 ready = udev_device_get_property_value(dev, "SYSTEMD_READY");
592 if (streq(action, "remove") || (ready && parse_boolean(ready) == 0)) {
593 if ((r = device_process_removed_device(m, dev)) < 0) {
594 log_error("Failed to process udev device event: %s", strerror(-r));
598 if ((r = device_process_new_device(m, dev, true)) < 0) {
599 log_error("Failed to process udev device event: %s", strerror(-r));
605 udev_device_unref(dev);
608 static const char* const device_state_table[_DEVICE_STATE_MAX] = {
609 [DEVICE_DEAD] = "dead",
610 [DEVICE_PLUGGED] = "plugged"
613 DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState);
615 const UnitVTable device_vtable = {
616 .object_size = sizeof(Device),
622 .no_instances = true,
626 .load = unit_load_fragment_and_dropin_optional,
628 .coldplug = device_coldplug,
632 .active_state = device_active_state,
633 .sub_state_to_string = device_sub_state_to_string,
635 .bus_interface = "org.freedesktop.systemd1.Device",
636 .bus_message_handler = bus_device_message_handler,
637 .bus_invalidating_properties = bus_device_invalidating_properties,
639 .following = device_following,
640 .following_set = device_following_set,
642 .enumerate = device_enumerate,
643 .shutdown = device_shutdown,
645 .status_message_formats = {
646 .starting_stopping = {
647 [0] = "Expecting device %s...",
649 .finished_start_job = {
650 [JOB_DONE] = "Found device %s.",
651 [JOB_TIMEOUT] = "Timed out waiting for device %s.",