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