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