]> 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
Merge pull request #7360 from poettering/preset-fix
[thirdparty/systemd.git] / src / core / manager.c
1 /***
2 This file is part of systemd.
3
4 Copyright 2010 Lennart Poettering
5
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
10
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <linux/kd.h>
23 #include <signal.h>
24 #include <string.h>
25 #include <sys/epoll.h>
26 #include <sys/inotify.h>
27 #include <sys/ioctl.h>
28 #include <sys/reboot.h>
29 #include <sys/timerfd.h>
30 #include <sys/wait.h>
31 #include <unistd.h>
32
33 #if HAVE_AUDIT
34 #include <libaudit.h>
35 #endif
36
37 #include "sd-daemon.h"
38 #include "sd-messages.h"
39 #include "sd-path.h"
40
41 #include "alloc-util.h"
42 #include "audit-fd.h"
43 #include "boot-timestamps.h"
44 #include "bus-common-errors.h"
45 #include "bus-error.h"
46 #include "bus-kernel.h"
47 #include "bus-util.h"
48 #include "clean-ipc.h"
49 #include "dbus-job.h"
50 #include "dbus-manager.h"
51 #include "dbus-unit.h"
52 #include "dbus.h"
53 #include "dirent-util.h"
54 #include "env-util.h"
55 #include "escape.h"
56 #include "exec-util.h"
57 #include "execute.h"
58 #include "exit-status.h"
59 #include "fd-util.h"
60 #include "fileio.h"
61 #include "fs-util.h"
62 #include "hashmap.h"
63 #include "io-util.h"
64 #include "label.h"
65 #include "locale-setup.h"
66 #include "log.h"
67 #include "macro.h"
68 #include "manager.h"
69 #include "missing.h"
70 #include "mkdir.h"
71 #include "parse-util.h"
72 #include "path-lookup.h"
73 #include "path-util.h"
74 #include "process-util.h"
75 #include "ratelimit.h"
76 #include "rm-rf.h"
77 #include "signal-util.h"
78 #include "special.h"
79 #include "stat-util.h"
80 #include "string-table.h"
81 #include "string-util.h"
82 #include "strv.h"
83 #include "terminal-util.h"
84 #include "time-util.h"
85 #include "transaction.h"
86 #include "umask-util.h"
87 #include "unit-name.h"
88 #include "user-util.h"
89 #include "util.h"
90 #include "virt.h"
91 #include "watchdog.h"
92
93 #define NOTIFY_RCVBUF_SIZE (8*1024*1024)
94 #define CGROUPS_AGENT_RCVBUF_SIZE (8*1024*1024)
95
96 /* Initial delay and the interval for printing status messages about running jobs */
97 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
98 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
99 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
100
101 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
102 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
103 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
104 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
105 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
106 static int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
107 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
108 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
109 static int manager_run_environment_generators(Manager *m);
110 static int manager_run_generators(Manager *m);
111
112 static void manager_watch_jobs_in_progress(Manager *m) {
113 usec_t next;
114 int r;
115
116 assert(m);
117
118 /* We do not want to show the cylon animation if the user
119 * needs to confirm service executions otherwise confirmation
120 * messages will be screwed by the cylon animation. */
121 if (!manager_is_confirm_spawn_disabled(m))
122 return;
123
124 if (m->jobs_in_progress_event_source)
125 return;
126
127 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
128 r = sd_event_add_time(
129 m->event,
130 &m->jobs_in_progress_event_source,
131 CLOCK_MONOTONIC,
132 next, 0,
133 manager_dispatch_jobs_in_progress, m);
134 if (r < 0)
135 return;
136
137 (void) sd_event_source_set_description(m->jobs_in_progress_event_source, "manager-jobs-in-progress");
138 }
139
140 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED)-1) + sizeof(ANSI_HIGHLIGHT_RED)-1 + 2*(sizeof(ANSI_NORMAL)-1))
141
142 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
143 char *p = buffer;
144
145 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
146 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
147
148 if (pos > 1) {
149 if (pos > 2)
150 p = mempset(p, ' ', pos-2);
151 if (log_get_show_color())
152 p = stpcpy(p, ANSI_RED);
153 *p++ = '*';
154 }
155
156 if (pos > 0 && pos <= width) {
157 if (log_get_show_color())
158 p = stpcpy(p, ANSI_HIGHLIGHT_RED);
159 *p++ = '*';
160 }
161
162 if (log_get_show_color())
163 p = stpcpy(p, ANSI_NORMAL);
164
165 if (pos < width) {
166 if (log_get_show_color())
167 p = stpcpy(p, ANSI_RED);
168 *p++ = '*';
169 if (pos < width-1)
170 p = mempset(p, ' ', width-1-pos);
171 if (log_get_show_color())
172 strcpy(p, ANSI_NORMAL);
173 }
174 }
175
176 void manager_flip_auto_status(Manager *m, bool enable) {
177 assert(m);
178
179 if (enable) {
180 if (m->show_status == SHOW_STATUS_AUTO)
181 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
182 } else {
183 if (m->show_status == SHOW_STATUS_TEMPORARY)
184 manager_set_show_status(m, SHOW_STATUS_AUTO);
185 }
186 }
187
188 static void manager_print_jobs_in_progress(Manager *m) {
189 _cleanup_free_ char *job_of_n = NULL;
190 Iterator i;
191 Job *j;
192 unsigned counter = 0, print_nr;
193 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
194 unsigned cylon_pos;
195 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
196 uint64_t x;
197
198 assert(m);
199 assert(m->n_running_jobs > 0);
200
201 manager_flip_auto_status(m, true);
202
203 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
204
205 HASHMAP_FOREACH(j, m->jobs, i)
206 if (j->state == JOB_RUNNING && counter++ == print_nr)
207 break;
208
209 /* m->n_running_jobs must be consistent with the contents of m->jobs,
210 * so the above loop must have succeeded in finding j. */
211 assert(counter == print_nr + 1);
212 assert(j);
213
214 cylon_pos = m->jobs_in_progress_iteration % 14;
215 if (cylon_pos >= 8)
216 cylon_pos = 14 - cylon_pos;
217 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
218
219 m->jobs_in_progress_iteration++;
220
221 if (m->n_running_jobs > 1) {
222 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
223 job_of_n = NULL;
224 }
225
226 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
227 if (job_get_timeout(j, &x) > 0)
228 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
229
230 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
231 "%sA %s job is running for %s (%s / %s)",
232 strempty(job_of_n),
233 job_type_to_string(j->type),
234 unit_description(j->unit),
235 time, limit);
236 }
237
238 static int have_ask_password(void) {
239 _cleanup_closedir_ DIR *dir;
240 struct dirent *de;
241
242 dir = opendir("/run/systemd/ask-password");
243 if (!dir) {
244 if (errno == ENOENT)
245 return false;
246 else
247 return -errno;
248 }
249
250 FOREACH_DIRENT_ALL(de, dir, return -errno) {
251 if (startswith(de->d_name, "ask."))
252 return true;
253 }
254 return false;
255 }
256
257 static int manager_dispatch_ask_password_fd(sd_event_source *source,
258 int fd, uint32_t revents, void *userdata) {
259 Manager *m = userdata;
260
261 assert(m);
262
263 flush_fd(fd);
264
265 m->have_ask_password = have_ask_password();
266 if (m->have_ask_password < 0)
267 /* Log error but continue. Negative have_ask_password
268 * is treated as unknown status. */
269 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
270
271 return 0;
272 }
273
274 static void manager_close_ask_password(Manager *m) {
275 assert(m);
276
277 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
278 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
279 m->have_ask_password = -EINVAL;
280 }
281
282 static int manager_check_ask_password(Manager *m) {
283 int r;
284
285 assert(m);
286
287 if (!m->ask_password_event_source) {
288 assert(m->ask_password_inotify_fd < 0);
289
290 mkdir_p_label("/run/systemd/ask-password", 0755);
291
292 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
293 if (m->ask_password_inotify_fd < 0)
294 return log_error_errno(errno, "inotify_init1() failed: %m");
295
296 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
297 log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
298 manager_close_ask_password(m);
299 return -errno;
300 }
301
302 r = sd_event_add_io(m->event, &m->ask_password_event_source,
303 m->ask_password_inotify_fd, EPOLLIN,
304 manager_dispatch_ask_password_fd, m);
305 if (r < 0) {
306 log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
307 manager_close_ask_password(m);
308 return -errno;
309 }
310
311 (void) sd_event_source_set_description(m->ask_password_event_source, "manager-ask-password");
312
313 /* Queries might have been added meanwhile... */
314 manager_dispatch_ask_password_fd(m->ask_password_event_source,
315 m->ask_password_inotify_fd, EPOLLIN, m);
316 }
317
318 return m->have_ask_password;
319 }
320
321 static int manager_watch_idle_pipe(Manager *m) {
322 int r;
323
324 assert(m);
325
326 if (m->idle_pipe_event_source)
327 return 0;
328
329 if (m->idle_pipe[2] < 0)
330 return 0;
331
332 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
333 if (r < 0)
334 return log_error_errno(r, "Failed to watch idle pipe: %m");
335
336 (void) sd_event_source_set_description(m->idle_pipe_event_source, "manager-idle-pipe");
337
338 return 0;
339 }
340
341 static void manager_close_idle_pipe(Manager *m) {
342 assert(m);
343
344 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
345
346 safe_close_pair(m->idle_pipe);
347 safe_close_pair(m->idle_pipe + 2);
348 }
349
350 static int manager_setup_time_change(Manager *m) {
351 int r;
352
353 /* We only care for the cancellation event, hence we set the
354 * timeout to the latest possible value. */
355 struct itimerspec its = {
356 .it_value.tv_sec = TIME_T_MAX,
357 };
358
359 assert(m);
360 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
361
362 if (m->test_run_flags)
363 return 0;
364
365 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
366 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
367
368 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
369 if (m->time_change_fd < 0)
370 return log_error_errno(errno, "Failed to create timerfd: %m");
371
372 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
373 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
374 m->time_change_fd = safe_close(m->time_change_fd);
375 return 0;
376 }
377
378 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
379 if (r < 0)
380 return log_error_errno(r, "Failed to create time change event source: %m");
381
382 (void) sd_event_source_set_description(m->time_change_event_source, "manager-time-change");
383
384 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
385
386 return 0;
387 }
388
389 static int enable_special_signals(Manager *m) {
390 _cleanup_close_ int fd = -1;
391
392 assert(m);
393
394 if (m->test_run_flags)
395 return 0;
396
397 /* Enable that we get SIGINT on control-alt-del. In containers
398 * this will fail with EPERM (older) or EINVAL (newer), so
399 * ignore that. */
400 if (reboot(RB_DISABLE_CAD) < 0 && !IN_SET(errno, EPERM, EINVAL))
401 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
402
403 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
404 if (fd < 0) {
405 /* Support systems without virtual console */
406 if (fd != -ENOENT)
407 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
408 } else {
409 /* Enable that we get SIGWINCH on kbrequest */
410 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
411 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
412 }
413
414 return 0;
415 }
416
417 static int manager_setup_signals(Manager *m) {
418 struct sigaction sa = {
419 .sa_handler = SIG_DFL,
420 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
421 };
422 sigset_t mask;
423 int r;
424
425 assert(m);
426
427 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
428
429 /* We make liberal use of realtime signals here. On
430 * Linux/glibc we have 30 of them (with the exception of Linux
431 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
432 * (aka SIGRTMAX). */
433
434 assert_se(sigemptyset(&mask) == 0);
435 sigset_add_many(&mask,
436 SIGCHLD, /* Child died */
437 SIGTERM, /* Reexecute daemon */
438 SIGHUP, /* Reload configuration */
439 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
440 SIGUSR2, /* systemd: dump status */
441 SIGINT, /* Kernel sends us this on control-alt-del */
442 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
443 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
444
445 SIGRTMIN+0, /* systemd: start default.target */
446 SIGRTMIN+1, /* systemd: isolate rescue.target */
447 SIGRTMIN+2, /* systemd: isolate emergency.target */
448 SIGRTMIN+3, /* systemd: start halt.target */
449 SIGRTMIN+4, /* systemd: start poweroff.target */
450 SIGRTMIN+5, /* systemd: start reboot.target */
451 SIGRTMIN+6, /* systemd: start kexec.target */
452
453 /* ... space for more special targets ... */
454
455 SIGRTMIN+13, /* systemd: Immediate halt */
456 SIGRTMIN+14, /* systemd: Immediate poweroff */
457 SIGRTMIN+15, /* systemd: Immediate reboot */
458 SIGRTMIN+16, /* systemd: Immediate kexec */
459
460 /* ... space for more immediate system state changes ... */
461
462 SIGRTMIN+20, /* systemd: enable status messages */
463 SIGRTMIN+21, /* systemd: disable status messages */
464 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
465 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
466 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
467
468 /* .. one free signal here ... */
469
470 #if !defined(__hppa64__) && !defined(__hppa__)
471 /* Apparently Linux on hppa has fewer RT
472 * signals (SIGRTMAX is SIGRTMIN+25 there),
473 * hence let's not try to make use of them
474 * here. Since these commands are accessible
475 * by different means and only really a safety
476 * net, the missing functionality on hppa
477 * shouldn't matter. */
478
479 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
480 SIGRTMIN+27, /* systemd: set log target to console */
481 SIGRTMIN+28, /* systemd: set log target to kmsg */
482 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
483
484 /* ... one free signal here SIGRTMIN+30 ... */
485 #endif
486 -1);
487 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
488
489 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
490 if (m->signal_fd < 0)
491 return -errno;
492
493 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
494 if (r < 0)
495 return r;
496
497 (void) sd_event_source_set_description(m->signal_event_source, "manager-signal");
498
499 /* Process signals a bit earlier than the rest of things, but later than notify_fd processing, so that the
500 * notify processing can still figure out to which process/service a message belongs, before we reap the
501 * process. Also, process this before handling cgroup notifications, so that we always collect child exit
502 * status information before detecting that there's no process in a cgroup. */
503 r = sd_event_source_set_priority(m->signal_event_source, SD_EVENT_PRIORITY_NORMAL-6);
504 if (r < 0)
505 return r;
506
507 if (MANAGER_IS_SYSTEM(m))
508 return enable_special_signals(m);
509
510 return 0;
511 }
512
513 static void manager_clean_environment(Manager *m) {
514 assert(m);
515
516 /* Let's remove some environment variables that we
517 * need ourselves to communicate with our clients */
518 strv_env_unset_many(
519 m->environment,
520 "NOTIFY_SOCKET",
521 "MAINPID",
522 "MANAGERPID",
523 "LISTEN_PID",
524 "LISTEN_FDS",
525 "LISTEN_FDNAMES",
526 "WATCHDOG_PID",
527 "WATCHDOG_USEC",
528 "INVOCATION_ID",
529 NULL);
530 }
531
532 static int manager_default_environment(Manager *m) {
533 assert(m);
534
535 if (MANAGER_IS_SYSTEM(m)) {
536 /* The system manager always starts with a clean
537 * environment for its children. It does not import
538 * the kernel's or the parents' exported variables.
539 *
540 * The initial passed environment is untouched to keep
541 * /proc/self/environ valid; it is used for tagging
542 * the init process inside containers. */
543 m->environment = strv_new("PATH=" DEFAULT_PATH,
544 NULL);
545
546 /* Import locale variables LC_*= from configuration */
547 locale_setup(&m->environment);
548 } else
549 /* The user manager passes its own environment
550 * along to its children. */
551 m->environment = strv_copy(environ);
552
553 if (!m->environment)
554 return -ENOMEM;
555
556 manager_clean_environment(m);
557 strv_sort(m->environment);
558
559 return 0;
560 }
561
562 static int manager_setup_prefix(Manager *m) {
563 struct table_entry {
564 uint64_t type;
565 const char *suffix;
566 };
567
568 static const struct table_entry paths_system[_EXEC_DIRECTORY_TYPE_MAX] = {
569 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_SYSTEM_RUNTIME, NULL },
570 [EXEC_DIRECTORY_STATE] = { SD_PATH_SYSTEM_STATE_PRIVATE, NULL },
571 [EXEC_DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE, NULL },
572 [EXEC_DIRECTORY_LOGS] = { SD_PATH_SYSTEM_STATE_LOGS, NULL },
573 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_SYSTEM_CONFIGURATION, NULL },
574 };
575
576 static const struct table_entry paths_user[_EXEC_DIRECTORY_TYPE_MAX] = {
577 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_USER_RUNTIME, NULL },
578 [EXEC_DIRECTORY_STATE] = { SD_PATH_USER_CONFIGURATION, NULL },
579 [EXEC_DIRECTORY_CACHE] = { SD_PATH_USER_STATE_CACHE, NULL },
580 [EXEC_DIRECTORY_LOGS] = { SD_PATH_USER_CONFIGURATION, "log" },
581 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_USER_CONFIGURATION, NULL },
582 };
583
584 const struct table_entry *p;
585 ExecDirectoryType i;
586 int r;
587
588 assert(m);
589
590 if (MANAGER_IS_SYSTEM(m))
591 p = paths_system;
592 else
593 p = paths_user;
594
595 for (i = 0; i < _EXEC_DIRECTORY_TYPE_MAX; i++) {
596 r = sd_path_home(p[i].type, p[i].suffix, &m->prefix[i]);
597 if (r < 0)
598 return r;
599 }
600
601 return 0;
602 }
603
604 int manager_new(UnitFileScope scope, unsigned test_run_flags, Manager **_m) {
605 Manager *m;
606 int r;
607
608 assert(_m);
609 assert(IN_SET(scope, UNIT_FILE_SYSTEM, UNIT_FILE_USER));
610
611 m = new0(Manager, 1);
612 if (!m)
613 return -ENOMEM;
614
615 m->unit_file_scope = scope;
616 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
617 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
618 m->default_tasks_accounting = true;
619 m->default_tasks_max = UINT64_MAX;
620 m->default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
621 m->default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
622 m->default_restart_usec = DEFAULT_RESTART_USEC;
623
624 #if ENABLE_EFI
625 if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
626 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
627 #endif
628
629 /* Prepare log fields we can use for structured logging */
630 if (MANAGER_IS_SYSTEM(m)) {
631 m->unit_log_field = "UNIT=";
632 m->unit_log_format_string = "UNIT=%s";
633
634 m->invocation_log_field = "INVOCATION_ID=";
635 m->invocation_log_format_string = "INVOCATION_ID=%s";
636 } else {
637 m->unit_log_field = "USER_UNIT=";
638 m->unit_log_format_string = "USER_UNIT=%s";
639
640 m->invocation_log_field = "USER_INVOCATION_ID=";
641 m->invocation_log_format_string = "USER_INVOCATION_ID=%s";
642 }
643
644 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
645
646 m->pin_cgroupfs_fd = m->notify_fd = m->cgroups_agent_fd = m->signal_fd = m->time_change_fd =
647 m->dev_autofs_fd = m->private_listen_fd = m->cgroup_inotify_fd =
648 m->ask_password_inotify_fd = -1;
649
650 m->user_lookup_fds[0] = m->user_lookup_fds[1] = -1;
651
652 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
653
654 m->have_ask_password = -EINVAL; /* we don't know */
655 m->first_boot = -1;
656
657 m->test_run_flags = test_run_flags;
658
659 /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
660 RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7);
661
662 r = manager_default_environment(m);
663 if (r < 0)
664 goto fail;
665
666 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
667 if (r < 0)
668 goto fail;
669
670 r = hashmap_ensure_allocated(&m->jobs, NULL);
671 if (r < 0)
672 goto fail;
673
674 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
675 if (r < 0)
676 goto fail;
677
678 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
679 if (r < 0)
680 goto fail;
681
682 r = sd_event_default(&m->event);
683 if (r < 0)
684 goto fail;
685
686 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
687 if (r < 0)
688 goto fail;
689
690 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
691 if (r < 0)
692 goto fail;
693
694 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
695 if (r < 0)
696 goto fail;
697
698 (void) sd_event_source_set_description(m->run_queue_event_source, "manager-run-queue");
699
700 r = manager_setup_signals(m);
701 if (r < 0)
702 goto fail;
703
704 r = manager_setup_cgroup(m);
705 if (r < 0)
706 goto fail;
707
708 r = manager_setup_time_change(m);
709 if (r < 0)
710 goto fail;
711
712 m->udev = udev_new();
713 if (!m->udev) {
714 r = -ENOMEM;
715 goto fail;
716 }
717
718 if (MANAGER_IS_SYSTEM(m)) {
719 r = mkdir_label("/run/systemd/units", 0755);
720 if (r < 0 && r != -EEXIST)
721 goto fail;
722 }
723
724 /* Note that we do not set up the notify fd here. We do that after deserialization,
725 * since they might have gotten serialized across the reexec. */
726
727 m->taint_usr = dir_is_empty("/usr") > 0;
728
729 r = manager_setup_prefix(m);
730 if (r < 0)
731 goto fail;
732
733 *_m = m;
734 return 0;
735
736 fail:
737 manager_free(m);
738 return r;
739 }
740
741 static int manager_setup_notify(Manager *m) {
742 int r;
743
744 if (m->test_run_flags)
745 return 0;
746
747 if (m->notify_fd < 0) {
748 _cleanup_close_ int fd = -1;
749 union sockaddr_union sa = {
750 .sa.sa_family = AF_UNIX,
751 };
752 static const int one = 1;
753
754 /* First free all secondary fields */
755 m->notify_socket = mfree(m->notify_socket);
756 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
757
758 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
759 if (fd < 0)
760 return log_error_errno(errno, "Failed to allocate notification socket: %m");
761
762 fd_inc_rcvbuf(fd, NOTIFY_RCVBUF_SIZE);
763
764 m->notify_socket = strappend(m->prefix[EXEC_DIRECTORY_RUNTIME], "/systemd/notify");
765 if (!m->notify_socket)
766 return log_oom();
767
768 (void) mkdir_parents_label(m->notify_socket, 0755);
769 (void) unlink(m->notify_socket);
770
771 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
772 r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
773 if (r < 0)
774 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
775
776 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
777 if (r < 0)
778 return log_error_errno(errno, "SO_PASSCRED failed: %m");
779
780 m->notify_fd = fd;
781 fd = -1;
782
783 log_debug("Using notification socket %s", m->notify_socket);
784 }
785
786 if (!m->notify_event_source) {
787 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
788 if (r < 0)
789 return log_error_errno(r, "Failed to allocate notify event source: %m");
790
791 /* Process notification messages a bit earlier than SIGCHLD, so that we can still identify to which
792 * service an exit message belongs. */
793 r = sd_event_source_set_priority(m->notify_event_source, SD_EVENT_PRIORITY_NORMAL-7);
794 if (r < 0)
795 return log_error_errno(r, "Failed to set priority of notify event source: %m");
796
797 (void) sd_event_source_set_description(m->notify_event_source, "manager-notify");
798 }
799
800 return 0;
801 }
802
803 static int manager_setup_cgroups_agent(Manager *m) {
804
805 static const union sockaddr_union sa = {
806 .un.sun_family = AF_UNIX,
807 .un.sun_path = "/run/systemd/cgroups-agent",
808 };
809 int r;
810
811 /* This creates a listening socket we receive cgroups agent messages on. We do not use D-Bus for delivering
812 * these messages from the cgroups agent binary to PID 1, as the cgroups agent binary is very short-living, and
813 * each instance of it needs a new D-Bus connection. Since D-Bus connections are SOCK_STREAM/AF_UNIX, on
814 * overloaded systems the backlog of the D-Bus socket becomes relevant, as not more than the configured number
815 * of D-Bus connections may be queued until the kernel will start dropping further incoming connections,
816 * possibly resulting in lost cgroups agent messages. To avoid this, we'll use a private SOCK_DGRAM/AF_UNIX
817 * socket, where no backlog is relevant as communication may take place without an actual connect() cycle, and
818 * we thus won't lose messages.
819 *
820 * Note that PID 1 will forward the agent message to system bus, so that the user systemd instance may listen
821 * to it. The system instance hence listens on this special socket, but the user instances listen on the system
822 * bus for these messages. */
823
824 if (m->test_run_flags)
825 return 0;
826
827 if (!MANAGER_IS_SYSTEM(m))
828 return 0;
829
830 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
831 if (r < 0)
832 return log_error_errno(r, "Failed to determine whether unified cgroups hierarchy is used: %m");
833 if (r > 0) /* We don't need this anymore on the unified hierarchy */
834 return 0;
835
836 if (m->cgroups_agent_fd < 0) {
837 _cleanup_close_ int fd = -1;
838
839 /* First free all secondary fields */
840 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
841
842 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
843 if (fd < 0)
844 return log_error_errno(errno, "Failed to allocate cgroups agent socket: %m");
845
846 fd_inc_rcvbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE);
847
848 (void) unlink(sa.un.sun_path);
849
850 /* Only allow root to connect to this socket */
851 RUN_WITH_UMASK(0077)
852 r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
853 if (r < 0)
854 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
855
856 m->cgroups_agent_fd = fd;
857 fd = -1;
858 }
859
860 if (!m->cgroups_agent_event_source) {
861 r = sd_event_add_io(m->event, &m->cgroups_agent_event_source, m->cgroups_agent_fd, EPOLLIN, manager_dispatch_cgroups_agent_fd, m);
862 if (r < 0)
863 return log_error_errno(r, "Failed to allocate cgroups agent event source: %m");
864
865 /* Process cgroups notifications early, but after having processed service notification messages or
866 * SIGCHLD signals, so that a cgroup running empty is always just the last safety net of notification,
867 * and we collected the metadata the notification and SIGCHLD stuff offers first. Also see handling of
868 * cgroup inotify for the unified cgroup stuff. */
869 r = sd_event_source_set_priority(m->cgroups_agent_event_source, SD_EVENT_PRIORITY_NORMAL-4);
870 if (r < 0)
871 return log_error_errno(r, "Failed to set priority of cgroups agent event source: %m");
872
873 (void) sd_event_source_set_description(m->cgroups_agent_event_source, "manager-cgroups-agent");
874 }
875
876 return 0;
877 }
878
879 static int manager_setup_user_lookup_fd(Manager *m) {
880 int r;
881
882 assert(m);
883
884 /* Set up the socket pair used for passing UID/GID resolution results from forked off processes to PID
885 * 1. Background: we can't do name lookups (NSS) from PID 1, since it might involve IPC and thus activation,
886 * and we might hence deadlock on ourselves. Hence we do all user/group lookups asynchronously from the forked
887 * off processes right before executing the binaries to start. In order to be able to clean up any IPC objects
888 * created by a unit (see RemoveIPC=) we need to know in PID 1 the used UID/GID of the executed processes,
889 * hence we establish this communication channel so that forked off processes can pass their UID/GID
890 * information back to PID 1. The forked off processes send their resolved UID/GID to PID 1 in a simple
891 * datagram, along with their unit name, so that we can share one communication socket pair among all units for
892 * this purpose.
893 *
894 * You might wonder why we need a communication channel for this that is independent of the usual notification
895 * socket scheme (i.e. $NOTIFY_SOCKET). The primary difference is about trust: data sent via the $NOTIFY_SOCKET
896 * channel is only accepted if it originates from the right unit and if reception was enabled for it. The user
897 * lookup socket OTOH is only accessible by PID 1 and its children until they exec(), and always available.
898 *
899 * Note that this function is called under two circumstances: when we first initialize (in which case we
900 * allocate both the socket pair and the event source to listen on it), and when we deserialize after a reload
901 * (in which case the socket pair already exists but we still need to allocate the event source for it). */
902
903 if (m->user_lookup_fds[0] < 0) {
904
905 /* Free all secondary fields */
906 safe_close_pair(m->user_lookup_fds);
907 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
908
909 if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, m->user_lookup_fds) < 0)
910 return log_error_errno(errno, "Failed to allocate user lookup socket: %m");
911
912 (void) fd_inc_rcvbuf(m->user_lookup_fds[0], NOTIFY_RCVBUF_SIZE);
913 }
914
915 if (!m->user_lookup_event_source) {
916 r = sd_event_add_io(m->event, &m->user_lookup_event_source, m->user_lookup_fds[0], EPOLLIN, manager_dispatch_user_lookup_fd, m);
917 if (r < 0)
918 return log_error_errno(errno, "Failed to allocate user lookup event source: %m");
919
920 /* Process even earlier than the notify event source, so that we always know first about valid UID/GID
921 * resolutions */
922 r = sd_event_source_set_priority(m->user_lookup_event_source, SD_EVENT_PRIORITY_NORMAL-8);
923 if (r < 0)
924 return log_error_errno(errno, "Failed to set priority ot user lookup event source: %m");
925
926 (void) sd_event_source_set_description(m->user_lookup_event_source, "user-lookup");
927 }
928
929 return 0;
930 }
931
932 static int manager_connect_bus(Manager *m, bool reexecuting) {
933 bool try_bus_connect;
934 Unit *u = NULL;
935
936 assert(m);
937
938 if (m->test_run_flags)
939 return 0;
940
941 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
942
943 try_bus_connect =
944 (u && SERVICE(u)->deserialized_state == SERVICE_RUNNING) &&
945 (reexecuting ||
946 (MANAGER_IS_USER(m) && getenv("DBUS_SESSION_BUS_ADDRESS")));
947
948 /* Try to connect to the buses, if possible. */
949 return bus_init(m, try_bus_connect);
950 }
951
952 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
953 Unit *u;
954 unsigned n = 0;
955
956 assert(m);
957
958 while ((u = m->cleanup_queue)) {
959 assert(u->in_cleanup_queue);
960
961 unit_free(u);
962 n++;
963 }
964
965 return n;
966 }
967
968 enum {
969 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
970 GC_OFFSET_UNSURE, /* No clue */
971 GC_OFFSET_GOOD, /* We still need this unit */
972 GC_OFFSET_BAD, /* We don't need this unit anymore */
973 _GC_OFFSET_MAX
974 };
975
976 static void unit_gc_mark_good(Unit *u, unsigned gc_marker) {
977 Unit *other;
978 Iterator i;
979 void *v;
980
981 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
982
983 /* Recursively mark referenced units as GOOD as well */
984 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCES], i)
985 if (other->gc_marker == gc_marker + GC_OFFSET_UNSURE)
986 unit_gc_mark_good(other, gc_marker);
987 }
988
989 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
990 Unit *other;
991 bool is_bad;
992 Iterator i;
993 void *v;
994
995 assert(u);
996
997 if (IN_SET(u->gc_marker - gc_marker,
998 GC_OFFSET_GOOD, GC_OFFSET_BAD, GC_OFFSET_UNSURE, GC_OFFSET_IN_PATH))
999 return;
1000
1001 if (u->in_cleanup_queue)
1002 goto bad;
1003
1004 if (unit_check_gc(u))
1005 goto good;
1006
1007 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
1008
1009 is_bad = true;
1010
1011 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCED_BY], i) {
1012 unit_gc_sweep(other, gc_marker);
1013
1014 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
1015 goto good;
1016
1017 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
1018 is_bad = false;
1019 }
1020
1021 if (is_bad)
1022 goto bad;
1023
1024 /* We were unable to find anything out about this entry, so
1025 * let's investigate it later */
1026 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
1027 unit_add_to_gc_queue(u);
1028 return;
1029
1030 bad:
1031 /* We definitely know that this one is not useful anymore, so
1032 * let's mark it for deletion */
1033 u->gc_marker = gc_marker + GC_OFFSET_BAD;
1034 unit_add_to_cleanup_queue(u);
1035 return;
1036
1037 good:
1038 unit_gc_mark_good(u, gc_marker);
1039 }
1040
1041 static unsigned manager_dispatch_gc_unit_queue(Manager *m) {
1042 unsigned n = 0, gc_marker;
1043 Unit *u;
1044
1045 assert(m);
1046
1047 /* log_debug("Running GC..."); */
1048
1049 m->gc_marker += _GC_OFFSET_MAX;
1050 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
1051 m->gc_marker = 1;
1052
1053 gc_marker = m->gc_marker;
1054
1055 while ((u = m->gc_unit_queue)) {
1056 assert(u->in_gc_queue);
1057
1058 unit_gc_sweep(u, gc_marker);
1059
1060 LIST_REMOVE(gc_queue, m->gc_unit_queue, u);
1061 u->in_gc_queue = false;
1062
1063 n++;
1064
1065 if (IN_SET(u->gc_marker - gc_marker,
1066 GC_OFFSET_BAD, GC_OFFSET_UNSURE)) {
1067 if (u->id)
1068 log_unit_debug(u, "Collecting.");
1069 u->gc_marker = gc_marker + GC_OFFSET_BAD;
1070 unit_add_to_cleanup_queue(u);
1071 }
1072 }
1073
1074 return n;
1075 }
1076
1077 static unsigned manager_dispatch_gc_job_queue(Manager *m) {
1078 unsigned n = 0;
1079 Job *j;
1080
1081 assert(m);
1082
1083 while ((j = m->gc_job_queue)) {
1084 assert(j->in_gc_queue);
1085
1086 LIST_REMOVE(gc_queue, m->gc_job_queue, j);
1087 j->in_gc_queue = false;
1088
1089 n++;
1090
1091 if (job_check_gc(j))
1092 continue;
1093
1094 log_unit_debug(j->unit, "Collecting job.");
1095 (void) job_finish_and_invalidate(j, JOB_COLLECTED, false, false);
1096 }
1097
1098 return n;
1099 }
1100
1101 static void manager_clear_jobs_and_units(Manager *m) {
1102 Unit *u;
1103
1104 assert(m);
1105
1106 while ((u = hashmap_first(m->units)))
1107 unit_free(u);
1108
1109 manager_dispatch_cleanup_queue(m);
1110
1111 assert(!m->load_queue);
1112 assert(!m->run_queue);
1113 assert(!m->dbus_unit_queue);
1114 assert(!m->dbus_job_queue);
1115 assert(!m->cleanup_queue);
1116 assert(!m->gc_unit_queue);
1117 assert(!m->gc_job_queue);
1118
1119 assert(hashmap_isempty(m->jobs));
1120 assert(hashmap_isempty(m->units));
1121
1122 m->n_on_console = 0;
1123 m->n_running_jobs = 0;
1124 }
1125
1126 Manager* manager_free(Manager *m) {
1127 UnitType c;
1128 int i;
1129 ExecDirectoryType dt;
1130
1131 if (!m)
1132 return NULL;
1133
1134 manager_clear_jobs_and_units(m);
1135
1136 for (c = 0; c < _UNIT_TYPE_MAX; c++)
1137 if (unit_vtable[c]->shutdown)
1138 unit_vtable[c]->shutdown(m);
1139
1140 /* If we reexecute ourselves, we keep the root cgroup around */
1141 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
1142
1143 lookup_paths_flush_generator(&m->lookup_paths);
1144
1145 bus_done(m);
1146
1147 dynamic_user_vacuum(m, false);
1148 hashmap_free(m->dynamic_users);
1149
1150 hashmap_free(m->units);
1151 hashmap_free(m->units_by_invocation_id);
1152 hashmap_free(m->jobs);
1153 hashmap_free(m->watch_pids1);
1154 hashmap_free(m->watch_pids2);
1155 hashmap_free(m->watch_bus);
1156
1157 set_free(m->startup_units);
1158 set_free(m->failed_units);
1159
1160 sd_event_source_unref(m->signal_event_source);
1161 sd_event_source_unref(m->notify_event_source);
1162 sd_event_source_unref(m->cgroups_agent_event_source);
1163 sd_event_source_unref(m->time_change_event_source);
1164 sd_event_source_unref(m->jobs_in_progress_event_source);
1165 sd_event_source_unref(m->run_queue_event_source);
1166 sd_event_source_unref(m->user_lookup_event_source);
1167
1168 safe_close(m->signal_fd);
1169 safe_close(m->notify_fd);
1170 safe_close(m->cgroups_agent_fd);
1171 safe_close(m->time_change_fd);
1172 safe_close_pair(m->user_lookup_fds);
1173
1174 manager_close_ask_password(m);
1175
1176 manager_close_idle_pipe(m);
1177
1178 udev_unref(m->udev);
1179 sd_event_unref(m->event);
1180
1181 free(m->notify_socket);
1182
1183 lookup_paths_free(&m->lookup_paths);
1184 strv_free(m->environment);
1185
1186 hashmap_free(m->cgroup_unit);
1187 set_free_free(m->unit_path_cache);
1188
1189 free(m->switch_root);
1190 free(m->switch_root_init);
1191
1192 for (i = 0; i < _RLIMIT_MAX; i++)
1193 m->rlimit[i] = mfree(m->rlimit[i]);
1194
1195 assert(hashmap_isempty(m->units_requiring_mounts_for));
1196 hashmap_free(m->units_requiring_mounts_for);
1197
1198 hashmap_free(m->uid_refs);
1199 hashmap_free(m->gid_refs);
1200
1201 for (dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++)
1202 m->prefix[dt] = mfree(m->prefix[dt]);
1203
1204 return mfree(m);
1205 }
1206
1207 void manager_enumerate(Manager *m) {
1208 UnitType c;
1209
1210 assert(m);
1211
1212 /* Let's ask every type to load all units from disk/kernel
1213 * that it might know */
1214 for (c = 0; c < _UNIT_TYPE_MAX; c++) {
1215 if (!unit_type_supported(c)) {
1216 log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
1217 continue;
1218 }
1219
1220 if (!unit_vtable[c]->enumerate)
1221 continue;
1222
1223 unit_vtable[c]->enumerate(m);
1224 }
1225
1226 manager_dispatch_load_queue(m);
1227 }
1228
1229 static void manager_coldplug(Manager *m) {
1230 Iterator i;
1231 Unit *u;
1232 char *k;
1233 int r;
1234
1235 assert(m);
1236
1237 /* Then, let's set up their initial state. */
1238 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1239
1240 /* ignore aliases */
1241 if (u->id != k)
1242 continue;
1243
1244 r = unit_coldplug(u);
1245 if (r < 0)
1246 log_warning_errno(r, "We couldn't coldplug %s, proceeding anyway: %m", u->id);
1247 }
1248 }
1249
1250 static void manager_build_unit_path_cache(Manager *m) {
1251 char **i;
1252 int r;
1253
1254 assert(m);
1255
1256 set_free_free(m->unit_path_cache);
1257
1258 m->unit_path_cache = set_new(&string_hash_ops);
1259 if (!m->unit_path_cache) {
1260 r = -ENOMEM;
1261 goto fail;
1262 }
1263
1264 /* This simply builds a list of files we know exist, so that
1265 * we don't always have to go to disk */
1266
1267 STRV_FOREACH(i, m->lookup_paths.search_path) {
1268 _cleanup_closedir_ DIR *d = NULL;
1269 struct dirent *de;
1270
1271 d = opendir(*i);
1272 if (!d) {
1273 if (errno != ENOENT)
1274 log_warning_errno(errno, "Failed to open directory %s, ignoring: %m", *i);
1275 continue;
1276 }
1277
1278 FOREACH_DIRENT(de, d, r = -errno; goto fail) {
1279 char *p;
1280
1281 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name);
1282 if (!p) {
1283 r = -ENOMEM;
1284 goto fail;
1285 }
1286
1287 r = set_consume(m->unit_path_cache, p);
1288 if (r < 0)
1289 goto fail;
1290 }
1291 }
1292
1293 return;
1294
1295 fail:
1296 log_warning_errno(r, "Failed to build unit path cache, proceeding without: %m");
1297 m->unit_path_cache = set_free_free(m->unit_path_cache);
1298 }
1299
1300 static void manager_distribute_fds(Manager *m, FDSet *fds) {
1301 Iterator i;
1302 Unit *u;
1303
1304 assert(m);
1305
1306 HASHMAP_FOREACH(u, m->units, i) {
1307
1308 if (fdset_size(fds) <= 0)
1309 break;
1310
1311 if (!UNIT_VTABLE(u)->distribute_fds)
1312 continue;
1313
1314 UNIT_VTABLE(u)->distribute_fds(u, fds);
1315 }
1316 }
1317
1318 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1319 int r;
1320
1321 assert(m);
1322
1323 /* If we are running in test mode, we still want to run the generators,
1324 * but we should not touch the real generator directories. */
1325 r = lookup_paths_init(&m->lookup_paths, m->unit_file_scope,
1326 m->test_run_flags ? LOOKUP_PATHS_TEMPORARY_GENERATED : 0,
1327 NULL);
1328 if (r < 0)
1329 return r;
1330
1331 r = manager_run_environment_generators(m);
1332 if (r < 0)
1333 return r;
1334
1335 /* Make sure the transient directory always exists, so that it remains
1336 * in the search path */
1337 r = mkdir_p_label(m->lookup_paths.transient, 0755);
1338 if (r < 0)
1339 return log_error_errno(r, "Failed to create transient generator directory \"%s\": %m",
1340 m->lookup_paths.transient);
1341
1342 dual_timestamp_get(&m->generators_start_timestamp);
1343 r = manager_run_generators(m);
1344 dual_timestamp_get(&m->generators_finish_timestamp);
1345 if (r < 0)
1346 return r;
1347
1348 /* If this is the first boot, and we are in the host system, then preset everything */
1349 if (m->first_boot > 0 &&
1350 MANAGER_IS_SYSTEM(m) &&
1351 !m->test_run_flags) {
1352
1353 r = unit_file_preset_all(UNIT_FILE_SYSTEM, 0, NULL, UNIT_FILE_PRESET_ENABLE_ONLY, NULL, 0);
1354 if (r < 0)
1355 log_full_errno(r == -EEXIST ? LOG_NOTICE : LOG_WARNING, r,
1356 "Failed to populate /etc with preset unit settings, ignoring: %m");
1357 else
1358 log_info("Populated /etc with preset unit settings.");
1359 }
1360
1361 lookup_paths_reduce(&m->lookup_paths);
1362 manager_build_unit_path_cache(m);
1363
1364 /* If we will deserialize make sure that during enumeration
1365 * this is already known, so we increase the counter here
1366 * already */
1367 if (serialization)
1368 m->n_reloading++;
1369
1370 /* First, enumerate what we can from all config files */
1371 dual_timestamp_get(&m->units_load_start_timestamp);
1372 manager_enumerate(m);
1373 dual_timestamp_get(&m->units_load_finish_timestamp);
1374
1375 /* Second, deserialize if there is something to deserialize */
1376 if (serialization) {
1377 r = manager_deserialize(m, serialization, fds);
1378 if (r < 0)
1379 return log_error_errno(r, "Deserialization failed: %m");
1380 }
1381
1382 /* Any fds left? Find some unit which wants them. This is
1383 * useful to allow container managers to pass some file
1384 * descriptors to us pre-initialized. This enables
1385 * socket-based activation of entire containers. */
1386 manager_distribute_fds(m, fds);
1387
1388 /* We might have deserialized the notify fd, but if we didn't
1389 * then let's create the bus now */
1390 r = manager_setup_notify(m);
1391 if (r < 0)
1392 /* No sense to continue without notifications, our children would fail anyway. */
1393 return r;
1394
1395 r = manager_setup_cgroups_agent(m);
1396 if (r < 0)
1397 /* Likewise, no sense to continue without empty cgroup notifications. */
1398 return r;
1399
1400 r = manager_setup_user_lookup_fd(m);
1401 if (r < 0)
1402 /* This shouldn't fail, except if things are really broken. */
1403 return r;
1404
1405 /* Let's connect to the bus now. */
1406 (void) manager_connect_bus(m, !!serialization);
1407
1408 (void) bus_track_coldplug(m, &m->subscribed, false, m->deserialized_subscribed);
1409 m->deserialized_subscribed = strv_free(m->deserialized_subscribed);
1410
1411 /* Third, fire things up! */
1412 manager_coldplug(m);
1413
1414 /* Release any dynamic users no longer referenced */
1415 dynamic_user_vacuum(m, true);
1416
1417 /* Release any references to UIDs/GIDs no longer referenced, and destroy any IPC owned by them */
1418 manager_vacuum_uid_refs(m);
1419 manager_vacuum_gid_refs(m);
1420
1421 if (serialization) {
1422 assert(m->n_reloading > 0);
1423 m->n_reloading--;
1424
1425 /* Let's wait for the UnitNew/JobNew messages being
1426 * sent, before we notify that the reload is
1427 * finished */
1428 m->send_reloading_done = true;
1429 }
1430
1431 return 0;
1432 }
1433
1434 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, sd_bus_error *e, Job **_ret) {
1435 int r;
1436 Transaction *tr;
1437
1438 assert(m);
1439 assert(type < _JOB_TYPE_MAX);
1440 assert(unit);
1441 assert(mode < _JOB_MODE_MAX);
1442
1443 if (mode == JOB_ISOLATE && type != JOB_START)
1444 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1445
1446 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1447 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1448
1449 log_unit_debug(unit, "Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1450
1451 type = job_type_collapse(type, unit);
1452
1453 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1454 if (!tr)
1455 return -ENOMEM;
1456
1457 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, false,
1458 IN_SET(mode, JOB_IGNORE_DEPENDENCIES, JOB_IGNORE_REQUIREMENTS),
1459 mode == JOB_IGNORE_DEPENDENCIES, e);
1460 if (r < 0)
1461 goto tr_abort;
1462
1463 if (mode == JOB_ISOLATE) {
1464 r = transaction_add_isolate_jobs(tr, m);
1465 if (r < 0)
1466 goto tr_abort;
1467 }
1468
1469 r = transaction_activate(tr, m, mode, e);
1470 if (r < 0)
1471 goto tr_abort;
1472
1473 log_unit_debug(unit,
1474 "Enqueued job %s/%s as %u", unit->id,
1475 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1476
1477 if (_ret)
1478 *_ret = tr->anchor_job;
1479
1480 transaction_free(tr);
1481 return 0;
1482
1483 tr_abort:
1484 transaction_abort(tr);
1485 transaction_free(tr);
1486 return r;
1487 }
1488
1489 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, sd_bus_error *e, Job **ret) {
1490 Unit *unit = NULL; /* just to appease gcc, initialization is not really necessary */
1491 int r;
1492
1493 assert(m);
1494 assert(type < _JOB_TYPE_MAX);
1495 assert(name);
1496 assert(mode < _JOB_MODE_MAX);
1497
1498 r = manager_load_unit(m, name, NULL, NULL, &unit);
1499 if (r < 0)
1500 return r;
1501 assert(unit);
1502
1503 return manager_add_job(m, type, unit, mode, e, ret);
1504 }
1505
1506 int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Job **ret) {
1507 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1508 int r;
1509
1510 assert(m);
1511 assert(type < _JOB_TYPE_MAX);
1512 assert(name);
1513 assert(mode < _JOB_MODE_MAX);
1514
1515 r = manager_add_job_by_name(m, type, name, mode, &error, ret);
1516 if (r < 0)
1517 return log_warning_errno(r, "Failed to enqueue %s job for %s: %s", job_mode_to_string(mode), name, bus_error_message(&error, r));
1518
1519 return r;
1520 }
1521
1522 int manager_propagate_reload(Manager *m, Unit *unit, JobMode mode, sd_bus_error *e) {
1523 int r;
1524 Transaction *tr;
1525
1526 assert(m);
1527 assert(unit);
1528 assert(mode < _JOB_MODE_MAX);
1529 assert(mode != JOB_ISOLATE); /* Isolate is only valid for start */
1530
1531 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1532 if (!tr)
1533 return -ENOMEM;
1534
1535 /* We need an anchor job */
1536 r = transaction_add_job_and_dependencies(tr, JOB_NOP, unit, NULL, false, false, true, true, e);
1537 if (r < 0)
1538 goto tr_abort;
1539
1540 /* Failure in adding individual dependencies is ignored, so this always succeeds. */
1541 transaction_add_propagate_reload_jobs(tr, unit, tr->anchor_job, mode == JOB_IGNORE_DEPENDENCIES, e);
1542
1543 r = transaction_activate(tr, m, mode, e);
1544 if (r < 0)
1545 goto tr_abort;
1546
1547 transaction_free(tr);
1548 return 0;
1549
1550 tr_abort:
1551 transaction_abort(tr);
1552 transaction_free(tr);
1553 return r;
1554 }
1555
1556 Job *manager_get_job(Manager *m, uint32_t id) {
1557 assert(m);
1558
1559 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1560 }
1561
1562 Unit *manager_get_unit(Manager *m, const char *name) {
1563 assert(m);
1564 assert(name);
1565
1566 return hashmap_get(m->units, name);
1567 }
1568
1569 unsigned manager_dispatch_load_queue(Manager *m) {
1570 Unit *u;
1571 unsigned n = 0;
1572
1573 assert(m);
1574
1575 /* Make sure we are not run recursively */
1576 if (m->dispatching_load_queue)
1577 return 0;
1578
1579 m->dispatching_load_queue = true;
1580
1581 /* Dispatches the load queue. Takes a unit from the queue and
1582 * tries to load its data until the queue is empty */
1583
1584 while ((u = m->load_queue)) {
1585 assert(u->in_load_queue);
1586
1587 unit_load(u);
1588 n++;
1589 }
1590
1591 m->dispatching_load_queue = false;
1592 return n;
1593 }
1594
1595 int manager_load_unit_prepare(
1596 Manager *m,
1597 const char *name,
1598 const char *path,
1599 sd_bus_error *e,
1600 Unit **_ret) {
1601
1602 Unit *ret;
1603 UnitType t;
1604 int r;
1605
1606 assert(m);
1607 assert(name || path);
1608 assert(_ret);
1609
1610 /* This will prepare the unit for loading, but not actually
1611 * load anything from disk. */
1612
1613 if (path && !is_path(path))
1614 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1615
1616 if (!name)
1617 name = basename(path);
1618
1619 t = unit_name_to_type(name);
1620
1621 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE)) {
1622 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE))
1623 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is missing the instance name.", name);
1624
1625 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1626 }
1627
1628 ret = manager_get_unit(m, name);
1629 if (ret) {
1630 *_ret = ret;
1631 return 1;
1632 }
1633
1634 ret = unit_new(m, unit_vtable[t]->object_size);
1635 if (!ret)
1636 return -ENOMEM;
1637
1638 if (path) {
1639 ret->fragment_path = strdup(path);
1640 if (!ret->fragment_path) {
1641 unit_free(ret);
1642 return -ENOMEM;
1643 }
1644 }
1645
1646 r = unit_add_name(ret, name);
1647 if (r < 0) {
1648 unit_free(ret);
1649 return r;
1650 }
1651
1652 unit_add_to_load_queue(ret);
1653 unit_add_to_dbus_queue(ret);
1654 unit_add_to_gc_queue(ret);
1655
1656 *_ret = ret;
1657
1658 return 0;
1659 }
1660
1661 int manager_load_unit(
1662 Manager *m,
1663 const char *name,
1664 const char *path,
1665 sd_bus_error *e,
1666 Unit **_ret) {
1667
1668 int r;
1669
1670 assert(m);
1671 assert(_ret);
1672
1673 /* This will load the service information files, but not actually
1674 * start any services or anything. */
1675
1676 r = manager_load_unit_prepare(m, name, path, e, _ret);
1677 if (r != 0)
1678 return r;
1679
1680 manager_dispatch_load_queue(m);
1681
1682 *_ret = unit_follow_merge(*_ret);
1683
1684 return 0;
1685 }
1686
1687 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1688 Iterator i;
1689 Job *j;
1690
1691 assert(s);
1692 assert(f);
1693
1694 HASHMAP_FOREACH(j, s->jobs, i)
1695 job_dump(j, f, prefix);
1696 }
1697
1698 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1699 Iterator i;
1700 Unit *u;
1701 const char *t;
1702
1703 assert(s);
1704 assert(f);
1705
1706 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1707 if (u->id == t)
1708 unit_dump(u, f, prefix);
1709 }
1710
1711 void manager_clear_jobs(Manager *m) {
1712 Job *j;
1713
1714 assert(m);
1715
1716 while ((j = hashmap_first(m->jobs)))
1717 /* No need to recurse. We're cancelling all jobs. */
1718 job_finish_and_invalidate(j, JOB_CANCELED, false, false);
1719 }
1720
1721 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1722 Manager *m = userdata;
1723 Job *j;
1724
1725 assert(source);
1726 assert(m);
1727
1728 while ((j = m->run_queue)) {
1729 assert(j->installed);
1730 assert(j->in_run_queue);
1731
1732 job_run_and_invalidate(j);
1733 }
1734
1735 if (m->n_running_jobs > 0)
1736 manager_watch_jobs_in_progress(m);
1737
1738 if (m->n_on_console > 0)
1739 manager_watch_idle_pipe(m);
1740
1741 return 1;
1742 }
1743
1744 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1745 Job *j;
1746 Unit *u;
1747 unsigned n = 0;
1748
1749 assert(m);
1750
1751 if (m->dispatching_dbus_queue)
1752 return 0;
1753
1754 m->dispatching_dbus_queue = true;
1755
1756 while ((u = m->dbus_unit_queue)) {
1757 assert(u->in_dbus_queue);
1758
1759 bus_unit_send_change_signal(u);
1760 n++;
1761 }
1762
1763 while ((j = m->dbus_job_queue)) {
1764 assert(j->in_dbus_queue);
1765
1766 bus_job_send_change_signal(j);
1767 n++;
1768 }
1769
1770 m->dispatching_dbus_queue = false;
1771
1772 if (m->send_reloading_done) {
1773 m->send_reloading_done = false;
1774
1775 bus_manager_send_reloading(m, false);
1776 }
1777
1778 if (m->queued_message)
1779 bus_send_queued_message(m);
1780
1781 return n;
1782 }
1783
1784 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1785 Manager *m = userdata;
1786 char buf[PATH_MAX+1];
1787 ssize_t n;
1788
1789 n = recv(fd, buf, sizeof(buf), 0);
1790 if (n < 0)
1791 return log_error_errno(errno, "Failed to read cgroups agent message: %m");
1792 if (n == 0) {
1793 log_error("Got zero-length cgroups agent message, ignoring.");
1794 return 0;
1795 }
1796 if ((size_t) n >= sizeof(buf)) {
1797 log_error("Got overly long cgroups agent message, ignoring.");
1798 return 0;
1799 }
1800
1801 if (memchr(buf, 0, n)) {
1802 log_error("Got cgroups agent message with embedded NUL byte, ignoring.");
1803 return 0;
1804 }
1805 buf[n] = 0;
1806
1807 manager_notify_cgroup_empty(m, buf);
1808 (void) bus_forward_agent_released(m, buf);
1809
1810 return 0;
1811 }
1812
1813 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, const char *buf, FDSet *fds) {
1814 _cleanup_strv_free_ char **tags = NULL;
1815
1816 assert(m);
1817 assert(u);
1818 assert(buf);
1819
1820 tags = strv_split(buf, "\n\r");
1821 if (!tags) {
1822 log_oom();
1823 return;
1824 }
1825
1826 if (UNIT_VTABLE(u)->notify_message)
1827 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1828 else if (_unlikely_(log_get_max_level() >= LOG_DEBUG)) {
1829 _cleanup_free_ char *x = NULL, *y = NULL;
1830
1831 x = cescape(buf);
1832 if (x)
1833 y = ellipsize(x, 20, 90);
1834 log_unit_debug(u, "Got notification message \"%s\", ignoring.", strnull(y));
1835 }
1836 }
1837
1838 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1839
1840 _cleanup_fdset_free_ FDSet *fds = NULL;
1841 Manager *m = userdata;
1842 char buf[NOTIFY_BUFFER_MAX+1];
1843 struct iovec iovec = {
1844 .iov_base = buf,
1845 .iov_len = sizeof(buf)-1,
1846 };
1847 union {
1848 struct cmsghdr cmsghdr;
1849 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1850 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1851 } control = {};
1852 struct msghdr msghdr = {
1853 .msg_iov = &iovec,
1854 .msg_iovlen = 1,
1855 .msg_control = &control,
1856 .msg_controllen = sizeof(control),
1857 };
1858
1859 struct cmsghdr *cmsg;
1860 struct ucred *ucred = NULL;
1861 Unit *u1, *u2, *u3;
1862 int r, *fd_array = NULL;
1863 unsigned n_fds = 0;
1864 ssize_t n;
1865
1866 assert(m);
1867 assert(m->notify_fd == fd);
1868
1869 if (revents != EPOLLIN) {
1870 log_warning("Got unexpected poll event for notify fd.");
1871 return 0;
1872 }
1873
1874 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC|MSG_TRUNC);
1875 if (n < 0) {
1876 if (IN_SET(errno, EAGAIN, EINTR))
1877 return 0; /* Spurious wakeup, try again */
1878
1879 /* If this is any other, real error, then let's stop processing this socket. This of course means we
1880 * won't take notification messages anymore, but that's still better than busy looping around this:
1881 * being woken up over and over again but being unable to actually read the message off the socket. */
1882 return log_error_errno(errno, "Failed to receive notification message: %m");
1883 }
1884
1885 CMSG_FOREACH(cmsg, &msghdr) {
1886 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1887
1888 fd_array = (int*) CMSG_DATA(cmsg);
1889 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1890
1891 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1892 cmsg->cmsg_type == SCM_CREDENTIALS &&
1893 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1894
1895 ucred = (struct ucred*) CMSG_DATA(cmsg);
1896 }
1897 }
1898
1899 if (n_fds > 0) {
1900 assert(fd_array);
1901
1902 r = fdset_new_array(&fds, fd_array, n_fds);
1903 if (r < 0) {
1904 close_many(fd_array, n_fds);
1905 log_oom();
1906 return 0;
1907 }
1908 }
1909
1910 if (!ucred || ucred->pid <= 0) {
1911 log_warning("Received notify message without valid credentials. Ignoring.");
1912 return 0;
1913 }
1914
1915 if ((size_t) n >= sizeof(buf) || (msghdr.msg_flags & MSG_TRUNC)) {
1916 log_warning("Received notify message exceeded maximum size. Ignoring.");
1917 return 0;
1918 }
1919
1920 /* As extra safety check, let's make sure the string we get doesn't contain embedded NUL bytes. We permit one
1921 * trailing NUL byte in the message, but don't expect it. */
1922 if (n > 1 && memchr(buf, 0, n-1)) {
1923 log_warning("Received notify message with embedded NUL bytes. Ignoring.");
1924 return 0;
1925 }
1926
1927 /* Make sure it's NUL-terminated. */
1928 buf[n] = 0;
1929
1930 /* Notify every unit that might be interested, but try
1931 * to avoid notifying the same one multiple times. */
1932 u1 = manager_get_unit_by_pid_cgroup(m, ucred->pid);
1933 if (u1)
1934 manager_invoke_notify_message(m, u1, ucred->pid, buf, fds);
1935
1936 u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(ucred->pid));
1937 if (u2 && u2 != u1)
1938 manager_invoke_notify_message(m, u2, ucred->pid, buf, fds);
1939
1940 u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(ucred->pid));
1941 if (u3 && u3 != u2 && u3 != u1)
1942 manager_invoke_notify_message(m, u3, ucred->pid, buf, fds);
1943
1944 if (!u1 && !u2 && !u3)
1945 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1946
1947 if (fdset_size(fds) > 0)
1948 log_warning("Got extra auxiliary fds with notification message, closing them.");
1949
1950 return 0;
1951 }
1952
1953 static void invoke_sigchld_event(Manager *m, Unit *u, const siginfo_t *si) {
1954 uint64_t iteration;
1955
1956 assert(m);
1957 assert(u);
1958 assert(si);
1959
1960 sd_event_get_iteration(m->event, &iteration);
1961
1962 log_unit_debug(u, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1963
1964 unit_unwatch_pid(u, si->si_pid);
1965
1966 if (UNIT_VTABLE(u)->sigchld_event) {
1967 if (set_size(u->pids) <= 1 ||
1968 iteration != u->sigchldgen ||
1969 unit_main_pid(u) == si->si_pid ||
1970 unit_control_pid(u) == si->si_pid) {
1971 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1972 u->sigchldgen = iteration;
1973 } else
1974 log_debug("%s already issued a sigchld this iteration %" PRIu64 ", skipping. Pids still being watched %d", u->id, iteration, set_size(u->pids));
1975 }
1976 }
1977
1978 static int manager_dispatch_sigchld(Manager *m) {
1979 assert(m);
1980
1981 for (;;) {
1982 siginfo_t si = {};
1983
1984 /* First we call waitd() for a PID and do not reap the
1985 * zombie. That way we can still access /proc/$PID for
1986 * it while it is a zombie. */
1987 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1988
1989 if (errno == ECHILD)
1990 break;
1991
1992 if (errno == EINTR)
1993 continue;
1994
1995 return -errno;
1996 }
1997
1998 if (si.si_pid <= 0)
1999 break;
2000
2001 if (IN_SET(si.si_code, CLD_EXITED, CLD_KILLED, CLD_DUMPED)) {
2002 _cleanup_free_ char *name = NULL;
2003 Unit *u1, *u2, *u3;
2004
2005 get_process_comm(si.si_pid, &name);
2006
2007 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
2008 si.si_pid, strna(name),
2009 sigchld_code_to_string(si.si_code),
2010 si.si_status,
2011 strna(si.si_code == CLD_EXITED
2012 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
2013 : signal_to_string(si.si_status)));
2014
2015 /* And now figure out the unit this belongs
2016 * to, it might be multiple... */
2017 u1 = manager_get_unit_by_pid_cgroup(m, si.si_pid);
2018 if (u1)
2019 invoke_sigchld_event(m, u1, &si);
2020 u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(si.si_pid));
2021 if (u2 && u2 != u1)
2022 invoke_sigchld_event(m, u2, &si);
2023 u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(si.si_pid));
2024 if (u3 && u3 != u2 && u3 != u1)
2025 invoke_sigchld_event(m, u3, &si);
2026 }
2027
2028 /* And now, we actually reap the zombie. */
2029 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
2030 if (errno == EINTR)
2031 continue;
2032
2033 return -errno;
2034 }
2035 }
2036
2037 return 0;
2038 }
2039
2040 static void manager_start_target(Manager *m, const char *name, JobMode mode) {
2041 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2042 int r;
2043
2044 log_debug("Activating special unit %s", name);
2045
2046 r = manager_add_job_by_name(m, JOB_START, name, mode, &error, NULL);
2047 if (r < 0)
2048 log_error("Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
2049 }
2050
2051 static void manager_handle_ctrl_alt_del(Manager *m) {
2052 /* If the user presses C-A-D more than
2053 * 7 times within 2s, we reboot/shutdown immediately,
2054 * unless it was disabled in system.conf */
2055
2056 if (ratelimit_test(&m->ctrl_alt_del_ratelimit) || m->cad_burst_action == EMERGENCY_ACTION_NONE)
2057 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
2058 else
2059 emergency_action(m, m->cad_burst_action, NULL,
2060 "Ctrl-Alt-Del was pressed more than 7 times within 2s");
2061 }
2062
2063 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2064 Manager *m = userdata;
2065 ssize_t n;
2066 struct signalfd_siginfo sfsi;
2067 bool sigchld = false;
2068 int r;
2069
2070 assert(m);
2071 assert(m->signal_fd == fd);
2072
2073 if (revents != EPOLLIN) {
2074 log_warning("Got unexpected events from signal file descriptor.");
2075 return 0;
2076 }
2077
2078 for (;;) {
2079 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
2080 if (n != sizeof(sfsi)) {
2081 if (n >= 0) {
2082 log_warning("Truncated read from signal fd (%zu bytes)!", n);
2083 return 0;
2084 }
2085
2086 if (IN_SET(errno, EINTR, EAGAIN))
2087 break;
2088
2089 /* We return an error here, which will kill this handler,
2090 * to avoid a busy loop on read error. */
2091 return log_error_errno(errno, "Reading from signal fd failed: %m");
2092 }
2093
2094 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
2095 (sfsi.ssi_signo == SIGTERM && MANAGER_IS_USER(m))
2096 ? LOG_DEBUG : LOG_INFO,
2097 &sfsi);
2098
2099 switch (sfsi.ssi_signo) {
2100
2101 case SIGCHLD:
2102 sigchld = true;
2103 break;
2104
2105 case SIGTERM:
2106 if (MANAGER_IS_SYSTEM(m)) {
2107 /* This is for compatibility with the
2108 * original sysvinit */
2109 r = verify_run_space_and_log("Refusing to reexecute");
2110 if (r >= 0)
2111 m->exit_code = MANAGER_REEXECUTE;
2112 break;
2113 }
2114
2115 /* Fall through */
2116
2117 case SIGINT:
2118 if (MANAGER_IS_SYSTEM(m))
2119 manager_handle_ctrl_alt_del(m);
2120 else
2121 manager_start_target(m, SPECIAL_EXIT_TARGET,
2122 JOB_REPLACE_IRREVERSIBLY);
2123 break;
2124
2125 case SIGWINCH:
2126 if (MANAGER_IS_SYSTEM(m))
2127 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2128
2129 /* This is a nop on non-init */
2130 break;
2131
2132 case SIGPWR:
2133 if (MANAGER_IS_SYSTEM(m))
2134 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2135
2136 /* This is a nop on non-init */
2137 break;
2138
2139 case SIGUSR1: {
2140 Unit *u;
2141
2142 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
2143
2144 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
2145 log_info("Trying to reconnect to bus...");
2146 bus_init(m, true);
2147 }
2148
2149 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
2150 log_info("Loading D-Bus service...");
2151 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2152 }
2153
2154 break;
2155 }
2156
2157 case SIGUSR2: {
2158 _cleanup_free_ char *dump = NULL;
2159 _cleanup_fclose_ FILE *f = NULL;
2160 size_t size;
2161
2162 f = open_memstream(&dump, &size);
2163 if (!f) {
2164 log_warning_errno(errno, "Failed to allocate memory stream: %m");
2165 break;
2166 }
2167
2168 manager_dump_units(m, f, "\t");
2169 manager_dump_jobs(m, f, "\t");
2170
2171 r = fflush_and_check(f);
2172 if (r < 0) {
2173 log_warning_errno(r, "Failed to write status stream: %m");
2174 break;
2175 }
2176
2177 log_dump(LOG_INFO, dump);
2178 break;
2179 }
2180
2181 case SIGHUP:
2182 r = verify_run_space_and_log("Refusing to reload");
2183 if (r >= 0)
2184 m->exit_code = MANAGER_RELOAD;
2185 break;
2186
2187 default: {
2188
2189 /* Starting SIGRTMIN+0 */
2190 static const struct {
2191 const char *target;
2192 JobMode mode;
2193 } target_table[] = {
2194 [0] = { SPECIAL_DEFAULT_TARGET, JOB_ISOLATE },
2195 [1] = { SPECIAL_RESCUE_TARGET, JOB_ISOLATE },
2196 [2] = { SPECIAL_EMERGENCY_TARGET, JOB_ISOLATE },
2197 [3] = { SPECIAL_HALT_TARGET, JOB_REPLACE_IRREVERSIBLY },
2198 [4] = { SPECIAL_POWEROFF_TARGET, JOB_REPLACE_IRREVERSIBLY },
2199 [5] = { SPECIAL_REBOOT_TARGET, JOB_REPLACE_IRREVERSIBLY },
2200 [6] = { SPECIAL_KEXEC_TARGET, JOB_REPLACE_IRREVERSIBLY }
2201 };
2202
2203 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2204 static const ManagerExitCode code_table[] = {
2205 [0] = MANAGER_HALT,
2206 [1] = MANAGER_POWEROFF,
2207 [2] = MANAGER_REBOOT,
2208 [3] = MANAGER_KEXEC
2209 };
2210
2211 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2212 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2213 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2214 manager_start_target(m, target_table[idx].target,
2215 target_table[idx].mode);
2216 break;
2217 }
2218
2219 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2220 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
2221 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
2222 break;
2223 }
2224
2225 switch (sfsi.ssi_signo - SIGRTMIN) {
2226
2227 case 20:
2228 manager_set_show_status(m, SHOW_STATUS_YES);
2229 break;
2230
2231 case 21:
2232 manager_set_show_status(m, SHOW_STATUS_NO);
2233 break;
2234
2235 case 22:
2236 log_set_max_level(LOG_DEBUG);
2237 log_info("Setting log level to debug.");
2238 break;
2239
2240 case 23:
2241 log_set_max_level(LOG_INFO);
2242 log_info("Setting log level to info.");
2243 break;
2244
2245 case 24:
2246 if (MANAGER_IS_USER(m)) {
2247 m->exit_code = MANAGER_EXIT;
2248 return 0;
2249 }
2250
2251 /* This is a nop on init */
2252 break;
2253
2254 case 26:
2255 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
2256 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
2257 log_notice("Setting log target to journal-or-kmsg.");
2258 break;
2259
2260 case 27:
2261 log_set_target(LOG_TARGET_CONSOLE);
2262 log_notice("Setting log target to console.");
2263 break;
2264
2265 case 28:
2266 log_set_target(LOG_TARGET_KMSG);
2267 log_notice("Setting log target to kmsg.");
2268 break;
2269
2270 default:
2271 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2272 }
2273 }
2274 }
2275 }
2276
2277 if (sigchld)
2278 manager_dispatch_sigchld(m);
2279
2280 return 0;
2281 }
2282
2283 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2284 Manager *m = userdata;
2285 Iterator i;
2286 Unit *u;
2287
2288 assert(m);
2289 assert(m->time_change_fd == fd);
2290
2291 log_struct(LOG_DEBUG,
2292 "MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
2293 LOG_MESSAGE("Time has been changed"),
2294 NULL);
2295
2296 /* Restart the watch */
2297 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
2298 m->time_change_fd = safe_close(m->time_change_fd);
2299
2300 manager_setup_time_change(m);
2301
2302 HASHMAP_FOREACH(u, m->units, i)
2303 if (UNIT_VTABLE(u)->time_change)
2304 UNIT_VTABLE(u)->time_change(u);
2305
2306 return 0;
2307 }
2308
2309 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2310 Manager *m = userdata;
2311
2312 assert(m);
2313 assert(m->idle_pipe[2] == fd);
2314
2315 m->no_console_output = m->n_on_console > 0;
2316
2317 manager_close_idle_pipe(m);
2318
2319 return 0;
2320 }
2321
2322 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
2323 Manager *m = userdata;
2324 int r;
2325 uint64_t next;
2326
2327 assert(m);
2328 assert(source);
2329
2330 manager_print_jobs_in_progress(m);
2331
2332 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
2333 r = sd_event_source_set_time(source, next);
2334 if (r < 0)
2335 return r;
2336
2337 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
2338 }
2339
2340 int manager_loop(Manager *m) {
2341 int r;
2342
2343 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
2344
2345 assert(m);
2346 m->exit_code = MANAGER_OK;
2347
2348 /* Release the path cache */
2349 m->unit_path_cache = set_free_free(m->unit_path_cache);
2350
2351 manager_check_finished(m);
2352
2353 /* There might still be some zombies hanging around from
2354 * before we were exec()'ed. Let's reap them. */
2355 r = manager_dispatch_sigchld(m);
2356 if (r < 0)
2357 return r;
2358
2359 while (m->exit_code == MANAGER_OK) {
2360 usec_t wait_usec;
2361
2362 if (m->runtime_watchdog > 0 && m->runtime_watchdog != USEC_INFINITY && MANAGER_IS_SYSTEM(m))
2363 watchdog_ping();
2364
2365 if (!ratelimit_test(&rl)) {
2366 /* Yay, something is going seriously wrong, pause a little */
2367 log_warning("Looping too fast. Throttling execution a little.");
2368 sleep(1);
2369 }
2370
2371 if (manager_dispatch_load_queue(m) > 0)
2372 continue;
2373
2374 if (manager_dispatch_gc_job_queue(m) > 0)
2375 continue;
2376
2377 if (manager_dispatch_gc_unit_queue(m) > 0)
2378 continue;
2379
2380 if (manager_dispatch_cleanup_queue(m) > 0)
2381 continue;
2382
2383 if (manager_dispatch_cgroup_realize_queue(m) > 0)
2384 continue;
2385
2386 if (manager_dispatch_dbus_queue(m) > 0)
2387 continue;
2388
2389 /* Sleep for half the watchdog time */
2390 if (m->runtime_watchdog > 0 && m->runtime_watchdog != USEC_INFINITY && MANAGER_IS_SYSTEM(m)) {
2391 wait_usec = m->runtime_watchdog / 2;
2392 if (wait_usec <= 0)
2393 wait_usec = 1;
2394 } else
2395 wait_usec = USEC_INFINITY;
2396
2397 r = sd_event_run(m->event, wait_usec);
2398 if (r < 0)
2399 return log_error_errno(r, "Failed to run event loop: %m");
2400 }
2401
2402 return m->exit_code;
2403 }
2404
2405 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2406 _cleanup_free_ char *n = NULL;
2407 sd_id128_t invocation_id;
2408 Unit *u;
2409 int r;
2410
2411 assert(m);
2412 assert(s);
2413 assert(_u);
2414
2415 r = unit_name_from_dbus_path(s, &n);
2416 if (r < 0)
2417 return r;
2418
2419 /* Permit addressing units by invocation ID: if the passed bus path is suffixed by a 128bit ID then we use it
2420 * as invocation ID. */
2421 r = sd_id128_from_string(n, &invocation_id);
2422 if (r >= 0) {
2423 u = hashmap_get(m->units_by_invocation_id, &invocation_id);
2424 if (u) {
2425 *_u = u;
2426 return 0;
2427 }
2428
2429 return sd_bus_error_setf(e, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID, "No unit with the specified invocation ID " SD_ID128_FORMAT_STR " known.", SD_ID128_FORMAT_VAL(invocation_id));
2430 }
2431
2432 /* If this didn't work, we check if this is a unit name */
2433 if (!unit_name_is_valid(n, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
2434 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is neither a valid invocation ID nor unit name.", n);
2435
2436 r = manager_load_unit(m, n, NULL, e, &u);
2437 if (r < 0)
2438 return r;
2439
2440 *_u = u;
2441 return 0;
2442 }
2443
2444 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2445 const char *p;
2446 unsigned id;
2447 Job *j;
2448 int r;
2449
2450 assert(m);
2451 assert(s);
2452 assert(_j);
2453
2454 p = startswith(s, "/org/freedesktop/systemd1/job/");
2455 if (!p)
2456 return -EINVAL;
2457
2458 r = safe_atou(p, &id);
2459 if (r < 0)
2460 return r;
2461
2462 j = manager_get_job(m, id);
2463 if (!j)
2464 return -ENOENT;
2465
2466 *_j = j;
2467
2468 return 0;
2469 }
2470
2471 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2472
2473 #if HAVE_AUDIT
2474 _cleanup_free_ char *p = NULL;
2475 const char *msg;
2476 int audit_fd, r;
2477
2478 if (!MANAGER_IS_SYSTEM(m))
2479 return;
2480
2481 audit_fd = get_audit_fd();
2482 if (audit_fd < 0)
2483 return;
2484
2485 /* Don't generate audit events if the service was already
2486 * started and we're just deserializing */
2487 if (MANAGER_IS_RELOADING(m))
2488 return;
2489
2490 if (u->type != UNIT_SERVICE)
2491 return;
2492
2493 r = unit_name_to_prefix_and_instance(u->id, &p);
2494 if (r < 0) {
2495 log_error_errno(r, "Failed to extract prefix and instance of unit name: %m");
2496 return;
2497 }
2498
2499 msg = strjoina("unit=", p);
2500 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2501 if (errno == EPERM)
2502 /* We aren't allowed to send audit messages?
2503 * Then let's not retry again. */
2504 close_audit_fd();
2505 else
2506 log_warning_errno(errno, "Failed to send audit message: %m");
2507 }
2508 #endif
2509
2510 }
2511
2512 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2513 static const union sockaddr_union sa = PLYMOUTH_SOCKET;
2514 _cleanup_free_ char *message = NULL;
2515 _cleanup_close_ int fd = -1;
2516 int n = 0;
2517
2518 /* Don't generate plymouth events if the service was already
2519 * started and we're just deserializing */
2520 if (MANAGER_IS_RELOADING(m))
2521 return;
2522
2523 if (!MANAGER_IS_SYSTEM(m))
2524 return;
2525
2526 if (detect_container() > 0)
2527 return;
2528
2529 if (!IN_SET(u->type, UNIT_SERVICE, UNIT_MOUNT, UNIT_SWAP))
2530 return;
2531
2532 /* We set SOCK_NONBLOCK here so that we rather drop the
2533 * message then wait for plymouth */
2534 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2535 if (fd < 0) {
2536 log_error_errno(errno, "socket() failed: %m");
2537 return;
2538 }
2539
2540 if (connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
2541
2542 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2543 log_error_errno(errno, "connect() failed: %m");
2544 return;
2545 }
2546
2547 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2548 log_oom();
2549 return;
2550 }
2551
2552 errno = 0;
2553 if (write(fd, message, n + 1) != n + 1)
2554 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2555 log_error_errno(errno, "Failed to write Plymouth message: %m");
2556 }
2557
2558 int manager_open_serialization(Manager *m, FILE **_f) {
2559 int fd;
2560 FILE *f;
2561
2562 assert(_f);
2563
2564 fd = open_serialization_fd("systemd-state");
2565 if (fd < 0)
2566 return fd;
2567
2568 f = fdopen(fd, "w+");
2569 if (!f) {
2570 safe_close(fd);
2571 return -errno;
2572 }
2573
2574 *_f = f;
2575 return 0;
2576 }
2577
2578 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2579 Iterator i;
2580 Unit *u;
2581 const char *t;
2582 int r;
2583
2584 assert(m);
2585 assert(f);
2586 assert(fds);
2587
2588 m->n_reloading++;
2589
2590 fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2591 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2592 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2593 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2594 fprintf(f, "ready-sent=%s\n", yes_no(m->ready_sent));
2595
2596 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2597 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2598 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2599 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2600
2601 if (!in_initrd()) {
2602 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2603 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2604 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2605 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2606 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2607 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2608 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2609 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2610 }
2611
2612 if (!switching_root)
2613 (void) serialize_environment(f, m->environment);
2614
2615 if (m->notify_fd >= 0) {
2616 int copy;
2617
2618 copy = fdset_put_dup(fds, m->notify_fd);
2619 if (copy < 0)
2620 return copy;
2621
2622 fprintf(f, "notify-fd=%i\n", copy);
2623 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2624 }
2625
2626 if (m->cgroups_agent_fd >= 0) {
2627 int copy;
2628
2629 copy = fdset_put_dup(fds, m->cgroups_agent_fd);
2630 if (copy < 0)
2631 return copy;
2632
2633 fprintf(f, "cgroups-agent-fd=%i\n", copy);
2634 }
2635
2636 if (m->user_lookup_fds[0] >= 0) {
2637 int copy0, copy1;
2638
2639 copy0 = fdset_put_dup(fds, m->user_lookup_fds[0]);
2640 if (copy0 < 0)
2641 return copy0;
2642
2643 copy1 = fdset_put_dup(fds, m->user_lookup_fds[1]);
2644 if (copy1 < 0)
2645 return copy1;
2646
2647 fprintf(f, "user-lookup=%i %i\n", copy0, copy1);
2648 }
2649
2650 bus_track_serialize(m->subscribed, f, "subscribed");
2651
2652 r = dynamic_user_serialize(m, f, fds);
2653 if (r < 0)
2654 return r;
2655
2656 manager_serialize_uid_refs(m, f);
2657 manager_serialize_gid_refs(m, f);
2658
2659 fputc_unlocked('\n', f);
2660
2661 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2662 if (u->id != t)
2663 continue;
2664
2665 /* Start marker */
2666 fputs_unlocked(u->id, f);
2667 fputc_unlocked('\n', f);
2668
2669 r = unit_serialize(u, f, fds, !switching_root);
2670 if (r < 0) {
2671 m->n_reloading--;
2672 return r;
2673 }
2674 }
2675
2676 assert(m->n_reloading > 0);
2677 m->n_reloading--;
2678
2679 if (ferror(f))
2680 return -EIO;
2681
2682 r = bus_fdset_add_all(m, fds);
2683 if (r < 0)
2684 return r;
2685
2686 return 0;
2687 }
2688
2689 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2690 int r = 0;
2691
2692 assert(m);
2693 assert(f);
2694
2695 log_debug("Deserializing state...");
2696
2697 m->n_reloading++;
2698
2699 for (;;) {
2700 char line[LINE_MAX];
2701 const char *val, *l;
2702
2703 if (!fgets(line, sizeof(line), f)) {
2704 if (feof(f))
2705 r = 0;
2706 else
2707 r = -errno;
2708
2709 goto finish;
2710 }
2711
2712 char_array_0(line);
2713 l = strstrip(line);
2714
2715 if (l[0] == 0)
2716 break;
2717
2718 if ((val = startswith(l, "current-job-id="))) {
2719 uint32_t id;
2720
2721 if (safe_atou32(val, &id) < 0)
2722 log_notice("Failed to parse current job id value %s", val);
2723 else
2724 m->current_job_id = MAX(m->current_job_id, id);
2725
2726 } else if ((val = startswith(l, "n-installed-jobs="))) {
2727 uint32_t n;
2728
2729 if (safe_atou32(val, &n) < 0)
2730 log_notice("Failed to parse installed jobs counter %s", val);
2731 else
2732 m->n_installed_jobs += n;
2733
2734 } else if ((val = startswith(l, "n-failed-jobs="))) {
2735 uint32_t n;
2736
2737 if (safe_atou32(val, &n) < 0)
2738 log_notice("Failed to parse failed jobs counter %s", val);
2739 else
2740 m->n_failed_jobs += n;
2741
2742 } else if ((val = startswith(l, "taint-usr="))) {
2743 int b;
2744
2745 b = parse_boolean(val);
2746 if (b < 0)
2747 log_notice("Failed to parse taint /usr flag %s", val);
2748 else
2749 m->taint_usr = m->taint_usr || b;
2750
2751 } else if ((val = startswith(l, "ready-sent="))) {
2752 int b;
2753
2754 b = parse_boolean(val);
2755 if (b < 0)
2756 log_notice("Failed to parse ready-sent flag %s", val);
2757 else
2758 m->ready_sent = m->ready_sent || b;
2759
2760 } else if ((val = startswith(l, "firmware-timestamp=")))
2761 dual_timestamp_deserialize(val, &m->firmware_timestamp);
2762 else if ((val = startswith(l, "loader-timestamp=")))
2763 dual_timestamp_deserialize(val, &m->loader_timestamp);
2764 else if ((val = startswith(l, "kernel-timestamp=")))
2765 dual_timestamp_deserialize(val, &m->kernel_timestamp);
2766 else if ((val = startswith(l, "initrd-timestamp=")))
2767 dual_timestamp_deserialize(val, &m->initrd_timestamp);
2768 else if ((val = startswith(l, "userspace-timestamp=")))
2769 dual_timestamp_deserialize(val, &m->userspace_timestamp);
2770 else if ((val = startswith(l, "finish-timestamp=")))
2771 dual_timestamp_deserialize(val, &m->finish_timestamp);
2772 else if ((val = startswith(l, "security-start-timestamp=")))
2773 dual_timestamp_deserialize(val, &m->security_start_timestamp);
2774 else if ((val = startswith(l, "security-finish-timestamp=")))
2775 dual_timestamp_deserialize(val, &m->security_finish_timestamp);
2776 else if ((val = startswith(l, "generators-start-timestamp=")))
2777 dual_timestamp_deserialize(val, &m->generators_start_timestamp);
2778 else if ((val = startswith(l, "generators-finish-timestamp=")))
2779 dual_timestamp_deserialize(val, &m->generators_finish_timestamp);
2780 else if ((val = startswith(l, "units-load-start-timestamp=")))
2781 dual_timestamp_deserialize(val, &m->units_load_start_timestamp);
2782 else if ((val = startswith(l, "units-load-finish-timestamp=")))
2783 dual_timestamp_deserialize(val, &m->units_load_finish_timestamp);
2784 else if (startswith(l, "env=")) {
2785 r = deserialize_environment(&m->environment, l);
2786 if (r == -ENOMEM)
2787 goto finish;
2788 if (r < 0)
2789 log_notice_errno(r, "Failed to parse environment entry: \"%s\": %m", l);
2790
2791 } else if ((val = startswith(l, "notify-fd="))) {
2792 int fd;
2793
2794 if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2795 log_notice("Failed to parse notify fd: \"%s\"", val);
2796 else {
2797 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2798 safe_close(m->notify_fd);
2799 m->notify_fd = fdset_remove(fds, fd);
2800 }
2801
2802 } else if ((val = startswith(l, "notify-socket="))) {
2803 char *n;
2804
2805 n = strdup(val);
2806 if (!n) {
2807 r = -ENOMEM;
2808 goto finish;
2809 }
2810
2811 free(m->notify_socket);
2812 m->notify_socket = n;
2813
2814 } else if ((val = startswith(l, "cgroups-agent-fd="))) {
2815 int fd;
2816
2817 if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2818 log_notice("Failed to parse cgroups agent fd: %s", val);
2819 else {
2820 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
2821 safe_close(m->cgroups_agent_fd);
2822 m->cgroups_agent_fd = fdset_remove(fds, fd);
2823 }
2824
2825 } else if ((val = startswith(l, "user-lookup="))) {
2826 int fd0, fd1;
2827
2828 if (sscanf(val, "%i %i", &fd0, &fd1) != 2 || fd0 < 0 || fd1 < 0 || fd0 == fd1 || !fdset_contains(fds, fd0) || !fdset_contains(fds, fd1))
2829 log_notice("Failed to parse user lookup fd: %s", val);
2830 else {
2831 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
2832 safe_close_pair(m->user_lookup_fds);
2833 m->user_lookup_fds[0] = fdset_remove(fds, fd0);
2834 m->user_lookup_fds[1] = fdset_remove(fds, fd1);
2835 }
2836
2837 } else if ((val = startswith(l, "dynamic-user=")))
2838 dynamic_user_deserialize_one(m, val, fds);
2839 else if ((val = startswith(l, "destroy-ipc-uid=")))
2840 manager_deserialize_uid_refs_one(m, val);
2841 else if ((val = startswith(l, "destroy-ipc-gid=")))
2842 manager_deserialize_gid_refs_one(m, val);
2843 else if ((val = startswith(l, "subscribed="))) {
2844
2845 if (strv_extend(&m->deserialized_subscribed, val) < 0)
2846 log_oom();
2847
2848 } else if (!startswith(l, "kdbus-fd=")) /* ignore this one */
2849 log_notice("Unknown serialization item '%s'", l);
2850 }
2851
2852 for (;;) {
2853 Unit *u;
2854 char name[UNIT_NAME_MAX+2];
2855 const char* unit_name;
2856
2857 /* Start marker */
2858 if (!fgets(name, sizeof(name), f)) {
2859 if (feof(f))
2860 r = 0;
2861 else
2862 r = -errno;
2863
2864 goto finish;
2865 }
2866
2867 char_array_0(name);
2868 unit_name = strstrip(name);
2869
2870 r = manager_load_unit(m, unit_name, NULL, NULL, &u);
2871 if (r < 0) {
2872 log_notice_errno(r, "Failed to load unit \"%s\", skipping deserialization: %m", unit_name);
2873 if (r == -ENOMEM)
2874 goto finish;
2875 unit_deserialize_skip(f);
2876 continue;
2877 }
2878
2879 r = unit_deserialize(u, f, fds);
2880 if (r < 0) {
2881 log_notice_errno(r, "Failed to deserialize unit \"%s\": %m", unit_name);
2882 if (r == -ENOMEM)
2883 goto finish;
2884 }
2885 }
2886
2887 finish:
2888 if (ferror(f))
2889 r = -EIO;
2890
2891 assert(m->n_reloading > 0);
2892 m->n_reloading--;
2893
2894 return r;
2895 }
2896
2897 int manager_reload(Manager *m) {
2898 int r, q;
2899 _cleanup_fclose_ FILE *f = NULL;
2900 _cleanup_fdset_free_ FDSet *fds = NULL;
2901
2902 assert(m);
2903
2904 r = manager_open_serialization(m, &f);
2905 if (r < 0)
2906 return r;
2907
2908 m->n_reloading++;
2909 bus_manager_send_reloading(m, true);
2910
2911 fds = fdset_new();
2912 if (!fds) {
2913 m->n_reloading--;
2914 return -ENOMEM;
2915 }
2916
2917 r = manager_serialize(m, f, fds, false);
2918 if (r < 0) {
2919 m->n_reloading--;
2920 return r;
2921 }
2922
2923 if (fseeko(f, 0, SEEK_SET) < 0) {
2924 m->n_reloading--;
2925 return -errno;
2926 }
2927
2928 /* From here on there is no way back. */
2929 manager_clear_jobs_and_units(m);
2930 lookup_paths_flush_generator(&m->lookup_paths);
2931 lookup_paths_free(&m->lookup_paths);
2932 dynamic_user_vacuum(m, false);
2933 m->uid_refs = hashmap_free(m->uid_refs);
2934 m->gid_refs = hashmap_free(m->gid_refs);
2935
2936 q = lookup_paths_init(&m->lookup_paths, m->unit_file_scope, 0, NULL);
2937 if (q < 0 && r >= 0)
2938 r = q;
2939
2940 q = manager_run_environment_generators(m);
2941 if (q < 0 && r >= 0)
2942 r = q;
2943
2944 /* Find new unit paths */
2945 q = manager_run_generators(m);
2946 if (q < 0 && r >= 0)
2947 r = q;
2948
2949 lookup_paths_reduce(&m->lookup_paths);
2950 manager_build_unit_path_cache(m);
2951
2952 /* First, enumerate what we can from all config files */
2953 manager_enumerate(m);
2954
2955 /* Second, deserialize our stored data */
2956 q = manager_deserialize(m, f, fds);
2957 if (q < 0) {
2958 log_error_errno(q, "Deserialization failed: %m");
2959
2960 if (r >= 0)
2961 r = q;
2962 }
2963
2964 fclose(f);
2965 f = NULL;
2966
2967 /* Re-register notify_fd as event source */
2968 q = manager_setup_notify(m);
2969 if (q < 0 && r >= 0)
2970 r = q;
2971
2972 q = manager_setup_cgroups_agent(m);
2973 if (q < 0 && r >= 0)
2974 r = q;
2975
2976 q = manager_setup_user_lookup_fd(m);
2977 if (q < 0 && r >= 0)
2978 r = q;
2979
2980 /* Third, fire things up! */
2981 manager_coldplug(m);
2982
2983 /* Release any dynamic users no longer referenced */
2984 dynamic_user_vacuum(m, true);
2985
2986 /* Release any references to UIDs/GIDs no longer referenced, and destroy any IPC owned by them */
2987 manager_vacuum_uid_refs(m);
2988 manager_vacuum_gid_refs(m);
2989
2990 /* Sync current state of bus names with our set of listening units */
2991 if (m->api_bus)
2992 manager_sync_bus_names(m, m->api_bus);
2993
2994 assert(m->n_reloading > 0);
2995 m->n_reloading--;
2996
2997 m->send_reloading_done = true;
2998
2999 return r;
3000 }
3001
3002 void manager_reset_failed(Manager *m) {
3003 Unit *u;
3004 Iterator i;
3005
3006 assert(m);
3007
3008 HASHMAP_FOREACH(u, m->units, i)
3009 unit_reset_failed(u);
3010 }
3011
3012 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
3013 Unit *u;
3014
3015 assert(m);
3016 assert(name);
3017
3018 /* Returns true if the unit is inactive or going down */
3019 u = manager_get_unit(m, name);
3020 if (!u)
3021 return true;
3022
3023 return unit_inactive_or_pending(u);
3024 }
3025
3026 static void manager_notify_finished(Manager *m) {
3027 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
3028 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
3029
3030 if (m->test_run_flags)
3031 return;
3032
3033 if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0) {
3034
3035 /* Note that m->kernel_usec.monotonic is always at 0,
3036 * and m->firmware_usec.monotonic and
3037 * m->loader_usec.monotonic should be considered
3038 * negative values. */
3039
3040 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
3041 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
3042 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
3043 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
3044
3045 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
3046
3047 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
3048 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
3049
3050 log_struct(LOG_INFO,
3051 "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
3052 "KERNEL_USEC="USEC_FMT, kernel_usec,
3053 "INITRD_USEC="USEC_FMT, initrd_usec,
3054 "USERSPACE_USEC="USEC_FMT, userspace_usec,
3055 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
3056 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
3057 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
3058 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
3059 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3060 NULL);
3061 } else {
3062 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
3063 initrd_usec = 0;
3064
3065 log_struct(LOG_INFO,
3066 "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
3067 "KERNEL_USEC="USEC_FMT, kernel_usec,
3068 "USERSPACE_USEC="USEC_FMT, userspace_usec,
3069 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
3070 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
3071 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
3072 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3073 NULL);
3074 }
3075 } else {
3076 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
3077 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
3078
3079 log_struct(LOG_INFO,
3080 "MESSAGE_ID=" SD_MESSAGE_USER_STARTUP_FINISHED_STR,
3081 "USERSPACE_USEC="USEC_FMT, userspace_usec,
3082 LOG_MESSAGE("Startup finished in %s.",
3083 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3084 NULL);
3085 }
3086
3087 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
3088
3089 sd_notifyf(false,
3090 m->ready_sent ? "STATUS=Startup finished in %s."
3091 : "READY=1\n"
3092 "STATUS=Startup finished in %s.",
3093 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
3094 m->ready_sent = true;
3095 }
3096
3097 void manager_check_finished(Manager *m) {
3098 assert(m);
3099
3100 if (MANAGER_IS_RELOADING(m))
3101 return;
3102
3103 /* Verify that we are actually running currently. Initially
3104 * the exit code is set to invalid, and during operation it is
3105 * then set to MANAGER_OK */
3106 if (m->exit_code != MANAGER_OK)
3107 return;
3108
3109 /* For user managers, send out READY=1 as soon as we reach basic.target */
3110 if (MANAGER_IS_USER(m) && !m->ready_sent) {
3111 Unit *u;
3112
3113 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3114 if (u && !u->job) {
3115 sd_notifyf(false,
3116 "READY=1\n"
3117 "STATUS=Reached " SPECIAL_BASIC_TARGET ".");
3118 m->ready_sent = true;
3119 }
3120 }
3121
3122 if (hashmap_size(m->jobs) > 0) {
3123 if (m->jobs_in_progress_event_source)
3124 /* Ignore any failure, this is only for feedback */
3125 (void) sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
3126
3127 return;
3128 }
3129
3130 manager_flip_auto_status(m, false);
3131
3132 /* Notify Type=idle units that we are done now */
3133 manager_close_idle_pipe(m);
3134
3135 /* Turn off confirm spawn now */
3136 m->confirm_spawn = NULL;
3137
3138 /* No need to update ask password status when we're going non-interactive */
3139 manager_close_ask_password(m);
3140
3141 /* This is no longer the first boot */
3142 manager_set_first_boot(m, false);
3143
3144 if (dual_timestamp_is_set(&m->finish_timestamp))
3145 return;
3146
3147 dual_timestamp_get(&m->finish_timestamp);
3148
3149 manager_notify_finished(m);
3150
3151 manager_invalidate_startup_units(m);
3152 }
3153
3154 static bool generator_path_any(const char* const* paths) {
3155 char **path;
3156 bool found = false;
3157
3158 /* Optimize by skipping the whole process by not creating output directories
3159 * if no generators are found. */
3160 STRV_FOREACH(path, (char**) paths)
3161 if (access(*path, F_OK) == 0)
3162 found = true;
3163 else if (errno != ENOENT)
3164 log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
3165
3166 return found;
3167 }
3168
3169 static const char* system_env_generator_binary_paths[] = {
3170 "/run/systemd/system-environment-generators",
3171 "/etc/systemd/system-environment-generators",
3172 "/usr/local/lib/systemd/system-environment-generators",
3173 SYSTEM_ENV_GENERATOR_PATH,
3174 NULL
3175 };
3176
3177 static const char* user_env_generator_binary_paths[] = {
3178 "/run/systemd/user-environment-generators",
3179 "/etc/systemd/user-environment-generators",
3180 "/usr/local/lib/systemd/user-environment-generators",
3181 USER_ENV_GENERATOR_PATH,
3182 NULL
3183 };
3184
3185 static int manager_run_environment_generators(Manager *m) {
3186 char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
3187 const char **paths;
3188 void* args[] = {&tmp, &tmp, &m->environment};
3189
3190 if (m->test_run_flags && !(m->test_run_flags & MANAGER_TEST_RUN_ENV_GENERATORS))
3191 return 0;
3192
3193 paths = MANAGER_IS_SYSTEM(m) ? system_env_generator_binary_paths : user_env_generator_binary_paths;
3194
3195 if (!generator_path_any(paths))
3196 return 0;
3197
3198 return execute_directories(paths, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL);
3199 }
3200
3201 static int manager_run_generators(Manager *m) {
3202 _cleanup_strv_free_ char **paths = NULL;
3203 const char *argv[5];
3204 int r;
3205
3206 assert(m);
3207
3208 if (m->test_run_flags && !(m->test_run_flags & MANAGER_TEST_RUN_GENERATORS))
3209 return 0;
3210
3211 paths = generator_binary_paths(m->unit_file_scope);
3212 if (!paths)
3213 return log_oom();
3214
3215 if (!generator_path_any((const char* const*) paths))
3216 return 0;
3217
3218 r = lookup_paths_mkdir_generator(&m->lookup_paths);
3219 if (r < 0)
3220 goto finish;
3221
3222 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
3223 argv[1] = m->lookup_paths.generator;
3224 argv[2] = m->lookup_paths.generator_early;
3225 argv[3] = m->lookup_paths.generator_late;
3226 argv[4] = NULL;
3227
3228 RUN_WITH_UMASK(0022)
3229 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC,
3230 NULL, NULL, (char**) argv);
3231
3232 finish:
3233 lookup_paths_trim_generator(&m->lookup_paths);
3234 return r;
3235 }
3236
3237 int manager_environment_add(Manager *m, char **minus, char **plus) {
3238 char **a = NULL, **b = NULL, **l;
3239 assert(m);
3240
3241 l = m->environment;
3242
3243 if (!strv_isempty(minus)) {
3244 a = strv_env_delete(l, 1, minus);
3245 if (!a)
3246 return -ENOMEM;
3247
3248 l = a;
3249 }
3250
3251 if (!strv_isempty(plus)) {
3252 b = strv_env_merge(2, l, plus);
3253 if (!b) {
3254 strv_free(a);
3255 return -ENOMEM;
3256 }
3257
3258 l = b;
3259 }
3260
3261 if (m->environment != l)
3262 strv_free(m->environment);
3263 if (a != l)
3264 strv_free(a);
3265 if (b != l)
3266 strv_free(b);
3267
3268 m->environment = l;
3269 manager_clean_environment(m);
3270 strv_sort(m->environment);
3271
3272 return 0;
3273 }
3274
3275 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
3276 int i;
3277
3278 assert(m);
3279
3280 for (i = 0; i < _RLIMIT_MAX; i++) {
3281 m->rlimit[i] = mfree(m->rlimit[i]);
3282
3283 if (!default_rlimit[i])
3284 continue;
3285
3286 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
3287 if (!m->rlimit[i])
3288 return log_oom();
3289 }
3290
3291 return 0;
3292 }
3293
3294 void manager_recheck_journal(Manager *m) {
3295 Unit *u;
3296
3297 assert(m);
3298
3299 if (!MANAGER_IS_SYSTEM(m))
3300 return;
3301
3302 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
3303 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
3304 log_close_journal();
3305 return;
3306 }
3307
3308 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
3309 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
3310 log_close_journal();
3311 return;
3312 }
3313
3314 /* Hmm, OK, so the socket is fully up and the service is up
3315 * too, then let's make use of the thing. */
3316 log_open();
3317 }
3318
3319 void manager_set_show_status(Manager *m, ShowStatus mode) {
3320 assert(m);
3321 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
3322
3323 if (!MANAGER_IS_SYSTEM(m))
3324 return;
3325
3326 if (m->show_status != mode)
3327 log_debug("%s showing of status.",
3328 mode == SHOW_STATUS_NO ? "Disabling" : "Enabling");
3329 m->show_status = mode;
3330
3331 if (mode > 0)
3332 (void) touch("/run/systemd/show-status");
3333 else
3334 (void) unlink("/run/systemd/show-status");
3335 }
3336
3337 static bool manager_get_show_status(Manager *m, StatusType type) {
3338 assert(m);
3339
3340 if (!MANAGER_IS_SYSTEM(m))
3341 return false;
3342
3343 if (m->no_console_output)
3344 return false;
3345
3346 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
3347 return false;
3348
3349 /* If we cannot find out the status properly, just proceed. */
3350 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
3351 return false;
3352
3353 if (m->show_status > 0)
3354 return true;
3355
3356 return false;
3357 }
3358
3359 const char *manager_get_confirm_spawn(Manager *m) {
3360 static int last_errno = 0;
3361 const char *vc = m->confirm_spawn;
3362 struct stat st;
3363 int r;
3364
3365 /* Here's the deal: we want to test the validity of the console but don't want
3366 * PID1 to go through the whole console process which might block. But we also
3367 * want to warn the user only once if something is wrong with the console so we
3368 * cannot do the sanity checks after spawning our children. So here we simply do
3369 * really basic tests to hopefully trap common errors.
3370 *
3371 * If the console suddenly disappear at the time our children will really it
3372 * then they will simply fail to acquire it and a positive answer will be
3373 * assumed. New children will fallback to /dev/console though.
3374 *
3375 * Note: TTYs are devices that can come and go any time, and frequently aren't
3376 * available yet during early boot (consider a USB rs232 dongle...). If for any
3377 * reason the configured console is not ready, we fallback to the default
3378 * console. */
3379
3380 if (!vc || path_equal(vc, "/dev/console"))
3381 return vc;
3382
3383 r = stat(vc, &st);
3384 if (r < 0)
3385 goto fail;
3386
3387 if (!S_ISCHR(st.st_mode)) {
3388 errno = ENOTTY;
3389 goto fail;
3390 }
3391
3392 last_errno = 0;
3393 return vc;
3394 fail:
3395 if (last_errno != errno) {
3396 last_errno = errno;
3397 log_warning_errno(errno, "Failed to open %s: %m, using default console", vc);
3398 }
3399 return "/dev/console";
3400 }
3401
3402 void manager_set_first_boot(Manager *m, bool b) {
3403 assert(m);
3404
3405 if (!MANAGER_IS_SYSTEM(m))
3406 return;
3407
3408 if (m->first_boot != (int) b) {
3409 if (b)
3410 (void) touch("/run/systemd/first-boot");
3411 else
3412 (void) unlink("/run/systemd/first-boot");
3413 }
3414
3415 m->first_boot = b;
3416 }
3417
3418 void manager_disable_confirm_spawn(void) {
3419 (void) touch("/run/systemd/confirm_spawn_disabled");
3420 }
3421
3422 bool manager_is_confirm_spawn_disabled(Manager *m) {
3423 if (!m->confirm_spawn)
3424 return true;
3425
3426 return access("/run/systemd/confirm_spawn_disabled", F_OK) >= 0;
3427 }
3428
3429 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3430 va_list ap;
3431
3432 /* If m is NULL, assume we're after shutdown and let the messages through. */
3433
3434 if (m && !manager_get_show_status(m, type))
3435 return;
3436
3437 /* XXX We should totally drop the check for ephemeral here
3438 * and thus effectively make 'Type=idle' pointless. */
3439 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3440 return;
3441
3442 va_start(ap, format);
3443 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3444 va_end(ap);
3445 }
3446
3447 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3448 char p[strlen(path)+1];
3449
3450 assert(m);
3451 assert(path);
3452
3453 strcpy(p, path);
3454 path_kill_slashes(p);
3455
3456 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3457 }
3458
3459 void manager_set_exec_params(Manager *m, ExecParameters *p) {
3460 assert(m);
3461 assert(p);
3462
3463 p->environment = m->environment;
3464 p->confirm_spawn = manager_get_confirm_spawn(m);
3465 p->cgroup_supported = m->cgroup_supported;
3466 p->prefix = m->prefix;
3467
3468 SET_FLAG(p->flags, EXEC_PASS_LOG_UNIT|EXEC_CHOWN_DIRECTORIES, MANAGER_IS_SYSTEM(m));
3469 }
3470
3471 int manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3472 unsigned size;
3473 int r;
3474
3475 assert(m);
3476 assert(u->manager == m);
3477
3478 size = set_size(m->failed_units);
3479
3480 if (failed) {
3481 r = set_ensure_allocated(&m->failed_units, NULL);
3482 if (r < 0)
3483 return log_oom();
3484
3485 if (set_put(m->failed_units, u) < 0)
3486 return log_oom();
3487 } else
3488 (void) set_remove(m->failed_units, u);
3489
3490 if (set_size(m->failed_units) != size)
3491 bus_manager_send_change_signal(m);
3492
3493 return 0;
3494 }
3495
3496 ManagerState manager_state(Manager *m) {
3497 Unit *u;
3498
3499 assert(m);
3500
3501 /* Did we ever finish booting? If not then we are still starting up */
3502 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3503
3504 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3505 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3506 return MANAGER_INITIALIZING;
3507
3508 return MANAGER_STARTING;
3509 }
3510
3511 /* Is the special shutdown target queued? If so, we are in shutdown state */
3512 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3513 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_RELOAD_OR_START))
3514 return MANAGER_STOPPING;
3515
3516 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3517 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3518 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3519 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_RELOAD_OR_START))))
3520 return MANAGER_MAINTENANCE;
3521
3522 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3523 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3524 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_RELOAD_OR_START))))
3525 return MANAGER_MAINTENANCE;
3526
3527 /* Are there any failed units? If so, we are in degraded mode */
3528 if (set_size(m->failed_units) > 0)
3529 return MANAGER_DEGRADED;
3530
3531 return MANAGER_RUNNING;
3532 }
3533
3534 #define DESTROY_IPC_FLAG (UINT32_C(1) << 31)
3535
3536 static void manager_unref_uid_internal(
3537 Manager *m,
3538 Hashmap **uid_refs,
3539 uid_t uid,
3540 bool destroy_now,
3541 int (*_clean_ipc)(uid_t uid)) {
3542
3543 uint32_t c, n;
3544
3545 assert(m);
3546 assert(uid_refs);
3547 assert(uid_is_valid(uid));
3548 assert(_clean_ipc);
3549
3550 /* A generic implementation, covering both manager_unref_uid() and manager_unref_gid(), under the assumption
3551 * that uid_t and gid_t are actually defined the same way, with the same validity rules.
3552 *
3553 * We store a hashmap where the UID/GID is they key and the value is a 32bit reference counter, whose highest
3554 * bit is used as flag for marking UIDs/GIDs whose IPC objects to remove when the last reference to the UID/GID
3555 * is dropped. The flag is set to on, once at least one reference from a unit where RemoveIPC= is set is added
3556 * on a UID/GID. It is reset when the UID's/GID's reference counter drops to 0 again. */
3557
3558 assert_cc(sizeof(uid_t) == sizeof(gid_t));
3559 assert_cc(UID_INVALID == (uid_t) GID_INVALID);
3560
3561 if (uid == 0) /* We don't keep track of root, and will never destroy it */
3562 return;
3563
3564 c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3565
3566 n = c & ~DESTROY_IPC_FLAG;
3567 assert(n > 0);
3568 n--;
3569
3570 if (destroy_now && n == 0) {
3571 hashmap_remove(*uid_refs, UID_TO_PTR(uid));
3572
3573 if (c & DESTROY_IPC_FLAG) {
3574 log_debug("%s " UID_FMT " is no longer referenced, cleaning up its IPC.",
3575 _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
3576 uid);
3577 (void) _clean_ipc(uid);
3578 }
3579 } else {
3580 c = n | (c & DESTROY_IPC_FLAG);
3581 assert_se(hashmap_update(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c)) >= 0);
3582 }
3583 }
3584
3585 void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now) {
3586 manager_unref_uid_internal(m, &m->uid_refs, uid, destroy_now, clean_ipc_by_uid);
3587 }
3588
3589 void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now) {
3590 manager_unref_uid_internal(m, &m->gid_refs, (uid_t) gid, destroy_now, clean_ipc_by_gid);
3591 }
3592
3593 static int manager_ref_uid_internal(
3594 Manager *m,
3595 Hashmap **uid_refs,
3596 uid_t uid,
3597 bool clean_ipc) {
3598
3599 uint32_t c, n;
3600 int r;
3601
3602 assert(m);
3603 assert(uid_refs);
3604 assert(uid_is_valid(uid));
3605
3606 /* A generic implementation, covering both manager_ref_uid() and manager_ref_gid(), under the assumption
3607 * that uid_t and gid_t are actually defined the same way, with the same validity rules. */
3608
3609 assert_cc(sizeof(uid_t) == sizeof(gid_t));
3610 assert_cc(UID_INVALID == (uid_t) GID_INVALID);
3611
3612 if (uid == 0) /* We don't keep track of root, and will never destroy it */
3613 return 0;
3614
3615 r = hashmap_ensure_allocated(uid_refs, &trivial_hash_ops);
3616 if (r < 0)
3617 return r;
3618
3619 c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3620
3621 n = c & ~DESTROY_IPC_FLAG;
3622 n++;
3623
3624 if (n & DESTROY_IPC_FLAG) /* check for overflow */
3625 return -EOVERFLOW;
3626
3627 c = n | (c & DESTROY_IPC_FLAG) | (clean_ipc ? DESTROY_IPC_FLAG : 0);
3628
3629 return hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
3630 }
3631
3632 int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc) {
3633 return manager_ref_uid_internal(m, &m->uid_refs, uid, clean_ipc);
3634 }
3635
3636 int manager_ref_gid(Manager *m, gid_t gid, bool clean_ipc) {
3637 return manager_ref_uid_internal(m, &m->gid_refs, (uid_t) gid, clean_ipc);
3638 }
3639
3640 static void manager_vacuum_uid_refs_internal(
3641 Manager *m,
3642 Hashmap **uid_refs,
3643 int (*_clean_ipc)(uid_t uid)) {
3644
3645 Iterator i;
3646 void *p, *k;
3647
3648 assert(m);
3649 assert(uid_refs);
3650 assert(_clean_ipc);
3651
3652 HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
3653 uint32_t c, n;
3654 uid_t uid;
3655
3656 uid = PTR_TO_UID(k);
3657 c = PTR_TO_UINT32(p);
3658
3659 n = c & ~DESTROY_IPC_FLAG;
3660 if (n > 0)
3661 continue;
3662
3663 if (c & DESTROY_IPC_FLAG) {
3664 log_debug("Found unreferenced %s " UID_FMT " after reload/reexec. Cleaning up.",
3665 _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
3666 uid);
3667 (void) _clean_ipc(uid);
3668 }
3669
3670 assert_se(hashmap_remove(*uid_refs, k) == p);
3671 }
3672 }
3673
3674 void manager_vacuum_uid_refs(Manager *m) {
3675 manager_vacuum_uid_refs_internal(m, &m->uid_refs, clean_ipc_by_uid);
3676 }
3677
3678 void manager_vacuum_gid_refs(Manager *m) {
3679 manager_vacuum_uid_refs_internal(m, &m->gid_refs, clean_ipc_by_gid);
3680 }
3681
3682 static void manager_serialize_uid_refs_internal(
3683 Manager *m,
3684 FILE *f,
3685 Hashmap **uid_refs,
3686 const char *field_name) {
3687
3688 Iterator i;
3689 void *p, *k;
3690
3691 assert(m);
3692 assert(f);
3693 assert(uid_refs);
3694 assert(field_name);
3695
3696 /* Serialize the UID reference table. Or actually, just the IPC destruction flag of it, as the actual counter
3697 * of it is better rebuild after a reload/reexec. */
3698
3699 HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
3700 uint32_t c;
3701 uid_t uid;
3702
3703 uid = PTR_TO_UID(k);
3704 c = PTR_TO_UINT32(p);
3705
3706 if (!(c & DESTROY_IPC_FLAG))
3707 continue;
3708
3709 fprintf(f, "%s=" UID_FMT "\n", field_name, uid);
3710 }
3711 }
3712
3713 void manager_serialize_uid_refs(Manager *m, FILE *f) {
3714 manager_serialize_uid_refs_internal(m, f, &m->uid_refs, "destroy-ipc-uid");
3715 }
3716
3717 void manager_serialize_gid_refs(Manager *m, FILE *f) {
3718 manager_serialize_uid_refs_internal(m, f, &m->gid_refs, "destroy-ipc-gid");
3719 }
3720
3721 static void manager_deserialize_uid_refs_one_internal(
3722 Manager *m,
3723 Hashmap** uid_refs,
3724 const char *value) {
3725
3726 uid_t uid;
3727 uint32_t c;
3728 int r;
3729
3730 assert(m);
3731 assert(uid_refs);
3732 assert(value);
3733
3734 r = parse_uid(value, &uid);
3735 if (r < 0 || uid == 0) {
3736 log_debug("Unable to parse UID reference serialization");
3737 return;
3738 }
3739
3740 r = hashmap_ensure_allocated(uid_refs, &trivial_hash_ops);
3741 if (r < 0) {
3742 log_oom();
3743 return;
3744 }
3745
3746 c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3747 if (c & DESTROY_IPC_FLAG)
3748 return;
3749
3750 c |= DESTROY_IPC_FLAG;
3751
3752 r = hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
3753 if (r < 0) {
3754 log_debug("Failed to add UID reference entry");
3755 return;
3756 }
3757 }
3758
3759 void manager_deserialize_uid_refs_one(Manager *m, const char *value) {
3760 manager_deserialize_uid_refs_one_internal(m, &m->uid_refs, value);
3761 }
3762
3763 void manager_deserialize_gid_refs_one(Manager *m, const char *value) {
3764 manager_deserialize_uid_refs_one_internal(m, &m->gid_refs, value);
3765 }
3766
3767 int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
3768 struct buffer {
3769 uid_t uid;
3770 gid_t gid;
3771 char unit_name[UNIT_NAME_MAX+1];
3772 } _packed_ buffer;
3773
3774 Manager *m = userdata;
3775 ssize_t l;
3776 size_t n;
3777 Unit *u;
3778
3779 assert_se(source);
3780 assert_se(m);
3781
3782 /* Invoked whenever a child process succeeded resolving its user/group to use and sent us the resulting UID/GID
3783 * in a datagram. We parse the datagram here and pass it off to the unit, so that it can add a reference to the
3784 * UID/GID so that it can destroy the UID/GID's IPC objects when the reference counter drops to 0. */
3785
3786 l = recv(fd, &buffer, sizeof(buffer), MSG_DONTWAIT);
3787 if (l < 0) {
3788 if (IN_SET(errno, EINTR, EAGAIN))
3789 return 0;
3790
3791 return log_error_errno(errno, "Failed to read from user lookup fd: %m");
3792 }
3793
3794 if ((size_t) l <= offsetof(struct buffer, unit_name)) {
3795 log_warning("Received too short user lookup message, ignoring.");
3796 return 0;
3797 }
3798
3799 if ((size_t) l > offsetof(struct buffer, unit_name) + UNIT_NAME_MAX) {
3800 log_warning("Received too long user lookup message, ignoring.");
3801 return 0;
3802 }
3803
3804 if (!uid_is_valid(buffer.uid) && !gid_is_valid(buffer.gid)) {
3805 log_warning("Got user lookup message with invalid UID/GID pair, ignoring.");
3806 return 0;
3807 }
3808
3809 n = (size_t) l - offsetof(struct buffer, unit_name);
3810 if (memchr(buffer.unit_name, 0, n)) {
3811 log_warning("Received lookup message with embedded NUL character, ignoring.");
3812 return 0;
3813 }
3814
3815 buffer.unit_name[n] = 0;
3816 u = manager_get_unit(m, buffer.unit_name);
3817 if (!u) {
3818 log_debug("Got user lookup message but unit doesn't exist, ignoring.");
3819 return 0;
3820 }
3821
3822 log_unit_debug(u, "User lookup succeeded: uid=" UID_FMT " gid=" GID_FMT, buffer.uid, buffer.gid);
3823
3824 unit_notify_user_lookup(u, buffer.uid, buffer.gid);
3825 return 0;
3826 }
3827
3828 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3829 [MANAGER_INITIALIZING] = "initializing",
3830 [MANAGER_STARTING] = "starting",
3831 [MANAGER_RUNNING] = "running",
3832 [MANAGER_DEGRADED] = "degraded",
3833 [MANAGER_MAINTENANCE] = "maintenance",
3834 [MANAGER_STOPPING] = "stopping",
3835 };
3836
3837 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
Unnamed repository; edit this file 'description' to name the repository.