1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/epoll.h>
26 #include "alloc-util.h"
27 #include "dbus-device.h"
30 #include "parse-util.h"
31 #include "path-util.h"
32 #include "stat-util.h"
33 #include "string-util.h"
35 #include "udev-util.h"
36 #include "unit-name.h"
39 static const UnitActiveState state_translation_table
[_DEVICE_STATE_MAX
] = {
40 [DEVICE_DEAD
] = UNIT_INACTIVE
,
41 [DEVICE_TENTATIVE
] = UNIT_ACTIVATING
,
42 [DEVICE_PLUGGED
] = UNIT_ACTIVE
,
45 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
47 static void device_unset_sysfs(Device
*d
) {
56 /* Remove this unit from the chain of devices which share the
58 devices
= UNIT(d
)->manager
->devices_by_sysfs
;
59 first
= hashmap_get(devices
, d
->sysfs
);
60 LIST_REMOVE(same_sysfs
, first
, d
);
63 hashmap_remove_and_replace(devices
, d
->sysfs
, first
->sysfs
, first
);
65 hashmap_remove(devices
, d
->sysfs
);
67 d
->sysfs
= mfree(d
->sysfs
);
70 static int device_set_sysfs(Device
*d
, const char *sysfs
) {
77 if (streq_ptr(d
->sysfs
, sysfs
))
80 r
= hashmap_ensure_allocated(&UNIT(d
)->manager
->devices_by_sysfs
, &path_hash_ops
);
88 device_unset_sysfs(d
);
90 first
= hashmap_get(UNIT(d
)->manager
->devices_by_sysfs
, sysfs
);
91 LIST_PREPEND(same_sysfs
, first
, d
);
93 r
= hashmap_replace(UNIT(d
)->manager
->devices_by_sysfs
, copy
, first
);
95 LIST_REMOVE(same_sysfs
, first
, d
);
105 static void device_init(Unit
*u
) {
106 Device
*d
= DEVICE(u
);
109 assert(UNIT(d
)->load_state
== UNIT_STUB
);
111 /* In contrast to all other unit types we timeout jobs waiting
112 * for devices by default. This is because they otherwise wait
113 * indefinitely for plugged in devices, something which cannot
114 * happen for the other units since their operations time out
116 u
->job_running_timeout
= u
->manager
->default_timeout_start_usec
;
118 u
->ignore_on_isolate
= true;
121 static void device_done(Unit
*u
) {
122 Device
*d
= DEVICE(u
);
126 device_unset_sysfs(d
);
129 static void device_set_state(Device
*d
, DeviceState state
) {
130 DeviceState old_state
;
133 old_state
= d
->state
;
136 if (state
!= old_state
)
137 log_unit_debug(UNIT(d
), "Changed %s -> %s", device_state_to_string(old_state
), device_state_to_string(state
));
139 unit_notify(UNIT(d
), state_translation_table
[old_state
], state_translation_table
[state
], true);
142 static int device_coldplug(Unit
*u
) {
143 Device
*d
= DEVICE(u
);
146 assert(d
->state
== DEVICE_DEAD
);
148 if (d
->found
& DEVICE_FOUND_UDEV
)
149 /* If udev says the device is around, it's around */
150 device_set_state(d
, DEVICE_PLUGGED
);
151 else if (d
->found
!= DEVICE_NOT_FOUND
&& d
->deserialized_state
!= DEVICE_PLUGGED
)
152 /* If a device is found in /proc/self/mountinfo or
153 * /proc/swaps, and was not yet announced via udev,
154 * it's "tentatively" around. */
155 device_set_state(d
, DEVICE_TENTATIVE
);
160 static int device_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
161 Device
*d
= DEVICE(u
);
167 unit_serialize_item(u
, f
, "state", device_state_to_string(d
->state
));
172 static int device_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
173 Device
*d
= DEVICE(u
);
180 if (streq(key
, "state")) {
183 state
= device_state_from_string(value
);
185 log_unit_debug(u
, "Failed to parse state value: %s", value
);
187 d
->deserialized_state
= state
;
189 log_unit_debug(u
, "Unknown serialization key: %s", key
);
194 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
195 Device
*d
= DEVICE(u
);
200 "%sDevice State: %s\n"
201 "%sSysfs Path: %s\n",
202 prefix
, device_state_to_string(d
->state
),
203 prefix
, strna(d
->sysfs
));
206 _pure_
static UnitActiveState
device_active_state(Unit
*u
) {
209 return state_translation_table
[DEVICE(u
)->state
];
212 _pure_
static const char *device_sub_state_to_string(Unit
*u
) {
215 return device_state_to_string(DEVICE(u
)->state
);
218 static int device_update_description(Unit
*u
, struct udev_device
*dev
, const char *path
) {
226 model
= udev_device_get_property_value(dev
, "ID_MODEL_FROM_DATABASE");
228 model
= udev_device_get_property_value(dev
, "ID_MODEL");
233 /* Try to concatenate the device model string with a label, if there is one */
234 label
= udev_device_get_property_value(dev
, "ID_FS_LABEL");
236 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NAME");
238 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NUMBER");
241 _cleanup_free_
char *j
;
243 j
= strjoin(model
, " ", label
);
245 r
= unit_set_description(u
, j
);
249 r
= unit_set_description(u
, model
);
251 r
= unit_set_description(u
, path
);
254 log_unit_error_errno(u
, r
, "Failed to set device description: %m");
259 static int device_add_udev_wants(Unit
*u
, struct udev_device
*dev
) {
260 const char *wants
, *property
;
266 property
= MANAGER_IS_USER(u
->manager
) ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
268 wants
= udev_device_get_property_value(dev
, property
);
273 _cleanup_free_
char *word
= NULL
, *k
= NULL
;
275 r
= extract_first_word(&wants
, &word
, NULL
, EXTRACT_QUOTES
);
281 return log_unit_error_errno(u
, r
, "Failed to parse property %s with value %s: %m", property
, wants
);
283 if (unit_name_is_valid(word
, UNIT_NAME_TEMPLATE
) && DEVICE(u
)->sysfs
) {
284 _cleanup_free_
char *escaped
= NULL
;
286 /* If the unit name is specified as template, then automatically fill in the sysfs path of the
287 * device as instance name, properly escaped. */
289 r
= unit_name_path_escape(DEVICE(u
)->sysfs
, &escaped
);
291 return log_unit_error_errno(u
, r
, "Failed to escape %s: %m", DEVICE(u
)->sysfs
);
293 r
= unit_name_replace_instance(word
, escaped
, &k
);
295 return log_unit_error_errno(u
, r
, "Failed to build %s instance of template %s: %m", escaped
, word
);
297 /* If this is not a template, then let's mangle it so, that it becomes a valid unit name. */
299 r
= unit_name_mangle(word
, UNIT_NAME_MANGLE_WARN
, &k
);
301 return log_unit_error_errno(u
, r
, "Failed to mangle unit name \"%s\": %m", word
);
304 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, k
, NULL
, true, UNIT_DEPENDENCY_UDEV
);
306 return log_unit_error_errno(u
, r
, "Failed to add Wants= dependency: %m");
310 static bool device_is_bound_by_mounts(Device
*d
, struct udev_device
*dev
) {
311 const char *bound_by
;
317 bound_by
= udev_device_get_property_value(dev
, "SYSTEMD_MOUNT_DEVICE_BOUND");
319 r
= parse_boolean(bound_by
);
321 log_warning_errno(r
, "Failed to parse SYSTEMD_MOUNT_DEVICE_BOUND='%s' udev property of %s, ignoring: %m", bound_by
, strna(d
->sysfs
));
323 d
->bind_mounts
= r
> 0;
325 d
->bind_mounts
= false;
327 return d
->bind_mounts
;
330 static int device_upgrade_mount_deps(Unit
*u
) {
336 /* Let's upgrade Requires= to BindsTo= on us. (Used when SYSTEMD_MOUNT_DEVICE_BOUND is set) */
338 HASHMAP_FOREACH_KEY(v
, other
, u
->dependencies
[UNIT_REQUIRED_BY
], i
) {
339 if (other
->type
!= UNIT_MOUNT
)
342 r
= unit_add_dependency(other
, UNIT_BINDS_TO
, u
, true, UNIT_DEPENDENCY_UDEV
);
349 static int device_setup_unit(Manager
*m
, struct udev_device
*dev
, const char *path
, bool main
) {
350 _cleanup_free_
char *e
= NULL
;
351 const char *sysfs
= NULL
;
360 sysfs
= udev_device_get_syspath(dev
);
365 r
= unit_name_from_path(path
, ".device", &e
);
367 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
369 u
= manager_get_unit(m
, e
);
371 /* The device unit can still be present even if the device was unplugged: a mount unit can reference it hence
372 * preventing the GC to have garbaged it. That's desired since the device unit may have a dependency on the
373 * mount unit which was added during the loading of the later. */
374 if (dev
&& DEVICE(u
)->state
== DEVICE_PLUGGED
) {
376 /* This unit is in plugged state: we're sure it's attached to a device. */
377 if (!path_equal(DEVICE(u
)->sysfs
, sysfs
)) {
378 log_unit_debug(u
, "Dev %s appeared twice with different sysfs paths %s and %s",
379 e
, DEVICE(u
)->sysfs
, sysfs
);
386 /* Let's remove all dependencies generated due to udev properties. We'll readd whatever is configured
388 unit_remove_dependencies(u
, UNIT_DEPENDENCY_UDEV
);
392 r
= unit_new_for_name(m
, sizeof(Device
), e
, &u
);
396 unit_add_to_load_queue(u
);
399 /* If this was created via some dependency and has not
400 * actually been seen yet ->sysfs will not be
401 * initialized. Hence initialize it if necessary. */
403 r
= device_set_sysfs(DEVICE(u
), sysfs
);
407 (void) device_update_description(u
, dev
, path
);
409 /* The additional systemd udev properties we only interpret
410 * for the main object */
412 (void) device_add_udev_wants(u
, dev
);
415 /* So the user wants the mount units to be bound to the device but a mount unit might has been seen by systemd
416 * before the device appears on its radar. In this case the device unit is partially initialized and includes
417 * the deps on the mount unit but at that time the "bind mounts" flag wasn't not present. Fix this up now. */
418 if (dev
&& device_is_bound_by_mounts(DEVICE(u
), dev
))
419 device_upgrade_mount_deps(u
);
421 /* Note that this won't dispatch the load queue, the caller has to do that if needed and appropriate */
423 unit_add_to_dbus_queue(u
);
427 log_unit_warning_errno(u
, r
, "Failed to set up device unit: %m");
435 static int device_process_new(Manager
*m
, struct udev_device
*dev
) {
436 const char *sysfs
, *dn
, *alias
;
437 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
442 sysfs
= udev_device_get_syspath(dev
);
446 /* Add the main unit named after the sysfs path */
447 r
= device_setup_unit(m
, dev
, sysfs
, true);
451 /* Add an additional unit for the device node */
452 dn
= udev_device_get_devnode(dev
);
454 (void) device_setup_unit(m
, dev
, dn
, false);
456 /* Add additional units for all symlinks */
457 first
= udev_device_get_devlinks_list_entry(dev
);
458 udev_list_entry_foreach(item
, first
) {
462 /* Don't bother with the /dev/block links */
463 p
= udev_list_entry_get_name(item
);
465 if (path_startswith(p
, "/dev/block/") ||
466 path_startswith(p
, "/dev/char/"))
469 /* Verify that the symlink in the FS actually belongs
470 * to this device. This is useful to deal with
471 * conflicting devices, e.g. when two disks want the
472 * same /dev/disk/by-label/xxx link because they have
473 * the same label. We want to make sure that the same
474 * device that won the symlink wins in systemd, so we
475 * check the device node major/minor */
476 if (stat(p
, &st
) >= 0)
477 if ((!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
)) ||
478 st
.st_rdev
!= udev_device_get_devnum(dev
))
481 (void) device_setup_unit(m
, dev
, p
, false);
484 /* Add additional units for all explicitly configured
486 alias
= udev_device_get_property_value(dev
, "SYSTEMD_ALIAS");
488 _cleanup_free_
char *word
= NULL
;
490 r
= extract_first_word(&alias
, &word
, NULL
, EXTRACT_QUOTES
);
496 return log_warning_errno(r
, "Failed to add parse SYSTEMD_ALIAS for %s: %m", sysfs
);
498 if (path_is_absolute(word
))
499 (void) device_setup_unit(m
, dev
, word
, false);
501 log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs
, word
);
505 static void device_update_found_one(Device
*d
, bool add
, DeviceFound found
, bool now
) {
506 DeviceFound n
, previous
;
510 n
= add
? (d
->found
| found
) : (d
->found
& ~found
);
520 /* Didn't exist before, but does now? if so, generate a new invocation ID for it */
521 if (previous
== DEVICE_NOT_FOUND
&& d
->found
!= DEVICE_NOT_FOUND
)
522 (void) unit_acquire_invocation_id(UNIT(d
));
524 if (d
->found
& DEVICE_FOUND_UDEV
)
525 /* When the device is known to udev we consider it
527 device_set_state(d
, DEVICE_PLUGGED
);
528 else if (d
->found
!= DEVICE_NOT_FOUND
&& (previous
& DEVICE_FOUND_UDEV
) == 0)
529 /* If the device has not been seen by udev yet, but is
530 * now referenced by the kernel, then we assume the
531 * kernel knows it now, and udev might soon too. */
532 device_set_state(d
, DEVICE_TENTATIVE
);
534 /* If nobody sees the device, or if the device was
535 * previously seen by udev and now is only referenced
536 * from the kernel, then we consider the device is
537 * gone, the kernel just hasn't noticed it yet. */
539 device_set_state(d
, DEVICE_DEAD
);
540 device_unset_sysfs(d
);
545 static int device_update_found_by_sysfs(Manager
*m
, const char *sysfs
, bool add
, DeviceFound found
, bool now
) {
551 if (found
== DEVICE_NOT_FOUND
)
554 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
555 LIST_FOREACH_SAFE(same_sysfs
, d
, n
, l
)
556 device_update_found_one(d
, add
, found
, now
);
561 static int device_update_found_by_name(Manager
*m
, const char *path
, bool add
, DeviceFound found
, bool now
) {
562 _cleanup_free_
char *e
= NULL
;
569 if (found
== DEVICE_NOT_FOUND
)
572 r
= unit_name_from_path(path
, ".device", &e
);
574 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
576 u
= manager_get_unit(m
, e
);
580 device_update_found_one(DEVICE(u
), add
, found
, now
);
584 static bool device_is_ready(struct udev_device
*dev
) {
589 ready
= udev_device_get_property_value(dev
, "SYSTEMD_READY");
593 return parse_boolean(ready
) != 0;
596 static Unit
*device_following(Unit
*u
) {
597 Device
*d
= DEVICE(u
);
598 Device
*other
, *first
= NULL
;
602 if (startswith(u
->id
, "sys-"))
605 /* Make everybody follow the unit that's named after the sysfs path */
606 for (other
= d
->same_sysfs_next
; other
; other
= other
->same_sysfs_next
)
607 if (startswith(UNIT(other
)->id
, "sys-"))
610 for (other
= d
->same_sysfs_prev
; other
; other
= other
->same_sysfs_prev
) {
611 if (startswith(UNIT(other
)->id
, "sys-"))
620 static int device_following_set(Unit
*u
, Set
**_set
) {
621 Device
*d
= DEVICE(u
), *other
;
628 if (LIST_JUST_US(same_sysfs
, d
)) {
637 LIST_FOREACH_AFTER(same_sysfs
, other
, d
) {
638 r
= set_put(set
, other
);
643 LIST_FOREACH_BEFORE(same_sysfs
, other
, d
) {
644 r
= set_put(set
, other
);
657 static void device_shutdown(Manager
*m
) {
660 m
->udev_event_source
= sd_event_source_unref(m
->udev_event_source
);
662 if (m
->udev_monitor
) {
663 udev_monitor_unref(m
->udev_monitor
);
664 m
->udev_monitor
= NULL
;
667 m
->devices_by_sysfs
= hashmap_free(m
->devices_by_sysfs
);
670 static void device_enumerate(Manager
*m
) {
671 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
672 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
677 if (!m
->udev_monitor
) {
678 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
679 if (!m
->udev_monitor
) {
684 /* This will fail if we are unprivileged, but that
685 * should not matter much, as user instances won't run
687 (void) udev_monitor_set_receive_buffer_size(m
->udev_monitor
, 128*1024*1024);
689 r
= udev_monitor_filter_add_match_tag(m
->udev_monitor
, "systemd");
691 log_error_errno(r
, "Failed to add udev tag match: %m");
695 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
697 log_error_errno(r
, "Failed to enable udev event reception: %m");
701 r
= sd_event_add_io(m
->event
, &m
->udev_event_source
, udev_monitor_get_fd(m
->udev_monitor
), EPOLLIN
, device_dispatch_io
, m
);
703 log_error_errno(r
, "Failed to watch udev file descriptor: %m");
707 (void) sd_event_source_set_description(m
->udev_event_source
, "device");
710 e
= udev_enumerate_new(m
->udev
);
716 r
= udev_enumerate_add_match_tag(e
, "systemd");
718 log_error_errno(r
, "Failed to create udev tag enumeration: %m");
722 r
= udev_enumerate_add_match_is_initialized(e
);
724 log_error_errno(r
, "Failed to install initialization match into enumeration: %m");
728 r
= udev_enumerate_scan_devices(e
);
730 log_error_errno(r
, "Failed to enumerate devices: %m");
734 first
= udev_enumerate_get_list_entry(e
);
735 udev_list_entry_foreach(item
, first
) {
736 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
739 sysfs
= udev_list_entry_get_name(item
);
741 dev
= udev_device_new_from_syspath(m
->udev
, sysfs
);
747 if (!device_is_ready(dev
))
750 (void) device_process_new(m
, dev
);
752 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, false);
761 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
762 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
763 Manager
*m
= userdata
;
764 const char *action
, *sysfs
;
769 if (revents
!= EPOLLIN
) {
770 static RATELIMIT_DEFINE(limit
, 10*USEC_PER_SEC
, 5);
772 if (!ratelimit_test(&limit
))
773 log_error_errno(errno
, "Failed to get udev event: %m");
774 if (!(revents
& EPOLLIN
))
779 * libudev might filter-out devices which pass the bloom
780 * filter, so getting NULL here is not necessarily an error.
782 dev
= udev_monitor_receive_device(m
->udev_monitor
);
786 sysfs
= udev_device_get_syspath(dev
);
788 log_error("Failed to get udev sys path.");
792 action
= udev_device_get_action(dev
);
794 log_error("Failed to get udev action string.");
798 if (streq(action
, "change")) {
802 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
803 LIST_FOREACH_SAFE(same_sysfs
, d
, n
, l
) {
805 if (u
&& UNIT_VTABLE(u
)->active_state(u
) == UNIT_ACTIVE
) {
806 r
= manager_propagate_reload(m
, u
, JOB_REPLACE
, NULL
);
808 log_error_errno(r
, "Failed to propagate reload: %m");
813 /* A change event can signal that a device is becoming ready, in particular if
814 * the device is using the SYSTEMD_READY logic in udev
815 * so we need to reach the else block of the follwing if, even for change events */
816 if (streq(action
, "remove")) {
817 r
= swap_process_device_remove(m
, dev
);
819 log_error_errno(r
, "Failed to process swap device remove event: %m");
821 /* If we get notified that a device was removed by
822 * udev, then it's completely gone, hence unset all
824 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
|DEVICE_FOUND_MOUNT
|DEVICE_FOUND_SWAP
, true);
826 } else if (device_is_ready(dev
)) {
828 (void) device_process_new(m
, dev
);
830 r
= swap_process_device_new(m
, dev
);
832 log_error_errno(r
, "Failed to process swap device new event: %m");
834 manager_dispatch_load_queue(m
);
836 /* The device is found now, set the udev found bit */
837 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, true);
840 /* The device is nominally around, but not ready for
841 * us. Hence unset the udev bit, but leave the rest
844 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
, true);
850 static bool device_supported(void) {
851 static int read_only
= -1;
853 /* If /sys is read-only we don't support device units, and any
854 * attempts to start one should fail immediately. */
857 read_only
= path_is_read_only_fs("/sys");
859 return read_only
<= 0;
862 int device_found_node(Manager
*m
, const char *node
, bool add
, DeviceFound found
, bool now
) {
863 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
869 if (!device_supported())
872 /* This is called whenever we find a device referenced in
873 * /proc/swaps or /proc/self/mounts. Such a device might be
874 * mounted/enabled at a time where udev has not finished
875 * probing it yet, and we thus haven't learned about it
876 * yet. In this case we will set the device unit to
877 * "tentative" state. */
880 if (!path_startswith(node
, "/dev"))
883 /* We make an extra check here, if the device node
884 * actually exists. If it's missing, then this is an
885 * indication that device was unplugged but is still
886 * referenced in /proc/swaps or
887 * /proc/self/mountinfo. Note that this check doesn't
888 * really cover all cases where a device might be gone
889 * away, since drives that can have a medium inserted
890 * will still have a device node even when the medium
893 if (stat(node
, &st
) >= 0) {
894 if (!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
897 dev
= udev_device_new_from_devnum(m
->udev
, S_ISBLK(st
.st_mode
) ? 'b' : 'c', st
.st_rdev
);
898 if (!dev
&& errno
!= ENOENT
)
899 return log_error_errno(errno
, "Failed to get udev device from devnum %u:%u: %m", major(st
.st_rdev
), minor(st
.st_rdev
));
901 } else if (errno
!= ENOENT
)
902 return log_error_errno(errno
, "Failed to stat device node file %s: %m", node
);
904 /* If the device is known in the kernel and newly
905 * appeared, then we'll create a device unit for it,
906 * under the name referenced in /proc/swaps or
907 * /proc/self/mountinfo. */
909 (void) device_setup_unit(m
, dev
, node
, false);
912 /* Update the device unit's state, should it exist */
913 return device_update_found_by_name(m
, node
, add
, found
, now
);
916 bool device_shall_be_bound_by(Unit
*device
, Unit
*u
) {
918 if (u
->type
!= UNIT_MOUNT
)
921 return DEVICE(device
)->bind_mounts
;
924 const UnitVTable device_vtable
= {
925 .object_size
= sizeof(Device
),
935 .load
= unit_load_fragment_and_dropin_optional
,
937 .coldplug
= device_coldplug
,
939 .serialize
= device_serialize
,
940 .deserialize_item
= device_deserialize_item
,
944 .active_state
= device_active_state
,
945 .sub_state_to_string
= device_sub_state_to_string
,
947 .bus_vtable
= bus_device_vtable
,
949 .following
= device_following
,
950 .following_set
= device_following_set
,
952 .enumerate
= device_enumerate
,
953 .shutdown
= device_shutdown
,
954 .supported
= device_supported
,
956 .status_message_formats
= {
957 .starting_stopping
= {
958 [0] = "Expecting device %s...",
960 .finished_start_job
= {
961 [JOB_DONE
] = "Found device %s.",
962 [JOB_TIMEOUT
] = "Timed out waiting for device %s.",