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