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