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