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