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


2e89f19839add470275f2b72bb1e74ec5a79ca1d
[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.", (unsigned long) ucred->pid);
1234 continue;
1235 }
1236 }
1237
1238 assert((size_t) n < sizeof(buf));
1239 buf[n] = 0;
1240 tags = strv_split(buf, "\n\r");
1241 if (!tags)
1242 return log_oom();
1243
1244 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1245
1246 if (UNIT_VTABLE(u)->notify_message)
1247 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1248 }
1249
1250 return 0;
1251 }
1252
1253 static int manager_dispatch_sigchld(Manager *m) {
1254 assert(m);
1255
1256 for (;;) {
1257 siginfo_t si;
1258 Unit *u;
1259 int r;
1260
1261 zero(si);
1262
1263 /* First we call waitd() for a PID and do not reap the
1264 * zombie. That way we can still access /proc/$PID for
1265 * it while it is a zombie. */
1266 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1267
1268 if (errno == ECHILD)
1269 break;
1270
1271 if (errno == EINTR)
1272 continue;
1273
1274 return -errno;
1275 }
1276
1277 if (si.si_pid <= 0)
1278 break;
1279
1280 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1281 char _cleanup_free_ *name = NULL;
1282
1283 get_process_comm(si.si_pid, &name);
1284 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1285 }
1286
1287 /* Let's flush any message the dying child might still
1288 * have queued for us. This ensures that the process
1289 * still exists in /proc so that we can figure out
1290 * which cgroup and hence unit it belongs to. */
1291 r = manager_process_notify_fd(m);
1292 if (r < 0)
1293 return r;
1294
1295 /* And now figure out the unit this belongs to */
1296 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1297 if (!u)
1298 u = cgroup_unit_by_pid(m, si.si_pid);
1299
1300 /* And now, we actually reap the zombie. */
1301 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1302 if (errno == EINTR)
1303 continue;
1304
1305 return -errno;
1306 }
1307
1308 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1309 continue;
1310
1311 log_debug("Child %lu died (code=%s, status=%i/%s)",
1312 (long unsigned) si.si_pid,
1313 sigchld_code_to_string(si.si_code),
1314 si.si_status,
1315 strna(si.si_code == CLD_EXITED
1316 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1317 : signal_to_string(si.si_status)));
1318
1319 if (!u)
1320 continue;
1321
1322 log_debug_unit(u->id,
1323 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1324
1325 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1326 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1327 }
1328
1329 return 0;
1330 }
1331
1332 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1333 int r;
1334 DBusError error;
1335
1336 dbus_error_init(&error);
1337
1338 log_debug_unit(name, "Activating special unit %s", name);
1339
1340 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1341 if (r < 0)
1342 log_error_unit(name,
1343 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1344
1345 dbus_error_free(&error);
1346
1347 return r;
1348 }
1349
1350 static int manager_process_signal_fd(Manager *m) {
1351 ssize_t n;
1352 struct signalfd_siginfo sfsi;
1353 bool sigchld = false;
1354
1355 assert(m);
1356
1357 for (;;) {
1358 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1359 if (n != sizeof(sfsi)) {
1360
1361 if (n >= 0)
1362 return -EIO;
1363
1364 if (errno == EINTR || errno == EAGAIN)
1365 break;
1366
1367 return -errno;
1368 }
1369
1370 if (sfsi.ssi_pid > 0) {
1371 char *p = NULL;
1372
1373 get_process_comm(sfsi.ssi_pid, &p);
1374
1375 log_debug("Received SIG%s from PID %lu (%s).",
1376 signal_to_string(sfsi.ssi_signo),
1377 (unsigned long) sfsi.ssi_pid, strna(p));
1378 free(p);
1379 } else
1380 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1381
1382 switch (sfsi.ssi_signo) {
1383
1384 case SIGCHLD:
1385 sigchld = true;
1386 break;
1387
1388 case SIGTERM:
1389 if (m->running_as == SYSTEMD_SYSTEM) {
1390 /* This is for compatibility with the
1391 * original sysvinit */
1392 m->exit_code = MANAGER_REEXECUTE;
1393 break;
1394 }
1395
1396 /* Fall through */
1397
1398 case SIGINT:
1399 if (m->running_as == SYSTEMD_SYSTEM) {
1400 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1401 break;
1402 }
1403
1404 /* Run the exit target if there is one, if not, just exit. */
1405 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1406 m->exit_code = MANAGER_EXIT;
1407 return 0;
1408 }
1409
1410 break;
1411
1412 case SIGWINCH:
1413 if (m->running_as == SYSTEMD_SYSTEM)
1414 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1415
1416 /* This is a nop on non-init */
1417 break;
1418
1419 case SIGPWR:
1420 if (m->running_as == SYSTEMD_SYSTEM)
1421 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1422
1423 /* This is a nop on non-init */
1424 break;
1425
1426 case SIGUSR1: {
1427 Unit *u;
1428
1429 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1430
1431 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1432 log_info("Trying to reconnect to bus...");
1433 bus_init(m, true);
1434 }
1435
1436 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1437 log_info("Loading D-Bus service...");
1438 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1439 }
1440
1441 break;
1442 }
1443
1444 case SIGUSR2: {
1445 FILE *f;
1446 char *dump = NULL;
1447 size_t size;
1448
1449 if (!(f = open_memstream(&dump, &size))) {
1450 log_warning("Failed to allocate memory stream.");
1451 break;
1452 }
1453
1454 manager_dump_units(m, f, "\t");
1455 manager_dump_jobs(m, f, "\t");
1456
1457 if (ferror(f)) {
1458 fclose(f);
1459 free(dump);
1460 log_warning("Failed to write status stream");
1461 break;
1462 }
1463
1464 fclose(f);
1465 log_dump(LOG_INFO, dump);
1466 free(dump);
1467
1468 break;
1469 }
1470
1471 case SIGHUP:
1472 m->exit_code = MANAGER_RELOAD;
1473 break;
1474
1475 default: {
1476
1477 /* Starting SIGRTMIN+0 */
1478 static const char * const target_table[] = {
1479 [0] = SPECIAL_DEFAULT_TARGET,
1480 [1] = SPECIAL_RESCUE_TARGET,
1481 [2] = SPECIAL_EMERGENCY_TARGET,
1482 [3] = SPECIAL_HALT_TARGET,
1483 [4] = SPECIAL_POWEROFF_TARGET,
1484 [5] = SPECIAL_REBOOT_TARGET,
1485 [6] = SPECIAL_KEXEC_TARGET
1486 };
1487
1488 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1489 static const ManagerExitCode code_table[] = {
1490 [0] = MANAGER_HALT,
1491 [1] = MANAGER_POWEROFF,
1492 [2] = MANAGER_REBOOT,
1493 [3] = MANAGER_KEXEC
1494 };
1495
1496 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1497 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1498 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1499 manager_start_target(m, target_table[idx],
1500 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1501 break;
1502 }
1503
1504 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1505 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1506 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1507 break;
1508 }
1509
1510 switch (sfsi.ssi_signo - SIGRTMIN) {
1511
1512 case 20:
1513 log_debug("Enabling showing of status.");
1514 manager_set_show_status(m, true);
1515 break;
1516
1517 case 21:
1518 log_debug("Disabling showing of status.");
1519 manager_set_show_status(m, false);
1520 break;
1521
1522 case 22:
1523 log_set_max_level(LOG_DEBUG);
1524 log_notice("Setting log level to debug.");
1525 break;
1526
1527 case 23:
1528 log_set_max_level(LOG_INFO);
1529 log_notice("Setting log level to info.");
1530 break;
1531
1532 case 24:
1533 if (m->running_as == SYSTEMD_USER) {
1534 m->exit_code = MANAGER_EXIT;
1535 return 0;
1536 }
1537
1538 /* This is a nop on init */
1539 break;
1540
1541 case 26:
1542 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1543 log_notice("Setting log target to journal-or-kmsg.");
1544 break;
1545
1546 case 27:
1547 log_set_target(LOG_TARGET_CONSOLE);
1548 log_notice("Setting log target to console.");
1549 break;
1550
1551 case 28:
1552 log_set_target(LOG_TARGET_KMSG);
1553 log_notice("Setting log target to kmsg.");
1554 break;
1555
1556 case 29:
1557 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1558 log_notice("Setting log target to syslog-or-kmsg.");
1559 break;
1560
1561 default:
1562 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1563 }
1564 }
1565 }
1566 }
1567
1568 if (sigchld)
1569 return manager_dispatch_sigchld(m);
1570
1571 return 0;
1572 }
1573
1574 static int process_event(Manager *m, struct epoll_event *ev) {
1575 int r;
1576 Watch *w;
1577
1578 assert(m);
1579 assert(ev);
1580
1581 assert_se(w = ev->data.ptr);
1582
1583 if (w->type == WATCH_INVALID)
1584 return 0;
1585
1586 switch (w->type) {
1587
1588 case WATCH_SIGNAL:
1589
1590 /* An incoming signal? */
1591 if (ev->events != EPOLLIN)
1592 return -EINVAL;
1593
1594 if ((r = manager_process_signal_fd(m)) < 0)
1595 return r;
1596
1597 break;
1598
1599 case WATCH_NOTIFY:
1600
1601 /* An incoming daemon notification event? */
1602 if (ev->events != EPOLLIN)
1603 return -EINVAL;
1604
1605 if ((r = manager_process_notify_fd(m)) < 0)
1606 return r;
1607
1608 break;
1609
1610 case WATCH_FD:
1611
1612 /* Some fd event, to be dispatched to the units */
1613 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1614 break;
1615
1616 case WATCH_UNIT_TIMER:
1617 case WATCH_JOB_TIMER: {
1618 uint64_t v;
1619 ssize_t k;
1620
1621 /* Some timer event, to be dispatched to the units */
1622 k = read(w->fd, &v, sizeof(v));
1623 if (k != sizeof(v)) {
1624
1625 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1626 break;
1627
1628 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1629 return k < 0 ? -errno : -EIO;
1630 }
1631
1632 if (w->type == WATCH_UNIT_TIMER)
1633 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1634 else
1635 job_timer_event(w->data.job, v, w);
1636 break;
1637 }
1638
1639 case WATCH_MOUNT:
1640 /* Some mount table change, intended for the mount subsystem */
1641 mount_fd_event(m, ev->events);
1642 break;
1643
1644 case WATCH_SWAP:
1645 /* Some swap table change, intended for the swap subsystem */
1646 swap_fd_event(m, ev->events);
1647 break;
1648
1649 case WATCH_UDEV:
1650 /* Some notification from udev, intended for the device subsystem */
1651 device_fd_event(m, ev->events);
1652 break;
1653
1654 case WATCH_DBUS_WATCH:
1655 bus_watch_event(m, w, ev->events);
1656 break;
1657
1658 case WATCH_DBUS_TIMEOUT:
1659 bus_timeout_event(m, w, ev->events);
1660 break;
1661
1662 case WATCH_TIME_CHANGE: {
1663 Unit *u;
1664 Iterator i;
1665
1666 log_struct(LOG_INFO,
1667 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1668 "MESSAGE=Time has been changed",
1669 NULL);
1670
1671 /* Restart the watch */
1672 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1673 NULL);
1674 close_nointr_nofail(m->time_change_watch.fd);
1675 watch_init(&m->time_change_watch);
1676 manager_setup_time_change(m);
1677
1678 HASHMAP_FOREACH(u, m->units, i) {
1679 if (UNIT_VTABLE(u)->time_change)
1680 UNIT_VTABLE(u)->time_change(u);
1681 }
1682
1683 break;
1684 }
1685
1686 case WATCH_JOBS_IN_PROGRESS: {
1687 uint64_t v;
1688
1689 /* not interested in the data */
1690 read(w->fd, &v, sizeof(v));
1691
1692 manager_print_jobs_in_progress(m);
1693 break;
1694 }
1695
1696 default:
1697 log_error("event type=%i", w->type);
1698 assert_not_reached("Unknown epoll event type.");
1699 }
1700
1701 return 0;
1702 }
1703
1704 int manager_loop(Manager *m) {
1705 int r;
1706
1707 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1708
1709 assert(m);
1710 m->exit_code = MANAGER_RUNNING;
1711
1712 /* Release the path cache */
1713 set_free_free(m->unit_path_cache);
1714 m->unit_path_cache = NULL;
1715
1716 manager_check_finished(m);
1717
1718 /* There might still be some zombies hanging around from
1719 * before we were exec()'ed. Leat's reap them */
1720 r = manager_dispatch_sigchld(m);
1721 if (r < 0)
1722 return r;
1723
1724 while (m->exit_code == MANAGER_RUNNING) {
1725 struct epoll_event event;
1726 int n;
1727 int wait_msec = -1;
1728
1729 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1730 watchdog_ping();
1731
1732 if (!ratelimit_test(&rl)) {
1733 /* Yay, something is going seriously wrong, pause a little */
1734 log_warning("Looping too fast. Throttling execution a little.");
1735 sleep(1);
1736 continue;
1737 }
1738
1739 if (manager_dispatch_load_queue(m) > 0)
1740 continue;
1741
1742 if (manager_dispatch_run_queue(m) > 0)
1743 continue;
1744
1745 if (bus_dispatch(m) > 0)
1746 continue;
1747
1748 if (manager_dispatch_cleanup_queue(m) > 0)
1749 continue;
1750
1751 if (manager_dispatch_gc_queue(m) > 0)
1752 continue;
1753
1754 if (manager_dispatch_dbus_queue(m) > 0)
1755 continue;
1756
1757 if (swap_dispatch_reload(m) > 0)
1758 continue;
1759
1760 /* Sleep for half the watchdog time */
1761 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1762 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1763 if (wait_msec <= 0)
1764 wait_msec = 1;
1765 } else
1766 wait_msec = -1;
1767
1768 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1769 if (n < 0) {
1770
1771 if (errno == EINTR)
1772 continue;
1773
1774 return -errno;
1775 } else if (n == 0)
1776 continue;
1777
1778 assert(n == 1);
1779
1780 r = process_event(m, &event);
1781 if (r < 0)
1782 return r;
1783 }
1784
1785 return m->exit_code;
1786 }
1787
1788 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1789 char *n;
1790 Unit *u;
1791 int r;
1792
1793 assert(m);
1794 assert(s);
1795 assert(_u);
1796
1797 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1798 return -EINVAL;
1799
1800 n = bus_path_unescape(s+31);
1801 if (!n)
1802 return -ENOMEM;
1803
1804 r = manager_load_unit(m, n, NULL, e, &u);
1805 free(n);
1806
1807 if (r < 0)
1808 return r;
1809
1810 *_u = u;
1811
1812 return 0;
1813 }
1814
1815 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1816 Job *j;
1817 unsigned id;
1818 int r;
1819
1820 assert(m);
1821 assert(s);
1822 assert(_j);
1823
1824 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1825 return -EINVAL;
1826
1827 r = safe_atou(s + 30, &id);
1828 if (r < 0)
1829 return r;
1830
1831 j = manager_get_job(m, id);
1832 if (!j)
1833 return -ENOENT;
1834
1835 *_j = j;
1836
1837 return 0;
1838 }
1839
1840 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1841
1842 #ifdef HAVE_AUDIT
1843 char *p;
1844 int audit_fd;
1845
1846 audit_fd = get_audit_fd();
1847 if (audit_fd < 0)
1848 return;
1849
1850 /* Don't generate audit events if the service was already
1851 * started and we're just deserializing */
1852 if (m->n_reloading > 0)
1853 return;
1854
1855 if (m->running_as != SYSTEMD_SYSTEM)
1856 return;
1857
1858 if (u->type != UNIT_SERVICE)
1859 return;
1860
1861 p = unit_name_to_prefix_and_instance(u->id);
1862 if (!p) {
1863 log_error_unit(u->id,
1864 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1865 return;
1866 }
1867
1868 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1869 if (errno == EPERM) {
1870 /* We aren't allowed to send audit messages?
1871 * Then let's not retry again. */
1872 close_audit_fd();
1873 } else
1874 log_warning("Failed to send audit message: %m");
1875 }
1876
1877 free(p);
1878 #endif
1879
1880 }
1881
1882 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1883 int fd = -1;
1884 union sockaddr_union sa;
1885 int n = 0;
1886 char *message = NULL;
1887
1888 /* Don't generate plymouth events if the service was already
1889 * started and we're just deserializing */
1890 if (m->n_reloading > 0)
1891 return;
1892
1893 if (m->running_as != SYSTEMD_SYSTEM)
1894 return;
1895
1896 if (u->type != UNIT_SERVICE &&
1897 u->type != UNIT_MOUNT &&
1898 u->type != UNIT_SWAP)
1899 return;
1900
1901 /* We set SOCK_NONBLOCK here so that we rather drop the
1902 * message then wait for plymouth */
1903 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1904 if (fd < 0) {
1905 log_error("socket() failed: %m");
1906 return;
1907 }
1908
1909 zero(sa);
1910 sa.sa.sa_family = AF_UNIX;
1911 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1912 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1913
1914 if (errno != EPIPE &&
1915 errno != EAGAIN &&
1916 errno != ENOENT &&
1917 errno != ECONNREFUSED &&
1918 errno != ECONNRESET &&
1919 errno != ECONNABORTED)
1920 log_error("connect() failed: %m");
1921
1922 goto finish;
1923 }
1924
1925 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1926 log_oom();
1927 goto finish;
1928 }
1929
1930 errno = 0;
1931 if (write(fd, message, n + 1) != n + 1) {
1932
1933 if (errno != EPIPE &&
1934 errno != EAGAIN &&
1935 errno != ENOENT &&
1936 errno != ECONNREFUSED &&
1937 errno != ECONNRESET &&
1938 errno != ECONNABORTED)
1939 log_error("Failed to write Plymouth message: %m");
1940
1941 goto finish;
1942 }
1943
1944 finish:
1945 if (fd >= 0)
1946 close_nointr_nofail(fd);
1947
1948 free(message);
1949 }
1950
1951 void manager_dispatch_bus_name_owner_changed(
1952 Manager *m,
1953 const char *name,
1954 const char* old_owner,
1955 const char *new_owner) {
1956
1957 Unit *u;
1958
1959 assert(m);
1960 assert(name);
1961
1962 if (!(u = hashmap_get(m->watch_bus, name)))
1963 return;
1964
1965 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1966 }
1967
1968 void manager_dispatch_bus_query_pid_done(
1969 Manager *m,
1970 const char *name,
1971 pid_t pid) {
1972
1973 Unit *u;
1974
1975 assert(m);
1976 assert(name);
1977 assert(pid >= 1);
1978
1979 if (!(u = hashmap_get(m->watch_bus, name)))
1980 return;
1981
1982 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1983 }
1984
1985 int manager_open_serialization(Manager *m, FILE **_f) {
1986 char *path = NULL;
1987 mode_t saved_umask;
1988 int fd;
1989 FILE *f;
1990
1991 assert(_f);
1992
1993 if (m->running_as == SYSTEMD_SYSTEM)
1994 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1995 else
1996 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1997
1998 if (!path)
1999 return -ENOMEM;
2000
2001 saved_umask = umask(0077);
2002 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2003 umask(saved_umask);
2004
2005 if (fd < 0) {
2006 free(path);
2007 return -errno;
2008 }
2009
2010 unlink(path);
2011
2012 log_debug("Serializing state to %s", path);
2013 free(path);
2014
2015 f = fdopen(fd, "w+");
2016 if (!f)
2017 return -errno;
2018
2019 *_f = f;
2020
2021 return 0;
2022 }
2023
2024 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
2025 Iterator i;
2026 Unit *u;
2027 const char *t;
2028 char **e;
2029 int r;
2030
2031 assert(m);
2032 assert(f);
2033 assert(fds);
2034
2035 m->n_reloading ++;
2036
2037 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2038 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2039 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2040 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2041
2042 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2043 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2044 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2045 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2046
2047 if (!in_initrd()) {
2048 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2049 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2050 }
2051
2052 STRV_FOREACH(e, m->environment) {
2053 _cleanup_free_ char *ce;
2054
2055 ce = cescape(*e);
2056 if (ce)
2057 fprintf(f, "env=%s\n", *e);
2058 }
2059
2060 fputc('\n', f);
2061
2062 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2063 if (u->id != t)
2064 continue;
2065
2066 if (!unit_can_serialize(u))
2067 continue;
2068
2069 /* Start marker */
2070 fputs(u->id, f);
2071 fputc('\n', f);
2072
2073 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
2074 m->n_reloading --;
2075 return r;
2076 }
2077 }
2078
2079 assert(m->n_reloading > 0);
2080 m->n_reloading --;
2081
2082 if (ferror(f))
2083 return -EIO;
2084
2085 r = bus_fdset_add_all(m, fds);
2086 if (r < 0)
2087 return r;
2088
2089 return 0;
2090 }
2091
2092 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2093 int r = 0;
2094
2095 assert(m);
2096 assert(f);
2097
2098 log_debug("Deserializing state...");
2099
2100 m->n_reloading ++;
2101
2102 for (;;) {
2103 char line[LINE_MAX], *l;
2104
2105 if (!fgets(line, sizeof(line), f)) {
2106 if (feof(f))
2107 r = 0;
2108 else
2109 r = -errno;
2110
2111 goto finish;
2112 }
2113
2114 char_array_0(line);
2115 l = strstrip(line);
2116
2117 if (l[0] == 0)
2118 break;
2119
2120 if (startswith(l, "current-job-id=")) {
2121 uint32_t id;
2122
2123 if (safe_atou32(l+15, &id) < 0)
2124 log_debug("Failed to parse current job id value %s", l+15);
2125 else
2126 m->current_job_id = MAX(m->current_job_id, id);
2127 } else if (startswith(l, "n-installed-jobs=")) {
2128 uint32_t n;
2129
2130 if (safe_atou32(l+17, &n) < 0)
2131 log_debug("Failed to parse installed jobs counter %s", l+17);
2132 else
2133 m->n_installed_jobs += n;
2134 } else if (startswith(l, "n-failed-jobs=")) {
2135 uint32_t n;
2136
2137 if (safe_atou32(l+14, &n) < 0)
2138 log_debug("Failed to parse failed jobs counter %s", l+14);
2139 else
2140 m->n_failed_jobs += n;
2141 } else if (startswith(l, "taint-usr=")) {
2142 int b;
2143
2144 if ((b = parse_boolean(l+10)) < 0)
2145 log_debug("Failed to parse taint /usr flag %s", l+10);
2146 else
2147 m->taint_usr = m->taint_usr || b;
2148 } else if (startswith(l, "firmware-timestamp="))
2149 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2150 else if (startswith(l, "loader-timestamp="))
2151 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2152 else if (startswith(l, "kernel-timestamp="))
2153 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2154 else if (startswith(l, "initrd-timestamp="))
2155 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2156 else if (startswith(l, "userspace-timestamp="))
2157 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2158 else if (startswith(l, "finish-timestamp="))
2159 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2160 else if (startswith(l, "env=")) {
2161 _cleanup_free_ char *uce = NULL;
2162 char **e;
2163
2164 uce = cunescape(l+4);
2165 if (!uce) {
2166 r = -ENOMEM;
2167 goto finish;
2168 }
2169
2170 e = strv_env_set(m->environment, uce);
2171 if (!e) {
2172 r = -ENOMEM;
2173 goto finish;
2174 }
2175
2176 strv_free(m->environment);
2177 m->environment = e;
2178 } else
2179 log_debug("Unknown serialization item '%s'", l);
2180 }
2181
2182 for (;;) {
2183 Unit *u;
2184 char name[UNIT_NAME_MAX+2];
2185
2186 /* Start marker */
2187 if (!fgets(name, sizeof(name), f)) {
2188 if (feof(f))
2189 r = 0;
2190 else
2191 r = -errno;
2192
2193 goto finish;
2194 }
2195
2196 char_array_0(name);
2197
2198 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2199 if (r < 0)
2200 goto finish;
2201
2202 r = unit_deserialize(u, f, fds);
2203 if (r < 0)
2204 goto finish;
2205 }
2206
2207 finish:
2208 if (ferror(f)) {
2209 r = -EIO;
2210 goto finish;
2211 }
2212
2213 assert(m->n_reloading > 0);
2214 m->n_reloading --;
2215
2216 return r;
2217 }
2218
2219 int manager_distribute_fds(Manager *m, FDSet *fds) {
2220 Unit *u;
2221 Iterator i;
2222 int r;
2223
2224 assert(m);
2225
2226 HASHMAP_FOREACH(u, m->units, i) {
2227
2228 if (fdset_size(fds) <= 0)
2229 break;
2230
2231 if (UNIT_VTABLE(u)->distribute_fds) {
2232 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2233 if (r < 0)
2234 return r;
2235 }
2236 }
2237
2238 return 0;
2239 }
2240
2241 int manager_reload(Manager *m) {
2242 int r, q;
2243 FILE *f;
2244 FDSet *fds;
2245
2246 assert(m);
2247
2248 r = manager_open_serialization(m, &f);
2249 if (r < 0)
2250 return r;
2251
2252 m->n_reloading ++;
2253
2254 fds = fdset_new();
2255 if (!fds) {
2256 m->n_reloading --;
2257 r = -ENOMEM;
2258 goto finish;
2259 }
2260
2261 r = manager_serialize(m, f, fds, true);
2262 if (r < 0) {
2263 m->n_reloading --;
2264 goto finish;
2265 }
2266
2267 if (fseeko(f, 0, SEEK_SET) < 0) {
2268 m->n_reloading --;
2269 r = -errno;
2270 goto finish;
2271 }
2272
2273 /* From here on there is no way back. */
2274 manager_clear_jobs_and_units(m);
2275 manager_undo_generators(m);
2276 lookup_paths_free(&m->lookup_paths);
2277
2278 /* Find new unit paths */
2279 manager_run_generators(m);
2280
2281 q = lookup_paths_init(
2282 &m->lookup_paths, m->running_as, true,
2283 m->generator_unit_path,
2284 m->generator_unit_path_early,
2285 m->generator_unit_path_late);
2286 if (q < 0)
2287 r = q;
2288
2289 manager_build_unit_path_cache(m);
2290
2291 /* First, enumerate what we can from all config files */
2292 q = manager_enumerate(m);
2293 if (q < 0)
2294 r = q;
2295
2296 /* Second, deserialize our stored data */
2297 q = manager_deserialize(m, f, fds);
2298 if (q < 0)
2299 r = q;
2300
2301 fclose(f);
2302 f = NULL;
2303
2304 /* Third, fire things up! */
2305 q = manager_coldplug(m);
2306 if (q < 0)
2307 r = q;
2308
2309 assert(m->n_reloading > 0);
2310 m->n_reloading--;
2311
2312 finish:
2313 if (f)
2314 fclose(f);
2315
2316 if (fds)
2317 fdset_free(fds);
2318
2319 return r;
2320 }
2321
2322 static bool manager_is_booting_or_shutting_down(Manager *m) {
2323 Unit *u;
2324
2325 assert(m);
2326
2327 /* Is the initial job still around? */
2328 if (manager_get_job(m, m->default_unit_job_id))
2329 return true;
2330
2331 /* Is there a job for the shutdown target? */
2332 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2333 if (u)
2334 return !!u->job;
2335
2336 return false;
2337 }
2338
2339 bool manager_is_reloading_or_reexecuting(Manager *m) {
2340 assert(m);
2341
2342 return m->n_reloading != 0;
2343 }
2344
2345 void manager_reset_failed(Manager *m) {
2346 Unit *u;
2347 Iterator i;
2348
2349 assert(m);
2350
2351 HASHMAP_FOREACH(u, m->units, i)
2352 unit_reset_failed(u);
2353 }
2354
2355 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2356 Unit *u;
2357
2358 assert(m);
2359 assert(name);
2360
2361 /* Returns true if the unit is inactive or going down */
2362 u = manager_get_unit(m, name);
2363 if (!u)
2364 return true;
2365
2366 return unit_pending_inactive(u);
2367 }
2368
2369 void manager_check_finished(Manager *m) {
2370 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2371 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2372
2373 assert(m);
2374
2375 if (m->n_running_jobs == 0)
2376 manager_unwatch_jobs_in_progress(m);
2377
2378 if (hashmap_size(m->jobs) > 0) {
2379 manager_jobs_in_progress_mod_timer(m);
2380 return;
2381 }
2382
2383 /* Notify Type=idle units that we are done now */
2384 close_pipe(m->idle_pipe);
2385
2386 /* Turn off confirm spawn now */
2387 m->confirm_spawn = false;
2388
2389 if (dual_timestamp_is_set(&m->finish_timestamp))
2390 return;
2391
2392 dual_timestamp_get(&m->finish_timestamp);
2393
2394 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2395
2396 /* Note that m->kernel_usec.monotonic is always at 0,
2397 * and m->firmware_usec.monotonic and
2398 * m->loader_usec.monotonic should be considered
2399 * negative values. */
2400
2401 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2402 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2403 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2404 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2405
2406 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2407
2408 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2409 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2410
2411 if (!log_on_console())
2412 log_struct(LOG_INFO,
2413 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2414 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2415 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2416 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2417 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2418 format_timespan(kernel, sizeof(kernel), kernel_usec),
2419 format_timespan(initrd, sizeof(initrd), initrd_usec),
2420 format_timespan(userspace, sizeof(userspace), userspace_usec),
2421 format_timespan(sum, sizeof(sum), total_usec),
2422 NULL);
2423 } else {
2424 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2425 initrd_usec = 0;
2426
2427 if (!log_on_console())
2428 log_struct(LOG_INFO,
2429 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2430 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2431 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2432 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2433 format_timespan(kernel, sizeof(kernel), kernel_usec),
2434 format_timespan(userspace, sizeof(userspace), userspace_usec),
2435 format_timespan(sum, sizeof(sum), total_usec),
2436 NULL);
2437 }
2438 } else {
2439 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2440 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2441
2442 if (!log_on_console())
2443 log_struct(LOG_INFO,
2444 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2445 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2446 "MESSAGE=Startup finished in %s.",
2447 format_timespan(sum, sizeof(sum), total_usec),
2448 NULL);
2449 }
2450
2451 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2452
2453 sd_notifyf(false,
2454 "READY=1\nSTATUS=Startup finished in %s.",
2455 format_timespan(sum, sizeof(sum), total_usec));
2456 }
2457
2458 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2459 char *p;
2460 int r;
2461
2462 assert(m);
2463 assert(generator);
2464 assert(name);
2465
2466 if (*generator)
2467 return 0;
2468
2469 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2470
2471 p = strappend("/run/systemd/", name);
2472 if (!p)
2473 return log_oom();
2474
2475 r = mkdir_p_label(p, 0755);
2476 if (r < 0) {
2477 log_error("Failed to create generator directory %s: %s",
2478 p, strerror(-r));
2479 free(p);
2480 return r;
2481 }
2482 } else {
2483 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2484 if (!p)
2485 return log_oom();
2486
2487 if (!mkdtemp(p)) {
2488 log_error("Failed to create generator directory %s: %m",
2489 p);
2490 free(p);
2491 return -errno;
2492 }
2493 }
2494
2495 *generator = p;
2496 return 0;
2497 }
2498
2499 static void trim_generator_dir(Manager *m, char **generator) {
2500 assert(m);
2501 assert(generator);
2502
2503 if (!*generator)
2504 return;
2505
2506 if (rmdir(*generator) >= 0) {
2507 free(*generator);
2508 *generator = NULL;
2509 }
2510
2511 return;
2512 }
2513
2514 void manager_run_generators(Manager *m) {
2515 DIR *d = NULL;
2516 const char *generator_path;
2517 const char *argv[5];
2518 mode_t u;
2519 int r;
2520
2521 assert(m);
2522
2523 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2524 d = opendir(generator_path);
2525 if (!d) {
2526 if (errno == ENOENT)
2527 return;
2528
2529 log_error("Failed to enumerate generator directory %s: %m",
2530 generator_path);
2531 return;
2532 }
2533
2534 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2535 if (r < 0)
2536 goto finish;
2537
2538 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2539 if (r < 0)
2540 goto finish;
2541
2542 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2543 if (r < 0)
2544 goto finish;
2545
2546 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2547 argv[1] = m->generator_unit_path;
2548 argv[2] = m->generator_unit_path_early;
2549 argv[3] = m->generator_unit_path_late;
2550 argv[4] = NULL;
2551
2552 u = umask(0022);
2553 execute_directory(generator_path, d, (char**) argv);
2554 umask(u);
2555
2556 trim_generator_dir(m, &m->generator_unit_path);
2557 trim_generator_dir(m, &m->generator_unit_path_early);
2558 trim_generator_dir(m, &m->generator_unit_path_late);
2559
2560 finish:
2561 if (d)
2562 closedir(d);
2563 }
2564
2565 static void remove_generator_dir(Manager *m, char **generator) {
2566 assert(m);
2567 assert(generator);
2568
2569 if (!*generator)
2570 return;
2571
2572 strv_remove(m->lookup_paths.unit_path, *generator);
2573 rm_rf(*generator, false, true, false);
2574
2575 free(*generator);
2576 *generator = NULL;
2577 }
2578
2579 void manager_undo_generators(Manager *m) {
2580 assert(m);
2581
2582 remove_generator_dir(m, &m->generator_unit_path);
2583 remove_generator_dir(m, &m->generator_unit_path_early);
2584 remove_generator_dir(m, &m->generator_unit_path_late);
2585 }
2586
2587 int manager_set_default_controllers(Manager *m, char **controllers) {
2588 char **l;
2589
2590 assert(m);
2591
2592 l = strv_copy(controllers);
2593 if (!l)
2594 return -ENOMEM;
2595
2596 strv_free(m->default_controllers);
2597 m->default_controllers = l;
2598
2599 cg_shorten_controllers(m->default_controllers);
2600
2601 return 0;
2602 }
2603
2604 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2605 int i;
2606
2607 assert(m);
2608
2609 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2610 if (!default_rlimit[i])
2611 continue;
2612
2613 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2614 if (!m->rlimit[i])
2615 return -ENOMEM;
2616 }
2617
2618 return 0;
2619 }
2620
2621 void manager_recheck_journal(Manager *m) {
2622 Unit *u;
2623
2624 assert(m);
2625
2626 if (m->running_as != SYSTEMD_SYSTEM)
2627 return;
2628
2629 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2630 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2631 log_close_journal();
2632 return;
2633 }
2634
2635 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2636 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2637 log_close_journal();
2638 return;
2639 }
2640
2641 /* Hmm, OK, so the socket is fully up and the service is up
2642 * too, then let's make use of the thing. */
2643 log_open();
2644 }
2645
2646 void manager_set_show_status(Manager *m, bool b) {
2647 assert(m);
2648
2649 if (m->running_as != SYSTEMD_SYSTEM)
2650 return;
2651
2652 m->show_status = b;
2653
2654 if (b)
2655 touch("/run/systemd/show-status");
2656 else
2657 unlink("/run/systemd/show-status");
2658 }
2659
2660 static bool manager_get_show_status(Manager *m) {
2661 assert(m);
2662
2663 if (m->running_as != SYSTEMD_SYSTEM)
2664 return false;
2665
2666 if (m->show_status)
2667 return true;
2668
2669 /* If Plymouth is running make sure we show the status, so
2670 * that there's something nice to see when people press Esc */
2671
2672 return plymouth_running();
2673 }
2674
2675 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2676 va_list ap;
2677
2678 if (!manager_get_show_status(m))
2679 return;
2680
2681 /* XXX We should totally drop the check for ephemeral here
2682 * and thus effectively make 'Type=idle' pointless. */
2683 if (ephemeral && m->n_on_console > 0)
2684 return;
2685
2686 if (!manager_is_booting_or_shutting_down(m))
2687 return;
2688
2689 va_start(ap, format);
2690 status_vprintf(status, true, ephemeral, format, ap);
2691 va_end(ap);
2692 }
2693
2694 void watch_init(Watch *w) {
2695 assert(w);
2696
2697 w->type = WATCH_INVALID;
2698 w->fd = -1;
2699 }
Unnamed repository; edit this file 'description' to name the repository.