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>
25 #include "alloc-util.h"
26 #include "dbus-device.h"
30 #include "parse-util.h"
31 #include "path-util.h"
32 #include "stat-util.h"
33 #include "string-util.h"
35 #include "udev-util.h"
36 #include "unit-name.h"
39 static const UnitActiveState state_translation_table
[_DEVICE_STATE_MAX
] = {
40 [DEVICE_DEAD
] = UNIT_INACTIVE
,
41 [DEVICE_TENTATIVE
] = UNIT_ACTIVATING
,
42 [DEVICE_PLUGGED
] = UNIT_ACTIVE
,
45 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
47 static void device_unset_sysfs(Device
*d
) {
56 /* Remove this unit from the chain of devices which share the
58 devices
= UNIT(d
)->manager
->devices_by_sysfs
;
59 first
= hashmap_get(devices
, d
->sysfs
);
60 LIST_REMOVE(same_sysfs
, first
, d
);
63 hashmap_remove_and_replace(devices
, d
->sysfs
, first
->sysfs
, first
);
65 hashmap_remove(devices
, d
->sysfs
);
67 d
->sysfs
= mfree(d
->sysfs
);
70 static int device_set_sysfs(Device
*d
, const char *sysfs
) {
77 if (streq_ptr(d
->sysfs
, sysfs
))
80 r
= hashmap_ensure_allocated(&UNIT(d
)->manager
->devices_by_sysfs
, &string_hash_ops
);
88 device_unset_sysfs(d
);
90 first
= hashmap_get(UNIT(d
)->manager
->devices_by_sysfs
, sysfs
);
91 LIST_PREPEND(same_sysfs
, first
, d
);
93 r
= hashmap_replace(UNIT(d
)->manager
->devices_by_sysfs
, copy
, first
);
95 LIST_REMOVE(same_sysfs
, first
, d
);
105 static void device_init(Unit
*u
) {
106 Device
*d
= DEVICE(u
);
109 assert(UNIT(d
)->load_state
== UNIT_STUB
);
111 /* In contrast to all other unit types we timeout jobs waiting
112 * for devices by default. This is because they otherwise wait
113 * indefinitely for plugged in devices, something which cannot
114 * happen for the other units since their operations time out
116 u
->job_timeout
= u
->manager
->default_timeout_start_usec
;
118 u
->ignore_on_isolate
= true;
121 static void device_done(Unit
*u
) {
122 Device
*d
= DEVICE(u
);
126 device_unset_sysfs(d
);
129 static void device_set_state(Device
*d
, DeviceState state
) {
130 DeviceState old_state
;
133 old_state
= d
->state
;
136 if (state
!= old_state
)
137 log_unit_debug(UNIT(d
), "Changed %s -> %s", device_state_to_string(old_state
), device_state_to_string(state
));
139 unit_notify(UNIT(d
), state_translation_table
[old_state
], state_translation_table
[state
], true);
142 static int device_coldplug(Unit
*u
) {
143 Device
*d
= DEVICE(u
);
146 assert(d
->state
== DEVICE_DEAD
);
148 if (d
->found
& DEVICE_FOUND_UDEV
)
149 /* If udev says the device is around, it's around */
150 device_set_state(d
, DEVICE_PLUGGED
);
151 else if (d
->found
!= DEVICE_NOT_FOUND
&& d
->deserialized_state
!= DEVICE_PLUGGED
)
152 /* If a device is found in /proc/self/mountinfo or
153 * /proc/swaps, and was not yet announced via udev,
154 * it's "tentatively" around. */
155 device_set_state(d
, DEVICE_TENTATIVE
);
160 static int device_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
161 Device
*d
= DEVICE(u
);
167 unit_serialize_item(u
, f
, "state", device_state_to_string(d
->state
));
172 static int device_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
173 Device
*d
= DEVICE(u
);
180 if (streq(key
, "state")) {
183 state
= device_state_from_string(value
);
185 log_unit_debug(u
, "Failed to parse state value: %s", value
);
187 d
->deserialized_state
= state
;
189 log_unit_debug(u
, "Unknown serialization key: %s", key
);
194 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
195 Device
*d
= DEVICE(u
);
200 "%sDevice State: %s\n"
201 "%sSysfs Path: %s\n",
202 prefix
, device_state_to_string(d
->state
),
203 prefix
, strna(d
->sysfs
));
206 _pure_
static UnitActiveState
device_active_state(Unit
*u
) {
209 return state_translation_table
[DEVICE(u
)->state
];
212 _pure_
static const char *device_sub_state_to_string(Unit
*u
) {
215 return device_state_to_string(DEVICE(u
)->state
);
218 static int device_update_description(Unit
*u
, struct udev_device
*dev
, const char *path
) {
226 model
= udev_device_get_property_value(dev
, "ID_MODEL_FROM_DATABASE");
228 model
= udev_device_get_property_value(dev
, "ID_MODEL");
233 /* Try to concatenate the device model string with a label, if there is one */
234 label
= udev_device_get_property_value(dev
, "ID_FS_LABEL");
236 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NAME");
238 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NUMBER");
241 _cleanup_free_
char *j
;
243 j
= strjoin(model
, " ", label
, NULL
);
245 r
= unit_set_description(u
, j
);
249 r
= unit_set_description(u
, model
);
251 r
= unit_set_description(u
, path
);
254 log_unit_error_errno(u
, r
, "Failed to set device description: %m");
259 static int device_add_udev_wants(Unit
*u
, struct udev_device
*dev
) {
261 const char *word
, *state
;
264 const char *property
;
269 property
= u
->manager
->running_as
== MANAGER_USER
? "MANAGER_USER_WANTS" : "SYSTEMD_WANTS";
270 wants
= udev_device_get_property_value(dev
, property
);
274 FOREACH_WORD_QUOTED(word
, l
, wants
, state
) {
275 _cleanup_free_
char *n
= NULL
;
281 r
= unit_name_mangle(e
, UNIT_NAME_NOGLOB
, &n
);
283 return log_unit_error_errno(u
, r
, "Failed to mangle unit name: %m");
285 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, n
, NULL
, true);
287 return log_unit_error_errno(u
, r
, "Failed to add wants dependency: %m");
290 log_unit_warning(u
, "Property %s on %s has trailing garbage, ignoring.", property
, strna(udev_device_get_syspath(dev
)));
295 static int device_setup_unit(Manager
*m
, struct udev_device
*dev
, const char *path
, bool main
) {
296 _cleanup_free_
char *e
= NULL
;
297 const char *sysfs
= NULL
;
306 sysfs
= udev_device_get_syspath(dev
);
311 r
= unit_name_from_path(path
, ".device", &e
);
313 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
315 u
= manager_get_unit(m
, e
);
320 !path_equal(DEVICE(u
)->sysfs
, sysfs
)) {
321 log_unit_debug(u
, "Device %s appeared twice with different sysfs paths %s and %s", e
, DEVICE(u
)->sysfs
, sysfs
);
328 u
= unit_new(m
, sizeof(Device
));
332 r
= unit_add_name(u
, e
);
336 unit_add_to_load_queue(u
);
340 /* If this was created via some dependency and has not
341 * actually been seen yet ->sysfs will not be
342 * initialized. Hence initialize it if necessary. */
344 r
= device_set_sysfs(DEVICE(u
), sysfs
);
348 (void) device_update_description(u
, dev
, path
);
350 /* The additional systemd udev properties we only interpret
351 * for the main object */
353 (void) device_add_udev_wants(u
, dev
);
357 /* Note that this won't dispatch the load queue, the caller
358 * has to do that if needed and appropriate */
360 unit_add_to_dbus_queue(u
);
364 log_unit_warning_errno(u
, r
, "Failed to set up device unit: %m");
372 static int device_process_new(Manager
*m
, struct udev_device
*dev
) {
373 const char *sysfs
, *dn
, *alias
;
374 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
379 sysfs
= udev_device_get_syspath(dev
);
383 /* Add the main unit named after the sysfs path */
384 r
= device_setup_unit(m
, dev
, sysfs
, true);
388 /* Add an additional unit for the device node */
389 dn
= udev_device_get_devnode(dev
);
391 (void) device_setup_unit(m
, dev
, dn
, false);
393 /* Add additional units for all symlinks */
394 first
= udev_device_get_devlinks_list_entry(dev
);
395 udev_list_entry_foreach(item
, first
) {
399 /* Don't bother with the /dev/block links */
400 p
= udev_list_entry_get_name(item
);
402 if (path_startswith(p
, "/dev/block/") ||
403 path_startswith(p
, "/dev/char/"))
406 /* Verify that the symlink in the FS actually belongs
407 * to this device. This is useful to deal with
408 * conflicting devices, e.g. when two disks want the
409 * same /dev/disk/by-label/xxx link because they have
410 * the same label. We want to make sure that the same
411 * device that won the symlink wins in systemd, so we
412 * check the device node major/minor */
413 if (stat(p
, &st
) >= 0)
414 if ((!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
)) ||
415 st
.st_rdev
!= udev_device_get_devnum(dev
))
418 (void) device_setup_unit(m
, dev
, p
, false);
421 /* Add additional units for all explicitly configured
423 alias
= udev_device_get_property_value(dev
, "SYSTEMD_ALIAS");
425 const char *word
, *state
;
428 FOREACH_WORD_QUOTED(word
, l
, alias
, state
) {
434 if (path_is_absolute(e
))
435 (void) device_setup_unit(m
, dev
, e
, false);
437 log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs
, e
);
440 log_warning("SYSTEMD_ALIAS for %s has trailing garbage, ignoring.", sysfs
);
446 static void device_update_found_one(Device
*d
, bool add
, DeviceFound found
, bool now
) {
447 DeviceFound n
, previous
;
451 n
= add
? (d
->found
| found
) : (d
->found
& ~found
);
461 if (d
->found
& DEVICE_FOUND_UDEV
)
462 /* When the device is known to udev we consider it
464 device_set_state(d
, DEVICE_PLUGGED
);
465 else if (d
->found
!= DEVICE_NOT_FOUND
&& (previous
& DEVICE_FOUND_UDEV
) == 0)
466 /* If the device has not been seen by udev yet, but is
467 * now referenced by the kernel, then we assume the
468 * kernel knows it now, and udev might soon too. */
469 device_set_state(d
, DEVICE_TENTATIVE
);
471 /* If nobody sees the device, or if the device was
472 * previously seen by udev and now is only referenced
473 * from the kernel, then we consider the device is
474 * gone, the kernel just hasn't noticed it yet. */
475 device_set_state(d
, DEVICE_DEAD
);
478 static int device_update_found_by_sysfs(Manager
*m
, const char *sysfs
, bool add
, DeviceFound found
, bool now
) {
484 if (found
== DEVICE_NOT_FOUND
)
487 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
488 LIST_FOREACH(same_sysfs
, d
, l
)
489 device_update_found_one(d
, add
, found
, now
);
494 static int device_update_found_by_name(Manager
*m
, const char *path
, bool add
, DeviceFound found
, bool now
) {
495 _cleanup_free_
char *e
= NULL
;
502 if (found
== DEVICE_NOT_FOUND
)
505 r
= unit_name_from_path(path
, ".device", &e
);
507 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
509 u
= manager_get_unit(m
, e
);
513 device_update_found_one(DEVICE(u
), add
, found
, now
);
517 static bool device_is_ready(struct udev_device
*dev
) {
522 ready
= udev_device_get_property_value(dev
, "SYSTEMD_READY");
526 return parse_boolean(ready
) != 0;
529 static Unit
*device_following(Unit
*u
) {
530 Device
*d
= DEVICE(u
);
531 Device
*other
, *first
= NULL
;
535 if (startswith(u
->id
, "sys-"))
538 /* Make everybody follow the unit that's named after the sysfs path */
539 for (other
= d
->same_sysfs_next
; other
; other
= other
->same_sysfs_next
)
540 if (startswith(UNIT(other
)->id
, "sys-"))
543 for (other
= d
->same_sysfs_prev
; other
; other
= other
->same_sysfs_prev
) {
544 if (startswith(UNIT(other
)->id
, "sys-"))
553 static int device_following_set(Unit
*u
, Set
**_set
) {
554 Device
*d
= DEVICE(u
), *other
;
561 if (LIST_JUST_US(same_sysfs
, d
)) {
570 LIST_FOREACH_AFTER(same_sysfs
, other
, d
) {
571 r
= set_put(set
, other
);
576 LIST_FOREACH_BEFORE(same_sysfs
, other
, d
) {
577 r
= set_put(set
, other
);
590 static void device_shutdown(Manager
*m
) {
593 m
->udev_event_source
= sd_event_source_unref(m
->udev_event_source
);
595 if (m
->udev_monitor
) {
596 udev_monitor_unref(m
->udev_monitor
);
597 m
->udev_monitor
= NULL
;
600 m
->devices_by_sysfs
= hashmap_free(m
->devices_by_sysfs
);
603 static void device_enumerate(Manager
*m
) {
604 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
605 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
610 if (!m
->udev_monitor
) {
611 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
612 if (!m
->udev_monitor
) {
617 /* This will fail if we are unprivileged, but that
618 * should not matter much, as user instances won't run
620 (void) udev_monitor_set_receive_buffer_size(m
->udev_monitor
, 128*1024*1024);
622 r
= udev_monitor_filter_add_match_tag(m
->udev_monitor
, "systemd");
624 log_error_errno(r
, "Failed to add udev tag match: %m");
628 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
630 log_error_errno(r
, "Failed to enable udev event reception: %m");
634 r
= sd_event_add_io(m
->event
, &m
->udev_event_source
, udev_monitor_get_fd(m
->udev_monitor
), EPOLLIN
, device_dispatch_io
, m
);
636 log_error_errno(r
, "Failed to watch udev file descriptor: %m");
640 (void) sd_event_source_set_description(m
->udev_event_source
, "device");
643 e
= udev_enumerate_new(m
->udev
);
649 r
= udev_enumerate_add_match_tag(e
, "systemd");
651 log_error_errno(r
, "Failed to create udev tag enumeration: %m");
655 r
= udev_enumerate_add_match_is_initialized(e
);
657 log_error_errno(r
, "Failed to install initialization match into enumeration: %m");
661 r
= udev_enumerate_scan_devices(e
);
663 log_error_errno(r
, "Failed to enumerate devices: %m");
667 first
= udev_enumerate_get_list_entry(e
);
668 udev_list_entry_foreach(item
, first
) {
669 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
672 sysfs
= udev_list_entry_get_name(item
);
674 dev
= udev_device_new_from_syspath(m
->udev
, sysfs
);
680 if (!device_is_ready(dev
))
683 (void) device_process_new(m
, dev
);
685 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, false);
694 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
695 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
696 Manager
*m
= userdata
;
697 const char *action
, *sysfs
;
702 if (revents
!= EPOLLIN
) {
703 static RATELIMIT_DEFINE(limit
, 10*USEC_PER_SEC
, 5);
705 if (!ratelimit_test(&limit
))
706 log_error_errno(errno
, "Failed to get udev event: %m");
707 if (!(revents
& EPOLLIN
))
712 * libudev might filter-out devices which pass the bloom
713 * filter, so getting NULL here is not necessarily an error.
715 dev
= udev_monitor_receive_device(m
->udev_monitor
);
719 sysfs
= udev_device_get_syspath(dev
);
721 log_error("Failed to get udev sys path.");
725 action
= udev_device_get_action(dev
);
727 log_error("Failed to get udev action string.");
731 if (streq(action
, "remove")) {
732 r
= swap_process_device_remove(m
, dev
);
734 log_error_errno(r
, "Failed to process swap device remove event: %m");
736 /* If we get notified that a device was removed by
737 * udev, then it's completely gone, hence unset all
739 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
|DEVICE_FOUND_MOUNT
|DEVICE_FOUND_SWAP
, true);
741 } else if (device_is_ready(dev
)) {
743 (void) device_process_new(m
, dev
);
745 r
= swap_process_device_new(m
, dev
);
747 log_error_errno(r
, "Failed to process swap device new event: %m");
749 manager_dispatch_load_queue(m
);
751 /* The device is found now, set the udev found bit */
752 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, true);
755 /* The device is nominally around, but not ready for
756 * us. Hence unset the udev bit, but leave the rest
759 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
, true);
765 static bool device_supported(void) {
766 static int read_only
= -1;
768 /* If /sys is read-only we don't support device units, and any
769 * attempts to start one should fail immediately. */
772 read_only
= path_is_read_only_fs("/sys");
774 return read_only
<= 0;
777 int device_found_node(Manager
*m
, const char *node
, bool add
, DeviceFound found
, bool now
) {
778 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
784 if (!device_supported())
787 /* This is called whenever we find a device referenced in
788 * /proc/swaps or /proc/self/mounts. Such a device might be
789 * mounted/enabled at a time where udev has not finished
790 * probing it yet, and we thus haven't learned about it
791 * yet. In this case we will set the device unit to
792 * "tentative" state. */
795 if (!path_startswith(node
, "/dev"))
798 /* We make an extra check here, if the device node
799 * actually exists. If it's missing, then this is an
800 * indication that device was unplugged but is still
801 * referenced in /proc/swaps or
802 * /proc/self/mountinfo. Note that this check doesn't
803 * really cover all cases where a device might be gone
804 * away, since drives that can have a medium inserted
805 * will still have a device node even when the medium
808 if (stat(node
, &st
) >= 0) {
809 if (!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
812 dev
= udev_device_new_from_devnum(m
->udev
, S_ISBLK(st
.st_mode
) ? 'b' : 'c', st
.st_rdev
);
813 if (!dev
&& errno
!= ENOENT
)
814 return log_error_errno(errno
, "Failed to get udev device from devnum %u:%u: %m", major(st
.st_rdev
), minor(st
.st_rdev
));
816 } else if (errno
!= ENOENT
)
817 return log_error_errno(errno
, "Failed to stat device node file %s: %m", node
);
819 /* If the device is known in the kernel and newly
820 * appeared, then we'll create a device unit for it,
821 * under the name referenced in /proc/swaps or
822 * /proc/self/mountinfo. */
824 (void) device_setup_unit(m
, dev
, node
, false);
827 /* Update the device unit's state, should it exist */
828 return device_update_found_by_name(m
, node
, add
, found
, now
);
831 const UnitVTable device_vtable
= {
832 .object_size
= sizeof(Device
),
838 .no_instances
= true,
842 .load
= unit_load_fragment_and_dropin_optional
,
844 .coldplug
= device_coldplug
,
846 .serialize
= device_serialize
,
847 .deserialize_item
= device_deserialize_item
,
851 .active_state
= device_active_state
,
852 .sub_state_to_string
= device_sub_state_to_string
,
854 .bus_vtable
= bus_device_vtable
,
856 .following
= device_following
,
857 .following_set
= device_following_set
,
859 .enumerate
= device_enumerate
,
860 .shutdown
= device_shutdown
,
861 .supported
= device_supported
,
863 .status_message_formats
= {
864 .starting_stopping
= {
865 [0] = "Expecting device %s...",
867 .finished_start_job
= {
868 [JOB_DONE
] = "Found device %s.",
869 [JOB_TIMEOUT
] = "Timed out waiting for device %s.",