2 This file is part of systemd.
4 Copyright 2010 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 #include <sys/epoll.h>
25 #include "alloc-util.h"
26 #include "dbus-device.h"
29 #include "parse-util.h"
30 #include "path-util.h"
31 #include "stat-util.h"
32 #include "string-util.h"
34 #include "udev-util.h"
35 #include "unit-name.h"
38 static const UnitActiveState state_translation_table
[_DEVICE_STATE_MAX
] = {
39 [DEVICE_DEAD
] = UNIT_INACTIVE
,
40 [DEVICE_TENTATIVE
] = UNIT_ACTIVATING
,
41 [DEVICE_PLUGGED
] = UNIT_ACTIVE
,
44 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
46 static void device_unset_sysfs(Device
*d
) {
55 /* Remove this unit from the chain of devices which share the
57 devices
= UNIT(d
)->manager
->devices_by_sysfs
;
58 first
= hashmap_get(devices
, d
->sysfs
);
59 LIST_REMOVE(same_sysfs
, first
, d
);
62 hashmap_remove_and_replace(devices
, d
->sysfs
, first
->sysfs
, first
);
64 hashmap_remove(devices
, d
->sysfs
);
66 d
->sysfs
= mfree(d
->sysfs
);
69 static int device_set_sysfs(Device
*d
, const char *sysfs
) {
76 if (streq_ptr(d
->sysfs
, sysfs
))
79 r
= hashmap_ensure_allocated(&UNIT(d
)->manager
->devices_by_sysfs
, &string_hash_ops
);
87 device_unset_sysfs(d
);
89 first
= hashmap_get(UNIT(d
)->manager
->devices_by_sysfs
, sysfs
);
90 LIST_PREPEND(same_sysfs
, first
, d
);
92 r
= hashmap_replace(UNIT(d
)->manager
->devices_by_sysfs
, copy
, first
);
94 LIST_REMOVE(same_sysfs
, first
, d
);
104 static void device_init(Unit
*u
) {
105 Device
*d
= DEVICE(u
);
108 assert(UNIT(d
)->load_state
== UNIT_STUB
);
110 /* In contrast to all other unit types we timeout jobs waiting
111 * for devices by default. This is because they otherwise wait
112 * indefinitely for plugged in devices, something which cannot
113 * happen for the other units since their operations time out
115 u
->job_timeout
= u
->manager
->default_timeout_start_usec
;
117 u
->ignore_on_isolate
= true;
120 static void device_done(Unit
*u
) {
121 Device
*d
= DEVICE(u
);
125 device_unset_sysfs(d
);
128 static void device_set_state(Device
*d
, DeviceState state
) {
129 DeviceState old_state
;
132 old_state
= d
->state
;
135 if (state
!= old_state
)
136 log_unit_debug(UNIT(d
), "Changed %s -> %s", device_state_to_string(old_state
), device_state_to_string(state
));
138 unit_notify(UNIT(d
), state_translation_table
[old_state
], state_translation_table
[state
], true);
141 static int device_coldplug(Unit
*u
) {
142 Device
*d
= DEVICE(u
);
145 assert(d
->state
== DEVICE_DEAD
);
147 if (d
->found
& DEVICE_FOUND_UDEV
)
148 /* If udev says the device is around, it's around */
149 device_set_state(d
, DEVICE_PLUGGED
);
150 else if (d
->found
!= DEVICE_NOT_FOUND
&& d
->deserialized_state
!= DEVICE_PLUGGED
)
151 /* If a device is found in /proc/self/mountinfo or
152 * /proc/swaps, and was not yet announced via udev,
153 * it's "tentatively" around. */
154 device_set_state(d
, DEVICE_TENTATIVE
);
159 static int device_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
160 Device
*d
= DEVICE(u
);
166 unit_serialize_item(u
, f
, "state", device_state_to_string(d
->state
));
171 static int device_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
172 Device
*d
= DEVICE(u
);
179 if (streq(key
, "state")) {
182 state
= device_state_from_string(value
);
184 log_unit_debug(u
, "Failed to parse state value: %s", value
);
186 d
->deserialized_state
= state
;
188 log_unit_debug(u
, "Unknown serialization key: %s", key
);
193 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
194 Device
*d
= DEVICE(u
);
199 "%sDevice State: %s\n"
200 "%sSysfs Path: %s\n",
201 prefix
, device_state_to_string(d
->state
),
202 prefix
, strna(d
->sysfs
));
205 _pure_
static UnitActiveState
device_active_state(Unit
*u
) {
208 return state_translation_table
[DEVICE(u
)->state
];
211 _pure_
static const char *device_sub_state_to_string(Unit
*u
) {
214 return device_state_to_string(DEVICE(u
)->state
);
217 static int device_update_description(Unit
*u
, struct udev_device
*dev
, const char *path
) {
225 model
= udev_device_get_property_value(dev
, "ID_MODEL_FROM_DATABASE");
227 model
= udev_device_get_property_value(dev
, "ID_MODEL");
232 /* Try to concatenate the device model string with a label, if there is one */
233 label
= udev_device_get_property_value(dev
, "ID_FS_LABEL");
235 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NAME");
237 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NUMBER");
240 _cleanup_free_
char *j
;
242 j
= strjoin(model
, " ", label
);
244 r
= unit_set_description(u
, j
);
248 r
= unit_set_description(u
, model
);
250 r
= unit_set_description(u
, path
);
253 log_unit_error_errno(u
, r
, "Failed to set device description: %m");
258 static int device_add_udev_wants(Unit
*u
, struct udev_device
*dev
) {
259 const char *wants
, *property
, *p
;
265 property
= MANAGER_IS_USER(u
->manager
) ? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
266 wants
= udev_device_get_property_value(dev
, property
);
268 _cleanup_free_
char *word
= NULL
, *k
= NULL
;
270 r
= extract_first_word(&p
, &word
, NULL
, EXTRACT_QUOTES
);
276 return log_unit_error_errno(u
, r
, "Failed to add parse %s: %m", property
);
278 r
= unit_name_mangle(word
, UNIT_NAME_NOGLOB
, &k
);
280 return log_unit_error_errno(u
, r
, "Failed to mangle unit name \"%s\": %m", word
);
282 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, k
, NULL
, true);
284 return log_unit_error_errno(u
, r
, "Failed to add wants dependency: %m");
288 static int device_setup_unit(Manager
*m
, struct udev_device
*dev
, const char *path
, bool main
) {
289 _cleanup_free_
char *e
= NULL
;
290 const char *sysfs
= NULL
;
299 sysfs
= udev_device_get_syspath(dev
);
304 r
= unit_name_from_path(path
, ".device", &e
);
306 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
308 u
= manager_get_unit(m
, e
);
310 /* The device unit can still be present even if the device was
311 * unplugged: a mount unit can reference it hence preventing
312 * the GC to have garbaged it. That's desired since the device
313 * unit may have a dependency on the mount unit which was
314 * added during the loading of the later. */
315 if (dev
&& u
&& DEVICE(u
)->state
== DEVICE_PLUGGED
) {
316 /* This unit is in plugged state: we're sure it's
317 * attached to a device. */
318 if (!path_equal(DEVICE(u
)->sysfs
, sysfs
)) {
319 log_unit_debug(u
, "Dev %s appeared twice with different sysfs paths %s and %s",
320 e
, DEVICE(u
)->sysfs
, sysfs
);
328 r
= unit_new_for_name(m
, sizeof(Device
), e
, &u
);
332 unit_add_to_load_queue(u
);
336 /* If this was created via some dependency and has not
337 * actually been seen yet ->sysfs will not be
338 * initialized. Hence initialize it if necessary. */
340 r
= device_set_sysfs(DEVICE(u
), sysfs
);
344 (void) device_update_description(u
, dev
, path
);
346 /* The additional systemd udev properties we only interpret
347 * for the main object */
349 (void) device_add_udev_wants(u
, dev
);
353 /* Note that this won't dispatch the load queue, the caller
354 * has to do that if needed and appropriate */
356 unit_add_to_dbus_queue(u
);
360 log_unit_warning_errno(u
, r
, "Failed to set up device unit: %m");
368 static int device_process_new(Manager
*m
, struct udev_device
*dev
) {
369 const char *sysfs
, *dn
, *alias
;
370 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
375 sysfs
= udev_device_get_syspath(dev
);
379 /* Add the main unit named after the sysfs path */
380 r
= device_setup_unit(m
, dev
, sysfs
, true);
384 /* Add an additional unit for the device node */
385 dn
= udev_device_get_devnode(dev
);
387 (void) device_setup_unit(m
, dev
, dn
, false);
389 /* Add additional units for all symlinks */
390 first
= udev_device_get_devlinks_list_entry(dev
);
391 udev_list_entry_foreach(item
, first
) {
395 /* Don't bother with the /dev/block links */
396 p
= udev_list_entry_get_name(item
);
398 if (path_startswith(p
, "/dev/block/") ||
399 path_startswith(p
, "/dev/char/"))
402 /* Verify that the symlink in the FS actually belongs
403 * to this device. This is useful to deal with
404 * conflicting devices, e.g. when two disks want the
405 * same /dev/disk/by-label/xxx link because they have
406 * the same label. We want to make sure that the same
407 * device that won the symlink wins in systemd, so we
408 * check the device node major/minor */
409 if (stat(p
, &st
) >= 0)
410 if ((!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
)) ||
411 st
.st_rdev
!= udev_device_get_devnum(dev
))
414 (void) device_setup_unit(m
, dev
, p
, false);
417 /* Add additional units for all explicitly configured
419 alias
= udev_device_get_property_value(dev
, "SYSTEMD_ALIAS");
421 _cleanup_free_
char *word
= NULL
, *k
= NULL
;
423 r
= extract_first_word(&alias
, &word
, NULL
, EXTRACT_QUOTES
);
429 return log_warning_errno(r
, "Failed to add parse SYSTEMD_ALIAS for %s: %m", sysfs
);
431 if (path_is_absolute(word
))
432 (void) device_setup_unit(m
, dev
, word
, false);
434 log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs
, word
);
438 static void device_update_found_one(Device
*d
, bool add
, DeviceFound found
, bool now
) {
439 DeviceFound n
, previous
;
443 n
= add
? (d
->found
| found
) : (d
->found
& ~found
);
453 /* Didn't exist before, but does now? if so, generate a new invocation ID for it */
454 if (previous
== DEVICE_NOT_FOUND
&& d
->found
!= DEVICE_NOT_FOUND
)
455 (void) unit_acquire_invocation_id(UNIT(d
));
457 if (d
->found
& DEVICE_FOUND_UDEV
)
458 /* When the device is known to udev we consider it
460 device_set_state(d
, DEVICE_PLUGGED
);
461 else if (d
->found
!= DEVICE_NOT_FOUND
&& (previous
& DEVICE_FOUND_UDEV
) == 0)
462 /* If the device has not been seen by udev yet, but is
463 * now referenced by the kernel, then we assume the
464 * kernel knows it now, and udev might soon too. */
465 device_set_state(d
, DEVICE_TENTATIVE
);
467 /* If nobody sees the device, or if the device was
468 * previously seen by udev and now is only referenced
469 * from the kernel, then we consider the device is
470 * gone, the kernel just hasn't noticed it yet. */
471 device_set_state(d
, DEVICE_DEAD
);
474 static int device_update_found_by_sysfs(Manager
*m
, const char *sysfs
, bool add
, DeviceFound found
, bool now
) {
480 if (found
== DEVICE_NOT_FOUND
)
483 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
484 LIST_FOREACH(same_sysfs
, d
, l
)
485 device_update_found_one(d
, add
, found
, now
);
490 static int device_update_found_by_name(Manager
*m
, const char *path
, bool add
, DeviceFound found
, bool now
) {
491 _cleanup_free_
char *e
= NULL
;
498 if (found
== DEVICE_NOT_FOUND
)
501 r
= unit_name_from_path(path
, ".device", &e
);
503 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
505 u
= manager_get_unit(m
, e
);
509 device_update_found_one(DEVICE(u
), add
, found
, now
);
513 static bool device_is_ready(struct udev_device
*dev
) {
518 ready
= udev_device_get_property_value(dev
, "SYSTEMD_READY");
522 return parse_boolean(ready
) != 0;
525 static Unit
*device_following(Unit
*u
) {
526 Device
*d
= DEVICE(u
);
527 Device
*other
, *first
= NULL
;
531 if (startswith(u
->id
, "sys-"))
534 /* Make everybody follow the unit that's named after the sysfs path */
535 for (other
= d
->same_sysfs_next
; other
; other
= other
->same_sysfs_next
)
536 if (startswith(UNIT(other
)->id
, "sys-"))
539 for (other
= d
->same_sysfs_prev
; other
; other
= other
->same_sysfs_prev
) {
540 if (startswith(UNIT(other
)->id
, "sys-"))
549 static int device_following_set(Unit
*u
, Set
**_set
) {
550 Device
*d
= DEVICE(u
), *other
;
557 if (LIST_JUST_US(same_sysfs
, d
)) {
566 LIST_FOREACH_AFTER(same_sysfs
, other
, d
) {
567 r
= set_put(set
, other
);
572 LIST_FOREACH_BEFORE(same_sysfs
, other
, d
) {
573 r
= set_put(set
, other
);
586 static void device_shutdown(Manager
*m
) {
589 m
->udev_event_source
= sd_event_source_unref(m
->udev_event_source
);
591 if (m
->udev_monitor
) {
592 udev_monitor_unref(m
->udev_monitor
);
593 m
->udev_monitor
= NULL
;
596 m
->devices_by_sysfs
= hashmap_free(m
->devices_by_sysfs
);
599 static void device_enumerate(Manager
*m
) {
600 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
601 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
606 if (!m
->udev_monitor
) {
607 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
608 if (!m
->udev_monitor
) {
613 /* This will fail if we are unprivileged, but that
614 * should not matter much, as user instances won't run
616 (void) udev_monitor_set_receive_buffer_size(m
->udev_monitor
, 128*1024*1024);
618 r
= udev_monitor_filter_add_match_tag(m
->udev_monitor
, "systemd");
620 log_error_errno(r
, "Failed to add udev tag match: %m");
624 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
626 log_error_errno(r
, "Failed to enable udev event reception: %m");
630 r
= sd_event_add_io(m
->event
, &m
->udev_event_source
, udev_monitor_get_fd(m
->udev_monitor
), EPOLLIN
, device_dispatch_io
, m
);
632 log_error_errno(r
, "Failed to watch udev file descriptor: %m");
636 (void) sd_event_source_set_description(m
->udev_event_source
, "device");
639 e
= udev_enumerate_new(m
->udev
);
645 r
= udev_enumerate_add_match_tag(e
, "systemd");
647 log_error_errno(r
, "Failed to create udev tag enumeration: %m");
651 r
= udev_enumerate_add_match_is_initialized(e
);
653 log_error_errno(r
, "Failed to install initialization match into enumeration: %m");
657 r
= udev_enumerate_scan_devices(e
);
659 log_error_errno(r
, "Failed to enumerate devices: %m");
663 first
= udev_enumerate_get_list_entry(e
);
664 udev_list_entry_foreach(item
, first
) {
665 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
668 sysfs
= udev_list_entry_get_name(item
);
670 dev
= udev_device_new_from_syspath(m
->udev
, sysfs
);
676 if (!device_is_ready(dev
))
679 (void) device_process_new(m
, dev
);
681 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, false);
690 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
691 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
692 Manager
*m
= userdata
;
693 const char *action
, *sysfs
;
698 if (revents
!= EPOLLIN
) {
699 static RATELIMIT_DEFINE(limit
, 10*USEC_PER_SEC
, 5);
701 if (!ratelimit_test(&limit
))
702 log_error_errno(errno
, "Failed to get udev event: %m");
703 if (!(revents
& EPOLLIN
))
708 * libudev might filter-out devices which pass the bloom
709 * filter, so getting NULL here is not necessarily an error.
711 dev
= udev_monitor_receive_device(m
->udev_monitor
);
715 sysfs
= udev_device_get_syspath(dev
);
717 log_error("Failed to get udev sys path.");
721 action
= udev_device_get_action(dev
);
723 log_error("Failed to get udev action string.");
727 if (streq(action
, "remove")) {
728 r
= swap_process_device_remove(m
, dev
);
730 log_error_errno(r
, "Failed to process swap device remove event: %m");
732 /* If we get notified that a device was removed by
733 * udev, then it's completely gone, hence unset all
735 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
|DEVICE_FOUND_MOUNT
|DEVICE_FOUND_SWAP
, true);
737 } else if (device_is_ready(dev
)) {
739 (void) device_process_new(m
, dev
);
741 r
= swap_process_device_new(m
, dev
);
743 log_error_errno(r
, "Failed to process swap device new event: %m");
745 manager_dispatch_load_queue(m
);
747 /* The device is found now, set the udev found bit */
748 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, true);
751 /* The device is nominally around, but not ready for
752 * us. Hence unset the udev bit, but leave the rest
755 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
, true);
761 static bool device_supported(void) {
762 static int read_only
= -1;
764 /* If /sys is read-only we don't support device units, and any
765 * attempts to start one should fail immediately. */
768 read_only
= path_is_read_only_fs("/sys");
770 return read_only
<= 0;
773 int device_found_node(Manager
*m
, const char *node
, bool add
, DeviceFound found
, bool now
) {
774 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
780 if (!device_supported())
783 /* This is called whenever we find a device referenced in
784 * /proc/swaps or /proc/self/mounts. Such a device might be
785 * mounted/enabled at a time where udev has not finished
786 * probing it yet, and we thus haven't learned about it
787 * yet. In this case we will set the device unit to
788 * "tentative" state. */
791 if (!path_startswith(node
, "/dev"))
794 /* We make an extra check here, if the device node
795 * actually exists. If it's missing, then this is an
796 * indication that device was unplugged but is still
797 * referenced in /proc/swaps or
798 * /proc/self/mountinfo. Note that this check doesn't
799 * really cover all cases where a device might be gone
800 * away, since drives that can have a medium inserted
801 * will still have a device node even when the medium
804 if (stat(node
, &st
) >= 0) {
805 if (!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
808 dev
= udev_device_new_from_devnum(m
->udev
, S_ISBLK(st
.st_mode
) ? 'b' : 'c', st
.st_rdev
);
809 if (!dev
&& errno
!= ENOENT
)
810 return log_error_errno(errno
, "Failed to get udev device from devnum %u:%u: %m", major(st
.st_rdev
), minor(st
.st_rdev
));
812 } else if (errno
!= ENOENT
)
813 return log_error_errno(errno
, "Failed to stat device node file %s: %m", node
);
815 /* If the device is known in the kernel and newly
816 * appeared, then we'll create a device unit for it,
817 * under the name referenced in /proc/swaps or
818 * /proc/self/mountinfo. */
820 (void) device_setup_unit(m
, dev
, node
, false);
823 /* Update the device unit's state, should it exist */
824 return device_update_found_by_name(m
, node
, add
, found
, now
);
827 const UnitVTable device_vtable
= {
828 .object_size
= sizeof(Device
),
838 .load
= unit_load_fragment_and_dropin_optional
,
840 .coldplug
= device_coldplug
,
842 .serialize
= device_serialize
,
843 .deserialize_item
= device_deserialize_item
,
847 .active_state
= device_active_state
,
848 .sub_state_to_string
= device_sub_state_to_string
,
850 .bus_vtable
= bus_device_vtable
,
852 .following
= device_following
,
853 .following_set
= device_following_set
,
855 .enumerate
= device_enumerate
,
856 .shutdown
= device_shutdown
,
857 .supported
= device_supported
,
859 .status_message_formats
= {
860 .starting_stopping
= {
861 [0] = "Expecting device %s...",
863 .finished_start_job
= {
864 [JOB_DONE
] = "Found device %s.",
865 [JOB_TIMEOUT
] = "Timed out waiting for device %s.",