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