]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/manager.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of ssh://git.freedesktop.org/git/systemd/systemd into work
[thirdparty/systemd.git] / src / core / manager.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <sys/epoll.h>
26 #include <signal.h>
27 #include <sys/signalfd.h>
28 #include <sys/wait.h>
29 #include <unistd.h>
30 #include <sys/poll.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
33 #include <linux/kd.h>
34 #include <termios.h>
35 #include <fcntl.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <dirent.h>
39 #include <sys/timerfd.h>
40
41 #ifdef HAVE_AUDIT
42 #include <libaudit.h>
43 #endif
44
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
48
49 #include "manager.h"
50 #include "transaction.h"
51 #include "hashmap.h"
52 #include "macro.h"
53 #include "strv.h"
54 #include "log.h"
55 #include "util.h"
56 #include "mkdir.h"
57 #include "ratelimit.h"
58 #include "cgroup.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
61 #include "dbus-unit.h"
62 #include "dbus-job.h"
63 #include "missing.h"
64 #include "path-lookup.h"
65 #include "special.h"
66 #include "bus-errors.h"
67 #include "exit-status.h"
68 #include "virt.h"
69 #include "watchdog.h"
70 #include "cgroup-util.h"
71 #include "path-util.h"
72 #include "audit-fd.h"
73 #include "efivars.h"
74 #include "env-util.h"
75
76 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_ENTRIES_MAX 16
78
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
81
82 /* Where clients shall send notification messages to */
83 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
84
85 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
86
87 static int manager_setup_notify(Manager *m) {
88 union {
89 struct sockaddr sa;
90 struct sockaddr_un un;
91 } sa;
92 struct epoll_event ev;
93 int one = 1;
94
95 assert(m);
96
97 m->notify_watch.type = WATCH_NOTIFY;
98 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
99 if (m->notify_watch.fd < 0) {
100 log_error("Failed to allocate notification socket: %m");
101 return -errno;
102 }
103
104 zero(sa);
105 sa.sa.sa_family = AF_UNIX;
106
107 if (getpid() != 1 || detect_container(NULL) > 0)
108 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
109 else
110 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
111
112 sa.un.sun_path[0] = 0;
113
114 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
115 log_error("bind() failed: %m");
116 return -errno;
117 }
118
119 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
120 log_error("SO_PASSCRED failed: %m");
121 return -errno;
122 }
123
124 zero(ev);
125 ev.events = EPOLLIN;
126 ev.data.ptr = &m->notify_watch;
127
128 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
129 log_error("Failed to add notification socket fd to epoll: %m");
130 return -errno;
131 }
132
133 sa.un.sun_path[0] = '@';
134 m->notify_socket = strdup(sa.un.sun_path);
135 if (!m->notify_socket)
136 return log_oom();
137
138 log_debug("Using notification socket %s", m->notify_socket);
139
140 return 0;
141 }
142
143 static int manager_setup_time_change(Manager *m) {
144 struct epoll_event ev;
145 struct itimerspec its;
146
147 assert(m);
148 assert(m->time_change_watch.type == WATCH_INVALID);
149
150 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
151 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
152
153 m->time_change_watch.type = WATCH_TIME_CHANGE;
154 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
155 if (m->time_change_watch.fd < 0) {
156 log_error("Failed to create timerfd: %m");
157 return -errno;
158 }
159
160 zero(its);
161
162 /* We only care for the cancellation event, hence we set the
163 * timeout to the latest possible value. */
164 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
165 its.it_value.tv_sec = TIME_T_MAX;
166
167 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
168 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
169 close_nointr_nofail(m->time_change_watch.fd);
170 watch_init(&m->time_change_watch);
171 return 0;
172 }
173
174 zero(ev);
175 ev.events = EPOLLIN;
176 ev.data.ptr = &m->time_change_watch;
177
178 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
179 log_error("Failed to add timer change fd to epoll: %m");
180 return -errno;
181 }
182
183 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
184
185 return 0;
186 }
187
188 static int enable_special_signals(Manager *m) {
189 int fd;
190
191 assert(m);
192
193 /* Enable that we get SIGINT on control-alt-del. In containers
194 * this will fail with EPERM (older) or EINVAL (newer), so
195 * ignore that. */
196 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
197 log_warning("Failed to enable ctrl-alt-del handling: %m");
198
199 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
200 if (fd < 0) {
201 /* Support systems without virtual console */
202 if (fd != -ENOENT)
203 log_warning("Failed to open /dev/tty0: %m");
204 } else {
205 /* Enable that we get SIGWINCH on kbrequest */
206 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
207 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
208
209 close_nointr_nofail(fd);
210 }
211
212 return 0;
213 }
214
215 static int manager_setup_signals(Manager *m) {
216 sigset_t mask;
217 struct epoll_event ev;
218 struct sigaction sa;
219
220 assert(m);
221
222 /* We are not interested in SIGSTOP and friends. */
223 zero(sa);
224 sa.sa_handler = SIG_DFL;
225 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
226 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
227
228 assert_se(sigemptyset(&mask) == 0);
229
230 sigset_add_many(&mask,
231 SIGCHLD, /* Child died */
232 SIGTERM, /* Reexecute daemon */
233 SIGHUP, /* Reload configuration */
234 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
235 SIGUSR2, /* systemd: dump status */
236 SIGINT, /* Kernel sends us this on control-alt-del */
237 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
238 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
239 SIGRTMIN+0, /* systemd: start default.target */
240 SIGRTMIN+1, /* systemd: isolate rescue.target */
241 SIGRTMIN+2, /* systemd: isolate emergency.target */
242 SIGRTMIN+3, /* systemd: start halt.target */
243 SIGRTMIN+4, /* systemd: start poweroff.target */
244 SIGRTMIN+5, /* systemd: start reboot.target */
245 SIGRTMIN+6, /* systemd: start kexec.target */
246 SIGRTMIN+13, /* systemd: Immediate halt */
247 SIGRTMIN+14, /* systemd: Immediate poweroff */
248 SIGRTMIN+15, /* systemd: Immediate reboot */
249 SIGRTMIN+16, /* systemd: Immediate kexec */
250 SIGRTMIN+20, /* systemd: enable status messages */
251 SIGRTMIN+21, /* systemd: disable status messages */
252 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
253 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
254 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
255 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
256 SIGRTMIN+27, /* systemd: set log target to console */
257 SIGRTMIN+28, /* systemd: set log target to kmsg */
258 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
259 -1);
260 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
261
262 m->signal_watch.type = WATCH_SIGNAL;
263 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
264 if (m->signal_watch.fd < 0)
265 return -errno;
266
267 zero(ev);
268 ev.events = EPOLLIN;
269 ev.data.ptr = &m->signal_watch;
270
271 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
272 return -errno;
273
274 if (m->running_as == SYSTEMD_SYSTEM)
275 return enable_special_signals(m);
276
277 return 0;
278 }
279
280 static void manager_strip_environment(Manager *m) {
281 assert(m);
282
283 /* Remove variables from the inherited set that are part of
284 * the container interface:
285 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
286 strv_remove_prefix(m->environment, "container=");
287 strv_remove_prefix(m->environment, "container_");
288
289 /* Remove variables from the inherited set that are part of
290 * the initrd interface:
291 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
292 strv_remove_prefix(m->environment, "RD_");
293
294 /* Drop invalid entries */
295 strv_env_clean(m->environment);
296 }
297
298 int manager_new(SystemdRunningAs running_as, Manager **_m) {
299 Manager *m;
300 int r = -ENOMEM;
301
302 assert(_m);
303 assert(running_as >= 0);
304 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
305
306 m = new0(Manager, 1);
307 if (!m)
308 return -ENOMEM;
309
310 dual_timestamp_get(&m->userspace_timestamp);
311 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
312 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
313
314 m->running_as = running_as;
315 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
316 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
317 m->pin_cgroupfs_fd = -1;
318 m->idle_pipe[0] = m->idle_pipe[1] = -1;
319
320 watch_init(&m->signal_watch);
321 watch_init(&m->mount_watch);
322 watch_init(&m->swap_watch);
323 watch_init(&m->udev_watch);
324 watch_init(&m->time_change_watch);
325
326 m->epoll_fd = m->dev_autofs_fd = -1;
327 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
328
329 m->environment = strv_copy(environ);
330 if (!m->environment)
331 goto fail;
332
333 manager_strip_environment(m);
334
335 if (running_as == SYSTEMD_SYSTEM) {
336 m->default_controllers = strv_new("cpu", NULL);
337 if (!m->default_controllers)
338 goto fail;
339 }
340
341 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
342 goto fail;
343
344 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
345 goto fail;
346
347 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
348 goto fail;
349
350 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
351 goto fail;
352
353 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
354 goto fail;
355
356 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
357 if (m->epoll_fd < 0)
358 goto fail;
359
360 r = manager_setup_signals(m);
361 if (r < 0)
362 goto fail;
363
364 r = manager_setup_cgroup(m);
365 if (r < 0)
366 goto fail;
367
368 r = manager_setup_notify(m);
369 if (r < 0)
370 goto fail;
371
372 r = manager_setup_time_change(m);
373 if (r < 0)
374 goto fail;
375
376 /* Try to connect to the busses, if possible. */
377 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
378 if (r < 0)
379 goto fail;
380
381 m->taint_usr = dir_is_empty("/usr") > 0;
382
383 *_m = m;
384 return 0;
385
386 fail:
387 manager_free(m);
388 return r;
389 }
390
391 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
392 Unit *u;
393 unsigned n = 0;
394
395 assert(m);
396
397 while ((u = m->cleanup_queue)) {
398 assert(u->in_cleanup_queue);
399
400 unit_free(u);
401 n++;
402 }
403
404 return n;
405 }
406
407 enum {
408 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
409 GC_OFFSET_UNSURE, /* No clue */
410 GC_OFFSET_GOOD, /* We still need this unit */
411 GC_OFFSET_BAD, /* We don't need this unit anymore */
412 _GC_OFFSET_MAX
413 };
414
415 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
416 Iterator i;
417 Unit *other;
418 bool is_bad;
419
420 assert(u);
421
422 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
423 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
424 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
425 return;
426
427 if (u->in_cleanup_queue)
428 goto bad;
429
430 if (unit_check_gc(u))
431 goto good;
432
433 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
434
435 is_bad = true;
436
437 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
438 unit_gc_sweep(other, gc_marker);
439
440 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
441 goto good;
442
443 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
444 is_bad = false;
445 }
446
447 if (is_bad)
448 goto bad;
449
450 /* We were unable to find anything out about this entry, so
451 * let's investigate it later */
452 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
453 unit_add_to_gc_queue(u);
454 return;
455
456 bad:
457 /* We definitely know that this one is not useful anymore, so
458 * let's mark it for deletion */
459 u->gc_marker = gc_marker + GC_OFFSET_BAD;
460 unit_add_to_cleanup_queue(u);
461 return;
462
463 good:
464 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
465 }
466
467 static unsigned manager_dispatch_gc_queue(Manager *m) {
468 Unit *u;
469 unsigned n = 0;
470 unsigned gc_marker;
471
472 assert(m);
473
474 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
475 (m->gc_queue_timestamp <= 0 ||
476 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
477 return 0;
478
479 log_debug("Running GC...");
480
481 m->gc_marker += _GC_OFFSET_MAX;
482 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
483 m->gc_marker = 1;
484
485 gc_marker = m->gc_marker;
486
487 while ((u = m->gc_queue)) {
488 assert(u->in_gc_queue);
489
490 unit_gc_sweep(u, gc_marker);
491
492 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
493 u->in_gc_queue = false;
494
495 n++;
496
497 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
498 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
499 log_debug_unit(u->id, "Collecting %s", u->id);
500 u->gc_marker = gc_marker + GC_OFFSET_BAD;
501 unit_add_to_cleanup_queue(u);
502 }
503 }
504
505 m->n_in_gc_queue = 0;
506 m->gc_queue_timestamp = 0;
507
508 return n;
509 }
510
511 static void manager_clear_jobs_and_units(Manager *m) {
512 Unit *u;
513
514 assert(m);
515
516 while ((u = hashmap_first(m->units)))
517 unit_free(u);
518
519 manager_dispatch_cleanup_queue(m);
520
521 assert(!m->load_queue);
522 assert(!m->run_queue);
523 assert(!m->dbus_unit_queue);
524 assert(!m->dbus_job_queue);
525 assert(!m->cleanup_queue);
526 assert(!m->gc_queue);
527
528 assert(hashmap_isempty(m->jobs));
529 assert(hashmap_isempty(m->units));
530 }
531
532 void manager_free(Manager *m) {
533 UnitType c;
534 int i;
535
536 assert(m);
537
538 manager_clear_jobs_and_units(m);
539
540 for (c = 0; c < _UNIT_TYPE_MAX; c++)
541 if (unit_vtable[c]->shutdown)
542 unit_vtable[c]->shutdown(m);
543
544 /* If we reexecute ourselves, we keep the root cgroup
545 * around */
546 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
547
548 manager_undo_generators(m);
549
550 bus_done(m);
551
552 hashmap_free(m->units);
553 hashmap_free(m->jobs);
554 hashmap_free(m->watch_pids);
555 hashmap_free(m->watch_bus);
556
557 if (m->epoll_fd >= 0)
558 close_nointr_nofail(m->epoll_fd);
559 if (m->signal_watch.fd >= 0)
560 close_nointr_nofail(m->signal_watch.fd);
561 if (m->notify_watch.fd >= 0)
562 close_nointr_nofail(m->notify_watch.fd);
563 if (m->time_change_watch.fd >= 0)
564 close_nointr_nofail(m->time_change_watch.fd);
565
566 free(m->notify_socket);
567
568 lookup_paths_free(&m->lookup_paths);
569 strv_free(m->environment);
570
571 strv_free(m->default_controllers);
572
573 hashmap_free(m->cgroup_bondings);
574 set_free_free(m->unit_path_cache);
575
576 close_pipe(m->idle_pipe);
577
578 free(m->switch_root);
579 free(m->switch_root_init);
580
581 for (i = 0; i < RLIMIT_NLIMITS; i++)
582 free(m->rlimit[i]);
583
584 free(m);
585 }
586
587 int manager_enumerate(Manager *m) {
588 int r = 0, q;
589 UnitType c;
590
591 assert(m);
592
593 /* Let's ask every type to load all units from disk/kernel
594 * that it might know */
595 for (c = 0; c < _UNIT_TYPE_MAX; c++)
596 if (unit_vtable[c]->enumerate)
597 if ((q = unit_vtable[c]->enumerate(m)) < 0)
598 r = q;
599
600 manager_dispatch_load_queue(m);
601 return r;
602 }
603
604 int manager_coldplug(Manager *m) {
605 int r = 0, q;
606 Iterator i;
607 Unit *u;
608 char *k;
609
610 assert(m);
611
612 /* Then, let's set up their initial state. */
613 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
614
615 /* ignore aliases */
616 if (u->id != k)
617 continue;
618
619 if ((q = unit_coldplug(u)) < 0)
620 r = q;
621 }
622
623 return r;
624 }
625
626 static void manager_build_unit_path_cache(Manager *m) {
627 char **i;
628 DIR _cleanup_free_ *d = NULL;
629 int r;
630
631 assert(m);
632
633 set_free_free(m->unit_path_cache);
634
635 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
636 if (!m->unit_path_cache) {
637 log_error("Failed to allocate unit path cache.");
638 return;
639 }
640
641 /* This simply builds a list of files we know exist, so that
642 * we don't always have to go to disk */
643
644 STRV_FOREACH(i, m->lookup_paths.unit_path) {
645 struct dirent *de;
646
647 d = opendir(*i);
648 if (!d) {
649 if (errno != ENOENT)
650 log_error("Failed to open directory %s: %m", *i);
651 continue;
652 }
653
654 while ((de = readdir(d))) {
655 char *p;
656
657 if (ignore_file(de->d_name))
658 continue;
659
660 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
661 if (!p) {
662 r = -ENOMEM;
663 goto fail;
664 }
665
666 r = set_put(m->unit_path_cache, p);
667 if (r < 0) {
668 free(p);
669 goto fail;
670 }
671 }
672
673 closedir(d);
674 d = NULL;
675 }
676
677 return;
678
679 fail:
680 log_error("Failed to build unit path cache: %s", strerror(-r));
681
682 set_free_free(m->unit_path_cache);
683 m->unit_path_cache = NULL;
684 }
685
686 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
687 int r, q;
688
689 assert(m);
690
691 manager_run_generators(m);
692
693 r = lookup_paths_init(
694 &m->lookup_paths, m->running_as, true,
695 m->generator_unit_path,
696 m->generator_unit_path_early,
697 m->generator_unit_path_late);
698 if (r < 0)
699 return r;
700
701 manager_build_unit_path_cache(m);
702
703 /* If we will deserialize make sure that during enumeration
704 * this is already known, so we increase the counter here
705 * already */
706 if (serialization)
707 m->n_reloading ++;
708
709 /* First, enumerate what we can from all config files */
710 r = manager_enumerate(m);
711
712 /* Second, deserialize if there is something to deserialize */
713 if (serialization) {
714 q = manager_deserialize(m, serialization, fds);
715 if (q < 0)
716 r = q;
717 }
718
719 /* Any fds left? Find some unit which wants them. This is
720 * useful to allow container managers to pass some file
721 * descriptors to us pre-initialized. This enables
722 * socket-based activation of entire containers. */
723 if (fdset_size(fds) > 0) {
724 q = manager_distribute_fds(m, fds);
725 if (q < 0)
726 r = q;
727 }
728
729 /* Third, fire things up! */
730 q = manager_coldplug(m);
731 if (q < 0)
732 r = q;
733
734 if (serialization) {
735 assert(m->n_reloading > 0);
736 m->n_reloading --;
737 }
738
739 return r;
740 }
741
742 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
743 int r;
744 Transaction *tr;
745
746 assert(m);
747 assert(type < _JOB_TYPE_MAX);
748 assert(unit);
749 assert(mode < _JOB_MODE_MAX);
750
751 if (mode == JOB_ISOLATE && type != JOB_START) {
752 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
753 return -EINVAL;
754 }
755
756 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
757 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
758 return -EPERM;
759 }
760
761 log_debug_unit(unit->id,
762 "Trying to enqueue job %s/%s/%s", unit->id,
763 job_type_to_string(type), job_mode_to_string(mode));
764
765 job_type_collapse(&type, unit);
766
767 tr = transaction_new();
768 if (!tr)
769 return -ENOMEM;
770
771 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
772 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
773 mode == JOB_IGNORE_DEPENDENCIES, e);
774 if (r < 0)
775 goto tr_abort;
776
777 if (mode == JOB_ISOLATE) {
778 r = transaction_add_isolate_jobs(tr, m);
779 if (r < 0)
780 goto tr_abort;
781 }
782
783 r = transaction_activate(tr, m, mode, e);
784 if (r < 0)
785 goto tr_abort;
786
787 log_debug_unit(unit->id,
788 "Enqueued job %s/%s as %u", unit->id,
789 job_type_to_string(type), (unsigned) tr->anchor_job->id);
790
791 if (_ret)
792 *_ret = tr->anchor_job;
793
794 transaction_free(tr);
795 return 0;
796
797 tr_abort:
798 transaction_abort(tr);
799 transaction_free(tr);
800 return r;
801 }
802
803 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
804 Unit *unit;
805 int r;
806
807 assert(m);
808 assert(type < _JOB_TYPE_MAX);
809 assert(name);
810 assert(mode < _JOB_MODE_MAX);
811
812 r = manager_load_unit(m, name, NULL, NULL, &unit);
813 if (r < 0)
814 return r;
815
816 return manager_add_job(m, type, unit, mode, override, e, _ret);
817 }
818
819 Job *manager_get_job(Manager *m, uint32_t id) {
820 assert(m);
821
822 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
823 }
824
825 Unit *manager_get_unit(Manager *m, const char *name) {
826 assert(m);
827 assert(name);
828
829 return hashmap_get(m->units, name);
830 }
831
832 unsigned manager_dispatch_load_queue(Manager *m) {
833 Unit *u;
834 unsigned n = 0;
835
836 assert(m);
837
838 /* Make sure we are not run recursively */
839 if (m->dispatching_load_queue)
840 return 0;
841
842 m->dispatching_load_queue = true;
843
844 /* Dispatches the load queue. Takes a unit from the queue and
845 * tries to load its data until the queue is empty */
846
847 while ((u = m->load_queue)) {
848 assert(u->in_load_queue);
849
850 unit_load(u);
851 n++;
852 }
853
854 m->dispatching_load_queue = false;
855 return n;
856 }
857
858 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
859 Unit *ret;
860 UnitType t;
861 int r;
862
863 assert(m);
864 assert(name || path);
865
866 /* This will prepare the unit for loading, but not actually
867 * load anything from disk. */
868
869 if (path && !is_path(path)) {
870 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
871 return -EINVAL;
872 }
873
874 if (!name)
875 name = path_get_file_name(path);
876
877 t = unit_name_to_type(name);
878
879 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
880 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
881 return -EINVAL;
882 }
883
884 ret = manager_get_unit(m, name);
885 if (ret) {
886 *_ret = ret;
887 return 1;
888 }
889
890 ret = unit_new(m, unit_vtable[t]->object_size);
891 if (!ret)
892 return -ENOMEM;
893
894 if (path) {
895 ret->fragment_path = strdup(path);
896 if (!ret->fragment_path) {
897 unit_free(ret);
898 return -ENOMEM;
899 }
900 }
901
902 if ((r = unit_add_name(ret, name)) < 0) {
903 unit_free(ret);
904 return r;
905 }
906
907 unit_add_to_load_queue(ret);
908 unit_add_to_dbus_queue(ret);
909 unit_add_to_gc_queue(ret);
910
911 if (_ret)
912 *_ret = ret;
913
914 return 0;
915 }
916
917 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
918 int r;
919
920 assert(m);
921
922 /* This will load the service information files, but not actually
923 * start any services or anything. */
924
925 r = manager_load_unit_prepare(m, name, path, e, _ret);
926 if (r != 0)
927 return r;
928
929 manager_dispatch_load_queue(m);
930
931 if (_ret)
932 *_ret = unit_follow_merge(*_ret);
933
934 return 0;
935 }
936
937 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
938 Iterator i;
939 Job *j;
940
941 assert(s);
942 assert(f);
943
944 HASHMAP_FOREACH(j, s->jobs, i)
945 job_dump(j, f, prefix);
946 }
947
948 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
949 Iterator i;
950 Unit *u;
951 const char *t;
952
953 assert(s);
954 assert(f);
955
956 HASHMAP_FOREACH_KEY(u, t, s->units, i)
957 if (u->id == t)
958 unit_dump(u, f, prefix);
959 }
960
961 void manager_clear_jobs(Manager *m) {
962 Job *j;
963
964 assert(m);
965
966 while ((j = hashmap_first(m->jobs)))
967 /* No need to recurse. We're cancelling all jobs. */
968 job_finish_and_invalidate(j, JOB_CANCELED, false);
969 }
970
971 unsigned manager_dispatch_run_queue(Manager *m) {
972 Job *j;
973 unsigned n = 0;
974
975 if (m->dispatching_run_queue)
976 return 0;
977
978 m->dispatching_run_queue = true;
979
980 while ((j = m->run_queue)) {
981 assert(j->installed);
982 assert(j->in_run_queue);
983
984 job_run_and_invalidate(j);
985 n++;
986 }
987
988 m->dispatching_run_queue = false;
989 return n;
990 }
991
992 unsigned manager_dispatch_dbus_queue(Manager *m) {
993 Job *j;
994 Unit *u;
995 unsigned n = 0;
996
997 assert(m);
998
999 if (m->dispatching_dbus_queue)
1000 return 0;
1001
1002 m->dispatching_dbus_queue = true;
1003
1004 while ((u = m->dbus_unit_queue)) {
1005 assert(u->in_dbus_queue);
1006
1007 bus_unit_send_change_signal(u);
1008 n++;
1009 }
1010
1011 while ((j = m->dbus_job_queue)) {
1012 assert(j->in_dbus_queue);
1013
1014 bus_job_send_change_signal(j);
1015 n++;
1016 }
1017
1018 m->dispatching_dbus_queue = false;
1019 return n;
1020 }
1021
1022 static int manager_process_notify_fd(Manager *m) {
1023 ssize_t n;
1024
1025 assert(m);
1026
1027 for (;;) {
1028 char buf[4096];
1029 struct msghdr msghdr;
1030 struct iovec iovec;
1031 struct ucred *ucred;
1032 union {
1033 struct cmsghdr cmsghdr;
1034 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1035 } control;
1036 Unit *u;
1037 char **tags;
1038
1039 zero(iovec);
1040 iovec.iov_base = buf;
1041 iovec.iov_len = sizeof(buf)-1;
1042
1043 zero(control);
1044 zero(msghdr);
1045 msghdr.msg_iov = &iovec;
1046 msghdr.msg_iovlen = 1;
1047 msghdr.msg_control = &control;
1048 msghdr.msg_controllen = sizeof(control);
1049
1050 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1051 if (n <= 0) {
1052 if (n >= 0)
1053 return -EIO;
1054
1055 if (errno == EAGAIN || errno == EINTR)
1056 break;
1057
1058 return -errno;
1059 }
1060
1061 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1062 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1063 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1064 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1065 log_warning("Received notify message without credentials. Ignoring.");
1066 continue;
1067 }
1068
1069 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1070
1071 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1072 if (!u) {
1073 u = cgroup_unit_by_pid(m, ucred->pid);
1074 if (!u) {
1075 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1076 continue;
1077 }
1078 }
1079
1080 assert((size_t) n < sizeof(buf));
1081 buf[n] = 0;
1082 tags = strv_split(buf, "\n\r");
1083 if (!tags)
1084 return log_oom();
1085
1086 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1087
1088 if (UNIT_VTABLE(u)->notify_message)
1089 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1090
1091 strv_free(tags);
1092 }
1093
1094 return 0;
1095 }
1096
1097 static int manager_dispatch_sigchld(Manager *m) {
1098 assert(m);
1099
1100 for (;;) {
1101 siginfo_t si;
1102 Unit *u;
1103 int r;
1104
1105 zero(si);
1106
1107 /* First we call waitd() for a PID and do not reap the
1108 * zombie. That way we can still access /proc/$PID for
1109 * it while it is a zombie. */
1110 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1111
1112 if (errno == ECHILD)
1113 break;
1114
1115 if (errno == EINTR)
1116 continue;
1117
1118 return -errno;
1119 }
1120
1121 if (si.si_pid <= 0)
1122 break;
1123
1124 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1125 char _cleanup_free_ *name = NULL;
1126
1127 get_process_comm(si.si_pid, &name);
1128 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1129 }
1130
1131 /* Let's flush any message the dying child might still
1132 * have queued for us. This ensures that the process
1133 * still exists in /proc so that we can figure out
1134 * which cgroup and hence unit it belongs to. */
1135 r = manager_process_notify_fd(m);
1136 if (r < 0)
1137 return r;
1138
1139 /* And now figure out the unit this belongs to */
1140 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1141 if (!u)
1142 u = cgroup_unit_by_pid(m, si.si_pid);
1143
1144 /* And now, we actually reap the zombie. */
1145 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1146 if (errno == EINTR)
1147 continue;
1148
1149 return -errno;
1150 }
1151
1152 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1153 continue;
1154
1155 log_debug("Child %lu died (code=%s, status=%i/%s)",
1156 (long unsigned) si.si_pid,
1157 sigchld_code_to_string(si.si_code),
1158 si.si_status,
1159 strna(si.si_code == CLD_EXITED
1160 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1161 : signal_to_string(si.si_status)));
1162
1163 if (!u)
1164 continue;
1165
1166 log_debug_unit(u->id,
1167 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1168
1169 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1170 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1171 }
1172
1173 return 0;
1174 }
1175
1176 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1177 int r;
1178 DBusError error;
1179
1180 dbus_error_init(&error);
1181
1182 log_debug_unit(name, "Activating special unit %s", name);
1183
1184 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1185 if (r < 0)
1186 log_error_unit(name,
1187 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1188
1189 dbus_error_free(&error);
1190
1191 return r;
1192 }
1193
1194 static int manager_process_signal_fd(Manager *m) {
1195 ssize_t n;
1196 struct signalfd_siginfo sfsi;
1197 bool sigchld = false;
1198
1199 assert(m);
1200
1201 for (;;) {
1202 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1203 if (n != sizeof(sfsi)) {
1204
1205 if (n >= 0)
1206 return -EIO;
1207
1208 if (errno == EINTR || errno == EAGAIN)
1209 break;
1210
1211 return -errno;
1212 }
1213
1214 if (sfsi.ssi_pid > 0) {
1215 char *p = NULL;
1216
1217 get_process_comm(sfsi.ssi_pid, &p);
1218
1219 log_debug("Received SIG%s from PID %lu (%s).",
1220 signal_to_string(sfsi.ssi_signo),
1221 (unsigned long) sfsi.ssi_pid, strna(p));
1222 free(p);
1223 } else
1224 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1225
1226 switch (sfsi.ssi_signo) {
1227
1228 case SIGCHLD:
1229 sigchld = true;
1230 break;
1231
1232 case SIGTERM:
1233 if (m->running_as == SYSTEMD_SYSTEM) {
1234 /* This is for compatibility with the
1235 * original sysvinit */
1236 m->exit_code = MANAGER_REEXECUTE;
1237 break;
1238 }
1239
1240 /* Fall through */
1241
1242 case SIGINT:
1243 if (m->running_as == SYSTEMD_SYSTEM) {
1244 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1245 break;
1246 }
1247
1248 /* Run the exit target if there is one, if not, just exit. */
1249 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1250 m->exit_code = MANAGER_EXIT;
1251 return 0;
1252 }
1253
1254 break;
1255
1256 case SIGWINCH:
1257 if (m->running_as == SYSTEMD_SYSTEM)
1258 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1259
1260 /* This is a nop on non-init */
1261 break;
1262
1263 case SIGPWR:
1264 if (m->running_as == SYSTEMD_SYSTEM)
1265 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1266
1267 /* This is a nop on non-init */
1268 break;
1269
1270 case SIGUSR1: {
1271 Unit *u;
1272
1273 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1274
1275 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1276 log_info("Trying to reconnect to bus...");
1277 bus_init(m, true);
1278 }
1279
1280 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1281 log_info("Loading D-Bus service...");
1282 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1283 }
1284
1285 break;
1286 }
1287
1288 case SIGUSR2: {
1289 FILE *f;
1290 char *dump = NULL;
1291 size_t size;
1292
1293 if (!(f = open_memstream(&dump, &size))) {
1294 log_warning("Failed to allocate memory stream.");
1295 break;
1296 }
1297
1298 manager_dump_units(m, f, "\t");
1299 manager_dump_jobs(m, f, "\t");
1300
1301 if (ferror(f)) {
1302 fclose(f);
1303 free(dump);
1304 log_warning("Failed to write status stream");
1305 break;
1306 }
1307
1308 fclose(f);
1309 log_dump(LOG_INFO, dump);
1310 free(dump);
1311
1312 break;
1313 }
1314
1315 case SIGHUP:
1316 m->exit_code = MANAGER_RELOAD;
1317 break;
1318
1319 default: {
1320
1321 /* Starting SIGRTMIN+0 */
1322 static const char * const target_table[] = {
1323 [0] = SPECIAL_DEFAULT_TARGET,
1324 [1] = SPECIAL_RESCUE_TARGET,
1325 [2] = SPECIAL_EMERGENCY_TARGET,
1326 [3] = SPECIAL_HALT_TARGET,
1327 [4] = SPECIAL_POWEROFF_TARGET,
1328 [5] = SPECIAL_REBOOT_TARGET,
1329 [6] = SPECIAL_KEXEC_TARGET
1330 };
1331
1332 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1333 static const ManagerExitCode code_table[] = {
1334 [0] = MANAGER_HALT,
1335 [1] = MANAGER_POWEROFF,
1336 [2] = MANAGER_REBOOT,
1337 [3] = MANAGER_KEXEC
1338 };
1339
1340 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1341 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1342 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1343 manager_start_target(m, target_table[idx],
1344 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1345 break;
1346 }
1347
1348 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1349 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1350 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1351 break;
1352 }
1353
1354 switch (sfsi.ssi_signo - SIGRTMIN) {
1355
1356 case 20:
1357 log_debug("Enabling showing of status.");
1358 manager_set_show_status(m, true);
1359 break;
1360
1361 case 21:
1362 log_debug("Disabling showing of status.");
1363 manager_set_show_status(m, false);
1364 break;
1365
1366 case 22:
1367 log_set_max_level(LOG_DEBUG);
1368 log_notice("Setting log level to debug.");
1369 break;
1370
1371 case 23:
1372 log_set_max_level(LOG_INFO);
1373 log_notice("Setting log level to info.");
1374 break;
1375
1376 case 24:
1377 if (m->running_as == SYSTEMD_USER) {
1378 m->exit_code = MANAGER_EXIT;
1379 return 0;
1380 }
1381
1382 /* This is a nop on init */
1383 break;
1384
1385 case 26:
1386 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1387 log_notice("Setting log target to journal-or-kmsg.");
1388 break;
1389
1390 case 27:
1391 log_set_target(LOG_TARGET_CONSOLE);
1392 log_notice("Setting log target to console.");
1393 break;
1394
1395 case 28:
1396 log_set_target(LOG_TARGET_KMSG);
1397 log_notice("Setting log target to kmsg.");
1398 break;
1399
1400 case 29:
1401 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1402 log_notice("Setting log target to syslog-or-kmsg.");
1403 break;
1404
1405 default:
1406 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1407 }
1408 }
1409 }
1410 }
1411
1412 if (sigchld)
1413 return manager_dispatch_sigchld(m);
1414
1415 return 0;
1416 }
1417
1418 static int process_event(Manager *m, struct epoll_event *ev) {
1419 int r;
1420 Watch *w;
1421
1422 assert(m);
1423 assert(ev);
1424
1425 assert_se(w = ev->data.ptr);
1426
1427 if (w->type == WATCH_INVALID)
1428 return 0;
1429
1430 switch (w->type) {
1431
1432 case WATCH_SIGNAL:
1433
1434 /* An incoming signal? */
1435 if (ev->events != EPOLLIN)
1436 return -EINVAL;
1437
1438 if ((r = manager_process_signal_fd(m)) < 0)
1439 return r;
1440
1441 break;
1442
1443 case WATCH_NOTIFY:
1444
1445 /* An incoming daemon notification event? */
1446 if (ev->events != EPOLLIN)
1447 return -EINVAL;
1448
1449 if ((r = manager_process_notify_fd(m)) < 0)
1450 return r;
1451
1452 break;
1453
1454 case WATCH_FD:
1455
1456 /* Some fd event, to be dispatched to the units */
1457 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1458 break;
1459
1460 case WATCH_UNIT_TIMER:
1461 case WATCH_JOB_TIMER: {
1462 uint64_t v;
1463 ssize_t k;
1464
1465 /* Some timer event, to be dispatched to the units */
1466 k = read(w->fd, &v, sizeof(v));
1467 if (k != sizeof(v)) {
1468
1469 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1470 break;
1471
1472 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1473 return k < 0 ? -errno : -EIO;
1474 }
1475
1476 if (w->type == WATCH_UNIT_TIMER)
1477 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1478 else
1479 job_timer_event(w->data.job, v, w);
1480 break;
1481 }
1482
1483 case WATCH_MOUNT:
1484 /* Some mount table change, intended for the mount subsystem */
1485 mount_fd_event(m, ev->events);
1486 break;
1487
1488 case WATCH_SWAP:
1489 /* Some swap table change, intended for the swap subsystem */
1490 swap_fd_event(m, ev->events);
1491 break;
1492
1493 case WATCH_UDEV:
1494 /* Some notification from udev, intended for the device subsystem */
1495 device_fd_event(m, ev->events);
1496 break;
1497
1498 case WATCH_DBUS_WATCH:
1499 bus_watch_event(m, w, ev->events);
1500 break;
1501
1502 case WATCH_DBUS_TIMEOUT:
1503 bus_timeout_event(m, w, ev->events);
1504 break;
1505
1506 case WATCH_TIME_CHANGE: {
1507 Unit *u;
1508 Iterator i;
1509
1510 log_struct(LOG_INFO,
1511 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1512 "MESSAGE=Time has been changed",
1513 NULL);
1514
1515 /* Restart the watch */
1516 close_nointr_nofail(m->time_change_watch.fd);
1517 watch_init(&m->time_change_watch);
1518 manager_setup_time_change(m);
1519
1520 HASHMAP_FOREACH(u, m->units, i) {
1521 if (UNIT_VTABLE(u)->time_change)
1522 UNIT_VTABLE(u)->time_change(u);
1523 }
1524
1525 break;
1526 }
1527
1528 default:
1529 log_error("event type=%i", w->type);
1530 assert_not_reached("Unknown epoll event type.");
1531 }
1532
1533 return 0;
1534 }
1535
1536 int manager_loop(Manager *m) {
1537 int r;
1538
1539 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1540
1541 assert(m);
1542 m->exit_code = MANAGER_RUNNING;
1543
1544 /* Release the path cache */
1545 set_free_free(m->unit_path_cache);
1546 m->unit_path_cache = NULL;
1547
1548 manager_check_finished(m);
1549
1550 /* There might still be some zombies hanging around from
1551 * before we were exec()'ed. Leat's reap them */
1552 r = manager_dispatch_sigchld(m);
1553 if (r < 0)
1554 return r;
1555
1556 while (m->exit_code == MANAGER_RUNNING) {
1557 struct epoll_event event;
1558 int n;
1559 int wait_msec = -1;
1560
1561 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1562 watchdog_ping();
1563
1564 if (!ratelimit_test(&rl)) {
1565 /* Yay, something is going seriously wrong, pause a little */
1566 log_warning("Looping too fast. Throttling execution a little.");
1567 sleep(1);
1568 continue;
1569 }
1570
1571 if (manager_dispatch_load_queue(m) > 0)
1572 continue;
1573
1574 if (manager_dispatch_run_queue(m) > 0)
1575 continue;
1576
1577 if (bus_dispatch(m) > 0)
1578 continue;
1579
1580 if (manager_dispatch_cleanup_queue(m) > 0)
1581 continue;
1582
1583 if (manager_dispatch_gc_queue(m) > 0)
1584 continue;
1585
1586 if (manager_dispatch_dbus_queue(m) > 0)
1587 continue;
1588
1589 if (swap_dispatch_reload(m) > 0)
1590 continue;
1591
1592 /* Sleep for half the watchdog time */
1593 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1594 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1595 if (wait_msec <= 0)
1596 wait_msec = 1;
1597 } else
1598 wait_msec = -1;
1599
1600 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1601 if (n < 0) {
1602
1603 if (errno == EINTR)
1604 continue;
1605
1606 return -errno;
1607 } else if (n == 0)
1608 continue;
1609
1610 assert(n == 1);
1611
1612 r = process_event(m, &event);
1613 if (r < 0)
1614 return r;
1615 }
1616
1617 return m->exit_code;
1618 }
1619
1620 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1621 char *n;
1622 Unit *u;
1623 int r;
1624
1625 assert(m);
1626 assert(s);
1627 assert(_u);
1628
1629 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1630 return -EINVAL;
1631
1632 n = bus_path_unescape(s+31);
1633 if (!n)
1634 return -ENOMEM;
1635
1636 r = manager_load_unit(m, n, NULL, e, &u);
1637 free(n);
1638
1639 if (r < 0)
1640 return r;
1641
1642 *_u = u;
1643
1644 return 0;
1645 }
1646
1647 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1648 Job *j;
1649 unsigned id;
1650 int r;
1651
1652 assert(m);
1653 assert(s);
1654 assert(_j);
1655
1656 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1657 return -EINVAL;
1658
1659 r = safe_atou(s + 30, &id);
1660 if (r < 0)
1661 return r;
1662
1663 j = manager_get_job(m, id);
1664 if (!j)
1665 return -ENOENT;
1666
1667 *_j = j;
1668
1669 return 0;
1670 }
1671
1672 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1673
1674 #ifdef HAVE_AUDIT
1675 char *p;
1676 int audit_fd;
1677
1678 audit_fd = get_audit_fd();
1679 if (audit_fd < 0)
1680 return;
1681
1682 /* Don't generate audit events if the service was already
1683 * started and we're just deserializing */
1684 if (m->n_reloading > 0)
1685 return;
1686
1687 if (m->running_as != SYSTEMD_SYSTEM)
1688 return;
1689
1690 if (u->type != UNIT_SERVICE)
1691 return;
1692
1693 p = unit_name_to_prefix_and_instance(u->id);
1694 if (!p) {
1695 log_error_unit(u->id,
1696 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1697 return;
1698 }
1699
1700 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1701 if (errno == EPERM) {
1702 /* We aren't allowed to send audit messages?
1703 * Then let's not retry again. */
1704 close_audit_fd();
1705 } else
1706 log_warning("Failed to send audit message: %m");
1707 }
1708
1709 free(p);
1710 #endif
1711
1712 }
1713
1714 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1715 int fd = -1;
1716 union sockaddr_union sa;
1717 int n = 0;
1718 char *message = NULL;
1719
1720 /* Don't generate plymouth events if the service was already
1721 * started and we're just deserializing */
1722 if (m->n_reloading > 0)
1723 return;
1724
1725 if (m->running_as != SYSTEMD_SYSTEM)
1726 return;
1727
1728 if (u->type != UNIT_SERVICE &&
1729 u->type != UNIT_MOUNT &&
1730 u->type != UNIT_SWAP)
1731 return;
1732
1733 /* We set SOCK_NONBLOCK here so that we rather drop the
1734 * message then wait for plymouth */
1735 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1736 log_error("socket() failed: %m");
1737 return;
1738 }
1739
1740 zero(sa);
1741 sa.sa.sa_family = AF_UNIX;
1742 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1743 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1744
1745 if (errno != EPIPE &&
1746 errno != EAGAIN &&
1747 errno != ENOENT &&
1748 errno != ECONNREFUSED &&
1749 errno != ECONNRESET &&
1750 errno != ECONNABORTED)
1751 log_error("connect() failed: %m");
1752
1753 goto finish;
1754 }
1755
1756 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1757 log_oom();
1758 goto finish;
1759 }
1760
1761 errno = 0;
1762 if (write(fd, message, n + 1) != n + 1) {
1763
1764 if (errno != EPIPE &&
1765 errno != EAGAIN &&
1766 errno != ENOENT &&
1767 errno != ECONNREFUSED &&
1768 errno != ECONNRESET &&
1769 errno != ECONNABORTED)
1770 log_error("Failed to write Plymouth message: %m");
1771
1772 goto finish;
1773 }
1774
1775 finish:
1776 if (fd >= 0)
1777 close_nointr_nofail(fd);
1778
1779 free(message);
1780 }
1781
1782 void manager_dispatch_bus_name_owner_changed(
1783 Manager *m,
1784 const char *name,
1785 const char* old_owner,
1786 const char *new_owner) {
1787
1788 Unit *u;
1789
1790 assert(m);
1791 assert(name);
1792
1793 if (!(u = hashmap_get(m->watch_bus, name)))
1794 return;
1795
1796 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1797 }
1798
1799 void manager_dispatch_bus_query_pid_done(
1800 Manager *m,
1801 const char *name,
1802 pid_t pid) {
1803
1804 Unit *u;
1805
1806 assert(m);
1807 assert(name);
1808 assert(pid >= 1);
1809
1810 if (!(u = hashmap_get(m->watch_bus, name)))
1811 return;
1812
1813 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1814 }
1815
1816 int manager_open_serialization(Manager *m, FILE **_f) {
1817 char *path = NULL;
1818 mode_t saved_umask;
1819 int fd;
1820 FILE *f;
1821
1822 assert(_f);
1823
1824 if (m->running_as == SYSTEMD_SYSTEM)
1825 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1826 else
1827 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1828
1829 if (!path)
1830 return -ENOMEM;
1831
1832 saved_umask = umask(0077);
1833 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1834 umask(saved_umask);
1835
1836 if (fd < 0) {
1837 free(path);
1838 return -errno;
1839 }
1840
1841 unlink(path);
1842
1843 log_debug("Serializing state to %s", path);
1844 free(path);
1845
1846 f = fdopen(fd, "w+");
1847 if (!f)
1848 return -errno;
1849
1850 *_f = f;
1851
1852 return 0;
1853 }
1854
1855 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1856 Iterator i;
1857 Unit *u;
1858 const char *t;
1859 char **e;
1860 int r;
1861
1862 assert(m);
1863 assert(f);
1864 assert(fds);
1865
1866 m->n_reloading ++;
1867
1868 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1869 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1870 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1871 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1872
1873 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1874 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1875 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1876 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1877
1878 if (!in_initrd()) {
1879 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1880 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1881 }
1882
1883 STRV_FOREACH(e, m->environment) {
1884 _cleanup_free_ char *ce;
1885
1886 ce = cescape(*e);
1887 if (ce)
1888 fprintf(f, "env=%s\n", *e);
1889 }
1890
1891 fputc('\n', f);
1892
1893 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1894 if (u->id != t)
1895 continue;
1896
1897 if (!unit_can_serialize(u))
1898 continue;
1899
1900 /* Start marker */
1901 fputs(u->id, f);
1902 fputc('\n', f);
1903
1904 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1905 m->n_reloading --;
1906 return r;
1907 }
1908 }
1909
1910 assert(m->n_reloading > 0);
1911 m->n_reloading --;
1912
1913 if (ferror(f))
1914 return -EIO;
1915
1916 r = bus_fdset_add_all(m, fds);
1917 if (r < 0)
1918 return r;
1919
1920 return 0;
1921 }
1922
1923 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1924 int r = 0;
1925
1926 assert(m);
1927 assert(f);
1928
1929 log_debug("Deserializing state...");
1930
1931 m->n_reloading ++;
1932
1933 for (;;) {
1934 char line[LINE_MAX], *l;
1935
1936 if (!fgets(line, sizeof(line), f)) {
1937 if (feof(f))
1938 r = 0;
1939 else
1940 r = -errno;
1941
1942 goto finish;
1943 }
1944
1945 char_array_0(line);
1946 l = strstrip(line);
1947
1948 if (l[0] == 0)
1949 break;
1950
1951 if (startswith(l, "current-job-id=")) {
1952 uint32_t id;
1953
1954 if (safe_atou32(l+15, &id) < 0)
1955 log_debug("Failed to parse current job id value %s", l+15);
1956 else
1957 m->current_job_id = MAX(m->current_job_id, id);
1958 } else if (startswith(l, "n-installed-jobs=")) {
1959 uint32_t n;
1960
1961 if (safe_atou32(l+17, &n) < 0)
1962 log_debug("Failed to parse installed jobs counter %s", l+17);
1963 else
1964 m->n_installed_jobs += n;
1965 } else if (startswith(l, "n-failed-jobs=")) {
1966 uint32_t n;
1967
1968 if (safe_atou32(l+14, &n) < 0)
1969 log_debug("Failed to parse failed jobs counter %s", l+14);
1970 else
1971 m->n_failed_jobs += n;
1972 } else if (startswith(l, "taint-usr=")) {
1973 int b;
1974
1975 if ((b = parse_boolean(l+10)) < 0)
1976 log_debug("Failed to parse taint /usr flag %s", l+10);
1977 else
1978 m->taint_usr = m->taint_usr || b;
1979 } else if (startswith(l, "firmware-timestamp="))
1980 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1981 else if (startswith(l, "loader-timestamp="))
1982 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1983 else if (startswith(l, "kernel-timestamp="))
1984 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1985 else if (startswith(l, "initrd-timestamp="))
1986 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1987 else if (startswith(l, "userspace-timestamp="))
1988 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1989 else if (startswith(l, "finish-timestamp="))
1990 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1991 else if (startswith(l, "env=")) {
1992 _cleanup_free_ char *uce = NULL;
1993 char **e;
1994
1995 uce = cunescape(l+4);
1996 if (!uce) {
1997 r = -ENOMEM;
1998 goto finish;
1999 }
2000
2001 e = strv_env_set(m->environment, uce);
2002 if (!e) {
2003 r = -ENOMEM;
2004 goto finish;
2005 }
2006
2007 strv_free(m->environment);
2008 m->environment = e;
2009 } else
2010 log_debug("Unknown serialization item '%s'", l);
2011 }
2012
2013 for (;;) {
2014 Unit *u;
2015 char name[UNIT_NAME_MAX+2];
2016
2017 /* Start marker */
2018 if (!fgets(name, sizeof(name), f)) {
2019 if (feof(f))
2020 r = 0;
2021 else
2022 r = -errno;
2023
2024 goto finish;
2025 }
2026
2027 char_array_0(name);
2028
2029 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2030 if (r < 0)
2031 goto finish;
2032
2033 r = unit_deserialize(u, f, fds);
2034 if (r < 0)
2035 goto finish;
2036 }
2037
2038 finish:
2039 if (ferror(f)) {
2040 r = -EIO;
2041 goto finish;
2042 }
2043
2044 assert(m->n_reloading > 0);
2045 m->n_reloading --;
2046
2047 return r;
2048 }
2049
2050 int manager_distribute_fds(Manager *m, FDSet *fds) {
2051 Unit *u;
2052 Iterator i;
2053 int r;
2054
2055 assert(m);
2056
2057 HASHMAP_FOREACH(u, m->units, i) {
2058
2059 if (fdset_size(fds) <= 0)
2060 break;
2061
2062 if (UNIT_VTABLE(u)->distribute_fds) {
2063 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2064 if (r < 0)
2065 return r;
2066 }
2067 }
2068
2069 return 0;
2070 }
2071
2072 int manager_reload(Manager *m) {
2073 int r, q;
2074 FILE *f;
2075 FDSet *fds;
2076
2077 assert(m);
2078
2079 r = manager_open_serialization(m, &f);
2080 if (r < 0)
2081 return r;
2082
2083 m->n_reloading ++;
2084
2085 fds = fdset_new();
2086 if (!fds) {
2087 m->n_reloading --;
2088 r = -ENOMEM;
2089 goto finish;
2090 }
2091
2092 r = manager_serialize(m, f, fds, true);
2093 if (r < 0) {
2094 m->n_reloading --;
2095 goto finish;
2096 }
2097
2098 if (fseeko(f, 0, SEEK_SET) < 0) {
2099 m->n_reloading --;
2100 r = -errno;
2101 goto finish;
2102 }
2103
2104 /* From here on there is no way back. */
2105 manager_clear_jobs_and_units(m);
2106 manager_undo_generators(m);
2107 lookup_paths_free(&m->lookup_paths);
2108
2109 /* Find new unit paths */
2110 manager_run_generators(m);
2111
2112 q = lookup_paths_init(
2113 &m->lookup_paths, m->running_as, true,
2114 m->generator_unit_path,
2115 m->generator_unit_path_early,
2116 m->generator_unit_path_late);
2117 if (q < 0)
2118 r = q;
2119
2120 manager_build_unit_path_cache(m);
2121
2122 /* First, enumerate what we can from all config files */
2123 q = manager_enumerate(m);
2124 if (q < 0)
2125 r = q;
2126
2127 /* Second, deserialize our stored data */
2128 q = manager_deserialize(m, f, fds);
2129 if (q < 0)
2130 r = q;
2131
2132 fclose(f);
2133 f = NULL;
2134
2135 /* Third, fire things up! */
2136 q = manager_coldplug(m);
2137 if (q < 0)
2138 r = q;
2139
2140 assert(m->n_reloading > 0);
2141 m->n_reloading--;
2142
2143 finish:
2144 if (f)
2145 fclose(f);
2146
2147 if (fds)
2148 fdset_free(fds);
2149
2150 return r;
2151 }
2152
2153 bool manager_is_booting_or_shutting_down(Manager *m) {
2154 Unit *u;
2155
2156 assert(m);
2157
2158 /* Is the initial job still around? */
2159 if (manager_get_job(m, m->default_unit_job_id))
2160 return true;
2161
2162 /* Is there a job for the shutdown target? */
2163 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2164 if (u)
2165 return !!u->job;
2166
2167 return false;
2168 }
2169
2170 void manager_reset_failed(Manager *m) {
2171 Unit *u;
2172 Iterator i;
2173
2174 assert(m);
2175
2176 HASHMAP_FOREACH(u, m->units, i)
2177 unit_reset_failed(u);
2178 }
2179
2180 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2181 Unit *u;
2182
2183 assert(m);
2184 assert(name);
2185
2186 /* Returns true if the unit is inactive or going down */
2187 u = manager_get_unit(m, name);
2188 if (!u)
2189 return true;
2190
2191 return unit_pending_inactive(u);
2192 }
2193
2194 void manager_check_finished(Manager *m) {
2195 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2196 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2197
2198 assert(m);
2199
2200 if (hashmap_size(m->jobs) > 0)
2201 return;
2202
2203 /* Notify Type=idle units that we are done now */
2204 close_pipe(m->idle_pipe);
2205
2206 /* Turn off confirm spawn now */
2207 m->confirm_spawn = false;
2208
2209 if (dual_timestamp_is_set(&m->finish_timestamp))
2210 return;
2211
2212 dual_timestamp_get(&m->finish_timestamp);
2213
2214 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2215
2216 /* Note that m->kernel_usec.monotonic is always at 0,
2217 * and m->firmware_usec.monotonic and
2218 * m->loader_usec.monotonic should be considered
2219 * negative values. */
2220
2221 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2222 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2223 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2224 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2225
2226 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2227
2228 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2229 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2230
2231 if (!log_on_console())
2232 log_struct(LOG_INFO,
2233 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2234 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2235 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2236 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2237 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2238 format_timespan(kernel, sizeof(kernel), kernel_usec),
2239 format_timespan(initrd, sizeof(initrd), initrd_usec),
2240 format_timespan(userspace, sizeof(userspace), userspace_usec),
2241 format_timespan(sum, sizeof(sum), total_usec),
2242 NULL);
2243 } else {
2244 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2245 initrd_usec = 0;
2246
2247 if (!log_on_console())
2248 log_struct(LOG_INFO,
2249 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2250 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2251 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2252 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2253 format_timespan(kernel, sizeof(kernel), kernel_usec),
2254 format_timespan(userspace, sizeof(userspace), userspace_usec),
2255 format_timespan(sum, sizeof(sum), total_usec),
2256 NULL);
2257 }
2258 } else {
2259 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2260 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2261
2262 if (!log_on_console())
2263 log_struct(LOG_INFO,
2264 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2265 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2266 "MESSAGE=Startup finished in %s.",
2267 format_timespan(sum, sizeof(sum), total_usec),
2268 NULL);
2269 }
2270
2271 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2272
2273 sd_notifyf(false,
2274 "READY=1\nSTATUS=Startup finished in %s.",
2275 format_timespan(sum, sizeof(sum), total_usec));
2276 }
2277
2278 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2279 char *p;
2280 int r;
2281
2282 assert(m);
2283 assert(generator);
2284 assert(name);
2285
2286 if (*generator)
2287 return 0;
2288
2289 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2290
2291 p = strappend("/run/systemd/", name);
2292 if (!p)
2293 return log_oom();
2294
2295 r = mkdir_p_label(p, 0755);
2296 if (r < 0) {
2297 log_error("Failed to create generator directory %s: %s",
2298 p, strerror(-r));
2299 free(p);
2300 return r;
2301 }
2302 } else {
2303 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2304 if (!p)
2305 return log_oom();
2306
2307 if (!mkdtemp(p)) {
2308 free(p);
2309 log_error("Failed to create generator directory %s: %m",
2310 p);
2311 return -errno;
2312 }
2313 }
2314
2315 *generator = p;
2316 return 0;
2317 }
2318
2319 static void trim_generator_dir(Manager *m, char **generator) {
2320 assert(m);
2321 assert(generator);
2322
2323 if (!*generator)
2324 return;
2325
2326 if (rmdir(*generator) >= 0) {
2327 free(*generator);
2328 *generator = NULL;
2329 }
2330
2331 return;
2332 }
2333
2334 void manager_run_generators(Manager *m) {
2335 DIR *d = NULL;
2336 const char *generator_path;
2337 const char *argv[5];
2338 mode_t u;
2339 int r;
2340
2341 assert(m);
2342
2343 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2344 d = opendir(generator_path);
2345 if (!d) {
2346 if (errno == ENOENT)
2347 return;
2348
2349 log_error("Failed to enumerate generator directory %s: %m",
2350 generator_path);
2351 return;
2352 }
2353
2354 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2355 if (r < 0)
2356 goto finish;
2357
2358 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2359 if (r < 0)
2360 goto finish;
2361
2362 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2363 if (r < 0)
2364 goto finish;
2365
2366 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2367 argv[1] = m->generator_unit_path;
2368 argv[2] = m->generator_unit_path_early;
2369 argv[3] = m->generator_unit_path_late;
2370 argv[4] = NULL;
2371
2372 u = umask(0022);
2373 execute_directory(generator_path, d, (char**) argv);
2374 umask(u);
2375
2376 trim_generator_dir(m, &m->generator_unit_path);
2377 trim_generator_dir(m, &m->generator_unit_path_early);
2378 trim_generator_dir(m, &m->generator_unit_path_late);
2379
2380 finish:
2381 if (d)
2382 closedir(d);
2383 }
2384
2385 static void remove_generator_dir(Manager *m, char **generator) {
2386 assert(m);
2387 assert(generator);
2388
2389 if (!*generator)
2390 return;
2391
2392 strv_remove(m->lookup_paths.unit_path, *generator);
2393 rm_rf(*generator, false, true, false);
2394
2395 free(*generator);
2396 *generator = NULL;
2397 }
2398
2399 void manager_undo_generators(Manager *m) {
2400 assert(m);
2401
2402 remove_generator_dir(m, &m->generator_unit_path);
2403 remove_generator_dir(m, &m->generator_unit_path_early);
2404 remove_generator_dir(m, &m->generator_unit_path_late);
2405 }
2406
2407 int manager_set_default_controllers(Manager *m, char **controllers) {
2408 char **l;
2409
2410 assert(m);
2411
2412 l = strv_copy(controllers);
2413 if (!l)
2414 return -ENOMEM;
2415
2416 strv_free(m->default_controllers);
2417 m->default_controllers = l;
2418
2419 cg_shorten_controllers(m->default_controllers);
2420
2421 return 0;
2422 }
2423
2424 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2425 int i;
2426
2427 assert(m);
2428
2429 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2430 if (!default_rlimit[i])
2431 continue;
2432
2433 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2434 if (!m->rlimit[i])
2435 return -ENOMEM;
2436 }
2437
2438 return 0;
2439 }
2440
2441 void manager_recheck_journal(Manager *m) {
2442 Unit *u;
2443
2444 assert(m);
2445
2446 if (m->running_as != SYSTEMD_SYSTEM)
2447 return;
2448
2449 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2450 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2451 log_close_journal();
2452 return;
2453 }
2454
2455 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2456 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2457 log_close_journal();
2458 return;
2459 }
2460
2461 /* Hmm, OK, so the socket is fully up and the service is up
2462 * too, then let's make use of the thing. */
2463 log_open();
2464 }
2465
2466 void manager_set_show_status(Manager *m, bool b) {
2467 assert(m);
2468
2469 if (m->running_as != SYSTEMD_SYSTEM)
2470 return;
2471
2472 m->show_status = b;
2473
2474 if (b)
2475 touch("/run/systemd/show-status");
2476 else
2477 unlink("/run/systemd/show-status");
2478 }
2479
2480 bool manager_get_show_status(Manager *m) {
2481 assert(m);
2482
2483 if (m->running_as != SYSTEMD_SYSTEM)
2484 return false;
2485
2486 if (m->show_status)
2487 return true;
2488
2489 /* If Plymouth is running make sure we show the status, so
2490 * that there's something nice to see when people press Esc */
2491
2492 return plymouth_running();
2493 }
2494
2495 void watch_init(Watch *w) {
2496 assert(w);
2497
2498 w->type = WATCH_INVALID;
2499 w->fd = -1;
2500 }
Unnamed repository; edit this file 'description' to name the repository.