]> 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
sd-event: rework API to support CLOCK_REALTIME_ALARM and CLOCK_BOOTTIME_ALARM, too
[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 <signal.h>
26 #include <sys/wait.h>
27 #include <unistd.h>
28 #include <sys/poll.h>
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
31 #include <linux/kd.h>
32 #include <termios.h>
33 #include <fcntl.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <dirent.h>
37 #include <sys/timerfd.h>
38
39 #ifdef HAVE_AUDIT
40 #include <libaudit.h>
41 #endif
42
43 #include "sd-daemon.h"
44 #include "sd-id128.h"
45 #include "sd-messages.h"
46
47 #include "manager.h"
48 #include "transaction.h"
49 #include "hashmap.h"
50 #include "macro.h"
51 #include "strv.h"
52 #include "log.h"
53 #include "util.h"
54 #include "mkdir.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
59 #include "missing.h"
60 #include "path-lookup.h"
61 #include "special.h"
62 #include "exit-status.h"
63 #include "virt.h"
64 #include "watchdog.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
67 #include "audit-fd.h"
68 #include "boot-timestamps.h"
69 #include "env-util.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
72 #include "bus-util.h"
73 #include "dbus.h"
74 #include "dbus-unit.h"
75 #include "dbus-job.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
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 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
86
87 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
88
89 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
90 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
92 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
94 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
95
96 static int manager_watch_jobs_in_progress(Manager *m) {
97 usec_t next;
98
99 assert(m);
100
101 if (m->jobs_in_progress_event_source)
102 return 0;
103
104 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
105 return sd_event_add_time(
106 m->event,
107 &m->jobs_in_progress_event_source,
108 CLOCK_MONOTONIC,
109 next, 0,
110 manager_dispatch_jobs_in_progress, m);
111 }
112
113 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
114
115 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
116 char *p = buffer;
117
118 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
119 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
120
121 if (pos > 1) {
122 if (pos > 2)
123 p = mempset(p, ' ', pos-2);
124 p = stpcpy(p, ANSI_RED_ON);
125 *p++ = '*';
126 }
127
128 if (pos > 0 && pos <= width) {
129 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
130 *p++ = '*';
131 }
132
133 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
134
135 if (pos < width) {
136 p = stpcpy(p, ANSI_RED_ON);
137 *p++ = '*';
138 if (pos < width-1)
139 p = mempset(p, ' ', width-1-pos);
140 strcpy(p, ANSI_HIGHLIGHT_OFF);
141 }
142 }
143
144 void manager_flip_auto_status(Manager *m, bool enable) {
145 assert(m);
146
147 if (enable) {
148 if (m->show_status == SHOW_STATUS_AUTO)
149 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
150 } else {
151 if (m->show_status == SHOW_STATUS_TEMPORARY)
152 manager_set_show_status(m, SHOW_STATUS_AUTO);
153 }
154 }
155
156 static void manager_print_jobs_in_progress(Manager *m) {
157 _cleanup_free_ char *job_of_n = NULL;
158 Iterator i;
159 Job *j;
160 unsigned counter = 0, print_nr;
161 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
162 unsigned cylon_pos;
163 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
164 uint64_t x;
165
166 assert(m);
167
168 manager_flip_auto_status(m, true);
169
170 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
171
172 HASHMAP_FOREACH(j, m->jobs, i)
173 if (j->state == JOB_RUNNING && counter++ == print_nr)
174 break;
175
176 /* m->n_running_jobs must be consistent with the contents of m->jobs,
177 * so the above loop must have succeeded in finding j. */
178 assert(counter == print_nr + 1);
179 assert(j);
180
181 cylon_pos = m->jobs_in_progress_iteration % 14;
182 if (cylon_pos >= 8)
183 cylon_pos = 14 - cylon_pos;
184 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
185
186 m->jobs_in_progress_iteration++;
187
188 if (m->n_running_jobs > 1)
189 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
190 job_of_n = NULL;
191
192 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
193 if (job_get_timeout(j, &x) > 0)
194 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
195
196 manager_status_printf(m, true, cylon,
197 "%sA %s job is running for %s (%s / %s)",
198 strempty(job_of_n),
199 job_type_to_string(j->type),
200 unit_description(j->unit),
201 time, limit);
202
203 }
204
205 static int manager_watch_idle_pipe(Manager *m) {
206 int r;
207
208 assert(m);
209
210 if (m->idle_pipe_event_source)
211 return 0;
212
213 if (m->idle_pipe[2] < 0)
214 return 0;
215
216 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
217 if (r < 0) {
218 log_error("Failed to watch idle pipe: %s", strerror(-r));
219 return r;
220 }
221
222 return 0;
223 }
224
225 static void manager_close_idle_pipe(Manager *m) {
226 assert(m);
227
228 close_pipe(m->idle_pipe);
229 close_pipe(m->idle_pipe + 2);
230 }
231
232 static int manager_setup_time_change(Manager *m) {
233 int r;
234
235 /* We only care for the cancellation event, hence we set the
236 * timeout to the latest possible value. */
237 struct itimerspec its = {
238 .it_value.tv_sec = TIME_T_MAX,
239 };
240
241 assert(m);
242 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
243
244 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
245 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
246
247 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
248 if (m->time_change_fd < 0) {
249 log_error("Failed to create timerfd: %m");
250 return -errno;
251 }
252
253 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
254 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
255 m->time_change_fd = safe_close(m->time_change_fd);
256 return 0;
257 }
258
259 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
260 if (r < 0) {
261 log_error("Failed to create time change event source: %s", strerror(-r));
262 return r;
263 }
264
265 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
266
267 return 0;
268 }
269
270 static int enable_special_signals(Manager *m) {
271 _cleanup_close_ int fd = -1;
272
273 assert(m);
274
275 /* Enable that we get SIGINT on control-alt-del. In containers
276 * this will fail with EPERM (older) or EINVAL (newer), so
277 * ignore that. */
278 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
279 log_warning("Failed to enable ctrl-alt-del handling: %m");
280
281 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
282 if (fd < 0) {
283 /* Support systems without virtual console */
284 if (fd != -ENOENT)
285 log_warning("Failed to open /dev/tty0: %m");
286 } else {
287 /* Enable that we get SIGWINCH on kbrequest */
288 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
289 log_warning("Failed to enable kbrequest handling: %m");
290 }
291
292 return 0;
293 }
294
295 static int manager_setup_signals(Manager *m) {
296 struct sigaction sa = {
297 .sa_handler = SIG_DFL,
298 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
299 };
300 sigset_t mask;
301 int r;
302
303 assert(m);
304
305 /* We are not interested in SIGSTOP and friends. */
306 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
307
308 assert_se(sigemptyset(&mask) == 0);
309
310 sigset_add_many(&mask,
311 SIGCHLD, /* Child died */
312 SIGTERM, /* Reexecute daemon */
313 SIGHUP, /* Reload configuration */
314 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
315 SIGUSR2, /* systemd: dump status */
316 SIGINT, /* Kernel sends us this on control-alt-del */
317 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
318 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
319 SIGRTMIN+0, /* systemd: start default.target */
320 SIGRTMIN+1, /* systemd: isolate rescue.target */
321 SIGRTMIN+2, /* systemd: isolate emergency.target */
322 SIGRTMIN+3, /* systemd: start halt.target */
323 SIGRTMIN+4, /* systemd: start poweroff.target */
324 SIGRTMIN+5, /* systemd: start reboot.target */
325 SIGRTMIN+6, /* systemd: start kexec.target */
326 SIGRTMIN+13, /* systemd: Immediate halt */
327 SIGRTMIN+14, /* systemd: Immediate poweroff */
328 SIGRTMIN+15, /* systemd: Immediate reboot */
329 SIGRTMIN+16, /* systemd: Immediate kexec */
330 SIGRTMIN+20, /* systemd: enable status messages */
331 SIGRTMIN+21, /* systemd: disable status messages */
332 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
333 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
334 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
335 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
336 SIGRTMIN+27, /* systemd: set log target to console */
337 SIGRTMIN+28, /* systemd: set log target to kmsg */
338 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
339 -1);
340 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
341
342 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
343 if (m->signal_fd < 0)
344 return -errno;
345
346 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
347 if (r < 0)
348 return r;
349
350 /* Process signals a bit earlier than the rest of things, but
351 * later that notify_fd processing, so that the notify
352 * processing can still figure out to which process/service a
353 * message belongs, before we reap the process. */
354 r = sd_event_source_set_priority(m->signal_event_source, -5);
355 if (r < 0)
356 return r;
357
358 if (m->running_as == SYSTEMD_SYSTEM)
359 return enable_special_signals(m);
360
361 return 0;
362 }
363
364 static void manager_clean_environment(Manager *m) {
365 assert(m);
366
367 /* Let's remove some environment variables that we
368 * need ourselves to communicate with our clients */
369 strv_env_unset_many(
370 m->environment,
371 "NOTIFY_SOCKET",
372 "MAINPID",
373 "MANAGERPID",
374 "LISTEN_PID",
375 "LISTEN_FDS",
376 "WATCHDOG_PID",
377 "WATCHDOG_USEC",
378 NULL);
379 }
380
381 static int manager_default_environment(Manager *m) {
382 assert(m);
383
384 if (m->running_as == SYSTEMD_SYSTEM) {
385 /* The system manager always starts with a clean
386 * environment for its children. It does not import
387 * the kernel or the parents exported variables.
388 *
389 * The initial passed environ is untouched to keep
390 * /proc/self/environ valid; it is used for tagging
391 * the init process inside containers. */
392 m->environment = strv_new("PATH=" DEFAULT_PATH,
393 NULL);
394
395 /* Import locale variables LC_*= from configuration */
396 locale_setup(&m->environment);
397 } else {
398 /* The user manager passes its own environment
399 * along to its children. */
400 m->environment = strv_copy(environ);
401 }
402
403 if (!m->environment)
404 return -ENOMEM;
405
406 manager_clean_environment(m);
407 strv_sort(m->environment);
408
409 return 0;
410 }
411
412 int manager_new(SystemdRunningAs running_as, Manager **_m) {
413 Manager *m;
414 int r;
415
416 assert(_m);
417 assert(running_as >= 0);
418 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
419
420 m = new0(Manager, 1);
421 if (!m)
422 return -ENOMEM;
423
424 #ifdef ENABLE_EFI
425 if (detect_container(NULL) <= 0)
426 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
427 #endif
428
429 m->running_as = running_as;
430 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
431
432 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
433
434 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = -1;
435 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
436
437 r = manager_default_environment(m);
438 if (r < 0)
439 goto fail;
440
441 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
442 if (r < 0)
443 goto fail;
444
445 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
446 if (r < 0)
447 goto fail;
448
449 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
450 if (r < 0)
451 goto fail;
452
453 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
454 if (r < 0)
455 goto fail;
456
457 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
458 if (r < 0)
459 goto fail;
460
461 r = sd_event_default(&m->event);
462 if (r < 0)
463 goto fail;
464
465 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
466 if (r < 0)
467 goto fail;
468
469 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
470 if (r < 0)
471 goto fail;
472
473 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
474 if (r < 0)
475 goto fail;
476
477 r = manager_setup_signals(m);
478 if (r < 0)
479 goto fail;
480
481 r = manager_setup_cgroup(m);
482 if (r < 0)
483 goto fail;
484
485 r = manager_setup_time_change(m);
486 if (r < 0)
487 goto fail;
488
489 m->udev = udev_new();
490 if (!m->udev) {
491 r = -ENOMEM;
492 goto fail;
493 }
494
495 /* Note that we set up neither kdbus, nor the notify fd
496 * here. We do that after deserialization, since they might
497 * have gotten serialized across the reexec. */
498
499 m->taint_usr = dir_is_empty("/usr") > 0;
500
501 *_m = m;
502 return 0;
503
504 fail:
505 manager_free(m);
506 return r;
507 }
508
509 static int manager_setup_notify(Manager *m) {
510 int r;
511
512 if (m->notify_fd < 0) {
513 _cleanup_close_ int fd = -1;
514 union {
515 struct sockaddr sa;
516 struct sockaddr_un un;
517 } sa = {
518 .sa.sa_family = AF_UNIX,
519 };
520 int one = 1;
521
522 /* First free all secondary fields */
523 free(m->notify_socket);
524 m->notify_socket = NULL;
525 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
526
527 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
528 if (fd < 0) {
529 log_error("Failed to allocate notification socket: %m");
530 return -errno;
531 }
532
533 if (m->running_as == SYSTEMD_SYSTEM)
534 m->notify_socket = strdup("/run/systemd/notify");
535 else {
536 const char *e;
537
538 e = getenv("XDG_RUNTIME_DIR");
539 if (!e) {
540 log_error("XDG_RUNTIME_DIR is not set: %m");
541 return -EINVAL;
542 }
543
544 m->notify_socket = strappend(e, "/systemd/notify");
545 }
546 if (!m->notify_socket)
547 return log_oom();
548
549 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
550 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
551 if (r < 0) {
552 log_error("bind() failed: %m");
553 return -errno;
554 }
555
556 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
557 if (r < 0) {
558 log_error("SO_PASSCRED failed: %m");
559 return -errno;
560 }
561
562 m->notify_fd = fd;
563 fd = -1;
564
565 log_debug("Using notification socket %s", m->notify_socket);
566 }
567
568 if (!m->notify_event_source) {
569 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
570 if (r < 0) {
571 log_error("Failed to allocate notify event source: %s", strerror(-r));
572 return -errno;
573 }
574
575 /* Process signals a bit earlier than SIGCHLD, so that we can
576 * still identify to which service an exit message belongs */
577 r = sd_event_source_set_priority(m->notify_event_source, -7);
578 if (r < 0) {
579 log_error("Failed to set priority of notify event source: %s", strerror(-r));
580 return r;
581 }
582 }
583
584 return 0;
585 }
586
587 static int manager_setup_kdbus(Manager *m) {
588 #ifdef ENABLE_KDBUS
589 _cleanup_free_ char *p = NULL;
590 #endif
591
592 #ifdef ENABLE_KDBUS
593 assert(m);
594
595 if (m->kdbus_fd >= 0)
596 return 0;
597
598 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
599 if (m->kdbus_fd < 0) {
600 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
601 return m->kdbus_fd;
602 }
603
604 log_debug("Successfully set up kdbus on %s", p);
605
606 /* Create the namespace directory here, so that the contents
607 * of that directory is not visible to non-root users. This is
608 * necessary to ensure that users cannot get access to busses
609 * of virtualized users when no UID namespacing is used. */
610 if (m->running_as == SYSTEMD_SYSTEM)
611 mkdir_p_label("/dev/kdbus/domain", 0700);
612 #endif
613
614 return 0;
615 }
616
617 static int manager_connect_bus(Manager *m, bool reexecuting) {
618 bool try_bus_connect;
619
620 assert(m);
621
622 try_bus_connect =
623 m->kdbus_fd >= 0 ||
624 reexecuting ||
625 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
626
627 /* Try to connect to the busses, if possible. */
628 return bus_init(m, try_bus_connect);
629 }
630
631 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
632 Unit *u;
633 unsigned n = 0;
634
635 assert(m);
636
637 while ((u = m->cleanup_queue)) {
638 assert(u->in_cleanup_queue);
639
640 unit_free(u);
641 n++;
642 }
643
644 return n;
645 }
646
647 enum {
648 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
649 GC_OFFSET_UNSURE, /* No clue */
650 GC_OFFSET_GOOD, /* We still need this unit */
651 GC_OFFSET_BAD, /* We don't need this unit anymore */
652 _GC_OFFSET_MAX
653 };
654
655 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
656 Iterator i;
657 Unit *other;
658 bool is_bad;
659
660 assert(u);
661
662 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
663 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
664 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
665 return;
666
667 if (u->in_cleanup_queue)
668 goto bad;
669
670 if (unit_check_gc(u))
671 goto good;
672
673 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
674
675 is_bad = true;
676
677 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
678 unit_gc_sweep(other, gc_marker);
679
680 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
681 goto good;
682
683 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
684 is_bad = false;
685 }
686
687 if (is_bad)
688 goto bad;
689
690 /* We were unable to find anything out about this entry, so
691 * let's investigate it later */
692 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
693 unit_add_to_gc_queue(u);
694 return;
695
696 bad:
697 /* We definitely know that this one is not useful anymore, so
698 * let's mark it for deletion */
699 u->gc_marker = gc_marker + GC_OFFSET_BAD;
700 unit_add_to_cleanup_queue(u);
701 return;
702
703 good:
704 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
705 }
706
707 static unsigned manager_dispatch_gc_queue(Manager *m) {
708 Unit *u;
709 unsigned n = 0;
710 unsigned gc_marker;
711
712 assert(m);
713
714 /* log_debug("Running GC..."); */
715
716 m->gc_marker += _GC_OFFSET_MAX;
717 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
718 m->gc_marker = 1;
719
720 gc_marker = m->gc_marker;
721
722 while ((u = m->gc_queue)) {
723 assert(u->in_gc_queue);
724
725 unit_gc_sweep(u, gc_marker);
726
727 LIST_REMOVE(gc_queue, m->gc_queue, u);
728 u->in_gc_queue = false;
729
730 n++;
731
732 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
733 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
734 log_debug_unit(u->id, "Collecting %s", u->id);
735 u->gc_marker = gc_marker + GC_OFFSET_BAD;
736 unit_add_to_cleanup_queue(u);
737 }
738 }
739
740 m->n_in_gc_queue = 0;
741
742 return n;
743 }
744
745 static void manager_clear_jobs_and_units(Manager *m) {
746 Unit *u;
747
748 assert(m);
749
750 while ((u = hashmap_first(m->units)))
751 unit_free(u);
752
753 manager_dispatch_cleanup_queue(m);
754
755 assert(!m->load_queue);
756 assert(!m->run_queue);
757 assert(!m->dbus_unit_queue);
758 assert(!m->dbus_job_queue);
759 assert(!m->cleanup_queue);
760 assert(!m->gc_queue);
761
762 assert(hashmap_isempty(m->jobs));
763 assert(hashmap_isempty(m->units));
764
765 m->n_on_console = 0;
766 m->n_running_jobs = 0;
767 }
768
769 void manager_free(Manager *m) {
770 UnitType c;
771 int i;
772
773 assert(m);
774
775 manager_clear_jobs_and_units(m);
776
777 for (c = 0; c < _UNIT_TYPE_MAX; c++)
778 if (unit_vtable[c]->shutdown)
779 unit_vtable[c]->shutdown(m);
780
781 /* If we reexecute ourselves, we keep the root cgroup
782 * around */
783 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
784
785 manager_undo_generators(m);
786
787 bus_done(m);
788
789 hashmap_free(m->units);
790 hashmap_free(m->jobs);
791 hashmap_free(m->watch_pids1);
792 hashmap_free(m->watch_pids2);
793 hashmap_free(m->watch_bus);
794
795 set_free(m->failed_units);
796
797 sd_event_source_unref(m->signal_event_source);
798 sd_event_source_unref(m->notify_event_source);
799 sd_event_source_unref(m->time_change_event_source);
800 sd_event_source_unref(m->jobs_in_progress_event_source);
801 sd_event_source_unref(m->idle_pipe_event_source);
802 sd_event_source_unref(m->run_queue_event_source);
803
804 safe_close(m->signal_fd);
805 safe_close(m->notify_fd);
806 safe_close(m->time_change_fd);
807 safe_close(m->kdbus_fd);
808
809 manager_close_idle_pipe(m);
810
811 udev_unref(m->udev);
812 sd_event_unref(m->event);
813
814 free(m->notify_socket);
815
816 lookup_paths_free(&m->lookup_paths);
817 strv_free(m->environment);
818
819 hashmap_free(m->cgroup_unit);
820 set_free_free(m->unit_path_cache);
821
822 free(m->switch_root);
823 free(m->switch_root_init);
824
825 for (i = 0; i < _RLIMIT_MAX; i++)
826 free(m->rlimit[i]);
827
828 assert(hashmap_isempty(m->units_requiring_mounts_for));
829 hashmap_free(m->units_requiring_mounts_for);
830
831 free(m);
832 }
833
834 int manager_enumerate(Manager *m) {
835 int r = 0, q;
836 UnitType c;
837
838 assert(m);
839
840 /* Let's ask every type to load all units from disk/kernel
841 * that it might know */
842 for (c = 0; c < _UNIT_TYPE_MAX; c++)
843 if (unit_vtable[c]->enumerate) {
844 q = unit_vtable[c]->enumerate(m);
845 if (q < 0)
846 r = q;
847 }
848
849 manager_dispatch_load_queue(m);
850 return r;
851 }
852
853 static int manager_coldplug(Manager *m) {
854 int r = 0;
855 Iterator i;
856 Unit *u;
857 char *k;
858
859 assert(m);
860
861 /* Then, let's set up their initial state. */
862 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
863 int q;
864
865 /* ignore aliases */
866 if (u->id != k)
867 continue;
868
869 q = unit_coldplug(u);
870 if (q < 0)
871 r = q;
872 }
873
874 return r;
875 }
876
877 static void manager_build_unit_path_cache(Manager *m) {
878 char **i;
879 _cleanup_free_ DIR *d = NULL;
880 int r;
881
882 assert(m);
883
884 set_free_free(m->unit_path_cache);
885
886 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
887 if (!m->unit_path_cache) {
888 log_error("Failed to allocate unit path cache.");
889 return;
890 }
891
892 /* This simply builds a list of files we know exist, so that
893 * we don't always have to go to disk */
894
895 STRV_FOREACH(i, m->lookup_paths.unit_path) {
896 struct dirent *de;
897
898 d = opendir(*i);
899 if (!d) {
900 if (errno != ENOENT)
901 log_error("Failed to open directory %s: %m", *i);
902 continue;
903 }
904
905 while ((de = readdir(d))) {
906 char *p;
907
908 if (ignore_file(de->d_name))
909 continue;
910
911 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
912 if (!p) {
913 r = -ENOMEM;
914 goto fail;
915 }
916
917 r = set_consume(m->unit_path_cache, p);
918 if (r < 0)
919 goto fail;
920 }
921
922 closedir(d);
923 d = NULL;
924 }
925
926 return;
927
928 fail:
929 log_error("Failed to build unit path cache: %s", strerror(-r));
930
931 set_free_free(m->unit_path_cache);
932 m->unit_path_cache = NULL;
933 }
934
935
936 static int manager_distribute_fds(Manager *m, FDSet *fds) {
937 Unit *u;
938 Iterator i;
939 int r;
940
941 assert(m);
942
943 HASHMAP_FOREACH(u, m->units, i) {
944
945 if (fdset_size(fds) <= 0)
946 break;
947
948 if (UNIT_VTABLE(u)->distribute_fds) {
949 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
950 if (r < 0)
951 return r;
952 }
953 }
954
955 return 0;
956 }
957
958 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
959 int r, q;
960
961 assert(m);
962
963 dual_timestamp_get(&m->generators_start_timestamp);
964 manager_run_generators(m);
965 dual_timestamp_get(&m->generators_finish_timestamp);
966
967 r = lookup_paths_init(
968 &m->lookup_paths, m->running_as, true,
969 m->generator_unit_path,
970 m->generator_unit_path_early,
971 m->generator_unit_path_late);
972 if (r < 0)
973 return r;
974
975 manager_build_unit_path_cache(m);
976
977 /* If we will deserialize make sure that during enumeration
978 * this is already known, so we increase the counter here
979 * already */
980 if (serialization)
981 m->n_reloading ++;
982
983 /* First, enumerate what we can from all config files */
984 dual_timestamp_get(&m->units_load_start_timestamp);
985 r = manager_enumerate(m);
986 dual_timestamp_get(&m->units_load_finish_timestamp);
987
988 /* Second, deserialize if there is something to deserialize */
989 if (serialization) {
990 q = manager_deserialize(m, serialization, fds);
991 if (q < 0)
992 r = q;
993 }
994
995 /* Any fds left? Find some unit which wants them. This is
996 * useful to allow container managers to pass some file
997 * descriptors to us pre-initialized. This enables
998 * socket-based activation of entire containers. */
999 if (fdset_size(fds) > 0) {
1000 q = manager_distribute_fds(m, fds);
1001 if (q < 0)
1002 r = q;
1003 }
1004
1005 /* We might have deserialized the notify fd, but if we didn't
1006 * then let's create the bus now */
1007 manager_setup_notify(m);
1008
1009 /* We might have deserialized the kdbus control fd, but if we
1010 * didn't, then let's create the bus now. */
1011 manager_setup_kdbus(m);
1012 manager_connect_bus(m, !!serialization);
1013 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1014
1015 /* Third, fire things up! */
1016 q = manager_coldplug(m);
1017 if (q < 0)
1018 r = q;
1019
1020 if (serialization) {
1021 assert(m->n_reloading > 0);
1022 m->n_reloading --;
1023
1024 /* Let's wait for the UnitNew/JobNew messages being
1025 * sent, before we notify that the reload is
1026 * finished */
1027 m->send_reloading_done = true;
1028 }
1029
1030 return r;
1031 }
1032
1033 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1034 int r;
1035 Transaction *tr;
1036
1037 assert(m);
1038 assert(type < _JOB_TYPE_MAX);
1039 assert(unit);
1040 assert(mode < _JOB_MODE_MAX);
1041
1042 if (mode == JOB_ISOLATE && type != JOB_START) {
1043 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1044 return -EINVAL;
1045 }
1046
1047 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1048 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1049 return -EPERM;
1050 }
1051
1052 log_debug_unit(unit->id,
1053 "Trying to enqueue job %s/%s/%s", unit->id,
1054 job_type_to_string(type), job_mode_to_string(mode));
1055
1056 job_type_collapse(&type, unit);
1057
1058 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1059 if (!tr)
1060 return -ENOMEM;
1061
1062 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1063 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1064 mode == JOB_IGNORE_DEPENDENCIES, e);
1065 if (r < 0)
1066 goto tr_abort;
1067
1068 if (mode == JOB_ISOLATE) {
1069 r = transaction_add_isolate_jobs(tr, m);
1070 if (r < 0)
1071 goto tr_abort;
1072 }
1073
1074 r = transaction_activate(tr, m, mode, e);
1075 if (r < 0)
1076 goto tr_abort;
1077
1078 log_debug_unit(unit->id,
1079 "Enqueued job %s/%s as %u", unit->id,
1080 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1081
1082 if (_ret)
1083 *_ret = tr->anchor_job;
1084
1085 transaction_free(tr);
1086 return 0;
1087
1088 tr_abort:
1089 transaction_abort(tr);
1090 transaction_free(tr);
1091 return r;
1092 }
1093
1094 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1095 Unit *unit;
1096 int r;
1097
1098 assert(m);
1099 assert(type < _JOB_TYPE_MAX);
1100 assert(name);
1101 assert(mode < _JOB_MODE_MAX);
1102
1103 r = manager_load_unit(m, name, NULL, NULL, &unit);
1104 if (r < 0)
1105 return r;
1106
1107 return manager_add_job(m, type, unit, mode, override, e, _ret);
1108 }
1109
1110 Job *manager_get_job(Manager *m, uint32_t id) {
1111 assert(m);
1112
1113 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1114 }
1115
1116 Unit *manager_get_unit(Manager *m, const char *name) {
1117 assert(m);
1118 assert(name);
1119
1120 return hashmap_get(m->units, name);
1121 }
1122
1123 unsigned manager_dispatch_load_queue(Manager *m) {
1124 Unit *u;
1125 unsigned n = 0;
1126
1127 assert(m);
1128
1129 /* Make sure we are not run recursively */
1130 if (m->dispatching_load_queue)
1131 return 0;
1132
1133 m->dispatching_load_queue = true;
1134
1135 /* Dispatches the load queue. Takes a unit from the queue and
1136 * tries to load its data until the queue is empty */
1137
1138 while ((u = m->load_queue)) {
1139 assert(u->in_load_queue);
1140
1141 unit_load(u);
1142 n++;
1143 }
1144
1145 m->dispatching_load_queue = false;
1146 return n;
1147 }
1148
1149 int manager_load_unit_prepare(
1150 Manager *m,
1151 const char *name,
1152 const char *path,
1153 sd_bus_error *e,
1154 Unit **_ret) {
1155
1156 Unit *ret;
1157 UnitType t;
1158 int r;
1159
1160 assert(m);
1161 assert(name || path);
1162
1163 /* This will prepare the unit for loading, but not actually
1164 * load anything from disk. */
1165
1166 if (path && !is_path(path))
1167 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1168
1169 if (!name)
1170 name = basename(path);
1171
1172 t = unit_name_to_type(name);
1173
1174 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1175 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1176
1177 ret = manager_get_unit(m, name);
1178 if (ret) {
1179 *_ret = ret;
1180 return 1;
1181 }
1182
1183 ret = unit_new(m, unit_vtable[t]->object_size);
1184 if (!ret)
1185 return -ENOMEM;
1186
1187 if (path) {
1188 ret->fragment_path = strdup(path);
1189 if (!ret->fragment_path) {
1190 unit_free(ret);
1191 return -ENOMEM;
1192 }
1193 }
1194
1195 r = unit_add_name(ret, name);
1196 if (r < 0) {
1197 unit_free(ret);
1198 return r;
1199 }
1200
1201 unit_add_to_load_queue(ret);
1202 unit_add_to_dbus_queue(ret);
1203 unit_add_to_gc_queue(ret);
1204
1205 if (_ret)
1206 *_ret = ret;
1207
1208 return 0;
1209 }
1210
1211 int manager_load_unit(
1212 Manager *m,
1213 const char *name,
1214 const char *path,
1215 sd_bus_error *e,
1216 Unit **_ret) {
1217
1218 int r;
1219
1220 assert(m);
1221
1222 /* This will load the service information files, but not actually
1223 * start any services or anything. */
1224
1225 r = manager_load_unit_prepare(m, name, path, e, _ret);
1226 if (r != 0)
1227 return r;
1228
1229 manager_dispatch_load_queue(m);
1230
1231 if (_ret)
1232 *_ret = unit_follow_merge(*_ret);
1233
1234 return 0;
1235 }
1236
1237 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1238 Iterator i;
1239 Job *j;
1240
1241 assert(s);
1242 assert(f);
1243
1244 HASHMAP_FOREACH(j, s->jobs, i)
1245 job_dump(j, f, prefix);
1246 }
1247
1248 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1249 Iterator i;
1250 Unit *u;
1251 const char *t;
1252
1253 assert(s);
1254 assert(f);
1255
1256 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1257 if (u->id == t)
1258 unit_dump(u, f, prefix);
1259 }
1260
1261 void manager_clear_jobs(Manager *m) {
1262 Job *j;
1263
1264 assert(m);
1265
1266 while ((j = hashmap_first(m->jobs)))
1267 /* No need to recurse. We're cancelling all jobs. */
1268 job_finish_and_invalidate(j, JOB_CANCELED, false);
1269 }
1270
1271 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1272 Manager *m = userdata;
1273 Job *j;
1274
1275 assert(source);
1276 assert(m);
1277
1278 while ((j = m->run_queue)) {
1279 assert(j->installed);
1280 assert(j->in_run_queue);
1281
1282 job_run_and_invalidate(j);
1283 }
1284
1285 if (m->n_running_jobs > 0)
1286 manager_watch_jobs_in_progress(m);
1287
1288 if (m->n_on_console > 0)
1289 manager_watch_idle_pipe(m);
1290
1291 return 1;
1292 }
1293
1294 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1295 Job *j;
1296 Unit *u;
1297 unsigned n = 0;
1298
1299 assert(m);
1300
1301 if (m->dispatching_dbus_queue)
1302 return 0;
1303
1304 m->dispatching_dbus_queue = true;
1305
1306 while ((u = m->dbus_unit_queue)) {
1307 assert(u->in_dbus_queue);
1308
1309 bus_unit_send_change_signal(u);
1310 n++;
1311 }
1312
1313 while ((j = m->dbus_job_queue)) {
1314 assert(j->in_dbus_queue);
1315
1316 bus_job_send_change_signal(j);
1317 n++;
1318 }
1319
1320 m->dispatching_dbus_queue = false;
1321
1322 if (m->send_reloading_done) {
1323 m->send_reloading_done = false;
1324
1325 bus_manager_send_reloading(m, false);
1326 }
1327
1328 if (m->queued_message)
1329 bus_send_queued_message(m);
1330
1331 return n;
1332 }
1333
1334 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1335 _cleanup_strv_free_ char **tags = NULL;
1336
1337 assert(m);
1338 assert(u);
1339 assert(buf);
1340 assert(n > 0);
1341
1342 tags = strv_split(buf, "\n\r");
1343 if (!tags) {
1344 log_oom();
1345 return;
1346 }
1347
1348 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1349
1350 if (UNIT_VTABLE(u)->notify_message)
1351 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1352 }
1353
1354 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1355 Manager *m = userdata;
1356 ssize_t n;
1357
1358 assert(m);
1359 assert(m->notify_fd == fd);
1360
1361 if (revents != EPOLLIN) {
1362 log_warning("Got unexpected poll event for notify fd.");
1363 return 0;
1364 }
1365
1366 for (;;) {
1367 char buf[4096];
1368 struct iovec iovec = {
1369 .iov_base = buf,
1370 .iov_len = sizeof(buf)-1,
1371 };
1372 bool found = false;
1373
1374 union {
1375 struct cmsghdr cmsghdr;
1376 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1377 } control = {};
1378
1379 struct msghdr msghdr = {
1380 .msg_iov = &iovec,
1381 .msg_iovlen = 1,
1382 .msg_control = &control,
1383 .msg_controllen = sizeof(control),
1384 };
1385 struct ucred *ucred;
1386 Unit *u;
1387
1388 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1389 if (n <= 0) {
1390 if (n == 0)
1391 return -EIO;
1392
1393 if (errno == EAGAIN || errno == EINTR)
1394 break;
1395
1396 return -errno;
1397 }
1398
1399 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1400 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1401 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1402 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1403 log_warning("Received notify message without credentials. Ignoring.");
1404 continue;
1405 }
1406
1407 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1408
1409 assert((size_t) n < sizeof(buf));
1410 buf[n] = 0;
1411
1412 u = manager_get_unit_by_pid(m, ucred->pid);
1413 if (u) {
1414 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1415 found = true;
1416 }
1417
1418 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1419 if (u) {
1420 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1421 found = true;
1422 }
1423
1424 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1425 if (u) {
1426 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1427 found = true;
1428 }
1429
1430 if (!found)
1431 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1432 }
1433
1434 return 0;
1435 }
1436
1437 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1438 assert(m);
1439 assert(u);
1440 assert(si);
1441
1442 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1443
1444 unit_unwatch_pid(u, si->si_pid);
1445 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1446 }
1447
1448 static int manager_dispatch_sigchld(Manager *m) {
1449 assert(m);
1450
1451 for (;;) {
1452 siginfo_t si = {};
1453
1454 /* First we call waitd() for a PID and do not reap the
1455 * zombie. That way we can still access /proc/$PID for
1456 * it while it is a zombie. */
1457 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1458
1459 if (errno == ECHILD)
1460 break;
1461
1462 if (errno == EINTR)
1463 continue;
1464
1465 return -errno;
1466 }
1467
1468 if (si.si_pid <= 0)
1469 break;
1470
1471 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1472 _cleanup_free_ char *name = NULL;
1473 Unit *u;
1474
1475 get_process_comm(si.si_pid, &name);
1476
1477 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1478 si.si_pid, strna(name),
1479 sigchld_code_to_string(si.si_code),
1480 si.si_status,
1481 strna(si.si_code == CLD_EXITED
1482 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1483 : signal_to_string(si.si_status)));
1484
1485 /* And now figure out the unit this belongs
1486 * to, it might be multiple... */
1487 u = manager_get_unit_by_pid(m, si.si_pid);
1488 if (u)
1489 invoke_sigchld_event(m, u, &si);
1490 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1491 if (u)
1492 invoke_sigchld_event(m, u, &si);
1493 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1494 if (u)
1495 invoke_sigchld_event(m, u, &si);
1496 }
1497
1498 /* And now, we actually reap the zombie. */
1499 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1500 if (errno == EINTR)
1501 continue;
1502
1503 return -errno;
1504 }
1505 }
1506
1507 return 0;
1508 }
1509
1510 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1511 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1512 int r;
1513
1514 log_debug_unit(name, "Activating special unit %s", name);
1515
1516 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1517 if (r < 0)
1518 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1519
1520 return r;
1521 }
1522
1523 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1524 Manager *m = userdata;
1525 ssize_t n;
1526 struct signalfd_siginfo sfsi;
1527 bool sigchld = false;
1528
1529 assert(m);
1530 assert(m->signal_fd == fd);
1531
1532 if (revents != EPOLLIN) {
1533 log_warning("Got unexpected events from signal file descriptor.");
1534 return 0;
1535 }
1536
1537 for (;;) {
1538 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1539 if (n != sizeof(sfsi)) {
1540
1541 if (n >= 0)
1542 return -EIO;
1543
1544 if (errno == EINTR || errno == EAGAIN)
1545 break;
1546
1547 return -errno;
1548 }
1549
1550 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1551 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1552 ? LOG_DEBUG : LOG_INFO,
1553 &sfsi);
1554
1555 switch (sfsi.ssi_signo) {
1556
1557 case SIGCHLD:
1558 sigchld = true;
1559 break;
1560
1561 case SIGTERM:
1562 if (m->running_as == SYSTEMD_SYSTEM) {
1563 /* This is for compatibility with the
1564 * original sysvinit */
1565 m->exit_code = MANAGER_REEXECUTE;
1566 break;
1567 }
1568
1569 /* Fall through */
1570
1571 case SIGINT:
1572 if (m->running_as == SYSTEMD_SYSTEM) {
1573 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1574 break;
1575 }
1576
1577 /* Run the exit target if there is one, if not, just exit. */
1578 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1579 m->exit_code = MANAGER_EXIT;
1580 return 0;
1581 }
1582
1583 break;
1584
1585 case SIGWINCH:
1586 if (m->running_as == SYSTEMD_SYSTEM)
1587 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1588
1589 /* This is a nop on non-init */
1590 break;
1591
1592 case SIGPWR:
1593 if (m->running_as == SYSTEMD_SYSTEM)
1594 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1595
1596 /* This is a nop on non-init */
1597 break;
1598
1599 case SIGUSR1: {
1600 Unit *u;
1601
1602 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1603
1604 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1605 log_info("Trying to reconnect to bus...");
1606 bus_init(m, true);
1607 }
1608
1609 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1610 log_info("Loading D-Bus service...");
1611 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1612 }
1613
1614 break;
1615 }
1616
1617 case SIGUSR2: {
1618 _cleanup_free_ char *dump = NULL;
1619 _cleanup_fclose_ FILE *f = NULL;
1620 size_t size;
1621
1622 f = open_memstream(&dump, &size);
1623 if (!f) {
1624 log_warning("Failed to allocate memory stream.");
1625 break;
1626 }
1627
1628 manager_dump_units(m, f, "\t");
1629 manager_dump_jobs(m, f, "\t");
1630
1631 if (ferror(f)) {
1632 log_warning("Failed to write status stream");
1633 break;
1634 }
1635
1636 if (fflush(f)) {
1637 log_warning("Failed to flush status stream");
1638 break;
1639 }
1640
1641 log_dump(LOG_INFO, dump);
1642 break;
1643 }
1644
1645 case SIGHUP:
1646 m->exit_code = MANAGER_RELOAD;
1647 break;
1648
1649 default: {
1650
1651 /* Starting SIGRTMIN+0 */
1652 static const char * const target_table[] = {
1653 [0] = SPECIAL_DEFAULT_TARGET,
1654 [1] = SPECIAL_RESCUE_TARGET,
1655 [2] = SPECIAL_EMERGENCY_TARGET,
1656 [3] = SPECIAL_HALT_TARGET,
1657 [4] = SPECIAL_POWEROFF_TARGET,
1658 [5] = SPECIAL_REBOOT_TARGET,
1659 [6] = SPECIAL_KEXEC_TARGET
1660 };
1661
1662 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1663 static const ManagerExitCode code_table[] = {
1664 [0] = MANAGER_HALT,
1665 [1] = MANAGER_POWEROFF,
1666 [2] = MANAGER_REBOOT,
1667 [3] = MANAGER_KEXEC
1668 };
1669
1670 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1671 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1672 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1673 manager_start_target(m, target_table[idx],
1674 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1675 break;
1676 }
1677
1678 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1679 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1680 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1681 break;
1682 }
1683
1684 switch (sfsi.ssi_signo - SIGRTMIN) {
1685
1686 case 20:
1687 log_debug("Enabling showing of status.");
1688 manager_set_show_status(m, SHOW_STATUS_YES);
1689 break;
1690
1691 case 21:
1692 log_debug("Disabling showing of status.");
1693 manager_set_show_status(m, SHOW_STATUS_NO);
1694 break;
1695
1696 case 22:
1697 log_set_max_level(LOG_DEBUG);
1698 log_notice("Setting log level to debug.");
1699 break;
1700
1701 case 23:
1702 log_set_max_level(LOG_INFO);
1703 log_notice("Setting log level to info.");
1704 break;
1705
1706 case 24:
1707 if (m->running_as == SYSTEMD_USER) {
1708 m->exit_code = MANAGER_EXIT;
1709 return 0;
1710 }
1711
1712 /* This is a nop on init */
1713 break;
1714
1715 case 26:
1716 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1717 log_notice("Setting log target to journal-or-kmsg.");
1718 break;
1719
1720 case 27:
1721 log_set_target(LOG_TARGET_CONSOLE);
1722 log_notice("Setting log target to console.");
1723 break;
1724
1725 case 28:
1726 log_set_target(LOG_TARGET_KMSG);
1727 log_notice("Setting log target to kmsg.");
1728 break;
1729
1730 case 29:
1731 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1732 log_notice("Setting log target to syslog-or-kmsg.");
1733 break;
1734
1735 default:
1736 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1737 }
1738 }
1739 }
1740 }
1741
1742 if (sigchld)
1743 manager_dispatch_sigchld(m);
1744
1745 return 0;
1746 }
1747
1748 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1749 Manager *m = userdata;
1750 Iterator i;
1751 Unit *u;
1752
1753 assert(m);
1754 assert(m->time_change_fd == fd);
1755
1756 log_struct(LOG_INFO,
1757 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1758 "MESSAGE=Time has been changed",
1759 NULL);
1760
1761 /* Restart the watch */
1762 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1763 m->time_change_fd = safe_close(m->time_change_fd);
1764
1765 manager_setup_time_change(m);
1766
1767 HASHMAP_FOREACH(u, m->units, i)
1768 if (UNIT_VTABLE(u)->time_change)
1769 UNIT_VTABLE(u)->time_change(u);
1770
1771 return 0;
1772 }
1773
1774 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1775 Manager *m = userdata;
1776
1777 assert(m);
1778 assert(m->idle_pipe[2] == fd);
1779
1780 m->no_console_output = m->n_on_console > 0;
1781
1782 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1783 manager_close_idle_pipe(m);
1784
1785 return 0;
1786 }
1787
1788 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1789 Manager *m = userdata;
1790 int r;
1791 uint64_t next;
1792
1793 assert(m);
1794 assert(source);
1795
1796 manager_print_jobs_in_progress(m);
1797
1798 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1799 r = sd_event_source_set_time(source, next);
1800 if (r < 0)
1801 return r;
1802
1803 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1804 }
1805
1806 int manager_loop(Manager *m) {
1807 int r;
1808
1809 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1810
1811 assert(m);
1812 m->exit_code = MANAGER_OK;
1813
1814 /* Release the path cache */
1815 set_free_free(m->unit_path_cache);
1816 m->unit_path_cache = NULL;
1817
1818 manager_check_finished(m);
1819
1820 /* There might still be some zombies hanging around from
1821 * before we were exec()'ed. Let's reap them. */
1822 r = manager_dispatch_sigchld(m);
1823 if (r < 0)
1824 return r;
1825
1826 while (m->exit_code == MANAGER_OK) {
1827 usec_t wait_usec;
1828
1829 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1830 watchdog_ping();
1831
1832 if (!ratelimit_test(&rl)) {
1833 /* Yay, something is going seriously wrong, pause a little */
1834 log_warning("Looping too fast. Throttling execution a little.");
1835 sleep(1);
1836 continue;
1837 }
1838
1839 if (manager_dispatch_load_queue(m) > 0)
1840 continue;
1841
1842 if (manager_dispatch_gc_queue(m) > 0)
1843 continue;
1844
1845 if (manager_dispatch_cleanup_queue(m) > 0)
1846 continue;
1847
1848 if (manager_dispatch_cgroup_queue(m) > 0)
1849 continue;
1850
1851 if (manager_dispatch_dbus_queue(m) > 0)
1852 continue;
1853
1854 /* Sleep for half the watchdog time */
1855 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1856 wait_usec = m->runtime_watchdog / 2;
1857 if (wait_usec <= 0)
1858 wait_usec = 1;
1859 } else
1860 wait_usec = (usec_t) -1;
1861
1862 r = sd_event_run(m->event, wait_usec);
1863 if (r < 0) {
1864 log_error("Failed to run event loop: %s", strerror(-r));
1865 return r;
1866 }
1867 }
1868
1869 return m->exit_code;
1870 }
1871
1872 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1873 _cleanup_free_ char *n = NULL;
1874 Unit *u;
1875 int r;
1876
1877 assert(m);
1878 assert(s);
1879 assert(_u);
1880
1881 r = unit_name_from_dbus_path(s, &n);
1882 if (r < 0)
1883 return r;
1884
1885 r = manager_load_unit(m, n, NULL, e, &u);
1886 if (r < 0)
1887 return r;
1888
1889 *_u = u;
1890
1891 return 0;
1892 }
1893
1894 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1895 const char *p;
1896 unsigned id;
1897 Job *j;
1898 int r;
1899
1900 assert(m);
1901 assert(s);
1902 assert(_j);
1903
1904 p = startswith(s, "/org/freedesktop/systemd1/job/");
1905 if (!p)
1906 return -EINVAL;
1907
1908 r = safe_atou(p, &id);
1909 if (r < 0)
1910 return r;
1911
1912 j = manager_get_job(m, id);
1913 if (!j)
1914 return -ENOENT;
1915
1916 *_j = j;
1917
1918 return 0;
1919 }
1920
1921 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1922
1923 #ifdef HAVE_AUDIT
1924 _cleanup_free_ char *p = NULL;
1925 int audit_fd;
1926
1927 audit_fd = get_audit_fd();
1928 if (audit_fd < 0)
1929 return;
1930
1931 /* Don't generate audit events if the service was already
1932 * started and we're just deserializing */
1933 if (m->n_reloading > 0)
1934 return;
1935
1936 if (m->running_as != SYSTEMD_SYSTEM)
1937 return;
1938
1939 if (u->type != UNIT_SERVICE)
1940 return;
1941
1942 p = unit_name_to_prefix_and_instance(u->id);
1943 if (!p) {
1944 log_error_unit(u->id,
1945 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1946 return;
1947 }
1948
1949 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1950 if (errno == EPERM) {
1951 /* We aren't allowed to send audit messages?
1952 * Then let's not retry again. */
1953 close_audit_fd();
1954 } else
1955 log_warning("Failed to send audit message: %m");
1956 }
1957 #endif
1958
1959 }
1960
1961 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1962 union sockaddr_union sa = {
1963 .un.sun_family = AF_UNIX,
1964 .un.sun_path = "\0/org/freedesktop/plymouthd",
1965 };
1966
1967 int n = 0;
1968 _cleanup_free_ char *message = NULL;
1969 _cleanup_close_ int fd = -1;
1970
1971 /* Don't generate plymouth events if the service was already
1972 * started and we're just deserializing */
1973 if (m->n_reloading > 0)
1974 return;
1975
1976 if (m->running_as != SYSTEMD_SYSTEM)
1977 return;
1978
1979 if (detect_container(NULL) > 0)
1980 return;
1981
1982 if (u->type != UNIT_SERVICE &&
1983 u->type != UNIT_MOUNT &&
1984 u->type != UNIT_SWAP)
1985 return;
1986
1987 /* We set SOCK_NONBLOCK here so that we rather drop the
1988 * message then wait for plymouth */
1989 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1990 if (fd < 0) {
1991 log_error("socket() failed: %m");
1992 return;
1993 }
1994
1995 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1996
1997 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
1998 log_error("connect() failed: %m");
1999 return;
2000 }
2001
2002 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2003 log_oom();
2004 return;
2005 }
2006
2007 errno = 0;
2008 if (write(fd, message, n + 1) != n + 1)
2009 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2010 log_error("Failed to write Plymouth message: %m");
2011 }
2012
2013 void manager_dispatch_bus_name_owner_changed(
2014 Manager *m,
2015 const char *name,
2016 const char* old_owner,
2017 const char *new_owner) {
2018
2019 Unit *u;
2020
2021 assert(m);
2022 assert(name);
2023
2024 u = hashmap_get(m->watch_bus, name);
2025 if (!u)
2026 return;
2027
2028 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2029 }
2030
2031 int manager_open_serialization(Manager *m, FILE **_f) {
2032 const char *path;
2033 int fd = -1;
2034 FILE *f;
2035
2036 assert(_f);
2037
2038 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2039 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2040 if (fd < 0)
2041 return -errno;
2042
2043 log_debug("Serializing state to %s", path);
2044
2045 f = fdopen(fd, "w+");
2046 if (!f) {
2047 safe_close(fd);
2048 return -errno;
2049 }
2050
2051 *_f = f;
2052
2053 return 0;
2054 }
2055
2056 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2057 Iterator i;
2058 Unit *u;
2059 const char *t;
2060 char **e;
2061 int r;
2062
2063 assert(m);
2064 assert(f);
2065 assert(fds);
2066
2067 m->n_reloading ++;
2068
2069 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2070 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2071 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2072 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2073
2074 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2075 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2076 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2077 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2078
2079 if (!in_initrd()) {
2080 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2081 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2082 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2083 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2084 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2085 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2086 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2087 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2088 }
2089
2090 if (!switching_root) {
2091 STRV_FOREACH(e, m->environment) {
2092 _cleanup_free_ char *ce;
2093
2094 ce = cescape(*e);
2095 if (!ce)
2096 return -ENOMEM;
2097
2098 fprintf(f, "env=%s\n", *e);
2099 }
2100 }
2101
2102 if (m->notify_fd >= 0) {
2103 int copy;
2104
2105 copy = fdset_put_dup(fds, m->notify_fd);
2106 if (copy < 0)
2107 return copy;
2108
2109 fprintf(f, "notify-fd=%i\n", copy);
2110 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2111 }
2112
2113 if (m->kdbus_fd >= 0) {
2114 int copy;
2115
2116 copy = fdset_put_dup(fds, m->kdbus_fd);
2117 if (copy < 0)
2118 return copy;
2119
2120 fprintf(f, "kdbus-fd=%i\n", copy);
2121 }
2122
2123 bus_track_serialize(m->subscribed, f);
2124
2125 fputc('\n', f);
2126
2127 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2128 if (u->id != t)
2129 continue;
2130
2131 if (!unit_can_serialize(u))
2132 continue;
2133
2134 /* Start marker */
2135 fputs(u->id, f);
2136 fputc('\n', f);
2137
2138 r = unit_serialize(u, f, fds, !switching_root);
2139 if (r < 0) {
2140 m->n_reloading --;
2141 return r;
2142 }
2143 }
2144
2145 assert(m->n_reloading > 0);
2146 m->n_reloading --;
2147
2148 if (ferror(f))
2149 return -EIO;
2150
2151 r = bus_fdset_add_all(m, fds);
2152 if (r < 0)
2153 return r;
2154
2155 return 0;
2156 }
2157
2158 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2159 int r = 0;
2160
2161 assert(m);
2162 assert(f);
2163
2164 log_debug("Deserializing state...");
2165
2166 m->n_reloading ++;
2167
2168 for (;;) {
2169 char line[LINE_MAX], *l;
2170
2171 if (!fgets(line, sizeof(line), f)) {
2172 if (feof(f))
2173 r = 0;
2174 else
2175 r = -errno;
2176
2177 goto finish;
2178 }
2179
2180 char_array_0(line);
2181 l = strstrip(line);
2182
2183 if (l[0] == 0)
2184 break;
2185
2186 if (startswith(l, "current-job-id=")) {
2187 uint32_t id;
2188
2189 if (safe_atou32(l+15, &id) < 0)
2190 log_debug("Failed to parse current job id value %s", l+15);
2191 else
2192 m->current_job_id = MAX(m->current_job_id, id);
2193
2194 } else if (startswith(l, "n-installed-jobs=")) {
2195 uint32_t n;
2196
2197 if (safe_atou32(l+17, &n) < 0)
2198 log_debug("Failed to parse installed jobs counter %s", l+17);
2199 else
2200 m->n_installed_jobs += n;
2201
2202 } else if (startswith(l, "n-failed-jobs=")) {
2203 uint32_t n;
2204
2205 if (safe_atou32(l+14, &n) < 0)
2206 log_debug("Failed to parse failed jobs counter %s", l+14);
2207 else
2208 m->n_failed_jobs += n;
2209
2210 } else if (startswith(l, "taint-usr=")) {
2211 int b;
2212
2213 b = parse_boolean(l+10);
2214 if (b < 0)
2215 log_debug("Failed to parse taint /usr flag %s", l+10);
2216 else
2217 m->taint_usr = m->taint_usr || b;
2218
2219 } else if (startswith(l, "firmware-timestamp="))
2220 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2221 else if (startswith(l, "loader-timestamp="))
2222 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2223 else if (startswith(l, "kernel-timestamp="))
2224 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2225 else if (startswith(l, "initrd-timestamp="))
2226 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2227 else if (startswith(l, "userspace-timestamp="))
2228 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2229 else if (startswith(l, "finish-timestamp="))
2230 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2231 else if (startswith(l, "security-start-timestamp="))
2232 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2233 else if (startswith(l, "security-finish-timestamp="))
2234 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2235 else if (startswith(l, "generators-start-timestamp="))
2236 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2237 else if (startswith(l, "generators-finish-timestamp="))
2238 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2239 else if (startswith(l, "units-load-start-timestamp="))
2240 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2241 else if (startswith(l, "units-load-finish-timestamp="))
2242 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2243 else if (startswith(l, "env=")) {
2244 _cleanup_free_ char *uce = NULL;
2245 char **e;
2246
2247 uce = cunescape(l+4);
2248 if (!uce) {
2249 r = -ENOMEM;
2250 goto finish;
2251 }
2252
2253 e = strv_env_set(m->environment, uce);
2254 if (!e) {
2255 r = -ENOMEM;
2256 goto finish;
2257 }
2258
2259 strv_free(m->environment);
2260 m->environment = e;
2261
2262 } else if (startswith(l, "notify-fd=")) {
2263 int fd;
2264
2265 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2266 log_debug("Failed to parse notify fd: %s", l + 10);
2267 else {
2268 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2269 safe_close(m->notify_fd);
2270 m->notify_fd = fdset_remove(fds, fd);
2271 }
2272
2273 } else if (startswith(l, "notify-socket=")) {
2274 char *n;
2275
2276 n = strdup(l+14);
2277 if (!n) {
2278 r = -ENOMEM;
2279 goto finish;
2280 }
2281
2282 free(m->notify_socket);
2283 m->notify_socket = n;
2284
2285 } else if (startswith(l, "kdbus-fd=")) {
2286 int fd;
2287
2288 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2289 log_debug("Failed to parse kdbus fd: %s", l + 9);
2290 else {
2291 safe_close(m->kdbus_fd);
2292 m->kdbus_fd = fdset_remove(fds, fd);
2293 }
2294
2295 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2296 log_debug("Unknown serialization item '%s'", l);
2297 }
2298
2299 for (;;) {
2300 Unit *u;
2301 char name[UNIT_NAME_MAX+2];
2302
2303 /* Start marker */
2304 if (!fgets(name, sizeof(name), f)) {
2305 if (feof(f))
2306 r = 0;
2307 else
2308 r = -errno;
2309
2310 goto finish;
2311 }
2312
2313 char_array_0(name);
2314
2315 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2316 if (r < 0)
2317 goto finish;
2318
2319 r = unit_deserialize(u, f, fds);
2320 if (r < 0)
2321 goto finish;
2322 }
2323
2324 finish:
2325 if (ferror(f))
2326 r = -EIO;
2327
2328 assert(m->n_reloading > 0);
2329 m->n_reloading --;
2330
2331 return r;
2332 }
2333
2334 int manager_reload(Manager *m) {
2335 int r, q;
2336 _cleanup_fclose_ FILE *f = NULL;
2337 _cleanup_fdset_free_ FDSet *fds = NULL;
2338
2339 assert(m);
2340
2341 r = manager_open_serialization(m, &f);
2342 if (r < 0)
2343 return r;
2344
2345 m->n_reloading ++;
2346 bus_manager_send_reloading(m, true);
2347
2348 fds = fdset_new();
2349 if (!fds) {
2350 m->n_reloading --;
2351 return -ENOMEM;
2352 }
2353
2354 r = manager_serialize(m, f, fds, false);
2355 if (r < 0) {
2356 m->n_reloading --;
2357 return r;
2358 }
2359
2360 if (fseeko(f, 0, SEEK_SET) < 0) {
2361 m->n_reloading --;
2362 return -errno;
2363 }
2364
2365 /* From here on there is no way back. */
2366 manager_clear_jobs_and_units(m);
2367 manager_undo_generators(m);
2368 lookup_paths_free(&m->lookup_paths);
2369
2370 /* Find new unit paths */
2371 manager_run_generators(m);
2372
2373 q = lookup_paths_init(
2374 &m->lookup_paths, m->running_as, true,
2375 m->generator_unit_path,
2376 m->generator_unit_path_early,
2377 m->generator_unit_path_late);
2378 if (q < 0)
2379 r = q;
2380
2381 manager_build_unit_path_cache(m);
2382
2383 /* First, enumerate what we can from all config files */
2384 q = manager_enumerate(m);
2385 if (q < 0)
2386 r = q;
2387
2388 /* Second, deserialize our stored data */
2389 q = manager_deserialize(m, f, fds);
2390 if (q < 0)
2391 r = q;
2392
2393 fclose(f);
2394 f = NULL;
2395
2396 /* Re-register notify_fd as event source */
2397 q = manager_setup_notify(m);
2398 if (q < 0)
2399 r = q;
2400
2401 /* Third, fire things up! */
2402 q = manager_coldplug(m);
2403 if (q < 0)
2404 r = q;
2405
2406 assert(m->n_reloading > 0);
2407 m->n_reloading--;
2408
2409 m->send_reloading_done = true;
2410
2411 return r;
2412 }
2413
2414 bool manager_is_reloading_or_reexecuting(Manager *m) {
2415 assert(m);
2416
2417 return m->n_reloading != 0;
2418 }
2419
2420 void manager_reset_failed(Manager *m) {
2421 Unit *u;
2422 Iterator i;
2423
2424 assert(m);
2425
2426 HASHMAP_FOREACH(u, m->units, i)
2427 unit_reset_failed(u);
2428 }
2429
2430 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2431 Unit *u;
2432
2433 assert(m);
2434 assert(name);
2435
2436 /* Returns true if the unit is inactive or going down */
2437 u = manager_get_unit(m, name);
2438 if (!u)
2439 return true;
2440
2441 return unit_inactive_or_pending(u);
2442 }
2443
2444 void manager_check_finished(Manager *m) {
2445 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2446 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2447
2448 assert(m);
2449
2450 if (m->n_running_jobs == 0)
2451 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2452
2453 if (hashmap_size(m->jobs) > 0) {
2454
2455 if (m->jobs_in_progress_event_source) {
2456 sd_event_source_set_time(m->jobs_in_progress_event_source,
2457 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2458 }
2459
2460 return;
2461 }
2462
2463 manager_flip_auto_status(m, false);
2464
2465 /* Notify Type=idle units that we are done now */
2466 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2467 manager_close_idle_pipe(m);
2468
2469 /* Turn off confirm spawn now */
2470 m->confirm_spawn = false;
2471
2472 if (dual_timestamp_is_set(&m->finish_timestamp))
2473 return;
2474
2475 dual_timestamp_get(&m->finish_timestamp);
2476
2477 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2478
2479 /* Note that m->kernel_usec.monotonic is always at 0,
2480 * and m->firmware_usec.monotonic and
2481 * m->loader_usec.monotonic should be considered
2482 * negative values. */
2483
2484 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2485 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2486 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2487 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2488
2489 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2490
2491 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2492 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2493
2494 if (!log_on_console())
2495 log_struct(LOG_INFO,
2496 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2497 "KERNEL_USEC="USEC_FMT, kernel_usec,
2498 "INITRD_USEC="USEC_FMT, initrd_usec,
2499 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2500 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2501 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2502 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2503 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2504 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2505 NULL);
2506 } else {
2507 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2508 initrd_usec = 0;
2509
2510 if (!log_on_console())
2511 log_struct(LOG_INFO,
2512 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2513 "KERNEL_USEC="USEC_FMT, kernel_usec,
2514 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2515 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2516 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2517 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2518 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2519 NULL);
2520 }
2521 } else {
2522 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2523 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2524
2525 if (!log_on_console())
2526 log_struct(LOG_INFO,
2527 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2528 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2529 "MESSAGE=Startup finished in %s.",
2530 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2531 NULL);
2532 }
2533
2534 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2535
2536 sd_notifyf(false,
2537 "READY=1\nSTATUS=Startup finished in %s.",
2538 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2539 }
2540
2541 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2542 char *p;
2543 int r;
2544
2545 assert(m);
2546 assert(generator);
2547 assert(name);
2548
2549 if (*generator)
2550 return 0;
2551
2552 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2553 /* systemd --system, not running --test */
2554
2555 p = strappend("/run/systemd/", name);
2556 if (!p)
2557 return log_oom();
2558
2559 r = mkdir_p_label(p, 0755);
2560 if (r < 0) {
2561 log_error("Failed to create generator directory %s: %s",
2562 p, strerror(-r));
2563 free(p);
2564 return r;
2565 }
2566 } else if (m->running_as == SYSTEMD_USER) {
2567 const char *s = NULL;
2568
2569 s = getenv("XDG_RUNTIME_DIR");
2570 if (!s)
2571 return -EINVAL;
2572 p = strjoin(s, "/systemd/", name, NULL);
2573 if (!p)
2574 return log_oom();
2575
2576 r = mkdir_p_label(p, 0755);
2577 if (r < 0) {
2578 log_error("Failed to create generator directory %s: %s",
2579 p, strerror(-r));
2580 free(p);
2581 return r;
2582 }
2583 } else {
2584 /* systemd --system --test */
2585
2586 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2587 if (!p)
2588 return log_oom();
2589
2590 if (!mkdtemp(p)) {
2591 log_error("Failed to create generator directory %s: %m",
2592 p);
2593 free(p);
2594 return -errno;
2595 }
2596 }
2597
2598 *generator = p;
2599 return 0;
2600 }
2601
2602 static void trim_generator_dir(Manager *m, char **generator) {
2603 assert(m);
2604 assert(generator);
2605
2606 if (!*generator)
2607 return;
2608
2609 if (rmdir(*generator) >= 0) {
2610 free(*generator);
2611 *generator = NULL;
2612 }
2613
2614 return;
2615 }
2616
2617 void manager_run_generators(Manager *m) {
2618 _cleanup_closedir_ DIR *d = NULL;
2619 const char *generator_path;
2620 const char *argv[5];
2621 int r;
2622
2623 assert(m);
2624
2625 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2626 d = opendir(generator_path);
2627 if (!d) {
2628 if (errno == ENOENT)
2629 return;
2630
2631 log_error("Failed to enumerate generator directory %s: %m",
2632 generator_path);
2633 return;
2634 }
2635
2636 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2637 if (r < 0)
2638 goto finish;
2639
2640 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2641 if (r < 0)
2642 goto finish;
2643
2644 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2645 if (r < 0)
2646 goto finish;
2647
2648 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2649 argv[1] = m->generator_unit_path;
2650 argv[2] = m->generator_unit_path_early;
2651 argv[3] = m->generator_unit_path_late;
2652 argv[4] = NULL;
2653
2654 RUN_WITH_UMASK(0022)
2655 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2656
2657 finish:
2658 trim_generator_dir(m, &m->generator_unit_path);
2659 trim_generator_dir(m, &m->generator_unit_path_early);
2660 trim_generator_dir(m, &m->generator_unit_path_late);
2661 }
2662
2663 static void remove_generator_dir(Manager *m, char **generator) {
2664 assert(m);
2665 assert(generator);
2666
2667 if (!*generator)
2668 return;
2669
2670 strv_remove(m->lookup_paths.unit_path, *generator);
2671 rm_rf(*generator, false, true, false);
2672
2673 free(*generator);
2674 *generator = NULL;
2675 }
2676
2677 void manager_undo_generators(Manager *m) {
2678 assert(m);
2679
2680 remove_generator_dir(m, &m->generator_unit_path);
2681 remove_generator_dir(m, &m->generator_unit_path_early);
2682 remove_generator_dir(m, &m->generator_unit_path_late);
2683 }
2684
2685 int manager_environment_add(Manager *m, char **minus, char **plus) {
2686 char **a = NULL, **b = NULL, **l;
2687 assert(m);
2688
2689 l = m->environment;
2690
2691 if (!strv_isempty(minus)) {
2692 a = strv_env_delete(l, 1, minus);
2693 if (!a)
2694 return -ENOMEM;
2695
2696 l = a;
2697 }
2698
2699 if (!strv_isempty(plus)) {
2700 b = strv_env_merge(2, l, plus);
2701 if (!b)
2702 return -ENOMEM;
2703
2704 l = b;
2705 }
2706
2707 if (m->environment != l)
2708 strv_free(m->environment);
2709 if (a != l)
2710 strv_free(a);
2711 if (b != l)
2712 strv_free(b);
2713
2714 m->environment = l;
2715 manager_clean_environment(m);
2716 strv_sort(m->environment);
2717
2718 return 0;
2719 }
2720
2721 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2722 int i;
2723
2724 assert(m);
2725
2726 for (i = 0; i < _RLIMIT_MAX; i++) {
2727 if (!default_rlimit[i])
2728 continue;
2729
2730 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2731 if (!m->rlimit[i])
2732 return -ENOMEM;
2733 }
2734
2735 return 0;
2736 }
2737
2738 void manager_recheck_journal(Manager *m) {
2739 Unit *u;
2740
2741 assert(m);
2742
2743 if (m->running_as != SYSTEMD_SYSTEM)
2744 return;
2745
2746 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2747 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2748 log_close_journal();
2749 return;
2750 }
2751
2752 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2753 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2754 log_close_journal();
2755 return;
2756 }
2757
2758 /* Hmm, OK, so the socket is fully up and the service is up
2759 * too, then let's make use of the thing. */
2760 log_open();
2761 }
2762
2763 void manager_set_show_status(Manager *m, ShowStatus mode) {
2764 assert(m);
2765 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2766
2767 if (m->running_as != SYSTEMD_SYSTEM)
2768 return;
2769
2770 m->show_status = mode;
2771
2772 if (mode > 0)
2773 touch("/run/systemd/show-status");
2774 else
2775 unlink("/run/systemd/show-status");
2776 }
2777
2778 static bool manager_get_show_status(Manager *m) {
2779 assert(m);
2780
2781 if (m->running_as != SYSTEMD_SYSTEM)
2782 return false;
2783
2784 if (m->no_console_output)
2785 return false;
2786
2787 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2788 return false;
2789
2790 if (m->show_status > 0)
2791 return true;
2792
2793 /* If Plymouth is running make sure we show the status, so
2794 * that there's something nice to see when people press Esc */
2795
2796 return plymouth_running();
2797 }
2798
2799 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2800 va_list ap;
2801
2802 if (!manager_get_show_status(m))
2803 return;
2804
2805 /* XXX We should totally drop the check for ephemeral here
2806 * and thus effectively make 'Type=idle' pointless. */
2807 if (ephemeral && m->n_on_console > 0)
2808 return;
2809
2810 va_start(ap, format);
2811 status_vprintf(status, true, ephemeral, format, ap);
2812 va_end(ap);
2813 }
2814
2815 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2816 _cleanup_free_ char *p = NULL;
2817 Unit *found;
2818
2819 assert(m);
2820 assert(path);
2821 assert(suffix);
2822 assert(_found);
2823
2824 p = unit_name_from_path(path, suffix);
2825 if (!p)
2826 return -ENOMEM;
2827
2828 found = manager_get_unit(m, p);
2829 if (!found) {
2830 *_found = NULL;
2831 return 0;
2832 }
2833
2834 *_found = found;
2835 return 1;
2836 }
2837
2838 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2839 char p[strlen(path)+1];
2840
2841 assert(m);
2842 assert(path);
2843
2844 strcpy(p, path);
2845 path_kill_slashes(p);
2846
2847 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2848 }
2849
2850 const char *manager_get_runtime_prefix(Manager *m) {
2851 assert(m);
2852
2853 return m->running_as == SYSTEMD_SYSTEM ?
2854 "/run" :
2855 getenv("XDG_RUNTIME_DIR");
2856 }
2857
2858 ManagerState manager_state(Manager *m) {
2859 Unit *u;
2860
2861 assert(m);
2862
2863 /* Did we ever finish booting? If not then we are still starting up */
2864 if (!dual_timestamp_is_set(&m->finish_timestamp))
2865 return MANAGER_STARTING;
2866
2867 /* Is the special shutdown target queued? If so, we are in shutdown state */
2868 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2869 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2870 return MANAGER_STOPPING;
2871
2872 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2873 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2874 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2875 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2876 return MANAGER_MAINTENANCE;
2877
2878 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2879 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2880 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2881 return MANAGER_MAINTENANCE;
2882
2883 /* Are there any failed units? If so, we are in degraded mode */
2884 if (set_size(m->failed_units) > 0)
2885 return MANAGER_DEGRADED;
2886
2887 return MANAGER_RUNNING;
2888 }
2889
2890 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2891 [MANAGER_STARTING] = "starting",
2892 [MANAGER_RUNNING] = "running",
2893 [MANAGER_DEGRADED] = "degraded",
2894 [MANAGER_MAINTENANCE] = "maintenance",
2895 [MANAGER_STOPPING] = "stopping",
2896 };
2897
2898 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
Unnamed repository; edit this file 'description' to name the repository.