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 General Public License as published by
10 the Free Software Foundation; either version 2 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 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 #include <sys/epoll.h>
30 #include "unit-name.h"
31 #include "dbus-device.h"
34 static const UnitActiveState state_translation_table
[_DEVICE_STATE_MAX
] = {
35 [DEVICE_DEAD
] = UNIT_INACTIVE
,
36 [DEVICE_PLUGGED
] = UNIT_ACTIVE
39 static void device_unset_sysfs(Device
*d
) {
47 /* Remove this unit from the chain of devices which share the
49 first
= hashmap_get(d
->meta
.manager
->devices_by_sysfs
, d
->sysfs
);
50 LIST_REMOVE(Device
, same_sysfs
, first
, d
);
53 hashmap_remove_and_replace(d
->meta
.manager
->devices_by_sysfs
, d
->sysfs
, first
->sysfs
, first
);
55 hashmap_remove(d
->meta
.manager
->devices_by_sysfs
, d
->sysfs
);
61 static void device_init(Unit
*u
) {
62 Device
*d
= DEVICE(u
);
65 assert(d
->meta
.load_state
== UNIT_STUB
);
67 /* In contrast to all other unit types we timeout jobs waiting
68 * for devices by default. This is because they otherwise wait
69 * indefinitely for plugged in devices, something which cannot
70 * happen for the other units since their operations time out
72 d
->meta
.job_timeout
= DEFAULT_TIMEOUT_USEC
;
75 static void device_done(Unit
*u
) {
76 Device
*d
= DEVICE(u
);
80 device_unset_sysfs(d
);
83 static void device_set_state(Device
*d
, DeviceState state
) {
84 DeviceState old_state
;
90 if (state
!= old_state
)
91 log_debug("%s changed %s -> %s",
93 device_state_to_string(old_state
),
94 device_state_to_string(state
));
96 unit_notify(UNIT(d
), state_translation_table
[old_state
], state_translation_table
[state
], true);
99 static int device_coldplug(Unit
*u
) {
100 Device
*d
= DEVICE(u
);
103 assert(d
->state
== DEVICE_DEAD
);
106 device_set_state(d
, DEVICE_PLUGGED
);
111 static void device_dump(Unit
*u
, FILE *f
, const char *prefix
) {
112 Device
*d
= DEVICE(u
);
117 "%sDevice State: %s\n"
118 "%sSysfs Path: %s\n",
119 prefix
, device_state_to_string(d
->state
),
120 prefix
, strna(d
->sysfs
));
123 static UnitActiveState
device_active_state(Unit
*u
) {
126 return state_translation_table
[DEVICE(u
)->state
];
129 static const char *device_sub_state_to_string(Unit
*u
) {
132 return device_state_to_string(DEVICE(u
)->state
);
135 static int device_add_escaped_name(Unit
*u
, const char *dn
) {
141 assert(dn
[0] == '/');
143 if (!(e
= unit_name_from_path(dn
, ".device")))
146 r
= unit_add_name(u
, e
);
149 if (r
< 0 && r
!= -EEXIST
)
155 static int device_find_escape_name(Manager
*m
, const char *dn
, Unit
**_u
) {
161 assert(dn
[0] == '/');
164 if (!(e
= unit_name_from_path(dn
, ".device")))
167 u
= manager_get_unit(m
, e
);
178 static int device_update_unit(Manager
*m
, struct udev_device
*dev
, const char *path
, bool main
) {
179 const char *sysfs
, *model
;
186 if (!(sysfs
= udev_device_get_syspath(dev
)))
189 if ((r
= device_find_escape_name(m
, path
, &u
)) < 0)
192 if (u
&& DEVICE(u
)->sysfs
&& !path_equal(DEVICE(u
)->sysfs
, sysfs
))
198 if (!(u
= unit_new(m
)))
201 if ((r
= device_add_escaped_name(u
, path
)) < 0)
204 unit_add_to_load_queue(u
);
208 /* If this was created via some dependency and has not
209 * actually been seen yet ->sysfs will not be
210 * initialized. Hence initialize it if necessary. */
212 if (!DEVICE(u
)->sysfs
) {
215 if (!(DEVICE(u
)->sysfs
= strdup(sysfs
))) {
220 if (!m
->devices_by_sysfs
)
221 if (!(m
->devices_by_sysfs
= hashmap_new(string_hash_func
, string_compare_func
))) {
226 first
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
227 LIST_PREPEND(Device
, same_sysfs
, first
, DEVICE(u
));
229 if ((r
= hashmap_replace(m
->devices_by_sysfs
, DEVICE(u
)->sysfs
, first
)) < 0)
233 if ((model
= udev_device_get_property_value(dev
, "ID_MODEL_FROM_DATABASE")) ||
234 (model
= udev_device_get_property_value(dev
, "ID_MODEL"))) {
235 if ((r
= unit_set_description(u
, model
)) < 0)
238 if ((r
= unit_set_description(u
, path
)) < 0)
242 /* The additional systemd udev properties we only
243 * interpret for the main object */
244 const char *wants
, *alias
;
246 if ((alias
= udev_device_get_property_value(dev
, "SYSTEMD_ALIAS"))) {
248 log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs
, alias
);
250 if ((r
= device_add_escaped_name(u
, alias
)) < 0)
255 if ((wants
= udev_device_get_property_value(dev
, "SYSTEMD_WANTS"))) {
259 FOREACH_WORD_QUOTED(w
, l
, wants
, state
) {
262 if (!(e
= strndup(w
, l
))) {
267 r
= unit_add_dependency_by_name(u
, UNIT_WANTS
, e
, NULL
, true);
276 unit_add_to_dbus_queue(u
);
280 log_warning("Failed to load device unit: %s", strerror(-r
));
288 static int device_process_new_device(Manager
*m
, struct udev_device
*dev
, bool update_state
) {
289 const char *sysfs
, *dn
;
290 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
294 if (!(sysfs
= udev_device_get_syspath(dev
)))
297 /* Add the main unit named after the sysfs path */
298 device_update_unit(m
, dev
, sysfs
, true);
300 /* Add an additional unit for the device node */
301 if ((dn
= udev_device_get_devnode(dev
)))
302 device_update_unit(m
, dev
, dn
, false);
304 /* Add additional units for all symlinks */
305 first
= udev_device_get_devlinks_list_entry(dev
);
306 udev_list_entry_foreach(item
, first
) {
310 /* Don't bother with the /dev/block links */
311 p
= udev_list_entry_get_name(item
);
313 if (path_startswith(p
, "/dev/block/") ||
314 path_startswith(p
, "/dev/char/"))
317 /* Verify that the symlink in the FS actually belongs
318 * to this device. This is useful to deal with
319 * conflicting devices, e.g. when two disks want the
320 * same /dev/disk/by-label/xxx link because they have
321 * the same label. We want to make sure that the same
322 * device that won the symlink wins in systemd, so we
323 * check the device node major/minor*/
324 if (stat(p
, &st
) >= 0)
325 if ((!S_ISBLK(st
.st_mode
) && !S_ISCHR(st
.st_mode
)) ||
326 st
.st_rdev
!= udev_device_get_devnum(dev
))
329 device_update_unit(m
, dev
, p
, false);
335 manager_dispatch_load_queue(m
);
337 l
= hashmap_get(m
->devices_by_sysfs
, sysfs
);
338 LIST_FOREACH(same_sysfs
, d
, l
)
339 device_set_state(d
, DEVICE_PLUGGED
);
345 static int device_process_path(Manager
*m
, const char *path
, bool update_state
) {
347 struct udev_device
*dev
;
352 if (!(dev
= udev_device_new_from_syspath(m
->udev
, path
))) {
353 log_warning("Failed to get udev device object from udev for path %s.", path
);
357 r
= device_process_new_device(m
, dev
, update_state
);
358 udev_device_unref(dev
);
362 static int device_process_removed_device(Manager
*m
, struct udev_device
*dev
) {
369 if (!(sysfs
= udev_device_get_syspath(dev
)))
372 /* Remove all units of this sysfs path */
373 while ((d
= hashmap_get(m
->devices_by_sysfs
, sysfs
))) {
374 device_unset_sysfs(d
);
375 device_set_state(d
, DEVICE_DEAD
);
381 static Unit
*device_following(Unit
*u
) {
382 Device
*d
= DEVICE(u
);
383 Device
*other
, *first
= NULL
;
387 if (startswith(u
->meta
.id
, "sys-"))
390 /* Make everybody follow the unit that's named after the sysfs path */
391 for (other
= d
->same_sysfs_next
; other
; other
= other
->same_sysfs_next
)
392 if (startswith(other
->meta
.id
, "sys-"))
395 for (other
= d
->same_sysfs_prev
; other
; other
= other
->same_sysfs_prev
) {
396 if (startswith(other
->meta
.id
, "sys-"))
405 static int device_following_set(Unit
*u
, Set
**_s
) {
406 Device
*d
= DEVICE(u
);
414 if (!d
->same_sysfs_prev
&& !d
->same_sysfs_next
) {
419 if (!(s
= set_new(NULL
, NULL
)))
422 for (other
= d
->same_sysfs_next
; other
; other
= other
->same_sysfs_next
)
423 if ((r
= set_put(s
, other
)) < 0)
426 for (other
= d
->same_sysfs_prev
; other
; other
= other
->same_sysfs_prev
)
427 if ((r
= set_put(s
, other
)) < 0)
438 static void device_shutdown(Manager
*m
) {
441 if (m
->udev_monitor
) {
442 udev_monitor_unref(m
->udev_monitor
);
443 m
->udev_monitor
= NULL
;
451 hashmap_free(m
->devices_by_sysfs
);
452 m
->devices_by_sysfs
= NULL
;
455 static int device_enumerate(Manager
*m
) {
456 struct epoll_event ev
;
458 struct udev_enumerate
*e
= NULL
;
459 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
464 if (!(m
->udev
= udev_new()))
467 if (!(m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev"))) {
472 /* This will fail if we are unprivileged, but that
473 * should not matter much, as user instances won't run
475 udev_monitor_set_receive_buffer_size(m
->udev_monitor
, 128*1024*1024);
477 if (udev_monitor_filter_add_match_tag(m
->udev_monitor
, "systemd") < 0) {
482 if (udev_monitor_enable_receiving(m
->udev_monitor
) < 0) {
487 m
->udev_watch
.type
= WATCH_UDEV
;
488 m
->udev_watch
.fd
= udev_monitor_get_fd(m
->udev_monitor
);
492 ev
.data
.ptr
= &m
->udev_watch
;
494 if (epoll_ctl(m
->epoll_fd
, EPOLL_CTL_ADD
, m
->udev_watch
.fd
, &ev
) < 0)
498 if (!(e
= udev_enumerate_new(m
->udev
))) {
502 if (udev_enumerate_add_match_tag(e
, "systemd") < 0) {
507 if (udev_enumerate_scan_devices(e
) < 0) {
512 first
= udev_enumerate_get_list_entry(e
);
513 udev_list_entry_foreach(item
, first
)
514 device_process_path(m
, udev_list_entry_get_name(item
), false);
516 udev_enumerate_unref(e
);
521 udev_enumerate_unref(e
);
527 void device_fd_event(Manager
*m
, int events
) {
528 struct udev_device
*dev
;
530 const char *action
, *ready
;
534 if (events
!= EPOLLIN
) {
535 static RATELIMIT_DEFINE(limit
, 10*USEC_PER_SEC
, 5);
537 if (!ratelimit_test(&limit
))
538 log_error("Failed to get udev event: %m");
539 if (!(events
& EPOLLIN
))
543 if (!(dev
= udev_monitor_receive_device(m
->udev_monitor
))) {
545 * libudev might filter-out devices which pass the bloom filter,
546 * so getting NULL here is not necessarily an error
551 if (!(action
= udev_device_get_action(dev
))) {
552 log_error("Failed to get udev action string.");
556 ready
= udev_device_get_property_value(dev
, "SYSTEMD_READY");
558 if (streq(action
, "remove") || (ready
&& parse_boolean(ready
) == 0)) {
559 if ((r
= device_process_removed_device(m
, dev
)) < 0) {
560 log_error("Failed to process udev device event: %s", strerror(-r
));
564 if ((r
= device_process_new_device(m
, dev
, true)) < 0) {
565 log_error("Failed to process udev device event: %s", strerror(-r
));
571 udev_device_unref(dev
);
574 static const char* const device_state_table
[_DEVICE_STATE_MAX
] = {
575 [DEVICE_DEAD
] = "dead",
576 [DEVICE_PLUGGED
] = "plugged"
579 DEFINE_STRING_TABLE_LOOKUP(device_state
, DeviceState
);
581 const UnitVTable device_vtable
= {
584 .no_instances
= true,
585 .no_snapshots
= true,
590 .load
= unit_load_fragment_and_dropin_optional
,
592 .coldplug
= device_coldplug
,
596 .active_state
= device_active_state
,
597 .sub_state_to_string
= device_sub_state_to_string
,
599 .bus_interface
= "org.freedesktop.systemd1.Device",
600 .bus_message_handler
= bus_device_message_handler
,
601 .bus_invalidating_properties
= bus_device_invalidating_properties
,
603 .following
= device_following
,
604 .following_set
= device_following_set
,
606 .enumerate
= device_enumerate
,
607 .shutdown
= device_shutdown