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