1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 #include <sys/epoll.h>
27 #include "alloc-util.h"
28 #include "dbus-device.h"
31 #include "parse-util.h"
32 #include "path-util.h"
33 #include "stat-util.h"
34 #include "string-util.h"
36 #include "udev-util.h"
37 #include "unit-name.h"
40 static const UnitActiveState state_translation_table
[_DEVICE_STATE_MAX
] = {
41 [DEVICE_DEAD
] = UNIT_INACTIVE
,
42 [DEVICE_TENTATIVE
] = UNIT_ACTIVATING
,
43 [DEVICE_PLUGGED
] = UNIT_ACTIVE
,
46 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
48 static void device_unset_sysfs(Device
*d
) {
57 /* Remove this unit from the chain of devices which share the
59 devices
= UNIT(d
)->manager
->devices_by_sysfs
;
60 first
= hashmap_get(devices
, d
->sysfs
);
61 LIST_REMOVE(same_sysfs
, first
, d
);
64 hashmap_remove_and_replace(devices
, d
->sysfs
, first
->sysfs
, first
);
66 hashmap_remove(devices
, d
->sysfs
);
68 d
->sysfs
= mfree(d
->sysfs
);
71 static int device_set_sysfs(Device
*d
, const char *sysfs
) {
78 if (streq_ptr(d
->sysfs
, sysfs
))
81 r
= hashmap_ensure_allocated(&UNIT(d
)->manager
->devices_by_sysfs
, &string_hash_ops
);
89 device_unset_sysfs(d
);
91 first
= hashmap_get(UNIT(d
)->manager
->devices_by_sysfs
, sysfs
);
92 LIST_PREPEND(same_sysfs
, first
, d
);
94 r
= hashmap_replace(UNIT(d
)->manager
->devices_by_sysfs
, copy
, first
);
96 LIST_REMOVE(same_sysfs
, first
, d
);
106 static void device_init(Unit
*u
) {
107 Device
*d
= DEVICE(u
);
110 assert(UNIT(d
)->load_state
== UNIT_STUB
);
112 /* In contrast to all other unit types we timeout jobs waiting
113 * for devices by default. This is because they otherwise wait
114 * indefinitely for plugged in devices, something which cannot
115 * happen for the other units since their operations time out
117 u
->job_timeout
= u
->manager
->default_timeout_start_usec
;
119 u
->ignore_on_isolate
= true;
122 static void device_done(Unit
*u
) {
123 Device
*d
= DEVICE(u
);
127 device_unset_sysfs(d
);
130 static void device_set_state(Device
*d
, DeviceState state
) {
131 DeviceState old_state
;
134 old_state
= d
->state
;
137 if (state
!= old_state
)
138 log_unit_debug(UNIT(d
), "Changed %s -> %s", device_state_to_string(old_state
), device_state_to_string(state
));
140 unit_notify(UNIT(d
), state_translation_table
[old_state
], state_translation_table
[state
], true);
143 static int device_coldplug(Unit
*u
) {
144 Device
*d
= DEVICE(u
);
147 assert(d
->state
== DEVICE_DEAD
);
149 if (d
->found
& DEVICE_FOUND_UDEV
)
150 /* If udev says the device is around, it's around */
151 device_set_state(d
, DEVICE_PLUGGED
);
152 else if (d
->found
!= DEVICE_NOT_FOUND
&& d
->deserialized_state
!= DEVICE_PLUGGED
)
153 /* If a device is found in /proc/self/mountinfo or
154 * /proc/swaps, and was not yet announced via udev,
155 * it's "tentatively" around. */
156 device_set_state(d
, DEVICE_TENTATIVE
);
161 static int device_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
162 Device
*d
= DEVICE(u
);
168 unit_serialize_item(u
, f
, "state", device_state_to_string(d
->state
));
173 static int device_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
174 Device
*d
= DEVICE(u
);
181 if (streq(key
, "state")) {
184 state
= device_state_from_string(value
);
186 log_unit_debug(u
, "Failed to parse state value: %s", value
);
188 d
->deserialized_state
= state
;
190 log_unit_debug(u
, "Unknown serialization key: %s", key
);
195 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
196 Device
*d
= DEVICE(u
);
201 "%sDevice State: %s\n"
202 "%sSysfs Path: %s\n",
203 prefix
, device_state_to_string(d
->state
),
204 prefix
, strna(d
->sysfs
));
207 _pure_
static UnitActiveState
device_active_state(Unit
*u
) {
210 return state_translation_table
[DEVICE(u
)->state
];
213 _pure_
static const char *device_sub_state_to_string(Unit
*u
) {
216 return device_state_to_string(DEVICE(u
)->state
);
219 static int device_update_description(Unit
*u
, struct udev_device
*dev
, const char *path
) {
227 model
= udev_device_get_property_value(dev
, "ID_MODEL_FROM_DATABASE");
229 model
= udev_device_get_property_value(dev
, "ID_MODEL");
234 /* Try to concatenate the device model string with a label, if there is one */
235 label
= udev_device_get_property_value(dev
, "ID_FS_LABEL");
237 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NAME");
239 label
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NUMBER");
242 _cleanup_free_
char *j
;
244 j
= strjoin(model
, " ", label
, NULL
);
246 r
= unit_set_description(u
, j
);
250 r
= unit_set_description(u
, model
);
252 r
= unit_set_description(u
, path
);
255 log_unit_error_errno(u
, r
, "Failed to set device description: %m");
260 static int device_add_udev_wants(Unit
*u
, struct udev_device
*dev
) {
262 const char *word
, *state
;
265 const char *property
;
270 property
= u
->manager
->running_as
== MANAGER_USER
? "SYSTEMD_USER_WANTS" : "SYSTEMD_WANTS";
271 wants
= udev_device_get_property_value(dev
, property
);
275 FOREACH_WORD_QUOTED(word
, l
, wants
, state
) {
276 _cleanup_free_
char *n
= NULL
;
282 r
= unit_name_mangle(e
, UNIT_NAME_NOGLOB
, &n
);
284 return log_unit_error_errno(u
, r
, "Failed to mangle unit name: %m");
286 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, n
, NULL
, true);
288 return log_unit_error_errno(u
, r
, "Failed to add wants dependency: %m");
291 log_unit_warning(u
, "Property %s on %s has trailing garbage, ignoring.", property
, strna(udev_device_get_syspath(dev
)));
296 static int device_setup_unit(Manager
*m
, struct udev_device
*dev
, const char *path
, bool main
) {
297 _cleanup_free_
char *e
= NULL
;
298 const char *sysfs
= NULL
;
307 sysfs
= udev_device_get_syspath(dev
);
312 r
= unit_name_from_path(path
, ".device", &e
);
314 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
316 u
= manager_get_unit(m
, e
);
318 /* The device unit can still be present even if the device was
319 * unplugged: a mount unit can reference it hence preventing
320 * the GC to have garbaged it. That's desired since the device
321 * unit may have a dependency on the mount unit which was
322 * added during the loading of the later. */
323 if (u
&& DEVICE(u
)->state
== DEVICE_PLUGGED
) {
324 /* This unit is in plugged state: we're sure it's
325 * attached to a device. */
326 if (!path_equal(DEVICE(u
)->sysfs
, sysfs
)) {
327 log_unit_error(u
, "Dev %s appeared twice with different sysfs paths %s and %s",
328 e
, DEVICE(u
)->sysfs
, sysfs
);
336 u
= unit_new(m
, sizeof(Device
));
340 r
= unit_add_name(u
, e
);
344 unit_add_to_load_queue(u
);
348 /* If this was created via some dependency and has not
349 * actually been seen yet ->sysfs will not be
350 * initialized. Hence initialize it if necessary. */
352 r
= device_set_sysfs(DEVICE(u
), sysfs
);
356 (void) device_update_description(u
, dev
, path
);
358 /* The additional systemd udev properties we only interpret
359 * for the main object */
361 (void) device_add_udev_wants(u
, dev
);
365 /* Note that this won't dispatch the load queue, the caller
366 * has to do that if needed and appropriate */
368 unit_add_to_dbus_queue(u
);
372 log_unit_warning_errno(u
, r
, "Failed to set up device unit: %m");
380 static int device_process_new(Manager
*m
, struct udev_device
*dev
) {
381 const char *sysfs
, *dn
, *alias
;
382 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
387 sysfs
= udev_device_get_syspath(dev
);
391 /* Add the main unit named after the sysfs path */
392 r
= device_setup_unit(m
, dev
, sysfs
, true);
396 /* Add an additional unit for the device node */
397 dn
= udev_device_get_devnode(dev
);
399 (void) device_setup_unit(m
, dev
, dn
, false);
401 /* Add additional units for all symlinks */
402 first
= udev_device_get_devlinks_list_entry(dev
);
403 udev_list_entry_foreach(item
, first
) {
407 /* Don't bother with the /dev/block links */
408 p
= udev_list_entry_get_name(item
);
410 if (path_startswith(p
, "/dev/block/") ||
411 path_startswith(p
, "/dev/char/"))
414 /* Verify that the symlink in the FS actually belongs
415 * to this device. This is useful to deal with
416 * conflicting devices, e.g. when two disks want the
417 * same /dev/disk/by-label/xxx link because they have
418 * the same label. We want to make sure that the same
419 * device that won the symlink wins in systemd, so we
420 * check the device node major/minor */
421 if (stat(p
, &st
) >= 0)
422 if ((!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
)) ||
423 st
.st_rdev
!= udev_device_get_devnum(dev
))
426 (void) device_setup_unit(m
, dev
, p
, false);
429 /* Add additional units for all explicitly configured
431 alias
= udev_device_get_property_value(dev
, "SYSTEMD_ALIAS");
433 const char *word
, *state
;
436 FOREACH_WORD_QUOTED(word
, l
, alias
, state
) {
442 if (path_is_absolute(e
))
443 (void) device_setup_unit(m
, dev
, e
, false);
445 log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs
, e
);
448 log_warning("SYSTEMD_ALIAS for %s has trailing garbage, ignoring.", sysfs
);
454 static void device_update_found_one(Device
*d
, bool add
, DeviceFound found
, bool now
) {
455 DeviceFound n
, previous
;
459 n
= add
? (d
->found
| found
) : (d
->found
& ~found
);
469 if (d
->found
& DEVICE_FOUND_UDEV
)
470 /* When the device is known to udev we consider it
472 device_set_state(d
, DEVICE_PLUGGED
);
473 else if (d
->found
!= DEVICE_NOT_FOUND
&& (previous
& DEVICE_FOUND_UDEV
) == 0)
474 /* If the device has not been seen by udev yet, but is
475 * now referenced by the kernel, then we assume the
476 * kernel knows it now, and udev might soon too. */
477 device_set_state(d
, DEVICE_TENTATIVE
);
479 /* If nobody sees the device, or if the device was
480 * previously seen by udev and now is only referenced
481 * from the kernel, then we consider the device is
482 * gone, the kernel just hasn't noticed it yet. */
483 device_set_state(d
, DEVICE_DEAD
);
486 static int device_update_found_by_sysfs(Manager
*m
, const char *sysfs
, bool add
, DeviceFound found
, bool now
) {
492 if (found
== DEVICE_NOT_FOUND
)
495 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
496 LIST_FOREACH(same_sysfs
, d
, l
)
497 device_update_found_one(d
, add
, found
, now
);
502 static int device_update_found_by_name(Manager
*m
, const char *path
, bool add
, DeviceFound found
, bool now
) {
503 _cleanup_free_
char *e
= NULL
;
510 if (found
== DEVICE_NOT_FOUND
)
513 r
= unit_name_from_path(path
, ".device", &e
);
515 return log_error_errno(r
, "Failed to generate unit name from device path: %m");
517 u
= manager_get_unit(m
, e
);
521 device_update_found_one(DEVICE(u
), add
, found
, now
);
525 static bool device_is_ready(struct udev_device
*dev
) {
530 ready
= udev_device_get_property_value(dev
, "SYSTEMD_READY");
534 return parse_boolean(ready
) != 0;
537 static Unit
*device_following(Unit
*u
) {
538 Device
*d
= DEVICE(u
);
539 Device
*other
, *first
= NULL
;
543 if (startswith(u
->id
, "sys-"))
546 /* Make everybody follow the unit that's named after the sysfs path */
547 for (other
= d
->same_sysfs_next
; other
; other
= other
->same_sysfs_next
)
548 if (startswith(UNIT(other
)->id
, "sys-"))
551 for (other
= d
->same_sysfs_prev
; other
; other
= other
->same_sysfs_prev
) {
552 if (startswith(UNIT(other
)->id
, "sys-"))
561 static int device_following_set(Unit
*u
, Set
**_set
) {
562 Device
*d
= DEVICE(u
), *other
;
569 if (LIST_JUST_US(same_sysfs
, d
)) {
578 LIST_FOREACH_AFTER(same_sysfs
, other
, d
) {
579 r
= set_put(set
, other
);
584 LIST_FOREACH_BEFORE(same_sysfs
, other
, d
) {
585 r
= set_put(set
, other
);
598 static void device_shutdown(Manager
*m
) {
601 m
->udev_event_source
= sd_event_source_unref(m
->udev_event_source
);
603 if (m
->udev_monitor
) {
604 udev_monitor_unref(m
->udev_monitor
);
605 m
->udev_monitor
= NULL
;
608 m
->devices_by_sysfs
= hashmap_free(m
->devices_by_sysfs
);
611 static void device_enumerate(Manager
*m
) {
612 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
613 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
618 if (!m
->udev_monitor
) {
619 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
620 if (!m
->udev_monitor
) {
625 /* This will fail if we are unprivileged, but that
626 * should not matter much, as user instances won't run
628 (void) udev_monitor_set_receive_buffer_size(m
->udev_monitor
, 128*1024*1024);
630 r
= udev_monitor_filter_add_match_tag(m
->udev_monitor
, "systemd");
632 log_error_errno(r
, "Failed to add udev tag match: %m");
636 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
638 log_error_errno(r
, "Failed to enable udev event reception: %m");
642 r
= sd_event_add_io(m
->event
, &m
->udev_event_source
, udev_monitor_get_fd(m
->udev_monitor
), EPOLLIN
, device_dispatch_io
, m
);
644 log_error_errno(r
, "Failed to watch udev file descriptor: %m");
648 (void) sd_event_source_set_description(m
->udev_event_source
, "device");
651 e
= udev_enumerate_new(m
->udev
);
657 r
= udev_enumerate_add_match_tag(e
, "systemd");
659 log_error_errno(r
, "Failed to create udev tag enumeration: %m");
663 r
= udev_enumerate_add_match_is_initialized(e
);
665 log_error_errno(r
, "Failed to install initialization match into enumeration: %m");
669 r
= udev_enumerate_scan_devices(e
);
671 log_error_errno(r
, "Failed to enumerate devices: %m");
675 first
= udev_enumerate_get_list_entry(e
);
676 udev_list_entry_foreach(item
, first
) {
677 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
680 sysfs
= udev_list_entry_get_name(item
);
682 dev
= udev_device_new_from_syspath(m
->udev
, sysfs
);
688 if (!device_is_ready(dev
))
691 (void) device_process_new(m
, dev
);
693 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, false);
702 static int device_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
703 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
704 Manager
*m
= userdata
;
705 const char *action
, *sysfs
;
710 if (revents
!= EPOLLIN
) {
711 static RATELIMIT_DEFINE(limit
, 10*USEC_PER_SEC
, 5);
713 if (!ratelimit_test(&limit
))
714 log_error_errno(errno
, "Failed to get udev event: %m");
715 if (!(revents
& EPOLLIN
))
720 * libudev might filter-out devices which pass the bloom
721 * filter, so getting NULL here is not necessarily an error.
723 dev
= udev_monitor_receive_device(m
->udev_monitor
);
727 sysfs
= udev_device_get_syspath(dev
);
729 log_error("Failed to get udev sys path.");
733 action
= udev_device_get_action(dev
);
735 log_error("Failed to get udev action string.");
739 if (streq(action
, "remove")) {
740 r
= swap_process_device_remove(m
, dev
);
742 log_error_errno(r
, "Failed to process swap device remove event: %m");
744 /* If we get notified that a device was removed by
745 * udev, then it's completely gone, hence unset all
747 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
|DEVICE_FOUND_MOUNT
|DEVICE_FOUND_SWAP
, true);
749 } else if (device_is_ready(dev
)) {
751 (void) device_process_new(m
, dev
);
753 r
= swap_process_device_new(m
, dev
);
755 log_error_errno(r
, "Failed to process swap device new event: %m");
757 manager_dispatch_load_queue(m
);
759 /* The device is found now, set the udev found bit */
760 device_update_found_by_sysfs(m
, sysfs
, true, DEVICE_FOUND_UDEV
, true);
763 /* The device is nominally around, but not ready for
764 * us. Hence unset the udev bit, but leave the rest
767 device_update_found_by_sysfs(m
, sysfs
, false, DEVICE_FOUND_UDEV
, true);
773 static bool device_supported(void) {
774 static int read_only
= -1;
776 /* If /sys is read-only we don't support device units, and any
777 * attempts to start one should fail immediately. */
780 read_only
= path_is_read_only_fs("/sys");
782 return read_only
<= 0;
785 int device_found_node(Manager
*m
, const char *node
, bool add
, DeviceFound found
, bool now
) {
786 _cleanup_udev_device_unref_
struct udev_device
*dev
= NULL
;
792 if (!device_supported())
795 /* This is called whenever we find a device referenced in
796 * /proc/swaps or /proc/self/mounts. Such a device might be
797 * mounted/enabled at a time where udev has not finished
798 * probing it yet, and we thus haven't learned about it
799 * yet. In this case we will set the device unit to
800 * "tentative" state. */
803 if (!path_startswith(node
, "/dev"))
806 /* We make an extra check here, if the device node
807 * actually exists. If it's missing, then this is an
808 * indication that device was unplugged but is still
809 * referenced in /proc/swaps or
810 * /proc/self/mountinfo. Note that this check doesn't
811 * really cover all cases where a device might be gone
812 * away, since drives that can have a medium inserted
813 * will still have a device node even when the medium
816 if (stat(node
, &st
) >= 0) {
817 if (!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
820 dev
= udev_device_new_from_devnum(m
->udev
, S_ISBLK(st
.st_mode
) ? 'b' : 'c', st
.st_rdev
);
821 if (!dev
&& errno
!= ENOENT
)
822 return log_error_errno(errno
, "Failed to get udev device from devnum %u:%u: %m", major(st
.st_rdev
), minor(st
.st_rdev
));
824 } else if (errno
!= ENOENT
)
825 return log_error_errno(errno
, "Failed to stat device node file %s: %m", node
);
827 /* If the device is known in the kernel and newly
828 * appeared, then we'll create a device unit for it,
829 * under the name referenced in /proc/swaps or
830 * /proc/self/mountinfo. */
832 (void) device_setup_unit(m
, dev
, node
, false);
835 /* Update the device unit's state, should it exist */
836 return device_update_found_by_name(m
, node
, add
, found
, now
);
839 const UnitVTable device_vtable
= {
840 .object_size
= sizeof(Device
),
846 .no_instances
= true,
850 .load
= unit_load_fragment_and_dropin_optional
,
852 .coldplug
= device_coldplug
,
854 .serialize
= device_serialize
,
855 .deserialize_item
= device_deserialize_item
,
859 .active_state
= device_active_state
,
860 .sub_state_to_string
= device_sub_state_to_string
,
862 .bus_vtable
= bus_device_vtable
,
864 .following
= device_following
,
865 .following_set
= device_following_set
,
867 .enumerate
= device_enumerate
,
868 .shutdown
= device_shutdown
,
869 .supported
= device_supported
,
871 .status_message_formats
= {
872 .starting_stopping
= {
873 [0] = "Expecting device %s...",
875 .finished_start_job
= {
876 [JOB_DONE
] = "Found device %s.",
877 [JOB_TIMEOUT
] = "Timed out waiting for device %s.",