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