1 /* SPDX-License-Identifier: GPL-2.0+ */
3 * Copyright © 2004 Chris Friesen <chris_friesen@sympatico.ca>
4 * Copyright © 2009 Canonical Ltd.
5 * Copyright © 2009 Scott James Remnant <scott@netsplit.com>
17 #include <sys/epoll.h>
19 #include <sys/inotify.h>
20 #include <sys/ioctl.h>
21 #include <sys/mount.h>
22 #include <sys/prctl.h>
23 #include <sys/signalfd.h>
24 #include <sys/socket.h>
30 #include "sd-daemon.h"
33 #include "alloc-util.h"
34 #include "cgroup-util.h"
35 #include "cpu-set-util.h"
36 #include "dev-setup.h"
37 #include "device-monitor-private.h"
38 #include "device-private.h"
39 #include "device-util.h"
40 #include "event-util.h"
43 #include "format-util.h"
47 #include "libudev-device-internal.h"
49 #include "main-func.h"
51 #include "netlink-util.h"
52 #include "parse-util.h"
53 #include "pretty-print.h"
54 #include "proc-cmdline.h"
55 #include "process-util.h"
56 #include "selinux-util.h"
57 #include "signal-util.h"
58 #include "socket-util.h"
59 #include "string-util.h"
62 #include "syslog-util.h"
63 #include "udev-builtin.h"
64 #include "udev-ctrl.h"
65 #include "udev-util.h"
66 #include "udev-watch.h"
68 #include "user-util.h"
70 static bool arg_debug
= false;
71 static int arg_daemonize
= false;
72 static ResolveNameTiming arg_resolve_name_timing
= RESOLVE_NAME_EARLY
;
73 static unsigned arg_children_max
= 0;
74 static usec_t arg_exec_delay_usec
= 0;
75 static usec_t arg_event_timeout_usec
= 180 * USEC_PER_SEC
;
77 typedef struct Manager
{
80 LIST_HEAD(struct event
, events
);
82 pid_t pid
; /* the process that originally allocated the manager object */
89 sd_device_monitor
*monitor
;
90 struct udev_ctrl
*ctrl
;
91 struct udev_ctrl_connection
*ctrl_conn_blocking
;
95 sd_event_source
*ctrl_event
;
96 sd_event_source
*uevent_event
;
97 sd_event_source
*inotify_event
;
98 sd_event_source
*kill_workers_event
;
102 bool stop_exec_queue
:1;
114 struct worker
*worker
;
115 enum event_state state
;
118 sd_device
*dev_kernel
; /* clone of originally received device */
121 uint64_t delaying_seqnum
;
123 sd_event_source
*timeout_warning_event
;
124 sd_event_source
*timeout_event
;
126 LIST_FIELDS(struct event
, event
);
129 static void event_queue_cleanup(Manager
*manager
, enum event_state type
);
141 sd_device_monitor
*monitor
;
142 enum worker_state state
;
146 /* passed from worker to main process */
147 struct worker_message
{
150 static void event_free(struct event
*event
) {
154 assert(event
->manager
);
156 LIST_REMOVE(event
, event
->manager
->events
, event
);
157 sd_device_unref(event
->dev
);
158 sd_device_unref(event
->dev_kernel
);
160 sd_event_source_unref(event
->timeout_warning_event
);
161 sd_event_source_unref(event
->timeout_event
);
164 event
->worker
->event
= NULL
;
166 /* only clean up the queue from the process that created it */
167 if (LIST_IS_EMPTY(event
->manager
->events
) &&
168 event
->manager
->pid
== getpid_cached())
169 if (unlink("/run/udev/queue") < 0)
170 log_warning_errno(errno
, "Failed to unlink /run/udev/queue: %m");
175 static void worker_free(struct worker
*worker
) {
179 assert(worker
->manager
);
181 hashmap_remove(worker
->manager
->workers
, PID_TO_PTR(worker
->pid
));
182 sd_device_monitor_unref(worker
->monitor
);
183 event_free(worker
->event
);
188 static void manager_workers_free(Manager
*manager
) {
189 struct worker
*worker
;
194 HASHMAP_FOREACH(worker
, manager
->workers
, i
)
197 manager
->workers
= hashmap_free(manager
->workers
);
200 static int worker_new(struct worker
**ret
, Manager
*manager
, sd_device_monitor
*worker_monitor
, pid_t pid
) {
201 _cleanup_free_
struct worker
*worker
= NULL
;
206 assert(worker_monitor
);
209 worker
= new0(struct worker
, 1);
213 worker
->manager
= manager
;
214 /* close monitor, but keep address around */
215 device_monitor_disconnect(worker_monitor
);
216 worker
->monitor
= sd_device_monitor_ref(worker_monitor
);
219 r
= hashmap_ensure_allocated(&manager
->workers
, NULL
);
223 r
= hashmap_put(manager
->workers
, PID_TO_PTR(pid
), worker
);
227 *ret
= TAKE_PTR(worker
);
232 static int on_event_timeout(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
233 struct event
*event
= userdata
;
236 assert(event
->worker
);
238 kill_and_sigcont(event
->worker
->pid
, SIGKILL
);
239 event
->worker
->state
= WORKER_KILLED
;
241 log_device_error(event
->dev
, "Worker ["PID_FMT
"] processing SEQNUM=%"PRIu64
" killed", event
->worker
->pid
, event
->seqnum
);
246 static int on_event_timeout_warning(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
247 struct event
*event
= userdata
;
250 assert(event
->worker
);
252 log_device_warning(event
->dev
, "Worker ["PID_FMT
"] processing SEQNUM=%"PRIu64
" is taking a long time", event
->worker
->pid
, event
->seqnum
);
257 static void worker_attach_event(struct worker
*worker
, struct event
*event
) {
262 assert(worker
->manager
);
264 assert(!event
->worker
);
265 assert(!worker
->event
);
267 worker
->state
= WORKER_RUNNING
;
268 worker
->event
= event
;
269 event
->state
= EVENT_RUNNING
;
270 event
->worker
= worker
;
272 e
= worker
->manager
->event
;
274 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &usec
) >= 0);
276 (void) sd_event_add_time(e
, &event
->timeout_warning_event
, CLOCK_MONOTONIC
,
277 usec
+ udev_warn_timeout(arg_event_timeout_usec
), USEC_PER_SEC
, on_event_timeout_warning
, event
);
279 (void) sd_event_add_time(e
, &event
->timeout_event
, CLOCK_MONOTONIC
,
280 usec
+ arg_event_timeout_usec
, USEC_PER_SEC
, on_event_timeout
, event
);
283 static void manager_clear_for_worker(Manager
*manager
) {
286 manager
->ctrl_event
= sd_event_source_unref(manager
->ctrl_event
);
287 manager
->uevent_event
= sd_event_source_unref(manager
->uevent_event
);
288 manager
->inotify_event
= sd_event_source_unref(manager
->inotify_event
);
289 manager
->kill_workers_event
= sd_event_source_unref(manager
->kill_workers_event
);
291 manager
->event
= sd_event_unref(manager
->event
);
293 manager_workers_free(manager
);
294 event_queue_cleanup(manager
, EVENT_UNDEF
);
296 manager
->monitor
= sd_device_monitor_unref(manager
->monitor
);
297 manager
->ctrl_conn_blocking
= udev_ctrl_connection_unref(manager
->ctrl_conn_blocking
);
298 manager
->ctrl
= udev_ctrl_unref(manager
->ctrl
);
300 manager
->worker_watch
[READ_END
] = safe_close(manager
->worker_watch
[READ_END
]);
303 static void manager_free(Manager
*manager
) {
309 manager_clear_for_worker(manager
);
311 sd_netlink_unref(manager
->rtnl
);
313 hashmap_free_free_free(manager
->properties
);
314 udev_rules_free(manager
->rules
);
316 safe_close(manager
->fd_inotify
);
317 safe_close_pair(manager
->worker_watch
);
322 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager
*, manager_free
);
324 static int worker_send_message(int fd
) {
325 struct worker_message message
= {};
327 return loop_write(fd
, &message
, sizeof(message
), false);
330 static int worker_lock_block_device(sd_device
*dev
, int *ret_fd
) {
331 _cleanup_close_
int fd
= -1;
339 * Take a shared lock on the device node; this establishes
340 * a concept of device "ownership" to serialize device
341 * access. External processes holding an exclusive lock will
342 * cause udev to skip the event handling; in the case udev
343 * acquired the lock, the external process can block until
344 * udev has finished its event handling.
347 r
= sd_device_get_property_value(dev
, "ACTION", &val
);
349 return log_device_debug_errno(dev
, r
, "Failed to get the value of property 'ACTION': %m");
351 if (streq(val
, "remove"))
354 r
= sd_device_get_subsystem(dev
, &val
);
356 return log_device_debug_errno(dev
, r
, "Failed to get subsystem: %m");
358 if (!streq(val
, "block"))
361 r
= sd_device_get_sysname(dev
, &val
);
363 return log_device_debug_errno(dev
, r
, "Failed to get sysname: %m");
365 if (STARTSWITH_SET(val
, "dm-", "md", "drbd"))
368 r
= sd_device_get_devtype(dev
, &val
);
369 if (r
< 0 && r
!= -ENOENT
)
370 return log_device_debug_errno(dev
, r
, "Failed to get devtype: %m");
371 if (r
>= 0 && streq(val
, "partition")) {
372 r
= sd_device_get_parent(dev
, &dev
);
374 return log_device_debug_errno(dev
, r
, "Failed to get parent device: %m");
377 r
= sd_device_get_devname(dev
, &val
);
381 return log_device_debug_errno(dev
, r
, "Failed to get devname: %m");
383 fd
= open(val
, O_RDONLY
|O_CLOEXEC
|O_NOFOLLOW
|O_NONBLOCK
);
385 log_device_debug_errno(dev
, errno
, "Failed to open '%s', ignoring: %m", val
);
389 if (flock(fd
, LOCK_SH
|LOCK_NB
) < 0)
390 return log_device_debug_errno(dev
, errno
, "Failed to flock(%s): %m", val
);
392 *ret_fd
= TAKE_FD(fd
);
396 static int worker_process_device(Manager
*manager
, sd_device
*dev
) {
397 _cleanup_(udev_event_freep
) UdevEvent
*udev_event
= NULL
;
398 _cleanup_close_
int fd_lock
= -1;
405 r
= sd_device_get_property_value(dev
, "SEQNUM", &seqnum
);
407 log_device_debug_errno(dev
, r
, "Failed to get SEQNUM: %m");
409 log_device_debug(dev
, "Processing device (SEQNUM=%s)", seqnum
);
411 udev_event
= udev_event_new(dev
, arg_exec_delay_usec
, manager
->rtnl
);
415 r
= worker_lock_block_device(dev
, &fd_lock
);
419 /* apply rules, create node, symlinks */
420 udev_event_execute_rules(udev_event
, arg_event_timeout_usec
, manager
->properties
, manager
->rules
);
421 udev_event_execute_run(udev_event
, arg_event_timeout_usec
);
424 /* in case rtnl was initialized */
425 manager
->rtnl
= sd_netlink_ref(udev_event
->rtnl
);
427 /* apply/restore inotify watch */
428 if (udev_event
->inotify_watch
) {
429 (void) udev_watch_begin(dev
);
430 r
= device_update_db(dev
);
432 return log_device_debug_errno(dev
, r
, "Failed to update database under /run/udev/data/: %m");
435 log_device_debug(dev
, "Device (SEQNUM=%s) processed", seqnum
);
440 static int worker_device_monitor_handler(sd_device_monitor
*monitor
, sd_device
*dev
, void *userdata
) {
441 Manager
*manager
= userdata
;
447 r
= worker_process_device(manager
, dev
);
449 log_device_warning_errno(dev
, r
, "Failed to process device, ignoring: %m");
451 /* send processed event back to libudev listeners */
452 r
= device_monitor_send_device(monitor
, NULL
, dev
);
454 log_device_warning_errno(dev
, r
, "Failed to send device, ignoring: %m");
456 /* send udevd the result of the event execution */
457 r
= worker_send_message(manager
->worker_watch
[WRITE_END
]);
459 log_device_warning_errno(dev
, r
, "Failed to send signal to main daemon, ignoring: %m");
464 static int worker_main(Manager
*_manager
, sd_device_monitor
*monitor
, sd_device
*first_device
) {
465 _cleanup_(sd_device_unrefp
) sd_device
*dev
= first_device
;
466 _cleanup_(manager_freep
) Manager
*manager
= _manager
;
473 unsetenv("NOTIFY_SOCKET");
475 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGTERM
, -1) >= 0);
477 /* Reset OOM score, we only protect the main daemon. */
478 r
= set_oom_score_adjust(0);
480 log_debug_errno(r
, "Failed to reset OOM score, ignoring: %m");
482 /* Clear unnecessary data in Manager object.*/
483 manager_clear_for_worker(manager
);
485 r
= sd_event_new(&manager
->event
);
487 return log_error_errno(r
, "Failed to allocate event loop: %m");
489 r
= sd_event_add_signal(manager
->event
, NULL
, SIGTERM
, NULL
, NULL
);
491 return log_error_errno(r
, "Failed to set SIGTERM event: %m");
493 r
= sd_device_monitor_attach_event(monitor
, manager
->event
);
495 return log_error_errno(r
, "Failed to attach event loop to device monitor: %m");
497 r
= sd_device_monitor_start(monitor
, worker_device_monitor_handler
, manager
);
499 return log_error_errno(r
, "Failed to start device monitor: %m");
501 (void) sd_event_source_set_description(sd_device_monitor_get_event_source(monitor
), "worker-device-monitor");
503 /* Process first device */
504 (void) worker_device_monitor_handler(monitor
, dev
, manager
);
506 r
= sd_event_loop(manager
->event
);
508 return log_error_errno(r
, "Event loop failed: %m");
510 r
= sd_event_get_exit_code(manager
->event
, &ret
);
512 return log_error_errno(r
, "Failed to get exit code: %m");
517 static int worker_spawn(Manager
*manager
, struct event
*event
) {
518 _cleanup_(sd_device_monitor_unrefp
) sd_device_monitor
*worker_monitor
= NULL
;
519 struct worker
*worker
;
523 /* listen for new events */
524 r
= device_monitor_new_full(&worker_monitor
, MONITOR_GROUP_NONE
, -1);
528 /* allow the main daemon netlink address to send devices to the worker */
529 r
= device_monitor_allow_unicast_sender(worker_monitor
, manager
->monitor
);
531 return log_error_errno(r
, "Worker: Failed to set unicast sender: %m");
533 r
= device_monitor_enable_receiving(worker_monitor
);
535 return log_error_errno(r
, "Worker: Failed to enable receiving of device: %m");
537 r
= safe_fork("(worker)", FORK_DEATHSIG
, &pid
);
539 event
->state
= EVENT_QUEUED
;
540 return log_error_errno(r
, "Failed to fork() worker: %m");
544 r
= worker_main(manager
, worker_monitor
, sd_device_ref(event
->dev
));
546 _exit(r
< 0 ? EXIT_FAILURE
: EXIT_SUCCESS
);
549 r
= worker_new(&worker
, manager
, worker_monitor
, pid
);
551 return log_error_errno(r
, "Failed to create worker object: %m");
553 worker_attach_event(worker
, event
);
555 log_device_debug(event
->dev
, "Worker ["PID_FMT
"] is forked for processing SEQNUM=%"PRIu64
".", pid
, event
->seqnum
);
559 static void event_run(Manager
*manager
, struct event
*event
) {
560 struct worker
*worker
;
567 HASHMAP_FOREACH(worker
, manager
->workers
, i
) {
568 if (worker
->state
!= WORKER_IDLE
)
571 r
= device_monitor_send_device(manager
->monitor
, worker
->monitor
, event
->dev
);
573 log_device_error_errno(event
->dev
, r
, "Worker ["PID_FMT
"] did not accept message, killing the worker: %m",
575 (void) kill(worker
->pid
, SIGKILL
);
576 worker
->state
= WORKER_KILLED
;
579 worker_attach_event(worker
, event
);
583 if (hashmap_size(manager
->workers
) >= arg_children_max
) {
584 if (arg_children_max
> 1)
585 log_debug("Maximum number (%u) of children reached.", hashmap_size(manager
->workers
));
589 /* start new worker and pass initial device */
590 worker_spawn(manager
, event
);
593 static int event_queue_insert(Manager
*manager
, sd_device
*dev
) {
594 _cleanup_(sd_device_unrefp
) sd_device
*clone
= NULL
;
603 /* only one process can add events to the queue */
604 if (manager
->pid
== 0)
605 manager
->pid
= getpid_cached();
607 assert(manager
->pid
== getpid_cached());
609 /* We only accepts devices received by device monitor. */
610 r
= sd_device_get_property_value(dev
, "SEQNUM", &val
);
614 r
= safe_atou64(val
, &seqnum
);
621 /* Save original device to restore the state on failures. */
622 r
= device_shallow_clone(dev
, &clone
);
626 r
= device_copy_properties(clone
, dev
);
630 event
= new(struct event
, 1);
634 *event
= (struct event
) {
636 .dev
= sd_device_ref(dev
),
637 .dev_kernel
= TAKE_PTR(clone
),
639 .state
= EVENT_QUEUED
,
642 if (LIST_IS_EMPTY(manager
->events
)) {
643 r
= touch("/run/udev/queue");
645 log_warning_errno(r
, "Failed to touch /run/udev/queue: %m");
648 LIST_APPEND(event
, manager
->events
, event
);
651 if (sd_device_get_property_value(dev
, "ACTION", &val
) < 0)
654 log_device_debug(dev
, "Device (SEQNUM=%"PRIu64
", ACTION=%s) is queued", seqnum
, strnull(val
));
660 static void manager_kill_workers(Manager
*manager
) {
661 struct worker
*worker
;
666 HASHMAP_FOREACH(worker
, manager
->workers
, i
) {
667 if (worker
->state
== WORKER_KILLED
)
670 worker
->state
= WORKER_KILLED
;
671 (void) kill(worker
->pid
, SIGTERM
);
675 /* lookup event for identical, parent, child device */
676 static int is_device_busy(Manager
*manager
, struct event
*event
) {
677 const char *subsystem
, *devpath
, *devpath_old
= NULL
;
678 dev_t devnum
= makedev(0, 0);
679 struct event
*loop_event
;
684 r
= sd_device_get_subsystem(event
->dev
, &subsystem
);
688 is_block
= streq(subsystem
, "block");
690 r
= sd_device_get_devpath(event
->dev
, &devpath
);
694 devpath_len
= strlen(devpath
);
696 r
= sd_device_get_property_value(event
->dev
, "DEVPATH_OLD", &devpath_old
);
697 if (r
< 0 && r
!= -ENOENT
)
700 r
= sd_device_get_devnum(event
->dev
, &devnum
);
701 if (r
< 0 && r
!= -ENOENT
)
704 r
= sd_device_get_ifindex(event
->dev
, &ifindex
);
705 if (r
< 0 && r
!= -ENOENT
)
708 /* check if queue contains events we depend on */
709 LIST_FOREACH(event
, loop_event
, manager
->events
) {
710 size_t loop_devpath_len
, common
;
711 const char *loop_devpath
;
713 /* we already found a later event, earlier cannot block us, no need to check again */
714 if (loop_event
->seqnum
< event
->delaying_seqnum
)
717 /* event we checked earlier still exists, no need to check again */
718 if (loop_event
->seqnum
== event
->delaying_seqnum
)
721 /* found ourself, no later event can block us */
722 if (loop_event
->seqnum
>= event
->seqnum
)
725 /* check major/minor */
726 if (major(devnum
) != 0) {
730 if (sd_device_get_subsystem(loop_event
->dev
, &s
) < 0)
733 if (sd_device_get_devnum(loop_event
->dev
, &d
) >= 0 &&
734 devnum
== d
&& is_block
== streq(s
, "block"))
738 /* check network device ifindex */
742 if (sd_device_get_ifindex(loop_event
->dev
, &i
) >= 0 &&
747 if (sd_device_get_devpath(loop_event
->dev
, &loop_devpath
) < 0)
750 /* check our old name */
751 if (devpath_old
&& streq(devpath_old
, loop_devpath
)) {
752 event
->delaying_seqnum
= loop_event
->seqnum
;
756 loop_devpath_len
= strlen(loop_devpath
);
758 /* compare devpath */
759 common
= MIN(devpath_len
, loop_devpath_len
);
761 /* one devpath is contained in the other? */
762 if (!strneq(devpath
, loop_devpath
, common
))
765 /* identical device event found */
766 if (devpath_len
== loop_devpath_len
) {
767 /* devices names might have changed/swapped in the meantime */
768 if (major(devnum
) != 0 || ifindex
> 0)
770 event
->delaying_seqnum
= loop_event
->seqnum
;
774 /* parent device event found */
775 if (devpath
[common
] == '/') {
776 event
->delaying_seqnum
= loop_event
->seqnum
;
780 /* child device event found */
781 if (loop_devpath
[common
] == '/') {
782 event
->delaying_seqnum
= loop_event
->seqnum
;
790 static int on_exit_timeout(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
791 Manager
*manager
= userdata
;
795 log_error("Giving up waiting for workers to finish.");
796 sd_event_exit(manager
->event
, -ETIMEDOUT
);
801 static void manager_exit(Manager
*manager
) {
807 manager
->exit
= true;
811 "STATUS=Starting shutdown...");
813 /* close sources of new events and discard buffered events */
814 manager
->ctrl_event
= sd_event_source_unref(manager
->ctrl_event
);
815 manager
->ctrl
= udev_ctrl_unref(manager
->ctrl
);
817 manager
->inotify_event
= sd_event_source_unref(manager
->inotify_event
);
818 manager
->fd_inotify
= safe_close(manager
->fd_inotify
);
820 manager
->uevent_event
= sd_event_source_unref(manager
->uevent_event
);
821 manager
->monitor
= sd_device_monitor_unref(manager
->monitor
);
823 /* discard queued events and kill workers */
824 event_queue_cleanup(manager
, EVENT_QUEUED
);
825 manager_kill_workers(manager
);
827 assert_se(sd_event_now(manager
->event
, CLOCK_MONOTONIC
, &usec
) >= 0);
829 r
= sd_event_add_time(manager
->event
, NULL
, CLOCK_MONOTONIC
,
830 usec
+ 30 * USEC_PER_SEC
, USEC_PER_SEC
, on_exit_timeout
, manager
);
835 /* reload requested, HUP signal received, rules changed, builtin changed */
836 static void manager_reload(Manager
*manager
) {
842 "STATUS=Flushing configuration...");
844 manager_kill_workers(manager
);
845 manager
->rules
= udev_rules_free(manager
->rules
);
850 "STATUS=Processing with %u children at max", arg_children_max
);
853 static int on_kill_workers_event(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
854 Manager
*manager
= userdata
;
858 log_debug("Cleanup idle workers");
859 manager_kill_workers(manager
);
864 static void event_queue_start(Manager
*manager
) {
871 if (LIST_IS_EMPTY(manager
->events
) ||
872 manager
->exit
|| manager
->stop_exec_queue
)
875 assert_se(sd_event_now(manager
->event
, CLOCK_MONOTONIC
, &usec
) >= 0);
876 /* check for changed config, every 3 seconds at most */
877 if (manager
->last_usec
== 0 ||
878 (usec
- manager
->last_usec
) > 3 * USEC_PER_SEC
) {
879 if (udev_rules_check_timestamp(manager
->rules
) ||
880 udev_builtin_validate())
881 manager_reload(manager
);
883 manager
->last_usec
= usec
;
886 r
= event_source_disable(manager
->kill_workers_event
);
888 log_warning_errno(r
, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
892 if (!manager
->rules
) {
893 r
= udev_rules_new(&manager
->rules
, arg_resolve_name_timing
);
895 log_warning_errno(r
, "Failed to read udev rules: %m");
900 LIST_FOREACH(event
, event
, manager
->events
) {
901 if (event
->state
!= EVENT_QUEUED
)
904 /* do not start event if parent or child event is still running */
905 if (is_device_busy(manager
, event
) != 0)
908 event_run(manager
, event
);
912 static void event_queue_cleanup(Manager
*manager
, enum event_state match_type
) {
913 struct event
*event
, *tmp
;
915 LIST_FOREACH_SAFE(event
, event
, tmp
, manager
->events
) {
916 if (match_type
!= EVENT_UNDEF
&& match_type
!= event
->state
)
923 static int on_worker(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
924 Manager
*manager
= userdata
;
929 struct worker_message msg
;
930 struct iovec iovec
= {
932 .iov_len
= sizeof(msg
),
935 struct cmsghdr cmsghdr
;
936 uint8_t buf
[CMSG_SPACE(sizeof(struct ucred
))];
938 struct msghdr msghdr
= {
941 .msg_control
= &control
,
942 .msg_controllen
= sizeof(control
),
944 struct cmsghdr
*cmsg
;
946 struct ucred
*ucred
= NULL
;
947 struct worker
*worker
;
949 size
= recvmsg(fd
, &msghdr
, MSG_DONTWAIT
);
953 else if (errno
== EAGAIN
)
954 /* nothing more to read */
957 return log_error_errno(errno
, "Failed to receive message: %m");
958 } else if (size
!= sizeof(struct worker_message
)) {
959 log_warning("Ignoring worker message with invalid size %zi bytes", size
);
963 CMSG_FOREACH(cmsg
, &msghdr
) {
964 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
965 cmsg
->cmsg_type
== SCM_CREDENTIALS
&&
966 cmsg
->cmsg_len
== CMSG_LEN(sizeof(struct ucred
)))
967 ucred
= (struct ucred
*) CMSG_DATA(cmsg
);
970 if (!ucred
|| ucred
->pid
<= 0) {
971 log_warning("Ignoring worker message without valid PID");
975 /* lookup worker who sent the signal */
976 worker
= hashmap_get(manager
->workers
, PID_TO_PTR(ucred
->pid
));
978 log_debug("Worker ["PID_FMT
"] returned, but is no longer tracked", ucred
->pid
);
982 if (worker
->state
!= WORKER_KILLED
)
983 worker
->state
= WORKER_IDLE
;
985 /* worker returned */
986 event_free(worker
->event
);
989 /* we have free workers, try to schedule events */
990 event_queue_start(manager
);
995 static int on_uevent(sd_device_monitor
*monitor
, sd_device
*dev
, void *userdata
) {
996 Manager
*manager
= userdata
;
1001 device_ensure_usec_initialized(dev
, NULL
);
1003 r
= event_queue_insert(manager
, dev
);
1005 log_device_error_errno(dev
, r
, "Failed to insert device into event queue: %m");
1009 /* we have fresh events, try to schedule them */
1010 event_queue_start(manager
);
1015 /* receive the udevd message from userspace */
1016 static int on_ctrl_msg(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
1017 Manager
*manager
= userdata
;
1018 _cleanup_(udev_ctrl_connection_unrefp
) struct udev_ctrl_connection
*ctrl_conn
= NULL
;
1019 _cleanup_(udev_ctrl_msg_unrefp
) struct udev_ctrl_msg
*ctrl_msg
= NULL
;
1025 ctrl_conn
= udev_ctrl_get_connection(manager
->ctrl
);
1029 ctrl_msg
= udev_ctrl_receive_msg(ctrl_conn
);
1033 i
= udev_ctrl_get_set_log_level(ctrl_msg
);
1035 log_debug("Received udev control message (SET_LOG_LEVEL), setting log_priority=%i", i
);
1036 log_set_max_level(i
);
1037 manager_kill_workers(manager
);
1040 if (udev_ctrl_get_stop_exec_queue(ctrl_msg
) > 0) {
1041 log_debug("Received udev control message (STOP_EXEC_QUEUE)");
1042 manager
->stop_exec_queue
= true;
1045 if (udev_ctrl_get_start_exec_queue(ctrl_msg
) > 0) {
1046 log_debug("Received udev control message (START_EXEC_QUEUE)");
1047 manager
->stop_exec_queue
= false;
1048 event_queue_start(manager
);
1051 if (udev_ctrl_get_reload(ctrl_msg
) > 0) {
1052 log_debug("Received udev control message (RELOAD)");
1053 manager_reload(manager
);
1056 str
= udev_ctrl_get_set_env(ctrl_msg
);
1058 _cleanup_free_
char *key
= NULL
, *val
= NULL
, *old_key
= NULL
, *old_val
= NULL
;
1061 eq
= strchr(str
, '=');
1063 log_error("Invalid key format '%s'", str
);
1067 key
= strndup(str
, eq
- str
);
1073 old_val
= hashmap_remove2(manager
->properties
, key
, (void **) &old_key
);
1075 r
= hashmap_ensure_allocated(&manager
->properties
, &string_hash_ops
);
1083 log_debug("Received udev control message (ENV), unsetting '%s'", key
);
1085 r
= hashmap_put(manager
->properties
, key
, NULL
);
1097 log_debug("Received udev control message (ENV), setting '%s=%s'", key
, val
);
1099 r
= hashmap_put(manager
->properties
, key
, val
);
1107 manager_kill_workers(manager
);
1110 i
= udev_ctrl_get_set_children_max(ctrl_msg
);
1112 log_debug("Receivd udev control message (SET_MAX_CHILDREN), setting children_max=%i", i
);
1113 arg_children_max
= i
;
1115 (void) sd_notifyf(false,
1117 "STATUS=Processing with %u children at max", arg_children_max
);
1120 if (udev_ctrl_get_ping(ctrl_msg
) > 0)
1121 log_debug("Received udev control message (SYNC)");
1123 if (udev_ctrl_get_exit(ctrl_msg
) > 0) {
1124 log_debug("Received udev control message (EXIT)");
1125 manager_exit(manager
);
1126 /* keep reference to block the client until we exit
1127 TODO: deal with several blocking exit requests */
1128 manager
->ctrl_conn_blocking
= udev_ctrl_connection_ref(ctrl_conn
);
1134 static int synthesize_change(sd_device
*dev
) {
1135 const char *subsystem
, *sysname
, *devname
, *syspath
, *devtype
;
1136 char filename
[PATH_MAX
];
1139 r
= sd_device_get_subsystem(dev
, &subsystem
);
1143 r
= sd_device_get_sysname(dev
, &sysname
);
1147 r
= sd_device_get_devname(dev
, &devname
);
1151 r
= sd_device_get_syspath(dev
, &syspath
);
1155 r
= sd_device_get_devtype(dev
, &devtype
);
1159 if (streq_ptr("block", subsystem
) &&
1160 streq_ptr("disk", devtype
) &&
1161 !startswith(sysname
, "dm-")) {
1162 _cleanup_(sd_device_enumerator_unrefp
) sd_device_enumerator
*e
= NULL
;
1163 bool part_table_read
= false, has_partitions
= false;
1168 * Try to re-read the partition table. This only succeeds if
1169 * none of the devices is busy. The kernel returns 0 if no
1170 * partition table is found, and we will not get an event for
1173 fd
= open(devname
, O_RDONLY
|O_CLOEXEC
|O_NOFOLLOW
|O_NONBLOCK
);
1175 r
= flock(fd
, LOCK_EX
|LOCK_NB
);
1177 r
= ioctl(fd
, BLKRRPART
, 0);
1181 part_table_read
= true;
1184 /* search for partitions */
1185 r
= sd_device_enumerator_new(&e
);
1189 r
= sd_device_enumerator_allow_uninitialized(e
);
1193 r
= sd_device_enumerator_add_match_parent(e
, dev
);
1197 r
= sd_device_enumerator_add_match_subsystem(e
, "block", true);
1201 FOREACH_DEVICE(e
, d
) {
1204 if (sd_device_get_devtype(d
, &t
) < 0 ||
1205 !streq("partition", t
))
1208 has_partitions
= true;
1213 * We have partitions and re-read the table, the kernel already sent
1214 * out a "change" event for the disk, and "remove/add" for all
1217 if (part_table_read
&& has_partitions
)
1221 * We have partitions but re-reading the partition table did not
1222 * work, synthesize "change" for the disk and all partitions.
1224 log_debug("Device '%s' is closed, synthesising 'change'", devname
);
1225 strscpyl(filename
, sizeof(filename
), syspath
, "/uevent", NULL
);
1226 write_string_file(filename
, "change", WRITE_STRING_FILE_DISABLE_BUFFER
);
1228 FOREACH_DEVICE(e
, d
) {
1229 const char *t
, *n
, *s
;
1231 if (sd_device_get_devtype(d
, &t
) < 0 ||
1232 !streq("partition", t
))
1235 if (sd_device_get_devname(d
, &n
) < 0 ||
1236 sd_device_get_syspath(d
, &s
) < 0)
1239 log_debug("Device '%s' is closed, synthesising partition '%s' 'change'", devname
, n
);
1240 strscpyl(filename
, sizeof(filename
), s
, "/uevent", NULL
);
1241 write_string_file(filename
, "change", WRITE_STRING_FILE_DISABLE_BUFFER
);
1247 log_debug("Device %s is closed, synthesising 'change'", devname
);
1248 strscpyl(filename
, sizeof(filename
), syspath
, "/uevent", NULL
);
1249 write_string_file(filename
, "change", WRITE_STRING_FILE_DISABLE_BUFFER
);
1254 static int on_inotify(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
1255 Manager
*manager
= userdata
;
1256 union inotify_event_buffer buffer
;
1257 struct inotify_event
*e
;
1263 r
= event_source_disable(manager
->kill_workers_event
);
1265 log_warning_errno(r
, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
1267 l
= read(fd
, &buffer
, sizeof(buffer
));
1269 if (IN_SET(errno
, EAGAIN
, EINTR
))
1272 return log_error_errno(errno
, "Failed to read inotify fd: %m");
1275 FOREACH_INOTIFY_EVENT(e
, buffer
, l
) {
1276 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
1277 const char *devnode
;
1279 if (udev_watch_lookup(e
->wd
, &dev
) <= 0)
1282 if (sd_device_get_devname(dev
, &devnode
) < 0)
1285 log_device_debug(dev
, "Inotify event: %x for %s", e
->mask
, devnode
);
1286 if (e
->mask
& IN_CLOSE_WRITE
)
1287 synthesize_change(dev
);
1288 else if (e
->mask
& IN_IGNORED
)
1289 udev_watch_end(dev
);
1295 static int on_sigterm(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
1296 Manager
*manager
= userdata
;
1300 manager_exit(manager
);
1305 static int on_sighup(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
1306 Manager
*manager
= userdata
;
1310 manager_reload(manager
);
1315 static int on_sigchld(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
1316 Manager
*manager
= userdata
;
1324 struct worker
*worker
;
1326 pid
= waitpid(-1, &status
, WNOHANG
);
1330 worker
= hashmap_get(manager
->workers
, PID_TO_PTR(pid
));
1332 log_warning("Worker ["PID_FMT
"] is unknown, ignoring", pid
);
1336 if (WIFEXITED(status
)) {
1337 if (WEXITSTATUS(status
) == 0)
1338 log_debug("Worker ["PID_FMT
"] exited", pid
);
1340 log_warning("Worker ["PID_FMT
"] exited with return code %i", pid
, WEXITSTATUS(status
));
1341 } else if (WIFSIGNALED(status
)) {
1342 log_warning("Worker ["PID_FMT
"] terminated by signal %i (%s)", pid
, WTERMSIG(status
), signal_to_string(WTERMSIG(status
)));
1343 } else if (WIFSTOPPED(status
)) {
1344 log_info("Worker ["PID_FMT
"] stopped", pid
);
1346 } else if (WIFCONTINUED(status
)) {
1347 log_info("Worker ["PID_FMT
"] continued", pid
);
1350 log_warning("Worker ["PID_FMT
"] exit with status 0x%04x", pid
, status
);
1352 if ((!WIFEXITED(status
) || WEXITSTATUS(status
) != 0) && worker
->event
) {
1353 log_device_error(worker
->event
->dev
, "Worker ["PID_FMT
"] failed", pid
);
1355 /* delete state from disk */
1356 device_delete_db(worker
->event
->dev
);
1357 device_tag_index(worker
->event
->dev
, NULL
, false);
1359 /* forward kernel event without amending it */
1360 r
= device_monitor_send_device(manager
->monitor
, NULL
, worker
->event
->dev_kernel
);
1362 log_device_error_errno(worker
->event
->dev_kernel
, r
, "Failed to send back device to kernel: %m");
1365 worker_free(worker
);
1368 /* we can start new workers, try to schedule events */
1369 event_queue_start(manager
);
1371 /* Disable unnecessary cleanup event */
1372 if (hashmap_isempty(manager
->workers
)) {
1373 r
= event_source_disable(manager
->kill_workers_event
);
1375 log_warning_errno(r
, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
1381 static int on_post(sd_event_source
*s
, void *userdata
) {
1382 Manager
*manager
= userdata
;
1386 if (!LIST_IS_EMPTY(manager
->events
))
1389 /* There are no pending events. Let's cleanup idle process. */
1391 if (!hashmap_isempty(manager
->workers
)) {
1392 /* There are idle workers */
1393 (void) event_reset_time(manager
->event
, &manager
->kill_workers_event
, CLOCK_MONOTONIC
,
1394 now(CLOCK_MONOTONIC
) + 3 * USEC_PER_SEC
, USEC_PER_SEC
,
1395 on_kill_workers_event
, manager
, 0, "kill-workers-event", false);
1399 /* There are no idle workers. */
1402 return sd_event_exit(manager
->event
, 0);
1404 if (manager
->cgroup
)
1405 /* cleanup possible left-over processes in our cgroup */
1406 (void) cg_kill(SYSTEMD_CGROUP_CONTROLLER
, manager
->cgroup
, SIGKILL
, CGROUP_IGNORE_SELF
, NULL
, NULL
, NULL
);
1411 static int listen_fds(int *ret_ctrl
, int *ret_netlink
) {
1412 int ctrl_fd
= -1, netlink_fd
= -1;
1416 assert(ret_netlink
);
1418 n
= sd_listen_fds(true);
1422 for (fd
= SD_LISTEN_FDS_START
; fd
< n
+ SD_LISTEN_FDS_START
; fd
++) {
1423 if (sd_is_socket(fd
, AF_LOCAL
, SOCK_SEQPACKET
, -1) > 0) {
1430 if (sd_is_socket(fd
, AF_NETLINK
, SOCK_RAW
, -1) > 0) {
1431 if (netlink_fd
>= 0)
1440 *ret_ctrl
= ctrl_fd
;
1441 *ret_netlink
= netlink_fd
;
1447 * read the kernel command line, in case we need to get into debug mode
1448 * udev.log_priority=<level> syslog priority
1449 * udev.children_max=<number of workers> events are fully serialized if set to 1
1450 * udev.exec_delay=<number of seconds> delay execution of every executed program
1451 * udev.event_timeout=<number of seconds> seconds to wait before terminating an event
1453 static int parse_proc_cmdline_item(const char *key
, const char *value
, void *data
) {
1461 if (proc_cmdline_key_streq(key
, "udev.log_priority")) {
1463 if (proc_cmdline_value_missing(key
, value
))
1466 r
= log_level_from_string(value
);
1468 log_set_max_level(r
);
1470 } else if (proc_cmdline_key_streq(key
, "udev.event_timeout")) {
1472 if (proc_cmdline_value_missing(key
, value
))
1475 r
= parse_sec(value
, &arg_event_timeout_usec
);
1477 } else if (proc_cmdline_key_streq(key
, "udev.children_max")) {
1479 if (proc_cmdline_value_missing(key
, value
))
1482 r
= safe_atou(value
, &arg_children_max
);
1484 } else if (proc_cmdline_key_streq(key
, "udev.exec_delay")) {
1486 if (proc_cmdline_value_missing(key
, value
))
1489 r
= parse_sec(value
, &arg_exec_delay_usec
);
1491 } else if (startswith(key
, "udev."))
1492 log_warning("Unknown udev kernel command line option \"%s\", ignoring", key
);
1495 log_warning_errno(r
, "Failed to parse \"%s=%s\", ignoring: %m", key
, value
);
1500 static int help(void) {
1501 _cleanup_free_
char *link
= NULL
;
1504 r
= terminal_urlify_man("systemd-udevd.service", "8", &link
);
1508 printf("%s [OPTIONS...]\n\n"
1509 "Manages devices.\n\n"
1510 " -h --help Print this message\n"
1511 " -V --version Print version of the program\n"
1512 " -d --daemon Detach and run in the background\n"
1513 " -D --debug Enable debug output\n"
1514 " -c --children-max=INT Set maximum number of workers\n"
1515 " -e --exec-delay=SECONDS Seconds to wait before executing RUN=\n"
1516 " -t --event-timeout=SECONDS Seconds to wait before terminating an event\n"
1517 " -N --resolve-names=early|late|never\n"
1518 " When to resolve users and groups\n"
1519 "\nSee the %s for details.\n"
1520 , program_invocation_short_name
1527 static int parse_argv(int argc
, char *argv
[]) {
1528 static const struct option options
[] = {
1529 { "daemon", no_argument
, NULL
, 'd' },
1530 { "debug", no_argument
, NULL
, 'D' },
1531 { "children-max", required_argument
, NULL
, 'c' },
1532 { "exec-delay", required_argument
, NULL
, 'e' },
1533 { "event-timeout", required_argument
, NULL
, 't' },
1534 { "resolve-names", required_argument
, NULL
, 'N' },
1535 { "help", no_argument
, NULL
, 'h' },
1536 { "version", no_argument
, NULL
, 'V' },
1545 while ((c
= getopt_long(argc
, argv
, "c:de:Dt:N:hV", options
, NULL
)) >= 0) {
1549 arg_daemonize
= true;
1552 r
= safe_atou(optarg
, &arg_children_max
);
1554 log_warning_errno(r
, "Failed to parse --children-max= value '%s', ignoring: %m", optarg
);
1557 r
= parse_sec(optarg
, &arg_exec_delay_usec
);
1559 log_warning_errno(r
, "Failed to parse --exec-delay= value '%s', ignoring: %m", optarg
);
1562 r
= parse_sec(optarg
, &arg_event_timeout_usec
);
1564 log_warning_errno(r
, "Failed to parse --event-timeout= value '%s', ignoring: %m", optarg
);
1570 ResolveNameTiming t
;
1572 t
= resolve_name_timing_from_string(optarg
);
1574 log_warning("Invalid --resolve-names= value '%s', ignoring.", optarg
);
1576 arg_resolve_name_timing
= t
;
1582 printf("%s\n", PACKAGE_VERSION
);
1587 assert_not_reached("Unhandled option");
1595 static int manager_new(Manager
**ret
, int fd_ctrl
, int fd_uevent
, const char *cgroup
) {
1596 _cleanup_(manager_freep
) Manager
*manager
= NULL
;
1601 manager
= new(Manager
, 1);
1605 *manager
= (Manager
) {
1607 .worker_watch
= { -1, -1 },
1611 udev_builtin_init();
1613 r
= udev_rules_new(&manager
->rules
, arg_resolve_name_timing
);
1614 if (!manager
->rules
)
1615 return log_error_errno(r
, "Failed to read udev rules: %m");
1617 manager
->ctrl
= udev_ctrl_new_from_fd(fd_ctrl
);
1619 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "Failed to initialize udev control socket");
1622 r
= udev_ctrl_enable_receiving(manager
->ctrl
);
1624 return log_error_errno(r
, "Failed to bind udev control socket: %m");
1627 fd_ctrl
= udev_ctrl_get_fd(manager
->ctrl
);
1629 return log_error_errno(fd_ctrl
, "Failed to get udev control socket fd: %m");
1631 r
= device_monitor_new_full(&manager
->monitor
, MONITOR_GROUP_KERNEL
, fd_uevent
);
1633 return log_error_errno(r
, "Failed to initialize device monitor: %m");
1635 (void) sd_device_monitor_set_receive_buffer_size(manager
->monitor
, 128 * 1024 * 1024);
1637 /* unnamed socket from workers to the main daemon */
1638 r
= socketpair(AF_LOCAL
, SOCK_DGRAM
|SOCK_CLOEXEC
, 0, manager
->worker_watch
);
1640 return log_error_errno(errno
, "Failed to create socketpair for communicating with workers: %m");
1642 fd_worker
= manager
->worker_watch
[READ_END
];
1644 r
= setsockopt_int(fd_worker
, SOL_SOCKET
, SO_PASSCRED
, true);
1646 return log_error_errno(r
, "Failed to enable SO_PASSCRED: %m");
1648 r
= udev_watch_init();
1650 return log_error_errno(r
, "Failed to create inotify descriptor: %m");
1651 manager
->fd_inotify
= r
;
1653 udev_watch_restore();
1655 /* block and listen to all signals on signalfd */
1656 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGTERM
, SIGINT
, SIGHUP
, SIGCHLD
, -1) >= 0);
1658 r
= sd_event_default(&manager
->event
);
1660 return log_error_errno(r
, "Failed to allocate event loop: %m");
1662 r
= sd_event_add_signal(manager
->event
, NULL
, SIGINT
, on_sigterm
, manager
);
1664 return log_error_errno(r
, "Failed to create SIGINT event source: %m");
1666 r
= sd_event_add_signal(manager
->event
, NULL
, SIGTERM
, on_sigterm
, manager
);
1668 return log_error_errno(r
, "Failed to create SIGTERM event source: %m");
1670 r
= sd_event_add_signal(manager
->event
, NULL
, SIGHUP
, on_sighup
, manager
);
1672 return log_error_errno(r
, "Failed to create SIGHUP event source: %m");
1674 r
= sd_event_add_signal(manager
->event
, NULL
, SIGCHLD
, on_sigchld
, manager
);
1676 return log_error_errno(r
, "Failed to create SIGCHLD event source: %m");
1678 r
= sd_event_set_watchdog(manager
->event
, true);
1680 return log_error_errno(r
, "Failed to create watchdog event source: %m");
1682 r
= sd_event_add_io(manager
->event
, &manager
->ctrl_event
, fd_ctrl
, EPOLLIN
, on_ctrl_msg
, manager
);
1684 return log_error_errno(r
, "Failed to create udev control event source: %m");
1686 /* This needs to be after the inotify and uevent handling, to make sure
1687 * that the ping is send back after fully processing the pending uevents
1688 * (including the synthetic ones we may create due to inotify events).
1690 r
= sd_event_source_set_priority(manager
->ctrl_event
, SD_EVENT_PRIORITY_IDLE
);
1692 return log_error_errno(r
, "Failed to set IDLE event priority for udev control event source: %m");
1694 r
= sd_event_add_io(manager
->event
, &manager
->inotify_event
, manager
->fd_inotify
, EPOLLIN
, on_inotify
, manager
);
1696 return log_error_errno(r
, "Failed to create inotify event source: %m");
1698 r
= sd_device_monitor_attach_event(manager
->monitor
, manager
->event
);
1700 return log_error_errno(r
, "Failed to attach event to device monitor: %m");
1702 r
= sd_device_monitor_start(manager
->monitor
, on_uevent
, manager
);
1704 return log_error_errno(r
, "Failed to start device monitor: %m");
1706 (void) sd_event_source_set_description(sd_device_monitor_get_event_source(manager
->monitor
), "device-monitor");
1708 r
= sd_event_add_io(manager
->event
, NULL
, fd_worker
, EPOLLIN
, on_worker
, manager
);
1710 return log_error_errno(r
, "Failed to create worker event source: %m");
1712 r
= sd_event_add_post(manager
->event
, NULL
, on_post
, manager
);
1714 return log_error_errno(r
, "Failed to create post event source: %m");
1716 *ret
= TAKE_PTR(manager
);
1721 static int main_loop(int fd_ctrl
, int fd_uevent
, const char *cgroup
) {
1722 _cleanup_(manager_freep
) Manager
*manager
= NULL
;
1725 r
= manager_new(&manager
, fd_ctrl
, fd_uevent
, cgroup
);
1727 r
= log_error_errno(r
, "Failed to allocate manager object: %m");
1731 r
= udev_rules_apply_static_dev_perms(manager
->rules
);
1733 log_error_errno(r
, "Failed to apply permissions on static device nodes: %m");
1735 (void) sd_notifyf(false,
1737 "STATUS=Processing with %u children at max", arg_children_max
);
1739 r
= sd_event_loop(manager
->event
);
1741 log_error_errno(r
, "Event loop failed: %m");
1745 sd_event_get_exit_code(manager
->event
, &r
);
1750 "STATUS=Shutting down...");
1752 udev_ctrl_cleanup(manager
->ctrl
);
1756 static int run(int argc
, char *argv
[]) {
1757 _cleanup_free_
char *cgroup
= NULL
;
1758 int fd_ctrl
= -1, fd_uevent
= -1;
1761 log_set_target(LOG_TARGET_AUTO
);
1762 udev_parse_config_full(&arg_children_max
, &arg_exec_delay_usec
, &arg_event_timeout_usec
, &arg_resolve_name_timing
);
1763 log_parse_environment();
1766 r
= parse_argv(argc
, argv
);
1770 r
= proc_cmdline_parse(parse_proc_cmdline_item
, NULL
, PROC_CMDLINE_STRIP_RD_PREFIX
);
1772 log_warning_errno(r
, "Failed to parse kernel command line, ignoring: %m");
1775 log_set_target(LOG_TARGET_CONSOLE
);
1776 log_set_max_level(LOG_DEBUG
);
1779 log_set_max_level_realm(LOG_REALM_SYSTEMD
, log_get_max_level());
1785 if (arg_children_max
== 0) {
1787 unsigned long mem_limit
;
1789 arg_children_max
= 8;
1791 if (sched_getaffinity(0, sizeof(cpu_set
), &cpu_set
) == 0)
1792 arg_children_max
+= CPU_COUNT(&cpu_set
) * 8;
1794 mem_limit
= physical_memory() / (128LU*1024*1024);
1795 arg_children_max
= MAX(10U, MIN(arg_children_max
, mem_limit
));
1797 log_debug("Set children_max to %u", arg_children_max
);
1800 /* set umask before creating any file/directory */
1803 return log_error_errno(errno
, "Failed to change dir to '/': %m");
1807 r
= mac_selinux_init();
1809 return log_error_errno(r
, "Could not initialize labelling: %m");
1811 r
= mkdir_errno_wrapper("/run/udev", 0755);
1812 if (r
< 0 && r
!= -EEXIST
)
1813 return log_error_errno(r
, "Failed to create /run/udev: %m");
1815 dev_setup(NULL
, UID_INVALID
, GID_INVALID
);
1817 if (getppid() == 1) {
1818 /* get our own cgroup, we regularly kill everything udev has left behind
1819 we only do this on systemd systems, and only if we are directly spawned
1820 by PID1. otherwise we are not guaranteed to have a dedicated cgroup */
1821 r
= cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER
, 0, &cgroup
);
1823 if (IN_SET(r
, -ENOENT
, -ENOMEDIUM
))
1824 log_debug_errno(r
, "Dedicated cgroup not found: %m");
1826 log_warning_errno(r
, "Failed to get cgroup: %m");
1830 r
= listen_fds(&fd_ctrl
, &fd_uevent
);
1832 return log_error_errno(r
, "Failed to listen on fds: %m");
1834 if (arg_daemonize
) {
1837 log_info("starting version " PACKAGE_VERSION
);
1839 /* connect /dev/null to stdin, stdout, stderr */
1840 if (log_get_max_level() < LOG_DEBUG
) {
1841 r
= make_null_stdio();
1843 log_warning_errno(r
, "Failed to redirect standard streams to /dev/null: %m");
1848 return log_error_errno(errno
, "Failed to fork daemon: %m");
1856 r
= set_oom_score_adjust(-1000);
1858 log_debug_errno(r
, "Failed to adjust OOM score, ignoring: %m");
1861 return main_loop(fd_ctrl
, fd_uevent
, cgroup
);
1864 DEFINE_MAIN_FUNCTION(run
);