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