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