]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/udev/udevd.c
projects / thirdparty / systemd.git / blob
? search:


697506feaf55dd5a826a434e42215cf393ac3bb8
[thirdparty/systemd.git] / src / udev / udevd.c
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3 * Copyright © 2004 Chris Friesen <chris_friesen@sympatico.ca>
4 * Copyright © 2009 Canonical Ltd.
5 * Copyright © 2009 Scott James Remnant <scott@netsplit.com>
6 */
7
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <getopt.h>
11 #include <signal.h>
12 #include <stdbool.h>
13 #include <stddef.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <sys/epoll.h>
18 #include <sys/file.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>
25 #include <sys/stat.h>
26 #include <sys/time.h>
27 #include <sys/wait.h>
28 #include <unistd.h>
29
30 #include "sd-daemon.h"
31 #include "sd-event.h"
32
33 #include "alloc-util.h"
34 #include "build.h"
35 #include "cgroup-util.h"
36 #include "cpu-set-util.h"
37 #include "dev-setup.h"
38 #include "device-monitor-private.h"
39 #include "device-private.h"
40 #include "device-util.h"
41 #include "event-util.h"
42 #include "fd-util.h"
43 #include "fileio.h"
44 #include "format-util.h"
45 #include "fs-util.h"
46 #include "hashmap.h"
47 #include "io-util.h"
48 #include "libudev-device-internal.h"
49 #include "list.h"
50 #include "main-func.h"
51 #include "mkdir.h"
52 #include "netlink-util.h"
53 #include "parse-util.h"
54 #include "pretty-print.h"
55 #include "proc-cmdline.h"
56 #include "process-util.h"
57 #include "selinux-util.h"
58 #include "signal-util.h"
59 #include "socket-util.h"
60 #include "string-util.h"
61 #include "strv.h"
62 #include "strxcpyx.h"
63 #include "syslog-util.h"
64 #include "udev-builtin.h"
65 #include "udev-ctrl.h"
66 #include "udev-util.h"
67 #include "udev-watch.h"
68 #include "udev.h"
69 #include "user-util.h"
70
71 static bool arg_debug = false;
72 static int arg_daemonize = false;
73 static ResolveNameTiming arg_resolve_name_timing = RESOLVE_NAME_EARLY;
74 static unsigned arg_children_max = 0;
75 static usec_t arg_exec_delay_usec = 0;
76 static usec_t arg_event_timeout_usec = 180 * USEC_PER_SEC;
77
78 typedef struct Manager {
79 sd_event *event;
80 Hashmap *workers;
81 LIST_HEAD(struct event, events);
82 const char *cgroup;
83 pid_t pid; /* the process that originally allocated the manager object */
84
85 UdevRules *rules;
86 Hashmap *properties;
87
88 sd_netlink *rtnl;
89
90 sd_device_monitor *monitor;
91 struct udev_ctrl *ctrl;
92 struct udev_ctrl_connection *ctrl_conn_blocking;
93 int fd_inotify;
94 int worker_watch[2];
95
96 sd_event_source *ctrl_event;
97 sd_event_source *uevent_event;
98 sd_event_source *inotify_event;
99 sd_event_source *kill_workers_event;
100
101 usec_t last_usec;
102
103 bool stop_exec_queue:1;
104 bool exit:1;
105 } Manager;
106
107 enum event_state {
108 EVENT_UNDEF,
109 EVENT_QUEUED,
110 EVENT_RUNNING,
111 };
112
113 struct event {
114 Manager *manager;
115 struct worker *worker;
116 enum event_state state;
117
118 sd_device *dev;
119 sd_device *dev_kernel; /* clone of originally received device */
120
121 uint64_t seqnum;
122 uint64_t delaying_seqnum;
123
124 sd_event_source *timeout_warning_event;
125 sd_event_source *timeout_event;
126
127 LIST_FIELDS(struct event, event);
128 };
129
130 static void event_queue_cleanup(Manager *manager, enum event_state type);
131
132 enum worker_state {
133 WORKER_UNDEF,
134 WORKER_RUNNING,
135 WORKER_IDLE,
136 WORKER_KILLED,
137 };
138
139 struct worker {
140 Manager *manager;
141 pid_t pid;
142 sd_device_monitor *monitor;
143 enum worker_state state;
144 struct event *event;
145 };
146
147 /* passed from worker to main process */
148 struct worker_message {
149 };
150
151 static void event_free(struct event *event) {
152 if (!event)
153 return;
154
155 assert(event->manager);
156
157 LIST_REMOVE(event, event->manager->events, event);
158 sd_device_unref(event->dev);
159 sd_device_unref(event->dev_kernel);
160
161 sd_event_source_unref(event->timeout_warning_event);
162 sd_event_source_unref(event->timeout_event);
163
164 if (event->worker)
165 event->worker->event = NULL;
166
167 /* only clean up the queue from the process that created it */
168 if (LIST_IS_EMPTY(event->manager->events) &&
169 event->manager->pid == getpid_cached())
170 if (unlink("/run/udev/queue") < 0)
171 log_warning_errno(errno, "Failed to unlink /run/udev/queue: %m");
172
173 free(event);
174 }
175
176 static void worker_free(struct worker *worker) {
177 if (!worker)
178 return;
179
180 assert(worker->manager);
181
182 hashmap_remove(worker->manager->workers, PID_TO_PTR(worker->pid));
183 sd_device_monitor_unref(worker->monitor);
184 event_free(worker->event);
185
186 free(worker);
187 }
188
189 static void manager_workers_free(Manager *manager) {
190 struct worker *worker;
191 Iterator i;
192
193 assert(manager);
194
195 HASHMAP_FOREACH(worker, manager->workers, i)
196 worker_free(worker);
197
198 manager->workers = hashmap_free(manager->workers);
199 }
200
201 static int worker_new(struct worker **ret, Manager *manager, sd_device_monitor *worker_monitor, pid_t pid) {
202 _cleanup_free_ struct worker *worker = NULL;
203 int r;
204
205 assert(ret);
206 assert(manager);
207 assert(worker_monitor);
208 assert(pid > 1);
209
210 worker = new0(struct worker, 1);
211 if (!worker)
212 return -ENOMEM;
213
214 worker->manager = manager;
215 /* close monitor, but keep address around */
216 device_monitor_disconnect(worker_monitor);
217 worker->monitor = sd_device_monitor_ref(worker_monitor);
218 worker->pid = pid;
219
220 r = hashmap_ensure_allocated(&manager->workers, NULL);
221 if (r < 0)
222 return r;
223
224 r = hashmap_put(manager->workers, PID_TO_PTR(pid), worker);
225 if (r < 0)
226 return r;
227
228 *ret = TAKE_PTR(worker);
229
230 return 0;
231 }
232
233 static int on_event_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
234 struct event *event = userdata;
235
236 assert(event);
237 assert(event->worker);
238
239 kill_and_sigcont(event->worker->pid, SIGKILL);
240 event->worker->state = WORKER_KILLED;
241
242 log_device_error(event->dev, "Worker ["PID_FMT"] processing SEQNUM=%"PRIu64" killed", event->worker->pid, event->seqnum);
243
244 return 1;
245 }
246
247 static int on_event_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) {
248 struct event *event = userdata;
249
250 assert(event);
251 assert(event->worker);
252
253 log_device_warning(event->dev, "Worker ["PID_FMT"] processing SEQNUM=%"PRIu64" is taking a long time", event->worker->pid, event->seqnum);
254
255 return 1;
256 }
257
258 static void worker_attach_event(struct worker *worker, struct event *event) {
259 sd_event *e;
260 uint64_t usec;
261
262 assert(worker);
263 assert(worker->manager);
264 assert(event);
265 assert(!event->worker);
266 assert(!worker->event);
267
268 worker->state = WORKER_RUNNING;
269 worker->event = event;
270 event->state = EVENT_RUNNING;
271 event->worker = worker;
272
273 e = worker->manager->event;
274
275 assert_se(sd_event_now(e, CLOCK_MONOTONIC, &usec) >= 0);
276
277 (void) sd_event_add_time(e, &event->timeout_warning_event, CLOCK_MONOTONIC,
278 usec + udev_warn_timeout(arg_event_timeout_usec), USEC_PER_SEC, on_event_timeout_warning, event);
279
280 (void) sd_event_add_time(e, &event->timeout_event, CLOCK_MONOTONIC,
281 usec + arg_event_timeout_usec, USEC_PER_SEC, on_event_timeout, event);
282 }
283
284 static void manager_clear_for_worker(Manager *manager) {
285 assert(manager);
286
287 manager->ctrl_event = sd_event_source_unref(manager->ctrl_event);
288 manager->uevent_event = sd_event_source_unref(manager->uevent_event);
289 manager->inotify_event = sd_event_source_unref(manager->inotify_event);
290 manager->kill_workers_event = sd_event_source_unref(manager->kill_workers_event);
291
292 manager->event = sd_event_unref(manager->event);
293
294 manager_workers_free(manager);
295 event_queue_cleanup(manager, EVENT_UNDEF);
296
297 manager->monitor = sd_device_monitor_unref(manager->monitor);
298 manager->ctrl_conn_blocking = udev_ctrl_connection_unref(manager->ctrl_conn_blocking);
299 manager->ctrl = udev_ctrl_unref(manager->ctrl);
300
301 manager->worker_watch[READ_END] = safe_close(manager->worker_watch[READ_END]);
302 }
303
304 static void manager_free(Manager *manager) {
305 if (!manager)
306 return;
307
308 udev_builtin_exit();
309
310 manager_clear_for_worker(manager);
311
312 sd_netlink_unref(manager->rtnl);
313
314 hashmap_free_free_free(manager->properties);
315 udev_rules_free(manager->rules);
316
317 safe_close(manager->fd_inotify);
318 safe_close_pair(manager->worker_watch);
319
320 free(manager);
321 }
322
323 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
324
325 static int worker_send_message(int fd) {
326 struct worker_message message = {};
327
328 return loop_write(fd, &message, sizeof(message), false);
329 }
330
331 static int worker_lock_block_device(sd_device *dev, int *ret_fd) {
332 _cleanup_close_ int fd = -1;
333 const char *val;
334 int r;
335
336 assert(dev);
337 assert(ret_fd);
338
339 /*
340 * Take a shared lock on the device node; this establishes
341 * a concept of device "ownership" to serialize device
342 * access. External processes holding an exclusive lock will
343 * cause udev to skip the event handling; in the case udev
344 * acquired the lock, the external process can block until
345 * udev has finished its event handling.
346 */
347
348 r = sd_device_get_property_value(dev, "ACTION", &val);
349 if (r < 0)
350 return log_device_debug_errno(dev, r, "Failed to get the value of property 'ACTION': %m");
351
352 if (streq(val, "remove"))
353 return 0;
354
355 r = sd_device_get_subsystem(dev, &val);
356 if (r < 0)
357 return log_device_debug_errno(dev, r, "Failed to get subsystem: %m");
358
359 if (!streq(val, "block"))
360 return 0;
361
362 r = sd_device_get_sysname(dev, &val);
363 if (r < 0)
364 return log_device_debug_errno(dev, r, "Failed to get sysname: %m");
365
366 if (STARTSWITH_SET(val, "dm-", "md", "drbd"))
367 return 0;
368
369 r = sd_device_get_devtype(dev, &val);
370 if (r < 0 && r != -ENOENT)
371 return log_device_debug_errno(dev, r, "Failed to get devtype: %m");
372 if (r >= 0 && streq(val, "partition")) {
373 r = sd_device_get_parent(dev, &dev);
374 if (r < 0)
375 return log_device_debug_errno(dev, r, "Failed to get parent device: %m");
376 }
377
378 r = sd_device_get_devname(dev, &val);
379 if (r == -ENOENT)
380 return 0;
381 if (r < 0)
382 return log_device_debug_errno(dev, r, "Failed to get devname: %m");
383
384 fd = open(val, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
385 if (fd < 0) {
386 log_device_debug_errno(dev, errno, "Failed to open '%s', ignoring: %m", val);
387 return 0;
388 }
389
390 if (flock(fd, LOCK_SH|LOCK_NB) < 0)
391 return log_device_debug_errno(dev, errno, "Failed to flock(%s): %m", val);
392
393 *ret_fd = TAKE_FD(fd);
394 return 1;
395 }
396
397 static int worker_process_device(Manager *manager, sd_device *dev) {
398 _cleanup_(udev_event_freep) UdevEvent *udev_event = NULL;
399 _cleanup_close_ int fd_lock = -1;
400 const char *seqnum;
401 int r;
402
403 assert(manager);
404 assert(dev);
405
406 r = sd_device_get_property_value(dev, "SEQNUM", &seqnum);
407 if (r < 0)
408 log_device_debug_errno(dev, r, "Failed to get SEQNUM: %m");
409
410 log_device_debug(dev, "Processing device (SEQNUM=%s)", seqnum);
411
412 udev_event = udev_event_new(dev, arg_exec_delay_usec, manager->rtnl);
413 if (!udev_event)
414 return -ENOMEM;
415
416 r = worker_lock_block_device(dev, &fd_lock);
417 if (r < 0)
418 return r;
419
420 /* apply rules, create node, symlinks */
421 udev_event_execute_rules(udev_event, arg_event_timeout_usec, manager->properties, manager->rules);
422 udev_event_execute_run(udev_event, arg_event_timeout_usec);
423
424 if (!manager->rtnl)
425 /* in case rtnl was initialized */
426 manager->rtnl = sd_netlink_ref(udev_event->rtnl);
427
428 /* apply/restore inotify watch */
429 if (udev_event->inotify_watch) {
430 (void) udev_watch_begin(dev);
431 r = device_update_db(dev);
432 if (r < 0)
433 return log_device_debug_errno(dev, r, "Failed to update database under /run/udev/data/: %m");
434 }
435
436 log_device_debug(dev, "Device (SEQNUM=%s) processed", seqnum);
437
438 return 0;
439 }
440
441 static int worker_device_monitor_handler(sd_device_monitor *monitor, sd_device *dev, void *userdata) {
442 Manager *manager = userdata;
443 int r;
444
445 assert(dev);
446 assert(manager);
447
448 r = worker_process_device(manager, dev);
449 if (r < 0)
450 log_device_warning_errno(dev, r, "Failed to process device, ignoring: %m");
451
452 /* send processed event back to libudev listeners */
453 r = device_monitor_send_device(monitor, NULL, dev);
454 if (r < 0)
455 log_device_warning_errno(dev, r, "Failed to send device, ignoring: %m");
456
457 /* send udevd the result of the event execution */
458 r = worker_send_message(manager->worker_watch[WRITE_END]);
459 if (r < 0)
460 log_device_warning_errno(dev, r, "Failed to send signal to main daemon, ignoring: %m");
461
462 return 1;
463 }
464
465 static int worker_main(Manager *_manager, sd_device_monitor *monitor, sd_device *first_device) {
466 _cleanup_(sd_device_unrefp) sd_device *dev = first_device;
467 _cleanup_(manager_freep) Manager *manager = _manager;
468 int r;
469
470 assert(manager);
471 assert(monitor);
472 assert(dev);
473
474 unsetenv("NOTIFY_SOCKET");
475
476 assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, -1) >= 0);
477
478 /* Reset OOM score, we only protect the main daemon. */
479 r = set_oom_score_adjust(0);
480 if (r < 0)
481 log_debug_errno(r, "Failed to reset OOM score, ignoring: %m");
482
483 /* Clear unnecessary data in Manager object.*/
484 manager_clear_for_worker(manager);
485
486 r = sd_event_new(&manager->event);
487 if (r < 0)
488 return log_error_errno(r, "Failed to allocate event loop: %m");
489
490 r = sd_event_add_signal(manager->event, NULL, SIGTERM, NULL, NULL);
491 if (r < 0)
492 return log_error_errno(r, "Failed to set SIGTERM event: %m");
493
494 r = sd_device_monitor_attach_event(monitor, manager->event);
495 if (r < 0)
496 return log_error_errno(r, "Failed to attach event loop to device monitor: %m");
497
498 r = sd_device_monitor_start(monitor, worker_device_monitor_handler, manager);
499 if (r < 0)
500 return log_error_errno(r, "Failed to start device monitor: %m");
501
502 (void) sd_event_source_set_description(sd_device_monitor_get_event_source(monitor), "worker-device-monitor");
503
504 /* Process first device */
505 (void) worker_device_monitor_handler(monitor, dev, manager);
506
507 r = sd_event_loop(manager->event);
508 if (r < 0)
509 return log_error_errno(r, "Event loop failed: %m");
510
511 return 0;
512 }
513
514 static int worker_spawn(Manager *manager, struct event *event) {
515 _cleanup_(sd_device_monitor_unrefp) sd_device_monitor *worker_monitor = NULL;
516 struct worker *worker;
517 pid_t pid;
518 int r;
519
520 /* listen for new events */
521 r = device_monitor_new_full(&worker_monitor, MONITOR_GROUP_NONE, -1);
522 if (r < 0)
523 return r;
524
525 /* allow the main daemon netlink address to send devices to the worker */
526 r = device_monitor_allow_unicast_sender(worker_monitor, manager->monitor);
527 if (r < 0)
528 return log_error_errno(r, "Worker: Failed to set unicast sender: %m");
529
530 r = device_monitor_enable_receiving(worker_monitor);
531 if (r < 0)
532 return log_error_errno(r, "Worker: Failed to enable receiving of device: %m");
533
534 r = safe_fork(NULL, FORK_DEATHSIG, &pid);
535 if (r < 0) {
536 event->state = EVENT_QUEUED;
537 return log_error_errno(r, "Failed to fork() worker: %m");
538 }
539 if (r == 0) {
540 /* Worker process */
541 r = worker_main(manager, worker_monitor, sd_device_ref(event->dev));
542 log_close();
543 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
544 }
545
546 r = worker_new(&worker, manager, worker_monitor, pid);
547 if (r < 0)
548 return log_error_errno(r, "Failed to create worker object: %m");
549
550 worker_attach_event(worker, event);
551
552 log_device_debug(event->dev, "Worker ["PID_FMT"] is forked for processing SEQNUM=%"PRIu64".", pid, event->seqnum);
553 return 0;
554 }
555
556 static void event_run(Manager *manager, struct event *event) {
557 struct worker *worker;
558 Iterator i;
559 int r;
560
561 assert(manager);
562 assert(event);
563
564 HASHMAP_FOREACH(worker, manager->workers, i) {
565 if (worker->state != WORKER_IDLE)
566 continue;
567
568 r = device_monitor_send_device(manager->monitor, worker->monitor, event->dev);
569 if (r < 0) {
570 log_device_error_errno(event->dev, r, "Worker ["PID_FMT"] did not accept message, killing the worker: %m",
571 worker->pid);
572 (void) kill(worker->pid, SIGKILL);
573 worker->state = WORKER_KILLED;
574 continue;
575 }
576 worker_attach_event(worker, event);
577 return;
578 }
579
580 if (hashmap_size(manager->workers) >= arg_children_max) {
581 if (arg_children_max > 1)
582 log_debug("Maximum number (%u) of children reached.", hashmap_size(manager->workers));
583 return;
584 }
585
586 /* start new worker and pass initial device */
587 worker_spawn(manager, event);
588 }
589
590 static int event_queue_insert(Manager *manager, sd_device *dev) {
591 _cleanup_(sd_device_unrefp) sd_device *clone = NULL;
592 struct event *event;
593 const char *val;
594 uint64_t seqnum;
595 int r;
596
597 assert(manager);
598 assert(dev);
599
600 /* only one process can add events to the queue */
601 if (manager->pid == 0)
602 manager->pid = getpid_cached();
603
604 assert(manager->pid == getpid_cached());
605
606 /* We only accepts devices received by device monitor. */
607 r = sd_device_get_property_value(dev, "SEQNUM", &val);
608 if (r < 0)
609 return r;
610
611 r = safe_atou64(val, &seqnum);
612 if (r < 0)
613 return r;
614
615 if (seqnum == 0)
616 return -EINVAL;
617
618 /* Save original device to restore the state on failures. */
619 r = device_shallow_clone(dev, &clone);
620 if (r < 0)
621 return r;
622
623 r = device_copy_properties(clone, dev);
624 if (r < 0)
625 return r;
626
627 event = new(struct event, 1);
628 if (!event)
629 return -ENOMEM;
630
631 *event = (struct event) {
632 .manager = manager,
633 .dev = sd_device_ref(dev),
634 .dev_kernel = TAKE_PTR(clone),
635 .seqnum = seqnum,
636 .state = EVENT_QUEUED,
637 };
638
639 if (LIST_IS_EMPTY(manager->events)) {
640 r = touch("/run/udev/queue");
641 if (r < 0)
642 log_warning_errno(r, "Failed to touch /run/udev/queue: %m");
643 }
644
645 LIST_APPEND(event, manager->events, event);
646
647 if (DEBUG_LOGGING) {
648 if (sd_device_get_property_value(dev, "ACTION", &val) < 0)
649 val = NULL;
650
651 log_device_debug(dev, "Device (SEQNUM=%"PRIu64", ACTION=%s) is queued", seqnum, strnull(val));
652 }
653
654 return 0;
655 }
656
657 static void manager_kill_workers(Manager *manager) {
658 struct worker *worker;
659 Iterator i;
660
661 assert(manager);
662
663 HASHMAP_FOREACH(worker, manager->workers, i) {
664 if (worker->state == WORKER_KILLED)
665 continue;
666
667 worker->state = WORKER_KILLED;
668 (void) kill(worker->pid, SIGTERM);
669 }
670 }
671
672 /* lookup event for identical, parent, child device */
673 static int is_device_busy(Manager *manager, struct event *event) {
674 const char *subsystem, *devpath, *devpath_old = NULL;
675 dev_t devnum = makedev(0, 0);
676 struct event *loop_event;
677 size_t devpath_len;
678 int r, ifindex = 0;
679 bool is_block;
680
681 r = sd_device_get_subsystem(event->dev, &subsystem);
682 if (r < 0)
683 return r;
684
685 is_block = streq(subsystem, "block");
686
687 r = sd_device_get_devpath(event->dev, &devpath);
688 if (r < 0)
689 return r;
690
691 devpath_len = strlen(devpath);
692
693 r = sd_device_get_property_value(event->dev, "DEVPATH_OLD", &devpath_old);
694 if (r < 0 && r != -ENOENT)
695 return r;
696
697 r = sd_device_get_devnum(event->dev, &devnum);
698 if (r < 0 && r != -ENOENT)
699 return r;
700
701 r = sd_device_get_ifindex(event->dev, &ifindex);
702 if (r < 0 && r != -ENOENT)
703 return r;
704
705 /* check if queue contains events we depend on */
706 LIST_FOREACH(event, loop_event, manager->events) {
707 size_t loop_devpath_len, common;
708 const char *loop_devpath;
709
710 /* we already found a later event, earlier cannot block us, no need to check again */
711 if (loop_event->seqnum < event->delaying_seqnum)
712 continue;
713
714 /* event we checked earlier still exists, no need to check again */
715 if (loop_event->seqnum == event->delaying_seqnum)
716 return true;
717
718 /* found ourself, no later event can block us */
719 if (loop_event->seqnum >= event->seqnum)
720 break;
721
722 /* check major/minor */
723 if (major(devnum) != 0) {
724 const char *s;
725 dev_t d;
726
727 if (sd_device_get_subsystem(loop_event->dev, &s) < 0)
728 continue;
729
730 if (sd_device_get_devnum(loop_event->dev, &d) >= 0 &&
731 devnum == d && is_block == streq(s, "block"))
732 return true;
733 }
734
735 /* check network device ifindex */
736 if (ifindex > 0) {
737 int i;
738
739 if (sd_device_get_ifindex(loop_event->dev, &i) >= 0 &&
740 ifindex == i)
741 return true;
742 }
743
744 if (sd_device_get_devpath(loop_event->dev, &loop_devpath) < 0)
745 continue;
746
747 /* check our old name */
748 if (devpath_old && streq(devpath_old, loop_devpath)) {
749 event->delaying_seqnum = loop_event->seqnum;
750 return true;
751 }
752
753 loop_devpath_len = strlen(loop_devpath);
754
755 /* compare devpath */
756 common = MIN(devpath_len, loop_devpath_len);
757
758 /* one devpath is contained in the other? */
759 if (!strneq(devpath, loop_devpath, common))
760 continue;
761
762 /* identical device event found */
763 if (devpath_len == loop_devpath_len) {
764 /* devices names might have changed/swapped in the meantime */
765 if (major(devnum) != 0 || ifindex > 0)
766 continue;
767 event->delaying_seqnum = loop_event->seqnum;
768 return true;
769 }
770
771 /* parent device event found */
772 if (devpath[common] == '/') {
773 event->delaying_seqnum = loop_event->seqnum;
774 return true;
775 }
776
777 /* child device event found */
778 if (loop_devpath[common] == '/') {
779 event->delaying_seqnum = loop_event->seqnum;
780 return true;
781 }
782 }
783
784 return false;
785 }
786
787 static int on_exit_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
788 Manager *manager = userdata;
789
790 assert(manager);
791
792 log_error("Giving up waiting for workers to finish.");
793 sd_event_exit(manager->event, -ETIMEDOUT);
794
795 return 1;
796 }
797
798 static void manager_exit(Manager *manager) {
799 uint64_t usec;
800 int r;
801
802 assert(manager);
803
804 manager->exit = true;
805
806 sd_notify(false,
807 "STOPPING=1\n"
808 "STATUS=Starting shutdown...");
809
810 /* close sources of new events and discard buffered events */
811 manager->ctrl_event = sd_event_source_unref(manager->ctrl_event);
812 manager->ctrl = udev_ctrl_unref(manager->ctrl);
813
814 manager->inotify_event = sd_event_source_unref(manager->inotify_event);
815 manager->fd_inotify = safe_close(manager->fd_inotify);
816
817 manager->uevent_event = sd_event_source_unref(manager->uevent_event);
818 manager->monitor = sd_device_monitor_unref(manager->monitor);
819
820 /* discard queued events and kill workers */
821 event_queue_cleanup(manager, EVENT_QUEUED);
822 manager_kill_workers(manager);
823
824 assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);
825
826 r = sd_event_add_time(manager->event, NULL, CLOCK_MONOTONIC,
827 usec + 30 * USEC_PER_SEC, USEC_PER_SEC, on_exit_timeout, manager);
828 if (r < 0)
829 return;
830 }
831
832 /* reload requested, HUP signal received, rules changed, builtin changed */
833 static void manager_reload(Manager *manager) {
834
835 assert(manager);
836
837 sd_notify(false,
838 "RELOADING=1\n"
839 "STATUS=Flushing configuration...");
840
841 manager_kill_workers(manager);
842 manager->rules = udev_rules_free(manager->rules);
843 udev_builtin_exit();
844
845 sd_notifyf(false,
846 "READY=1\n"
847 "STATUS=Processing with %u children at max", arg_children_max);
848 }
849
850 static int on_kill_workers_event(sd_event_source *s, uint64_t usec, void *userdata) {
851 Manager *manager = userdata;
852
853 assert(manager);
854
855 log_debug("Cleanup idle workers");
856 manager_kill_workers(manager);
857
858 return 1;
859 }
860
861 static void event_queue_start(Manager *manager) {
862 struct event *event;
863 usec_t usec;
864 int r;
865
866 assert(manager);
867
868 if (LIST_IS_EMPTY(manager->events) ||
869 manager->exit || manager->stop_exec_queue)
870 return;
871
872 assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);
873 /* check for changed config, every 3 seconds at most */
874 if (manager->last_usec == 0 ||
875 (usec - manager->last_usec) > 3 * USEC_PER_SEC) {
876 if (udev_rules_check_timestamp(manager->rules) ||
877 udev_builtin_validate())
878 manager_reload(manager);
879
880 manager->last_usec = usec;
881 }
882
883 r = event_source_disable(manager->kill_workers_event);
884 if (r < 0)
885 log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
886
887 udev_builtin_init();
888
889 if (!manager->rules) {
890 r = udev_rules_new(&manager->rules, arg_resolve_name_timing);
891 if (r < 0) {
892 log_warning_errno(r, "Failed to read udev rules: %m");
893 return;
894 }
895 }
896
897 LIST_FOREACH(event, event, manager->events) {
898 if (event->state != EVENT_QUEUED)
899 continue;
900
901 /* do not start event if parent or child event is still running */
902 if (is_device_busy(manager, event) != 0)
903 continue;
904
905 event_run(manager, event);
906 }
907 }
908
909 static void event_queue_cleanup(Manager *manager, enum event_state match_type) {
910 struct event *event, *tmp;
911
912 LIST_FOREACH_SAFE(event, event, tmp, manager->events) {
913 if (match_type != EVENT_UNDEF && match_type != event->state)
914 continue;
915
916 event_free(event);
917 }
918 }
919
920 static int on_worker(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
921 Manager *manager = userdata;
922
923 assert(manager);
924
925 for (;;) {
926 struct worker_message msg;
927 struct iovec iovec = {
928 .iov_base = &msg,
929 .iov_len = sizeof(msg),
930 };
931 union {
932 struct cmsghdr cmsghdr;
933 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
934 } control = {};
935 struct msghdr msghdr = {
936 .msg_iov = &iovec,
937 .msg_iovlen = 1,
938 .msg_control = &control,
939 .msg_controllen = sizeof(control),
940 };
941 struct cmsghdr *cmsg;
942 ssize_t size;
943 struct ucred *ucred = NULL;
944 struct worker *worker;
945
946 size = recvmsg(fd, &msghdr, MSG_DONTWAIT);
947 if (size < 0) {
948 if (errno == EINTR)
949 continue;
950 else if (errno == EAGAIN)
951 /* nothing more to read */
952 break;
953
954 return log_error_errno(errno, "Failed to receive message: %m");
955 } else if (size != sizeof(struct worker_message)) {
956 log_warning("Ignoring worker message with invalid size %zi bytes", size);
957 continue;
958 }
959
960 CMSG_FOREACH(cmsg, &msghdr) {
961 if (cmsg->cmsg_level == SOL_SOCKET &&
962 cmsg->cmsg_type == SCM_CREDENTIALS &&
963 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
964 ucred = (struct ucred*) CMSG_DATA(cmsg);
965 }
966
967 if (!ucred || ucred->pid <= 0) {
968 log_warning("Ignoring worker message without valid PID");
969 continue;
970 }
971
972 /* lookup worker who sent the signal */
973 worker = hashmap_get(manager->workers, PID_TO_PTR(ucred->pid));
974 if (!worker) {
975 log_debug("Worker ["PID_FMT"] returned, but is no longer tracked", ucred->pid);
976 continue;
977 }
978
979 if (worker->state != WORKER_KILLED)
980 worker->state = WORKER_IDLE;
981
982 /* worker returned */
983 event_free(worker->event);
984 }
985
986 /* we have free workers, try to schedule events */
987 event_queue_start(manager);
988
989 return 1;
990 }
991
992 static int on_uevent(sd_device_monitor *monitor, sd_device *dev, void *userdata) {
993 Manager *manager = userdata;
994 int r;
995
996 assert(manager);
997
998 device_ensure_usec_initialized(dev, NULL);
999
1000 r = event_queue_insert(manager, dev);
1001 if (r < 0) {
1002 log_device_error_errno(dev, r, "Failed to insert device into event queue: %m");
1003 return 1;
1004 }
1005
1006 /* we have fresh events, try to schedule them */
1007 event_queue_start(manager);
1008
1009 return 1;
1010 }
1011
1012 /* receive the udevd message from userspace */
1013 static int on_ctrl_msg(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1014 Manager *manager = userdata;
1015 _cleanup_(udev_ctrl_connection_unrefp) struct udev_ctrl_connection *ctrl_conn = NULL;
1016 _cleanup_(udev_ctrl_msg_unrefp) struct udev_ctrl_msg *ctrl_msg = NULL;
1017 const char *str;
1018 int i, r;
1019
1020 assert(manager);
1021
1022 ctrl_conn = udev_ctrl_get_connection(manager->ctrl);
1023 if (!ctrl_conn)
1024 return 1;
1025
1026 ctrl_msg = udev_ctrl_receive_msg(ctrl_conn);
1027 if (!ctrl_msg)
1028 return 1;
1029
1030 i = udev_ctrl_get_set_log_level(ctrl_msg);
1031 if (i >= 0) {
1032 log_debug("Received udev control message (SET_LOG_LEVEL), setting log_priority=%i", i);
1033 log_set_max_level(i);
1034 manager_kill_workers(manager);
1035 }
1036
1037 if (udev_ctrl_get_stop_exec_queue(ctrl_msg) > 0) {
1038 log_debug("Received udev control message (STOP_EXEC_QUEUE)");
1039 manager->stop_exec_queue = true;
1040 }
1041
1042 if (udev_ctrl_get_start_exec_queue(ctrl_msg) > 0) {
1043 log_debug("Received udev control message (START_EXEC_QUEUE)");
1044 manager->stop_exec_queue = false;
1045 event_queue_start(manager);
1046 }
1047
1048 if (udev_ctrl_get_reload(ctrl_msg) > 0) {
1049 log_debug("Received udev control message (RELOAD)");
1050 manager_reload(manager);
1051 }
1052
1053 str = udev_ctrl_get_set_env(ctrl_msg);
1054 if (str) {
1055 _cleanup_free_ char *key = NULL, *val = NULL, *old_key = NULL, *old_val = NULL;
1056 char *eq;
1057
1058 eq = strchr(str, '=');
1059 if (!eq) {
1060 log_error("Invalid key format '%s'", str);
1061 return 1;
1062 }
1063
1064 key = strndup(str, eq - str);
1065 if (!key) {
1066 log_oom();
1067 return 1;
1068 }
1069
1070 old_val = hashmap_remove2(manager->properties, key, (void **) &old_key);
1071
1072 r = hashmap_ensure_allocated(&manager->properties, &string_hash_ops);
1073 if (r < 0) {
1074 log_oom();
1075 return 1;
1076 }
1077
1078 eq++;
1079 if (!isempty(eq)) {
1080 log_debug("Received udev control message (ENV), unsetting '%s'", key);
1081
1082 r = hashmap_put(manager->properties, key, NULL);
1083 if (r < 0) {
1084 log_oom();
1085 return 1;
1086 }
1087 } else {
1088 val = strdup(eq);
1089 if (!val) {
1090 log_oom();
1091 return 1;
1092 }
1093
1094 log_debug("Received udev control message (ENV), setting '%s=%s'", key, val);
1095
1096 r = hashmap_put(manager->properties, key, val);
1097 if (r < 0) {
1098 log_oom();
1099 return 1;
1100 }
1101 }
1102
1103 key = val = NULL;
1104 manager_kill_workers(manager);
1105 }
1106
1107 i = udev_ctrl_get_set_children_max(ctrl_msg);
1108 if (i >= 0) {
1109 log_debug("Receivd udev control message (SET_MAX_CHILDREN), setting children_max=%i", i);
1110 arg_children_max = i;
1111
1112 (void) sd_notifyf(false,
1113 "READY=1\n"
1114 "STATUS=Processing with %u children at max", arg_children_max);
1115 }
1116
1117 if (udev_ctrl_get_ping(ctrl_msg) > 0)
1118 log_debug("Received udev control message (SYNC)");
1119
1120 if (udev_ctrl_get_exit(ctrl_msg) > 0) {
1121 log_debug("Received udev control message (EXIT)");
1122 manager_exit(manager);
1123 /* keep reference to block the client until we exit
1124 TODO: deal with several blocking exit requests */
1125 manager->ctrl_conn_blocking = udev_ctrl_connection_ref(ctrl_conn);
1126 }
1127
1128 return 1;
1129 }
1130
1131 static int synthesize_change(sd_device *dev) {
1132 const char *subsystem, *sysname, *devname, *syspath, *devtype;
1133 char filename[PATH_MAX];
1134 int r;
1135
1136 r = sd_device_get_subsystem(dev, &subsystem);
1137 if (r < 0)
1138 return r;
1139
1140 r = sd_device_get_sysname(dev, &sysname);
1141 if (r < 0)
1142 return r;
1143
1144 r = sd_device_get_devname(dev, &devname);
1145 if (r < 0)
1146 return r;
1147
1148 r = sd_device_get_syspath(dev, &syspath);
1149 if (r < 0)
1150 return r;
1151
1152 r = sd_device_get_devtype(dev, &devtype);
1153 if (r < 0)
1154 return r;
1155
1156 if (streq_ptr("block", subsystem) &&
1157 streq_ptr("disk", devtype) &&
1158 !startswith(sysname, "dm-")) {
1159 _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
1160 bool part_table_read = false, has_partitions = false;
1161 sd_device *d;
1162 int fd;
1163
1164 /*
1165 * Try to re-read the partition table. This only succeeds if
1166 * none of the devices is busy. The kernel returns 0 if no
1167 * partition table is found, and we will not get an event for
1168 * the disk.
1169 */
1170 fd = open(devname, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
1171 if (fd >= 0) {
1172 r = flock(fd, LOCK_EX|LOCK_NB);
1173 if (r >= 0)
1174 r = ioctl(fd, BLKRRPART, 0);
1175
1176 close(fd);
1177 if (r >= 0)
1178 part_table_read = true;
1179 }
1180
1181 /* search for partitions */
1182 r = sd_device_enumerator_new(&e);
1183 if (r < 0)
1184 return r;
1185
1186 r = sd_device_enumerator_allow_uninitialized(e);
1187 if (r < 0)
1188 return r;
1189
1190 r = sd_device_enumerator_add_match_parent(e, dev);
1191 if (r < 0)
1192 return r;
1193
1194 r = sd_device_enumerator_add_match_subsystem(e, "block", true);
1195 if (r < 0)
1196 return r;
1197
1198 FOREACH_DEVICE(e, d) {
1199 const char *t;
1200
1201 if (sd_device_get_devtype(d, &t) < 0 ||
1202 !streq("partition", t))
1203 continue;
1204
1205 has_partitions = true;
1206 break;
1207 }
1208
1209 /*
1210 * We have partitions and re-read the table, the kernel already sent
1211 * out a "change" event for the disk, and "remove/add" for all
1212 * partitions.
1213 */
1214 if (part_table_read && has_partitions)
1215 return 0;
1216
1217 /*
1218 * We have partitions but re-reading the partition table did not
1219 * work, synthesize "change" for the disk and all partitions.
1220 */
1221 log_debug("Device '%s' is closed, synthesising 'change'", devname);
1222 strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
1223 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1224
1225 FOREACH_DEVICE(e, d) {
1226 const char *t, *n, *s;
1227
1228 if (sd_device_get_devtype(d, &t) < 0 ||
1229 !streq("partition", t))
1230 continue;
1231
1232 if (sd_device_get_devname(d, &n) < 0 ||
1233 sd_device_get_syspath(d, &s) < 0)
1234 continue;
1235
1236 log_debug("Device '%s' is closed, synthesising partition '%s' 'change'", devname, n);
1237 strscpyl(filename, sizeof(filename), s, "/uevent", NULL);
1238 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1239 }
1240
1241 return 0;
1242 }
1243
1244 log_debug("Device %s is closed, synthesising 'change'", devname);
1245 strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
1246 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1247
1248 return 0;
1249 }
1250
1251 static int on_inotify(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1252 Manager *manager = userdata;
1253 union inotify_event_buffer buffer;
1254 struct inotify_event *e;
1255 ssize_t l;
1256 int r;
1257
1258 assert(manager);
1259
1260 r = event_source_disable(manager->kill_workers_event);
1261 if (r < 0)
1262 log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
1263
1264 l = read(fd, &buffer, sizeof(buffer));
1265 if (l < 0) {
1266 if (IN_SET(errno, EAGAIN, EINTR))
1267 return 1;
1268
1269 return log_error_errno(errno, "Failed to read inotify fd: %m");
1270 }
1271
1272 FOREACH_INOTIFY_EVENT(e, buffer, l) {
1273 _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
1274 const char *devnode;
1275
1276 if (udev_watch_lookup(e->wd, &dev) <= 0)
1277 continue;
1278
1279 if (sd_device_get_devname(dev, &devnode) < 0)
1280 continue;
1281
1282 log_device_debug(dev, "Inotify event: %x for %s", e->mask, devnode);
1283 if (e->mask & IN_CLOSE_WRITE)
1284 synthesize_change(dev);
1285 else if (e->mask & IN_IGNORED)
1286 udev_watch_end(dev);
1287 }
1288
1289 return 1;
1290 }
1291
1292 static int on_sigterm(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1293 Manager *manager = userdata;
1294
1295 assert(manager);
1296
1297 manager_exit(manager);
1298
1299 return 1;
1300 }
1301
1302 static int on_sighup(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1303 Manager *manager = userdata;
1304
1305 assert(manager);
1306
1307 manager_reload(manager);
1308
1309 return 1;
1310 }
1311
1312 static int on_sigchld(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1313 Manager *manager = userdata;
1314 int r;
1315
1316 assert(manager);
1317
1318 for (;;) {
1319 pid_t pid;
1320 int status;
1321 struct worker *worker;
1322
1323 pid = waitpid(-1, &status, WNOHANG);
1324 if (pid <= 0)
1325 break;
1326
1327 worker = hashmap_get(manager->workers, PID_TO_PTR(pid));
1328 if (!worker) {
1329 log_warning("Worker ["PID_FMT"] is unknown, ignoring", pid);
1330 continue;
1331 }
1332
1333 if (WIFEXITED(status)) {
1334 if (WEXITSTATUS(status) == 0)
1335 log_debug("Worker ["PID_FMT"] exited", pid);
1336 else
1337 log_warning("Worker ["PID_FMT"] exited with return code %i", pid, WEXITSTATUS(status));
1338 } else if (WIFSIGNALED(status)) {
1339 log_warning("Worker ["PID_FMT"] terminated by signal %i (%s)", pid, WTERMSIG(status), signal_to_string(WTERMSIG(status)));
1340 } else if (WIFSTOPPED(status)) {
1341 log_info("Worker ["PID_FMT"] stopped", pid);
1342 continue;
1343 } else if (WIFCONTINUED(status)) {
1344 log_info("Worker ["PID_FMT"] continued", pid);
1345 continue;
1346 } else
1347 log_warning("Worker ["PID_FMT"] exit with status 0x%04x", pid, status);
1348
1349 if ((!WIFEXITED(status) || WEXITSTATUS(status) != 0) && worker->event) {
1350 log_device_error(worker->event->dev, "Worker ["PID_FMT"] failed", pid);
1351
1352 /* delete state from disk */
1353 device_delete_db(worker->event->dev);
1354 device_tag_index(worker->event->dev, NULL, false);
1355
1356 /* forward kernel event without amending it */
1357 r = device_monitor_send_device(manager->monitor, NULL, worker->event->dev_kernel);
1358 if (r < 0)
1359 log_device_error_errno(worker->event->dev_kernel, r, "Failed to send back device to kernel: %m");
1360 }
1361
1362 worker_free(worker);
1363 }
1364
1365 /* we can start new workers, try to schedule events */
1366 event_queue_start(manager);
1367
1368 /* Disable unnecessary cleanup event */
1369 if (hashmap_isempty(manager->workers)) {
1370 r = event_source_disable(manager->kill_workers_event);
1371 if (r < 0)
1372 log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
1373 }
1374
1375 return 1;
1376 }
1377
1378 static int on_post(sd_event_source *s, void *userdata) {
1379 Manager *manager = userdata;
1380
1381 assert(manager);
1382
1383 if (!LIST_IS_EMPTY(manager->events))
1384 return 1;
1385
1386 /* There are no pending events. Let's cleanup idle process. */
1387
1388 if (!hashmap_isempty(manager->workers)) {
1389 /* There are idle workers */
1390 (void) event_reset_time(manager->event, &manager->kill_workers_event, CLOCK_MONOTONIC,
1391 now(CLOCK_MONOTONIC) + 3 * USEC_PER_SEC, USEC_PER_SEC,
1392 on_kill_workers_event, manager, 0, "kill-workers-event", false);
1393 return 1;
1394 }
1395
1396 /* There are no idle workers. */
1397
1398 if (manager->exit)
1399 return sd_event_exit(manager->event, 0);
1400
1401 if (manager->cgroup)
1402 /* cleanup possible left-over processes in our cgroup */
1403 (void) cg_kill(SYSTEMD_CGROUP_CONTROLLER, manager->cgroup, SIGKILL, CGROUP_IGNORE_SELF, NULL, NULL, NULL);
1404
1405 return 1;
1406 }
1407
1408 static int listen_fds(int *ret_ctrl, int *ret_netlink) {
1409 int ctrl_fd = -1, netlink_fd = -1;
1410 int fd, n;
1411
1412 assert(ret_ctrl);
1413 assert(ret_netlink);
1414
1415 n = sd_listen_fds(true);
1416 if (n < 0)
1417 return n;
1418
1419 for (fd = SD_LISTEN_FDS_START; fd < n + SD_LISTEN_FDS_START; fd++) {
1420 if (sd_is_socket(fd, AF_LOCAL, SOCK_SEQPACKET, -1) > 0) {
1421 if (ctrl_fd >= 0)
1422 return -EINVAL;
1423 ctrl_fd = fd;
1424 continue;
1425 }
1426
1427 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
1428 if (netlink_fd >= 0)
1429 return -EINVAL;
1430 netlink_fd = fd;
1431 continue;
1432 }
1433
1434 return -EINVAL;
1435 }
1436
1437 *ret_ctrl = ctrl_fd;
1438 *ret_netlink = netlink_fd;
1439
1440 return 0;
1441 }
1442
1443 /*
1444 * read the kernel command line, in case we need to get into debug mode
1445 * udev.log_priority=<level> syslog priority
1446 * udev.children_max=<number of workers> events are fully serialized if set to 1
1447 * udev.exec_delay=<number of seconds> delay execution of every executed program
1448 * udev.event_timeout=<number of seconds> seconds to wait before terminating an event
1449 */
1450 static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
1451 int r = 0;
1452
1453 assert(key);
1454
1455 if (!value)
1456 return 0;
1457
1458 if (proc_cmdline_key_streq(key, "udev.log_priority")) {
1459
1460 if (proc_cmdline_value_missing(key, value))
1461 return 0;
1462
1463 r = log_level_from_string(value);
1464 if (r >= 0)
1465 log_set_max_level(r);
1466
1467 } else if (proc_cmdline_key_streq(key, "udev.event_timeout")) {
1468
1469 if (proc_cmdline_value_missing(key, value))
1470 return 0;
1471
1472 r = parse_sec(value, &arg_event_timeout_usec);
1473
1474 } else if (proc_cmdline_key_streq(key, "udev.children_max")) {
1475
1476 if (proc_cmdline_value_missing(key, value))
1477 return 0;
1478
1479 r = safe_atou(value, &arg_children_max);
1480
1481 } else if (proc_cmdline_key_streq(key, "udev.exec_delay")) {
1482
1483 if (proc_cmdline_value_missing(key, value))
1484 return 0;
1485
1486 r = parse_sec(value, &arg_exec_delay_usec);
1487
1488 } else if (startswith(key, "udev."))
1489 log_warning("Unknown udev kernel command line option \"%s\", ignoring", key);
1490
1491 if (r < 0)
1492 log_warning_errno(r, "Failed to parse \"%s=%s\", ignoring: %m", key, value);
1493
1494 return 0;
1495 }
1496
1497 static int help(void) {
1498 _cleanup_free_ char *link = NULL;
1499 int r;
1500
1501 r = terminal_urlify_man("systemd-udevd.service", "8", &link);
1502 if (r < 0)
1503 return log_oom();
1504
1505 printf("%s [OPTIONS...]\n\n"
1506 "Manages devices.\n\n"
1507 " -h --help Print this message\n"
1508 " -V --version Print version of the program\n"
1509 " -d --daemon Detach and run in the background\n"
1510 " -D --debug Enable debug output\n"
1511 " -c --children-max=INT Set maximum number of workers\n"
1512 " -e --exec-delay=SECONDS Seconds to wait before executing RUN=\n"
1513 " -t --event-timeout=SECONDS Seconds to wait before terminating an event\n"
1514 " -N --resolve-names=early|late|never\n"
1515 " When to resolve users and groups\n"
1516 "\nSee the %s for details.\n"
1517 , program_invocation_short_name
1518 , link
1519 );
1520
1521 return 0;
1522 }
1523
1524 static int parse_argv(int argc, char *argv[]) {
1525 static const struct option options[] = {
1526 { "daemon", no_argument, NULL, 'd' },
1527 { "debug", no_argument, NULL, 'D' },
1528 { "children-max", required_argument, NULL, 'c' },
1529 { "exec-delay", required_argument, NULL, 'e' },
1530 { "event-timeout", required_argument, NULL, 't' },
1531 { "resolve-names", required_argument, NULL, 'N' },
1532 { "help", no_argument, NULL, 'h' },
1533 { "version", no_argument, NULL, 'V' },
1534 {}
1535 };
1536
1537 int c, r;
1538
1539 assert(argc >= 0);
1540 assert(argv);
1541
1542 while ((c = getopt_long(argc, argv, "c:de:Dt:N:hV", options, NULL)) >= 0) {
1543 switch (c) {
1544
1545 case 'd':
1546 arg_daemonize = true;
1547 break;
1548 case 'c':
1549 r = safe_atou(optarg, &arg_children_max);
1550 if (r < 0)
1551 log_warning_errno(r, "Failed to parse --children-max= value '%s', ignoring: %m", optarg);
1552 break;
1553 case 'e':
1554 r = parse_sec(optarg, &arg_exec_delay_usec);
1555 if (r < 0)
1556 log_warning_errno(r, "Failed to parse --exec-delay= value '%s', ignoring: %m", optarg);
1557 break;
1558 case 't':
1559 r = parse_sec(optarg, &arg_event_timeout_usec);
1560 if (r < 0)
1561 log_warning_errno(r, "Failed to parse --event-timeout= value '%s', ignoring: %m", optarg);
1562 break;
1563 case 'D':
1564 arg_debug = true;
1565 break;
1566 case 'N': {
1567 ResolveNameTiming t;
1568
1569 t = resolve_name_timing_from_string(optarg);
1570 if (t < 0)
1571 log_warning("Invalid --resolve-names= value '%s', ignoring.", optarg);
1572 else
1573 arg_resolve_name_timing = t;
1574 break;
1575 }
1576 case 'h':
1577 return help();
1578 case 'V':
1579 printf("%s\n", GIT_VERSION);
1580 return 0;
1581 case '?':
1582 return -EINVAL;
1583 default:
1584 assert_not_reached("Unhandled option");
1585
1586 }
1587 }
1588
1589 return 1;
1590 }
1591
1592 static int manager_new(Manager **ret, int fd_ctrl, int fd_uevent, const char *cgroup) {
1593 _cleanup_(manager_freep) Manager *manager = NULL;
1594 int r;
1595
1596 assert(ret);
1597
1598 manager = new(Manager, 1);
1599 if (!manager)
1600 return log_oom();
1601
1602 *manager = (Manager) {
1603 .fd_inotify = -1,
1604 .worker_watch = { -1, -1 },
1605 .cgroup = cgroup,
1606 };
1607
1608 manager->ctrl = udev_ctrl_new_from_fd(fd_ctrl);
1609 if (!manager->ctrl)
1610 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to initialize udev control socket");
1611
1612 r = udev_ctrl_enable_receiving(manager->ctrl);
1613 if (r < 0)
1614 return log_error_errno(r, "Failed to bind udev control socket: %m");
1615
1616 r = device_monitor_new_full(&manager->monitor, MONITOR_GROUP_KERNEL, fd_uevent);
1617 if (r < 0)
1618 return log_error_errno(r, "Failed to initialize device monitor: %m");
1619
1620 (void) sd_device_monitor_set_receive_buffer_size(manager->monitor, 128 * 1024 * 1024);
1621
1622 r = device_monitor_enable_receiving(manager->monitor);
1623 if (r < 0)
1624 return log_error_errno(r, "Failed to bind netlink socket: %m");
1625
1626 *ret = TAKE_PTR(manager);
1627
1628 return 0;
1629 }
1630
1631 static int main_loop(Manager *manager) {
1632 int fd_worker, fd_ctrl, r;
1633
1634 /* unnamed socket from workers to the main daemon */
1635 r = socketpair(AF_LOCAL, SOCK_DGRAM|SOCK_CLOEXEC, 0, manager->worker_watch);
1636 if (r < 0)
1637 return log_error_errno(errno, "Failed to create socketpair for communicating with workers: %m");
1638
1639 fd_worker = manager->worker_watch[READ_END];
1640
1641 r = setsockopt_int(fd_worker, SOL_SOCKET, SO_PASSCRED, true);
1642 if (r < 0)
1643 return log_error_errno(r, "Failed to enable SO_PASSCRED: %m");
1644
1645 r = udev_watch_init();
1646 if (r < 0)
1647 return log_error_errno(r, "Failed to create inotify descriptor: %m");
1648 manager->fd_inotify = r;
1649
1650 udev_watch_restore();
1651
1652 /* block and listen to all signals on signalfd */
1653 assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGHUP, SIGCHLD, -1) >= 0);
1654
1655 r = sd_event_default(&manager->event);
1656 if (r < 0)
1657 return log_error_errno(r, "Failed to allocate event loop: %m");
1658
1659 r = sd_event_add_signal(manager->event, NULL, SIGINT, on_sigterm, manager);
1660 if (r < 0)
1661 return log_error_errno(r, "Failed to create SIGINT event source: %m");
1662
1663 r = sd_event_add_signal(manager->event, NULL, SIGTERM, on_sigterm, manager);
1664 if (r < 0)
1665 return log_error_errno(r, "Failed to create SIGTERM event source: %m");
1666
1667 r = sd_event_add_signal(manager->event, NULL, SIGHUP, on_sighup, manager);
1668 if (r < 0)
1669 return log_error_errno(r, "Failed to create SIGHUP event source: %m");
1670
1671 r = sd_event_add_signal(manager->event, NULL, SIGCHLD, on_sigchld, manager);
1672 if (r < 0)
1673 return log_error_errno(r, "Failed to create SIGCHLD event source: %m");
1674
1675 r = sd_event_set_watchdog(manager->event, true);
1676 if (r < 0)
1677 return log_error_errno(r, "Failed to create watchdog event source: %m");
1678
1679 fd_ctrl = udev_ctrl_get_fd(manager->ctrl);
1680 if (fd_ctrl < 0)
1681 return log_error_errno(fd_ctrl, "Failed to get udev control socket fd: %m");
1682
1683 r = sd_event_add_io(manager->event, &manager->ctrl_event, fd_ctrl, EPOLLIN, on_ctrl_msg, manager);
1684 if (r < 0)
1685 return log_error_errno(r, "Failed to create udev control event source: %m");
1686
1687 /* This needs to be after the inotify and uevent handling, to make sure
1688 * that the ping is send back after fully processing the pending uevents
1689 * (including the synthetic ones we may create due to inotify events).
1690 */
1691 r = sd_event_source_set_priority(manager->ctrl_event, SD_EVENT_PRIORITY_IDLE);
1692 if (r < 0)
1693 return log_error_errno(r, "Failed to set IDLE event priority for udev control event source: %m");
1694
1695 r = sd_event_add_io(manager->event, &manager->inotify_event, manager->fd_inotify, EPOLLIN, on_inotify, manager);
1696 if (r < 0)
1697 return log_error_errno(r, "Failed to create inotify event source: %m");
1698
1699 r = sd_device_monitor_attach_event(manager->monitor, manager->event);
1700 if (r < 0)
1701 return log_error_errno(r, "Failed to attach event to device monitor: %m");
1702
1703 r = sd_device_monitor_start(manager->monitor, on_uevent, manager);
1704 if (r < 0)
1705 return log_error_errno(r, "Failed to start device monitor: %m");
1706
1707 (void) sd_event_source_set_description(sd_device_monitor_get_event_source(manager->monitor), "device-monitor");
1708
1709 r = sd_event_add_io(manager->event, NULL, fd_worker, EPOLLIN, on_worker, manager);
1710 if (r < 0)
1711 return log_error_errno(r, "Failed to create worker event source: %m");
1712
1713 r = sd_event_add_post(manager->event, NULL, on_post, manager);
1714 if (r < 0)
1715 return log_error_errno(r, "Failed to create post event source: %m");
1716
1717 udev_builtin_init();
1718
1719 r = udev_rules_new(&manager->rules, arg_resolve_name_timing);
1720 if (!manager->rules)
1721 return log_error_errno(r, "Failed to read udev rules: %m");
1722
1723 r = udev_rules_apply_static_dev_perms(manager->rules);
1724 if (r < 0)
1725 log_error_errno(r, "Failed to apply permissions on static device nodes: %m");
1726
1727 (void) sd_notifyf(false,
1728 "READY=1\n"
1729 "STATUS=Processing with %u children at max", arg_children_max);
1730
1731 r = sd_event_loop(manager->event);
1732 if (r < 0)
1733 log_error_errno(r, "Event loop failed: %m");
1734
1735 sd_notify(false,
1736 "STOPPING=1\n"
1737 "STATUS=Shutting down...");
1738 return r;
1739 }
1740
1741 static int run(int argc, char *argv[]) {
1742 _cleanup_free_ char *cgroup = NULL;
1743 _cleanup_(manager_freep) Manager *manager = NULL;
1744 int fd_ctrl = -1, fd_uevent = -1;
1745 int r;
1746
1747 log_set_target(LOG_TARGET_AUTO);
1748 udev_parse_config_full(&arg_children_max, &arg_exec_delay_usec, &arg_event_timeout_usec, &arg_resolve_name_timing);
1749 log_parse_environment();
1750 log_open();
1751
1752 r = parse_argv(argc, argv);
1753 if (r <= 0)
1754 return r;
1755
1756 r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
1757 if (r < 0)
1758 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
1759
1760 if (arg_debug) {
1761 log_set_target(LOG_TARGET_CONSOLE);
1762 log_set_max_level(LOG_DEBUG);
1763 }
1764
1765 log_set_max_level_realm(LOG_REALM_SYSTEMD, log_get_max_level());
1766
1767 r = must_be_root();
1768 if (r < 0)
1769 return r;
1770
1771 if (arg_children_max == 0) {
1772 cpu_set_t cpu_set;
1773 unsigned long mem_limit;
1774
1775 arg_children_max = 8;
1776
1777 if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) == 0)
1778 arg_children_max += CPU_COUNT(&cpu_set) * 8;
1779
1780 mem_limit = physical_memory() / (128LU*1024*1024);
1781 arg_children_max = MAX(10U, MIN(arg_children_max, mem_limit));
1782
1783 log_debug("Set children_max to %u", arg_children_max);
1784 }
1785
1786 /* set umask before creating any file/directory */
1787 r = chdir("/");
1788 if (r < 0)
1789 return log_error_errno(errno, "Failed to change dir to '/': %m");
1790
1791 umask(022);
1792
1793 r = mac_selinux_init();
1794 if (r < 0)
1795 return log_error_errno(r, "Could not initialize labelling: %m");
1796
1797 r = mkdir_errno_wrapper("/run/udev", 0755);
1798 if (r < 0 && r != -EEXIST)
1799 return log_error_errno(r, "Failed to create /run/udev: %m");
1800
1801 dev_setup(NULL, UID_INVALID, GID_INVALID);
1802
1803 if (getppid() == 1) {
1804 /* get our own cgroup, we regularly kill everything udev has left behind
1805 we only do this on systemd systems, and only if we are directly spawned
1806 by PID1. otherwise we are not guaranteed to have a dedicated cgroup */
1807 r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 0, &cgroup);
1808 if (r < 0) {
1809 if (IN_SET(r, -ENOENT, -ENOMEDIUM))
1810 log_debug_errno(r, "Dedicated cgroup not found: %m");
1811 else
1812 log_warning_errno(r, "Failed to get cgroup: %m");
1813 }
1814 }
1815
1816 r = listen_fds(&fd_ctrl, &fd_uevent);
1817 if (r < 0)
1818 return log_error_errno(r, "Failed to listen on fds: %m");
1819
1820 r = manager_new(&manager, fd_ctrl, fd_uevent, cgroup);
1821 if (r < 0)
1822 return log_error_errno(r, "Failed to create manager: %m");
1823
1824 if (arg_daemonize) {
1825 pid_t pid;
1826
1827 log_info("Starting version " GIT_VERSION);
1828
1829 /* connect /dev/null to stdin, stdout, stderr */
1830 if (log_get_max_level() < LOG_DEBUG) {
1831 r = make_null_stdio();
1832 if (r < 0)
1833 log_warning_errno(r, "Failed to redirect standard streams to /dev/null: %m");
1834 }
1835
1836 pid = fork();
1837 if (pid < 0)
1838 return log_error_errno(errno, "Failed to fork daemon: %m");
1839 if (pid > 0)
1840 /* parent */
1841 return 0;
1842
1843 /* child */
1844 (void) setsid();
1845
1846 r = set_oom_score_adjust(-1000);
1847 if (r < 0)
1848 log_debug_errno(r, "Failed to adjust OOM score, ignoring: %m");
1849 }
1850
1851 r = main_loop(manager);
1852 /* FIXME: move this into manager_free() */
1853 udev_ctrl_cleanup(manager->ctrl);
1854 return r;
1855 }
1856
1857 DEFINE_MAIN_FUNCTION(run);
Unnamed repository; edit this file 'description' to name the repository.