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