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