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