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