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