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