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-util.h"
40 #include "format-util.h"
44 #include "libudev-device-internal.h"
46 #include "netlink-util.h"
47 #include "parse-util.h"
48 #include "proc-cmdline.h"
49 #include "process-util.h"
50 #include "selinux-util.h"
51 #include "signal-util.h"
52 #include "socket-util.h"
53 #include "string-util.h"
54 #include "syslog-util.h"
55 #include "terminal-util.h"
56 #include "udev-builtin.h"
57 #include "udev-ctrl.h"
58 #include "udev-util.h"
59 #include "udev-watch.h"
61 #include "user-util.h"
63 static bool arg_debug
= false;
64 static int arg_daemonize
= false;
65 static ResolveNameTiming arg_resolve_name_timing
= RESOLVE_NAME_EARLY
;
66 static unsigned arg_children_max
= 0;
67 static usec_t arg_exec_delay_usec
= 0;
68 static usec_t arg_event_timeout_usec
= 180 * USEC_PER_SEC
;
69 static usec_t arg_event_timeout_warn_usec
= 180 * USEC_PER_SEC
/ 3;
71 typedef struct Manager
{
74 LIST_HEAD(struct event
, events
);
76 pid_t pid
; /* the process that originally allocated the manager object */
78 struct udev_rules
*rules
;
81 struct udev_monitor
*monitor
;
82 struct udev_ctrl
*ctrl
;
83 struct udev_ctrl_connection
*ctrl_conn_blocking
;
87 sd_event_source
*ctrl_event
;
88 sd_event_source
*uevent_event
;
89 sd_event_source
*inotify_event
;
90 sd_event_source
*kill_workers_event
;
94 bool stop_exec_queue
:1;
105 LIST_FIELDS(struct event
, event
);
107 struct udev_device
*dev
;
108 struct udev_device
*dev_kernel
;
109 struct worker
*worker
;
110 enum event_state state
;
111 unsigned long long int delaying_seqnum
;
112 unsigned long long int seqnum
;
115 const char *devpath_old
;
119 sd_event_source
*timeout_warning
;
120 sd_event_source
*timeout
;
123 static void event_queue_cleanup(Manager
*manager
, enum event_state type
);
135 struct udev_monitor
*monitor
;
136 enum worker_state state
;
140 /* passed from worker to main process */
141 struct worker_message
{
144 static void event_free(struct event
*event
) {
149 assert(event
->manager
);
151 LIST_REMOVE(event
, event
->manager
->events
, event
);
152 udev_device_unref(event
->dev
);
153 udev_device_unref(event
->dev_kernel
);
155 sd_event_source_unref(event
->timeout_warning
);
156 sd_event_source_unref(event
->timeout
);
159 event
->worker
->event
= NULL
;
161 if (LIST_IS_EMPTY(event
->manager
->events
)) {
162 /* only clean up the queue from the process that created it */
163 if (event
->manager
->pid
== getpid_cached()) {
164 r
= unlink("/run/udev/queue");
166 log_warning_errno(errno
, "could not unlink /run/udev/queue: %m");
173 static void worker_free(struct worker
*worker
) {
177 assert(worker
->manager
);
179 hashmap_remove(worker
->manager
->workers
, PID_TO_PTR(worker
->pid
));
180 udev_monitor_unref(worker
->monitor
);
181 event_free(worker
->event
);
186 static void manager_workers_free(Manager
*manager
) {
187 struct worker
*worker
;
192 HASHMAP_FOREACH(worker
, manager
->workers
, i
)
195 manager
->workers
= hashmap_free(manager
->workers
);
198 static int worker_new(struct worker
**ret
, Manager
*manager
, struct udev_monitor
*worker_monitor
, pid_t pid
) {
199 _cleanup_free_
struct worker
*worker
= NULL
;
204 assert(worker_monitor
);
207 worker
= new0(struct worker
, 1);
211 worker
->manager
= manager
;
212 /* close monitor, but keep address around */
213 udev_monitor_disconnect(worker_monitor
);
214 worker
->monitor
= udev_monitor_ref(worker_monitor
);
217 r
= hashmap_ensure_allocated(&manager
->workers
, NULL
);
221 r
= hashmap_put(manager
->workers
, PID_TO_PTR(pid
), worker
);
225 *ret
= TAKE_PTR(worker
);
230 static int on_event_timeout(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
231 struct event
*event
= userdata
;
234 assert(event
->worker
);
236 kill_and_sigcont(event
->worker
->pid
, SIGKILL
);
237 event
->worker
->state
= WORKER_KILLED
;
239 log_error("seq %llu '%s' killed", udev_device_get_seqnum(event
->dev
), event
->devpath
);
244 static int on_event_timeout_warning(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
245 struct event
*event
= userdata
;
249 log_warning("seq %llu '%s' is taking a long time", udev_device_get_seqnum(event
->dev
), event
->devpath
);
254 static void worker_attach_event(struct worker
*worker
, struct event
*event
) {
259 assert(worker
->manager
);
261 assert(!event
->worker
);
262 assert(!worker
->event
);
264 worker
->state
= WORKER_RUNNING
;
265 worker
->event
= event
;
266 event
->state
= EVENT_RUNNING
;
267 event
->worker
= worker
;
269 e
= worker
->manager
->event
;
271 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &usec
) >= 0);
273 (void) sd_event_add_time(e
, &event
->timeout_warning
, CLOCK_MONOTONIC
,
274 usec
+ arg_event_timeout_warn_usec
, USEC_PER_SEC
, on_event_timeout_warning
, event
);
276 (void) sd_event_add_time(e
, &event
->timeout
, CLOCK_MONOTONIC
,
277 usec
+ arg_event_timeout_usec
, USEC_PER_SEC
, on_event_timeout
, event
);
280 static void manager_free(Manager
*manager
) {
286 sd_event_source_unref(manager
->ctrl_event
);
287 sd_event_source_unref(manager
->uevent_event
);
288 sd_event_source_unref(manager
->inotify_event
);
289 sd_event_source_unref(manager
->kill_workers_event
);
291 sd_event_unref(manager
->event
);
292 manager_workers_free(manager
);
293 event_queue_cleanup(manager
, EVENT_UNDEF
);
295 udev_monitor_unref(manager
->monitor
);
296 udev_ctrl_unref(manager
->ctrl
);
297 udev_ctrl_connection_unref(manager
->ctrl_conn_blocking
);
299 hashmap_free_free_free(manager
->properties
);
300 udev_rules_unref(manager
->rules
);
302 safe_close(manager
->fd_inotify
);
303 safe_close_pair(manager
->worker_watch
);
308 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager
*, manager_free
);
310 static int worker_send_message(int fd
) {
311 struct worker_message message
= {};
313 return loop_write(fd
, &message
, sizeof(message
), false);
316 static bool shall_lock_device(struct udev_device
*dev
) {
319 if (!streq_ptr("block", udev_device_get_subsystem(dev
)))
322 sysname
= udev_device_get_sysname(dev
);
323 return !startswith(sysname
, "dm-") &&
324 !startswith(sysname
, "md") &&
325 !startswith(sysname
, "drbd");
328 static void worker_spawn(Manager
*manager
, struct event
*event
) {
329 _cleanup_(udev_monitor_unrefp
) struct udev_monitor
*worker_monitor
= NULL
;
333 /* listen for new events */
334 worker_monitor
= udev_monitor_new_from_netlink(NULL
, NULL
);
335 if (worker_monitor
== NULL
)
337 /* allow the main daemon netlink address to send devices to the worker */
338 udev_monitor_allow_unicast_sender(worker_monitor
, manager
->monitor
);
339 r
= udev_monitor_enable_receiving(worker_monitor
);
341 log_error_errno(r
, "worker: could not enable receiving of device: %m");
346 _cleanup_(udev_device_unrefp
) struct udev_device
*dev
= NULL
;
347 _cleanup_(sd_netlink_unrefp
) sd_netlink
*rtnl
= NULL
;
349 _cleanup_close_
int fd_signal
= -1, fd_ep
= -1;
350 struct epoll_event ep_signal
= { .events
= EPOLLIN
};
351 struct epoll_event ep_monitor
= { .events
= EPOLLIN
};
354 /* take initial device from queue */
355 dev
= TAKE_PTR(event
->dev
);
357 unsetenv("NOTIFY_SOCKET");
359 manager_workers_free(manager
);
360 event_queue_cleanup(manager
, EVENT_UNDEF
);
362 manager
->monitor
= udev_monitor_unref(manager
->monitor
);
363 manager
->ctrl_conn_blocking
= udev_ctrl_connection_unref(manager
->ctrl_conn_blocking
);
364 manager
->ctrl
= udev_ctrl_unref(manager
->ctrl
);
365 manager
->worker_watch
[READ_END
] = safe_close(manager
->worker_watch
[READ_END
]);
367 manager
->ctrl_event
= sd_event_source_unref(manager
->ctrl_event
);
368 manager
->uevent_event
= sd_event_source_unref(manager
->uevent_event
);
369 manager
->inotify_event
= sd_event_source_unref(manager
->inotify_event
);
370 manager
->kill_workers_event
= sd_event_source_unref(manager
->kill_workers_event
);
372 manager
->event
= sd_event_unref(manager
->event
);
375 fd_signal
= signalfd(-1, &mask
, SFD_NONBLOCK
|SFD_CLOEXEC
);
377 r
= log_error_errno(errno
, "error creating signalfd %m");
380 ep_signal
.data
.fd
= fd_signal
;
382 fd_monitor
= udev_monitor_get_fd(worker_monitor
);
383 ep_monitor
.data
.fd
= fd_monitor
;
385 fd_ep
= epoll_create1(EPOLL_CLOEXEC
);
387 r
= log_error_errno(errno
, "error creating epoll fd: %m");
391 if (epoll_ctl(fd_ep
, EPOLL_CTL_ADD
, fd_signal
, &ep_signal
) < 0 ||
392 epoll_ctl(fd_ep
, EPOLL_CTL_ADD
, fd_monitor
, &ep_monitor
) < 0) {
393 r
= log_error_errno(errno
, "fail to add fds to epoll: %m");
397 /* Request TERM signal if parent exits.
398 Ignore error, not much we can do in that case. */
399 (void) prctl(PR_SET_PDEATHSIG
, SIGTERM
);
401 /* Reset OOM score, we only protect the main daemon. */
402 r
= set_oom_score_adjust(0);
404 log_debug_errno(r
, "Failed to reset OOM score, ignoring: %m");
407 _cleanup_(udev_event_freep
) struct udev_event
*udev_event
= NULL
;
412 log_debug("seq %llu running", udev_device_get_seqnum(dev
));
413 udev_event
= udev_event_new(dev
->device
, arg_exec_delay_usec
, rtnl
);
420 * Take a shared lock on the device node; this establishes
421 * a concept of device "ownership" to serialize device
422 * access. External processes holding an exclusive lock will
423 * cause udev to skip the event handling; in the case udev
424 * acquired the lock, the external process can block until
425 * udev has finished its event handling.
427 if (!streq_ptr(udev_device_get_action(dev
), "remove") &&
428 shall_lock_device(dev
)) {
429 struct udev_device
*d
= dev
;
431 if (streq_ptr("partition", udev_device_get_devtype(d
)))
432 d
= udev_device_get_parent(d
);
435 fd_lock
= open(udev_device_get_devnode(d
), O_RDONLY
|O_CLOEXEC
|O_NOFOLLOW
|O_NONBLOCK
);
436 if (fd_lock
>= 0 && flock(fd_lock
, LOCK_SH
|LOCK_NB
) < 0) {
437 log_debug_errno(errno
, "Unable to flock(%s), skipping event handling: %m", udev_device_get_devnode(d
));
438 fd_lock
= safe_close(fd_lock
);
444 /* apply rules, create node, symlinks */
445 udev_event_execute_rules(udev_event
,
446 arg_event_timeout_usec
, arg_event_timeout_warn_usec
,
450 udev_event_execute_run(udev_event
,
451 arg_event_timeout_usec
, arg_event_timeout_warn_usec
);
454 /* in case rtnl was initialized */
455 rtnl
= sd_netlink_ref(udev_event
->rtnl
);
457 /* apply/restore inotify watch */
458 if (udev_event
->inotify_watch
) {
459 udev_watch_begin(dev
->device
);
460 udev_device_update_db(dev
);
465 /* send processed event back to libudev listeners */
466 udev_monitor_send_device(worker_monitor
, NULL
, dev
);
469 log_debug("seq %llu processed", udev_device_get_seqnum(dev
));
471 /* send udevd the result of the event execution */
472 r
= worker_send_message(manager
->worker_watch
[WRITE_END
]);
474 log_error_errno(r
, "failed to send result of seq %llu to main daemon: %m",
475 udev_device_get_seqnum(dev
));
477 dev
= udev_device_unref(dev
);
479 /* wait for more device messages from main udevd, or term signal */
480 while (dev
== NULL
) {
481 struct epoll_event ev
[4];
485 fdcount
= epoll_wait(fd_ep
, ev
, ELEMENTSOF(ev
), -1);
489 r
= log_error_errno(errno
, "failed to poll: %m");
493 for (i
= 0; i
< fdcount
; i
++) {
494 if (ev
[i
].data
.fd
== fd_monitor
&& ev
[i
].events
& EPOLLIN
) {
495 dev
= udev_monitor_receive_device(worker_monitor
);
497 } else if (ev
[i
].data
.fd
== fd_signal
&& ev
[i
].events
& EPOLLIN
) {
498 struct signalfd_siginfo fdsi
;
501 size
= read(fd_signal
, &fdsi
, sizeof(struct signalfd_siginfo
));
502 if (size
!= sizeof(struct signalfd_siginfo
))
504 switch (fdsi
.ssi_signo
) {
513 udev_device_unref(dev
);
514 manager_free(manager
);
516 _exit(r
< 0 ? EXIT_FAILURE
: EXIT_SUCCESS
);
519 event
->state
= EVENT_QUEUED
;
520 log_error_errno(errno
, "fork of child failed: %m");
524 struct worker
*worker
;
526 r
= worker_new(&worker
, manager
, worker_monitor
, pid
);
530 worker_attach_event(worker
, event
);
532 log_debug("seq %llu forked new worker ["PID_FMT
"]", udev_device_get_seqnum(event
->dev
), pid
);
538 static void event_run(Manager
*manager
, struct event
*event
) {
539 struct worker
*worker
;
545 HASHMAP_FOREACH(worker
, manager
->workers
, i
) {
548 if (worker
->state
!= WORKER_IDLE
)
551 count
= udev_monitor_send_device(manager
->monitor
, worker
->monitor
, event
->dev
);
553 log_error_errno(errno
, "worker ["PID_FMT
"] did not accept message %zi (%m), kill it",
555 (void) kill(worker
->pid
, SIGKILL
);
556 worker
->state
= WORKER_KILLED
;
559 worker_attach_event(worker
, event
);
563 if (hashmap_size(manager
->workers
) >= arg_children_max
) {
564 if (arg_children_max
> 1)
565 log_debug("maximum number (%i) of children reached", hashmap_size(manager
->workers
));
569 /* start new worker and pass initial device */
570 worker_spawn(manager
, event
);
573 static int event_queue_insert(Manager
*manager
, struct udev_device
*dev
) {
580 /* only one process can add events to the queue */
581 if (manager
->pid
== 0)
582 manager
->pid
= getpid_cached();
584 assert(manager
->pid
== getpid_cached());
586 event
= new0(struct event
, 1);
590 event
->manager
= manager
;
592 event
->dev_kernel
= udev_device_shallow_clone(dev
);
593 udev_device_copy_properties(event
->dev_kernel
, dev
);
594 event
->seqnum
= udev_device_get_seqnum(dev
);
595 event
->devpath
= udev_device_get_devpath(dev
);
596 event
->devpath_len
= strlen(event
->devpath
);
597 event
->devpath_old
= udev_device_get_devpath_old(dev
);
598 event
->devnum
= udev_device_get_devnum(dev
);
599 event
->is_block
= streq("block", udev_device_get_subsystem(dev
));
600 event
->ifindex
= udev_device_get_ifindex(dev
);
602 log_debug("seq %llu queued, '%s' '%s'", udev_device_get_seqnum(dev
),
603 udev_device_get_action(dev
), udev_device_get_subsystem(dev
));
605 event
->state
= EVENT_QUEUED
;
607 if (LIST_IS_EMPTY(manager
->events
)) {
608 r
= touch("/run/udev/queue");
610 log_warning_errno(r
, "could not touch /run/udev/queue: %m");
613 LIST_APPEND(event
, manager
->events
, event
);
618 static void manager_kill_workers(Manager
*manager
) {
619 struct worker
*worker
;
624 HASHMAP_FOREACH(worker
, manager
->workers
, i
) {
625 if (worker
->state
== WORKER_KILLED
)
628 worker
->state
= WORKER_KILLED
;
629 (void) kill(worker
->pid
, SIGTERM
);
633 /* lookup event for identical, parent, child device */
634 static bool is_devpath_busy(Manager
*manager
, struct event
*event
) {
635 struct event
*loop_event
;
638 /* check if queue contains events we depend on */
639 LIST_FOREACH(event
, loop_event
, manager
->events
) {
640 /* we already found a later event, earlier cannot block us, no need to check again */
641 if (loop_event
->seqnum
< event
->delaying_seqnum
)
644 /* event we checked earlier still exists, no need to check again */
645 if (loop_event
->seqnum
== event
->delaying_seqnum
)
648 /* found ourself, no later event can block us */
649 if (loop_event
->seqnum
>= event
->seqnum
)
652 /* check major/minor */
653 if (major(event
->devnum
) != 0 && event
->devnum
== loop_event
->devnum
&& event
->is_block
== loop_event
->is_block
)
656 /* check network device ifindex */
657 if (event
->ifindex
> 0 && event
->ifindex
== loop_event
->ifindex
)
660 /* check our old name */
661 if (event
->devpath_old
&& streq(loop_event
->devpath
, event
->devpath_old
)) {
662 event
->delaying_seqnum
= loop_event
->seqnum
;
666 /* compare devpath */
667 common
= MIN(loop_event
->devpath_len
, event
->devpath_len
);
669 /* one devpath is contained in the other? */
670 if (memcmp(loop_event
->devpath
, event
->devpath
, common
) != 0)
673 /* identical device event found */
674 if (loop_event
->devpath_len
== event
->devpath_len
) {
675 /* devices names might have changed/swapped in the meantime */
676 if (major(event
->devnum
) != 0 || event
->ifindex
> 0)
678 event
->delaying_seqnum
= loop_event
->seqnum
;
682 /* parent device event found */
683 if (event
->devpath
[common
] == '/') {
684 event
->delaying_seqnum
= loop_event
->seqnum
;
688 /* child device event found */
689 if (loop_event
->devpath
[common
] == '/') {
690 event
->delaying_seqnum
= loop_event
->seqnum
;
698 static int on_exit_timeout(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
699 Manager
*manager
= userdata
;
703 log_error_errno(ETIMEDOUT
, "giving up waiting for workers to finish");
705 sd_event_exit(manager
->event
, -ETIMEDOUT
);
710 static void manager_exit(Manager
*manager
) {
716 manager
->exit
= true;
720 "STATUS=Starting shutdown...");
722 /* close sources of new events and discard buffered events */
723 manager
->ctrl_event
= sd_event_source_unref(manager
->ctrl_event
);
724 manager
->ctrl
= udev_ctrl_unref(manager
->ctrl
);
726 manager
->inotify_event
= sd_event_source_unref(manager
->inotify_event
);
727 manager
->fd_inotify
= safe_close(manager
->fd_inotify
);
729 manager
->uevent_event
= sd_event_source_unref(manager
->uevent_event
);
730 manager
->monitor
= udev_monitor_unref(manager
->monitor
);
732 /* discard queued events and kill workers */
733 event_queue_cleanup(manager
, EVENT_QUEUED
);
734 manager_kill_workers(manager
);
736 assert_se(sd_event_now(manager
->event
, CLOCK_MONOTONIC
, &usec
) >= 0);
738 r
= sd_event_add_time(manager
->event
, NULL
, CLOCK_MONOTONIC
,
739 usec
+ 30 * USEC_PER_SEC
, USEC_PER_SEC
, on_exit_timeout
, manager
);
744 /* reload requested, HUP signal received, rules changed, builtin changed */
745 static void manager_reload(Manager
*manager
) {
751 "STATUS=Flushing configuration...");
753 manager_kill_workers(manager
);
754 manager
->rules
= udev_rules_unref(manager
->rules
);
759 "STATUS=Processing with %u children at max", arg_children_max
);
762 static int on_kill_workers_event(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
763 Manager
*manager
= userdata
;
767 log_debug("Cleanup idle workers");
768 manager_kill_workers(manager
);
773 static int manager_enable_kill_workers_event(Manager
*manager
) {
778 if (!manager
->kill_workers_event
)
781 r
= sd_event_source_get_enabled(manager
->kill_workers_event
, &enabled
);
783 log_debug_errno(r
, "Failed to query whether event source for killing idle workers is enabled or not, trying to create new event source: %m");
784 manager
->kill_workers_event
= sd_event_source_unref(manager
->kill_workers_event
);
788 if (enabled
== SD_EVENT_ONESHOT
)
791 r
= sd_event_source_set_time(manager
->kill_workers_event
, now(CLOCK_MONOTONIC
) + 3 * USEC_PER_SEC
);
793 log_debug_errno(r
, "Failed to set time to event source for killing idle workers, trying to create new event source: %m");
794 manager
->kill_workers_event
= sd_event_source_unref(manager
->kill_workers_event
);
798 r
= sd_event_source_set_enabled(manager
->kill_workers_event
, SD_EVENT_ONESHOT
);
800 log_debug_errno(r
, "Failed to enable event source for killing idle workers, trying to create new event source: %m");
801 manager
->kill_workers_event
= sd_event_source_unref(manager
->kill_workers_event
);
808 r
= sd_event_add_time(manager
->event
, &manager
->kill_workers_event
, CLOCK_MONOTONIC
,
809 now(CLOCK_MONOTONIC
) + 3 * USEC_PER_SEC
, USEC_PER_SEC
, on_kill_workers_event
, manager
);
811 return log_warning_errno(r
, "Failed to create timer event for killing idle workers: %m");
816 static int manager_disable_kill_workers_event(Manager
*manager
) {
819 if (!manager
->kill_workers_event
)
822 r
= sd_event_source_set_enabled(manager
->kill_workers_event
, SD_EVENT_OFF
);
824 return log_warning_errno(r
, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
829 static void event_queue_start(Manager
*manager
) {
835 if (LIST_IS_EMPTY(manager
->events
) ||
836 manager
->exit
|| manager
->stop_exec_queue
)
839 assert_se(sd_event_now(manager
->event
, CLOCK_MONOTONIC
, &usec
) >= 0);
840 /* check for changed config, every 3 seconds at most */
841 if (manager
->last_usec
== 0 ||
842 (usec
- manager
->last_usec
) > 3 * USEC_PER_SEC
) {
843 if (udev_rules_check_timestamp(manager
->rules
) ||
844 udev_builtin_validate())
845 manager_reload(manager
);
847 manager
->last_usec
= usec
;
850 (void) manager_disable_kill_workers_event(manager
);
854 if (!manager
->rules
) {
855 manager
->rules
= udev_rules_new(arg_resolve_name_timing
);
860 LIST_FOREACH(event
,event
,manager
->events
) {
861 if (event
->state
!= EVENT_QUEUED
)
864 /* do not start event if parent or child event is still running */
865 if (is_devpath_busy(manager
, event
))
868 event_run(manager
, event
);
872 static void event_queue_cleanup(Manager
*manager
, enum event_state match_type
) {
873 struct event
*event
, *tmp
;
875 LIST_FOREACH_SAFE(event
, event
, tmp
, manager
->events
) {
876 if (match_type
!= EVENT_UNDEF
&& match_type
!= event
->state
)
883 static int on_worker(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
884 Manager
*manager
= userdata
;
889 struct worker_message msg
;
890 struct iovec iovec
= {
892 .iov_len
= sizeof(msg
),
895 struct cmsghdr cmsghdr
;
896 uint8_t buf
[CMSG_SPACE(sizeof(struct ucred
))];
898 struct msghdr msghdr
= {
901 .msg_control
= &control
,
902 .msg_controllen
= sizeof(control
),
904 struct cmsghdr
*cmsg
;
906 struct ucred
*ucred
= NULL
;
907 struct worker
*worker
;
909 size
= recvmsg(fd
, &msghdr
, MSG_DONTWAIT
);
913 else if (errno
== EAGAIN
)
914 /* nothing more to read */
917 return log_error_errno(errno
, "failed to receive message: %m");
918 } else if (size
!= sizeof(struct worker_message
)) {
919 log_warning_errno(EIO
, "ignoring worker message with invalid size %zi bytes", size
);
923 CMSG_FOREACH(cmsg
, &msghdr
) {
924 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
925 cmsg
->cmsg_type
== SCM_CREDENTIALS
&&
926 cmsg
->cmsg_len
== CMSG_LEN(sizeof(struct ucred
)))
927 ucred
= (struct ucred
*) CMSG_DATA(cmsg
);
930 if (!ucred
|| ucred
->pid
<= 0) {
931 log_warning_errno(EIO
, "ignoring worker message without valid PID");
935 /* lookup worker who sent the signal */
936 worker
= hashmap_get(manager
->workers
, PID_TO_PTR(ucred
->pid
));
938 log_debug("worker ["PID_FMT
"] returned, but is no longer tracked", ucred
->pid
);
942 if (worker
->state
!= WORKER_KILLED
)
943 worker
->state
= WORKER_IDLE
;
945 /* worker returned */
946 event_free(worker
->event
);
949 /* we have free workers, try to schedule events */
950 event_queue_start(manager
);
955 static int on_uevent(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
956 Manager
*manager
= userdata
;
957 struct udev_device
*dev
;
962 dev
= udev_monitor_receive_device(manager
->monitor
);
964 udev_device_ensure_usec_initialized(dev
, NULL
);
965 r
= event_queue_insert(manager
, dev
);
967 udev_device_unref(dev
);
969 /* we have fresh events, try to schedule them */
970 event_queue_start(manager
);
976 /* receive the udevd message from userspace */
977 static int on_ctrl_msg(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
978 Manager
*manager
= userdata
;
979 _cleanup_(udev_ctrl_connection_unrefp
) struct udev_ctrl_connection
*ctrl_conn
= NULL
;
980 _cleanup_(udev_ctrl_msg_unrefp
) struct udev_ctrl_msg
*ctrl_msg
= NULL
;
986 ctrl_conn
= udev_ctrl_get_connection(manager
->ctrl
);
990 ctrl_msg
= udev_ctrl_receive_msg(ctrl_conn
);
994 i
= udev_ctrl_get_set_log_level(ctrl_msg
);
996 log_debug("udevd message (SET_LOG_LEVEL) received, log_priority=%i", i
);
997 log_set_max_level(i
);
998 manager_kill_workers(manager
);
1001 if (udev_ctrl_get_stop_exec_queue(ctrl_msg
) > 0) {
1002 log_debug("udevd message (STOP_EXEC_QUEUE) received");
1003 manager
->stop_exec_queue
= true;
1006 if (udev_ctrl_get_start_exec_queue(ctrl_msg
) > 0) {
1007 log_debug("udevd message (START_EXEC_QUEUE) received");
1008 manager
->stop_exec_queue
= false;
1009 event_queue_start(manager
);
1012 if (udev_ctrl_get_reload(ctrl_msg
) > 0) {
1013 log_debug("udevd message (RELOAD) received");
1014 manager_reload(manager
);
1017 str
= udev_ctrl_get_set_env(ctrl_msg
);
1019 _cleanup_free_
char *key
= NULL
, *val
= NULL
, *old_key
= NULL
, *old_val
= NULL
;
1022 eq
= strchr(str
, '=');
1024 log_error("Invalid key format '%s'", str
);
1028 key
= strndup(str
, eq
- str
);
1034 old_val
= hashmap_remove2(manager
->properties
, key
, (void **) &old_key
);
1036 r
= hashmap_ensure_allocated(&manager
->properties
, &string_hash_ops
);
1044 log_debug("udevd message (ENV) received, unset '%s'", key
);
1046 r
= hashmap_put(manager
->properties
, key
, NULL
);
1058 log_debug("udevd message (ENV) received, set '%s=%s'", key
, val
);
1060 r
= hashmap_put(manager
->properties
, key
, val
);
1068 manager_kill_workers(manager
);
1071 i
= udev_ctrl_get_set_children_max(ctrl_msg
);
1073 log_debug("udevd message (SET_MAX_CHILDREN) received, children_max=%i", i
);
1074 arg_children_max
= i
;
1076 (void) sd_notifyf(false,
1078 "STATUS=Processing with %u children at max", arg_children_max
);
1081 if (udev_ctrl_get_ping(ctrl_msg
) > 0)
1082 log_debug("udevd message (SYNC) received");
1084 if (udev_ctrl_get_exit(ctrl_msg
) > 0) {
1085 log_debug("udevd message (EXIT) received");
1086 manager_exit(manager
);
1087 /* keep reference to block the client until we exit
1088 TODO: deal with several blocking exit requests */
1089 manager
->ctrl_conn_blocking
= udev_ctrl_connection_ref(ctrl_conn
);
1095 static int synthesize_change(sd_device
*dev
) {
1096 const char *subsystem
, *sysname
, *devname
, *syspath
, *devtype
;
1097 char filename
[PATH_MAX
];
1100 r
= sd_device_get_subsystem(dev
, &subsystem
);
1104 r
= sd_device_get_sysname(dev
, &sysname
);
1108 r
= sd_device_get_devname(dev
, &devname
);
1112 r
= sd_device_get_syspath(dev
, &syspath
);
1116 r
= sd_device_get_devtype(dev
, &devtype
);
1120 if (streq_ptr("block", subsystem
) &&
1121 streq_ptr("disk", devtype
) &&
1122 !startswith(sysname
, "dm-")) {
1123 _cleanup_(sd_device_enumerator_unrefp
) sd_device_enumerator
*e
= NULL
;
1124 bool part_table_read
= false, has_partitions
= false;
1129 * Try to re-read the partition table. This only succeeds if
1130 * none of the devices is busy. The kernel returns 0 if no
1131 * partition table is found, and we will not get an event for
1134 fd
= open(devname
, O_RDONLY
|O_CLOEXEC
|O_NOFOLLOW
|O_NONBLOCK
);
1136 r
= flock(fd
, LOCK_EX
|LOCK_NB
);
1138 r
= ioctl(fd
, BLKRRPART
, 0);
1142 part_table_read
= true;
1145 /* search for partitions */
1146 r
= sd_device_enumerator_new(&e
);
1150 r
= sd_device_enumerator_allow_uninitialized(e
);
1154 r
= sd_device_enumerator_add_match_parent(e
, dev
);
1158 r
= sd_device_enumerator_add_match_subsystem(e
, "block", true);
1162 FOREACH_DEVICE(e
, d
) {
1165 if (sd_device_get_devtype(d
, &t
) < 0 ||
1166 !streq("partition", t
))
1169 has_partitions
= true;
1174 * We have partitions and re-read the table, the kernel already sent
1175 * out a "change" event for the disk, and "remove/add" for all
1178 if (part_table_read
&& has_partitions
)
1182 * We have partitions but re-reading the partition table did not
1183 * work, synthesize "change" for the disk and all partitions.
1185 log_debug("Device '%s' is closed, synthesising 'change'", devname
);
1186 strscpyl(filename
, sizeof(filename
), syspath
, "/uevent", NULL
);
1187 write_string_file(filename
, "change", WRITE_STRING_FILE_DISABLE_BUFFER
);
1189 FOREACH_DEVICE(e
, d
) {
1190 const char *t
, *n
, *s
;
1192 if (sd_device_get_devtype(d
, &t
) < 0 ||
1193 !streq("partition", t
))
1196 if (sd_device_get_devname(d
, &n
) < 0 ||
1197 sd_device_get_syspath(d
, &s
) < 0)
1200 log_debug("Device '%s' is closed, synthesising partition '%s' 'change'", devname
, n
);
1201 strscpyl(filename
, sizeof(filename
), s
, "/uevent", NULL
);
1202 write_string_file(filename
, "change", WRITE_STRING_FILE_DISABLE_BUFFER
);
1208 log_debug("Device %s is closed, synthesising 'change'", devname
);
1209 strscpyl(filename
, sizeof(filename
), syspath
, "/uevent", NULL
);
1210 write_string_file(filename
, "change", WRITE_STRING_FILE_DISABLE_BUFFER
);
1215 static int on_inotify(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
1216 Manager
*manager
= userdata
;
1217 union inotify_event_buffer buffer
;
1218 struct inotify_event
*e
;
1223 (void) manager_disable_kill_workers_event(manager
);
1225 l
= read(fd
, &buffer
, sizeof(buffer
));
1227 if (IN_SET(errno
, EAGAIN
, EINTR
))
1230 return log_error_errno(errno
, "Failed to read inotify fd: %m");
1233 FOREACH_INOTIFY_EVENT(e
, buffer
, l
) {
1234 _cleanup_(sd_device_unrefp
) sd_device
*dev
= NULL
;
1235 const char *devnode
;
1237 if (udev_watch_lookup(e
->wd
, &dev
) <= 0)
1240 if (sd_device_get_devname(dev
, &devnode
) < 0)
1243 log_device_debug(dev
, "Inotify event: %x for %s", e
->mask
, devnode
);
1244 if (e
->mask
& IN_CLOSE_WRITE
)
1245 synthesize_change(dev
);
1246 else if (e
->mask
& IN_IGNORED
)
1247 udev_watch_end(dev
);
1253 static int on_sigterm(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
1254 Manager
*manager
= userdata
;
1258 manager_exit(manager
);
1263 static int on_sighup(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
1264 Manager
*manager
= userdata
;
1268 manager_reload(manager
);
1273 static int on_sigchld(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
1274 Manager
*manager
= userdata
;
1281 struct worker
*worker
;
1283 pid
= waitpid(-1, &status
, WNOHANG
);
1287 worker
= hashmap_get(manager
->workers
, PID_TO_PTR(pid
));
1289 log_warning("worker ["PID_FMT
"] is unknown, ignoring", pid
);
1293 if (WIFEXITED(status
)) {
1294 if (WEXITSTATUS(status
) == 0)
1295 log_debug("worker ["PID_FMT
"] exited", pid
);
1297 log_warning("worker ["PID_FMT
"] exited with return code %i", pid
, WEXITSTATUS(status
));
1298 } else if (WIFSIGNALED(status
)) {
1299 log_warning("worker ["PID_FMT
"] terminated by signal %i (%s)", pid
, WTERMSIG(status
), signal_to_string(WTERMSIG(status
)));
1300 } else if (WIFSTOPPED(status
)) {
1301 log_info("worker ["PID_FMT
"] stopped", pid
);
1303 } else if (WIFCONTINUED(status
)) {
1304 log_info("worker ["PID_FMT
"] continued", pid
);
1307 log_warning("worker ["PID_FMT
"] exit with status 0x%04x", pid
, status
);
1309 if ((!WIFEXITED(status
) || WEXITSTATUS(status
) != 0) && worker
->event
) {
1310 log_error("worker ["PID_FMT
"] failed while handling '%s'", pid
, worker
->event
->devpath
);
1311 /* delete state from disk */
1312 udev_device_delete_db(worker
->event
->dev
);
1313 udev_device_tag_index(worker
->event
->dev
, NULL
, false);
1314 /* forward kernel event without amending it */
1315 udev_monitor_send_device(manager
->monitor
, NULL
, worker
->event
->dev_kernel
);
1318 worker_free(worker
);
1321 /* we can start new workers, try to schedule events */
1322 event_queue_start(manager
);
1324 /* Disable unnecessary cleanup event */
1325 if (hashmap_isempty(manager
->workers
) && manager
->kill_workers_event
)
1326 (void) sd_event_source_set_enabled(manager
->kill_workers_event
, SD_EVENT_OFF
);
1331 static int on_post(sd_event_source
*s
, void *userdata
) {
1332 Manager
*manager
= userdata
;
1336 if (!LIST_IS_EMPTY(manager
->events
))
1339 /* There are no pending events. Let's cleanup idle process. */
1341 if (!hashmap_isempty(manager
->workers
)) {
1342 /* There are idle workers */
1343 (void) manager_enable_kill_workers_event(manager
);
1347 /* There are no idle workers. */
1350 return sd_event_exit(manager
->event
, 0);
1352 if (manager
->cgroup
)
1353 /* cleanup possible left-over processes in our cgroup */
1354 (void) cg_kill(SYSTEMD_CGROUP_CONTROLLER
, manager
->cgroup
, SIGKILL
, CGROUP_IGNORE_SELF
, NULL
, NULL
, NULL
);
1359 static int listen_fds(int *ret_ctrl
, int *ret_netlink
) {
1360 int ctrl_fd
= -1, netlink_fd
= -1;
1364 assert(ret_netlink
);
1366 n
= sd_listen_fds(true);
1370 for (fd
= SD_LISTEN_FDS_START
; fd
< n
+ SD_LISTEN_FDS_START
; fd
++) {
1371 if (sd_is_socket(fd
, AF_LOCAL
, SOCK_SEQPACKET
, -1) > 0) {
1378 if (sd_is_socket(fd
, AF_NETLINK
, SOCK_RAW
, -1) > 0) {
1379 if (netlink_fd
>= 0)
1388 *ret_ctrl
= ctrl_fd
;
1389 *ret_netlink
= netlink_fd
;
1395 * read the kernel command line, in case we need to get into debug mode
1396 * udev.log_priority=<level> syslog priority
1397 * udev.children_max=<number of workers> events are fully serialized if set to 1
1398 * udev.exec_delay=<number of seconds> delay execution of every executed program
1399 * udev.event_timeout=<number of seconds> seconds to wait before terminating an event
1401 static int parse_proc_cmdline_item(const char *key
, const char *value
, void *data
) {
1409 if (proc_cmdline_key_streq(key
, "udev.log_priority")) {
1411 if (proc_cmdline_value_missing(key
, value
))
1414 r
= log_level_from_string(value
);
1416 log_set_max_level(r
);
1418 } else if (proc_cmdline_key_streq(key
, "udev.event_timeout")) {
1420 if (proc_cmdline_value_missing(key
, value
))
1423 r
= parse_sec(value
, &arg_event_timeout_usec
);
1425 arg_event_timeout_warn_usec
= DIV_ROUND_UP(arg_event_timeout_usec
, 3);
1427 } else if (proc_cmdline_key_streq(key
, "udev.children_max")) {
1429 if (proc_cmdline_value_missing(key
, value
))
1432 r
= safe_atou(value
, &arg_children_max
);
1434 } else if (proc_cmdline_key_streq(key
, "udev.exec_delay")) {
1436 if (proc_cmdline_value_missing(key
, value
))
1439 r
= parse_sec(value
, &arg_exec_delay_usec
);
1441 } else if (startswith(key
, "udev."))
1442 log_warning("Unknown udev kernel command line option \"%s\"", key
);
1445 log_warning_errno(r
, "Failed to parse \"%s=%s\", ignoring: %m", key
, value
);
1450 static int help(void) {
1451 _cleanup_free_
char *link
= NULL
;
1454 r
= terminal_urlify_man("systemd-udevd.service", "8", &link
);
1458 printf("%s [OPTIONS...]\n\n"
1459 "Manages devices.\n\n"
1460 " -h --help Print this message\n"
1461 " -V --version Print version of the program\n"
1462 " -d --daemon Detach and run in the background\n"
1463 " -D --debug Enable debug output\n"
1464 " -c --children-max=INT Set maximum number of workers\n"
1465 " -e --exec-delay=SECONDS Seconds to wait before executing RUN=\n"
1466 " -t --event-timeout=SECONDS Seconds to wait before terminating an event\n"
1467 " -N --resolve-names=early|late|never\n"
1468 " When to resolve users and groups\n"
1469 "\nSee the %s for details.\n"
1470 , program_invocation_short_name
1477 static int parse_argv(int argc
, char *argv
[]) {
1478 static const struct option options
[] = {
1479 { "daemon", no_argument
, NULL
, 'd' },
1480 { "debug", no_argument
, NULL
, 'D' },
1481 { "children-max", required_argument
, NULL
, 'c' },
1482 { "exec-delay", required_argument
, NULL
, 'e' },
1483 { "event-timeout", required_argument
, NULL
, 't' },
1484 { "resolve-names", required_argument
, NULL
, 'N' },
1485 { "help", no_argument
, NULL
, 'h' },
1486 { "version", no_argument
, NULL
, 'V' },
1495 while ((c
= getopt_long(argc
, argv
, "c:de:Dt:N:hV", options
, NULL
)) >= 0) {
1501 arg_daemonize
= true;
1504 r
= safe_atou(optarg
, &arg_children_max
);
1506 log_warning_errno(r
, "Failed to parse --children-max= value '%s', ignoring: %m", optarg
);
1509 r
= parse_sec(optarg
, &arg_exec_delay_usec
);
1511 log_warning_errno(r
, "Failed to parse --exec-delay= value '%s', ignoring: %m", optarg
);
1514 r
= parse_sec(optarg
, &arg_event_timeout_usec
);
1516 log_warning_errno(r
, "Failed to parse --event-timeout= value '%s', ignoring: %m", optarg
);
1518 arg_event_timeout_warn_usec
= DIV_ROUND_UP(arg_event_timeout_usec
, 3);
1524 ResolveNameTiming t
;
1526 t
= resolve_name_timing_from_string(optarg
);
1528 log_warning("Invalid --resolve-names= value '%s', ignoring.", optarg
);
1530 arg_resolve_name_timing
= t
;
1536 printf("%s\n", PACKAGE_VERSION
);
1541 assert_not_reached("Unhandled option");
1549 static int manager_new(Manager
**ret
, int fd_ctrl
, int fd_uevent
, const char *cgroup
) {
1550 _cleanup_(manager_freep
) Manager
*manager
= NULL
;
1555 manager
= new(Manager
, 1);
1559 *manager
= (Manager
) {
1561 .worker_watch
= { -1, -1 },
1565 udev_builtin_init();
1567 manager
->rules
= udev_rules_new(arg_resolve_name_timing
);
1568 if (!manager
->rules
)
1569 return log_error_errno(ENOMEM
, "error reading rules");
1571 manager
->ctrl
= udev_ctrl_new_from_fd(fd_ctrl
);
1573 return log_error_errno(EINVAL
, "error taking over udev control socket");
1575 r
= udev_ctrl_enable_receiving(manager
->ctrl
);
1577 return log_error_errno(r
, "Failed to bind udev control socket: %m");
1579 fd_ctrl
= udev_ctrl_get_fd(manager
->ctrl
);
1581 return log_error_errno(fd_ctrl
, "Failed to get udev control fd: %m");
1583 manager
->monitor
= udev_monitor_new_from_netlink_fd(NULL
, "kernel", fd_uevent
);
1584 if (!manager
->monitor
)
1585 return log_error_errno(EINVAL
, "error taking over netlink socket");
1587 (void) udev_monitor_set_receive_buffer_size(manager
->monitor
, 128 * 1024 * 1024);
1589 r
= udev_monitor_enable_receiving(manager
->monitor
);
1591 return log_error_errno(r
, "Failed to bind netlink socket; %m");
1593 fd_uevent
= udev_monitor_get_fd(manager
->monitor
);
1595 return log_error_errno(fd_uevent
, "Failed to get uevent fd: %m");
1597 /* unnamed socket from workers to the main daemon */
1598 r
= socketpair(AF_LOCAL
, SOCK_DGRAM
|SOCK_CLOEXEC
, 0, manager
->worker_watch
);
1600 return log_error_errno(errno
, "error creating socketpair: %m");
1602 fd_worker
= manager
->worker_watch
[READ_END
];
1604 r
= setsockopt_int(fd_worker
, SOL_SOCKET
, SO_PASSCRED
, true);
1606 return log_error_errno(r
, "could not enable SO_PASSCRED: %m");
1608 r
= udev_watch_init();
1610 return log_error_errno(r
, "Failed to create inotify descriptor: %m");
1611 manager
->fd_inotify
= r
;
1613 udev_watch_restore();
1615 /* block and listen to all signals on signalfd */
1616 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGTERM
, SIGINT
, SIGHUP
, SIGCHLD
, -1) >= 0);
1618 r
= sd_event_default(&manager
->event
);
1620 return log_error_errno(r
, "could not allocate event loop: %m");
1622 r
= sd_event_add_signal(manager
->event
, NULL
, SIGINT
, on_sigterm
, manager
);
1624 return log_error_errno(r
, "error creating sigint event source: %m");
1626 r
= sd_event_add_signal(manager
->event
, NULL
, SIGTERM
, on_sigterm
, manager
);
1628 return log_error_errno(r
, "error creating sigterm event source: %m");
1630 r
= sd_event_add_signal(manager
->event
, NULL
, SIGHUP
, on_sighup
, manager
);
1632 return log_error_errno(r
, "error creating sighup event source: %m");
1634 r
= sd_event_add_signal(manager
->event
, NULL
, SIGCHLD
, on_sigchld
, manager
);
1636 return log_error_errno(r
, "error creating sigchld event source: %m");
1638 r
= sd_event_set_watchdog(manager
->event
, true);
1640 return log_error_errno(r
, "error creating watchdog event source: %m");
1642 r
= sd_event_add_io(manager
->event
, &manager
->ctrl_event
, fd_ctrl
, EPOLLIN
, on_ctrl_msg
, manager
);
1644 return log_error_errno(r
, "error creating ctrl event source: %m");
1646 /* This needs to be after the inotify and uevent handling, to make sure
1647 * that the ping is send back after fully processing the pending uevents
1648 * (including the synthetic ones we may create due to inotify events).
1650 r
= sd_event_source_set_priority(manager
->ctrl_event
, SD_EVENT_PRIORITY_IDLE
);
1652 return log_error_errno(r
, "cold not set IDLE event priority for ctrl event source: %m");
1654 r
= sd_event_add_io(manager
->event
, &manager
->inotify_event
, manager
->fd_inotify
, EPOLLIN
, on_inotify
, manager
);
1656 return log_error_errno(r
, "error creating inotify event source: %m");
1658 r
= sd_event_add_io(manager
->event
, &manager
->uevent_event
, fd_uevent
, EPOLLIN
, on_uevent
, manager
);
1660 return log_error_errno(r
, "error creating uevent event source: %m");
1662 r
= sd_event_add_io(manager
->event
, NULL
, fd_worker
, EPOLLIN
, on_worker
, manager
);
1664 return log_error_errno(r
, "error creating worker event source: %m");
1666 r
= sd_event_add_post(manager
->event
, NULL
, on_post
, manager
);
1668 return log_error_errno(r
, "error creating post event source: %m");
1670 *ret
= TAKE_PTR(manager
);
1675 static int run(int fd_ctrl
, int fd_uevent
, const char *cgroup
) {
1676 _cleanup_(manager_freep
) Manager
*manager
= NULL
;
1679 r
= manager_new(&manager
, fd_ctrl
, fd_uevent
, cgroup
);
1681 r
= log_error_errno(r
, "failed to allocate manager object: %m");
1685 r
= udev_rules_apply_static_dev_perms(manager
->rules
);
1687 log_error_errno(r
, "failed to apply permissions on static device nodes: %m");
1689 (void) sd_notifyf(false,
1691 "STATUS=Processing with %u children at max", arg_children_max
);
1693 r
= sd_event_loop(manager
->event
);
1695 log_error_errno(r
, "event loop failed: %m");
1699 sd_event_get_exit_code(manager
->event
, &r
);
1704 "STATUS=Shutting down...");
1706 udev_ctrl_cleanup(manager
->ctrl
);
1710 int main(int argc
, char *argv
[]) {
1711 _cleanup_free_
char *cgroup
= NULL
;
1712 int fd_ctrl
= -1, fd_uevent
= -1;
1715 log_set_target(LOG_TARGET_AUTO
);
1716 udev_parse_config();
1717 log_parse_environment();
1720 r
= parse_argv(argc
, argv
);
1724 r
= proc_cmdline_parse(parse_proc_cmdline_item
, NULL
, PROC_CMDLINE_STRIP_RD_PREFIX
);
1726 log_warning_errno(r
, "failed to parse kernel command line, ignoring: %m");
1729 log_set_target(LOG_TARGET_CONSOLE
);
1730 log_set_max_level(LOG_DEBUG
);
1733 log_set_max_level_realm(LOG_REALM_SYSTEMD
, log_get_max_level());
1739 if (arg_children_max
== 0) {
1741 unsigned long mem_limit
;
1743 arg_children_max
= 8;
1745 if (sched_getaffinity(0, sizeof(cpu_set
), &cpu_set
) == 0)
1746 arg_children_max
+= CPU_COUNT(&cpu_set
) * 8;
1748 mem_limit
= physical_memory() / (128LU*1024*1024);
1749 arg_children_max
= MAX(10U, MIN(arg_children_max
, mem_limit
));
1751 log_debug("set children_max to %u", arg_children_max
);
1754 /* set umask before creating any file/directory */
1757 r
= log_error_errno(errno
, "could not change dir to /: %m");
1763 r
= mac_selinux_init();
1765 log_error_errno(r
, "could not initialize labelling: %m");
1769 r
= mkdir_errno_wrapper("/run/udev", 0755);
1770 if (r
< 0 && r
!= -EEXIST
) {
1771 log_error_errno(r
, "could not create /run/udev: %m");
1775 dev_setup(NULL
, UID_INVALID
, GID_INVALID
);
1777 if (getppid() == 1) {
1778 /* get our own cgroup, we regularly kill everything udev has left behind
1779 we only do this on systemd systems, and only if we are directly spawned
1780 by PID1. otherwise we are not guaranteed to have a dedicated cgroup */
1781 r
= cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER
, 0, &cgroup
);
1783 if (IN_SET(r
, -ENOENT
, -ENOMEDIUM
))
1784 log_debug_errno(r
, "did not find dedicated cgroup: %m");
1786 log_warning_errno(r
, "failed to get cgroup: %m");
1790 r
= listen_fds(&fd_ctrl
, &fd_uevent
);
1792 r
= log_error_errno(r
, "could not listen on fds: %m");
1796 if (arg_daemonize
) {
1799 log_info("starting version " PACKAGE_VERSION
);
1801 /* connect /dev/null to stdin, stdout, stderr */
1802 if (log_get_max_level() < LOG_DEBUG
) {
1803 r
= make_null_stdio();
1805 log_warning_errno(r
, "Failed to redirect standard streams to /dev/null: %m");
1813 r
= log_error_errno(errno
, "fork of daemon failed: %m");
1816 mac_selinux_finish();
1818 _exit(EXIT_SUCCESS
);
1823 r
= set_oom_score_adjust(-1000);
1825 log_debug_errno(r
, "Failed to adjust OOM score, ignoring: %m");
1828 r
= run(fd_ctrl
, fd_uevent
, cgroup
);
1831 mac_selinux_finish();
1833 return r
< 0 ? EXIT_FAILURE
: EXIT_SUCCESS
;