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("%s changed %s -> %s",
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 static UnitActiveState device_active_state(Unit *u) {
130 return state_translation_table[DEVICE(u)->state];
133 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 if (!(e = unit_name_from_path(dn, ".device")))
150 r = unit_add_name(u, e);
153 if (r < 0 && r != -EEXIST)
159 static int device_find_escape_name(Manager *m, const char *dn, Unit **_u) {
165 assert(dn[0] == '/');
168 if (!(e = unit_name_from_path(dn, ".device")))
171 u = manager_get_unit(m, e);
182 static int device_update_unit(Manager *m, struct udev_device *dev, const char *path, bool main) {
183 const char *sysfs, *model;
190 if (!(sysfs = udev_device_get_syspath(dev)))
193 if ((r = device_find_escape_name(m, path, &u)) < 0)
196 if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs))
202 u = unit_new(m, sizeof(Device));
206 r = device_add_escaped_name(u, path);
210 unit_add_to_load_queue(u);
214 /* If this was created via some dependency and has not
215 * actually been seen yet ->sysfs will not be
216 * initialized. Hence initialize it if necessary. */
218 if (!DEVICE(u)->sysfs) {
221 if (!(DEVICE(u)->sysfs = strdup(sysfs))) {
226 if (!m->devices_by_sysfs)
227 if (!(m->devices_by_sysfs = hashmap_new(string_hash_func, string_compare_func))) {
232 first = hashmap_get(m->devices_by_sysfs, sysfs);
233 LIST_PREPEND(Device, same_sysfs, first, DEVICE(u));
235 if ((r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first)) < 0)
239 if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) ||
240 (model = udev_device_get_property_value(dev, "ID_MODEL"))) {
241 if ((r = unit_set_description(u, model)) < 0)
244 if ((r = unit_set_description(u, path)) < 0)
248 /* The additional systemd udev properties we only
249 * interpret for the main object */
250 const char *wants, *alias;
252 if ((alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS"))) {
254 log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, alias);
256 if ((r = device_add_escaped_name(u, alias)) < 0)
261 if ((wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS"))) {
265 FOREACH_WORD_QUOTED(w, l, wants, state) {
268 if (!(e = strndup(w, l))) {
273 r = unit_add_dependency_by_name(u, UNIT_WANTS, e, NULL, true);
282 unit_add_to_dbus_queue(u);
286 log_warning("Failed to load device unit: %s", strerror(-r));
294 static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) {
295 const char *sysfs, *dn;
296 struct udev_list_entry *item = NULL, *first = NULL;
300 if (!(sysfs = udev_device_get_syspath(dev)))
303 /* Add the main unit named after the sysfs path */
304 device_update_unit(m, dev, sysfs, true);
306 /* Add an additional unit for the device node */
307 if ((dn = udev_device_get_devnode(dev)))
308 device_update_unit(m, dev, dn, false);
310 /* Add additional units for all symlinks */
311 first = udev_device_get_devlinks_list_entry(dev);
312 udev_list_entry_foreach(item, first) {
316 /* Don't bother with the /dev/block links */
317 p = udev_list_entry_get_name(item);
319 if (path_startswith(p, "/dev/block/") ||
320 path_startswith(p, "/dev/char/"))
323 /* Verify that the symlink in the FS actually belongs
324 * to this device. This is useful to deal with
325 * conflicting devices, e.g. when two disks want the
326 * same /dev/disk/by-label/xxx link because they have
327 * the same label. We want to make sure that the same
328 * device that won the symlink wins in systemd, so we
329 * check the device node major/minor*/
330 if (stat(p, &st) >= 0)
331 if ((!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode)) ||
332 st.st_rdev != udev_device_get_devnum(dev))
335 device_update_unit(m, dev, p, false);
341 manager_dispatch_load_queue(m);
343 l = hashmap_get(m->devices_by_sysfs, sysfs);
344 LIST_FOREACH(same_sysfs, d, l)
345 device_set_state(d, DEVICE_PLUGGED);
351 static int device_process_path(Manager *m, const char *path, bool update_state) {
353 struct udev_device *dev;
358 if (!(dev = udev_device_new_from_syspath(m->udev, path))) {
359 log_warning("Failed to get udev device object from udev for path %s.", path);
363 r = device_process_new_device(m, dev, update_state);
364 udev_device_unref(dev);
368 static int device_process_removed_device(Manager *m, struct udev_device *dev) {
375 if (!(sysfs = udev_device_get_syspath(dev)))
378 /* Remove all units of this sysfs path */
379 while ((d = hashmap_get(m->devices_by_sysfs, sysfs))) {
380 device_unset_sysfs(d);
381 device_set_state(d, DEVICE_DEAD);
387 static Unit *device_following(Unit *u) {
388 Device *d = DEVICE(u);
389 Device *other, *first = NULL;
393 if (startswith(u->id, "sys-"))
396 /* Make everybody follow the unit that's named after the sysfs path */
397 for (other = d->same_sysfs_next; other; other = other->same_sysfs_next)
398 if (startswith(UNIT(other)->id, "sys-"))
401 for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) {
402 if (startswith(UNIT(other)->id, "sys-"))
411 static int device_following_set(Unit *u, Set **_s) {
412 Device *d = DEVICE(u);
420 if (!d->same_sysfs_prev && !d->same_sysfs_next) {
425 if (!(s = set_new(NULL, NULL)))
428 for (other = d->same_sysfs_next; other; other = other->same_sysfs_next)
429 if ((r = set_put(s, other)) < 0)
432 for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev)
433 if ((r = set_put(s, other)) < 0)
444 static void device_shutdown(Manager *m) {
447 if (m->udev_monitor) {
448 udev_monitor_unref(m->udev_monitor);
449 m->udev_monitor = NULL;
457 hashmap_free(m->devices_by_sysfs);
458 m->devices_by_sysfs = NULL;
461 static int device_enumerate(Manager *m) {
462 struct epoll_event ev;
464 struct udev_enumerate *e = NULL;
465 struct udev_list_entry *item = NULL, *first = NULL;
470 if (!(m->udev = udev_new()))
473 if (!(m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev"))) {
478 /* This will fail if we are unprivileged, but that
479 * should not matter much, as user instances won't run
481 udev_monitor_set_receive_buffer_size(m->udev_monitor, 128*1024*1024);
483 if (udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd") < 0) {
488 if (udev_monitor_enable_receiving(m->udev_monitor) < 0) {
493 m->udev_watch.type = WATCH_UDEV;
494 m->udev_watch.fd = udev_monitor_get_fd(m->udev_monitor);
498 ev.data.ptr = &m->udev_watch;
500 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_watch.fd, &ev) < 0)
504 if (!(e = udev_enumerate_new(m->udev))) {
508 if (udev_enumerate_add_match_tag(e, "systemd") < 0) {
513 if (udev_enumerate_scan_devices(e) < 0) {
518 first = udev_enumerate_get_list_entry(e);
519 udev_list_entry_foreach(item, first)
520 device_process_path(m, udev_list_entry_get_name(item), false);
522 udev_enumerate_unref(e);
527 udev_enumerate_unref(e);
533 void device_fd_event(Manager *m, int events) {
534 struct udev_device *dev;
536 const char *action, *ready;
540 if (events != EPOLLIN) {
541 static RATELIMIT_DEFINE(limit, 10*USEC_PER_SEC, 5);
543 if (!ratelimit_test(&limit))
544 log_error("Failed to get udev event: %m");
545 if (!(events & EPOLLIN))
549 if (!(dev = udev_monitor_receive_device(m->udev_monitor))) {
551 * libudev might filter-out devices which pass the bloom filter,
552 * so getting NULL here is not necessarily an error
557 if (!(action = udev_device_get_action(dev))) {
558 log_error("Failed to get udev action string.");
562 ready = udev_device_get_property_value(dev, "SYSTEMD_READY");
564 if (streq(action, "remove") || (ready && parse_boolean(ready) == 0)) {
565 if ((r = device_process_removed_device(m, dev)) < 0) {
566 log_error("Failed to process udev device event: %s", strerror(-r));
570 if ((r = device_process_new_device(m, dev, true)) < 0) {
571 log_error("Failed to process udev device event: %s", strerror(-r));
577 udev_device_unref(dev);
580 static const char* const device_state_table[_DEVICE_STATE_MAX] = {
581 [DEVICE_DEAD] = "dead",
582 [DEVICE_PLUGGED] = "plugged"
585 DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState);
587 const UnitVTable device_vtable = {
589 .object_size = sizeof(Device),
595 .no_instances = true,
599 .load = unit_load_fragment_and_dropin_optional,
601 .coldplug = device_coldplug,
605 .active_state = device_active_state,
606 .sub_state_to_string = device_sub_state_to_string,
608 .bus_interface = "org.freedesktop.systemd1.Device",
609 .bus_message_handler = bus_device_message_handler,
610 .bus_invalidating_properties = bus_device_invalidating_properties,
612 .following = device_following,
613 .following_set = device_following_set,
615 .enumerate = device_enumerate,
616 .shutdown = device_shutdown,
618 .status_message_formats = {
619 .starting_stopping = {
620 [0] = "Expecting device %s...",
622 .finished_start_job = {
623 [JOB_DONE] = "Found device %s.",
624 [JOB_TIMEOUT] = "Timed out waiting for device %s.",