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