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