]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/manager.c
projects / thirdparty / systemd.git / blob
? search:


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