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