]> 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
util-lib: split out allocation calls into alloc-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 <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, 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 Manager *m = userdata;
1513 ssize_t n;
1514 int r;
1515
1516 assert(m);
1517 assert(m->notify_fd == fd);
1518
1519 if (revents != EPOLLIN) {
1520 log_warning("Got unexpected poll event for notify fd.");
1521 return 0;
1522 }
1523
1524 for (;;) {
1525 _cleanup_fdset_free_ FDSet *fds = NULL;
1526 char buf[NOTIFY_BUFFER_MAX+1];
1527 struct iovec iovec = {
1528 .iov_base = buf,
1529 .iov_len = sizeof(buf)-1,
1530 };
1531 union {
1532 struct cmsghdr cmsghdr;
1533 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1534 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1535 } control = {};
1536 struct msghdr msghdr = {
1537 .msg_iov = &iovec,
1538 .msg_iovlen = 1,
1539 .msg_control = &control,
1540 .msg_controllen = sizeof(control),
1541 };
1542 struct cmsghdr *cmsg;
1543 struct ucred *ucred = NULL;
1544 bool found = false;
1545 Unit *u1, *u2, *u3;
1546 int *fd_array = NULL;
1547 unsigned n_fds = 0;
1548
1549 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1550 if (n < 0) {
1551 if (errno == EAGAIN || errno == EINTR)
1552 break;
1553
1554 return -errno;
1555 }
1556
1557 CMSG_FOREACH(cmsg, &msghdr) {
1558 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1559
1560 fd_array = (int*) CMSG_DATA(cmsg);
1561 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1562
1563 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1564 cmsg->cmsg_type == SCM_CREDENTIALS &&
1565 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1566
1567 ucred = (struct ucred*) CMSG_DATA(cmsg);
1568 }
1569 }
1570
1571 if (n_fds > 0) {
1572 assert(fd_array);
1573
1574 r = fdset_new_array(&fds, fd_array, n_fds);
1575 if (r < 0) {
1576 close_many(fd_array, n_fds);
1577 return log_oom();
1578 }
1579 }
1580
1581 if (!ucred || ucred->pid <= 0) {
1582 log_warning("Received notify message without valid credentials. Ignoring.");
1583 continue;
1584 }
1585
1586 if ((size_t) n >= sizeof(buf)) {
1587 log_warning("Received notify message exceeded maximum size. Ignoring.");
1588 continue;
1589 }
1590
1591 buf[n] = 0;
1592
1593 /* Notify every unit that might be interested, but try
1594 * to avoid notifying the same one multiple times. */
1595 u1 = manager_get_unit_by_pid_cgroup(m, ucred->pid);
1596 if (u1) {
1597 manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1598 found = true;
1599 }
1600
1601 u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(ucred->pid));
1602 if (u2 && u2 != u1) {
1603 manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1604 found = true;
1605 }
1606
1607 u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(ucred->pid));
1608 if (u3 && u3 != u2 && u3 != u1) {
1609 manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1610 found = true;
1611 }
1612
1613 if (!found)
1614 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1615
1616 if (fdset_size(fds) > 0)
1617 log_warning("Got auxiliary fds with notification message, closing all.");
1618 }
1619
1620 return 0;
1621 }
1622
1623 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1624 assert(m);
1625 assert(u);
1626 assert(si);
1627
1628 log_unit_debug(u, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1629
1630 unit_unwatch_pid(u, si->si_pid);
1631 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1632 }
1633
1634 static int manager_dispatch_sigchld(Manager *m) {
1635 assert(m);
1636
1637 for (;;) {
1638 siginfo_t si = {};
1639
1640 /* First we call waitd() for a PID and do not reap the
1641 * zombie. That way we can still access /proc/$PID for
1642 * it while it is a zombie. */
1643 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1644
1645 if (errno == ECHILD)
1646 break;
1647
1648 if (errno == EINTR)
1649 continue;
1650
1651 return -errno;
1652 }
1653
1654 if (si.si_pid <= 0)
1655 break;
1656
1657 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1658 _cleanup_free_ char *name = NULL;
1659 Unit *u1, *u2, *u3;
1660
1661 get_process_comm(si.si_pid, &name);
1662
1663 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1664 si.si_pid, strna(name),
1665 sigchld_code_to_string(si.si_code),
1666 si.si_status,
1667 strna(si.si_code == CLD_EXITED
1668 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1669 : signal_to_string(si.si_status)));
1670
1671 /* And now figure out the unit this belongs
1672 * to, it might be multiple... */
1673 u1 = manager_get_unit_by_pid_cgroup(m, si.si_pid);
1674 if (u1)
1675 invoke_sigchld_event(m, u1, &si);
1676 u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(si.si_pid));
1677 if (u2 && u2 != u1)
1678 invoke_sigchld_event(m, u2, &si);
1679 u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(si.si_pid));
1680 if (u3 && u3 != u2 && u3 != u1)
1681 invoke_sigchld_event(m, u3, &si);
1682 }
1683
1684 /* And now, we actually reap the zombie. */
1685 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1686 if (errno == EINTR)
1687 continue;
1688
1689 return -errno;
1690 }
1691 }
1692
1693 return 0;
1694 }
1695
1696 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1697 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1698 int r;
1699
1700 log_debug("Activating special unit %s", name);
1701
1702 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1703 if (r < 0)
1704 log_error("Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1705
1706 return r;
1707 }
1708
1709 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1710 Manager *m = userdata;
1711 ssize_t n;
1712 struct signalfd_siginfo sfsi;
1713 bool sigchld = false;
1714 int r;
1715
1716 assert(m);
1717 assert(m->signal_fd == fd);
1718
1719 if (revents != EPOLLIN) {
1720 log_warning("Got unexpected events from signal file descriptor.");
1721 return 0;
1722 }
1723
1724 for (;;) {
1725 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1726 if (n != sizeof(sfsi)) {
1727
1728 if (n >= 0)
1729 return -EIO;
1730
1731 if (errno == EINTR || errno == EAGAIN)
1732 break;
1733
1734 return -errno;
1735 }
1736
1737 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1738 (sfsi.ssi_signo == SIGTERM && m->running_as == MANAGER_USER)
1739 ? LOG_DEBUG : LOG_INFO,
1740 &sfsi);
1741
1742 switch (sfsi.ssi_signo) {
1743
1744 case SIGCHLD:
1745 sigchld = true;
1746 break;
1747
1748 case SIGTERM:
1749 if (m->running_as == MANAGER_SYSTEM) {
1750 /* This is for compatibility with the
1751 * original sysvinit */
1752 m->exit_code = MANAGER_REEXECUTE;
1753 break;
1754 }
1755
1756 /* Fall through */
1757
1758 case SIGINT:
1759 if (m->running_as == MANAGER_SYSTEM) {
1760
1761 /* If the user presses C-A-D more than
1762 * 7 times within 2s, we reboot
1763 * immediately. */
1764
1765 if (ratelimit_test(&m->ctrl_alt_del_ratelimit))
1766 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1767 else {
1768 log_notice("Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1769 status_printf(NULL, true, false, "Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1770 m->exit_code = MANAGER_REBOOT;
1771 }
1772
1773 break;
1774 }
1775
1776 /* Run the exit target if there is one, if not, just exit. */
1777 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1778 m->exit_code = MANAGER_EXIT;
1779 return 0;
1780 }
1781
1782 break;
1783
1784 case SIGWINCH:
1785 if (m->running_as == MANAGER_SYSTEM)
1786 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1787
1788 /* This is a nop on non-init */
1789 break;
1790
1791 case SIGPWR:
1792 if (m->running_as == MANAGER_SYSTEM)
1793 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1794
1795 /* This is a nop on non-init */
1796 break;
1797
1798 case SIGUSR1: {
1799 Unit *u;
1800
1801 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1802
1803 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1804 log_info("Trying to reconnect to bus...");
1805 bus_init(m, true);
1806 }
1807
1808 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1809 log_info("Loading D-Bus service...");
1810 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1811 }
1812
1813 break;
1814 }
1815
1816 case SIGUSR2: {
1817 _cleanup_free_ char *dump = NULL;
1818 _cleanup_fclose_ FILE *f = NULL;
1819 size_t size;
1820
1821 f = open_memstream(&dump, &size);
1822 if (!f) {
1823 log_warning_errno(errno, "Failed to allocate memory stream: %m");
1824 break;
1825 }
1826
1827 manager_dump_units(m, f, "\t");
1828 manager_dump_jobs(m, f, "\t");
1829
1830 r = fflush_and_check(f);
1831 if (r < 0) {
1832 log_warning_errno(r, "Failed to write status stream: %m");
1833 break;
1834 }
1835
1836 log_dump(LOG_INFO, dump);
1837 break;
1838 }
1839
1840 case SIGHUP:
1841 m->exit_code = MANAGER_RELOAD;
1842 break;
1843
1844 default: {
1845
1846 /* Starting SIGRTMIN+0 */
1847 static const char * const target_table[] = {
1848 [0] = SPECIAL_DEFAULT_TARGET,
1849 [1] = SPECIAL_RESCUE_TARGET,
1850 [2] = SPECIAL_EMERGENCY_TARGET,
1851 [3] = SPECIAL_HALT_TARGET,
1852 [4] = SPECIAL_POWEROFF_TARGET,
1853 [5] = SPECIAL_REBOOT_TARGET,
1854 [6] = SPECIAL_KEXEC_TARGET
1855 };
1856
1857 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1858 static const ManagerExitCode code_table[] = {
1859 [0] = MANAGER_HALT,
1860 [1] = MANAGER_POWEROFF,
1861 [2] = MANAGER_REBOOT,
1862 [3] = MANAGER_KEXEC
1863 };
1864
1865 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1866 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1867 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1868 manager_start_target(m, target_table[idx],
1869 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1870 break;
1871 }
1872
1873 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1874 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1875 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1876 break;
1877 }
1878
1879 switch (sfsi.ssi_signo - SIGRTMIN) {
1880
1881 case 20:
1882 log_debug("Enabling showing of status.");
1883 manager_set_show_status(m, SHOW_STATUS_YES);
1884 break;
1885
1886 case 21:
1887 log_debug("Disabling showing of status.");
1888 manager_set_show_status(m, SHOW_STATUS_NO);
1889 break;
1890
1891 case 22:
1892 log_set_max_level(LOG_DEBUG);
1893 log_notice("Setting log level to debug.");
1894 break;
1895
1896 case 23:
1897 log_set_max_level(LOG_INFO);
1898 log_notice("Setting log level to info.");
1899 break;
1900
1901 case 24:
1902 if (m->running_as == MANAGER_USER) {
1903 m->exit_code = MANAGER_EXIT;
1904 return 0;
1905 }
1906
1907 /* This is a nop on init */
1908 break;
1909
1910 case 26:
1911 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1912 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1913 log_notice("Setting log target to journal-or-kmsg.");
1914 break;
1915
1916 case 27:
1917 log_set_target(LOG_TARGET_CONSOLE);
1918 log_notice("Setting log target to console.");
1919 break;
1920
1921 case 28:
1922 log_set_target(LOG_TARGET_KMSG);
1923 log_notice("Setting log target to kmsg.");
1924 break;
1925
1926 default:
1927 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1928 }
1929 }
1930 }
1931 }
1932
1933 if (sigchld)
1934 manager_dispatch_sigchld(m);
1935
1936 return 0;
1937 }
1938
1939 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1940 Manager *m = userdata;
1941 Iterator i;
1942 Unit *u;
1943
1944 assert(m);
1945 assert(m->time_change_fd == fd);
1946
1947 log_struct(LOG_INFO,
1948 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1949 LOG_MESSAGE("Time has been changed"),
1950 NULL);
1951
1952 /* Restart the watch */
1953 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1954 m->time_change_fd = safe_close(m->time_change_fd);
1955
1956 manager_setup_time_change(m);
1957
1958 HASHMAP_FOREACH(u, m->units, i)
1959 if (UNIT_VTABLE(u)->time_change)
1960 UNIT_VTABLE(u)->time_change(u);
1961
1962 return 0;
1963 }
1964
1965 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1966 Manager *m = userdata;
1967
1968 assert(m);
1969 assert(m->idle_pipe[2] == fd);
1970
1971 m->no_console_output = m->n_on_console > 0;
1972
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 == MANAGER_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 == MANAGER_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, r;
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 != MANAGER_SYSTEM)
2126 return;
2127
2128 if (u->type != UNIT_SERVICE)
2129 return;
2130
2131 r = unit_name_to_prefix_and_instance(u->id, &p);
2132 if (r < 0) {
2133 log_error_errno(r, "Failed to extract prefix and instance of unit name: %m");
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 != MANAGER_SYSTEM)
2163 return;
2164
2165 if (detect_container() > 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 int manager_open_serialization(Manager *m, FILE **_f) {
2200 const char *path;
2201 int fd = -1;
2202 FILE *f;
2203
2204 assert(_f);
2205
2206 path = m->running_as == MANAGER_SYSTEM ? "/run/systemd" : "/tmp";
2207 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2208 if (fd < 0)
2209 return -errno;
2210
2211 log_debug("Serializing state to %s", path);
2212
2213 f = fdopen(fd, "w+");
2214 if (!f) {
2215 safe_close(fd);
2216 return -errno;
2217 }
2218
2219 *_f = f;
2220
2221 return 0;
2222 }
2223
2224 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2225 Iterator i;
2226 Unit *u;
2227 const char *t;
2228 char **e;
2229 int r;
2230
2231 assert(m);
2232 assert(f);
2233 assert(fds);
2234
2235 m->n_reloading ++;
2236
2237 fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2238 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2239 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2240 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2241
2242 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2243 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2244 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2245 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2246
2247 if (!in_initrd()) {
2248 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2249 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2250 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2251 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2252 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2253 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2254 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2255 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2256 }
2257
2258 if (!switching_root) {
2259 STRV_FOREACH(e, m->environment) {
2260 _cleanup_free_ char *ce;
2261
2262 ce = cescape(*e);
2263 if (!ce)
2264 return -ENOMEM;
2265
2266 fprintf(f, "env=%s\n", *e);
2267 }
2268 }
2269
2270 if (m->notify_fd >= 0) {
2271 int copy;
2272
2273 copy = fdset_put_dup(fds, m->notify_fd);
2274 if (copy < 0)
2275 return copy;
2276
2277 fprintf(f, "notify-fd=%i\n", copy);
2278 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2279 }
2280
2281 if (m->kdbus_fd >= 0) {
2282 int copy;
2283
2284 copy = fdset_put_dup(fds, m->kdbus_fd);
2285 if (copy < 0)
2286 return copy;
2287
2288 fprintf(f, "kdbus-fd=%i\n", copy);
2289 }
2290
2291 bus_track_serialize(m->subscribed, f);
2292
2293 fputc('\n', f);
2294
2295 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2296 if (u->id != t)
2297 continue;
2298
2299 /* Start marker */
2300 fputs(u->id, f);
2301 fputc('\n', f);
2302
2303 r = unit_serialize(u, f, fds, !switching_root);
2304 if (r < 0) {
2305 m->n_reloading --;
2306 return r;
2307 }
2308 }
2309
2310 assert(m->n_reloading > 0);
2311 m->n_reloading --;
2312
2313 if (ferror(f))
2314 return -EIO;
2315
2316 r = bus_fdset_add_all(m, fds);
2317 if (r < 0)
2318 return r;
2319
2320 return 0;
2321 }
2322
2323 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2324 int r = 0;
2325
2326 assert(m);
2327 assert(f);
2328
2329 log_debug("Deserializing state...");
2330
2331 m->n_reloading ++;
2332
2333 for (;;) {
2334 char line[LINE_MAX], *l;
2335
2336 if (!fgets(line, sizeof(line), f)) {
2337 if (feof(f))
2338 r = 0;
2339 else
2340 r = -errno;
2341
2342 goto finish;
2343 }
2344
2345 char_array_0(line);
2346 l = strstrip(line);
2347
2348 if (l[0] == 0)
2349 break;
2350
2351 if (startswith(l, "current-job-id=")) {
2352 uint32_t id;
2353
2354 if (safe_atou32(l+15, &id) < 0)
2355 log_debug("Failed to parse current job id value %s", l+15);
2356 else
2357 m->current_job_id = MAX(m->current_job_id, id);
2358
2359 } else if (startswith(l, "n-installed-jobs=")) {
2360 uint32_t n;
2361
2362 if (safe_atou32(l+17, &n) < 0)
2363 log_debug("Failed to parse installed jobs counter %s", l+17);
2364 else
2365 m->n_installed_jobs += n;
2366
2367 } else if (startswith(l, "n-failed-jobs=")) {
2368 uint32_t n;
2369
2370 if (safe_atou32(l+14, &n) < 0)
2371 log_debug("Failed to parse failed jobs counter %s", l+14);
2372 else
2373 m->n_failed_jobs += n;
2374
2375 } else if (startswith(l, "taint-usr=")) {
2376 int b;
2377
2378 b = parse_boolean(l+10);
2379 if (b < 0)
2380 log_debug("Failed to parse taint /usr flag %s", l+10);
2381 else
2382 m->taint_usr = m->taint_usr || b;
2383
2384 } else if (startswith(l, "firmware-timestamp="))
2385 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2386 else if (startswith(l, "loader-timestamp="))
2387 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2388 else if (startswith(l, "kernel-timestamp="))
2389 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2390 else if (startswith(l, "initrd-timestamp="))
2391 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2392 else if (startswith(l, "userspace-timestamp="))
2393 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2394 else if (startswith(l, "finish-timestamp="))
2395 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2396 else if (startswith(l, "security-start-timestamp="))
2397 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2398 else if (startswith(l, "security-finish-timestamp="))
2399 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2400 else if (startswith(l, "generators-start-timestamp="))
2401 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2402 else if (startswith(l, "generators-finish-timestamp="))
2403 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2404 else if (startswith(l, "units-load-start-timestamp="))
2405 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2406 else if (startswith(l, "units-load-finish-timestamp="))
2407 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2408 else if (startswith(l, "env=")) {
2409 _cleanup_free_ char *uce = NULL;
2410 char **e;
2411
2412 r = cunescape(l + 4, UNESCAPE_RELAX, &uce);
2413 if (r < 0)
2414 goto finish;
2415
2416 e = strv_env_set(m->environment, uce);
2417 if (!e) {
2418 r = -ENOMEM;
2419 goto finish;
2420 }
2421
2422 strv_free(m->environment);
2423 m->environment = e;
2424
2425 } else if (startswith(l, "notify-fd=")) {
2426 int fd;
2427
2428 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2429 log_debug("Failed to parse notify fd: %s", l + 10);
2430 else {
2431 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2432 safe_close(m->notify_fd);
2433 m->notify_fd = fdset_remove(fds, fd);
2434 }
2435
2436 } else if (startswith(l, "notify-socket=")) {
2437 char *n;
2438
2439 n = strdup(l+14);
2440 if (!n) {
2441 r = -ENOMEM;
2442 goto finish;
2443 }
2444
2445 free(m->notify_socket);
2446 m->notify_socket = n;
2447
2448 } else if (startswith(l, "kdbus-fd=")) {
2449 int fd;
2450
2451 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2452 log_debug("Failed to parse kdbus fd: %s", l + 9);
2453 else {
2454 safe_close(m->kdbus_fd);
2455 m->kdbus_fd = fdset_remove(fds, fd);
2456 }
2457
2458 } else {
2459 int k;
2460
2461 k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2462 if (k < 0)
2463 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2464 else if (k == 0)
2465 log_debug("Unknown serialization item '%s'", l);
2466 }
2467 }
2468
2469 for (;;) {
2470 Unit *u;
2471 char name[UNIT_NAME_MAX+2];
2472
2473 /* Start marker */
2474 if (!fgets(name, sizeof(name), f)) {
2475 if (feof(f))
2476 r = 0;
2477 else
2478 r = -errno;
2479
2480 goto finish;
2481 }
2482
2483 char_array_0(name);
2484
2485 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2486 if (r < 0)
2487 goto finish;
2488
2489 r = unit_deserialize(u, f, fds);
2490 if (r < 0)
2491 goto finish;
2492 }
2493
2494 finish:
2495 if (ferror(f))
2496 r = -EIO;
2497
2498 assert(m->n_reloading > 0);
2499 m->n_reloading --;
2500
2501 return r;
2502 }
2503
2504 int manager_reload(Manager *m) {
2505 int r, q;
2506 _cleanup_fclose_ FILE *f = NULL;
2507 _cleanup_fdset_free_ FDSet *fds = NULL;
2508
2509 assert(m);
2510
2511 r = manager_open_serialization(m, &f);
2512 if (r < 0)
2513 return r;
2514
2515 m->n_reloading ++;
2516 bus_manager_send_reloading(m, true);
2517
2518 fds = fdset_new();
2519 if (!fds) {
2520 m->n_reloading --;
2521 return -ENOMEM;
2522 }
2523
2524 r = manager_serialize(m, f, fds, false);
2525 if (r < 0) {
2526 m->n_reloading --;
2527 return r;
2528 }
2529
2530 if (fseeko(f, 0, SEEK_SET) < 0) {
2531 m->n_reloading --;
2532 return -errno;
2533 }
2534
2535 /* From here on there is no way back. */
2536 manager_clear_jobs_and_units(m);
2537 manager_undo_generators(m);
2538 lookup_paths_free(&m->lookup_paths);
2539
2540 /* Find new unit paths */
2541 q = manager_run_generators(m);
2542 if (q < 0 && r >= 0)
2543 r = q;
2544
2545 q = lookup_paths_init(
2546 &m->lookup_paths, m->running_as, true,
2547 NULL,
2548 m->generator_unit_path,
2549 m->generator_unit_path_early,
2550 m->generator_unit_path_late);
2551 if (q < 0 && r >= 0)
2552 r = q;
2553
2554 manager_build_unit_path_cache(m);
2555
2556 /* First, enumerate what we can from all config files */
2557 q = manager_enumerate(m);
2558 if (q < 0 && r >= 0)
2559 r = q;
2560
2561 /* Second, deserialize our stored data */
2562 q = manager_deserialize(m, f, fds);
2563 if (q < 0 && r >= 0)
2564 r = q;
2565
2566 fclose(f);
2567 f = NULL;
2568
2569 /* Re-register notify_fd as event source */
2570 q = manager_setup_notify(m);
2571 if (q < 0 && r >= 0)
2572 r = q;
2573
2574 /* Third, fire things up! */
2575 manager_coldplug(m);
2576
2577 assert(m->n_reloading > 0);
2578 m->n_reloading--;
2579
2580 m->send_reloading_done = true;
2581
2582 return r;
2583 }
2584
2585 bool manager_is_reloading_or_reexecuting(Manager *m) {
2586 assert(m);
2587
2588 return m->n_reloading != 0;
2589 }
2590
2591 void manager_reset_failed(Manager *m) {
2592 Unit *u;
2593 Iterator i;
2594
2595 assert(m);
2596
2597 HASHMAP_FOREACH(u, m->units, i)
2598 unit_reset_failed(u);
2599 }
2600
2601 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2602 Unit *u;
2603
2604 assert(m);
2605 assert(name);
2606
2607 /* Returns true if the unit is inactive or going down */
2608 u = manager_get_unit(m, name);
2609 if (!u)
2610 return true;
2611
2612 return unit_inactive_or_pending(u);
2613 }
2614
2615 static void manager_notify_finished(Manager *m) {
2616 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2617 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2618
2619 if (m->test_run)
2620 return;
2621
2622 if (m->running_as == MANAGER_SYSTEM && detect_container() <= 0) {
2623
2624 /* Note that m->kernel_usec.monotonic is always at 0,
2625 * and m->firmware_usec.monotonic and
2626 * m->loader_usec.monotonic should be considered
2627 * negative values. */
2628
2629 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2630 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2631 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2632 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2633
2634 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2635
2636 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2637 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2638
2639 log_struct(LOG_INFO,
2640 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2641 "KERNEL_USEC="USEC_FMT, kernel_usec,
2642 "INITRD_USEC="USEC_FMT, initrd_usec,
2643 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2644 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2645 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2646 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2647 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2648 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2649 NULL);
2650 } else {
2651 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2652 initrd_usec = 0;
2653
2654 log_struct(LOG_INFO,
2655 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2656 "KERNEL_USEC="USEC_FMT, kernel_usec,
2657 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2658 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2659 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2660 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2661 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2662 NULL);
2663 }
2664 } else {
2665 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2666 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2667
2668 log_struct(LOG_INFO,
2669 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2670 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2671 LOG_MESSAGE("Startup finished in %s.",
2672 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2673 NULL);
2674 }
2675
2676 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2677
2678 sd_notifyf(false,
2679 "READY=1\n"
2680 "STATUS=Startup finished in %s.",
2681 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2682 }
2683
2684 void manager_check_finished(Manager *m) {
2685 assert(m);
2686
2687 if (m->n_reloading > 0)
2688 return;
2689
2690 /* Verify that we are actually running currently. Initially
2691 * the exit code is set to invalid, and during operation it is
2692 * then set to MANAGER_OK */
2693 if (m->exit_code != MANAGER_OK)
2694 return;
2695
2696 if (hashmap_size(m->jobs) > 0) {
2697 if (m->jobs_in_progress_event_source)
2698 /* Ignore any failure, this is only for feedback */
2699 (void) sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2700
2701 return;
2702 }
2703
2704 manager_flip_auto_status(m, false);
2705
2706 /* Notify Type=idle units that we are done now */
2707 manager_close_idle_pipe(m);
2708
2709 /* Turn off confirm spawn now */
2710 m->confirm_spawn = false;
2711
2712 /* No need to update ask password status when we're going non-interactive */
2713 manager_close_ask_password(m);
2714
2715 /* This is no longer the first boot */
2716 manager_set_first_boot(m, false);
2717
2718 if (dual_timestamp_is_set(&m->finish_timestamp))
2719 return;
2720
2721 dual_timestamp_get(&m->finish_timestamp);
2722
2723 manager_notify_finished(m);
2724
2725 manager_invalidate_startup_units(m);
2726 }
2727
2728 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2729 char *p;
2730 int r;
2731
2732 assert(m);
2733 assert(generator);
2734 assert(name);
2735
2736 if (*generator)
2737 return 0;
2738
2739 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2740 /* systemd --system, not running --test */
2741
2742 p = strappend("/run/systemd/", name);
2743 if (!p)
2744 return log_oom();
2745
2746 r = mkdir_p_label(p, 0755);
2747 if (r < 0) {
2748 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2749 free(p);
2750 return r;
2751 }
2752 } else if (m->running_as == MANAGER_USER) {
2753 const char *s = NULL;
2754
2755 s = getenv("XDG_RUNTIME_DIR");
2756 if (!s)
2757 return -EINVAL;
2758 p = strjoin(s, "/systemd/", name, NULL);
2759 if (!p)
2760 return log_oom();
2761
2762 r = mkdir_p_label(p, 0755);
2763 if (r < 0) {
2764 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2765 free(p);
2766 return r;
2767 }
2768 } else {
2769 /* systemd --system --test */
2770
2771 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2772 if (!p)
2773 return log_oom();
2774
2775 if (!mkdtemp(p)) {
2776 log_error_errno(errno, "Failed to create generator directory %s: %m",
2777 p);
2778 free(p);
2779 return -errno;
2780 }
2781 }
2782
2783 *generator = p;
2784 return 0;
2785 }
2786
2787 static void trim_generator_dir(Manager *m, char **generator) {
2788 assert(m);
2789 assert(generator);
2790
2791 if (!*generator)
2792 return;
2793
2794 if (rmdir(*generator) >= 0)
2795 *generator = mfree(*generator);
2796
2797 return;
2798 }
2799
2800 static int manager_run_generators(Manager *m) {
2801 _cleanup_strv_free_ char **paths = NULL;
2802 const char *argv[5];
2803 char **path;
2804 int r;
2805
2806 assert(m);
2807
2808 if (m->test_run)
2809 return 0;
2810
2811 paths = generator_paths(m->running_as);
2812 if (!paths)
2813 return log_oom();
2814
2815 /* Optimize by skipping the whole process by not creating output directories
2816 * if no generators are found. */
2817 STRV_FOREACH(path, paths) {
2818 r = access(*path, F_OK);
2819 if (r == 0)
2820 goto found;
2821 if (errno != ENOENT)
2822 log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2823 }
2824 return 0;
2825
2826 found:
2827 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2828 if (r < 0)
2829 goto finish;
2830
2831 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2832 if (r < 0)
2833 goto finish;
2834
2835 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2836 if (r < 0)
2837 goto finish;
2838
2839 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2840 argv[1] = m->generator_unit_path;
2841 argv[2] = m->generator_unit_path_early;
2842 argv[3] = m->generator_unit_path_late;
2843 argv[4] = NULL;
2844
2845 RUN_WITH_UMASK(0022)
2846 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2847
2848 finish:
2849 trim_generator_dir(m, &m->generator_unit_path);
2850 trim_generator_dir(m, &m->generator_unit_path_early);
2851 trim_generator_dir(m, &m->generator_unit_path_late);
2852 return r;
2853 }
2854
2855 static void remove_generator_dir(Manager *m, char **generator) {
2856 assert(m);
2857 assert(generator);
2858
2859 if (!*generator)
2860 return;
2861
2862 strv_remove(m->lookup_paths.unit_path, *generator);
2863 (void) rm_rf(*generator, REMOVE_ROOT);
2864
2865 *generator = mfree(*generator);
2866 }
2867
2868 static void manager_undo_generators(Manager *m) {
2869 assert(m);
2870
2871 remove_generator_dir(m, &m->generator_unit_path);
2872 remove_generator_dir(m, &m->generator_unit_path_early);
2873 remove_generator_dir(m, &m->generator_unit_path_late);
2874 }
2875
2876 int manager_environment_add(Manager *m, char **minus, char **plus) {
2877 char **a = NULL, **b = NULL, **l;
2878 assert(m);
2879
2880 l = m->environment;
2881
2882 if (!strv_isempty(minus)) {
2883 a = strv_env_delete(l, 1, minus);
2884 if (!a)
2885 return -ENOMEM;
2886
2887 l = a;
2888 }
2889
2890 if (!strv_isempty(plus)) {
2891 b = strv_env_merge(2, l, plus);
2892 if (!b) {
2893 strv_free(a);
2894 return -ENOMEM;
2895 }
2896
2897 l = b;
2898 }
2899
2900 if (m->environment != l)
2901 strv_free(m->environment);
2902 if (a != l)
2903 strv_free(a);
2904 if (b != l)
2905 strv_free(b);
2906
2907 m->environment = l;
2908 manager_clean_environment(m);
2909 strv_sort(m->environment);
2910
2911 return 0;
2912 }
2913
2914 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2915 int i;
2916
2917 assert(m);
2918
2919 for (i = 0; i < _RLIMIT_MAX; i++) {
2920 if (!default_rlimit[i])
2921 continue;
2922
2923 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2924 if (!m->rlimit[i])
2925 return -ENOMEM;
2926 }
2927
2928 return 0;
2929 }
2930
2931 void manager_recheck_journal(Manager *m) {
2932 Unit *u;
2933
2934 assert(m);
2935
2936 if (m->running_as != MANAGER_SYSTEM)
2937 return;
2938
2939 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2940 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2941 log_close_journal();
2942 return;
2943 }
2944
2945 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2946 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2947 log_close_journal();
2948 return;
2949 }
2950
2951 /* Hmm, OK, so the socket is fully up and the service is up
2952 * too, then let's make use of the thing. */
2953 log_open();
2954 }
2955
2956 void manager_set_show_status(Manager *m, ShowStatus mode) {
2957 assert(m);
2958 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2959
2960 if (m->running_as != MANAGER_SYSTEM)
2961 return;
2962
2963 m->show_status = mode;
2964
2965 if (mode > 0)
2966 (void) touch("/run/systemd/show-status");
2967 else
2968 (void) unlink("/run/systemd/show-status");
2969 }
2970
2971 static bool manager_get_show_status(Manager *m, StatusType type) {
2972 assert(m);
2973
2974 if (m->running_as != MANAGER_SYSTEM)
2975 return false;
2976
2977 if (m->no_console_output)
2978 return false;
2979
2980 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2981 return false;
2982
2983 /* If we cannot find out the status properly, just proceed. */
2984 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2985 return false;
2986
2987 if (m->show_status > 0)
2988 return true;
2989
2990 return false;
2991 }
2992
2993 void manager_set_first_boot(Manager *m, bool b) {
2994 assert(m);
2995
2996 if (m->running_as != MANAGER_SYSTEM)
2997 return;
2998
2999 if (m->first_boot != (int) b) {
3000 if (b)
3001 (void) touch("/run/systemd/first-boot");
3002 else
3003 (void) unlink("/run/systemd/first-boot");
3004 }
3005
3006 m->first_boot = b;
3007 }
3008
3009 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3010 va_list ap;
3011
3012 /* If m is NULL, assume we're after shutdown and let the messages through. */
3013
3014 if (m && !manager_get_show_status(m, type))
3015 return;
3016
3017 /* XXX We should totally drop the check for ephemeral here
3018 * and thus effectively make 'Type=idle' pointless. */
3019 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3020 return;
3021
3022 va_start(ap, format);
3023 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3024 va_end(ap);
3025 }
3026
3027 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3028 char p[strlen(path)+1];
3029
3030 assert(m);
3031 assert(path);
3032
3033 strcpy(p, path);
3034 path_kill_slashes(p);
3035
3036 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3037 }
3038
3039 const char *manager_get_runtime_prefix(Manager *m) {
3040 assert(m);
3041
3042 return m->running_as == MANAGER_SYSTEM ?
3043 "/run" :
3044 getenv("XDG_RUNTIME_DIR");
3045 }
3046
3047 int manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3048 unsigned size;
3049 int r;
3050
3051 assert(m);
3052 assert(u->manager == m);
3053
3054 size = set_size(m->failed_units);
3055
3056 if (failed) {
3057 r = set_ensure_allocated(&m->failed_units, NULL);
3058 if (r < 0)
3059 return log_oom();
3060
3061 if (set_put(m->failed_units, u) < 0)
3062 return log_oom();
3063 } else
3064 (void) set_remove(m->failed_units, u);
3065
3066 if (set_size(m->failed_units) != size)
3067 bus_manager_send_change_signal(m);
3068
3069 return 0;
3070 }
3071
3072 ManagerState manager_state(Manager *m) {
3073 Unit *u;
3074
3075 assert(m);
3076
3077 /* Did we ever finish booting? If not then we are still starting up */
3078 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3079
3080 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3081 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3082 return MANAGER_INITIALIZING;
3083
3084 return MANAGER_STARTING;
3085 }
3086
3087 /* Is the special shutdown target queued? If so, we are in shutdown state */
3088 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3089 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3090 return MANAGER_STOPPING;
3091
3092 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3093 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3094 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3095 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3096 return MANAGER_MAINTENANCE;
3097
3098 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3099 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3100 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3101 return MANAGER_MAINTENANCE;
3102
3103 /* Are there any failed units? If so, we are in degraded mode */
3104 if (set_size(m->failed_units) > 0)
3105 return MANAGER_DEGRADED;
3106
3107 return MANAGER_RUNNING;
3108 }
3109
3110 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3111 [MANAGER_INITIALIZING] = "initializing",
3112 [MANAGER_STARTING] = "starting",
3113 [MANAGER_RUNNING] = "running",
3114 [MANAGER_DEGRADED] = "degraded",
3115 [MANAGER_MAINTENANCE] = "maintenance",
3116 [MANAGER_STOPPING] = "stopping",
3117 };
3118
3119 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
Unnamed repository; edit this file 'description' to name the repository.