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