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