1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
4 #include "sd-messages.h"
6 #include "alloc-util.h"
7 #include "bus-common-errors.h"
10 #include "device-private.h"
11 #include "device-util.h"
12 #include "extract-word.h"
16 #include "path-util.h"
17 #include "serialize.h"
19 #include "string-util.h"
22 #include "udev-util.h"
24 #include "unit-name.h"
26 static const UnitActiveState state_translation_table
[_DEVICE_STATE_MAX
] = {
27 [DEVICE_DEAD
] = UNIT_INACTIVE
,
28 [DEVICE_TENTATIVE
] = UNIT_ACTIVATING
,
29 [DEVICE_PLUGGED
] = UNIT_ACTIVE
,
32 static int device_dispatch_io(sd_device_monitor
*monitor
, sd_device
*dev
, void *userdata
);
34 static int device_by_path(Manager
*m
, const char *path
, Unit
**ret
) {
35 _cleanup_free_
char *e
= NULL
;
42 r
= unit_name_from_path(path
, ".device", &e
);
46 u
= manager_get_unit(m
, e
);
55 static void device_unset_sysfs(Device
*d
) {
61 /* Remove this unit from the chain of devices which share the same sysfs path. */
63 Hashmap
*devices
= ASSERT_PTR(UNIT(d
)->manager
->devices_by_sysfs
);
65 if (d
->same_sysfs_prev
)
66 /* If this is not the first unit, then simply remove this unit. */
67 d
->same_sysfs_prev
->same_sysfs_next
= d
->same_sysfs_next
;
68 else if (d
->same_sysfs_next
)
69 /* If this is the first unit, replace with the next unit. */
70 assert_se(hashmap_replace(devices
, d
->same_sysfs_next
->sysfs
, d
->same_sysfs_next
) >= 0);
72 /* Otherwise, remove the entry. */
73 hashmap_remove(devices
, d
->sysfs
);
75 if (d
->same_sysfs_next
)
76 d
->same_sysfs_next
->same_sysfs_prev
= d
->same_sysfs_prev
;
78 d
->same_sysfs_prev
= d
->same_sysfs_next
= NULL
;
80 d
->sysfs
= mfree(d
->sysfs
);
83 static int device_set_sysfs(Device
*d
, const char *sysfs
) {
84 Unit
*u
= UNIT(ASSERT_PTR(d
));
89 if (path_equal(d
->sysfs
, sysfs
))
92 Hashmap
**devices
= &u
->manager
->devices_by_sysfs
;
94 r
= hashmap_ensure_allocated(devices
, &path_hash_ops
);
98 _cleanup_free_
char *copy
= strdup(sysfs
);
102 device_unset_sysfs(d
);
104 Device
*first
= hashmap_get(*devices
, sysfs
);
105 LIST_PREPEND(same_sysfs
, first
, d
);
107 r
= hashmap_replace(*devices
, copy
, first
);
109 LIST_REMOVE(same_sysfs
, first
, d
);
113 d
->sysfs
= TAKE_PTR(copy
);
114 unit_add_to_dbus_queue(u
);
119 static void device_init(Unit
*u
) {
120 Device
*d
= ASSERT_PTR(DEVICE(u
));
122 assert(u
->load_state
== UNIT_STUB
);
124 /* In contrast to all other unit types we timeout jobs waiting
125 * for devices by default. This is because they otherwise wait
126 * indefinitely for plugged in devices, something which cannot
127 * happen for the other units since their operations time out
129 u
->job_running_timeout
= u
->manager
->defaults
.device_timeout_usec
;
131 u
->ignore_on_isolate
= true;
133 d
->deserialized_state
= _DEVICE_STATE_INVALID
;
136 static void device_done(Unit
*u
) {
137 Device
*d
= ASSERT_PTR(DEVICE(u
));
139 device_unset_sysfs(d
);
140 d
->deserialized_sysfs
= mfree(d
->deserialized_sysfs
);
141 d
->wants_property
= strv_free(d
->wants_property
);
142 d
->path
= mfree(d
->path
);
145 static int device_load(Unit
*u
) {
148 r
= unit_load_fragment_and_dropin(u
, false);
152 if (!u
->description
) {
153 /* Generate a description based on the path, to be used until the device is initialized
155 r
= unit_name_to_path(u
->id
, &u
->description
);
157 log_unit_debug_errno(u
, r
, "Failed to unescape name: %m");
163 static void device_set_state(Device
*d
, DeviceState state
) {
164 DeviceState old_state
;
168 if (d
->state
!= state
)
169 bus_unit_send_pending_change_signal(UNIT(d
), false);
171 old_state
= d
->state
;
174 if (state
== DEVICE_DEAD
)
175 device_unset_sysfs(d
);
177 if (state
!= old_state
)
178 log_unit_debug(UNIT(d
), "Changed %s -> %s", device_state_to_string(old_state
), device_state_to_string(state
));
180 unit_notify(UNIT(d
), state_translation_table
[old_state
], state_translation_table
[state
], /* reload_success = */ true);
183 static void device_found_changed(Device
*d
, DeviceFound previous
, DeviceFound now
) {
186 /* Didn't exist before, but does now? if so, generate a new invocation ID for it */
187 if (previous
== DEVICE_NOT_FOUND
&& now
!= DEVICE_NOT_FOUND
)
188 (void) unit_acquire_invocation_id(UNIT(d
));
190 if (FLAGS_SET(now
, DEVICE_FOUND_UDEV
))
191 /* When the device is known to udev we consider it plugged. */
192 device_set_state(d
, DEVICE_PLUGGED
);
193 else if (now
!= DEVICE_NOT_FOUND
&& !FLAGS_SET(previous
, DEVICE_FOUND_UDEV
))
194 /* If the device has not been seen by udev yet, but is now referenced by the kernel, then we assume the
195 * kernel knows it now, and udev might soon too. */
196 device_set_state(d
, DEVICE_TENTATIVE
);
198 /* If nobody sees the device, or if the device was previously seen by udev and now is only referenced
199 * from the kernel, then we consider the device is gone, the kernel just hasn't noticed it yet. */
200 device_set_state(d
, DEVICE_DEAD
);
203 static void device_update_found_one(Device
*d
, DeviceFound found
, DeviceFound mask
) {
206 if (MANAGER_IS_RUNNING(UNIT(d
)->manager
)) {
207 DeviceFound n
, previous
;
209 /* When we are already running, then apply the new mask right-away, and trigger state changes
212 n
= (d
->found
& ~mask
) | (found
& mask
);
219 device_found_changed(d
, previous
, n
);
221 /* We aren't running yet, let's apply the new mask to the shadow variable instead, which we'll apply as
222 * soon as we catch-up with the state. */
223 d
->enumerated_found
= (d
->enumerated_found
& ~mask
) | (found
& mask
);
226 static void device_update_found_by_sysfs(Manager
*m
, const char *sysfs
, DeviceFound found
, DeviceFound mask
) {
235 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
236 LIST_FOREACH(same_sysfs
, d
, l
)
237 device_update_found_one(d
, found
, mask
);
240 static void device_update_found_by_name(Manager
*m
, const char *path
, DeviceFound found
, DeviceFound mask
) {
249 if (device_by_path(m
, path
, &u
) < 0)
252 device_update_found_one(DEVICE(u
), found
, mask
);
255 static int device_coldplug(Unit
*u
) {
256 Device
*d
= ASSERT_PTR(DEVICE(u
));
258 assert(d
->state
== DEVICE_DEAD
);
260 /* First, let's put the deserialized state and found mask into effect, if we have it. */
261 if (d
->deserialized_state
< 0)
264 Manager
*m
= u
->manager
;
265 DeviceFound found
= d
->deserialized_found
;
266 DeviceState state
= d
->deserialized_state
;
268 /* On initial boot, switch-root, reload, reexecute, the following happen:
269 * 1. MANAGER_IS_RUNNING() == false
270 * 2. enumerate devices: manager_enumerate() -> device_enumerate()
271 * Device.enumerated_found is set.
272 * 3. deserialize devices: manager_deserialize() -> device_deserialize_item()
273 * Device.deserialize_state and Device.deserialized_found are set.
274 * 4. coldplug devices: manager_coldplug() -> device_coldplug()
275 * deserialized properties are copied to the main properties.
276 * 5. MANAGER_IS_RUNNING() == true: manager_ready()
277 * 6. catchup devices: manager_catchup() -> device_catchup()
278 * Device.enumerated_found is applied to Device.found, and state is updated based on that.
281 * - On initial boot, no udev database exists. Hence, no devices are enumerated in the step 2.
282 * Also, there is no deserialized device. Device units are (a) generated based on dependencies of
283 * other units, or (b) generated when uevents are received.
285 * - On switch-root, the udev database may be cleared, except for devices with sticky bit, i.e.
286 * OPTIONS="db_persist". Hence, almost no devices are enumerated in the step 2. However, in
287 * general, we have several serialized devices. So, DEVICE_FOUND_UDEV bit in the
288 * Device.deserialized_found must be ignored, as udev rules in initrd and the main system are often
289 * different. If the deserialized state is DEVICE_PLUGGED, we need to downgrade it to
290 * DEVICE_TENTATIVE. Unlike the other starting mode, MANAGER_IS_SWITCHING_ROOT() is true when
291 * device_coldplug() and device_catchup() are called. Hence, let's conditionalize the operations by
292 * using the flag. After switch-root, systemd-udevd will (re-)process all devices, and the
293 * Device.found and Device.state will be adjusted.
295 * - On reload or reexecute, we can trust Device.enumerated_found, Device.deserialized_found, and
296 * Device.deserialized_state. Of course, deserialized parameters may be outdated, but the unit
297 * state can be adjusted later by device_catchup() or uevents. */
299 if (MANAGER_IS_SWITCHING_ROOT(m
) &&
300 !FLAGS_SET(d
->enumerated_found
, DEVICE_FOUND_UDEV
)) {
302 /* The device has not been enumerated. On switching-root, such situation is natural. See the
303 * above comment. To prevent problematic state transition active → dead → active, let's
304 * drop the DEVICE_FOUND_UDEV flag and downgrade state to DEVICE_TENTATIVE(activating). See
305 * issue #12953 and #23208. */
306 found
&= ~DEVICE_FOUND_UDEV
;
307 if (state
== DEVICE_PLUGGED
)
308 state
= DEVICE_TENTATIVE
;
310 /* Also check the validity of the device syspath. Without this check, if the device was
311 * removed while switching root, it would never go to inactive state, as both Device.found
312 * and Device.enumerated_found do not have the DEVICE_FOUND_UDEV flag, so device_catchup() in
313 * device_update_found_one() does nothing in most cases. See issue #25106. Note that the
314 * syspath field is only serialized when systemd is sufficiently new and the device has been
315 * already processed by udevd. */
316 if (d
->deserialized_sysfs
) {
317 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
319 if (sd_device_new_from_syspath(&dev
, d
->deserialized_sysfs
) < 0)
324 if (d
->found
== found
&& d
->state
== state
)
328 device_set_state(d
, state
);
332 static void device_catchup(Unit
*u
) {
333 Device
*d
= ASSERT_PTR(DEVICE(u
));
335 /* Second, let's update the state with the enumerated state */
337 /* If Device.found (set from Device.deserialized_found) does not have DEVICE_FOUND_UDEV, and the
338 * device has not been processed by udevd while enumeration, it indicates the unit was never active
339 * before reexecution, hence we can safely drop the flag from Device.enumerated_found. The device
340 * will be set up later when udev finishes processing (see also comment in
341 * device_setup_devlink_unit_one()).
343 * NB: 💣💣💣 If Device.found already contains udev, i.e. the unit was fully ready before
344 * reexecution, do not unset the flag. Otherwise, e.g. if systemd-udev-trigger.service is started
345 * just before reexec, reload, and so on, devices being reprocessed (carrying ID_PROCESSING=1
346 * property) on enumeration and will enter dead state. See issue #35329. */
347 if (!FLAGS_SET(d
->found
, DEVICE_FOUND_UDEV
) && !d
->processed
)
348 d
->enumerated_found
&= ~DEVICE_FOUND_UDEV
;
350 device_update_found_one(d
, d
->enumerated_found
, _DEVICE_FOUND_MASK
);
353 static const struct {
356 } device_found_map
[] = {
357 { DEVICE_FOUND_UDEV
, "found-udev" },
358 { DEVICE_FOUND_MOUNT
, "found-mount" },
359 { DEVICE_FOUND_SWAP
, "found-swap" },
362 static int device_found_to_string_many(DeviceFound flags
, char **ret
) {
363 _cleanup_free_
char *s
= NULL
;
365 assert((flags
& ~_DEVICE_FOUND_MASK
) == 0);
368 FOREACH_ELEMENT(i
, device_found_map
) {
369 if (!FLAGS_SET(flags
, i
->flag
))
372 if (!strextend_with_separator(&s
, ",", i
->name
))
381 static int device_found_from_string_many(const char *name
, DeviceFound
*ret
) {
382 DeviceFound flags
= 0;
388 _cleanup_free_
char *word
= NULL
;
391 r
= extract_first_word(&name
, &word
, ",", 0);
397 FOREACH_ELEMENT(i
, device_found_map
)
398 if (streq(word
, i
->name
)) {
413 static int device_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
414 Device
*d
= ASSERT_PTR(DEVICE(u
));
415 _cleanup_free_
char *s
= NULL
;
421 (void) serialize_item(f
, "sysfs", d
->sysfs
);
424 (void) serialize_item(f
, "path", d
->path
);
426 (void) serialize_item(f
, "state", device_state_to_string(d
->state
));
428 if (device_found_to_string_many(d
->found
, &s
) >= 0)
429 (void) serialize_item(f
, "found", s
);
434 static int device_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
435 Device
*d
= ASSERT_PTR(DEVICE(u
));
442 if (streq(key
, "sysfs")) {
443 if (!d
->deserialized_sysfs
) {
444 d
->deserialized_sysfs
= strdup(value
);
445 if (!d
->deserialized_sysfs
)
449 } else if (streq(key
, "path")) {
451 d
->path
= strdup(value
);
456 } else if (streq(key
, "state")) {
459 state
= device_state_from_string(value
);
461 log_unit_debug(u
, "Failed to parse state value, ignoring: %s", value
);
463 d
->deserialized_state
= state
;
465 } else if (streq(key
, "found")) {
466 r
= device_found_from_string_many(value
, &d
->deserialized_found
);
468 log_unit_debug_errno(u
, r
, "Failed to parse found value '%s', ignoring: %m", value
);
471 log_unit_debug(u
, "Unknown serialization key: %s", key
);
476 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
477 Device
*d
= ASSERT_PTR(DEVICE(u
));
478 _cleanup_free_
char *s
= NULL
;
483 (void) device_found_to_string_many(d
->found
, &s
);
486 "%sDevice State: %s\n"
487 "%sDevice Path: %s\n"
490 prefix
, device_state_to_string(d
->state
),
491 prefix
, strna(d
->path
),
492 prefix
, strna(d
->sysfs
),
495 STRV_FOREACH(i
, d
->wants_property
)
496 fprintf(f
, "%sudev SYSTEMD_WANTS: %s\n",
500 static UnitActiveState
device_active_state(Unit
*u
) {
501 Device
*d
= ASSERT_PTR(DEVICE(u
));
503 return state_translation_table
[d
->state
];
506 static const char *device_sub_state_to_string(Unit
*u
) {
507 Device
*d
= ASSERT_PTR(DEVICE(u
));
509 return device_state_to_string(d
->state
);
512 static int device_update_description(Unit
*u
, sd_device
*dev
, const char *path
) {
513 _cleanup_free_
char *j
= NULL
;
514 const char *model
, *label
, *desc
;
522 if (dev
&& device_get_model_string(dev
, &model
) >= 0) {
525 /* Try to concatenate the device model string with a label, if there is one */
526 if (sd_device_get_property_value(dev
, "ID_FS_LABEL", &label
) >= 0 ||
527 sd_device_get_property_value(dev
, "ID_PART_ENTRY_NAME", &label
) >= 0 ||
528 sd_device_get_property_value(dev
, "ID_PART_ENTRY_NUMBER", &label
) >= 0) {
530 desc
= j
= strjoin(model
, " ", label
);
536 r
= unit_set_description(u
, desc
);
538 return log_unit_error_errno(u
, r
, "Failed to set device description: %m");
543 static int device_add_udev_wants(Unit
*u
, sd_device
*dev
) {
544 Device
*d
= ASSERT_PTR(DEVICE(u
));
545 _cleanup_strv_free_
char **added
= NULL
;
546 const char *wants
, *property
;
551 property
= MANAGER_IS_USER(u
->manager
) ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
553 r
= sd_device_get_property_value(dev
, property
, &wants
);
558 _cleanup_free_
char *word
= NULL
, *k
= NULL
;
560 r
= extract_first_word(&wants
, &word
, NULL
, EXTRACT_UNQUOTE
| EXTRACT_RETAIN_ESCAPE
);
566 return log_unit_error_errno(u
, r
, "Failed to parse property %s with value %s: %m", property
, wants
);
568 if (unit_name_is_valid(word
, UNIT_NAME_TEMPLATE
) && d
->sysfs
) {
569 _cleanup_free_
char *escaped
= NULL
;
571 /* If the unit name is specified as template, then automatically fill in the sysfs path of the
572 * device as instance name, properly escaped. */
574 r
= unit_name_path_escape(d
->sysfs
, &escaped
);
576 return log_unit_error_errno(u
, r
, "Failed to escape %s: %m", d
->sysfs
);
578 r
= unit_name_replace_instance(word
, escaped
, &k
);
580 return log_unit_error_errno(u
, r
, "Failed to build %s instance of template %s: %m", escaped
, word
);
582 /* If this is not a template, then let's mangle it so, that it becomes a valid unit name. */
584 r
= unit_name_mangle(word
, UNIT_NAME_MANGLE_WARN
, &k
);
586 return log_unit_error_errno(u
, r
, "Failed to mangle unit name \"%s\": %m", word
);
589 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, k
, true, UNIT_DEPENDENCY_UDEV
);
591 return log_unit_error_errno(u
, r
, "Failed to add Wants= dependency: %m");
593 r
= strv_consume(&added
, TAKE_PTR(k
));
598 if (d
->state
!= DEVICE_DEAD
)
599 /* So here's a special hack, to compensate for the fact that the udev database's reload cycles are not
600 * synchronized with our own reload cycles: when we detect that the SYSTEMD_WANTS property of a device
601 * changes while the device unit is already up, let's skip to trigger units that were already listed
602 * and are active, and start units otherwise. This typically happens during the boot-time switch root
603 * transition, as udev devices will generally already be up in the initrd, but SYSTEMD_WANTS properties
604 * get then added through udev rules only available on the host system, and thus only when the initial
605 * udev coldplug trigger runs.
607 * We do this only if the device has been up already when we parse this, as otherwise the usual
608 * dependency logic that is run from the dead → plugged transition will trigger these deps. */
609 STRV_FOREACH(i
, added
) {
610 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
612 if (strv_contains(d
->wants_property
, *i
)) {
615 v
= manager_get_unit(u
->manager
, *i
);
616 if (v
&& UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(v
)))
617 continue; /* The unit was already listed and is running. */
620 r
= manager_add_job_by_name(u
->manager
, JOB_START
, *i
, JOB_FAIL
, NULL
, &error
, NULL
);
622 log_unit_full_errno(u
, sd_bus_error_has_name(&error
, BUS_ERROR_NO_SUCH_UNIT
) ? LOG_DEBUG
: LOG_WARNING
, r
,
623 "Failed to enqueue %s job, ignoring: %s", property
, bus_error_message(&error
, r
));
626 return strv_free_and_replace(d
->wants_property
, added
);
629 static bool device_is_bound_by_mounts(Device
*d
, sd_device
*dev
) {
635 r
= device_get_property_bool(dev
, "SYSTEMD_MOUNT_DEVICE_BOUND");
636 if (r
< 0 && r
!= -ENOENT
)
637 log_device_warning_errno(dev
, r
, "Failed to parse SYSTEMD_MOUNT_DEVICE_BOUND= udev property, ignoring: %m");
639 d
->bind_mounts
= r
> 0;
641 return d
->bind_mounts
;
644 static void device_upgrade_mount_deps(Unit
*u
) {
649 /* Let's upgrade Requires= to BindsTo= on us. (Used when SYSTEMD_MOUNT_DEVICE_BOUND is set) */
653 HASHMAP_FOREACH_KEY(v
, other
, unit_get_dependencies(u
, UNIT_REQUIRED_BY
)) {
654 if (other
->type
!= UNIT_MOUNT
)
657 r
= unit_add_dependency(other
, UNIT_BINDS_TO
, u
, true, UNIT_DEPENDENCY_UDEV
);
659 log_unit_warning_errno(u
, r
, "Failed to add BindsTo= dependency between device and mount unit, ignoring: %m");
663 static int device_setup_unit(Manager
*m
, sd_device
*dev
, const char *path
, bool main
, Set
**units
) {
664 _cleanup_(unit_freep
) Unit
*new_unit
= NULL
;
665 _cleanup_free_
char *e
= NULL
;
666 const char *sysfs
= NULL
;
674 r
= sd_device_get_syspath(dev
, &sysfs
);
676 return log_device_debug_errno(dev
, r
, "Couldn't get syspath from device, ignoring: %m");
679 r
= unit_name_from_path(path
, ".device", &e
);
681 return log_struct_errno(
683 LOG_MESSAGE_ID(SD_MESSAGE_DEVICE_PATH_NOT_SUITABLE_STR
),
684 LOG_ITEM("DEVICE=%s", path
),
685 LOG_MESSAGE("Failed to generate valid unit name from device path '%s', ignoring device: %m",
688 u
= manager_get_unit(m
, e
);
690 /* The device unit can still be present even if the device was unplugged: a mount unit can reference it
691 * hence preventing the GC to have garbaged it. That's desired since the device unit may have a
692 * dependency on the mount unit which was added during the loading of the later. When the device is
693 * plugged the sysfs might not be initialized yet, as we serialize the device's state but do not
694 * serialize the sysfs path across reloads/reexecs. Hence, when coming back from a reload/restart we
695 * might have the state valid, but not the sysfs path. Also, there is another possibility; when multiple
696 * devices have the same devlink (e.g. /dev/disk/by-uuid/xxxx), adding/updating/removing one of the
697 * device causes syspath change. Hence, let's always update sysfs path. */
699 /* Let's remove all dependencies generated due to udev properties. We'll re-add whatever is configured
701 unit_remove_dependencies(u
, UNIT_DEPENDENCY_UDEV
);
704 r
= unit_new_for_name(m
, sizeof(Device
), e
, &new_unit
);
706 return log_device_error_errno(dev
, r
, "Failed to allocate device unit %s: %m", e
);
710 unit_add_to_load_queue(u
);
713 Device
*d
= ASSERT_PTR(DEVICE(u
));
716 d
->path
= strdup(path
);
721 /* If this was created via some dependency and has not actually been seen yet ->sysfs will not be
722 * initialized. Hence initialize it if necessary. */
724 r
= device_set_sysfs(d
, sysfs
);
726 return log_unit_error_errno(u
, r
, "Failed to set sysfs path %s: %m", sysfs
);
728 /* The additional systemd udev properties we only interpret for the main object */
730 (void) device_add_udev_wants(u
, dev
);
733 (void) device_update_description(u
, dev
, path
);
735 /* So the user wants the mount units to be bound to the device but a mount unit might has been seen
736 * by systemd before the device appears on its radar. In this case the device unit is partially
737 * initialized and includes the deps on the mount unit but at that time the "bind mounts" flag wasn't
738 * present. Fix this up now. */
739 if (dev
&& device_is_bound_by_mounts(d
, dev
))
740 device_upgrade_mount_deps(u
);
743 r
= set_ensure_put(units
, NULL
, d
);
745 return log_unit_error_errno(u
, r
, "Failed to store unit: %m");
752 static bool device_is_ready(sd_device
*dev
) {
757 if (device_for_action(dev
, SD_DEVICE_REMOVE
))
760 r
= device_is_renaming(dev
);
762 log_device_warning_errno(dev
, r
, "Failed to check if device is renaming, assuming device is not renaming: %m");
764 log_device_debug(dev
, "Device busy: device is renaming");
768 /* Is it really tagged as 'systemd' right now? */
769 r
= sd_device_has_current_tag(dev
, "systemd");
771 log_device_warning_errno(dev
, r
, "Failed to check if device has \"systemd\" tag, assuming device is not tagged with \"systemd\": %m");
773 log_device_debug(dev
, "Device busy: device is not tagged with \"systemd\"");
777 r
= device_get_property_bool(dev
, "SYSTEMD_READY");
778 if (r
< 0 && r
!= -ENOENT
)
779 log_device_warning_errno(dev
, r
, "Failed to get device SYSTEMD_READY property, assuming device does not have \"SYSTEMD_READY\" property: %m");
781 log_device_debug(dev
, "Device busy: SYSTEMD_READY property from device is false");
786 static int device_setup_devlink_unit_one(Manager
*m
, const char *devlink
, Set
**ready_units
, Set
**not_ready_units
) {
787 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
793 assert(not_ready_units
);
795 if (sd_device_new_from_devname(&dev
, devlink
) >= 0 && device_is_ready(dev
)) {
796 if (MANAGER_IS_RUNNING(m
) && device_is_processed(dev
) <= 0)
797 /* The device is being processed by udevd. We will receive relevant uevent for the
798 * device later when completed. Let's ignore the device now. */
801 /* Note, even if the device is being processed by udevd, setup the unit on enumerate.
802 * See also the comments in device_catchup(). */
803 return device_setup_unit(m
, dev
, devlink
, /* main = */ false, ready_units
);
806 /* the devlink is already removed or not ready */
807 if (device_by_path(m
, devlink
, &u
) < 0)
808 return 0; /* The corresponding .device unit not found. That's fine. */
810 return set_ensure_put(not_ready_units
, NULL
, DEVICE(u
));
813 static int device_setup_extra_units(Manager
*m
, sd_device
*dev
, Set
**ready_units
, Set
**not_ready_units
) {
814 _cleanup_strv_free_
char **aliases
= NULL
;
815 const char *syspath
, *devname
= NULL
;
822 assert(not_ready_units
);
824 r
= sd_device_get_syspath(dev
, &syspath
);
828 (void) sd_device_get_devname(dev
, &devname
);
831 FOREACH_DEVICE_DEVLINK(dev
, devlink
) {
832 /* These are a kind of special devlink. They should be always unique, but neither persistent
833 * nor predictable. Hence, let's refuse them. See also the comments for alias units below. */
834 if (PATH_STARTSWITH_SET(devlink
, "/dev/block/", "/dev/char/"))
837 (void) device_setup_devlink_unit_one(m
, devlink
, ready_units
, not_ready_units
);
840 if (device_is_ready(dev
)) {
843 r
= sd_device_get_property_value(dev
, "SYSTEMD_ALIAS", &s
);
844 if (r
< 0 && r
!= -ENOENT
)
845 log_device_warning_errno(dev
, r
, "Failed to get SYSTEMD_ALIAS property, ignoring: %m");
847 r
= strv_split_full(&aliases
, s
, NULL
, EXTRACT_UNQUOTE
);
849 log_device_warning_errno(dev
, r
, "Failed to parse SYSTEMD_ALIAS property, ignoring: %m");
854 STRV_FOREACH(alias
, aliases
) {
855 if (!path_is_absolute(*alias
)) {
856 log_device_warning(dev
, "The alias \"%s\" specified in SYSTEMD_ALIAS is not an absolute path, ignoring.", *alias
);
860 if (!path_is_safe(*alias
)) {
861 log_device_warning(dev
, "The alias \"%s\" specified in SYSTEMD_ALIAS is not safe, ignoring.", *alias
);
865 /* Note, even if the devlink is not persistent, LVM expects /dev/block/ symlink units exist.
866 * To achieve that, they set the path to SYSTEMD_ALIAS. Hence, we cannot refuse aliases start
867 * with /dev/, unfortunately. */
869 (void) device_setup_unit(m
, dev
, *alias
, /* main = */ false, ready_units
);
872 l
= hashmap_get(m
->devices_by_sysfs
, syspath
);
873 LIST_FOREACH(same_sysfs
, d
, l
) {
877 if (path_equal(d
->path
, syspath
))
878 continue; /* This is the main unit. */
880 if (devname
&& path_equal(d
->path
, devname
))
881 continue; /* This is the real device node. */
883 if (device_has_devlink(dev
, d
->path
))
884 continue; /* The devlink was already processed in the above loop. */
886 if (strv_contains(aliases
, d
->path
))
887 continue; /* This is already processed in the above, and ready. */
889 if (path_startswith(d
->path
, "/dev/"))
890 /* This is a devlink unit. Check existence and update syspath. */
891 (void) device_setup_devlink_unit_one(m
, d
->path
, ready_units
, not_ready_units
);
893 /* This is an alias unit of dropped or not ready device. */
894 (void) set_ensure_put(not_ready_units
, NULL
, d
);
900 static int device_setup_units(Manager
*m
, sd_device
*dev
, Set
**ret_ready_units
, Set
**ret_not_ready_units
) {
901 _cleanup_set_free_ Set
*ready_units
= NULL
, *not_ready_units
= NULL
;
902 const char *syspath
, *devname
= NULL
;
907 assert(ret_ready_units
);
908 assert(ret_not_ready_units
);
910 r
= sd_device_get_syspath(dev
, &syspath
);
912 return log_device_debug_errno(dev
, r
, "Couldn't get syspath from device, ignoring: %m");
914 /* First, process the main (that is, points to the syspath) and (real, not symlink) devnode units. */
915 if (device_for_action(dev
, SD_DEVICE_REMOVE
))
916 /* If the device is removed, the main and devnode units will be removed by
917 * device_update_found_by_sysfs() in device_dispatch_io(). Hence, it is not necessary to
918 * store them to not_ready_units, and we have nothing to do here.
920 * Note, still we need to process devlink units below, as a devlink previously points to this
921 * device may still exist and now point to another device node. That is, do not forget to
922 * call device_setup_extra_units(). */
924 else if (device_is_ready(dev
)) {
925 /* Add the main unit named after the syspath. If this one fails, don't bother with the rest,
926 * as this one shall be the main device unit the others just follow. (Compare with how
927 * device_following() is implemented, see below, which looks for the sysfs device.) */
928 r
= device_setup_unit(m
, dev
, syspath
, /* main = */ true, &ready_units
);
932 /* Add an additional unit for the device node */
933 if (sd_device_get_devname(dev
, &devname
) >= 0)
934 (void) device_setup_unit(m
, dev
, devname
, /* main = */ false, &ready_units
);
939 /* If the device exists but not ready, then save the units and unset udev bits later. */
941 if (device_by_path(m
, syspath
, &u
) >= 0) {
942 r
= set_ensure_put(¬_ready_units
, NULL
, DEVICE(u
));
944 log_unit_debug_errno(u
, r
, "Failed to store unit, ignoring: %m");
947 if (sd_device_get_devname(dev
, &devname
) >= 0 &&
948 device_by_path(m
, devname
, &u
) >= 0) {
949 r
= set_ensure_put(¬_ready_units
, NULL
, DEVICE(u
));
951 log_unit_debug_errno(u
, r
, "Failed to store unit, ignoring: %m");
955 /* Next, add/update additional .device units point to aliases and symlinks. */
956 (void) device_setup_extra_units(m
, dev
, &ready_units
, ¬_ready_units
);
958 /* Safety check: no unit should be in ready_units and not_ready_units simultaneously. */
960 SET_FOREACH(u
, not_ready_units
)
961 if (set_remove(ready_units
, u
))
962 log_unit_error(u
, "Cannot activate and deactivate the unit simultaneously. Deactivating.");
964 *ret_ready_units
= TAKE_PTR(ready_units
);
965 *ret_not_ready_units
= TAKE_PTR(not_ready_units
);
969 static Unit
*device_following(Unit
*u
) {
970 Device
*d
= ASSERT_PTR(DEVICE(u
)), *first
= NULL
;
972 if (startswith(u
->id
, "sys-"))
975 /* Make everybody follow the unit that's named after the sysfs path */
976 LIST_FOREACH(same_sysfs
, other
, d
->same_sysfs_next
)
977 if (startswith(UNIT(other
)->id
, "sys-"))
980 LIST_FOREACH_BACKWARDS(same_sysfs
, other
, d
->same_sysfs_prev
) {
981 if (startswith(UNIT(other
)->id
, "sys-"))
990 static int device_following_set(Unit
*u
, Set
**ret
) {
991 Device
*d
= ASSERT_PTR(DEVICE(u
));
992 _cleanup_set_free_ Set
*set
= NULL
;
997 if (LIST_JUST_US(same_sysfs
, d
)) {
1002 set
= set_new(NULL
);
1006 LIST_FOREACH(same_sysfs
, other
, d
->same_sysfs_next
) {
1007 r
= set_put(set
, other
);
1012 LIST_FOREACH_BACKWARDS(same_sysfs
, other
, d
->same_sysfs_prev
) {
1013 r
= set_put(set
, other
);
1018 *ret
= TAKE_PTR(set
);
1022 static void device_shutdown(Manager
*m
) {
1025 m
->device_monitor
= sd_device_monitor_unref(m
->device_monitor
);
1026 m
->devices_by_sysfs
= hashmap_free(m
->devices_by_sysfs
);
1029 static void device_enumerate(Manager
*m
) {
1030 _cleanup_(sd_device_enumerator_unrefp
) sd_device_enumerator
*e
= NULL
;
1035 if (!m
->device_monitor
) {
1036 r
= sd_device_monitor_new(&m
->device_monitor
);
1038 log_error_errno(r
, "Failed to allocate device monitor: %m");
1042 r
= sd_device_monitor_filter_add_match_tag(m
->device_monitor
, "systemd");
1044 log_error_errno(r
, "Failed to add udev tag match: %m");
1048 r
= sd_device_monitor_attach_event(m
->device_monitor
, m
->event
);
1050 log_error_errno(r
, "Failed to attach event to device monitor: %m");
1054 r
= sd_device_monitor_start(m
->device_monitor
, device_dispatch_io
, m
);
1056 log_error_errno(r
, "Failed to start device monitor: %m");
1061 r
= sd_device_enumerator_new(&e
);
1063 log_error_errno(r
, "Failed to allocate device enumerator: %m");
1067 r
= sd_device_enumerator_add_match_tag(e
, "systemd");
1069 log_error_errno(r
, "Failed to set tag for device enumeration: %m");
1073 FOREACH_DEVICE(e
, dev
) {
1074 _cleanup_set_free_ Set
*ready_units
= NULL
, *not_ready_units
= NULL
;
1075 const char *syspath
;
1079 r
= sd_device_get_syspath(dev
, &syspath
);
1081 log_device_debug_errno(dev
, r
, "Failed to get syspath of enumerated device, ignoring: %m");
1085 r
= device_is_processed(dev
);
1087 log_device_debug_errno(dev
, r
, "Failed to check if device is processed by udevd, assuming not: %m");
1090 if (device_setup_units(m
, dev
, &ready_units
, ¬_ready_units
) < 0)
1093 SET_FOREACH(d
, ready_units
) {
1094 device_update_found_one(d
, DEVICE_FOUND_UDEV
, DEVICE_FOUND_UDEV
);
1096 /* Why we need to check the syspath here? Because the device unit may be generated by
1097 * a devlink, and the syspath may be different from the one of the original device. */
1098 if (path_equal(d
->sysfs
, syspath
))
1099 d
->processed
= processed
;
1101 SET_FOREACH(d
, not_ready_units
)
1102 device_update_found_one(d
, DEVICE_NOT_FOUND
, DEVICE_FOUND_UDEV
);
1111 static void device_propagate_reload(Manager
*m
, Device
*d
) {
1117 if (d
->state
== DEVICE_DEAD
)
1120 r
= manager_propagate_reload(m
, UNIT(d
), JOB_REPLACE
, NULL
);
1122 log_unit_warning_errno(UNIT(d
), r
, "Failed to propagate reload, ignoring: %m");
1125 static void device_remove_old_on_move(Manager
*m
, sd_device
*dev
) {
1126 _cleanup_free_
char *syspath_old
= NULL
;
1127 const char *devpath_old
;
1133 r
= sd_device_get_property_value(dev
, "DEVPATH_OLD", &devpath_old
);
1135 return (void) log_device_debug_errno(dev
, r
, "Failed to get DEVPATH_OLD= property on 'move' uevent, ignoring: %m");
1137 syspath_old
= path_join("/sys", devpath_old
);
1139 return (void) log_oom();
1141 device_update_found_by_sysfs(m
, syspath_old
, DEVICE_NOT_FOUND
, _DEVICE_FOUND_MASK
);
1144 static int device_dispatch_io(sd_device_monitor
*monitor
, sd_device
*dev
, void *userdata
) {
1145 Manager
*m
= ASSERT_PTR(userdata
);
1146 sd_device_action_t action
;
1154 log_device_uevent(dev
, "Processing udev action");
1156 r
= sd_device_get_syspath(dev
, &sysfs
);
1158 log_device_warning_errno(dev
, r
, "Failed to get device syspath, ignoring: %m");
1162 r
= sd_device_get_action(dev
, &action
);
1164 log_device_warning_errno(dev
, r
, "Failed to get udev action, ignoring: %m");
1168 log_device_debug(dev
, "Got '%s' action on syspath '%s'.", device_action_to_string(action
), sysfs
);
1170 if (action
== SD_DEVICE_MOVE
)
1171 device_remove_old_on_move(m
, dev
);
1173 /* When udevd failed to process the device, SYSTEMD_ALIAS or any other properties may contain invalid
1174 * values. Let's refuse to handle the uevent. */
1175 if (sd_device_get_property_value(dev
, "UDEV_WORKER_FAILED", NULL
) >= 0) {
1178 if (device_get_property_int(dev
, "UDEV_WORKER_ERRNO", &v
) >= 0)
1179 log_device_warning_errno(dev
, v
, "systemd-udevd failed to process the device, ignoring: %m");
1180 else if (device_get_property_int(dev
, "UDEV_WORKER_EXIT_STATUS", &v
) >= 0)
1181 log_device_warning(dev
, "systemd-udevd failed to process the device with exit status %i, ignoring.", v
);
1182 else if (device_get_property_int(dev
, "UDEV_WORKER_SIGNAL", &v
) >= 0) {
1184 (void) sd_device_get_property_value(dev
, "UDEV_WORKER_SIGNAL_NAME", &s
);
1185 log_device_warning(dev
, "systemd-udevd failed to process the device with signal %i(%s), ignoring.", v
, strna(s
));
1187 log_device_warning(dev
, "systemd-udevd failed to process the device with unknown result, ignoring.");
1192 /* A change event can signal that a device is becoming ready, in particular if the device is using
1193 * the SYSTEMD_READY logic in udev so we need to reach the else block of the following if, even for
1195 ready
= device_is_ready(dev
);
1197 _cleanup_set_free_ Set
*ready_units
= NULL
, *not_ready_units
= NULL
;
1198 (void) device_setup_units(m
, dev
, &ready_units
, ¬_ready_units
);
1200 if (action
== SD_DEVICE_REMOVE
) {
1201 r
= swap_process_device_remove(m
, dev
);
1203 log_device_warning_errno(dev
, r
, "Failed to process swap device remove event, ignoring: %m");
1205 r
= swap_process_device_new(m
, dev
);
1207 log_device_warning_errno(dev
, r
, "Failed to process swap device new event, ignoring: %m");
1210 if (!IN_SET(action
, SD_DEVICE_ADD
, SD_DEVICE_REMOVE
, SD_DEVICE_MOVE
))
1211 SET_FOREACH(d
, ready_units
)
1212 device_propagate_reload(m
, d
);
1214 if (!set_isempty(ready_units
))
1215 manager_dispatch_load_queue(m
);
1217 if (action
== SD_DEVICE_REMOVE
)
1218 /* If we get notified that a device was removed by udev, then it's completely gone, hence
1219 * unset all found bits. Note this affects all .device units still point to the removed
1221 device_update_found_by_sysfs(m
, sysfs
, DEVICE_NOT_FOUND
, _DEVICE_FOUND_MASK
);
1223 /* These devices are found and ready now, set the udev found bit. Note, this is also necessary to do
1224 * on remove uevent, as some devlinks may be updated and now point to other device nodes. */
1225 SET_FOREACH(d
, ready_units
)
1226 device_update_found_one(d
, DEVICE_FOUND_UDEV
, DEVICE_FOUND_UDEV
);
1228 /* These devices may be nominally around, but not ready for us. Hence unset the udev bit, but leave
1229 * the rest around. This may be redundant for remove uevent, but should be harmless. */
1230 SET_FOREACH(d
, not_ready_units
)
1231 device_update_found_one(d
, DEVICE_NOT_FOUND
, DEVICE_FOUND_UDEV
);
1236 void device_found_node(Manager
*m
, const char *node
, DeviceFound found
, DeviceFound mask
) {
1241 assert(!FLAGS_SET(mask
, DEVICE_FOUND_UDEV
));
1243 if (!udev_available())
1249 /* This is called whenever we find a device referenced in /proc/swaps or /proc/self/mounts. Such a device might
1250 * be mounted/enabled at a time where udev has not finished probing it yet, and we thus haven't learned about
1251 * it yet. In this case we will set the device unit to "tentative" state.
1253 * This takes a pair of DeviceFound flags parameters. The 'mask' parameter is a bit mask that indicates which
1254 * bits of 'found' to copy into the per-device DeviceFound flags field. Thus, this function may be used to set
1255 * and unset individual bits in a single call, while merging partially with previous state. */
1257 if ((found
& mask
) != 0) {
1258 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
1260 /* If the device is known in the kernel and newly appeared, then we'll create a device unit for it,
1261 * under the name referenced in /proc/swaps or /proc/self/mountinfo. But first, let's validate if
1262 * everything is alright with the device node. Note that we're fine with missing device nodes,
1263 * but not with badly set up ones. */
1265 r
= sd_device_new_from_devname(&dev
, node
);
1267 log_debug("Could not find device for %s, continuing without device node", node
);
1269 /* Reduce log noise from nodes which are not device nodes by skipping EINVAL. */
1271 log_error_errno(r
, "Failed to open %s device, ignoring: %m", node
);
1275 (void) device_setup_unit(m
, dev
, node
, /* main = */ false, NULL
); /* 'dev' may be NULL. */
1278 /* Update the device unit's state, should it exist */
1279 (void) device_update_found_by_name(m
, node
, found
, mask
);
1282 bool device_shall_be_bound_by(Unit
*device
, Unit
*u
) {
1286 if (u
->type
!= UNIT_MOUNT
)
1289 return DEVICE(device
)->bind_mounts
;
1292 const UnitVTable device_vtable
= {
1293 .object_size
= sizeof(Device
),
1301 .init
= device_init
,
1302 .done
= device_done
,
1303 .load
= device_load
,
1305 .coldplug
= device_coldplug
,
1306 .catchup
= device_catchup
,
1308 .serialize
= device_serialize
,
1309 .deserialize_item
= device_deserialize_item
,
1311 .dump
= device_dump
,
1313 .active_state
= device_active_state
,
1314 .sub_state_to_string
= device_sub_state_to_string
,
1316 .following
= device_following
,
1317 .following_set
= device_following_set
,
1319 .enumerate
= device_enumerate
,
1320 .shutdown
= device_shutdown
,
1321 .supported
= udev_available
,
1323 .status_message_formats
= {
1324 .starting_stopping
= {
1325 [0] = "Expecting device %s...",
1326 [1] = "Waiting for device %s to disappear...",
1328 .finished_start_job
= {
1329 [JOB_DONE
] = "Found device %s.",
1330 [JOB_TIMEOUT
] = "Timed out waiting for device %s.",