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