1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
6 #include "sd-messages.h"
8 #include "alloc-util.h"
9 #include "bus-common-errors.h"
10 #include "dbus-device.h"
11 #include "dbus-unit.h"
12 #include "device-private.h"
13 #include "device-util.h"
16 #include "parse-util.h"
17 #include "path-util.h"
18 #include "ratelimit.h"
19 #include "serialize.h"
20 #include "stat-util.h"
21 #include "string-util.h"
23 #include "udev-util.h"
24 #include "unit-name.h"
27 static const UnitActiveState state_translation_table
[_DEVICE_STATE_MAX
] = {
28 [DEVICE_DEAD
] = UNIT_INACTIVE
,
29 [DEVICE_TENTATIVE
] = UNIT_ACTIVATING
,
30 [DEVICE_PLUGGED
] = UNIT_ACTIVE
,
33 static int device_dispatch_io(sd_device_monitor
*monitor
, sd_device
*dev
, void *userdata
);
35 static int device_by_path(Manager
*m
, const char *path
, Unit
**ret
) {
36 _cleanup_free_
char *e
= NULL
;
43 r
= unit_name_from_path(path
, ".device", &e
);
47 u
= manager_get_unit(m
, e
);
56 static void device_unset_sysfs(Device
*d
) {
64 /* Remove this unit from the chain of devices which share the same sysfs path. */
66 devices
= UNIT(d
)->manager
->devices_by_sysfs
;
68 if (d
->same_sysfs_prev
)
69 /* If this is not the first unit, then simply remove this unit. */
70 d
->same_sysfs_prev
->same_sysfs_next
= d
->same_sysfs_next
;
71 else if (d
->same_sysfs_next
)
72 /* If this is the first unit, replace with the next unit. */
73 assert_se(hashmap_replace(devices
, d
->same_sysfs_next
->sysfs
, d
->same_sysfs_next
) >= 0);
75 /* Otherwise, remove the entry. */
76 hashmap_remove(devices
, d
->sysfs
);
78 if (d
->same_sysfs_next
)
79 d
->same_sysfs_next
->same_sysfs_prev
= d
->same_sysfs_prev
;
81 d
->same_sysfs_prev
= d
->same_sysfs_next
= NULL
;
83 d
->sysfs
= mfree(d
->sysfs
);
86 static int device_set_sysfs(Device
*d
, const char *sysfs
) {
87 _cleanup_free_
char *copy
= NULL
;
93 if (streq_ptr(d
->sysfs
, sysfs
))
96 r
= hashmap_ensure_allocated(&UNIT(d
)->manager
->devices_by_sysfs
, &path_hash_ops
);
100 copy
= strdup(sysfs
);
104 device_unset_sysfs(d
);
106 first
= hashmap_get(UNIT(d
)->manager
->devices_by_sysfs
, sysfs
);
107 LIST_PREPEND(same_sysfs
, first
, d
);
109 r
= hashmap_replace(UNIT(d
)->manager
->devices_by_sysfs
, copy
, first
);
111 LIST_REMOVE(same_sysfs
, first
, d
);
115 d
->sysfs
= TAKE_PTR(copy
);
116 unit_add_to_dbus_queue(UNIT(d
));
121 static void device_init(Unit
*u
) {
122 Device
*d
= ASSERT_PTR(DEVICE(u
));
124 assert(u
->load_state
== UNIT_STUB
);
126 /* In contrast to all other unit types we timeout jobs waiting
127 * for devices by default. This is because they otherwise wait
128 * indefinitely for plugged in devices, something which cannot
129 * happen for the other units since their operations time out
131 u
->job_running_timeout
= u
->manager
->defaults
.device_timeout_usec
;
133 u
->ignore_on_isolate
= true;
135 d
->deserialized_state
= _DEVICE_STATE_INVALID
;
138 static void device_done(Unit
*u
) {
139 Device
*d
= ASSERT_PTR(DEVICE(u
));
141 device_unset_sysfs(d
);
142 d
->deserialized_sysfs
= mfree(d
->deserialized_sysfs
);
143 d
->wants_property
= strv_free(d
->wants_property
);
144 d
->path
= mfree(d
->path
);
147 static int device_load(Unit
*u
) {
150 r
= unit_load_fragment_and_dropin(u
, false);
154 if (!u
->description
) {
155 /* Generate a description based on the path, to be used until the device is initialized
157 r
= unit_name_to_path(u
->id
, &u
->description
);
159 log_unit_debug_errno(u
, r
, "Failed to unescape name: %m");
165 static void device_set_state(Device
*d
, DeviceState state
) {
166 DeviceState old_state
;
170 if (d
->state
!= state
)
171 bus_unit_send_pending_change_signal(UNIT(d
), false);
173 old_state
= d
->state
;
176 if (state
== DEVICE_DEAD
)
177 device_unset_sysfs(d
);
179 if (state
!= old_state
)
180 log_unit_debug(UNIT(d
), "Changed %s -> %s", device_state_to_string(old_state
), device_state_to_string(state
));
182 unit_notify(UNIT(d
), state_translation_table
[old_state
], state_translation_table
[state
], /* reload_success = */ true);
185 static void device_found_changed(Device
*d
, DeviceFound previous
, DeviceFound now
) {
188 /* Didn't exist before, but does now? if so, generate a new invocation ID for it */
189 if (previous
== DEVICE_NOT_FOUND
&& now
!= DEVICE_NOT_FOUND
)
190 (void) unit_acquire_invocation_id(UNIT(d
));
192 if (FLAGS_SET(now
, DEVICE_FOUND_UDEV
))
193 /* When the device is known to udev we consider it plugged. */
194 device_set_state(d
, DEVICE_PLUGGED
);
195 else if (now
!= DEVICE_NOT_FOUND
&& !FLAGS_SET(previous
, DEVICE_FOUND_UDEV
))
196 /* If the device has not been seen by udev yet, but is now referenced by the kernel, then we assume the
197 * kernel knows it now, and udev might soon too. */
198 device_set_state(d
, DEVICE_TENTATIVE
);
200 /* If nobody sees the device, or if the device was previously seen by udev and now is only referenced
201 * from the kernel, then we consider the device is gone, the kernel just hasn't noticed it yet. */
202 device_set_state(d
, DEVICE_DEAD
);
205 static void device_update_found_one(Device
*d
, DeviceFound found
, DeviceFound mask
) {
208 if (MANAGER_IS_RUNNING(UNIT(d
)->manager
)) {
209 DeviceFound n
, previous
;
211 /* When we are already running, then apply the new mask right-away, and trigger state changes
214 n
= (d
->found
& ~mask
) | (found
& mask
);
221 device_found_changed(d
, previous
, n
);
223 /* We aren't running yet, let's apply the new mask to the shadow variable instead, which we'll apply as
224 * soon as we catch-up with the state. */
225 d
->enumerated_found
= (d
->enumerated_found
& ~mask
) | (found
& mask
);
228 static void device_update_found_by_sysfs(Manager
*m
, const char *sysfs
, DeviceFound found
, DeviceFound mask
) {
237 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
238 LIST_FOREACH(same_sysfs
, d
, l
)
239 device_update_found_one(d
, found
, mask
);
242 static void device_update_found_by_name(Manager
*m
, const char *path
, DeviceFound found
, DeviceFound mask
) {
251 if (device_by_path(m
, path
, &u
) < 0)
254 device_update_found_one(DEVICE(u
), found
, mask
);
257 static int device_coldplug(Unit
*u
) {
258 Device
*d
= ASSERT_PTR(DEVICE(u
));
260 assert(d
->state
== DEVICE_DEAD
);
262 /* First, let's put the deserialized state and found mask into effect, if we have it. */
263 if (d
->deserialized_state
< 0)
266 Manager
*m
= u
->manager
;
267 DeviceFound found
= d
->deserialized_found
;
268 DeviceState state
= d
->deserialized_state
;
270 /* On initial boot, switch-root, reload, reexecute, the following happen:
271 * 1. MANAGER_IS_RUNNING() == false
272 * 2. enumerate devices: manager_enumerate() -> device_enumerate()
273 * Device.enumerated_found is set.
274 * 3. deserialize devices: manager_deserialize() -> device_deserialize_item()
275 * Device.deserialize_state and Device.deserialized_found are set.
276 * 4. coldplug devices: manager_coldplug() -> device_coldplug()
277 * deserialized properties are copied to the main properties.
278 * 5. MANAGER_IS_RUNNING() == true: manager_ready()
279 * 6. catchup devices: manager_catchup() -> device_catchup()
280 * Device.enumerated_found is applied to Device.found, and state is updated based on that.
283 * - On initial boot, no udev database exists. Hence, no devices are enumerated in the step 2.
284 * Also, there is no deserialized device. Device units are (a) generated based on dependencies of
285 * other units, or (b) generated when uevents are received.
287 * - On switch-root, the udev database may be cleared, except for devices with sticky bit, i.e.
288 * OPTIONS="db_persist". Hence, almost no devices are enumerated in the step 2. However, in
289 * general, we have several serialized devices. So, DEVICE_FOUND_UDEV bit in the
290 * Device.deserialized_found must be ignored, as udev rules in initrd and the main system are often
291 * different. If the deserialized state is DEVICE_PLUGGED, we need to downgrade it to
292 * DEVICE_TENTATIVE. Unlike the other starting mode, MANAGER_IS_SWITCHING_ROOT() is true when
293 * device_coldplug() and device_catchup() are called. Hence, let's conditionalize the operations by
294 * using the flag. After switch-root, systemd-udevd will (re-)process all devices, and the
295 * Device.found and Device.state will be adjusted.
297 * - On reload or reexecute, we can trust Device.enumerated_found, Device.deserialized_found, and
298 * Device.deserialized_state. Of course, deserialized parameters may be outdated, but the unit
299 * state can be adjusted later by device_catchup() or uevents. */
301 if (MANAGER_IS_SWITCHING_ROOT(m
) &&
302 !FLAGS_SET(d
->enumerated_found
, DEVICE_FOUND_UDEV
)) {
304 /* The device has not been enumerated. On switching-root, such situation is natural. See the
305 * above comment. To prevent problematic state transition active → dead → active, let's
306 * drop the DEVICE_FOUND_UDEV flag and downgrade state to DEVICE_TENTATIVE(activating). See
307 * issue #12953 and #23208. */
308 found
&= ~DEVICE_FOUND_UDEV
;
309 if (state
== DEVICE_PLUGGED
)
310 state
= DEVICE_TENTATIVE
;
312 /* Also check the validity of the device syspath. Without this check, if the device was
313 * removed while switching root, it would never go to inactive state, as both Device.found
314 * and Device.enumerated_found do not have the DEVICE_FOUND_UDEV flag, so device_catchup() in
315 * device_update_found_one() does nothing in most cases. See issue #25106. Note that the
316 * syspath field is only serialized when systemd is sufficiently new and the device has been
317 * already processed by udevd. */
318 if (d
->deserialized_sysfs
) {
319 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
321 if (sd_device_new_from_syspath(&dev
, d
->deserialized_sysfs
) < 0)
326 if (d
->found
== found
&& d
->state
== state
)
330 device_set_state(d
, state
);
334 static void device_catchup(Unit
*u
) {
335 Device
*d
= ASSERT_PTR(DEVICE(u
));
337 /* Second, let's update the state with the enumerated state */
338 device_update_found_one(d
, d
->enumerated_found
, DEVICE_FOUND_MASK
);
341 static const struct {
344 } device_found_map
[] = {
345 { DEVICE_FOUND_UDEV
, "found-udev" },
346 { DEVICE_FOUND_MOUNT
, "found-mount" },
347 { DEVICE_FOUND_SWAP
, "found-swap" },
350 static int device_found_to_string_many(DeviceFound flags
, char **ret
) {
351 _cleanup_free_
char *s
= NULL
;
355 for (size_t i
= 0; i
< ELEMENTSOF(device_found_map
); i
++) {
356 if (!FLAGS_SET(flags
, device_found_map
[i
].flag
))
359 if (!strextend_with_separator(&s
, ",", device_found_map
[i
].name
))
368 static int device_found_from_string_many(const char *name
, DeviceFound
*ret
) {
369 DeviceFound flags
= 0;
375 _cleanup_free_
char *word
= NULL
;
379 r
= extract_first_word(&name
, &word
, ",", 0);
385 for (i
= 0; i
< ELEMENTSOF(device_found_map
); i
++)
386 if (streq(word
, device_found_map
[i
].name
)) {
387 f
= device_found_map
[i
].flag
;
401 static int device_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
402 Device
*d
= ASSERT_PTR(DEVICE(u
));
403 _cleanup_free_
char *s
= NULL
;
409 (void) serialize_item(f
, "sysfs", d
->sysfs
);
412 (void) serialize_item(f
, "path", d
->path
);
414 (void) serialize_item(f
, "state", device_state_to_string(d
->state
));
416 if (device_found_to_string_many(d
->found
, &s
) >= 0)
417 (void) serialize_item(f
, "found", s
);
422 static int device_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
423 Device
*d
= ASSERT_PTR(DEVICE(u
));
430 if (streq(key
, "sysfs")) {
431 if (!d
->deserialized_sysfs
) {
432 d
->deserialized_sysfs
= strdup(value
);
433 if (!d
->deserialized_sysfs
)
437 } else if (streq(key
, "path")) {
439 d
->path
= strdup(value
);
444 } else if (streq(key
, "state")) {
447 state
= device_state_from_string(value
);
449 log_unit_debug(u
, "Failed to parse state value, ignoring: %s", value
);
451 d
->deserialized_state
= state
;
453 } else if (streq(key
, "found")) {
454 r
= device_found_from_string_many(value
, &d
->deserialized_found
);
456 log_unit_debug_errno(u
, r
, "Failed to parse found value '%s', ignoring: %m", value
);
459 log_unit_debug(u
, "Unknown serialization key: %s", key
);
464 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
465 Device
*d
= ASSERT_PTR(DEVICE(u
));
466 _cleanup_free_
char *s
= NULL
;
471 (void) device_found_to_string_many(d
->found
, &s
);
474 "%sDevice State: %s\n"
475 "%sDevice Path: %s\n"
478 prefix
, device_state_to_string(d
->state
),
479 prefix
, strna(d
->path
),
480 prefix
, strna(d
->sysfs
),
483 STRV_FOREACH(i
, d
->wants_property
)
484 fprintf(f
, "%sudev SYSTEMD_WANTS: %s\n",
488 static UnitActiveState
device_active_state(Unit
*u
) {
489 Device
*d
= ASSERT_PTR(DEVICE(u
));
491 return state_translation_table
[d
->state
];
494 static const char *device_sub_state_to_string(Unit
*u
) {
495 Device
*d
= ASSERT_PTR(DEVICE(u
));
497 return device_state_to_string(d
->state
);
500 static int device_update_description(Unit
*u
, sd_device
*dev
, const char *path
) {
501 _cleanup_free_
char *j
= NULL
;
502 const char *model
, *label
, *desc
;
510 if (dev
&& device_get_model_string(dev
, &model
) >= 0) {
513 /* Try to concatenate the device model string with a label, if there is one */
514 if (sd_device_get_property_value(dev
, "ID_FS_LABEL", &label
) >= 0 ||
515 sd_device_get_property_value(dev
, "ID_PART_ENTRY_NAME", &label
) >= 0 ||
516 sd_device_get_property_value(dev
, "ID_PART_ENTRY_NUMBER", &label
) >= 0) {
518 desc
= j
= strjoin(model
, " ", label
);
524 r
= unit_set_description(u
, desc
);
526 return log_unit_error_errno(u
, r
, "Failed to set device description: %m");
531 static int device_add_udev_wants(Unit
*u
, sd_device
*dev
) {
532 Device
*d
= ASSERT_PTR(DEVICE(u
));
533 _cleanup_strv_free_
char **added
= NULL
;
534 const char *wants
, *property
;
539 property
= MANAGER_IS_USER(u
->manager
) ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
541 r
= sd_device_get_property_value(dev
, property
, &wants
);
546 _cleanup_free_
char *word
= NULL
, *k
= NULL
;
548 r
= extract_first_word(&wants
, &word
, NULL
, EXTRACT_UNQUOTE
);
554 return log_unit_error_errno(u
, r
, "Failed to parse property %s with value %s: %m", property
, wants
);
556 if (unit_name_is_valid(word
, UNIT_NAME_TEMPLATE
) && d
->sysfs
) {
557 _cleanup_free_
char *escaped
= NULL
;
559 /* If the unit name is specified as template, then automatically fill in the sysfs path of the
560 * device as instance name, properly escaped. */
562 r
= unit_name_path_escape(d
->sysfs
, &escaped
);
564 return log_unit_error_errno(u
, r
, "Failed to escape %s: %m", d
->sysfs
);
566 r
= unit_name_replace_instance(word
, escaped
, &k
);
568 return log_unit_error_errno(u
, r
, "Failed to build %s instance of template %s: %m", escaped
, word
);
570 /* If this is not a template, then let's mangle it so, that it becomes a valid unit name. */
572 r
= unit_name_mangle(word
, UNIT_NAME_MANGLE_WARN
, &k
);
574 return log_unit_error_errno(u
, r
, "Failed to mangle unit name \"%s\": %m", word
);
577 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, k
, true, UNIT_DEPENDENCY_UDEV
);
579 return log_unit_error_errno(u
, r
, "Failed to add Wants= dependency: %m");
581 r
= strv_consume(&added
, TAKE_PTR(k
));
586 if (d
->state
!= DEVICE_DEAD
)
587 /* So here's a special hack, to compensate for the fact that the udev database's reload cycles are not
588 * synchronized with our own reload cycles: when we detect that the SYSTEMD_WANTS property of a device
589 * changes while the device unit is already up, let's skip to trigger units that were already listed
590 * and are active, and start units otherwise. This typically happens during the boot-time switch root
591 * transition, as udev devices will generally already be up in the initrd, but SYSTEMD_WANTS properties
592 * get then added through udev rules only available on the host system, and thus only when the initial
593 * udev coldplug trigger runs.
595 * We do this only if the device has been up already when we parse this, as otherwise the usual
596 * dependency logic that is run from the dead → plugged transition will trigger these deps. */
597 STRV_FOREACH(i
, added
) {
598 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
600 if (strv_contains(d
->wants_property
, *i
)) {
603 v
= manager_get_unit(u
->manager
, *i
);
604 if (v
&& UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(v
)))
605 continue; /* The unit was already listed and is running. */
608 r
= manager_add_job_by_name(u
->manager
, JOB_START
, *i
, JOB_FAIL
, NULL
, &error
, NULL
);
610 log_unit_full_errno(u
, sd_bus_error_has_name(&error
, BUS_ERROR_NO_SUCH_UNIT
) ? LOG_DEBUG
: LOG_WARNING
, r
,
611 "Failed to enqueue %s job, ignoring: %s", property
, bus_error_message(&error
, r
));
614 return strv_free_and_replace(d
->wants_property
, added
);
617 static bool device_is_bound_by_mounts(Device
*d
, sd_device
*dev
) {
623 r
= device_get_property_bool(dev
, "SYSTEMD_MOUNT_DEVICE_BOUND");
624 if (r
< 0 && r
!= -ENOENT
)
625 log_device_warning_errno(dev
, r
, "Failed to parse SYSTEMD_MOUNT_DEVICE_BOUND= udev property, ignoring: %m");
627 d
->bind_mounts
= r
> 0;
629 return d
->bind_mounts
;
632 static void device_upgrade_mount_deps(Unit
*u
) {
637 /* Let's upgrade Requires= to BindsTo= on us. (Used when SYSTEMD_MOUNT_DEVICE_BOUND is set) */
641 HASHMAP_FOREACH_KEY(v
, other
, unit_get_dependencies(u
, UNIT_REQUIRED_BY
)) {
642 if (other
->type
!= UNIT_MOUNT
)
645 r
= unit_add_dependency(other
, UNIT_BINDS_TO
, u
, true, UNIT_DEPENDENCY_UDEV
);
647 log_unit_warning_errno(u
, r
, "Failed to add BindsTo= dependency between device and mount unit, ignoring: %m");
651 static int device_setup_unit(Manager
*m
, sd_device
*dev
, const char *path
, bool main
, Set
**units
) {
652 _cleanup_(unit_freep
) Unit
*new_unit
= NULL
;
653 _cleanup_free_
char *e
= NULL
;
654 const char *sysfs
= NULL
;
662 r
= sd_device_get_syspath(dev
, &sysfs
);
664 return log_device_debug_errno(dev
, r
, "Couldn't get syspath from device, ignoring: %m");
667 r
= unit_name_from_path(path
, ".device", &e
);
669 return log_struct_errno(
671 "MESSAGE_ID=" SD_MESSAGE_DEVICE_PATH_NOT_SUITABLE_STR
,
673 LOG_MESSAGE("Failed to generate valid unit name from device path '%s', ignoring device: %m",
676 u
= manager_get_unit(m
, e
);
678 /* The device unit can still be present even if the device was unplugged: a mount unit can reference it
679 * hence preventing the GC to have garbaged it. That's desired since the device unit may have a
680 * dependency on the mount unit which was added during the loading of the later. When the device is
681 * plugged the sysfs might not be initialized yet, as we serialize the device's state but do not
682 * serialize the sysfs path across reloads/reexecs. Hence, when coming back from a reload/restart we
683 * might have the state valid, but not the sysfs path. Also, there is another possibility; when multiple
684 * devices have the same devlink (e.g. /dev/disk/by-uuid/xxxx), adding/updating/removing one of the
685 * device causes syspath change. Hence, let's always update sysfs path. */
687 /* Let's remove all dependencies generated due to udev properties. We'll re-add whatever is configured
689 unit_remove_dependencies(u
, UNIT_DEPENDENCY_UDEV
);
692 r
= unit_new_for_name(m
, sizeof(Device
), e
, &new_unit
);
694 return log_device_error_errno(dev
, r
, "Failed to allocate device unit %s: %m", e
);
698 unit_add_to_load_queue(u
);
701 Device
*d
= ASSERT_PTR(DEVICE(u
));
704 d
->path
= strdup(path
);
709 /* If this was created via some dependency and has not actually been seen yet ->sysfs will not be
710 * initialized. Hence initialize it if necessary. */
712 r
= device_set_sysfs(d
, sysfs
);
714 return log_unit_error_errno(u
, r
, "Failed to set sysfs path %s: %m", sysfs
);
716 /* The additional systemd udev properties we only interpret for the main object */
718 (void) device_add_udev_wants(u
, dev
);
721 (void) device_update_description(u
, dev
, path
);
723 /* So the user wants the mount units to be bound to the device but a mount unit might has been seen
724 * by systemd before the device appears on its radar. In this case the device unit is partially
725 * initialized and includes the deps on the mount unit but at that time the "bind mounts" flag wasn't
726 * present. Fix this up now. */
727 if (dev
&& device_is_bound_by_mounts(d
, dev
))
728 device_upgrade_mount_deps(u
);
731 r
= set_ensure_put(units
, NULL
, d
);
733 return log_unit_error_errno(u
, r
, "Failed to store unit: %m");
740 static bool device_is_ready(sd_device
*dev
) {
745 if (device_for_action(dev
, SD_DEVICE_REMOVE
))
748 r
= device_is_renaming(dev
);
750 log_device_warning_errno(dev
, r
, "Failed to check if device is renaming, assuming device is not renaming: %m");
752 log_device_debug(dev
, "Device busy: device is renaming");
756 /* Is it really tagged as 'systemd' right now? */
757 r
= sd_device_has_current_tag(dev
, "systemd");
759 log_device_warning_errno(dev
, r
, "Failed to check if device has \"systemd\" tag, assuming device is not tagged with \"systemd\": %m");
761 log_device_debug(dev
, "Device busy: device is not tagged with \"systemd\"");
765 r
= device_get_property_bool(dev
, "SYSTEMD_READY");
766 if (r
< 0 && r
!= -ENOENT
)
767 log_device_warning_errno(dev
, r
, "Failed to get device SYSTEMD_READY property, assuming device does not have \"SYSTEMD_READY\" property: %m");
769 log_device_debug(dev
, "Device busy: SYSTEMD_READY property from device is false");
774 static int device_setup_devlink_unit_one(Manager
*m
, const char *devlink
, Set
**ready_units
, Set
**not_ready_units
) {
775 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
781 assert(not_ready_units
);
783 if (sd_device_new_from_devname(&dev
, devlink
) >= 0 && device_is_ready(dev
))
784 return device_setup_unit(m
, dev
, devlink
, /* main = */ false, ready_units
);
786 /* the devlink is already removed or not ready */
787 if (device_by_path(m
, devlink
, &u
) < 0)
788 return 0; /* The corresponding .device unit not found. That's fine. */
790 return set_ensure_put(not_ready_units
, NULL
, DEVICE(u
));
793 static int device_setup_extra_units(Manager
*m
, sd_device
*dev
, Set
**ready_units
, Set
**not_ready_units
) {
794 _cleanup_strv_free_
char **aliases
= NULL
;
795 const char *syspath
, *devname
= NULL
;
802 assert(not_ready_units
);
804 r
= sd_device_get_syspath(dev
, &syspath
);
808 (void) sd_device_get_devname(dev
, &devname
);
811 FOREACH_DEVICE_DEVLINK(dev
, devlink
) {
812 /* These are a kind of special devlink. They should be always unique, but neither persistent
813 * nor predictable. Hence, let's refuse them. See also the comments for alias units below. */
814 if (PATH_STARTSWITH_SET(devlink
, "/dev/block/", "/dev/char/"))
817 (void) device_setup_devlink_unit_one(m
, devlink
, ready_units
, not_ready_units
);
820 if (device_is_ready(dev
)) {
823 r
= sd_device_get_property_value(dev
, "SYSTEMD_ALIAS", &s
);
824 if (r
< 0 && r
!= -ENOENT
)
825 log_device_warning_errno(dev
, r
, "Failed to get SYSTEMD_ALIAS property, ignoring: %m");
827 r
= strv_split_full(&aliases
, s
, NULL
, EXTRACT_UNQUOTE
);
829 log_device_warning_errno(dev
, r
, "Failed to parse SYSTEMD_ALIAS property, ignoring: %m");
834 STRV_FOREACH(alias
, aliases
) {
835 if (!path_is_absolute(*alias
)) {
836 log_device_warning(dev
, "The alias \"%s\" specified in SYSTEMD_ALIAS is not an absolute path, ignoring.", *alias
);
840 if (!path_is_safe(*alias
)) {
841 log_device_warning(dev
, "The alias \"%s\" specified in SYSTEMD_ALIAS is not safe, ignoring.", *alias
);
845 /* Note, even if the devlink is not persistent, LVM expects /dev/block/ symlink units exist.
846 * To achieve that, they set the path to SYSTEMD_ALIAS. Hence, we cannot refuse aliases start
847 * with /dev/, unfortunately. */
849 (void) device_setup_unit(m
, dev
, *alias
, /* main = */ false, ready_units
);
852 l
= hashmap_get(m
->devices_by_sysfs
, syspath
);
853 LIST_FOREACH(same_sysfs
, d
, l
) {
857 if (path_equal(d
->path
, syspath
))
858 continue; /* This is the main unit. */
860 if (devname
&& path_equal(d
->path
, devname
))
861 continue; /* This is the real device node. */
863 if (device_has_devlink(dev
, d
->path
))
864 continue; /* The devlink was already processed in the above loop. */
866 if (strv_contains(aliases
, d
->path
))
867 continue; /* This is already processed in the above, and ready. */
869 if (path_startswith(d
->path
, "/dev/"))
870 /* This is a devlink unit. Check existence and update syspath. */
871 (void) device_setup_devlink_unit_one(m
, d
->path
, ready_units
, not_ready_units
);
873 /* This is an alias unit of dropped or not ready device. */
874 (void) set_ensure_put(not_ready_units
, NULL
, d
);
880 static int device_setup_units(Manager
*m
, sd_device
*dev
, Set
**ready_units
, Set
**not_ready_units
) {
881 const char *syspath
, *devname
= NULL
;
887 assert(not_ready_units
);
889 r
= sd_device_get_syspath(dev
, &syspath
);
891 return log_device_debug_errno(dev
, r
, "Couldn't get syspath from device, ignoring: %m");
893 /* First, process the main (that is, points to the syspath) and (real, not symlink) devnode units. */
894 if (device_for_action(dev
, SD_DEVICE_REMOVE
))
895 /* If the device is removed, the main and devnode units will be removed by
896 * device_update_found_by_sysfs() in device_dispatch_io(). Hence, it is not necessary to
897 * store them to not_ready_units, and we have nothing to do here.
899 * Note, still we need to process devlink units below, as a devlink previously points to this
900 * device may still exist and now point to another device node. That is, do not forget to
901 * call device_setup_extra_units(). */
903 else if (device_is_ready(dev
)) {
904 /* Add the main unit named after the syspath. If this one fails, don't bother with the rest,
905 * as this one shall be the main device unit the others just follow. (Compare with how
906 * device_following() is implemented, see below, which looks for the sysfs device.) */
907 r
= device_setup_unit(m
, dev
, syspath
, /* main = */ true, ready_units
);
911 /* Add an additional unit for the device node */
912 if (sd_device_get_devname(dev
, &devname
) >= 0)
913 (void) device_setup_unit(m
, dev
, devname
, /* main = */ false, ready_units
);
918 /* If the device exists but not ready, then save the units and unset udev bits later. */
920 if (device_by_path(m
, syspath
, &u
) >= 0) {
921 r
= set_ensure_put(not_ready_units
, NULL
, DEVICE(u
));
923 log_unit_debug_errno(u
, r
, "Failed to store unit, ignoring: %m");
926 if (sd_device_get_devname(dev
, &devname
) >= 0 &&
927 device_by_path(m
, devname
, &u
) >= 0) {
928 r
= set_ensure_put(not_ready_units
, NULL
, DEVICE(u
));
930 log_unit_debug_errno(u
, r
, "Failed to store unit, ignoring: %m");
934 /* Next, add/update additional .device units point to aliases and symlinks. */
935 (void) device_setup_extra_units(m
, dev
, ready_units
, not_ready_units
);
937 /* Safety check: no unit should be in ready_units and not_ready_units simultaneously. */
939 SET_FOREACH(u
, *not_ready_units
)
940 if (set_remove(*ready_units
, u
))
941 log_unit_error(u
, "Cannot activate and deactivate the unit simultaneously. Deactivating.");
946 static Unit
*device_following(Unit
*u
) {
947 Device
*d
= ASSERT_PTR(DEVICE(u
)), *first
= NULL
;
949 if (startswith(u
->id
, "sys-"))
952 /* Make everybody follow the unit that's named after the sysfs path */
953 LIST_FOREACH(same_sysfs
, other
, d
->same_sysfs_next
)
954 if (startswith(UNIT(other
)->id
, "sys-"))
957 LIST_FOREACH_BACKWARDS(same_sysfs
, other
, d
->same_sysfs_prev
) {
958 if (startswith(UNIT(other
)->id
, "sys-"))
967 static int device_following_set(Unit
*u
, Set
**ret
) {
968 Device
*d
= ASSERT_PTR(DEVICE(u
));
969 _cleanup_set_free_ Set
*set
= NULL
;
974 if (LIST_JUST_US(same_sysfs
, d
)) {
983 LIST_FOREACH(same_sysfs
, other
, d
->same_sysfs_next
) {
984 r
= set_put(set
, other
);
989 LIST_FOREACH_BACKWARDS(same_sysfs
, other
, d
->same_sysfs_prev
) {
990 r
= set_put(set
, other
);
995 *ret
= TAKE_PTR(set
);
999 static void device_shutdown(Manager
*m
) {
1002 m
->device_monitor
= sd_device_monitor_unref(m
->device_monitor
);
1003 m
->devices_by_sysfs
= hashmap_free(m
->devices_by_sysfs
);
1006 static void device_enumerate(Manager
*m
) {
1007 _cleanup_(sd_device_enumerator_unrefp
) sd_device_enumerator
*e
= NULL
;
1012 if (!m
->device_monitor
) {
1013 r
= sd_device_monitor_new(&m
->device_monitor
);
1015 log_error_errno(r
, "Failed to allocate device monitor: %m");
1019 r
= sd_device_monitor_filter_add_match_tag(m
->device_monitor
, "systemd");
1021 log_error_errno(r
, "Failed to add udev tag match: %m");
1025 r
= sd_device_monitor_attach_event(m
->device_monitor
, m
->event
);
1027 log_error_errno(r
, "Failed to attach event to device monitor: %m");
1031 r
= sd_device_monitor_start(m
->device_monitor
, device_dispatch_io
, m
);
1033 log_error_errno(r
, "Failed to start device monitor: %m");
1038 r
= sd_device_enumerator_new(&e
);
1040 log_error_errno(r
, "Failed to allocate device enumerator: %m");
1044 r
= sd_device_enumerator_add_match_tag(e
, "systemd");
1046 log_error_errno(r
, "Failed to set tag for device enumeration: %m");
1050 FOREACH_DEVICE(e
, dev
) {
1051 _cleanup_set_free_ Set
*ready_units
= NULL
, *not_ready_units
= NULL
;
1054 if (device_is_processed(dev
) <= 0)
1057 if (device_setup_units(m
, dev
, &ready_units
, ¬_ready_units
) < 0)
1060 SET_FOREACH(d
, ready_units
)
1061 device_update_found_one(d
, DEVICE_FOUND_UDEV
, DEVICE_FOUND_UDEV
);
1062 SET_FOREACH(d
, not_ready_units
)
1063 device_update_found_one(d
, DEVICE_NOT_FOUND
, DEVICE_FOUND_UDEV
);
1072 static void device_propagate_reload(Manager
*m
, Device
*d
) {
1078 if (d
->state
== DEVICE_DEAD
)
1081 r
= manager_propagate_reload(m
, UNIT(d
), JOB_REPLACE
, NULL
);
1083 log_unit_warning_errno(UNIT(d
), r
, "Failed to propagate reload, ignoring: %m");
1086 static void device_remove_old_on_move(Manager
*m
, sd_device
*dev
) {
1087 _cleanup_free_
char *syspath_old
= NULL
;
1088 const char *devpath_old
;
1094 r
= sd_device_get_property_value(dev
, "DEVPATH_OLD", &devpath_old
);
1096 return (void) log_device_debug_errno(dev
, r
, "Failed to get DEVPATH_OLD= property on 'move' uevent, ignoring: %m");
1098 syspath_old
= path_join("/sys", devpath_old
);
1100 return (void) log_oom();
1102 device_update_found_by_sysfs(m
, syspath_old
, DEVICE_NOT_FOUND
, DEVICE_FOUND_MASK
);
1105 static int device_dispatch_io(sd_device_monitor
*monitor
, sd_device
*dev
, void *userdata
) {
1106 _cleanup_set_free_ Set
*ready_units
= NULL
, *not_ready_units
= NULL
;
1107 Manager
*m
= ASSERT_PTR(userdata
);
1108 sd_device_action_t action
;
1116 log_device_uevent(dev
, "Processing udev action");
1118 r
= sd_device_get_syspath(dev
, &sysfs
);
1120 log_device_warning_errno(dev
, r
, "Failed to get device syspath, ignoring: %m");
1124 r
= sd_device_get_action(dev
, &action
);
1126 log_device_warning_errno(dev
, r
, "Failed to get udev action, ignoring: %m");
1130 log_device_debug(dev
, "Got '%s' action on syspath '%s'.", device_action_to_string(action
), sysfs
);
1132 if (action
== SD_DEVICE_MOVE
)
1133 device_remove_old_on_move(m
, dev
);
1135 /* When udevd failed to process the device, SYSTEMD_ALIAS or any other properties may contain invalid
1136 * values. Let's refuse to handle the uevent. */
1137 if (sd_device_get_property_value(dev
, "UDEV_WORKER_FAILED", NULL
) >= 0) {
1140 if (device_get_property_int(dev
, "UDEV_WORKER_ERRNO", &v
) >= 0)
1141 log_device_warning_errno(dev
, v
, "systemd-udevd failed to process the device, ignoring: %m");
1142 else if (device_get_property_int(dev
, "UDEV_WORKER_EXIT_STATUS", &v
) >= 0)
1143 log_device_warning(dev
, "systemd-udevd failed to process the device with exit status %i, ignoring.", v
);
1144 else if (device_get_property_int(dev
, "UDEV_WORKER_SIGNAL", &v
) >= 0) {
1146 (void) sd_device_get_property_value(dev
, "UDEV_WORKER_SIGNAL_NAME", &s
);
1147 log_device_warning(dev
, "systemd-udevd failed to process the device with signal %i(%s), ignoring.", v
, strna(s
));
1149 log_device_warning(dev
, "systemd-udevd failed to process the device with unknown result, ignoring.");
1154 /* A change event can signal that a device is becoming ready, in particular if the device is using
1155 * the SYSTEMD_READY logic in udev so we need to reach the else block of the following if, even for
1157 ready
= device_is_ready(dev
);
1159 (void) device_setup_units(m
, dev
, &ready_units
, ¬_ready_units
);
1161 if (action
== SD_DEVICE_REMOVE
) {
1162 r
= swap_process_device_remove(m
, dev
);
1164 log_device_warning_errno(dev
, r
, "Failed to process swap device remove event, ignoring: %m");
1166 r
= swap_process_device_new(m
, dev
);
1168 log_device_warning_errno(dev
, r
, "Failed to process swap device new event, ignoring: %m");
1171 if (!IN_SET(action
, SD_DEVICE_ADD
, SD_DEVICE_REMOVE
, SD_DEVICE_MOVE
))
1172 SET_FOREACH(d
, ready_units
)
1173 device_propagate_reload(m
, d
);
1175 if (!set_isempty(ready_units
))
1176 manager_dispatch_load_queue(m
);
1178 if (action
== SD_DEVICE_REMOVE
)
1179 /* If we get notified that a device was removed by udev, then it's completely gone, hence
1180 * unset all found bits. Note this affects all .device units still point to the removed
1182 device_update_found_by_sysfs(m
, sysfs
, DEVICE_NOT_FOUND
, DEVICE_FOUND_MASK
);
1184 /* These devices are found and ready now, set the udev found bit. Note, this is also necessary to do
1185 * on remove uevent, as some devlinks may be updated and now point to other device nodes. */
1186 SET_FOREACH(d
, ready_units
)
1187 device_update_found_one(d
, DEVICE_FOUND_UDEV
, DEVICE_FOUND_UDEV
);
1189 /* These devices may be nominally around, but not ready for us. Hence unset the udev bit, but leave
1190 * the rest around. This may be redundant for remove uevent, but should be harmless. */
1191 SET_FOREACH(d
, not_ready_units
)
1192 device_update_found_one(d
, DEVICE_NOT_FOUND
, DEVICE_FOUND_UDEV
);
1197 void device_found_node(Manager
*m
, const char *node
, DeviceFound found
, DeviceFound mask
) {
1202 assert(!FLAGS_SET(mask
, DEVICE_FOUND_UDEV
));
1204 if (!udev_available())
1210 /* This is called whenever we find a device referenced in /proc/swaps or /proc/self/mounts. Such a device might
1211 * be mounted/enabled at a time where udev has not finished probing it yet, and we thus haven't learned about
1212 * it yet. In this case we will set the device unit to "tentative" state.
1214 * This takes a pair of DeviceFound flags parameters. The 'mask' parameter is a bit mask that indicates which
1215 * bits of 'found' to copy into the per-device DeviceFound flags field. Thus, this function may be used to set
1216 * and unset individual bits in a single call, while merging partially with previous state. */
1218 if ((found
& mask
) != 0) {
1219 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
1221 /* If the device is known in the kernel and newly appeared, then we'll create a device unit for it,
1222 * under the name referenced in /proc/swaps or /proc/self/mountinfo. But first, let's validate if
1223 * everything is alright with the device node. Note that we're fine with missing device nodes,
1224 * but not with badly set up ones. */
1226 r
= sd_device_new_from_devname(&dev
, node
);
1228 log_debug("Could not find device for %s, continuing without device node", node
);
1230 /* Reduce log noise from nodes which are not device nodes by skipping EINVAL. */
1232 log_error_errno(r
, "Failed to open %s device, ignoring: %m", node
);
1236 (void) device_setup_unit(m
, dev
, node
, /* main = */ false, NULL
); /* 'dev' may be NULL. */
1239 /* Update the device unit's state, should it exist */
1240 (void) device_update_found_by_name(m
, node
, found
, mask
);
1243 bool device_shall_be_bound_by(Unit
*device
, Unit
*u
) {
1247 if (u
->type
!= UNIT_MOUNT
)
1250 return DEVICE(device
)->bind_mounts
;
1253 const UnitVTable device_vtable
= {
1254 .object_size
= sizeof(Device
),
1262 .init
= device_init
,
1263 .done
= device_done
,
1264 .load
= device_load
,
1266 .coldplug
= device_coldplug
,
1267 .catchup
= device_catchup
,
1269 .serialize
= device_serialize
,
1270 .deserialize_item
= device_deserialize_item
,
1272 .dump
= device_dump
,
1274 .active_state
= device_active_state
,
1275 .sub_state_to_string
= device_sub_state_to_string
,
1277 .following
= device_following
,
1278 .following_set
= device_following_set
,
1280 .enumerate
= device_enumerate
,
1281 .shutdown
= device_shutdown
,
1282 .supported
= udev_available
,
1284 .status_message_formats
= {
1285 .starting_stopping
= {
1286 [0] = "Expecting device %s...",
1287 [1] = "Waiting for device %s to disappear...",
1289 .finished_start_job
= {
1290 [JOB_DONE
] = "Found device %s.",
1291 [JOB_TIMEOUT
] = "Timed out waiting for device %s.",