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