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>
27 #include "unit-name.h"
28 #include "dbus-device.h"
29 #include "path-util.h"
30 #include "udev-util.h"
35 static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = {
36 [DEVICE_DEAD] = UNIT_INACTIVE,
37 [DEVICE_TENTATIVE] = UNIT_ACTIVATING,
38 [DEVICE_PLUGGED] = UNIT_ACTIVE,
41 static int device_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
43 static void device_unset_sysfs(Device *d) {
52 /* Remove this unit from the chain of devices which share the
54 devices = UNIT(d)->manager->devices_by_sysfs;
55 first = hashmap_get(devices, d->sysfs);
56 LIST_REMOVE(same_sysfs, first, d);
59 hashmap_remove_and_replace(devices, d->sysfs, first->sysfs, first);
61 hashmap_remove(devices, d->sysfs);
67 static int device_set_sysfs(Device *d, const char *sysfs) {
74 if (streq_ptr(d->sysfs, sysfs))
77 r = hashmap_ensure_allocated(&UNIT(d)->manager->devices_by_sysfs, &string_hash_ops);
85 device_unset_sysfs(d);
87 first = hashmap_get(UNIT(d)->manager->devices_by_sysfs, sysfs);
88 LIST_PREPEND(same_sysfs, first, d);
90 r = hashmap_replace(UNIT(d)->manager->devices_by_sysfs, copy, first);
92 LIST_REMOVE(same_sysfs, first, d);
102 static void device_init(Unit *u) {
103 Device *d = DEVICE(u);
106 assert(UNIT(d)->load_state == UNIT_STUB);
108 /* In contrast to all other unit types we timeout jobs waiting
109 * for devices by default. This is because they otherwise wait
110 * indefinitely for plugged in devices, something which cannot
111 * happen for the other units since their operations time out
113 u->job_timeout = u->manager->default_timeout_start_usec;
115 u->ignore_on_isolate = true;
116 u->ignore_on_snapshot = true;
119 static void device_done(Unit *u) {
120 Device *d = DEVICE(u);
124 device_unset_sysfs(d);
127 static void device_set_state(Device *d, DeviceState state) {
128 DeviceState old_state;
131 old_state = d->state;
134 if (state != old_state)
135 log_unit_debug(UNIT(d)->id,
136 "%s changed %s -> %s", UNIT(d)->id,
137 device_state_to_string(old_state),
138 device_state_to_string(state));
140 unit_notify(UNIT(d), state_translation_table[old_state], state_translation_table[state], true);
143 static int device_coldplug(Unit *u, Hashmap *deferred_work) {
144 Device *d = DEVICE(u);
147 assert(d->state == DEVICE_DEAD);
149 if (d->found & DEVICE_FOUND_UDEV)
150 /* If udev says the device is around, it's around */
151 device_set_state(d, DEVICE_PLUGGED);
152 else if (d->found != DEVICE_NOT_FOUND)
153 /* If a device is found in /proc/self/mountinfo or
154 * /proc/swaps, it's "tentatively" around. */
155 device_set_state(d, DEVICE_TENTATIVE);
160 static void device_dump(Unit *u, FILE *f, const char *prefix) {
161 Device *d = DEVICE(u);
166 "%sDevice State: %s\n"
167 "%sSysfs Path: %s\n",
168 prefix, device_state_to_string(d->state),
169 prefix, strna(d->sysfs));
172 _pure_ static UnitActiveState device_active_state(Unit *u) {
175 return state_translation_table[DEVICE(u)->state];
178 _pure_ static const char *device_sub_state_to_string(Unit *u) {
181 return device_state_to_string(DEVICE(u)->state);
184 static int device_update_description(Unit *u, struct udev_device *dev, const char *path) {
192 model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE");
194 model = udev_device_get_property_value(dev, "ID_MODEL");
199 /* Try to concatenate the device model string with a label, if there is one */
200 label = udev_device_get_property_value(dev, "ID_FS_LABEL");
202 label = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME");
204 label = udev_device_get_property_value(dev, "ID_PART_ENTRY_NUMBER");
207 _cleanup_free_ char *j;
209 j = strjoin(model, " ", label, NULL);
211 r = unit_set_description(u, j);
215 r = unit_set_description(u, model);
217 r = unit_set_description(u, path);
220 log_unit_error_errno(u->id, r, "Failed to set device description: %m");
225 static int device_add_udev_wants(Unit *u, struct udev_device *dev) {
227 const char *word, *state;
230 const char *property;
235 property = u->manager->running_as == SYSTEMD_USER ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
236 wants = udev_device_get_property_value(dev, property);
240 FOREACH_WORD_QUOTED(word, l, wants, state) {
241 _cleanup_free_ char *n = NULL;
247 n = unit_name_mangle(e, MANGLE_NOGLOB);
251 r = unit_add_dependency_by_name(u, UNIT_WANTS, n, NULL, true);
253 return log_unit_error_errno(u->id, r, "Failed to add wants dependency: %m");
256 log_unit_warning(u->id, "Property %s on %s has trailing garbage, ignoring.", property, strna(udev_device_get_syspath(dev)));
261 static int device_setup_unit(Manager *m, struct udev_device *dev, const char *path, bool main) {
262 _cleanup_free_ char *e = NULL;
272 sysfs = udev_device_get_syspath(dev);
276 e = unit_name_from_path(path, ".device");
280 u = manager_get_unit(m, e);
284 !path_equal(DEVICE(u)->sysfs, sysfs)) {
285 log_unit_error(u->id, "Device %s appeared twice with different sysfs paths %s and %s", e, DEVICE(u)->sysfs, sysfs);
292 u = unit_new(m, sizeof(Device));
296 r = unit_add_name(u, e);
300 unit_add_to_load_queue(u);
304 /* If this was created via some dependency and has not
305 * actually been seen yet ->sysfs will not be
306 * initialized. Hence initialize it if necessary. */
308 r = device_set_sysfs(DEVICE(u), sysfs);
312 (void) device_update_description(u, dev, path);
314 /* The additional systemd udev properties we only interpret
315 * for the main object */
317 (void) device_add_udev_wants(u, dev);
319 /* Note that this won't dispatch the load queue, the caller
320 * has to do that if needed and appropriate */
322 unit_add_to_dbus_queue(u);
326 log_unit_warning_errno(u->id, r, "Failed to set up device unit: %m");
334 static int device_process_new(Manager *m, struct udev_device *dev) {
335 const char *sysfs, *dn, *alias;
336 struct udev_list_entry *item = NULL, *first = NULL;
341 sysfs = udev_device_get_syspath(dev);
345 /* Add the main unit named after the sysfs path */
346 r = device_setup_unit(m, dev, sysfs, true);
350 /* Add an additional unit for the device node */
351 dn = udev_device_get_devnode(dev);
353 (void) device_setup_unit(m, dev, dn, false);
355 /* Add additional units for all symlinks */
356 first = udev_device_get_devlinks_list_entry(dev);
357 udev_list_entry_foreach(item, first) {
361 /* Don't bother with the /dev/block links */
362 p = udev_list_entry_get_name(item);
364 if (path_startswith(p, "/dev/block/") ||
365 path_startswith(p, "/dev/char/"))
368 /* Verify that the symlink in the FS actually belongs
369 * to this device. This is useful to deal with
370 * conflicting devices, e.g. when two disks want the
371 * same /dev/disk/by-label/xxx link because they have
372 * the same label. We want to make sure that the same
373 * device that won the symlink wins in systemd, so we
374 * check the device node major/minor */
375 if (stat(p, &st) >= 0)
376 if ((!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode)) ||
377 st.st_rdev != udev_device_get_devnum(dev))
380 (void) device_setup_unit(m, dev, p, false);
383 /* Add additional units for all explicitly configured
385 alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS");
387 const char *word, *state;
390 FOREACH_WORD_QUOTED(word, l, alias, state) {
396 if (path_is_absolute(e))
397 (void) device_setup_unit(m, dev, e, false);
399 log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs, e);
402 log_warning("SYSTEMD_ALIAS for %s has trailing garbage, ignoring.", sysfs);
408 static void device_update_found_one(Device *d, bool add, DeviceFound found, bool now) {
413 n = add ? (d->found | found) : (d->found & ~found);
420 if (d->found & DEVICE_FOUND_UDEV)
421 device_set_state(d, DEVICE_PLUGGED);
422 else if (add && d->found != DEVICE_NOT_FOUND)
423 device_set_state(d, DEVICE_TENTATIVE);
425 device_set_state(d, DEVICE_DEAD);
429 static int device_update_found_by_sysfs(Manager *m, const char *sysfs, bool add, DeviceFound found, bool now) {
435 if (found == DEVICE_NOT_FOUND)
438 l = hashmap_get(m->devices_by_sysfs, sysfs);
439 LIST_FOREACH(same_sysfs, d, l)
440 device_update_found_one(d, add, found, now);
445 static int device_update_found_by_name(Manager *m, const char *path, bool add, DeviceFound found, bool now) {
446 _cleanup_free_ char *e = NULL;
452 if (found == DEVICE_NOT_FOUND)
455 e = unit_name_from_path(path, ".device");
459 u = manager_get_unit(m, e);
463 device_update_found_one(DEVICE(u), add, found, now);
467 static bool device_is_ready(struct udev_device *dev) {
472 ready = udev_device_get_property_value(dev, "SYSTEMD_READY");
476 return parse_boolean(ready) != 0;
479 static Unit *device_following(Unit *u) {
480 Device *d = DEVICE(u);
481 Device *other, *first = NULL;
485 if (startswith(u->id, "sys-"))
488 /* Make everybody follow the unit that's named after the sysfs path */
489 for (other = d->same_sysfs_next; other; other = other->same_sysfs_next)
490 if (startswith(UNIT(other)->id, "sys-"))
493 for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) {
494 if (startswith(UNIT(other)->id, "sys-"))
503 static int device_following_set(Unit *u, Set **_set) {
504 Device *d = DEVICE(u), *other;
511 if (LIST_JUST_US(same_sysfs, d)) {
520 LIST_FOREACH_AFTER(same_sysfs, other, d) {
521 r = set_put(set, other);
526 LIST_FOREACH_BEFORE(same_sysfs, other, d) {
527 r = set_put(set, other);
540 static void device_shutdown(Manager *m) {
543 m->udev_event_source = sd_event_source_unref(m->udev_event_source);
545 if (m->udev_monitor) {
546 udev_monitor_unref(m->udev_monitor);
547 m->udev_monitor = NULL;
550 hashmap_free(m->devices_by_sysfs);
551 m->devices_by_sysfs = NULL;
554 static int device_enumerate(Manager *m) {
555 _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
556 struct udev_list_entry *item = NULL, *first = NULL;
561 if (!m->udev_monitor) {
562 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
563 if (!m->udev_monitor) {
568 /* This will fail if we are unprivileged, but that
569 * should not matter much, as user instances won't run
571 (void) udev_monitor_set_receive_buffer_size(m->udev_monitor, 128*1024*1024);
573 r = udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd");
577 r = udev_monitor_enable_receiving(m->udev_monitor);
581 r = sd_event_add_io(m->event, &m->udev_event_source, udev_monitor_get_fd(m->udev_monitor), EPOLLIN, device_dispatch_io, m);
586 e = udev_enumerate_new(m->udev);
592 r = udev_enumerate_add_match_tag(e, "systemd");
596 r = udev_enumerate_add_match_is_initialized(e);
600 r = udev_enumerate_scan_devices(e);
604 first = udev_enumerate_get_list_entry(e);
605 udev_list_entry_foreach(item, first) {
606 _cleanup_udev_device_unref_ struct udev_device *dev = NULL;
609 sysfs = udev_list_entry_get_name(item);
611 dev = udev_device_new_from_syspath(m->udev, sysfs);
617 if (!device_is_ready(dev))
620 (void) device_process_new(m, dev);
622 device_update_found_by_sysfs(m, sysfs, true, DEVICE_FOUND_UDEV, false);
628 log_error_errno(r, "Failed to enumerate devices: %m");
634 static int device_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
635 _cleanup_udev_device_unref_ struct udev_device *dev = NULL;
636 Manager *m = userdata;
637 const char *action, *sysfs;
642 if (revents != EPOLLIN) {
643 static RATELIMIT_DEFINE(limit, 10*USEC_PER_SEC, 5);
645 if (!ratelimit_test(&limit))
646 log_error_errno(errno, "Failed to get udev event: %m");
647 if (!(revents & EPOLLIN))
652 * libudev might filter-out devices which pass the bloom
653 * filter, so getting NULL here is not necessarily an error.
655 dev = udev_monitor_receive_device(m->udev_monitor);
659 sysfs = udev_device_get_syspath(dev);
661 log_error("Failed to get udev sys path.");
665 action = udev_device_get_action(dev);
667 log_error("Failed to get udev action string.");
671 if (streq(action, "remove")) {
672 r = swap_process_device_remove(m, dev);
674 log_error_errno(r, "Failed to process swap device remove event: %m");
676 /* If we get notified that a device was removed by
677 * udev, then it's completely gone, hence unset all
679 device_update_found_by_sysfs(m, sysfs, false, DEVICE_FOUND_UDEV|DEVICE_FOUND_MOUNT|DEVICE_FOUND_SWAP, true);
681 } else if (device_is_ready(dev)) {
683 (void) device_process_new(m, dev);
685 r = swap_process_device_new(m, dev);
687 log_error_errno(r, "Failed to process swap device new event: %m");
689 manager_dispatch_load_queue(m);
691 /* The device is found now, set the udev found bit */
692 device_update_found_by_sysfs(m, sysfs, true, DEVICE_FOUND_UDEV, true);
695 /* The device is nominally around, but not ready for
696 * us. Hence unset the udev bit, but leave the rest
699 device_update_found_by_sysfs(m, sysfs, false, DEVICE_FOUND_UDEV, true);
705 static bool device_supported(Manager *m) {
706 static int read_only = -1;
709 /* If /sys is read-only we don't support device units, and any
710 * attempts to start one should fail immediately. */
713 read_only = path_is_read_only_fs("/sys");
715 return read_only <= 0;
718 int device_found_node(Manager *m, const char *node, bool add, DeviceFound found, bool now) {
719 _cleanup_udev_device_unref_ struct udev_device *dev = NULL;
725 /* This is called whenever we find a device referenced in
726 * /proc/swaps or /proc/self/mounts. Such a device might be
727 * mounted/enabled at a time where udev has not finished
728 * probing it yet, and we thus haven't learned about it
729 * yet. In this case we will set the device unit to
730 * "tentative" state. */
733 if (!path_startswith(node, "/dev"))
736 if (stat(node, &st) < 0) {
740 return log_error_errno(errno, "Failed to stat device node file %s: %m", node);
743 if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
746 dev = udev_device_new_from_devnum(m->udev, S_ISBLK(st.st_mode) ? 'b' : 'c', st.st_rdev);
754 /* If the device is known in the kernel and newly
755 * appeared, then we'll create a device unit for it,
756 * under the name referenced in /proc/swaps or
757 * /proc/self/mountinfo. */
759 (void) device_setup_unit(m, dev, node, false);
762 /* Update the device unit's state, should it exist */
763 return device_update_found_by_name(m, node, add, found, now);
766 static const char* const device_state_table[_DEVICE_STATE_MAX] = {
767 [DEVICE_DEAD] = "dead",
768 [DEVICE_TENTATIVE] = "tentative",
769 [DEVICE_PLUGGED] = "plugged",
772 DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState);
774 const UnitVTable device_vtable = {
775 .object_size = sizeof(Device),
781 .no_instances = true,
785 .load = unit_load_fragment_and_dropin_optional,
787 .coldplug = device_coldplug,
791 .active_state = device_active_state,
792 .sub_state_to_string = device_sub_state_to_string,
794 .bus_interface = "org.freedesktop.systemd1.Device",
795 .bus_vtable = bus_device_vtable,
797 .following = device_following,
798 .following_set = device_following_set,
800 .enumerate = device_enumerate,
801 .shutdown = device_shutdown,
802 .supported = device_supported,
804 .status_message_formats = {
805 .starting_stopping = {
806 [0] = "Expecting device %s...",
808 .finished_start_job = {
809 [JOB_DONE] = "Found device %s.",
810 [JOB_TIMEOUT] = "Timed out waiting for device %s.",