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
) {
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
&& d
->deserialized_state
!= DEVICE_PLUGGED
)
153 /* If a device is found in /proc/self/mountinfo or
154 * /proc/swaps, and was not yet announced via udev,
155 * it's "tentatively" around. */
156 device_set_state(d
, DEVICE_TENTATIVE
);
161 static int device_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
162 Device
*d
= DEVICE(u
);
168 unit_serialize_item(u
, f
, "state", device_state_to_string(d
->state
));
171 static int device_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
172 Device
*d
= DEVICE(u
);
179 if (streq(key
, "state")) {
182 state
= device_state_from_string(value
);
184 log_unit_debug(u
->id
, "Failed to parse state value %s", value
);
186 d
->deserialized_state
= state
;
188 log_unit_debug(u
->id
, "Unknown serialization key '%s'", key
);
193 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
194 Device
*d
= DEVICE(u
);
199 "%sDevice State: %s\n"
200 "%sSysfs Path: %s\n",
201 prefix
, device_state_to_string(d
->state
),
202 prefix
, strna(d
->sysfs
));
205 _pure_
static UnitActiveState
device_active_state(Unit
*u
) {
208 return state_translation_table
[DEVICE(u
)->state
];
211 _pure_
static const char *device_sub_state_to_string(Unit
*u
) {
214 return device_state_to_string(DEVICE(u
)->state
);
217 static int device_update_description(Unit
*u
, struct udev_device
*dev
, const char *path
) {
225 model
= udev_device_get_property_value(dev
, "ID_MODEL_FROM_DATABASE");
227 model
= udev_device_get_property_value(dev
, "ID_MODEL");
232 /* Try to concatenate the device model string with a label, if there is one */
233 label
= udev_device_get_property_value(dev
, "ID_FS_LABEL");
235 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NAME");
237 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NUMBER");
240 _cleanup_free_
char *j
;
242 j
= strjoin(model
, " ", label
, NULL
);
244 r
= unit_set_description(u
, j
);
248 r
= unit_set_description(u
, model
);
250 r
= unit_set_description(u
, path
);
253 log_unit_error_errno(u
->id
, r
, "Failed to set device description: %m");
258 static int device_add_udev_wants(Unit
*u
, struct udev_device
*dev
) {
260 const char *word
, *state
;
263 const char *property
;
268 property
= u
->manager
->running_as
== SYSTEMD_USER
? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
269 wants
= udev_device_get_property_value(dev
, property
);
273 FOREACH_WORD_QUOTED(word
, l
, wants
, state
) {
274 _cleanup_free_
char *n
= NULL
;
280 n
= unit_name_mangle(e
, MANGLE_NOGLOB
);
284 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, n
, NULL
, true);
286 return log_unit_error_errno(u
->id
, r
, "Failed to add wants dependency: %m");
289 log_unit_warning(u
->id
, "Property %s on %s has trailing garbage, ignoring.", property
, strna(udev_device_get_syspath(dev
)));
294 static int device_setup_unit(Manager
*m
, struct udev_device
*dev
, const char *path
, bool main
) {
295 _cleanup_free_
char *e
= NULL
;
305 sysfs
= udev_device_get_syspath(dev
);
309 e
= unit_name_from_path(path
, ".device");
313 u
= manager_get_unit(m
, e
);
317 !path_equal(DEVICE(u
)->sysfs
, sysfs
)) {
318 log_unit_debug(u
->id
, "Device %s appeared twice with different sysfs paths %s and %s", e
, DEVICE(u
)->sysfs
, sysfs
);
325 u
= unit_new(m
, sizeof(Device
));
329 r
= unit_add_name(u
, e
);
333 unit_add_to_load_queue(u
);
337 /* If this was created via some dependency and has not
338 * actually been seen yet ->sysfs will not be
339 * initialized. Hence initialize it if necessary. */
341 r
= device_set_sysfs(DEVICE(u
), sysfs
);
345 (void) device_update_description(u
, dev
, path
);
347 /* The additional systemd udev properties we only interpret
348 * for the main object */
350 (void) device_add_udev_wants(u
, dev
);
352 /* Note that this won't dispatch the load queue, the caller
353 * has to do that if needed and appropriate */
355 unit_add_to_dbus_queue(u
);
359 log_unit_warning_errno(u
->id
, r
, "Failed to set up device unit: %m");
367 static int device_process_new(Manager
*m
, struct udev_device
*dev
) {
368 const char *sysfs
, *dn
, *alias
;
369 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
374 sysfs
= udev_device_get_syspath(dev
);
378 /* Add the main unit named after the sysfs path */
379 r
= device_setup_unit(m
, dev
, sysfs
, true);
383 /* Add an additional unit for the device node */
384 dn
= udev_device_get_devnode(dev
);
386 (void) device_setup_unit(m
, dev
, dn
, false);
388 /* Add additional units for all symlinks */
389 first
= udev_device_get_devlinks_list_entry(dev
);
390 udev_list_entry_foreach(item
, first
) {
394 /* Don't bother with the /dev/block links */
395 p
= udev_list_entry_get_name(item
);
397 if (path_startswith(p
, "/dev/block/") ||
398 path_startswith(p
, "/dev/char/"))
401 /* Verify that the symlink in the FS actually belongs
402 * to this device. This is useful to deal with
403 * conflicting devices, e.g. when two disks want the
404 * same /dev/disk/by-label/xxx link because they have
405 * the same label. We want to make sure that the same
406 * device that won the symlink wins in systemd, so we
407 * check the device node major/minor */
408 if (stat(p
, &st
) >= 0)
409 if ((!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
)) ||
410 st
.st_rdev
!= udev_device_get_devnum(dev
))
413 (void) device_setup_unit(m
, dev
, p
, false);
416 /* Add additional units for all explicitly configured
418 alias
= udev_device_get_property_value(dev
, "SYSTEMD_ALIAS");
420 const char *word
, *state
;
423 FOREACH_WORD_QUOTED(word
, l
, alias
, state
) {
429 if (path_is_absolute(e
))
430 (void) device_setup_unit(m
, dev
, e
, false);
432 log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs
, e
);
435 log_warning("SYSTEMD_ALIAS for %s has trailing garbage, ignoring.", sysfs
);
441 static void device_update_found_one(Device
*d
, bool add
, DeviceFound found
, bool now
) {
442 DeviceFound n
, previous
;
446 n
= add
? (d
->found
| found
) : (d
->found
& ~found
);
456 if (d
->found
& DEVICE_FOUND_UDEV
)
457 /* When the device is known to udev we consider it
459 device_set_state(d
, DEVICE_PLUGGED
);
460 else if (d
->found
!= DEVICE_NOT_FOUND
&& (previous
& DEVICE_FOUND_UDEV
) == 0)
461 /* If the device has not been seen by udev yet, but is
462 * now referenced by the kernel, then we assume the
463 * kernel knows it now, and udev might soon too. */
464 device_set_state(d
, DEVICE_TENTATIVE
);
466 /* If nobody sees the device, or if the device was
467 * previously seen by udev and now is only referenced
468 * from the kernel, then we consider the device is
469 * gone, the kernel just hasn't noticed it yet. */
470 device_set_state(d
, DEVICE_DEAD
);
473 static int device_update_found_by_sysfs(Manager
*m
, const char *sysfs
, bool add
, DeviceFound found
, bool now
) {
479 if (found
== DEVICE_NOT_FOUND
)
482 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
483 LIST_FOREACH(same_sysfs
, d
, l
)
484 device_update_found_one(d
, add
, found
, now
);
489 static int device_update_found_by_name(Manager
*m
, const char *path
, bool add
, DeviceFound found
, bool now
) {
490 _cleanup_free_
char *e
= NULL
;
496 if (found
== DEVICE_NOT_FOUND
)
499 e
= unit_name_from_path(path
, ".device");
503 u
= manager_get_unit(m
, e
);
507 device_update_found_one(DEVICE(u
), add
, found
, now
);
511 static bool device_is_ready(struct udev_device
*dev
) {
516 ready
= udev_device_get_property_value(dev
, "SYSTEMD_READY");
520 return parse_boolean(ready
) != 0;
523 static Unit
*device_following(Unit
*u
) {
524 Device
*d
= DEVICE(u
);
525 Device
*other
, *first
= NULL
;
529 if (startswith(u
->id
, "sys-"))
532 /* Make everybody follow the unit that's named after the sysfs path */
533 for (other
= d
->same_sysfs_next
; other
; other
= other
->same_sysfs_next
)
534 if (startswith(UNIT(other
)->id
, "sys-"))
537 for (other
= d
->same_sysfs_prev
; other
; other
= other
->same_sysfs_prev
) {
538 if (startswith(UNIT(other
)->id
, "sys-"))
547 static int device_following_set(Unit
*u
, Set
**_set
) {
548 Device
*d
= DEVICE(u
), *other
;
555 if (LIST_JUST_US(same_sysfs
, d
)) {
564 LIST_FOREACH_AFTER(same_sysfs
, other
, d
) {
565 r
= set_put(set
, other
);
570 LIST_FOREACH_BEFORE(same_sysfs
, other
, d
) {
571 r
= set_put(set
, other
);
584 static void device_shutdown(Manager
*m
) {
587 m
->udev_event_source
= sd_event_source_unref(m
->udev_event_source
);
589 if (m
->udev_monitor
) {
590 udev_monitor_unref(m
->udev_monitor
);
591 m
->udev_monitor
= NULL
;
594 hashmap_free(m
->devices_by_sysfs
);
595 m
->devices_by_sysfs
= NULL
;
598 static int device_enumerate(Manager
*m
) {
599 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
600 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
605 if (!m
->udev_monitor
) {
606 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
607 if (!m
->udev_monitor
) {
612 /* This will fail if we are unprivileged, but that
613 * should not matter much, as user instances won't run
615 (void) udev_monitor_set_receive_buffer_size(m
->udev_monitor
, 128*1024*1024);
617 r
= udev_monitor_filter_add_match_tag(m
->udev_monitor
, "systemd");
621 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
625 r
= sd_event_add_io(m
->event
, &m
->udev_event_source
, udev_monitor_get_fd(m
->udev_monitor
), EPOLLIN
, device_dispatch_io
, m
);
630 e
= udev_enumerate_new(m
->udev
);
636 r
= udev_enumerate_add_match_tag(e
, "systemd");
640 r
= udev_enumerate_add_match_is_initialized(e
);
644 r
= udev_enumerate_scan_devices(e
);
648 first
= udev_enumerate_get_list_entry(e
);
649 udev_list_entry_foreach(item
, first
) {
650 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
653 sysfs
= udev_list_entry_get_name(item
);
655 dev
= udev_device_new_from_syspath(m
->udev
, sysfs
);
661 if (!device_is_ready(dev
))
664 (void) device_process_new(m
, dev
);
666 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, false);
672 log_error_errno(r
, "Failed to enumerate devices: %m");
678 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
679 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
680 Manager
*m
= userdata
;
681 const char *action
, *sysfs
;
686 if (revents
!= EPOLLIN
) {
687 static RATELIMIT_DEFINE(limit
, 10*USEC_PER_SEC
, 5);
689 if (!ratelimit_test(&limit
))
690 log_error_errno(errno
, "Failed to get udev event: %m");
691 if (!(revents
& EPOLLIN
))
696 * libudev might filter-out devices which pass the bloom
697 * filter, so getting NULL here is not necessarily an error.
699 dev
= udev_monitor_receive_device(m
->udev_monitor
);
703 sysfs
= udev_device_get_syspath(dev
);
705 log_error("Failed to get udev sys path.");
709 action
= udev_device_get_action(dev
);
711 log_error("Failed to get udev action string.");
715 if (streq(action
, "remove")) {
716 r
= swap_process_device_remove(m
, dev
);
718 log_error_errno(r
, "Failed to process swap device remove event: %m");
720 /* If we get notified that a device was removed by
721 * udev, then it's completely gone, hence unset all
723 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
|DEVICE_FOUND_MOUNT
|DEVICE_FOUND_SWAP
, true);
725 } else if (device_is_ready(dev
)) {
727 (void) device_process_new(m
, dev
);
729 r
= swap_process_device_new(m
, dev
);
731 log_error_errno(r
, "Failed to process swap device new event: %m");
733 manager_dispatch_load_queue(m
);
735 /* The device is found now, set the udev found bit */
736 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, true);
739 /* The device is nominally around, but not ready for
740 * us. Hence unset the udev bit, but leave the rest
743 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
, true);
749 static bool device_supported(Manager
*m
) {
750 static int read_only
= -1;
753 /* If /sys is read-only we don't support device units, and any
754 * attempts to start one should fail immediately. */
757 read_only
= path_is_read_only_fs("/sys");
759 return read_only
<= 0;
762 int device_found_node(Manager
*m
, const char *node
, bool add
, DeviceFound found
, bool now
) {
763 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
769 /* This is called whenever we find a device referenced in
770 * /proc/swaps or /proc/self/mounts. Such a device might be
771 * mounted/enabled at a time where udev has not finished
772 * probing it yet, and we thus haven't learned about it
773 * yet. In this case we will set the device unit to
774 * "tentative" state. */
777 if (!path_startswith(node
, "/dev"))
780 /* We make an extra check here, if the device node
781 * actually exists. If it's missing, then this is an
782 * indication that device was unplugged but is still
783 * referenced in /proc/swaps or
784 * /proc/self/mountinfo. Note that this check doesn't
785 * really cover all cases where a device might be gone
786 * away, since drives that can have a medium inserted
787 * will still have a device node even when the medium
790 if (stat(node
, &st
) < 0) {
794 return log_error_errno(errno
, "Failed to stat device node file %s: %m", node
);
797 if (!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
800 dev
= udev_device_new_from_devnum(m
->udev
, S_ISBLK(st
.st_mode
) ? 'b' : 'c', st
.st_rdev
);
808 /* If the device is known in the kernel and newly
809 * appeared, then we'll create a device unit for it,
810 * under the name referenced in /proc/swaps or
811 * /proc/self/mountinfo. */
813 (void) device_setup_unit(m
, dev
, node
, false);
816 /* Update the device unit's state, should it exist */
817 return device_update_found_by_name(m
, node
, add
, found
, now
);
820 static const char* const device_state_table
[_DEVICE_STATE_MAX
] = {
821 [DEVICE_DEAD
] = "dead",
822 [DEVICE_TENTATIVE
] = "tentative",
823 [DEVICE_PLUGGED
] = "plugged",
826 DEFINE_STRING_TABLE_LOOKUP(device_state
, DeviceState
);
828 const UnitVTable device_vtable
= {
829 .object_size
= sizeof(Device
),
835 .no_instances
= true,
839 .load
= unit_load_fragment_and_dropin_optional
,
841 .coldplug
= device_coldplug
,
843 .serialize
= device_serialize
,
844 .deserialize_item
= device_deserialize_item
,
848 .active_state
= device_active_state
,
849 .sub_state_to_string
= device_sub_state_to_string
,
851 .bus_interface
= "org.freedesktop.systemd1.Device",
852 .bus_vtable
= bus_device_vtable
,
854 .following
= device_following
,
855 .following_set
= device_following_set
,
857 .enumerate
= device_enumerate
,
858 .shutdown
= device_shutdown
,
859 .supported
= device_supported
,
861 .status_message_formats
= {
862 .starting_stopping
= {
863 [0] = "Expecting device %s...",
865 .finished_start_job
= {
866 [JOB_DONE
] = "Found device %s.",
867 [JOB_TIMEOUT
] = "Timed out waiting for device %s.",