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(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 sysfs = udev_device_get_syspath(dev);
196 r = device_find_escape_name(m, path, &u);
200 if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs))
206 u = unit_new(m, sizeof(Device));
210 r = device_add_escaped_name(u, path);
214 unit_add_to_load_queue(u);
218 /* If this was created via some dependency and has not
219 * actually been seen yet ->sysfs will not be
220 * initialized. Hence initialize it if necessary. */
222 if (!DEVICE(u)->sysfs) {
225 if (!(DEVICE(u)->sysfs = strdup(sysfs))) {
230 if (!m->devices_by_sysfs)
231 if (!(m->devices_by_sysfs = hashmap_new(string_hash_func, string_compare_func))) {
236 first = hashmap_get(m->devices_by_sysfs, sysfs);
237 LIST_PREPEND(same_sysfs, first, DEVICE(u));
239 r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first);
244 if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) ||
245 (model = udev_device_get_property_value(dev, "ID_MODEL"))) {
246 r = unit_set_description(u, model);
250 r = unit_set_description(u, path);
256 /* The additional systemd udev properties we only
257 * interpret for the main object */
258 const char *wants, *alias;
260 alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS");
265 FOREACH_WORD_QUOTED(w, l, alias, state) {
266 _cleanup_free_ char *e;
275 device_update_unit(m, dev, e, false);
277 log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, e);
281 wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS");
286 FOREACH_WORD_QUOTED(w, l, wants, state) {
287 _cleanup_free_ char *e, *n = NULL;
295 n = unit_name_mangle(e);
301 r = unit_add_dependency_by_name(u, UNIT_WANTS, n, NULL, true);
308 unit_add_to_dbus_queue(u);
312 log_warning("Failed to load device unit: %s", strerror(-r));
320 static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) {
321 const char *sysfs, *dn;
322 struct udev_list_entry *item = NULL, *first = NULL;
327 if (!(sysfs = udev_device_get_syspath(dev)))
330 /* Add the main unit named after the sysfs path */
331 r = device_update_unit(m, dev, sysfs, true);
335 /* Add an additional unit for the device node */
336 if ((dn = udev_device_get_devnode(dev)))
337 device_update_unit(m, dev, dn, false);
339 /* Add additional units for all symlinks */
340 first = udev_device_get_devlinks_list_entry(dev);
341 udev_list_entry_foreach(item, first) {
345 /* Don't bother with the /dev/block links */
346 p = udev_list_entry_get_name(item);
348 if (path_startswith(p, "/dev/block/") ||
349 path_startswith(p, "/dev/char/"))
352 /* Verify that the symlink in the FS actually belongs
353 * to this device. This is useful to deal with
354 * conflicting devices, e.g. when two disks want the
355 * same /dev/disk/by-label/xxx link because they have
356 * the same label. We want to make sure that the same
357 * device that won the symlink wins in systemd, so we
358 * check the device node major/minor*/
359 if (stat(p, &st) >= 0)
360 if ((!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode)) ||
361 st.st_rdev != udev_device_get_devnum(dev))
364 device_update_unit(m, dev, p, false);
370 manager_dispatch_load_queue(m);
372 l = hashmap_get(m->devices_by_sysfs, sysfs);
373 LIST_FOREACH(same_sysfs, d, l)
374 device_set_state(d, DEVICE_PLUGGED);
380 static int device_process_path(Manager *m, const char *path, bool update_state) {
382 struct udev_device *dev;
387 if (!(dev = udev_device_new_from_syspath(m->udev, path))) {
388 log_warning("Failed to get udev device object from udev for path %s.", path);
392 r = device_process_new_device(m, dev, update_state);
393 udev_device_unref(dev);
397 static int device_process_removed_device(Manager *m, struct udev_device *dev) {
404 if (!(sysfs = udev_device_get_syspath(dev)))
407 /* Remove all units of this sysfs path */
408 while ((d = hashmap_get(m->devices_by_sysfs, sysfs))) {
409 device_unset_sysfs(d);
410 device_set_state(d, DEVICE_DEAD);
416 static Unit *device_following(Unit *u) {
417 Device *d = DEVICE(u);
418 Device *other, *first = NULL;
422 if (startswith(u->id, "sys-"))
425 /* Make everybody follow the unit that's named after the sysfs path */
426 for (other = d->same_sysfs_next; other; other = other->same_sysfs_next)
427 if (startswith(UNIT(other)->id, "sys-"))
430 for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev) {
431 if (startswith(UNIT(other)->id, "sys-"))
440 static int device_following_set(Unit *u, Set **_s) {
441 Device *d = DEVICE(u);
449 if (!d->same_sysfs_prev && !d->same_sysfs_next) {
454 if (!(s = set_new(NULL, NULL)))
457 for (other = d->same_sysfs_next; other; other = other->same_sysfs_next)
458 if ((r = set_put(s, other)) < 0)
461 for (other = d->same_sysfs_prev; other; other = other->same_sysfs_prev)
462 if ((r = set_put(s, other)) < 0)
473 static void device_shutdown(Manager *m) {
476 if (m->udev_monitor) {
477 udev_monitor_unref(m->udev_monitor);
478 m->udev_monitor = NULL;
486 hashmap_free(m->devices_by_sysfs);
487 m->devices_by_sysfs = NULL;
490 static int device_enumerate(Manager *m) {
492 struct udev_enumerate *e = NULL;
493 struct udev_list_entry *item = NULL, *first = NULL;
498 struct epoll_event ev;
500 if (!(m->udev = udev_new()))
503 if (!(m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev"))) {
508 /* This will fail if we are unprivileged, but that
509 * should not matter much, as user instances won't run
511 udev_monitor_set_receive_buffer_size(m->udev_monitor, 128*1024*1024);
513 if (udev_monitor_filter_add_match_tag(m->udev_monitor, "systemd") < 0) {
518 if (udev_monitor_enable_receiving(m->udev_monitor) < 0) {
523 m->udev_watch.type = WATCH_UDEV;
524 m->udev_watch.fd = udev_monitor_get_fd(m->udev_monitor);
528 ev.data.ptr = &m->udev_watch;
530 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_watch.fd, &ev) < 0)
534 if (!(e = udev_enumerate_new(m->udev))) {
538 if (udev_enumerate_add_match_tag(e, "systemd") < 0) {
543 if (udev_enumerate_scan_devices(e) < 0) {
548 first = udev_enumerate_get_list_entry(e);
549 udev_list_entry_foreach(item, first)
550 device_process_path(m, udev_list_entry_get_name(item), false);
552 udev_enumerate_unref(e);
557 udev_enumerate_unref(e);
563 void device_fd_event(Manager *m, int events) {
564 struct udev_device *dev;
566 const char *action, *ready;
570 if (events != EPOLLIN) {
571 static RATELIMIT_DEFINE(limit, 10*USEC_PER_SEC, 5);
573 if (!ratelimit_test(&limit))
574 log_error("Failed to get udev event: %m");
575 if (!(events & EPOLLIN))
579 if (!(dev = udev_monitor_receive_device(m->udev_monitor))) {
581 * libudev might filter-out devices which pass the bloom filter,
582 * so getting NULL here is not necessarily an error
587 if (!(action = udev_device_get_action(dev))) {
588 log_error("Failed to get udev action string.");
592 ready = udev_device_get_property_value(dev, "SYSTEMD_READY");
594 if (streq(action, "remove") || (ready && parse_boolean(ready) == 0)) {
595 if ((r = device_process_removed_device(m, dev)) < 0) {
596 log_error("Failed to process udev device event: %s", strerror(-r));
600 if ((r = device_process_new_device(m, dev, true)) < 0) {
601 log_error("Failed to process udev device event: %s", strerror(-r));
607 udev_device_unref(dev);
610 static const char* const device_state_table[_DEVICE_STATE_MAX] = {
611 [DEVICE_DEAD] = "dead",
612 [DEVICE_PLUGGED] = "plugged"
615 DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState);
617 const UnitVTable device_vtable = {
618 .object_size = sizeof(Device),
624 .no_instances = true,
628 .load = unit_load_fragment_and_dropin_optional,
630 .coldplug = device_coldplug,
634 .active_state = device_active_state,
635 .sub_state_to_string = device_sub_state_to_string,
637 .bus_interface = "org.freedesktop.systemd1.Device",
638 .bus_message_handler = bus_device_message_handler,
639 .bus_invalidating_properties = bus_device_invalidating_properties,
641 .following = device_following,
642 .following_set = device_following_set,
644 .enumerate = device_enumerate,
645 .shutdown = device_shutdown,
647 .status_message_formats = {
648 .starting_stopping = {
649 [0] = "Expecting device %s...",
651 .finished_start_job = {
652 [JOB_DONE] = "Found device %s.",
653 [JOB_TIMEOUT] = "Timed out waiting for device %s.",