]> 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 #18007 from fw-strlen/ipv6_masq_and_dnat
[thirdparty/systemd.git] / src / core / manager.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <linux/kd.h>
6 #include <sys/epoll.h>
7 #include <sys/inotify.h>
8 #include <sys/ioctl.h>
9 #include <sys/reboot.h>
10 #include <sys/timerfd.h>
11 #include <sys/wait.h>
12 #include <unistd.h>
13
14 #if HAVE_AUDIT
15 #include <libaudit.h>
16 #endif
17
18 #include "sd-daemon.h"
19 #include "sd-messages.h"
20 #include "sd-path.h"
21
22 #include "all-units.h"
23 #include "alloc-util.h"
24 #include "audit-fd.h"
25 #include "boot-timestamps.h"
26 #include "bus-common-errors.h"
27 #include "bus-error.h"
28 #include "bus-kernel.h"
29 #include "bus-util.h"
30 #include "clean-ipc.h"
31 #include "clock-util.h"
32 #include "core-varlink.h"
33 #include "dbus-job.h"
34 #include "dbus-manager.h"
35 #include "dbus-unit.h"
36 #include "dbus.h"
37 #include "def.h"
38 #include "dirent-util.h"
39 #include "env-util.h"
40 #include "escape.h"
41 #include "exec-util.h"
42 #include "execute.h"
43 #include "exit-status.h"
44 #include "fd-util.h"
45 #include "fileio.h"
46 #include "fs-util.h"
47 #include "generator-setup.h"
48 #include "hashmap.h"
49 #include "install.h"
50 #include "io-util.h"
51 #include "label.h"
52 #include "locale-setup.h"
53 #include "load-fragment.h"
54 #include "log.h"
55 #include "macro.h"
56 #include "manager.h"
57 #include "memory-util.h"
58 #include "mkdir.h"
59 #include "parse-util.h"
60 #include "path-lookup.h"
61 #include "path-util.h"
62 #include "process-util.h"
63 #include "ratelimit.h"
64 #include "rlimit-util.h"
65 #include "rm-rf.h"
66 #include "selinux-util.h"
67 #include "serialize.h"
68 #include "signal-util.h"
69 #include "socket-util.h"
70 #include "special.h"
71 #include "stat-util.h"
72 #include "string-table.h"
73 #include "string-util.h"
74 #include "strv.h"
75 #include "strxcpyx.h"
76 #include "sysctl-util.h"
77 #include "syslog-util.h"
78 #include "terminal-util.h"
79 #include "time-util.h"
80 #include "transaction.h"
81 #include "umask-util.h"
82 #include "unit-name.h"
83 #include "unit-serialize.h"
84 #include "user-util.h"
85 #include "virt.h"
86 #include "watchdog.h"
87
88 #define NOTIFY_RCVBUF_SIZE (8*1024*1024)
89 #define CGROUPS_AGENT_RCVBUF_SIZE (8*1024*1024)
90
91 /* Initial delay and the interval for printing status messages about running jobs */
92 #define JOBS_IN_PROGRESS_WAIT_USEC (2*USEC_PER_SEC)
93 #define JOBS_IN_PROGRESS_QUIET_WAIT_USEC (25*USEC_PER_SEC)
94 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
95 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
96
97 /* If there are more than 1K bus messages queue across our API and direct buses, then let's not add more on top until
98 * the queue gets more empty. */
99 #define MANAGER_BUS_BUSY_THRESHOLD 1024LU
100
101 /* How many units and jobs to process of the bus queue before returning to the event loop. */
102 #define MANAGER_BUS_MESSAGE_BUDGET 100U
103
104 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
105 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
106 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
107 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
108 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
109 static int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
110 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
111 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
112 static int manager_dispatch_sigchld(sd_event_source *source, void *userdata);
113 static int manager_dispatch_timezone_change(sd_event_source *source, const struct inotify_event *event, void *userdata);
114 static int manager_run_environment_generators(Manager *m);
115 static int manager_run_generators(Manager *m);
116 static void manager_vacuum(Manager *m);
117
118 static usec_t manager_watch_jobs_next_time(Manager *m) {
119 return usec_add(now(CLOCK_MONOTONIC),
120 show_status_on(m->show_status) ? JOBS_IN_PROGRESS_WAIT_USEC :
121 JOBS_IN_PROGRESS_QUIET_WAIT_USEC);
122 }
123
124 static void manager_watch_jobs_in_progress(Manager *m) {
125 usec_t next;
126 int r;
127
128 assert(m);
129
130 /* We do not want to show the cylon animation if the user
131 * needs to confirm service executions otherwise confirmation
132 * messages will be screwed by the cylon animation. */
133 if (!manager_is_confirm_spawn_disabled(m))
134 return;
135
136 if (m->jobs_in_progress_event_source)
137 return;
138
139 next = manager_watch_jobs_next_time(m);
140 r = sd_event_add_time(
141 m->event,
142 &m->jobs_in_progress_event_source,
143 CLOCK_MONOTONIC,
144 next, 0,
145 manager_dispatch_jobs_in_progress, m);
146 if (r < 0)
147 return;
148
149 (void) sd_event_source_set_description(m->jobs_in_progress_event_source, "manager-jobs-in-progress");
150 }
151
152 #define CYLON_BUFFER_EXTRA (2*STRLEN(ANSI_RED) + STRLEN(ANSI_HIGHLIGHT_RED) + 2*STRLEN(ANSI_NORMAL))
153
154 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
155 char *p = buffer;
156
157 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
158 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
159
160 if (pos > 1) {
161 if (pos > 2)
162 p = mempset(p, ' ', pos-2);
163 if (log_get_show_color())
164 p = stpcpy(p, ANSI_RED);
165 *p++ = '*';
166 }
167
168 if (pos > 0 && pos <= width) {
169 if (log_get_show_color())
170 p = stpcpy(p, ANSI_HIGHLIGHT_RED);
171 *p++ = '*';
172 }
173
174 if (log_get_show_color())
175 p = stpcpy(p, ANSI_NORMAL);
176
177 if (pos < width) {
178 if (log_get_show_color())
179 p = stpcpy(p, ANSI_RED);
180 *p++ = '*';
181 if (pos < width-1)
182 p = mempset(p, ' ', width-1-pos);
183 if (log_get_show_color())
184 strcpy(p, ANSI_NORMAL);
185 }
186 }
187
188 static void manager_flip_auto_status(Manager *m, bool enable, const char *reason) {
189 assert(m);
190
191 if (enable) {
192 if (m->show_status == SHOW_STATUS_AUTO)
193 manager_set_show_status(m, SHOW_STATUS_TEMPORARY, reason);
194 } else {
195 if (m->show_status == SHOW_STATUS_TEMPORARY)
196 manager_set_show_status(m, SHOW_STATUS_AUTO, reason);
197 }
198 }
199
200 static void manager_print_jobs_in_progress(Manager *m) {
201 _cleanup_free_ char *job_of_n = NULL;
202 Job *j;
203 unsigned counter = 0, print_nr;
204 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
205 unsigned cylon_pos;
206 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
207 uint64_t x;
208
209 assert(m);
210 assert(m->n_running_jobs > 0);
211
212 manager_flip_auto_status(m, true, "delay");
213
214 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
215
216 HASHMAP_FOREACH(j, m->jobs)
217 if (j->state == JOB_RUNNING && counter++ == print_nr)
218 break;
219
220 /* m->n_running_jobs must be consistent with the contents of m->jobs,
221 * so the above loop must have succeeded in finding j. */
222 assert(counter == print_nr + 1);
223 assert(j);
224
225 cylon_pos = m->jobs_in_progress_iteration % 14;
226 if (cylon_pos >= 8)
227 cylon_pos = 14 - cylon_pos;
228 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
229
230 m->jobs_in_progress_iteration++;
231
232 if (m->n_running_jobs > 1) {
233 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
234 job_of_n = NULL;
235 }
236
237 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
238 if (job_get_timeout(j, &x) > 0)
239 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
240
241 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
242 "%sA %s job is running for %s (%s / %s)",
243 strempty(job_of_n),
244 job_type_to_string(j->type),
245 unit_status_string(j->unit),
246 time, limit);
247 }
248
249 static int have_ask_password(void) {
250 _cleanup_closedir_ DIR *dir;
251 struct dirent *de;
252
253 dir = opendir("/run/systemd/ask-password");
254 if (!dir) {
255 if (errno == ENOENT)
256 return false;
257 else
258 return -errno;
259 }
260
261 FOREACH_DIRENT_ALL(de, dir, return -errno) {
262 if (startswith(de->d_name, "ask."))
263 return true;
264 }
265 return false;
266 }
267
268 static int manager_dispatch_ask_password_fd(sd_event_source *source,
269 int fd, uint32_t revents, void *userdata) {
270 Manager *m = userdata;
271
272 assert(m);
273
274 (void) flush_fd(fd);
275
276 m->have_ask_password = have_ask_password();
277 if (m->have_ask_password < 0)
278 /* Log error but continue. Negative have_ask_password
279 * is treated as unknown status. */
280 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
281
282 return 0;
283 }
284
285 static void manager_close_ask_password(Manager *m) {
286 assert(m);
287
288 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
289 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
290 m->have_ask_password = -EINVAL;
291 }
292
293 static int manager_check_ask_password(Manager *m) {
294 int r;
295
296 assert(m);
297
298 if (!m->ask_password_event_source) {
299 assert(m->ask_password_inotify_fd < 0);
300
301 (void) mkdir_p_label("/run/systemd/ask-password", 0755);
302
303 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
304 if (m->ask_password_inotify_fd < 0)
305 return log_error_errno(errno, "Failed to create inotify object: %m");
306
307 r = inotify_add_watch_and_warn(m->ask_password_inotify_fd,
308 "/run/systemd/ask-password",
309 IN_CREATE|IN_DELETE|IN_MOVE);
310 if (r < 0) {
311 manager_close_ask_password(m);
312 return r;
313 }
314
315 r = sd_event_add_io(m->event, &m->ask_password_event_source,
316 m->ask_password_inotify_fd, EPOLLIN,
317 manager_dispatch_ask_password_fd, m);
318 if (r < 0) {
319 log_error_errno(r, "Failed to add event source for /run/systemd/ask-password: %m");
320 manager_close_ask_password(m);
321 return r;
322 }
323
324 (void) sd_event_source_set_description(m->ask_password_event_source, "manager-ask-password");
325
326 /* Queries might have been added meanwhile... */
327 manager_dispatch_ask_password_fd(m->ask_password_event_source,
328 m->ask_password_inotify_fd, EPOLLIN, m);
329 }
330
331 return m->have_ask_password;
332 }
333
334 static int manager_watch_idle_pipe(Manager *m) {
335 int r;
336
337 assert(m);
338
339 if (m->idle_pipe_event_source)
340 return 0;
341
342 if (m->idle_pipe[2] < 0)
343 return 0;
344
345 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
346 if (r < 0)
347 return log_error_errno(r, "Failed to watch idle pipe: %m");
348
349 (void) sd_event_source_set_description(m->idle_pipe_event_source, "manager-idle-pipe");
350
351 return 0;
352 }
353
354 static void manager_close_idle_pipe(Manager *m) {
355 assert(m);
356
357 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
358
359 safe_close_pair(m->idle_pipe);
360 safe_close_pair(m->idle_pipe + 2);
361 }
362
363 static int manager_setup_time_change(Manager *m) {
364 int r;
365
366 assert(m);
367
368 if (MANAGER_IS_TEST_RUN(m))
369 return 0;
370
371 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
372 m->time_change_fd = safe_close(m->time_change_fd);
373
374 m->time_change_fd = time_change_fd();
375 if (m->time_change_fd < 0)
376 return log_error_errno(m->time_change_fd, "Failed to create timer change timer fd: %m");
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 /* Schedule this slightly earlier than the .timer event sources */
383 r = sd_event_source_set_priority(m->time_change_event_source, SD_EVENT_PRIORITY_NORMAL-1);
384 if (r < 0)
385 return log_error_errno(r, "Failed to set priority of time change event sources: %m");
386
387 (void) sd_event_source_set_description(m->time_change_event_source, "manager-time-change");
388
389 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
390
391 return 0;
392 }
393
394 static int manager_read_timezone_stat(Manager *m) {
395 struct stat st;
396 bool changed;
397
398 assert(m);
399
400 /* Read the current stat() data of /etc/localtime so that we detect changes */
401 if (lstat("/etc/localtime", &st) < 0) {
402 log_debug_errno(errno, "Failed to stat /etc/localtime, ignoring: %m");
403 changed = m->etc_localtime_accessible;
404 m->etc_localtime_accessible = false;
405 } else {
406 usec_t k;
407
408 k = timespec_load(&st.st_mtim);
409 changed = !m->etc_localtime_accessible || k != m->etc_localtime_mtime;
410
411 m->etc_localtime_mtime = k;
412 m->etc_localtime_accessible = true;
413 }
414
415 return changed;
416 }
417
418 static int manager_setup_timezone_change(Manager *m) {
419 _cleanup_(sd_event_source_unrefp) sd_event_source *new_event = NULL;
420 int r;
421
422 assert(m);
423
424 if (MANAGER_IS_TEST_RUN(m))
425 return 0;
426
427 /* We watch /etc/localtime for three events: change of the link count (which might mean removal from /etc even
428 * though another link might be kept), renames, and file close operations after writing. Note we don't bother
429 * with IN_DELETE_SELF, as that would just report when the inode is removed entirely, i.e. after the link count
430 * went to zero and all fds to it are closed.
431 *
432 * Note that we never follow symlinks here. This is a simplification, but should cover almost all cases
433 * correctly.
434 *
435 * Note that we create the new event source first here, before releasing the old one. This should optimize
436 * behaviour as this way sd-event can reuse the old watch in case the inode didn't change. */
437
438 r = sd_event_add_inotify(m->event, &new_event, "/etc/localtime",
439 IN_ATTRIB|IN_MOVE_SELF|IN_CLOSE_WRITE|IN_DONT_FOLLOW, manager_dispatch_timezone_change, m);
440 if (r == -ENOENT) {
441 /* If the file doesn't exist yet, subscribe to /etc instead, and wait until it is created either by
442 * O_CREATE or by rename() */
443
444 log_debug_errno(r, "/etc/localtime doesn't exist yet, watching /etc instead.");
445 r = sd_event_add_inotify(m->event, &new_event, "/etc",
446 IN_CREATE|IN_MOVED_TO|IN_ONLYDIR, manager_dispatch_timezone_change, m);
447 }
448 if (r < 0)
449 return log_error_errno(r, "Failed to create timezone change event source: %m");
450
451 /* Schedule this slightly earlier than the .timer event sources */
452 r = sd_event_source_set_priority(new_event, SD_EVENT_PRIORITY_NORMAL-1);
453 if (r < 0)
454 return log_error_errno(r, "Failed to set priority of timezone change event sources: %m");
455
456 sd_event_source_unref(m->timezone_change_event_source);
457 m->timezone_change_event_source = TAKE_PTR(new_event);
458
459 return 0;
460 }
461
462 static int enable_special_signals(Manager *m) {
463 _cleanup_close_ int fd = -1;
464
465 assert(m);
466
467 if (MANAGER_IS_TEST_RUN(m))
468 return 0;
469
470 /* Enable that we get SIGINT on control-alt-del. In containers
471 * this will fail with EPERM (older) or EINVAL (newer), so
472 * ignore that. */
473 if (reboot(RB_DISABLE_CAD) < 0 && !IN_SET(errno, EPERM, EINVAL))
474 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
475
476 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
477 if (fd < 0) {
478 /* Support systems without virtual console */
479 if (fd != -ENOENT)
480 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
481 } else {
482 /* Enable that we get SIGWINCH on kbrequest */
483 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
484 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
485 }
486
487 return 0;
488 }
489
490 #define RTSIG_IF_AVAILABLE(signum) (signum <= SIGRTMAX ? signum : -1)
491
492 static int manager_setup_signals(Manager *m) {
493 struct sigaction sa = {
494 .sa_handler = SIG_DFL,
495 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
496 };
497 sigset_t mask;
498 int r;
499
500 assert(m);
501
502 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
503
504 /* We make liberal use of realtime signals here. On
505 * Linux/glibc we have 30 of them (with the exception of Linux
506 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
507 * (aka SIGRTMAX). */
508
509 assert_se(sigemptyset(&mask) == 0);
510 sigset_add_many(&mask,
511 SIGCHLD, /* Child died */
512 SIGTERM, /* Reexecute daemon */
513 SIGHUP, /* Reload configuration */
514 SIGUSR1, /* systemd: reconnect to D-Bus */
515 SIGUSR2, /* systemd: dump status */
516 SIGINT, /* Kernel sends us this on control-alt-del */
517 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
518 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
519
520 SIGRTMIN+0, /* systemd: start default.target */
521 SIGRTMIN+1, /* systemd: isolate rescue.target */
522 SIGRTMIN+2, /* systemd: isolate emergency.target */
523 SIGRTMIN+3, /* systemd: start halt.target */
524 SIGRTMIN+4, /* systemd: start poweroff.target */
525 SIGRTMIN+5, /* systemd: start reboot.target */
526 SIGRTMIN+6, /* systemd: start kexec.target */
527
528 /* ... space for more special targets ... */
529
530 SIGRTMIN+13, /* systemd: Immediate halt */
531 SIGRTMIN+14, /* systemd: Immediate poweroff */
532 SIGRTMIN+15, /* systemd: Immediate reboot */
533 SIGRTMIN+16, /* systemd: Immediate kexec */
534
535 /* ... space for more immediate system state changes ... */
536
537 SIGRTMIN+20, /* systemd: enable status messages */
538 SIGRTMIN+21, /* systemd: disable status messages */
539 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
540 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
541 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
542
543 /* .. one free signal here ... */
544
545 /* Apparently Linux on hppa had fewer RT signals until v3.18,
546 * SIGRTMAX was SIGRTMIN+25, and then SIGRTMIN was lowered,
547 * see commit v3.17-7614-g1f25df2eff.
548 *
549 * We cannot unconditionally make use of those signals here,
550 * so let's use a runtime check. Since these commands are
551 * accessible by different means and only really a safety
552 * net, the missing functionality on hppa shouldn't matter.
553 */
554
555 RTSIG_IF_AVAILABLE(SIGRTMIN+26), /* systemd: set log target to journal-or-kmsg */
556 RTSIG_IF_AVAILABLE(SIGRTMIN+27), /* systemd: set log target to console */
557 RTSIG_IF_AVAILABLE(SIGRTMIN+28), /* systemd: set log target to kmsg */
558 RTSIG_IF_AVAILABLE(SIGRTMIN+29), /* systemd: set log target to syslog-or-kmsg (obsolete) */
559
560 /* ... one free signal here SIGRTMIN+30 ... */
561 -1);
562 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
563
564 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
565 if (m->signal_fd < 0)
566 return -errno;
567
568 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
569 if (r < 0)
570 return r;
571
572 (void) sd_event_source_set_description(m->signal_event_source, "manager-signal");
573
574 /* Process signals a bit earlier than the rest of things, but later than notify_fd processing, so that the
575 * notify processing can still figure out to which process/service a message belongs, before we reap the
576 * process. Also, process this before handling cgroup notifications, so that we always collect child exit
577 * status information before detecting that there's no process in a cgroup. */
578 r = sd_event_source_set_priority(m->signal_event_source, SD_EVENT_PRIORITY_NORMAL-6);
579 if (r < 0)
580 return r;
581
582 if (MANAGER_IS_SYSTEM(m))
583 return enable_special_signals(m);
584
585 return 0;
586 }
587
588 static char** sanitize_environment(char **l) {
589
590 /* Let's remove some environment variables that we need ourselves to communicate with our clients */
591 strv_env_unset_many(
592 l,
593 "CACHE_DIRECTORY",
594 "CONFIGURATION_DIRECTORY",
595 "CREDENTIALS_DIRECTORY",
596 "EXIT_CODE",
597 "EXIT_STATUS",
598 "INVOCATION_ID",
599 "JOURNAL_STREAM",
600 "LISTEN_FDNAMES",
601 "LISTEN_FDS",
602 "LISTEN_PID",
603 "LOGS_DIRECTORY",
604 "MAINPID",
605 "MANAGERPID",
606 "NOTIFY_SOCKET",
607 "PIDFILE",
608 "REMOTE_ADDR",
609 "REMOTE_PORT",
610 "RUNTIME_DIRECTORY",
611 "SERVICE_RESULT",
612 "STATE_DIRECTORY",
613 "WATCHDOG_PID",
614 "WATCHDOG_USEC",
615 NULL);
616
617 /* Let's order the environment alphabetically, just to make it pretty */
618 strv_sort(l);
619
620 return l;
621 }
622
623 int manager_default_environment(Manager *m) {
624 int r;
625
626 assert(m);
627
628 m->transient_environment = strv_free(m->transient_environment);
629
630 if (MANAGER_IS_SYSTEM(m)) {
631 /* The system manager always starts with a clean
632 * environment for its children. It does not import
633 * the kernel's or the parents' exported variables.
634 *
635 * The initial passed environment is untouched to keep
636 * /proc/self/environ valid; it is used for tagging
637 * the init process inside containers. */
638 m->transient_environment = strv_new("PATH=" DEFAULT_PATH);
639 if (!m->transient_environment)
640 return log_oom();
641
642 /* Import locale variables LC_*= from configuration */
643 (void) locale_setup(&m->transient_environment);
644 } else {
645 /* The user manager passes its own environment along to its children, except for $PATH. */
646 m->transient_environment = strv_copy(environ);
647 if (!m->transient_environment)
648 return log_oom();
649
650 r = strv_env_replace_strdup(&m->transient_environment, "PATH=" DEFAULT_USER_PATH);
651 if (r < 0)
652 return log_oom();
653 }
654
655 sanitize_environment(m->transient_environment);
656
657 return 0;
658 }
659
660 static int manager_setup_prefix(Manager *m) {
661 struct table_entry {
662 uint64_t type;
663 const char *suffix;
664 };
665
666 static const struct table_entry paths_system[_EXEC_DIRECTORY_TYPE_MAX] = {
667 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_SYSTEM_RUNTIME, NULL },
668 [EXEC_DIRECTORY_STATE] = { SD_PATH_SYSTEM_STATE_PRIVATE, NULL },
669 [EXEC_DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE, NULL },
670 [EXEC_DIRECTORY_LOGS] = { SD_PATH_SYSTEM_STATE_LOGS, NULL },
671 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_SYSTEM_CONFIGURATION, NULL },
672 };
673
674 static const struct table_entry paths_user[_EXEC_DIRECTORY_TYPE_MAX] = {
675 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_USER_RUNTIME, NULL },
676 [EXEC_DIRECTORY_STATE] = { SD_PATH_USER_CONFIGURATION, NULL },
677 [EXEC_DIRECTORY_CACHE] = { SD_PATH_USER_STATE_CACHE, NULL },
678 [EXEC_DIRECTORY_LOGS] = { SD_PATH_USER_CONFIGURATION, "log" },
679 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_USER_CONFIGURATION, NULL },
680 };
681
682 assert(m);
683
684 const struct table_entry *p = MANAGER_IS_SYSTEM(m) ? paths_system : paths_user;
685 int r;
686
687 for (ExecDirectoryType i = 0; i < _EXEC_DIRECTORY_TYPE_MAX; i++) {
688 r = sd_path_lookup(p[i].type, p[i].suffix, &m->prefix[i]);
689 if (r < 0)
690 return r;
691 }
692
693 return 0;
694 }
695
696 static void manager_free_unit_name_maps(Manager *m) {
697 m->unit_id_map = hashmap_free(m->unit_id_map);
698 m->unit_name_map = hashmap_free(m->unit_name_map);
699 m->unit_path_cache = set_free(m->unit_path_cache);
700 m->unit_cache_timestamp_hash = 0;
701 }
702
703 static int manager_setup_run_queue(Manager *m) {
704 int r;
705
706 assert(m);
707 assert(!m->run_queue_event_source);
708
709 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
710 if (r < 0)
711 return r;
712
713 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
714 if (r < 0)
715 return r;
716
717 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
718 if (r < 0)
719 return r;
720
721 (void) sd_event_source_set_description(m->run_queue_event_source, "manager-run-queue");
722
723 return 0;
724 }
725
726 static int manager_setup_sigchld_event_source(Manager *m) {
727 int r;
728
729 assert(m);
730 assert(!m->sigchld_event_source);
731
732 r = sd_event_add_defer(m->event, &m->sigchld_event_source, manager_dispatch_sigchld, m);
733 if (r < 0)
734 return r;
735
736 r = sd_event_source_set_priority(m->sigchld_event_source, SD_EVENT_PRIORITY_NORMAL-7);
737 if (r < 0)
738 return r;
739
740 r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_OFF);
741 if (r < 0)
742 return r;
743
744 (void) sd_event_source_set_description(m->sigchld_event_source, "manager-sigchld");
745
746 return 0;
747 }
748
749 int manager_new(UnitFileScope scope, ManagerTestRunFlags test_run_flags, Manager **_m) {
750 _cleanup_(manager_freep) Manager *m = NULL;
751 const char *e;
752 int r;
753
754 assert(_m);
755 assert(IN_SET(scope, UNIT_FILE_SYSTEM, UNIT_FILE_USER));
756
757 m = new(Manager, 1);
758 if (!m)
759 return -ENOMEM;
760
761 *m = (Manager) {
762 .unit_file_scope = scope,
763 .objective = _MANAGER_OBJECTIVE_INVALID,
764
765 .status_unit_format = STATUS_UNIT_FORMAT_DEFAULT,
766
767 .default_timer_accuracy_usec = USEC_PER_MINUTE,
768 .default_memory_accounting = MEMORY_ACCOUNTING_DEFAULT,
769 .default_tasks_accounting = true,
770 .default_tasks_max = TASKS_MAX_UNSET,
771 .default_timeout_start_usec = DEFAULT_TIMEOUT_USEC,
772 .default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC,
773 .default_restart_usec = DEFAULT_RESTART_USEC,
774
775 .original_log_level = -1,
776 .original_log_target = _LOG_TARGET_INVALID,
777
778 .watchdog_overridden[WATCHDOG_RUNTIME] = USEC_INFINITY,
779 .watchdog_overridden[WATCHDOG_REBOOT] = USEC_INFINITY,
780 .watchdog_overridden[WATCHDOG_KEXEC] = USEC_INFINITY,
781
782 .show_status_overridden = _SHOW_STATUS_INVALID,
783
784 .notify_fd = -1,
785 .cgroups_agent_fd = -1,
786 .signal_fd = -1,
787 .time_change_fd = -1,
788 .user_lookup_fds = { -1, -1 },
789 .private_listen_fd = -1,
790 .dev_autofs_fd = -1,
791 .cgroup_inotify_fd = -1,
792 .pin_cgroupfs_fd = -1,
793 .ask_password_inotify_fd = -1,
794 .idle_pipe = { -1, -1, -1, -1},
795
796 /* start as id #1, so that we can leave #0 around as "null-like" value */
797 .current_job_id = 1,
798
799 .have_ask_password = -EINVAL, /* we don't know */
800 .first_boot = -1,
801 .test_run_flags = test_run_flags,
802
803 .default_oom_policy = OOM_STOP,
804 };
805
806 #if ENABLE_EFI
807 if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
808 boot_timestamps(m->timestamps + MANAGER_TIMESTAMP_USERSPACE,
809 m->timestamps + MANAGER_TIMESTAMP_FIRMWARE,
810 m->timestamps + MANAGER_TIMESTAMP_LOADER);
811 #endif
812
813 /* Prepare log fields we can use for structured logging */
814 if (MANAGER_IS_SYSTEM(m)) {
815 m->unit_log_field = "UNIT=";
816 m->unit_log_format_string = "UNIT=%s";
817
818 m->invocation_log_field = "INVOCATION_ID=";
819 m->invocation_log_format_string = "INVOCATION_ID=%s";
820 } else {
821 m->unit_log_field = "USER_UNIT=";
822 m->unit_log_format_string = "USER_UNIT=%s";
823
824 m->invocation_log_field = "USER_INVOCATION_ID=";
825 m->invocation_log_format_string = "USER_INVOCATION_ID=%s";
826 }
827
828 /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
829 m->ctrl_alt_del_ratelimit = (RateLimit) { .interval = 2 * USEC_PER_SEC, .burst = 7 };
830
831 r = manager_default_environment(m);
832 if (r < 0)
833 return r;
834
835 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
836 if (r < 0)
837 return r;
838
839 r = hashmap_ensure_allocated(&m->cgroup_unit, &path_hash_ops);
840 if (r < 0)
841 return r;
842
843 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
844 if (r < 0)
845 return r;
846
847 r = prioq_ensure_allocated(&m->run_queue, compare_job_priority);
848 if (r < 0)
849 return r;
850
851 r = manager_setup_prefix(m);
852 if (r < 0)
853 return r;
854
855 e = secure_getenv("CREDENTIALS_DIRECTORY");
856 if (e) {
857 m->received_credentials = strdup(e);
858 if (!m->received_credentials)
859 return -ENOMEM;
860 }
861
862 r = sd_event_default(&m->event);
863 if (r < 0)
864 return r;
865
866 r = manager_setup_run_queue(m);
867 if (r < 0)
868 return r;
869
870 if (test_run_flags == MANAGER_TEST_RUN_MINIMAL) {
871 m->cgroup_root = strdup("");
872 if (!m->cgroup_root)
873 return -ENOMEM;
874 } else {
875 r = manager_setup_signals(m);
876 if (r < 0)
877 return r;
878
879 r = manager_setup_cgroup(m);
880 if (r < 0)
881 return r;
882
883 r = manager_setup_time_change(m);
884 if (r < 0)
885 return r;
886
887 r = manager_read_timezone_stat(m);
888 if (r < 0)
889 return r;
890
891 (void) manager_setup_timezone_change(m);
892
893 r = manager_setup_sigchld_event_source(m);
894 if (r < 0)
895 return r;
896 }
897
898 if (test_run_flags == 0) {
899 if (MANAGER_IS_SYSTEM(m))
900 r = mkdir_label("/run/systemd/units", 0755);
901 else {
902 _cleanup_free_ char *units_path = NULL;
903 r = xdg_user_runtime_dir(&units_path, "/systemd/units");
904 if (r < 0)
905 return r;
906 r = mkdir_p_label(units_path, 0755);
907 }
908
909 if (r < 0 && r != -EEXIST)
910 return r;
911 }
912
913 m->taint_usr =
914 !in_initrd() &&
915 dir_is_empty("/usr") > 0;
916
917 /* Note that we do not set up the notify fd here. We do that after deserialization,
918 * since they might have gotten serialized across the reexec. */
919
920 *_m = TAKE_PTR(m);
921
922 return 0;
923 }
924
925 static int manager_setup_notify(Manager *m) {
926 int r;
927
928 if (MANAGER_IS_TEST_RUN(m))
929 return 0;
930
931 if (m->notify_fd < 0) {
932 _cleanup_close_ int fd = -1;
933 union sockaddr_union sa;
934 socklen_t sa_len;
935
936 /* First free all secondary fields */
937 m->notify_socket = mfree(m->notify_socket);
938 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
939
940 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
941 if (fd < 0)
942 return log_error_errno(errno, "Failed to allocate notification socket: %m");
943
944 fd_inc_rcvbuf(fd, NOTIFY_RCVBUF_SIZE);
945
946 m->notify_socket = path_join(m->prefix[EXEC_DIRECTORY_RUNTIME], "systemd/notify");
947 if (!m->notify_socket)
948 return log_oom();
949
950 r = sockaddr_un_set_path(&sa.un, m->notify_socket);
951 if (r < 0)
952 return log_error_errno(r, "Notify socket '%s' not valid for AF_UNIX socket address, refusing.",
953 m->notify_socket);
954 sa_len = r;
955
956 (void) mkdir_parents_label(m->notify_socket, 0755);
957 (void) sockaddr_un_unlink(&sa.un);
958
959 r = mac_selinux_bind(fd, &sa.sa, sa_len);
960 if (r < 0)
961 return log_error_errno(r, "bind(%s) failed: %m", m->notify_socket);
962
963 r = setsockopt_int(fd, SOL_SOCKET, SO_PASSCRED, true);
964 if (r < 0)
965 return log_error_errno(r, "SO_PASSCRED failed: %m");
966
967 m->notify_fd = TAKE_FD(fd);
968
969 log_debug("Using notification socket %s", m->notify_socket);
970 }
971
972 if (!m->notify_event_source) {
973 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
974 if (r < 0)
975 return log_error_errno(r, "Failed to allocate notify event source: %m");
976
977 /* Process notification messages a bit earlier than SIGCHLD, so that we can still identify to which
978 * service an exit message belongs. */
979 r = sd_event_source_set_priority(m->notify_event_source, SD_EVENT_PRIORITY_NORMAL-8);
980 if (r < 0)
981 return log_error_errno(r, "Failed to set priority of notify event source: %m");
982
983 (void) sd_event_source_set_description(m->notify_event_source, "manager-notify");
984 }
985
986 return 0;
987 }
988
989 static int manager_setup_cgroups_agent(Manager *m) {
990
991 static const union sockaddr_union sa = {
992 .un.sun_family = AF_UNIX,
993 .un.sun_path = "/run/systemd/cgroups-agent",
994 };
995 int r;
996
997 /* This creates a listening socket we receive cgroups agent messages on. We do not use D-Bus for delivering
998 * these messages from the cgroups agent binary to PID 1, as the cgroups agent binary is very short-living, and
999 * each instance of it needs a new D-Bus connection. Since D-Bus connections are SOCK_STREAM/AF_UNIX, on
1000 * overloaded systems the backlog of the D-Bus socket becomes relevant, as not more than the configured number
1001 * of D-Bus connections may be queued until the kernel will start dropping further incoming connections,
1002 * possibly resulting in lost cgroups agent messages. To avoid this, we'll use a private SOCK_DGRAM/AF_UNIX
1003 * socket, where no backlog is relevant as communication may take place without an actual connect() cycle, and
1004 * we thus won't lose messages.
1005 *
1006 * Note that PID 1 will forward the agent message to system bus, so that the user systemd instance may listen
1007 * to it. The system instance hence listens on this special socket, but the user instances listen on the system
1008 * bus for these messages. */
1009
1010 if (MANAGER_IS_TEST_RUN(m))
1011 return 0;
1012
1013 if (!MANAGER_IS_SYSTEM(m))
1014 return 0;
1015
1016 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
1017 if (r < 0)
1018 return log_error_errno(r, "Failed to determine whether unified cgroups hierarchy is used: %m");
1019 if (r > 0) /* We don't need this anymore on the unified hierarchy */
1020 return 0;
1021
1022 if (m->cgroups_agent_fd < 0) {
1023 _cleanup_close_ int fd = -1;
1024
1025 /* First free all secondary fields */
1026 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
1027
1028 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1029 if (fd < 0)
1030 return log_error_errno(errno, "Failed to allocate cgroups agent socket: %m");
1031
1032 fd_inc_rcvbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE);
1033
1034 (void) sockaddr_un_unlink(&sa.un);
1035
1036 /* Only allow root to connect to this socket */
1037 RUN_WITH_UMASK(0077)
1038 r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
1039 if (r < 0)
1040 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
1041
1042 m->cgroups_agent_fd = TAKE_FD(fd);
1043 }
1044
1045 if (!m->cgroups_agent_event_source) {
1046 r = sd_event_add_io(m->event, &m->cgroups_agent_event_source, m->cgroups_agent_fd, EPOLLIN, manager_dispatch_cgroups_agent_fd, m);
1047 if (r < 0)
1048 return log_error_errno(r, "Failed to allocate cgroups agent event source: %m");
1049
1050 /* Process cgroups notifications early. Note that when the agent notification is received
1051 * we'll just enqueue the unit in the cgroup empty queue, hence pick a high priority than
1052 * that. Also see handling of cgroup inotify for the unified cgroup stuff. */
1053 r = sd_event_source_set_priority(m->cgroups_agent_event_source, SD_EVENT_PRIORITY_NORMAL-9);
1054 if (r < 0)
1055 return log_error_errno(r, "Failed to set priority of cgroups agent event source: %m");
1056
1057 (void) sd_event_source_set_description(m->cgroups_agent_event_source, "manager-cgroups-agent");
1058 }
1059
1060 return 0;
1061 }
1062
1063 static int manager_setup_user_lookup_fd(Manager *m) {
1064 int r;
1065
1066 assert(m);
1067
1068 /* Set up the socket pair used for passing UID/GID resolution results from forked off processes to PID
1069 * 1. Background: we can't do name lookups (NSS) from PID 1, since it might involve IPC and thus activation,
1070 * and we might hence deadlock on ourselves. Hence we do all user/group lookups asynchronously from the forked
1071 * off processes right before executing the binaries to start. In order to be able to clean up any IPC objects
1072 * created by a unit (see RemoveIPC=) we need to know in PID 1 the used UID/GID of the executed processes,
1073 * hence we establish this communication channel so that forked off processes can pass their UID/GID
1074 * information back to PID 1. The forked off processes send their resolved UID/GID to PID 1 in a simple
1075 * datagram, along with their unit name, so that we can share one communication socket pair among all units for
1076 * this purpose.
1077 *
1078 * You might wonder why we need a communication channel for this that is independent of the usual notification
1079 * socket scheme (i.e. $NOTIFY_SOCKET). The primary difference is about trust: data sent via the $NOTIFY_SOCKET
1080 * channel is only accepted if it originates from the right unit and if reception was enabled for it. The user
1081 * lookup socket OTOH is only accessible by PID 1 and its children until they exec(), and always available.
1082 *
1083 * Note that this function is called under two circumstances: when we first initialize (in which case we
1084 * allocate both the socket pair and the event source to listen on it), and when we deserialize after a reload
1085 * (in which case the socket pair already exists but we still need to allocate the event source for it). */
1086
1087 if (m->user_lookup_fds[0] < 0) {
1088
1089 /* Free all secondary fields */
1090 safe_close_pair(m->user_lookup_fds);
1091 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
1092
1093 if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, m->user_lookup_fds) < 0)
1094 return log_error_errno(errno, "Failed to allocate user lookup socket: %m");
1095
1096 (void) fd_inc_rcvbuf(m->user_lookup_fds[0], NOTIFY_RCVBUF_SIZE);
1097 }
1098
1099 if (!m->user_lookup_event_source) {
1100 r = sd_event_add_io(m->event, &m->user_lookup_event_source, m->user_lookup_fds[0], EPOLLIN, manager_dispatch_user_lookup_fd, m);
1101 if (r < 0)
1102 return log_error_errno(errno, "Failed to allocate user lookup event source: %m");
1103
1104 /* Process even earlier than the notify event source, so that we always know first about valid UID/GID
1105 * resolutions */
1106 r = sd_event_source_set_priority(m->user_lookup_event_source, SD_EVENT_PRIORITY_NORMAL-11);
1107 if (r < 0)
1108 return log_error_errno(errno, "Failed to set priority of user lookup event source: %m");
1109
1110 (void) sd_event_source_set_description(m->user_lookup_event_source, "user-lookup");
1111 }
1112
1113 return 0;
1114 }
1115
1116 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
1117 Unit *u;
1118 unsigned n = 0;
1119
1120 assert(m);
1121
1122 while ((u = m->cleanup_queue)) {
1123 assert(u->in_cleanup_queue);
1124
1125 unit_free(u);
1126 n++;
1127 }
1128
1129 return n;
1130 }
1131
1132 enum {
1133 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
1134 GC_OFFSET_UNSURE, /* No clue */
1135 GC_OFFSET_GOOD, /* We still need this unit */
1136 GC_OFFSET_BAD, /* We don't need this unit anymore */
1137 _GC_OFFSET_MAX
1138 };
1139
1140 static void unit_gc_mark_good(Unit *u, unsigned gc_marker) {
1141 Unit *other;
1142 void *v;
1143
1144 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
1145
1146 /* Recursively mark referenced units as GOOD as well */
1147 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCES])
1148 if (other->gc_marker == gc_marker + GC_OFFSET_UNSURE)
1149 unit_gc_mark_good(other, gc_marker);
1150 }
1151
1152 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
1153 Unit *other;
1154 bool is_bad;
1155 void *v;
1156
1157 assert(u);
1158
1159 if (IN_SET(u->gc_marker - gc_marker,
1160 GC_OFFSET_GOOD, GC_OFFSET_BAD, GC_OFFSET_UNSURE, GC_OFFSET_IN_PATH))
1161 return;
1162
1163 if (u->in_cleanup_queue)
1164 goto bad;
1165
1166 if (!unit_may_gc(u))
1167 goto good;
1168
1169 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
1170
1171 is_bad = true;
1172
1173 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCED_BY]) {
1174 unit_gc_sweep(other, gc_marker);
1175
1176 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
1177 goto good;
1178
1179 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
1180 is_bad = false;
1181 }
1182
1183 const UnitRef *ref;
1184 LIST_FOREACH(refs_by_target, ref, u->refs_by_target) {
1185 unit_gc_sweep(ref->source, gc_marker);
1186
1187 if (ref->source->gc_marker == gc_marker + GC_OFFSET_GOOD)
1188 goto good;
1189
1190 if (ref->source->gc_marker != gc_marker + GC_OFFSET_BAD)
1191 is_bad = false;
1192 }
1193
1194 if (is_bad)
1195 goto bad;
1196
1197 /* We were unable to find anything out about this entry, so
1198 * let's investigate it later */
1199 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
1200 unit_add_to_gc_queue(u);
1201 return;
1202
1203 bad:
1204 /* We definitely know that this one is not useful anymore, so
1205 * let's mark it for deletion */
1206 u->gc_marker = gc_marker + GC_OFFSET_BAD;
1207 unit_add_to_cleanup_queue(u);
1208 return;
1209
1210 good:
1211 unit_gc_mark_good(u, gc_marker);
1212 }
1213
1214 static unsigned manager_dispatch_gc_unit_queue(Manager *m) {
1215 unsigned n = 0, gc_marker;
1216 Unit *u;
1217
1218 assert(m);
1219
1220 /* log_debug("Running GC..."); */
1221
1222 m->gc_marker += _GC_OFFSET_MAX;
1223 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
1224 m->gc_marker = 1;
1225
1226 gc_marker = m->gc_marker;
1227
1228 while ((u = m->gc_unit_queue)) {
1229 assert(u->in_gc_queue);
1230
1231 unit_gc_sweep(u, gc_marker);
1232
1233 LIST_REMOVE(gc_queue, m->gc_unit_queue, u);
1234 u->in_gc_queue = false;
1235
1236 n++;
1237
1238 if (IN_SET(u->gc_marker - gc_marker,
1239 GC_OFFSET_BAD, GC_OFFSET_UNSURE)) {
1240 if (u->id)
1241 log_unit_debug(u, "Collecting.");
1242 u->gc_marker = gc_marker + GC_OFFSET_BAD;
1243 unit_add_to_cleanup_queue(u);
1244 }
1245 }
1246
1247 return n;
1248 }
1249
1250 static unsigned manager_dispatch_gc_job_queue(Manager *m) {
1251 unsigned n = 0;
1252 Job *j;
1253
1254 assert(m);
1255
1256 while ((j = m->gc_job_queue)) {
1257 assert(j->in_gc_queue);
1258
1259 LIST_REMOVE(gc_queue, m->gc_job_queue, j);
1260 j->in_gc_queue = false;
1261
1262 n++;
1263
1264 if (!job_may_gc(j))
1265 continue;
1266
1267 log_unit_debug(j->unit, "Collecting job.");
1268 (void) job_finish_and_invalidate(j, JOB_COLLECTED, false, false);
1269 }
1270
1271 return n;
1272 }
1273
1274 static unsigned manager_dispatch_stop_when_unneeded_queue(Manager *m) {
1275 unsigned n = 0;
1276 Unit *u;
1277 int r;
1278
1279 assert(m);
1280
1281 while ((u = m->stop_when_unneeded_queue)) {
1282 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1283 assert(m->stop_when_unneeded_queue);
1284
1285 assert(u->in_stop_when_unneeded_queue);
1286 LIST_REMOVE(stop_when_unneeded_queue, m->stop_when_unneeded_queue, u);
1287 u->in_stop_when_unneeded_queue = false;
1288
1289 n++;
1290
1291 if (!unit_is_unneeded(u))
1292 continue;
1293
1294 log_unit_debug(u, "Unit is not needed anymore.");
1295
1296 /* If stopping a unit fails continuously we might enter a stop loop here, hence stop acting on the
1297 * service being unnecessary after a while. */
1298
1299 if (!ratelimit_below(&u->auto_stop_ratelimit)) {
1300 log_unit_warning(u, "Unit not needed anymore, but not stopping since we tried this too often recently.");
1301 continue;
1302 }
1303
1304 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1305 r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, NULL, &error, NULL);
1306 if (r < 0)
1307 log_unit_warning_errno(u, r, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error, r));
1308 }
1309
1310 return n;
1311 }
1312
1313 static void manager_clear_jobs_and_units(Manager *m) {
1314 Unit *u;
1315
1316 assert(m);
1317
1318 while ((u = hashmap_first(m->units)))
1319 unit_free(u);
1320
1321 manager_dispatch_cleanup_queue(m);
1322
1323 assert(!m->load_queue);
1324 assert(prioq_isempty(m->run_queue));
1325 assert(!m->dbus_unit_queue);
1326 assert(!m->dbus_job_queue);
1327 assert(!m->cleanup_queue);
1328 assert(!m->gc_unit_queue);
1329 assert(!m->gc_job_queue);
1330 assert(!m->stop_when_unneeded_queue);
1331
1332 assert(hashmap_isempty(m->jobs));
1333 assert(hashmap_isempty(m->units));
1334
1335 m->n_on_console = 0;
1336 m->n_running_jobs = 0;
1337 m->n_installed_jobs = 0;
1338 m->n_failed_jobs = 0;
1339 }
1340
1341 Manager* manager_free(Manager *m) {
1342 if (!m)
1343 return NULL;
1344
1345 manager_clear_jobs_and_units(m);
1346
1347 for (UnitType c = 0; c < _UNIT_TYPE_MAX; c++)
1348 if (unit_vtable[c]->shutdown)
1349 unit_vtable[c]->shutdown(m);
1350
1351 /* Keep the cgroup hierarchy in place except when we know we are going down for good */
1352 manager_shutdown_cgroup(m, IN_SET(m->objective, MANAGER_EXIT, MANAGER_REBOOT, MANAGER_POWEROFF, MANAGER_HALT, MANAGER_KEXEC));
1353
1354 lookup_paths_flush_generator(&m->lookup_paths);
1355
1356 bus_done(m);
1357 manager_varlink_done(m);
1358
1359 exec_runtime_vacuum(m);
1360 hashmap_free(m->exec_runtime_by_id);
1361
1362 dynamic_user_vacuum(m, false);
1363 hashmap_free(m->dynamic_users);
1364
1365 hashmap_free(m->units);
1366 hashmap_free(m->units_by_invocation_id);
1367 hashmap_free(m->jobs);
1368 hashmap_free(m->watch_pids);
1369 hashmap_free(m->watch_bus);
1370
1371 prioq_free(m->run_queue);
1372
1373 set_free(m->startup_units);
1374 set_free(m->failed_units);
1375
1376 sd_event_source_unref(m->signal_event_source);
1377 sd_event_source_unref(m->sigchld_event_source);
1378 sd_event_source_unref(m->notify_event_source);
1379 sd_event_source_unref(m->cgroups_agent_event_source);
1380 sd_event_source_unref(m->time_change_event_source);
1381 sd_event_source_unref(m->timezone_change_event_source);
1382 sd_event_source_unref(m->jobs_in_progress_event_source);
1383 sd_event_source_unref(m->run_queue_event_source);
1384 sd_event_source_unref(m->user_lookup_event_source);
1385
1386 safe_close(m->signal_fd);
1387 safe_close(m->notify_fd);
1388 safe_close(m->cgroups_agent_fd);
1389 safe_close(m->time_change_fd);
1390 safe_close_pair(m->user_lookup_fds);
1391
1392 manager_close_ask_password(m);
1393
1394 manager_close_idle_pipe(m);
1395
1396 sd_event_unref(m->event);
1397
1398 free(m->notify_socket);
1399
1400 lookup_paths_free(&m->lookup_paths);
1401 strv_free(m->transient_environment);
1402 strv_free(m->client_environment);
1403
1404 hashmap_free(m->cgroup_unit);
1405 manager_free_unit_name_maps(m);
1406
1407 free(m->switch_root);
1408 free(m->switch_root_init);
1409
1410 rlimit_free_all(m->rlimit);
1411
1412 assert(hashmap_isempty(m->units_requiring_mounts_for));
1413 hashmap_free(m->units_requiring_mounts_for);
1414
1415 hashmap_free(m->uid_refs);
1416 hashmap_free(m->gid_refs);
1417
1418 for (ExecDirectoryType dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++)
1419 m->prefix[dt] = mfree(m->prefix[dt]);
1420 free(m->received_credentials);
1421
1422 return mfree(m);
1423 }
1424
1425 static void manager_enumerate_perpetual(Manager *m) {
1426 assert(m);
1427
1428 if (m->test_run_flags == MANAGER_TEST_RUN_MINIMAL)
1429 return;
1430
1431 /* Let's ask every type to load all units from disk/kernel that it might know */
1432 for (UnitType c = 0; c < _UNIT_TYPE_MAX; c++) {
1433 if (!unit_type_supported(c)) {
1434 log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
1435 continue;
1436 }
1437
1438 if (unit_vtable[c]->enumerate_perpetual)
1439 unit_vtable[c]->enumerate_perpetual(m);
1440 }
1441 }
1442
1443 static void manager_enumerate(Manager *m) {
1444 assert(m);
1445
1446 if (m->test_run_flags == MANAGER_TEST_RUN_MINIMAL)
1447 return;
1448
1449 /* Let's ask every type to load all units from disk/kernel that it might know */
1450 for (UnitType c = 0; c < _UNIT_TYPE_MAX; c++) {
1451 if (!unit_type_supported(c)) {
1452 log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
1453 continue;
1454 }
1455
1456 if (unit_vtable[c]->enumerate)
1457 unit_vtable[c]->enumerate(m);
1458 }
1459
1460 manager_dispatch_load_queue(m);
1461 }
1462
1463 static void manager_coldplug(Manager *m) {
1464 Unit *u;
1465 char *k;
1466 int r;
1467
1468 assert(m);
1469
1470 log_debug("Invoking unit coldplug() handlers…");
1471
1472 /* Let's place the units back into their deserialized state */
1473 HASHMAP_FOREACH_KEY(u, k, m->units) {
1474
1475 /* ignore aliases */
1476 if (u->id != k)
1477 continue;
1478
1479 r = unit_coldplug(u);
1480 if (r < 0)
1481 log_warning_errno(r, "We couldn't coldplug %s, proceeding anyway: %m", u->id);
1482 }
1483 }
1484
1485 static void manager_catchup(Manager *m) {
1486 Unit *u;
1487 char *k;
1488
1489 assert(m);
1490
1491 log_debug("Invoking unit catchup() handlers…");
1492
1493 /* Let's catch up on any state changes that happened while we were reloading/reexecing */
1494 HASHMAP_FOREACH_KEY(u, k, m->units) {
1495
1496 /* ignore aliases */
1497 if (u->id != k)
1498 continue;
1499
1500 unit_catchup(u);
1501 }
1502 }
1503
1504 static void manager_distribute_fds(Manager *m, FDSet *fds) {
1505 Unit *u;
1506
1507 assert(m);
1508
1509 HASHMAP_FOREACH(u, m->units) {
1510
1511 if (fdset_size(fds) <= 0)
1512 break;
1513
1514 if (!UNIT_VTABLE(u)->distribute_fds)
1515 continue;
1516
1517 UNIT_VTABLE(u)->distribute_fds(u, fds);
1518 }
1519 }
1520
1521 static bool manager_dbus_is_running(Manager *m, bool deserialized) {
1522 Unit *u;
1523
1524 assert(m);
1525
1526 /* This checks whether the dbus instance we are supposed to expose our APIs on is up. We check both the socket
1527 * and the service unit. If the 'deserialized' parameter is true we'll check the deserialized state of the unit
1528 * rather than the current one. */
1529
1530 if (MANAGER_IS_TEST_RUN(m))
1531 return false;
1532
1533 u = manager_get_unit(m, SPECIAL_DBUS_SOCKET);
1534 if (!u)
1535 return false;
1536 if ((deserialized ? SOCKET(u)->deserialized_state : SOCKET(u)->state) != SOCKET_RUNNING)
1537 return false;
1538
1539 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1540 if (!u)
1541 return false;
1542 if (!IN_SET((deserialized ? SERVICE(u)->deserialized_state : SERVICE(u)->state), SERVICE_RUNNING, SERVICE_RELOAD))
1543 return false;
1544
1545 return true;
1546 }
1547
1548 static void manager_setup_bus(Manager *m) {
1549 assert(m);
1550
1551 /* Let's set up our private bus connection now, unconditionally */
1552 (void) bus_init_private(m);
1553
1554 /* If we are in --user mode also connect to the system bus now */
1555 if (MANAGER_IS_USER(m))
1556 (void) bus_init_system(m);
1557
1558 /* Let's connect to the bus now, but only if the unit is supposed to be up */
1559 if (manager_dbus_is_running(m, MANAGER_IS_RELOADING(m))) {
1560 (void) bus_init_api(m);
1561
1562 if (MANAGER_IS_SYSTEM(m))
1563 (void) bus_init_system(m);
1564 }
1565 }
1566
1567 static void manager_preset_all(Manager *m) {
1568 int r;
1569
1570 assert(m);
1571
1572 if (m->first_boot <= 0)
1573 return;
1574
1575 if (!MANAGER_IS_SYSTEM(m))
1576 return;
1577
1578 if (MANAGER_IS_TEST_RUN(m))
1579 return;
1580
1581 /* If this is the first boot, and we are in the host system, then preset everything */
1582 r = unit_file_preset_all(UNIT_FILE_SYSTEM, 0, NULL, UNIT_FILE_PRESET_ENABLE_ONLY, NULL, 0);
1583 if (r < 0)
1584 log_full_errno(r == -EEXIST ? LOG_NOTICE : LOG_WARNING, r,
1585 "Failed to populate /etc with preset unit settings, ignoring: %m");
1586 else
1587 log_info("Populated /etc with preset unit settings.");
1588 }
1589
1590 static void manager_ready(Manager *m) {
1591 assert(m);
1592
1593 /* After having loaded everything, do the final round of catching up with what might have changed */
1594
1595 m->objective = MANAGER_OK; /* Tell everyone we are up now */
1596
1597 /* It might be safe to log to the journal now and connect to dbus */
1598 manager_recheck_journal(m);
1599 manager_recheck_dbus(m);
1600
1601 /* Let's finally catch up with any changes that took place while we were reloading/reexecing */
1602 manager_catchup(m);
1603
1604 m->honor_device_enumeration = true;
1605 }
1606
1607 static Manager* manager_reloading_start(Manager *m) {
1608 m->n_reloading++;
1609 return m;
1610 }
1611 static void manager_reloading_stopp(Manager **m) {
1612 if (*m) {
1613 assert((*m)->n_reloading > 0);
1614 (*m)->n_reloading--;
1615 }
1616 }
1617
1618 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1619 int r;
1620
1621 assert(m);
1622
1623 /* If we are running in test mode, we still want to run the generators,
1624 * but we should not touch the real generator directories. */
1625 r = lookup_paths_init(&m->lookup_paths, m->unit_file_scope,
1626 MANAGER_IS_TEST_RUN(m) ? LOOKUP_PATHS_TEMPORARY_GENERATED : 0,
1627 NULL);
1628 if (r < 0)
1629 return log_error_errno(r, "Failed to initialize path lookup table: %m");
1630
1631 dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_GENERATORS_START));
1632 r = manager_run_environment_generators(m);
1633 if (r >= 0)
1634 r = manager_run_generators(m);
1635 dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_GENERATORS_FINISH));
1636 if (r < 0)
1637 return r;
1638
1639 manager_preset_all(m);
1640
1641 lookup_paths_log(&m->lookup_paths);
1642
1643 {
1644 /* This block is (optionally) done with the reloading counter bumped */
1645 _cleanup_(manager_reloading_stopp) Manager *reloading = NULL;
1646
1647 /* If we will deserialize make sure that during enumeration this is already known, so we increase the
1648 * counter here already */
1649 if (serialization)
1650 reloading = manager_reloading_start(m);
1651
1652 /* First, enumerate what we can from all config files */
1653 dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_UNITS_LOAD_START));
1654 manager_enumerate_perpetual(m);
1655 manager_enumerate(m);
1656 dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_UNITS_LOAD_FINISH));
1657
1658 /* Second, deserialize if there is something to deserialize */
1659 if (serialization) {
1660 r = manager_deserialize(m, serialization, fds);
1661 if (r < 0)
1662 return log_error_errno(r, "Deserialization failed: %m");
1663 }
1664
1665 /* Any fds left? Find some unit which wants them. This is useful to allow container managers to pass
1666 * some file descriptors to us pre-initialized. This enables socket-based activation of entire
1667 * containers. */
1668 manager_distribute_fds(m, fds);
1669
1670 /* We might have deserialized the notify fd, but if we didn't then let's create the bus now */
1671 r = manager_setup_notify(m);
1672 if (r < 0)
1673 /* No sense to continue without notifications, our children would fail anyway. */
1674 return r;
1675
1676 r = manager_setup_cgroups_agent(m);
1677 if (r < 0)
1678 /* Likewise, no sense to continue without empty cgroup notifications. */
1679 return r;
1680
1681 r = manager_setup_user_lookup_fd(m);
1682 if (r < 0)
1683 /* This shouldn't fail, except if things are really broken. */
1684 return r;
1685
1686 /* Connect to the bus if we are good for it */
1687 manager_setup_bus(m);
1688
1689 /* Now that we are connected to all possible buses, let's deserialize who is tracking us. */
1690 r = bus_track_coldplug(m, &m->subscribed, false, m->deserialized_subscribed);
1691 if (r < 0)
1692 log_warning_errno(r, "Failed to deserialized tracked clients, ignoring: %m");
1693 m->deserialized_subscribed = strv_free(m->deserialized_subscribed);
1694
1695 r = manager_varlink_init(m);
1696 if (r < 0)
1697 log_warning_errno(r, "Failed to set up Varlink server, ignoring: %m");
1698
1699 /* Third, fire things up! */
1700 manager_coldplug(m);
1701
1702 /* Clean up runtime objects */
1703 manager_vacuum(m);
1704
1705 if (serialization)
1706 /* Let's wait for the UnitNew/JobNew messages being sent, before we notify that the
1707 * reload is finished */
1708 m->send_reloading_done = true;
1709 }
1710
1711 manager_ready(m);
1712
1713 return 0;
1714 }
1715
1716 int manager_add_job(
1717 Manager *m,
1718 JobType type,
1719 Unit *unit,
1720 JobMode mode,
1721 Set *affected_jobs,
1722 sd_bus_error *error,
1723 Job **ret) {
1724
1725 Transaction *tr;
1726 int r;
1727
1728 assert(m);
1729 assert(type < _JOB_TYPE_MAX);
1730 assert(unit);
1731 assert(mode < _JOB_MODE_MAX);
1732
1733 if (mode == JOB_ISOLATE && type != JOB_START)
1734 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1735
1736 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1737 return sd_bus_error_setf(error, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1738
1739 if (mode == JOB_TRIGGERING && type != JOB_STOP)
1740 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "--job-mode=triggering is only valid for stop.");
1741
1742 log_unit_debug(unit, "Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1743
1744 type = job_type_collapse(type, unit);
1745
1746 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1747 if (!tr)
1748 return -ENOMEM;
1749
1750 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, false,
1751 IN_SET(mode, JOB_IGNORE_DEPENDENCIES, JOB_IGNORE_REQUIREMENTS),
1752 mode == JOB_IGNORE_DEPENDENCIES, error);
1753 if (r < 0)
1754 goto tr_abort;
1755
1756 if (mode == JOB_ISOLATE) {
1757 r = transaction_add_isolate_jobs(tr, m);
1758 if (r < 0)
1759 goto tr_abort;
1760 }
1761
1762 if (mode == JOB_TRIGGERING) {
1763 r = transaction_add_triggering_jobs(tr, unit);
1764 if (r < 0)
1765 goto tr_abort;
1766 }
1767
1768 r = transaction_activate(tr, m, mode, affected_jobs, error);
1769 if (r < 0)
1770 goto tr_abort;
1771
1772 log_unit_debug(unit,
1773 "Enqueued job %s/%s as %u", unit->id,
1774 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1775
1776 if (ret)
1777 *ret = tr->anchor_job;
1778
1779 transaction_free(tr);
1780 return 0;
1781
1782 tr_abort:
1783 transaction_abort(tr);
1784 transaction_free(tr);
1785 return r;
1786 }
1787
1788 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs, sd_bus_error *e, Job **ret) {
1789 Unit *unit = NULL; /* just to appease gcc, initialization is not really necessary */
1790 int r;
1791
1792 assert(m);
1793 assert(type < _JOB_TYPE_MAX);
1794 assert(name);
1795 assert(mode < _JOB_MODE_MAX);
1796
1797 r = manager_load_unit(m, name, NULL, NULL, &unit);
1798 if (r < 0)
1799 return r;
1800 assert(unit);
1801
1802 return manager_add_job(m, type, unit, mode, affected_jobs, e, ret);
1803 }
1804
1805 int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs, Job **ret) {
1806 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1807 int r;
1808
1809 assert(m);
1810 assert(type < _JOB_TYPE_MAX);
1811 assert(name);
1812 assert(mode < _JOB_MODE_MAX);
1813
1814 r = manager_add_job_by_name(m, type, name, mode, affected_jobs, &error, ret);
1815 if (r < 0)
1816 return log_warning_errno(r, "Failed to enqueue %s job for %s: %s", job_mode_to_string(mode), name, bus_error_message(&error, r));
1817
1818 return r;
1819 }
1820
1821 int manager_propagate_reload(Manager *m, Unit *unit, JobMode mode, sd_bus_error *e) {
1822 int r;
1823 Transaction *tr;
1824
1825 assert(m);
1826 assert(unit);
1827 assert(mode < _JOB_MODE_MAX);
1828 assert(mode != JOB_ISOLATE); /* Isolate is only valid for start */
1829
1830 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1831 if (!tr)
1832 return -ENOMEM;
1833
1834 /* We need an anchor job */
1835 r = transaction_add_job_and_dependencies(tr, JOB_NOP, unit, NULL, false, false, true, true, e);
1836 if (r < 0)
1837 goto tr_abort;
1838
1839 /* Failure in adding individual dependencies is ignored, so this always succeeds. */
1840 transaction_add_propagate_reload_jobs(tr, unit, tr->anchor_job, mode == JOB_IGNORE_DEPENDENCIES, e);
1841
1842 r = transaction_activate(tr, m, mode, NULL, e);
1843 if (r < 0)
1844 goto tr_abort;
1845
1846 transaction_free(tr);
1847 return 0;
1848
1849 tr_abort:
1850 transaction_abort(tr);
1851 transaction_free(tr);
1852 return r;
1853 }
1854
1855 Job *manager_get_job(Manager *m, uint32_t id) {
1856 assert(m);
1857
1858 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1859 }
1860
1861 Unit *manager_get_unit(Manager *m, const char *name) {
1862 assert(m);
1863 assert(name);
1864
1865 return hashmap_get(m->units, name);
1866 }
1867
1868 static int manager_dispatch_target_deps_queue(Manager *m) {
1869 Unit *u;
1870 int r = 0;
1871
1872 static const UnitDependency deps[] = {
1873 UNIT_REQUIRED_BY,
1874 UNIT_REQUISITE_OF,
1875 UNIT_WANTED_BY,
1876 UNIT_BOUND_BY
1877 };
1878
1879 assert(m);
1880
1881 while ((u = m->target_deps_queue)) {
1882 assert(u->in_target_deps_queue);
1883
1884 LIST_REMOVE(target_deps_queue, u->manager->target_deps_queue, u);
1885 u->in_target_deps_queue = false;
1886
1887 for (size_t k = 0; k < ELEMENTSOF(deps); k++) {
1888 Unit *target;
1889 void *v;
1890
1891 HASHMAP_FOREACH_KEY(v, target, u->dependencies[deps[k]]) {
1892 r = unit_add_default_target_dependency(u, target);
1893 if (r < 0)
1894 return r;
1895 }
1896 }
1897 }
1898
1899 return r;
1900 }
1901
1902 unsigned manager_dispatch_load_queue(Manager *m) {
1903 Unit *u;
1904 unsigned n = 0;
1905
1906 assert(m);
1907
1908 /* Make sure we are not run recursively */
1909 if (m->dispatching_load_queue)
1910 return 0;
1911
1912 m->dispatching_load_queue = true;
1913
1914 /* Dispatches the load queue. Takes a unit from the queue and
1915 * tries to load its data until the queue is empty */
1916
1917 while ((u = m->load_queue)) {
1918 assert(u->in_load_queue);
1919
1920 unit_load(u);
1921 n++;
1922 }
1923
1924 m->dispatching_load_queue = false;
1925
1926 /* Dispatch the units waiting for their target dependencies to be added now, as all targets that we know about
1927 * should be loaded and have aliases resolved */
1928 (void) manager_dispatch_target_deps_queue(m);
1929
1930 return n;
1931 }
1932
1933 bool manager_unit_cache_should_retry_load(Unit *u) {
1934 assert(u);
1935
1936 /* Automatic reloading from disk only applies to units which were not found sometime in the past, and
1937 * the not-found stub is kept pinned in the unit graph by dependencies. For units that were
1938 * previously loaded, we don't do automatic reloading, and daemon-reload is necessary to update. */
1939 if (u->load_state != UNIT_NOT_FOUND)
1940 return false;
1941
1942 /* The cache has been updated since the last time we tried to load the unit. There might be new
1943 * fragment paths to read. */
1944 if (u->manager->unit_cache_timestamp_hash != u->fragment_not_found_timestamp_hash)
1945 return true;
1946
1947 /* The cache needs to be updated because there are modifications on disk. */
1948 return !lookup_paths_timestamp_hash_same(&u->manager->lookup_paths, u->manager->unit_cache_timestamp_hash, NULL);
1949 }
1950
1951 int manager_load_unit_prepare(
1952 Manager *m,
1953 const char *name,
1954 const char *path,
1955 sd_bus_error *e,
1956 Unit **_ret) {
1957
1958 _cleanup_(unit_freep) Unit *cleanup_ret = NULL;
1959 Unit *ret;
1960 UnitType t;
1961 int r;
1962
1963 assert(m);
1964 assert(_ret);
1965
1966 /* This will prepare the unit for loading, but not actually load anything from disk. */
1967
1968 if (path && !path_is_absolute(path))
1969 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1970
1971 if (!name) {
1972 /* 'name' and 'path' must not both be null. Check here 'path' using assert_se() to
1973 * workaround a bug in gcc that generates a -Wnonnull warning when calling basename(),
1974 * but this cannot be possible in any code path (See #6119). */
1975 assert_se(path);
1976 name = basename(path);
1977 }
1978
1979 t = unit_name_to_type(name);
1980
1981 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE)) {
1982 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE))
1983 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is missing the instance name.", name);
1984
1985 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1986 }
1987
1988 ret = manager_get_unit(m, name);
1989 if (ret) {
1990 /* The time-based cache allows to start new units without daemon-reload,
1991 * but if they are already referenced (because of dependencies or ordering)
1992 * then we have to force a load of the fragment. As an optimization, check
1993 * first if anything in the usual paths was modified since the last time
1994 * the cache was loaded. Also check if the last time an attempt to load the
1995 * unit was made was before the most recent cache refresh, so that we know
1996 * we need to try again — even if the cache is current, it might have been
1997 * updated in a different context before we had a chance to retry loading
1998 * this particular unit. */
1999 if (manager_unit_cache_should_retry_load(ret))
2000 ret->load_state = UNIT_STUB;
2001 else {
2002 *_ret = ret;
2003 return 1;
2004 }
2005 } else {
2006 ret = cleanup_ret = unit_new(m, unit_vtable[t]->object_size);
2007 if (!ret)
2008 return -ENOMEM;
2009 }
2010
2011 if (path) {
2012 r = free_and_strdup(&ret->fragment_path, path);
2013 if (r < 0)
2014 return r;
2015 }
2016
2017 r = unit_add_name(ret, name);
2018 if (r < 0)
2019 return r;
2020
2021 unit_add_to_load_queue(ret);
2022 unit_add_to_dbus_queue(ret);
2023 unit_add_to_gc_queue(ret);
2024
2025 *_ret = ret;
2026 cleanup_ret = NULL;
2027
2028 return 0;
2029 }
2030
2031 int manager_load_unit(
2032 Manager *m,
2033 const char *name,
2034 const char *path,
2035 sd_bus_error *e,
2036 Unit **_ret) {
2037
2038 int r;
2039
2040 assert(m);
2041 assert(_ret);
2042
2043 /* This will load the service information files, but not actually
2044 * start any services or anything. */
2045
2046 r = manager_load_unit_prepare(m, name, path, e, _ret);
2047 if (r != 0)
2048 return r;
2049
2050 manager_dispatch_load_queue(m);
2051
2052 *_ret = unit_follow_merge(*_ret);
2053 return 0;
2054 }
2055
2056 int manager_load_startable_unit_or_warn(
2057 Manager *m,
2058 const char *name,
2059 const char *path,
2060 Unit **ret) {
2061
2062 /* Load a unit, make sure it loaded fully and is not masked. */
2063
2064 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2065 Unit *unit;
2066 int r;
2067
2068 r = manager_load_unit(m, name, path, &error, &unit);
2069 if (r < 0)
2070 return log_error_errno(r, "Failed to load %s %s: %s",
2071 name ? "unit" : "unit file", name ?: path,
2072 bus_error_message(&error, r));
2073
2074 r = bus_unit_validate_load_state(unit, &error);
2075 if (r < 0)
2076 return log_error_errno(r, "%s", bus_error_message(&error, r));
2077
2078 *ret = unit;
2079 return 0;
2080 }
2081
2082 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
2083 Job *j;
2084
2085 assert(s);
2086 assert(f);
2087
2088 HASHMAP_FOREACH(j, s->jobs)
2089 job_dump(j, f, prefix);
2090 }
2091
2092 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
2093 Unit *u;
2094 const char *t;
2095
2096 assert(s);
2097 assert(f);
2098
2099 HASHMAP_FOREACH_KEY(u, t, s->units)
2100 if (u->id == t)
2101 unit_dump(u, f, prefix);
2102 }
2103
2104 void manager_dump(Manager *m, FILE *f, const char *prefix) {
2105 assert(m);
2106 assert(f);
2107
2108 for (ManagerTimestamp q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
2109 const dual_timestamp *t = m->timestamps + q;
2110 char buf[CONST_MAX(FORMAT_TIMESPAN_MAX, FORMAT_TIMESTAMP_MAX)];
2111
2112 if (dual_timestamp_is_set(t))
2113 fprintf(f, "%sTimestamp %s: %s\n",
2114 strempty(prefix),
2115 manager_timestamp_to_string(q),
2116 timestamp_is_set(t->realtime) ? format_timestamp(buf, sizeof buf, t->realtime) :
2117 format_timespan(buf, sizeof buf, t->monotonic, 1));
2118 }
2119
2120 manager_dump_units(m, f, prefix);
2121 manager_dump_jobs(m, f, prefix);
2122 }
2123
2124 int manager_get_dump_string(Manager *m, char **ret) {
2125 _cleanup_free_ char *dump = NULL;
2126 _cleanup_fclose_ FILE *f = NULL;
2127 size_t size;
2128 int r;
2129
2130 assert(m);
2131 assert(ret);
2132
2133 f = open_memstream_unlocked(&dump, &size);
2134 if (!f)
2135 return -errno;
2136
2137 manager_dump(m, f, NULL);
2138
2139 r = fflush_and_check(f);
2140 if (r < 0)
2141 return r;
2142
2143 f = safe_fclose(f);
2144
2145 *ret = TAKE_PTR(dump);
2146
2147 return 0;
2148 }
2149
2150 void manager_clear_jobs(Manager *m) {
2151 Job *j;
2152
2153 assert(m);
2154
2155 while ((j = hashmap_first(m->jobs)))
2156 /* No need to recurse. We're cancelling all jobs. */
2157 job_finish_and_invalidate(j, JOB_CANCELED, false, false);
2158 }
2159
2160 void manager_unwatch_pid(Manager *m, pid_t pid) {
2161 assert(m);
2162
2163 /* First let's drop the unit keyed as "pid". */
2164 (void) hashmap_remove(m->watch_pids, PID_TO_PTR(pid));
2165
2166 /* Then, let's also drop the array keyed by -pid. */
2167 free(hashmap_remove(m->watch_pids, PID_TO_PTR(-pid)));
2168 }
2169
2170 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
2171 Manager *m = userdata;
2172 Job *j;
2173
2174 assert(source);
2175 assert(m);
2176
2177 while ((j = prioq_peek(m->run_queue))) {
2178 assert(j->installed);
2179 assert(j->in_run_queue);
2180
2181 (void) job_run_and_invalidate(j);
2182 }
2183
2184 if (m->n_running_jobs > 0)
2185 manager_watch_jobs_in_progress(m);
2186
2187 if (m->n_on_console > 0)
2188 manager_watch_idle_pipe(m);
2189
2190 return 1;
2191 }
2192
2193 static unsigned manager_dispatch_dbus_queue(Manager *m) {
2194 unsigned n = 0, budget;
2195 Unit *u;
2196 Job *j;
2197
2198 assert(m);
2199
2200 /* When we are reloading, let's not wait with generating signals, since we need to exit the manager as quickly
2201 * as we can. There's no point in throttling generation of signals in that case. */
2202 if (MANAGER_IS_RELOADING(m) || m->send_reloading_done || m->pending_reload_message)
2203 budget = (unsigned) -1; /* infinite budget in this case */
2204 else {
2205 /* Anything to do at all? */
2206 if (!m->dbus_unit_queue && !m->dbus_job_queue)
2207 return 0;
2208
2209 /* Do we have overly many messages queued at the moment? If so, let's not enqueue more on top, let's
2210 * sit this cycle out, and process things in a later cycle when the queues got a bit emptier. */
2211 if (manager_bus_n_queued_write(m) > MANAGER_BUS_BUSY_THRESHOLD)
2212 return 0;
2213
2214 /* Only process a certain number of units/jobs per event loop iteration. Even if the bus queue wasn't
2215 * overly full before this call we shouldn't increase it in size too wildly in one step, and we
2216 * shouldn't monopolize CPU time with generating these messages. Note the difference in counting of
2217 * this "budget" and the "threshold" above: the "budget" is decreased only once per generated message,
2218 * regardless how many buses/direct connections it is enqueued on, while the "threshold" is applied to
2219 * each queued instance of bus message, i.e. if the same message is enqueued to five buses/direct
2220 * connections it will be counted five times. This difference in counting ("references"
2221 * vs. "instances") is primarily a result of the fact that it's easier to implement it this way,
2222 * however it also reflects the thinking that the "threshold" should put a limit on used queue memory,
2223 * i.e. space, while the "budget" should put a limit on time. Also note that the "threshold" is
2224 * currently chosen much higher than the "budget". */
2225 budget = MANAGER_BUS_MESSAGE_BUDGET;
2226 }
2227
2228 while (budget != 0 && (u = m->dbus_unit_queue)) {
2229
2230 assert(u->in_dbus_queue);
2231
2232 bus_unit_send_change_signal(u);
2233 n++;
2234
2235 if (budget != (unsigned) -1)
2236 budget--;
2237 }
2238
2239 while (budget != 0 && (j = m->dbus_job_queue)) {
2240 assert(j->in_dbus_queue);
2241
2242 bus_job_send_change_signal(j);
2243 n++;
2244
2245 if (budget != (unsigned) -1)
2246 budget--;
2247 }
2248
2249 if (m->send_reloading_done) {
2250 m->send_reloading_done = false;
2251 bus_manager_send_reloading(m, false);
2252 n++;
2253 }
2254
2255 if (m->pending_reload_message) {
2256 bus_send_pending_reload_message(m);
2257 n++;
2258 }
2259
2260 return n;
2261 }
2262
2263 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2264 Manager *m = userdata;
2265 char buf[PATH_MAX];
2266 ssize_t n;
2267
2268 n = recv(fd, buf, sizeof(buf), 0);
2269 if (n < 0)
2270 return log_error_errno(errno, "Failed to read cgroups agent message: %m");
2271 if (n == 0) {
2272 log_error("Got zero-length cgroups agent message, ignoring.");
2273 return 0;
2274 }
2275 if ((size_t) n >= sizeof(buf)) {
2276 log_error("Got overly long cgroups agent message, ignoring.");
2277 return 0;
2278 }
2279
2280 if (memchr(buf, 0, n)) {
2281 log_error("Got cgroups agent message with embedded NUL byte, ignoring.");
2282 return 0;
2283 }
2284 buf[n] = 0;
2285
2286 manager_notify_cgroup_empty(m, buf);
2287 (void) bus_forward_agent_released(m, buf);
2288
2289 return 0;
2290 }
2291
2292 static bool manager_process_barrier_fd(char * const *tags, FDSet *fds) {
2293
2294 /* nothing else must be sent when using BARRIER=1 */
2295 if (strv_contains(tags, "BARRIER=1")) {
2296 if (strv_length(tags) == 1) {
2297 if (fdset_size(fds) != 1)
2298 log_warning("Got incorrect number of fds with BARRIER=1, closing them.");
2299 } else
2300 log_warning("Extra notification messages sent with BARRIER=1, ignoring everything.");
2301
2302 /* Drop the message if BARRIER=1 was found */
2303 return true;
2304 }
2305
2306 return false;
2307 }
2308
2309 static void manager_invoke_notify_message(
2310 Manager *m,
2311 Unit *u,
2312 const struct ucred *ucred,
2313 char * const *tags,
2314 FDSet *fds) {
2315
2316 assert(m);
2317 assert(u);
2318 assert(ucred);
2319 assert(tags);
2320
2321 if (u->notifygen == m->notifygen) /* Already invoked on this same unit in this same iteration? */
2322 return;
2323 u->notifygen = m->notifygen;
2324
2325 if (UNIT_VTABLE(u)->notify_message)
2326 UNIT_VTABLE(u)->notify_message(u, ucred, tags, fds);
2327
2328 else if (DEBUG_LOGGING) {
2329 _cleanup_free_ char *buf = NULL, *x = NULL, *y = NULL;
2330
2331 buf = strv_join(tags, ", ");
2332 if (buf)
2333 x = ellipsize(buf, 20, 90);
2334 if (x)
2335 y = cescape(x);
2336
2337 log_unit_debug(u, "Got notification message \"%s\", ignoring.", strnull(y));
2338 }
2339 }
2340
2341 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2342
2343 _cleanup_fdset_free_ FDSet *fds = NULL;
2344 Manager *m = userdata;
2345 char buf[NOTIFY_BUFFER_MAX+1];
2346 struct iovec iovec = {
2347 .iov_base = buf,
2348 .iov_len = sizeof(buf)-1,
2349 };
2350 CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct ucred)) +
2351 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)) control;
2352 struct msghdr msghdr = {
2353 .msg_iov = &iovec,
2354 .msg_iovlen = 1,
2355 .msg_control = &control,
2356 .msg_controllen = sizeof(control),
2357 };
2358
2359 struct cmsghdr *cmsg;
2360 struct ucred *ucred = NULL;
2361 _cleanup_free_ Unit **array_copy = NULL;
2362 _cleanup_strv_free_ char **tags = NULL;
2363 Unit *u1, *u2, **array;
2364 int r, *fd_array = NULL;
2365 size_t n_fds = 0;
2366 bool found = false;
2367 ssize_t n;
2368
2369 assert(m);
2370 assert(m->notify_fd == fd);
2371
2372 if (revents != EPOLLIN) {
2373 log_warning("Got unexpected poll event for notify fd.");
2374 return 0;
2375 }
2376
2377 n = recvmsg_safe(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC|MSG_TRUNC);
2378 if (IN_SET(n, -EAGAIN, -EINTR))
2379 return 0; /* Spurious wakeup, try again */
2380 if (n == -EXFULL) {
2381 log_warning("Got message with truncated control data (too many fds sent?), ignoring.");
2382 return 0;
2383 }
2384 if (n < 0)
2385 /* If this is any other, real error, then let's stop processing this socket. This of course
2386 * means we won't take notification messages anymore, but that's still better than busy
2387 * looping around this: being woken up over and over again but being unable to actually read
2388 * the message off the socket. */
2389 return log_error_errno(n, "Failed to receive notification message: %m");
2390
2391 CMSG_FOREACH(cmsg, &msghdr) {
2392 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
2393
2394 assert(!fd_array);
2395 fd_array = (int*) CMSG_DATA(cmsg);
2396 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
2397
2398 } else if (cmsg->cmsg_level == SOL_SOCKET &&
2399 cmsg->cmsg_type == SCM_CREDENTIALS &&
2400 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
2401
2402 assert(!ucred);
2403 ucred = (struct ucred*) CMSG_DATA(cmsg);
2404 }
2405 }
2406
2407 if (n_fds > 0) {
2408 assert(fd_array);
2409
2410 r = fdset_new_array(&fds, fd_array, n_fds);
2411 if (r < 0) {
2412 close_many(fd_array, n_fds);
2413 log_oom();
2414 return 0;
2415 }
2416 }
2417
2418 if (!ucred || !pid_is_valid(ucred->pid)) {
2419 log_warning("Received notify message without valid credentials. Ignoring.");
2420 return 0;
2421 }
2422
2423 if ((size_t) n >= sizeof(buf) || (msghdr.msg_flags & MSG_TRUNC)) {
2424 log_warning("Received notify message exceeded maximum size. Ignoring.");
2425 return 0;
2426 }
2427
2428 /* As extra safety check, let's make sure the string we get doesn't contain embedded NUL bytes. We permit one
2429 * trailing NUL byte in the message, but don't expect it. */
2430 if (n > 1 && memchr(buf, 0, n-1)) {
2431 log_warning("Received notify message with embedded NUL bytes. Ignoring.");
2432 return 0;
2433 }
2434
2435 /* Make sure it's NUL-terminated, then parse it to obtain the tags list */
2436 buf[n] = 0;
2437 tags = strv_split_newlines(buf);
2438 if (!tags) {
2439 log_oom();
2440 return 0;
2441 }
2442
2443 /* possibly a barrier fd, let's see */
2444 if (manager_process_barrier_fd(tags, fds))
2445 return 0;
2446
2447 /* Increase the generation counter used for filtering out duplicate unit invocations. */
2448 m->notifygen++;
2449
2450 /* Notify every unit that might be interested, which might be multiple. */
2451 u1 = manager_get_unit_by_pid_cgroup(m, ucred->pid);
2452 u2 = hashmap_get(m->watch_pids, PID_TO_PTR(ucred->pid));
2453 array = hashmap_get(m->watch_pids, PID_TO_PTR(-ucred->pid));
2454 if (array) {
2455 size_t k = 0;
2456
2457 while (array[k])
2458 k++;
2459
2460 array_copy = newdup(Unit*, array, k+1);
2461 if (!array_copy)
2462 log_oom();
2463 }
2464 /* And now invoke the per-unit callbacks. Note that manager_invoke_notify_message() will handle duplicate units
2465 * make sure we only invoke each unit's handler once. */
2466 if (u1) {
2467 manager_invoke_notify_message(m, u1, ucred, tags, fds);
2468 found = true;
2469 }
2470 if (u2) {
2471 manager_invoke_notify_message(m, u2, ucred, tags, fds);
2472 found = true;
2473 }
2474 if (array_copy)
2475 for (size_t i = 0; array_copy[i]; i++) {
2476 manager_invoke_notify_message(m, array_copy[i], ucred, tags, fds);
2477 found = true;
2478 }
2479
2480 if (!found)
2481 log_warning("Cannot find unit for notify message of PID "PID_FMT", ignoring.", ucred->pid);
2482
2483 if (fdset_size(fds) > 0)
2484 log_warning("Got extra auxiliary fds with notification message, closing them.");
2485
2486 return 0;
2487 }
2488
2489 static void manager_invoke_sigchld_event(
2490 Manager *m,
2491 Unit *u,
2492 const siginfo_t *si) {
2493
2494 assert(m);
2495 assert(u);
2496 assert(si);
2497
2498 /* Already invoked the handler of this unit in this iteration? Then don't process this again */
2499 if (u->sigchldgen == m->sigchldgen)
2500 return;
2501 u->sigchldgen = m->sigchldgen;
2502
2503 log_unit_debug(u, "Child "PID_FMT" belongs to %s.", si->si_pid, u->id);
2504 unit_unwatch_pid(u, si->si_pid);
2505
2506 if (UNIT_VTABLE(u)->sigchld_event)
2507 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
2508 }
2509
2510 static int manager_dispatch_sigchld(sd_event_source *source, void *userdata) {
2511 Manager *m = userdata;
2512 siginfo_t si = {};
2513 int r;
2514
2515 assert(source);
2516 assert(m);
2517
2518 /* First we call waitid() for a PID and do not reap the zombie. That way we can still access /proc/$PID for it
2519 * while it is a zombie. */
2520
2521 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
2522
2523 if (errno != ECHILD)
2524 log_error_errno(errno, "Failed to peek for child with waitid(), ignoring: %m");
2525
2526 goto turn_off;
2527 }
2528
2529 if (si.si_pid <= 0)
2530 goto turn_off;
2531
2532 if (IN_SET(si.si_code, CLD_EXITED, CLD_KILLED, CLD_DUMPED)) {
2533 _cleanup_free_ Unit **array_copy = NULL;
2534 _cleanup_free_ char *name = NULL;
2535 Unit *u1, *u2, **array;
2536
2537 (void) get_process_comm(si.si_pid, &name);
2538
2539 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
2540 si.si_pid, strna(name),
2541 sigchld_code_to_string(si.si_code),
2542 si.si_status,
2543 strna(si.si_code == CLD_EXITED
2544 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
2545 : signal_to_string(si.si_status)));
2546
2547 /* Increase the generation counter used for filtering out duplicate unit invocations */
2548 m->sigchldgen++;
2549
2550 /* And now figure out the unit this belongs to, it might be multiple... */
2551 u1 = manager_get_unit_by_pid_cgroup(m, si.si_pid);
2552 u2 = hashmap_get(m->watch_pids, PID_TO_PTR(si.si_pid));
2553 array = hashmap_get(m->watch_pids, PID_TO_PTR(-si.si_pid));
2554 if (array) {
2555 size_t n = 0;
2556
2557 /* Count how many entries the array has */
2558 while (array[n])
2559 n++;
2560
2561 /* Make a copy of the array so that we don't trip up on the array changing beneath us */
2562 array_copy = newdup(Unit*, array, n+1);
2563 if (!array_copy)
2564 log_oom();
2565 }
2566
2567 /* Finally, execute them all. Note that u1, u2 and the array might contain duplicates, but
2568 * that's fine, manager_invoke_sigchld_event() will ensure we only invoke the handlers once for
2569 * each iteration. */
2570 if (u1) {
2571 /* We check for oom condition, in case we got SIGCHLD before the oom notification.
2572 * We only do this for the cgroup the PID belonged to. */
2573 (void) unit_check_oom(u1);
2574
2575 /* This only logs for now. In the future when the interface for kills/notifications
2576 * is more stable we can extend service results table similar to how kernel oom kills
2577 * are managed. */
2578 (void) unit_check_oomd_kill(u1);
2579
2580 manager_invoke_sigchld_event(m, u1, &si);
2581 }
2582 if (u2)
2583 manager_invoke_sigchld_event(m, u2, &si);
2584 if (array_copy)
2585 for (size_t i = 0; array_copy[i]; i++)
2586 manager_invoke_sigchld_event(m, array_copy[i], &si);
2587 }
2588
2589 /* And now, we actually reap the zombie. */
2590 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
2591 log_error_errno(errno, "Failed to dequeue child, ignoring: %m");
2592 return 0;
2593 }
2594
2595 return 0;
2596
2597 turn_off:
2598 /* All children processed for now, turn off event source */
2599
2600 r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_OFF);
2601 if (r < 0)
2602 return log_error_errno(r, "Failed to disable SIGCHLD event source: %m");
2603
2604 return 0;
2605 }
2606
2607 static void manager_start_target(Manager *m, const char *name, JobMode mode) {
2608 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2609 int r;
2610
2611 log_debug("Activating special unit %s", name);
2612
2613 r = manager_add_job_by_name(m, JOB_START, name, mode, NULL, &error, NULL);
2614 if (r < 0)
2615 log_error("Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
2616 }
2617
2618 static void manager_handle_ctrl_alt_del(Manager *m) {
2619 /* If the user presses C-A-D more than
2620 * 7 times within 2s, we reboot/shutdown immediately,
2621 * unless it was disabled in system.conf */
2622
2623 if (ratelimit_below(&m->ctrl_alt_del_ratelimit) || m->cad_burst_action == EMERGENCY_ACTION_NONE)
2624 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
2625 else
2626 emergency_action(m, m->cad_burst_action, EMERGENCY_ACTION_WARN, NULL, -1,
2627 "Ctrl-Alt-Del was pressed more than 7 times within 2s");
2628 }
2629
2630 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2631 Manager *m = userdata;
2632 ssize_t n;
2633 struct signalfd_siginfo sfsi;
2634 int r;
2635
2636 assert(m);
2637 assert(m->signal_fd == fd);
2638
2639 if (revents != EPOLLIN) {
2640 log_warning("Got unexpected events from signal file descriptor.");
2641 return 0;
2642 }
2643
2644 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
2645 if (n != sizeof(sfsi)) {
2646 if (n >= 0) {
2647 log_warning("Truncated read from signal fd (%zu bytes), ignoring!", n);
2648 return 0;
2649 }
2650
2651 if (IN_SET(errno, EINTR, EAGAIN))
2652 return 0;
2653
2654 /* We return an error here, which will kill this handler,
2655 * to avoid a busy loop on read error. */
2656 return log_error_errno(errno, "Reading from signal fd failed: %m");
2657 }
2658
2659 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
2660 (sfsi.ssi_signo == SIGTERM && MANAGER_IS_USER(m))
2661 ? LOG_DEBUG : LOG_INFO,
2662 &sfsi);
2663
2664 switch (sfsi.ssi_signo) {
2665
2666 case SIGCHLD:
2667 r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_ON);
2668 if (r < 0)
2669 log_warning_errno(r, "Failed to enable SIGCHLD event source, ignoring: %m");
2670
2671 break;
2672
2673 case SIGTERM:
2674 if (MANAGER_IS_SYSTEM(m)) {
2675 /* This is for compatibility with the original sysvinit */
2676 if (verify_run_space_and_log("Refusing to reexecute") < 0)
2677 break;
2678
2679 m->objective = MANAGER_REEXECUTE;
2680 break;
2681 }
2682
2683 _fallthrough_;
2684 case SIGINT:
2685 if (MANAGER_IS_SYSTEM(m))
2686 manager_handle_ctrl_alt_del(m);
2687 else
2688 manager_start_target(m, SPECIAL_EXIT_TARGET,
2689 JOB_REPLACE_IRREVERSIBLY);
2690 break;
2691
2692 case SIGWINCH:
2693 /* This is a nop on non-init */
2694 if (MANAGER_IS_SYSTEM(m))
2695 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2696
2697 break;
2698
2699 case SIGPWR:
2700 /* This is a nop on non-init */
2701 if (MANAGER_IS_SYSTEM(m))
2702 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2703
2704 break;
2705
2706 case SIGUSR1:
2707 if (manager_dbus_is_running(m, false)) {
2708 log_info("Trying to reconnect to bus...");
2709
2710 (void) bus_init_api(m);
2711
2712 if (MANAGER_IS_SYSTEM(m))
2713 (void) bus_init_system(m);
2714 } else {
2715 log_info("Starting D-Bus service...");
2716 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2717 }
2718
2719 break;
2720
2721 case SIGUSR2: {
2722 _cleanup_free_ char *dump = NULL;
2723
2724 r = manager_get_dump_string(m, &dump);
2725 if (r < 0) {
2726 log_warning_errno(errno, "Failed to acquire manager dump: %m");
2727 break;
2728 }
2729
2730 log_dump(LOG_INFO, dump);
2731 break;
2732 }
2733
2734 case SIGHUP:
2735 if (verify_run_space_and_log("Refusing to reload") < 0)
2736 break;
2737
2738 m->objective = MANAGER_RELOAD;
2739 break;
2740
2741 default: {
2742
2743 /* Starting SIGRTMIN+0 */
2744 static const struct {
2745 const char *target;
2746 JobMode mode;
2747 } target_table[] = {
2748 [0] = { SPECIAL_DEFAULT_TARGET, JOB_ISOLATE },
2749 [1] = { SPECIAL_RESCUE_TARGET, JOB_ISOLATE },
2750 [2] = { SPECIAL_EMERGENCY_TARGET, JOB_ISOLATE },
2751 [3] = { SPECIAL_HALT_TARGET, JOB_REPLACE_IRREVERSIBLY },
2752 [4] = { SPECIAL_POWEROFF_TARGET, JOB_REPLACE_IRREVERSIBLY },
2753 [5] = { SPECIAL_REBOOT_TARGET, JOB_REPLACE_IRREVERSIBLY },
2754 [6] = { SPECIAL_KEXEC_TARGET, JOB_REPLACE_IRREVERSIBLY },
2755 };
2756
2757 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2758 static const ManagerObjective objective_table[] = {
2759 [0] = MANAGER_HALT,
2760 [1] = MANAGER_POWEROFF,
2761 [2] = MANAGER_REBOOT,
2762 [3] = MANAGER_KEXEC,
2763 };
2764
2765 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2766 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2767 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2768 manager_start_target(m, target_table[idx].target,
2769 target_table[idx].mode);
2770 break;
2771 }
2772
2773 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2774 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(objective_table)) {
2775 m->objective = objective_table[sfsi.ssi_signo - SIGRTMIN - 13];
2776 break;
2777 }
2778
2779 switch (sfsi.ssi_signo - SIGRTMIN) {
2780
2781 case 20:
2782 manager_override_show_status(m, SHOW_STATUS_YES, "signal");
2783 break;
2784
2785 case 21:
2786 manager_override_show_status(m, SHOW_STATUS_NO, "signal");
2787 break;
2788
2789 case 22:
2790 manager_override_log_level(m, LOG_DEBUG);
2791 break;
2792
2793 case 23:
2794 manager_restore_original_log_level(m);
2795 break;
2796
2797 case 24:
2798 if (MANAGER_IS_USER(m)) {
2799 m->objective = MANAGER_EXIT;
2800 return 0;
2801 }
2802
2803 /* This is a nop on init */
2804 break;
2805
2806 case 26:
2807 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
2808 manager_restore_original_log_target(m);
2809 break;
2810
2811 case 27:
2812 manager_override_log_target(m, LOG_TARGET_CONSOLE);
2813 break;
2814
2815 case 28:
2816 manager_override_log_target(m, LOG_TARGET_KMSG);
2817 break;
2818
2819 default:
2820 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2821 }
2822 }}
2823
2824 return 0;
2825 }
2826
2827 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2828 Manager *m = userdata;
2829 Unit *u;
2830
2831 assert(m);
2832 assert(m->time_change_fd == fd);
2833
2834 log_struct(LOG_DEBUG,
2835 "MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
2836 LOG_MESSAGE("Time has been changed"));
2837
2838 /* Restart the watch */
2839 (void) manager_setup_time_change(m);
2840
2841 HASHMAP_FOREACH(u, m->units)
2842 if (UNIT_VTABLE(u)->time_change)
2843 UNIT_VTABLE(u)->time_change(u);
2844
2845 return 0;
2846 }
2847
2848 static int manager_dispatch_timezone_change(
2849 sd_event_source *source,
2850 const struct inotify_event *e,
2851 void *userdata) {
2852
2853 Manager *m = userdata;
2854 int changed;
2855 Unit *u;
2856
2857 assert(m);
2858
2859 log_debug("inotify event for /etc/localtime");
2860
2861 changed = manager_read_timezone_stat(m);
2862 if (changed <= 0)
2863 return changed;
2864
2865 /* Something changed, restart the watch, to ensure we watch the new /etc/localtime if it changed */
2866 (void) manager_setup_timezone_change(m);
2867
2868 /* Read the new timezone */
2869 tzset();
2870
2871 log_debug("Timezone has been changed (now: %s).", tzname[daylight]);
2872
2873 HASHMAP_FOREACH(u, m->units)
2874 if (UNIT_VTABLE(u)->timezone_change)
2875 UNIT_VTABLE(u)->timezone_change(u);
2876
2877 return 0;
2878 }
2879
2880 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2881 Manager *m = userdata;
2882
2883 assert(m);
2884 assert(m->idle_pipe[2] == fd);
2885
2886 /* There's at least one Type=idle child that just gave up on us waiting for the boot process to complete. Let's
2887 * now turn off any further console output if there's at least one service that needs console access, so that
2888 * from now on our own output should not spill into that service's output anymore. After all, we support
2889 * Type=idle only to beautify console output and it generally is set on services that want to own the console
2890 * exclusively without our interference. */
2891 m->no_console_output = m->n_on_console > 0;
2892
2893 /* Acknowledge the child's request, and let all all other children know too that they shouldn't wait any longer
2894 * by closing the pipes towards them, which is what they are waiting for. */
2895 manager_close_idle_pipe(m);
2896
2897 return 0;
2898 }
2899
2900 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
2901 Manager *m = userdata;
2902 int r;
2903
2904 assert(m);
2905 assert(source);
2906
2907 manager_print_jobs_in_progress(m);
2908
2909 r = sd_event_source_set_time_relative(source, JOBS_IN_PROGRESS_PERIOD_USEC);
2910 if (r < 0)
2911 return r;
2912
2913 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
2914 }
2915
2916 int manager_loop(Manager *m) {
2917 RateLimit rl = { .interval = 1*USEC_PER_SEC, .burst = 50000 };
2918 int r;
2919
2920 assert(m);
2921 assert(m->objective == MANAGER_OK); /* Ensure manager_startup() has been called */
2922
2923 manager_check_finished(m);
2924
2925 /* There might still be some zombies hanging around from before we were exec()'ed. Let's reap them. */
2926 r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_ON);
2927 if (r < 0)
2928 return log_error_errno(r, "Failed to enable SIGCHLD event source: %m");
2929
2930 while (m->objective == MANAGER_OK) {
2931 usec_t wait_usec, watchdog_usec;
2932
2933 watchdog_usec = manager_get_watchdog(m, WATCHDOG_RUNTIME);
2934 if (m->runtime_watchdog_running)
2935 (void) watchdog_ping();
2936 else if (timestamp_is_set(watchdog_usec))
2937 manager_retry_runtime_watchdog(m);
2938
2939 if (!ratelimit_below(&rl)) {
2940 /* Yay, something is going seriously wrong, pause a little */
2941 log_warning("Looping too fast. Throttling execution a little.");
2942 sleep(1);
2943 }
2944
2945 if (manager_dispatch_load_queue(m) > 0)
2946 continue;
2947
2948 if (manager_dispatch_gc_job_queue(m) > 0)
2949 continue;
2950
2951 if (manager_dispatch_gc_unit_queue(m) > 0)
2952 continue;
2953
2954 if (manager_dispatch_cleanup_queue(m) > 0)
2955 continue;
2956
2957 if (manager_dispatch_cgroup_realize_queue(m) > 0)
2958 continue;
2959
2960 if (manager_dispatch_stop_when_unneeded_queue(m) > 0)
2961 continue;
2962
2963 if (manager_dispatch_dbus_queue(m) > 0)
2964 continue;
2965
2966 /* Sleep for watchdog runtime wait time */
2967 if (timestamp_is_set(watchdog_usec))
2968 wait_usec = watchdog_runtime_wait();
2969 else
2970 wait_usec = USEC_INFINITY;
2971
2972 r = sd_event_run(m->event, wait_usec);
2973 if (r < 0)
2974 return log_error_errno(r, "Failed to run event loop: %m");
2975 }
2976
2977 return m->objective;
2978 }
2979
2980 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2981 _cleanup_free_ char *n = NULL;
2982 sd_id128_t invocation_id;
2983 Unit *u;
2984 int r;
2985
2986 assert(m);
2987 assert(s);
2988 assert(_u);
2989
2990 r = unit_name_from_dbus_path(s, &n);
2991 if (r < 0)
2992 return r;
2993
2994 /* Permit addressing units by invocation ID: if the passed bus path is suffixed by a 128bit ID then we use it
2995 * as invocation ID. */
2996 r = sd_id128_from_string(n, &invocation_id);
2997 if (r >= 0) {
2998 u = hashmap_get(m->units_by_invocation_id, &invocation_id);
2999 if (u) {
3000 *_u = u;
3001 return 0;
3002 }
3003
3004 return sd_bus_error_setf(e, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID,
3005 "No unit with the specified invocation ID " SD_ID128_FORMAT_STR " known.",
3006 SD_ID128_FORMAT_VAL(invocation_id));
3007 }
3008
3009 /* If this didn't work, we check if this is a unit name */
3010 if (!unit_name_is_valid(n, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE)) {
3011 _cleanup_free_ char *nn = NULL;
3012
3013 nn = cescape(n);
3014 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS,
3015 "Unit name %s is neither a valid invocation ID nor unit name.", strnull(nn));
3016 }
3017
3018 r = manager_load_unit(m, n, NULL, e, &u);
3019 if (r < 0)
3020 return r;
3021
3022 *_u = u;
3023 return 0;
3024 }
3025
3026 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
3027 const char *p;
3028 unsigned id;
3029 Job *j;
3030 int r;
3031
3032 assert(m);
3033 assert(s);
3034 assert(_j);
3035
3036 p = startswith(s, "/org/freedesktop/systemd1/job/");
3037 if (!p)
3038 return -EINVAL;
3039
3040 r = safe_atou(p, &id);
3041 if (r < 0)
3042 return r;
3043
3044 j = manager_get_job(m, id);
3045 if (!j)
3046 return -ENOENT;
3047
3048 *_j = j;
3049
3050 return 0;
3051 }
3052
3053 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
3054
3055 #if HAVE_AUDIT
3056 _cleanup_free_ char *p = NULL;
3057 const char *msg;
3058 int audit_fd, r;
3059
3060 if (!MANAGER_IS_SYSTEM(m))
3061 return;
3062
3063 audit_fd = get_audit_fd();
3064 if (audit_fd < 0)
3065 return;
3066
3067 /* Don't generate audit events if the service was already
3068 * started and we're just deserializing */
3069 if (MANAGER_IS_RELOADING(m))
3070 return;
3071
3072 if (u->type != UNIT_SERVICE)
3073 return;
3074
3075 r = unit_name_to_prefix_and_instance(u->id, &p);
3076 if (r < 0) {
3077 log_error_errno(r, "Failed to extract prefix and instance of unit name: %m");
3078 return;
3079 }
3080
3081 msg = strjoina("unit=", p);
3082 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
3083 if (errno == EPERM)
3084 /* We aren't allowed to send audit messages?
3085 * Then let's not retry again. */
3086 close_audit_fd();
3087 else
3088 log_warning_errno(errno, "Failed to send audit message: %m");
3089 }
3090 #endif
3091
3092 }
3093
3094 void manager_send_unit_plymouth(Manager *m, Unit *u) {
3095 static const union sockaddr_union sa = PLYMOUTH_SOCKET;
3096 _cleanup_free_ char *message = NULL;
3097 _cleanup_close_ int fd = -1;
3098 int n = 0;
3099
3100 /* Don't generate plymouth events if the service was already
3101 * started and we're just deserializing */
3102 if (MANAGER_IS_RELOADING(m))
3103 return;
3104
3105 if (!MANAGER_IS_SYSTEM(m))
3106 return;
3107
3108 if (detect_container() > 0)
3109 return;
3110
3111 if (!IN_SET(u->type, UNIT_SERVICE, UNIT_MOUNT, UNIT_SWAP))
3112 return;
3113
3114 /* We set SOCK_NONBLOCK here so that we rather drop the
3115 * message then wait for plymouth */
3116 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
3117 if (fd < 0) {
3118 log_error_errno(errno, "socket() failed: %m");
3119 return;
3120 }
3121
3122 if (connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
3123 if (!IN_SET(errno, EAGAIN, ENOENT) && !ERRNO_IS_DISCONNECT(errno))
3124 log_error_errno(errno, "connect() failed: %m");
3125 return;
3126 }
3127
3128 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
3129 log_oom();
3130 return;
3131 }
3132
3133 errno = 0;
3134 if (write(fd, message, n + 1) != n + 1)
3135 if (!IN_SET(errno, EAGAIN, ENOENT) && !ERRNO_IS_DISCONNECT(errno))
3136 log_error_errno(errno, "Failed to write Plymouth message: %m");
3137 }
3138
3139 int manager_open_serialization(Manager *m, FILE **_f) {
3140 _cleanup_close_ int fd = -1;
3141 FILE *f;
3142
3143 assert(_f);
3144
3145 fd = open_serialization_fd("systemd-state");
3146 if (fd < 0)
3147 return fd;
3148
3149 f = take_fdopen(&fd, "w+");
3150 if (!f)
3151 return -errno;
3152
3153 *_f = f;
3154 return 0;
3155 }
3156
3157 static bool manager_timestamp_shall_serialize(ManagerTimestamp t) {
3158
3159 if (!in_initrd())
3160 return true;
3161
3162 /* The following timestamps only apply to the host system, hence only serialize them there */
3163 return !IN_SET(t,
3164 MANAGER_TIMESTAMP_USERSPACE, MANAGER_TIMESTAMP_FINISH,
3165 MANAGER_TIMESTAMP_SECURITY_START, MANAGER_TIMESTAMP_SECURITY_FINISH,
3166 MANAGER_TIMESTAMP_GENERATORS_START, MANAGER_TIMESTAMP_GENERATORS_FINISH,
3167 MANAGER_TIMESTAMP_UNITS_LOAD_START, MANAGER_TIMESTAMP_UNITS_LOAD_FINISH);
3168 }
3169
3170 #define DESTROY_IPC_FLAG (UINT32_C(1) << 31)
3171
3172 static void manager_serialize_uid_refs_internal(
3173 FILE *f,
3174 Hashmap *uid_refs,
3175 const char *field_name) {
3176
3177 void *p, *k;
3178
3179 assert(f);
3180 assert(field_name);
3181
3182 /* Serialize the UID reference table. Or actually, just the IPC destruction flag of it, as
3183 * the actual counter of it is better rebuild after a reload/reexec. */
3184
3185 HASHMAP_FOREACH_KEY(p, k, uid_refs) {
3186 uint32_t c;
3187 uid_t uid;
3188
3189 uid = PTR_TO_UID(k);
3190 c = PTR_TO_UINT32(p);
3191
3192 if (!(c & DESTROY_IPC_FLAG))
3193 continue;
3194
3195 (void) serialize_item_format(f, field_name, UID_FMT, uid);
3196 }
3197 }
3198
3199 static void manager_serialize_uid_refs(Manager *m, FILE *f) {
3200 manager_serialize_uid_refs_internal(f, m->uid_refs, "destroy-ipc-uid");
3201 }
3202
3203 static void manager_serialize_gid_refs(Manager *m, FILE *f) {
3204 manager_serialize_uid_refs_internal(f, m->gid_refs, "destroy-ipc-gid");
3205 }
3206
3207 int manager_serialize(
3208 Manager *m,
3209 FILE *f,
3210 FDSet *fds,
3211 bool switching_root) {
3212
3213 const char *t;
3214 Unit *u;
3215 int r;
3216
3217 assert(m);
3218 assert(f);
3219 assert(fds);
3220
3221 _cleanup_(manager_reloading_stopp) _unused_ Manager *reloading = manager_reloading_start(m);
3222
3223 (void) serialize_item_format(f, "current-job-id", "%" PRIu32, m->current_job_id);
3224 (void) serialize_item_format(f, "n-installed-jobs", "%u", m->n_installed_jobs);
3225 (void) serialize_item_format(f, "n-failed-jobs", "%u", m->n_failed_jobs);
3226 (void) serialize_bool(f, "taint-usr", m->taint_usr);
3227 (void) serialize_bool(f, "ready-sent", m->ready_sent);
3228 (void) serialize_bool(f, "taint-logged", m->taint_logged);
3229 (void) serialize_bool(f, "service-watchdogs", m->service_watchdogs);
3230
3231 /* After switching root, udevd has not been started yet. So, enumeration results should not be emitted. */
3232 (void) serialize_bool(f, "honor-device-enumeration", !switching_root);
3233
3234 if (m->show_status_overridden != _SHOW_STATUS_INVALID)
3235 (void) serialize_item(f, "show-status-overridden",
3236 show_status_to_string(m->show_status_overridden));
3237
3238 if (m->log_level_overridden)
3239 (void) serialize_item_format(f, "log-level-override", "%i", log_get_max_level());
3240 if (m->log_target_overridden)
3241 (void) serialize_item(f, "log-target-override", log_target_to_string(log_get_target()));
3242
3243 (void) serialize_usec(f, "runtime-watchdog-overridden", m->watchdog_overridden[WATCHDOG_RUNTIME]);
3244 (void) serialize_usec(f, "reboot-watchdog-overridden", m->watchdog_overridden[WATCHDOG_REBOOT]);
3245 (void) serialize_usec(f, "kexec-watchdog-overridden", m->watchdog_overridden[WATCHDOG_KEXEC]);
3246
3247 for (ManagerTimestamp q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
3248 _cleanup_free_ char *joined = NULL;
3249
3250 if (!manager_timestamp_shall_serialize(q))
3251 continue;
3252
3253 joined = strjoin(manager_timestamp_to_string(q), "-timestamp");
3254 if (!joined)
3255 return log_oom();
3256
3257 (void) serialize_dual_timestamp(f, joined, m->timestamps + q);
3258 }
3259
3260 if (!switching_root)
3261 (void) serialize_strv(f, "env", m->client_environment);
3262
3263 if (m->notify_fd >= 0) {
3264 r = serialize_fd(f, fds, "notify-fd", m->notify_fd);
3265 if (r < 0)
3266 return r;
3267
3268 (void) serialize_item(f, "notify-socket", m->notify_socket);
3269 }
3270
3271 if (m->cgroups_agent_fd >= 0) {
3272 r = serialize_fd(f, fds, "cgroups-agent-fd", m->cgroups_agent_fd);
3273 if (r < 0)
3274 return r;
3275 }
3276
3277 if (m->user_lookup_fds[0] >= 0) {
3278 int copy0, copy1;
3279
3280 copy0 = fdset_put_dup(fds, m->user_lookup_fds[0]);
3281 if (copy0 < 0)
3282 return log_error_errno(copy0, "Failed to add user lookup fd to serialization: %m");
3283
3284 copy1 = fdset_put_dup(fds, m->user_lookup_fds[1]);
3285 if (copy1 < 0)
3286 return log_error_errno(copy1, "Failed to add user lookup fd to serialization: %m");
3287
3288 (void) serialize_item_format(f, "user-lookup", "%i %i", copy0, copy1);
3289 }
3290
3291 bus_track_serialize(m->subscribed, f, "subscribed");
3292
3293 r = dynamic_user_serialize(m, f, fds);
3294 if (r < 0)
3295 return r;
3296
3297 manager_serialize_uid_refs(m, f);
3298 manager_serialize_gid_refs(m, f);
3299
3300 r = exec_runtime_serialize(m, f, fds);
3301 if (r < 0)
3302 return r;
3303
3304 (void) fputc('\n', f);
3305
3306 HASHMAP_FOREACH_KEY(u, t, m->units) {
3307 if (u->id != t)
3308 continue;
3309
3310 /* Start marker */
3311 fputs(u->id, f);
3312 fputc('\n', f);
3313
3314 r = unit_serialize(u, f, fds, !switching_root);
3315 if (r < 0)
3316 return r;
3317 }
3318
3319 r = fflush_and_check(f);
3320 if (r < 0)
3321 return log_error_errno(r, "Failed to flush serialization: %m");
3322
3323 r = bus_fdset_add_all(m, fds);
3324 if (r < 0)
3325 return log_error_errno(r, "Failed to add bus sockets to serialization: %m");
3326
3327 return 0;
3328 }
3329
3330 static int manager_deserialize_one_unit(Manager *m, const char *name, FILE *f, FDSet *fds) {
3331 Unit *u;
3332 int r;
3333
3334 r = manager_load_unit(m, name, NULL, NULL, &u);
3335 if (r < 0) {
3336 if (r == -ENOMEM)
3337 return r;
3338 return log_notice_errno(r, "Failed to load unit \"%s\", skipping deserialization: %m", name);
3339 }
3340
3341 r = unit_deserialize(u, f, fds);
3342 if (r < 0) {
3343 if (r == -ENOMEM)
3344 return r;
3345 return log_notice_errno(r, "Failed to deserialize unit \"%s\", skipping: %m", name);
3346 }
3347
3348 return 0;
3349 }
3350
3351 static int manager_deserialize_units(Manager *m, FILE *f, FDSet *fds) {
3352 const char *unit_name;
3353 int r;
3354
3355 for (;;) {
3356 _cleanup_free_ char *line = NULL;
3357 /* Start marker */
3358 r = read_line(f, LONG_LINE_MAX, &line);
3359 if (r < 0)
3360 return log_error_errno(r, "Failed to read serialization line: %m");
3361 if (r == 0)
3362 break;
3363
3364 unit_name = strstrip(line);
3365
3366 r = manager_deserialize_one_unit(m, unit_name, f, fds);
3367 if (r == -ENOMEM)
3368 return r;
3369 if (r < 0) {
3370 r = unit_deserialize_skip(f);
3371 if (r < 0)
3372 return r;
3373 }
3374 }
3375
3376 return 0;
3377 }
3378
3379 usec_t manager_get_watchdog(Manager *m, WatchdogType t) {
3380 assert(m);
3381
3382 if (MANAGER_IS_USER(m))
3383 return USEC_INFINITY;
3384
3385 if (timestamp_is_set(m->watchdog_overridden[t]))
3386 return m->watchdog_overridden[t];
3387
3388 return m->watchdog[t];
3389 }
3390
3391 void manager_set_watchdog(Manager *m, WatchdogType t, usec_t timeout) {
3392 int r = 0;
3393
3394 assert(m);
3395
3396 if (MANAGER_IS_USER(m))
3397 return;
3398
3399 if (m->watchdog[t] == timeout)
3400 return;
3401
3402 if (t == WATCHDOG_RUNTIME)
3403 if (!timestamp_is_set(m->watchdog_overridden[WATCHDOG_RUNTIME])) {
3404 if (timestamp_is_set(timeout)) {
3405 r = watchdog_set_timeout(&timeout);
3406
3407 if (r >= 0)
3408 m->runtime_watchdog_running = true;
3409 } else {
3410 watchdog_close(true);
3411 m->runtime_watchdog_running = false;
3412 }
3413 }
3414
3415 m->watchdog[t] = timeout;
3416 }
3417
3418 int manager_override_watchdog(Manager *m, WatchdogType t, usec_t timeout) {
3419 int r = 0;
3420
3421 assert(m);
3422
3423 if (MANAGER_IS_USER(m))
3424 return 0;
3425
3426 if (m->watchdog_overridden[t] == timeout)
3427 return 0;
3428
3429 if (t == WATCHDOG_RUNTIME) {
3430 usec_t *p;
3431
3432 p = timestamp_is_set(timeout) ? &timeout : &m->watchdog[t];
3433 if (timestamp_is_set(*p)) {
3434 r = watchdog_set_timeout(p);
3435
3436 if (r >= 0)
3437 m->runtime_watchdog_running = true;
3438 } else {
3439 watchdog_close(true);
3440 m->runtime_watchdog_running = false;
3441 }
3442 }
3443
3444 m->watchdog_overridden[t] = timeout;
3445
3446 return 0;
3447 }
3448
3449 void manager_retry_runtime_watchdog(Manager *m) {
3450 int r = 0;
3451
3452 assert(m);
3453
3454 if (timestamp_is_set(m->watchdog_overridden[WATCHDOG_RUNTIME]))
3455 r = watchdog_set_timeout(&m->watchdog_overridden[WATCHDOG_RUNTIME]);
3456 else
3457 r = watchdog_set_timeout(&m->watchdog[WATCHDOG_RUNTIME]);
3458
3459 if (r >= 0)
3460 m->runtime_watchdog_running = true;
3461 }
3462
3463 static void manager_deserialize_uid_refs_one_internal(
3464 Hashmap** uid_refs,
3465 const char *value) {
3466
3467 uid_t uid;
3468 uint32_t c;
3469 int r;
3470
3471 assert(uid_refs);
3472 assert(value);
3473
3474 r = parse_uid(value, &uid);
3475 if (r < 0 || uid == 0) {
3476 log_debug("Unable to parse UID/GID reference serialization: " UID_FMT, uid);
3477 return;
3478 }
3479
3480 if (hashmap_ensure_allocated(uid_refs, &trivial_hash_ops) < 0) {
3481 log_oom();
3482 return;
3483 }
3484
3485 c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3486 if (c & DESTROY_IPC_FLAG)
3487 return;
3488
3489 c |= DESTROY_IPC_FLAG;
3490
3491 r = hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
3492 if (r < 0) {
3493 log_debug_errno(r, "Failed to add UID/GID reference entry: %m");
3494 return;
3495 }
3496 }
3497
3498 static void manager_deserialize_uid_refs_one(Manager *m, const char *value) {
3499 manager_deserialize_uid_refs_one_internal(&m->uid_refs, value);
3500 }
3501
3502 static void manager_deserialize_gid_refs_one(Manager *m, const char *value) {
3503 manager_deserialize_uid_refs_one_internal(&m->gid_refs, value);
3504 }
3505
3506 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
3507 int r = 0;
3508
3509 assert(m);
3510 assert(f);
3511
3512 if (DEBUG_LOGGING) {
3513 if (fdset_isempty(fds))
3514 log_debug("No file descriptors passed");
3515 else {
3516 int fd;
3517
3518 FDSET_FOREACH(fd, fds) {
3519 _cleanup_free_ char *fn = NULL;
3520
3521 r = fd_get_path(fd, &fn);
3522 if (r < 0)
3523 log_debug_errno(r, "Received serialized fd %i → %m", fd);
3524 else
3525 log_debug("Received serialized fd %i → %s", fd, strna(fn));
3526 }
3527 }
3528 }
3529
3530 log_debug("Deserializing state...");
3531
3532 /* If we are not in reload mode yet, enter it now. Not that this is recursive, a caller might already have
3533 * increased it to non-zero, which is why we just increase it by one here and down again at the end of this
3534 * call. */
3535 _cleanup_(manager_reloading_stopp) _unused_ Manager *reloading = manager_reloading_start(m);
3536
3537 for (;;) {
3538 _cleanup_free_ char *line = NULL;
3539 const char *val, *l;
3540
3541 r = read_line(f, LONG_LINE_MAX, &line);
3542 if (r < 0)
3543 return log_error_errno(r, "Failed to read serialization line: %m");
3544 if (r == 0)
3545 break;
3546
3547 l = strstrip(line);
3548 if (isempty(l)) /* end marker */
3549 break;
3550
3551 if ((val = startswith(l, "current-job-id="))) {
3552 uint32_t id;
3553
3554 if (safe_atou32(val, &id) < 0)
3555 log_notice("Failed to parse current job id value '%s', ignoring.", val);
3556 else
3557 m->current_job_id = MAX(m->current_job_id, id);
3558
3559 } else if ((val = startswith(l, "n-installed-jobs="))) {
3560 uint32_t n;
3561
3562 if (safe_atou32(val, &n) < 0)
3563 log_notice("Failed to parse installed jobs counter '%s', ignoring.", val);
3564 else
3565 m->n_installed_jobs += n;
3566
3567 } else if ((val = startswith(l, "n-failed-jobs="))) {
3568 uint32_t n;
3569
3570 if (safe_atou32(val, &n) < 0)
3571 log_notice("Failed to parse failed jobs counter '%s', ignoring.", val);
3572 else
3573 m->n_failed_jobs += n;
3574
3575 } else if ((val = startswith(l, "taint-usr="))) {
3576 int b;
3577
3578 b = parse_boolean(val);
3579 if (b < 0)
3580 log_notice("Failed to parse taint /usr flag '%s', ignoring.", val);
3581 else
3582 m->taint_usr = m->taint_usr || b;
3583
3584 } else if ((val = startswith(l, "ready-sent="))) {
3585 int b;
3586
3587 b = parse_boolean(val);
3588 if (b < 0)
3589 log_notice("Failed to parse ready-sent flag '%s', ignoring.", val);
3590 else
3591 m->ready_sent = m->ready_sent || b;
3592
3593 } else if ((val = startswith(l, "taint-logged="))) {
3594 int b;
3595
3596 b = parse_boolean(val);
3597 if (b < 0)
3598 log_notice("Failed to parse taint-logged flag '%s', ignoring.", val);
3599 else
3600 m->taint_logged = m->taint_logged || b;
3601
3602 } else if ((val = startswith(l, "service-watchdogs="))) {
3603 int b;
3604
3605 b = parse_boolean(val);
3606 if (b < 0)
3607 log_notice("Failed to parse service-watchdogs flag '%s', ignoring.", val);
3608 else
3609 m->service_watchdogs = b;
3610
3611 } else if ((val = startswith(l, "honor-device-enumeration="))) {
3612 int b;
3613
3614 b = parse_boolean(val);
3615 if (b < 0)
3616 log_notice("Failed to parse honor-device-enumeration flag '%s', ignoring.", val);
3617 else
3618 m->honor_device_enumeration = b;
3619
3620 } else if ((val = startswith(l, "show-status-overridden="))) {
3621 ShowStatus s;
3622
3623 s = show_status_from_string(val);
3624 if (s < 0)
3625 log_notice("Failed to parse show-status-overridden flag '%s', ignoring.", val);
3626 else
3627 manager_override_show_status(m, s, "deserialize");
3628
3629 } else if ((val = startswith(l, "log-level-override="))) {
3630 int level;
3631
3632 level = log_level_from_string(val);
3633 if (level < 0)
3634 log_notice("Failed to parse log-level-override value '%s', ignoring.", val);
3635 else
3636 manager_override_log_level(m, level);
3637
3638 } else if ((val = startswith(l, "log-target-override="))) {
3639 LogTarget target;
3640
3641 target = log_target_from_string(val);
3642 if (target < 0)
3643 log_notice("Failed to parse log-target-override value '%s', ignoring.", val);
3644 else
3645 manager_override_log_target(m, target);
3646
3647 } else if ((val = startswith(l, "runtime-watchdog-overridden="))) {
3648 usec_t t;
3649
3650 if (deserialize_usec(val, &t) < 0)
3651 log_notice("Failed to parse runtime-watchdog-overridden value '%s', ignoring.", val);
3652 else
3653 manager_override_watchdog(m, WATCHDOG_RUNTIME, t);
3654
3655 } else if ((val = startswith(l, "reboot-watchdog-overridden="))) {
3656 usec_t t;
3657
3658 if (deserialize_usec(val, &t) < 0)
3659 log_notice("Failed to parse reboot-watchdog-overridden value '%s', ignoring.", val);
3660 else
3661 manager_override_watchdog(m, WATCHDOG_REBOOT, t);
3662
3663 } else if ((val = startswith(l, "kexec-watchdog-overridden="))) {
3664 usec_t t;
3665
3666 if (deserialize_usec(val, &t) < 0)
3667 log_notice("Failed to parse kexec-watchdog-overridden value '%s', ignoring.", val);
3668 else
3669 manager_override_watchdog(m, WATCHDOG_KEXEC, t);
3670
3671 } else if (startswith(l, "env=")) {
3672 r = deserialize_environment(l + 4, &m->client_environment);
3673 if (r < 0)
3674 log_notice_errno(r, "Failed to parse environment entry: \"%s\", ignoring: %m", l);
3675
3676 } else if ((val = startswith(l, "notify-fd="))) {
3677 int fd;
3678
3679 if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
3680 log_notice("Failed to parse notify fd, ignoring: \"%s\"", val);
3681 else {
3682 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
3683 safe_close(m->notify_fd);
3684 m->notify_fd = fdset_remove(fds, fd);
3685 }
3686
3687 } else if ((val = startswith(l, "notify-socket="))) {
3688 r = free_and_strdup(&m->notify_socket, val);
3689 if (r < 0)
3690 return r;
3691
3692 } else if ((val = startswith(l, "cgroups-agent-fd="))) {
3693 int fd;
3694
3695 if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
3696 log_notice("Failed to parse cgroups agent fd, ignoring.: %s", val);
3697 else {
3698 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
3699 safe_close(m->cgroups_agent_fd);
3700 m->cgroups_agent_fd = fdset_remove(fds, fd);
3701 }
3702
3703 } else if ((val = startswith(l, "user-lookup="))) {
3704 int fd0, fd1;
3705
3706 if (sscanf(val, "%i %i", &fd0, &fd1) != 2 || fd0 < 0 || fd1 < 0 || fd0 == fd1 || !fdset_contains(fds, fd0) || !fdset_contains(fds, fd1))
3707 log_notice("Failed to parse user lookup fd, ignoring: %s", val);
3708 else {
3709 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
3710 safe_close_pair(m->user_lookup_fds);
3711 m->user_lookup_fds[0] = fdset_remove(fds, fd0);
3712 m->user_lookup_fds[1] = fdset_remove(fds, fd1);
3713 }
3714
3715 } else if ((val = startswith(l, "dynamic-user=")))
3716 dynamic_user_deserialize_one(m, val, fds);
3717 else if ((val = startswith(l, "destroy-ipc-uid=")))
3718 manager_deserialize_uid_refs_one(m, val);
3719 else if ((val = startswith(l, "destroy-ipc-gid=")))
3720 manager_deserialize_gid_refs_one(m, val);
3721 else if ((val = startswith(l, "exec-runtime=")))
3722 (void) exec_runtime_deserialize_one(m, val, fds);
3723 else if ((val = startswith(l, "subscribed="))) {
3724
3725 if (strv_extend(&m->deserialized_subscribed, val) < 0)
3726 return -ENOMEM;
3727
3728 } else {
3729 ManagerTimestamp q;
3730
3731 for (q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
3732 val = startswith(l, manager_timestamp_to_string(q));
3733 if (!val)
3734 continue;
3735
3736 val = startswith(val, "-timestamp=");
3737 if (val)
3738 break;
3739 }
3740
3741 if (q < _MANAGER_TIMESTAMP_MAX) /* found it */
3742 (void) deserialize_dual_timestamp(val, m->timestamps + q);
3743 else if (!startswith(l, "kdbus-fd=")) /* ignore kdbus */
3744 log_notice("Unknown serialization item '%s', ignoring.", l);
3745 }
3746 }
3747
3748 return manager_deserialize_units(m, f, fds);
3749 }
3750
3751 int manager_reload(Manager *m) {
3752 _cleanup_(manager_reloading_stopp) Manager *reloading = NULL;
3753 _cleanup_fdset_free_ FDSet *fds = NULL;
3754 _cleanup_fclose_ FILE *f = NULL;
3755 int r;
3756
3757 assert(m);
3758
3759 r = manager_open_serialization(m, &f);
3760 if (r < 0)
3761 return log_error_errno(r, "Failed to create serialization file: %m");
3762
3763 fds = fdset_new();
3764 if (!fds)
3765 return log_oom();
3766
3767 /* We are officially in reload mode from here on. */
3768 reloading = manager_reloading_start(m);
3769
3770 r = manager_serialize(m, f, fds, false);
3771 if (r < 0)
3772 return r;
3773
3774 if (fseeko(f, 0, SEEK_SET) < 0)
3775 return log_error_errno(errno, "Failed to seek to beginning of serialization: %m");
3776
3777 /* 💀 This is the point of no return, from here on there is no way back. 💀 */
3778 reloading = NULL;
3779
3780 bus_manager_send_reloading(m, true);
3781
3782 /* Start by flushing out all jobs and units, all generated units, all runtime environments, all dynamic users
3783 * and everything else that is worth flushing out. We'll get it all back from the serialization — if we need
3784 * it.*/
3785
3786 manager_clear_jobs_and_units(m);
3787 lookup_paths_flush_generator(&m->lookup_paths);
3788 lookup_paths_free(&m->lookup_paths);
3789 exec_runtime_vacuum(m);
3790 dynamic_user_vacuum(m, false);
3791 m->uid_refs = hashmap_free(m->uid_refs);
3792 m->gid_refs = hashmap_free(m->gid_refs);
3793
3794 r = lookup_paths_init(&m->lookup_paths, m->unit_file_scope, 0, NULL);
3795 if (r < 0)
3796 log_warning_errno(r, "Failed to initialize path lookup table, ignoring: %m");
3797
3798 (void) manager_run_environment_generators(m);
3799 (void) manager_run_generators(m);
3800
3801 lookup_paths_log(&m->lookup_paths);
3802
3803 /* We flushed out generated files, for which we don't watch mtime, so we should flush the old map. */
3804 manager_free_unit_name_maps(m);
3805
3806 /* First, enumerate what we can from kernel and suchlike */
3807 manager_enumerate_perpetual(m);
3808 manager_enumerate(m);
3809
3810 /* Second, deserialize our stored data */
3811 r = manager_deserialize(m, f, fds);
3812 if (r < 0)
3813 log_warning_errno(r, "Deserialization failed, proceeding anyway: %m");
3814
3815 /* We don't need the serialization anymore */
3816 f = safe_fclose(f);
3817
3818 /* Re-register notify_fd as event source, and set up other sockets/communication channels we might need */
3819 (void) manager_setup_notify(m);
3820 (void) manager_setup_cgroups_agent(m);
3821 (void) manager_setup_user_lookup_fd(m);
3822
3823 /* Third, fire things up! */
3824 manager_coldplug(m);
3825
3826 /* Clean up runtime objects no longer referenced */
3827 manager_vacuum(m);
3828
3829 /* Clean up deserialized tracked clients */
3830 m->deserialized_subscribed = strv_free(m->deserialized_subscribed);
3831
3832 /* Consider the reload process complete now. */
3833 assert(m->n_reloading > 0);
3834 m->n_reloading--;
3835
3836 /* On manager reloading, device tag data should exists, thus, we should honor the results of device
3837 * enumeration. The flag should be always set correctly by the serialized data, but it may fail. So,
3838 * let's always set the flag here for safety. */
3839 m->honor_device_enumeration = true;
3840
3841 manager_ready(m);
3842
3843 m->send_reloading_done = true;
3844 return 0;
3845 }
3846
3847 void manager_reset_failed(Manager *m) {
3848 Unit *u;
3849
3850 assert(m);
3851
3852 HASHMAP_FOREACH(u, m->units)
3853 unit_reset_failed(u);
3854 }
3855
3856 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
3857 Unit *u;
3858
3859 assert(m);
3860 assert(name);
3861
3862 /* Returns true if the unit is inactive or going down */
3863 u = manager_get_unit(m, name);
3864 if (!u)
3865 return true;
3866
3867 return unit_inactive_or_pending(u);
3868 }
3869
3870 static void log_taint_string(Manager *m) {
3871 _cleanup_free_ char *taint = NULL;
3872
3873 assert(m);
3874
3875 if (MANAGER_IS_USER(m) || m->taint_logged)
3876 return;
3877
3878 m->taint_logged = true; /* only check for taint once */
3879
3880 taint = manager_taint_string(m);
3881 if (isempty(taint))
3882 return;
3883
3884 log_struct(LOG_NOTICE,
3885 LOG_MESSAGE("System is tainted: %s", taint),
3886 "TAINT=%s", taint,
3887 "MESSAGE_ID=" SD_MESSAGE_TAINTED_STR);
3888 }
3889
3890 static void manager_notify_finished(Manager *m) {
3891 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
3892 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
3893
3894 if (MANAGER_IS_TEST_RUN(m))
3895 return;
3896
3897 if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0) {
3898 char ts[FORMAT_TIMESPAN_MAX];
3899 char buf[FORMAT_TIMESPAN_MAX + STRLEN(" (firmware) + ") + FORMAT_TIMESPAN_MAX + STRLEN(" (loader) + ")]
3900 = {};
3901 char *p = buf;
3902 size_t size = sizeof buf;
3903
3904 /* Note that MANAGER_TIMESTAMP_KERNEL's monotonic value is always at 0, and
3905 * MANAGER_TIMESTAMP_FIRMWARE's and MANAGER_TIMESTAMP_LOADER's monotonic value should be considered
3906 * negative values. */
3907
3908 firmware_usec = m->timestamps[MANAGER_TIMESTAMP_FIRMWARE].monotonic - m->timestamps[MANAGER_TIMESTAMP_LOADER].monotonic;
3909 loader_usec = m->timestamps[MANAGER_TIMESTAMP_LOADER].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
3910 userspace_usec = m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic - m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
3911 total_usec = m->timestamps[MANAGER_TIMESTAMP_FIRMWARE].monotonic + m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic;
3912
3913 if (firmware_usec > 0)
3914 size = strpcpyf(&p, size, "%s (firmware) + ", format_timespan(ts, sizeof(ts), firmware_usec, USEC_PER_MSEC));
3915 if (loader_usec > 0)
3916 size = strpcpyf(&p, size, "%s (loader) + ", format_timespan(ts, sizeof(ts), loader_usec, USEC_PER_MSEC));
3917
3918 if (dual_timestamp_is_set(&m->timestamps[MANAGER_TIMESTAMP_INITRD])) {
3919
3920 /* The initrd case on bare-metal*/
3921 kernel_usec = m->timestamps[MANAGER_TIMESTAMP_INITRD].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
3922 initrd_usec = m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic - m->timestamps[MANAGER_TIMESTAMP_INITRD].monotonic;
3923
3924 log_struct(LOG_INFO,
3925 "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
3926 "KERNEL_USEC="USEC_FMT, kernel_usec,
3927 "INITRD_USEC="USEC_FMT, initrd_usec,
3928 "USERSPACE_USEC="USEC_FMT, userspace_usec,
3929 LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (initrd) + %s (userspace) = %s.",
3930 buf,
3931 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
3932 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
3933 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
3934 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)));
3935 } else {
3936 /* The initrd-less case on bare-metal*/
3937
3938 kernel_usec = m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
3939 initrd_usec = 0;
3940
3941 log_struct(LOG_INFO,
3942 "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
3943 "KERNEL_USEC="USEC_FMT, kernel_usec,
3944 "USERSPACE_USEC="USEC_FMT, userspace_usec,
3945 LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (userspace) = %s.",
3946 buf,
3947 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
3948 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
3949 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)));
3950 }
3951 } else {
3952 /* The container and --user case */
3953 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
3954 total_usec = userspace_usec = m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic - m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
3955
3956 log_struct(LOG_INFO,
3957 "MESSAGE_ID=" SD_MESSAGE_USER_STARTUP_FINISHED_STR,
3958 "USERSPACE_USEC="USEC_FMT, userspace_usec,
3959 LOG_MESSAGE("Startup finished in %s.",
3960 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)));
3961 }
3962
3963 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
3964
3965 sd_notifyf(false,
3966 m->ready_sent ? "STATUS=Startup finished in %s."
3967 : "READY=1\n"
3968 "STATUS=Startup finished in %s.",
3969 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
3970 m->ready_sent = true;
3971
3972 log_taint_string(m);
3973 }
3974
3975 static void manager_send_ready(Manager *m) {
3976 assert(m);
3977
3978 /* We send READY=1 on reaching basic.target only when running in --user mode. */
3979 if (!MANAGER_IS_USER(m) || m->ready_sent)
3980 return;
3981
3982 m->ready_sent = true;
3983
3984 sd_notifyf(false,
3985 "READY=1\n"
3986 "STATUS=Reached " SPECIAL_BASIC_TARGET ".");
3987 }
3988
3989 static void manager_check_basic_target(Manager *m) {
3990 Unit *u;
3991
3992 assert(m);
3993
3994 /* Small shortcut */
3995 if (m->ready_sent && m->taint_logged)
3996 return;
3997
3998 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3999 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
4000 return;
4001
4002 /* For user managers, send out READY=1 as soon as we reach basic.target */
4003 manager_send_ready(m);
4004
4005 /* Log the taint string as soon as we reach basic.target */
4006 log_taint_string(m);
4007 }
4008
4009 void manager_check_finished(Manager *m) {
4010 assert(m);
4011
4012 if (MANAGER_IS_RELOADING(m))
4013 return;
4014
4015 /* Verify that we have entered the event loop already, and not left it again. */
4016 if (!MANAGER_IS_RUNNING(m))
4017 return;
4018
4019 manager_check_basic_target(m);
4020
4021 if (hashmap_size(m->jobs) > 0) {
4022 if (m->jobs_in_progress_event_source)
4023 /* Ignore any failure, this is only for feedback */
4024 (void) sd_event_source_set_time(m->jobs_in_progress_event_source,
4025 manager_watch_jobs_next_time(m));
4026 return;
4027 }
4028
4029 /* The jobs hashmap tends to grow a lot during boot, and then it's not reused until shutdown. Let's
4030 kill the hashmap if it is relatively large. */
4031 if (hashmap_buckets(m->jobs) > hashmap_size(m->units) / 10)
4032 m->jobs = hashmap_free(m->jobs);
4033
4034 manager_flip_auto_status(m, false, "boot finished");
4035
4036 /* Notify Type=idle units that we are done now */
4037 manager_close_idle_pipe(m);
4038
4039 /* Turn off confirm spawn now */
4040 m->confirm_spawn = NULL;
4041
4042 /* No need to update ask password status when we're going non-interactive */
4043 manager_close_ask_password(m);
4044
4045 /* This is no longer the first boot */
4046 manager_set_first_boot(m, false);
4047
4048 if (MANAGER_IS_FINISHED(m))
4049 return;
4050
4051 dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_FINISH);
4052
4053 manager_notify_finished(m);
4054
4055 manager_invalidate_startup_units(m);
4056 }
4057
4058 static bool generator_path_any(const char* const* paths) {
4059 char **path;
4060 bool found = false;
4061
4062 /* Optimize by skipping the whole process by not creating output directories
4063 * if no generators are found. */
4064 STRV_FOREACH(path, (char**) paths)
4065 if (access(*path, F_OK) == 0)
4066 found = true;
4067 else if (errno != ENOENT)
4068 log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
4069
4070 return found;
4071 }
4072
4073 static int manager_run_environment_generators(Manager *m) {
4074 char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
4075 _cleanup_strv_free_ char **paths = NULL;
4076 void* args[] = {
4077 [STDOUT_GENERATE] = &tmp,
4078 [STDOUT_COLLECT] = &tmp,
4079 [STDOUT_CONSUME] = &m->transient_environment,
4080 };
4081 int r;
4082
4083 if (MANAGER_IS_TEST_RUN(m) && !(m->test_run_flags & MANAGER_TEST_RUN_ENV_GENERATORS))
4084 return 0;
4085
4086 paths = env_generator_binary_paths(MANAGER_IS_SYSTEM(m));
4087 if (!paths)
4088 return log_oom();
4089
4090 if (!generator_path_any((const char* const*) paths))
4091 return 0;
4092
4093 RUN_WITH_UMASK(0022)
4094 r = execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, gather_environment,
4095 args, NULL, m->transient_environment,
4096 EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS | EXEC_DIR_SET_SYSTEMD_EXEC_PID);
4097 return r;
4098 }
4099
4100 static int manager_run_generators(Manager *m) {
4101 _cleanup_strv_free_ char **paths = NULL;
4102 const char *argv[5];
4103 int r;
4104
4105 assert(m);
4106
4107 if (MANAGER_IS_TEST_RUN(m) && !(m->test_run_flags & MANAGER_TEST_RUN_GENERATORS))
4108 return 0;
4109
4110 paths = generator_binary_paths(m->unit_file_scope);
4111 if (!paths)
4112 return log_oom();
4113
4114 if (!generator_path_any((const char* const*) paths))
4115 return 0;
4116
4117 r = lookup_paths_mkdir_generator(&m->lookup_paths);
4118 if (r < 0) {
4119 log_error_errno(r, "Failed to create generator directories: %m");
4120 goto finish;
4121 }
4122
4123 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
4124 argv[1] = m->lookup_paths.generator;
4125 argv[2] = m->lookup_paths.generator_early;
4126 argv[3] = m->lookup_paths.generator_late;
4127 argv[4] = NULL;
4128
4129 RUN_WITH_UMASK(0022)
4130 (void) execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, NULL, NULL,
4131 (char**) argv, m->transient_environment,
4132 EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS | EXEC_DIR_SET_SYSTEMD_EXEC_PID);
4133
4134 r = 0;
4135
4136 finish:
4137 lookup_paths_trim_generator(&m->lookup_paths);
4138 return r;
4139 }
4140
4141 int manager_transient_environment_add(Manager *m, char **plus) {
4142 char **a;
4143
4144 assert(m);
4145
4146 if (strv_isempty(plus))
4147 return 0;
4148
4149 a = strv_env_merge(2, m->transient_environment, plus);
4150 if (!a)
4151 return log_oom();
4152
4153 sanitize_environment(a);
4154
4155 return strv_free_and_replace(m->transient_environment, a);
4156 }
4157
4158 int manager_client_environment_modify(
4159 Manager *m,
4160 char **minus,
4161 char **plus) {
4162
4163 char **a = NULL, **b = NULL, **l;
4164
4165 assert(m);
4166
4167 if (strv_isempty(minus) && strv_isempty(plus))
4168 return 0;
4169
4170 l = m->client_environment;
4171
4172 if (!strv_isempty(minus)) {
4173 a = strv_env_delete(l, 1, minus);
4174 if (!a)
4175 return -ENOMEM;
4176
4177 l = a;
4178 }
4179
4180 if (!strv_isempty(plus)) {
4181 b = strv_env_merge(2, l, plus);
4182 if (!b) {
4183 strv_free(a);
4184 return -ENOMEM;
4185 }
4186
4187 l = b;
4188 }
4189
4190 if (m->client_environment != l)
4191 strv_free(m->client_environment);
4192
4193 if (a != l)
4194 strv_free(a);
4195 if (b != l)
4196 strv_free(b);
4197
4198 m->client_environment = sanitize_environment(l);
4199 return 0;
4200 }
4201
4202 int manager_get_effective_environment(Manager *m, char ***ret) {
4203 char **l;
4204
4205 assert(m);
4206 assert(ret);
4207
4208 l = strv_env_merge(2, m->transient_environment, m->client_environment);
4209 if (!l)
4210 return -ENOMEM;
4211
4212 *ret = l;
4213 return 0;
4214 }
4215
4216 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
4217 assert(m);
4218
4219 for (unsigned i = 0; i < _RLIMIT_MAX; i++) {
4220 m->rlimit[i] = mfree(m->rlimit[i]);
4221
4222 if (!default_rlimit[i])
4223 continue;
4224
4225 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
4226 if (!m->rlimit[i])
4227 return log_oom();
4228 }
4229
4230 return 0;
4231 }
4232
4233 void manager_recheck_dbus(Manager *m) {
4234 assert(m);
4235
4236 /* Connects to the bus if the dbus service and socket are running. If we are running in user mode this is all
4237 * it does. In system mode we'll also connect to the system bus (which will most likely just reuse the
4238 * connection of the API bus). That's because the system bus after all runs as service of the system instance,
4239 * while in the user instance we can assume it's already there. */
4240
4241 if (MANAGER_IS_RELOADING(m))
4242 return; /* don't check while we are reloading… */
4243
4244 if (manager_dbus_is_running(m, false)) {
4245 (void) bus_init_api(m);
4246
4247 if (MANAGER_IS_SYSTEM(m))
4248 (void) bus_init_system(m);
4249 } else {
4250 (void) bus_done_api(m);
4251
4252 if (MANAGER_IS_SYSTEM(m))
4253 (void) bus_done_system(m);
4254 }
4255 }
4256
4257 static bool manager_journal_is_running(Manager *m) {
4258 Unit *u;
4259
4260 assert(m);
4261
4262 if (MANAGER_IS_TEST_RUN(m))
4263 return false;
4264
4265 /* If we are the user manager we can safely assume that the journal is up */
4266 if (!MANAGER_IS_SYSTEM(m))
4267 return true;
4268
4269 /* Check that the socket is not only up, but in RUNNING state */
4270 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
4271 if (!u)
4272 return false;
4273 if (SOCKET(u)->state != SOCKET_RUNNING)
4274 return false;
4275
4276 /* Similar, check if the daemon itself is fully up, too */
4277 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
4278 if (!u)
4279 return false;
4280 if (!IN_SET(SERVICE(u)->state, SERVICE_RELOAD, SERVICE_RUNNING))
4281 return false;
4282
4283 return true;
4284 }
4285
4286 void disable_printk_ratelimit(void) {
4287 /* Disable kernel's printk ratelimit.
4288 *
4289 * Logging to /dev/kmsg is most useful during early boot and shutdown, where normal logging
4290 * mechanisms are not available. The semantics of this sysctl are such that any kernel command-line
4291 * setting takes precedence. */
4292 int r;
4293
4294 r = sysctl_write("kernel/printk_devkmsg", "on");
4295 if (r < 0)
4296 log_debug_errno(r, "Failed to set sysctl kernel.printk_devkmsg=on: %m");
4297 }
4298
4299 void manager_recheck_journal(Manager *m) {
4300
4301 assert(m);
4302
4303 /* Don't bother with this unless we are in the special situation of being PID 1 */
4304 if (getpid_cached() != 1)
4305 return;
4306
4307 /* Don't check this while we are reloading, things might still change */
4308 if (MANAGER_IS_RELOADING(m))
4309 return;
4310
4311 /* The journal is fully and entirely up? If so, let's permit logging to it, if that's configured. If the
4312 * journal is down, don't ever log to it, otherwise we might end up deadlocking ourselves as we might trigger
4313 * an activation ourselves we can't fulfill. */
4314 log_set_prohibit_ipc(!manager_journal_is_running(m));
4315 log_open();
4316 }
4317
4318 static ShowStatus manager_get_show_status(Manager *m) {
4319 assert(m);
4320
4321 if (MANAGER_IS_USER(m))
4322 return _SHOW_STATUS_INVALID;
4323
4324 if (m->show_status_overridden != _SHOW_STATUS_INVALID)
4325 return m->show_status_overridden;
4326
4327 return m->show_status;
4328 }
4329
4330 bool manager_get_show_status_on(Manager *m) {
4331 assert(m);
4332
4333 return show_status_on(manager_get_show_status(m));
4334 }
4335
4336 static void set_show_status_marker(bool b) {
4337 if (b)
4338 (void) touch("/run/systemd/show-status");
4339 else
4340 (void) unlink("/run/systemd/show-status");
4341 }
4342
4343 void manager_set_show_status(Manager *m, ShowStatus mode, const char *reason) {
4344 assert(m);
4345 assert(reason);
4346 assert(mode >= 0 && mode < _SHOW_STATUS_MAX);
4347
4348 if (MANAGER_IS_USER(m))
4349 return;
4350
4351 if (mode == m->show_status)
4352 return;
4353
4354 if (m->show_status_overridden == _SHOW_STATUS_INVALID) {
4355 bool enabled;
4356
4357 enabled = show_status_on(mode);
4358 log_debug("%s (%s) showing of status (%s).",
4359 enabled ? "Enabling" : "Disabling",
4360 strna(show_status_to_string(mode)),
4361 reason);
4362
4363 set_show_status_marker(enabled);
4364 }
4365
4366 m->show_status = mode;
4367 }
4368
4369 void manager_override_show_status(Manager *m, ShowStatus mode, const char *reason) {
4370 assert(m);
4371 assert(mode < _SHOW_STATUS_MAX);
4372
4373 if (MANAGER_IS_USER(m))
4374 return;
4375
4376 if (mode == m->show_status_overridden)
4377 return;
4378
4379 m->show_status_overridden = mode;
4380
4381 if (mode == _SHOW_STATUS_INVALID)
4382 mode = m->show_status;
4383
4384 log_debug("%s (%s) showing of status (%s).",
4385 m->show_status_overridden != _SHOW_STATUS_INVALID ? "Overriding" : "Restoring",
4386 strna(show_status_to_string(mode)),
4387 reason);
4388
4389 set_show_status_marker(show_status_on(mode));
4390 }
4391
4392 const char *manager_get_confirm_spawn(Manager *m) {
4393 static int last_errno = 0;
4394 struct stat st;
4395 int r;
4396
4397 assert(m);
4398
4399 /* Here's the deal: we want to test the validity of the console but don't want
4400 * PID1 to go through the whole console process which might block. But we also
4401 * want to warn the user only once if something is wrong with the console so we
4402 * cannot do the sanity checks after spawning our children. So here we simply do
4403 * really basic tests to hopefully trap common errors.
4404 *
4405 * If the console suddenly disappear at the time our children will really it
4406 * then they will simply fail to acquire it and a positive answer will be
4407 * assumed. New children will fall back to /dev/console though.
4408 *
4409 * Note: TTYs are devices that can come and go any time, and frequently aren't
4410 * available yet during early boot (consider a USB rs232 dongle...). If for any
4411 * reason the configured console is not ready, we fall back to the default
4412 * console. */
4413
4414 if (!m->confirm_spawn || path_equal(m->confirm_spawn, "/dev/console"))
4415 return m->confirm_spawn;
4416
4417 if (stat(m->confirm_spawn, &st) < 0) {
4418 r = -errno;
4419 goto fail;
4420 }
4421
4422 if (!S_ISCHR(st.st_mode)) {
4423 r = -ENOTTY;
4424 goto fail;
4425 }
4426
4427 last_errno = 0;
4428 return m->confirm_spawn;
4429
4430 fail:
4431 if (last_errno != r)
4432 last_errno = log_warning_errno(r, "Failed to open %s, using default console: %m", m->confirm_spawn);
4433
4434 return "/dev/console";
4435 }
4436
4437 void manager_set_first_boot(Manager *m, bool b) {
4438 assert(m);
4439
4440 if (!MANAGER_IS_SYSTEM(m))
4441 return;
4442
4443 if (m->first_boot != (int) b) {
4444 if (b)
4445 (void) touch("/run/systemd/first-boot");
4446 else
4447 (void) unlink("/run/systemd/first-boot");
4448 }
4449
4450 m->first_boot = b;
4451 }
4452
4453 void manager_disable_confirm_spawn(void) {
4454 (void) touch("/run/systemd/confirm_spawn_disabled");
4455 }
4456
4457 bool manager_is_confirm_spawn_disabled(Manager *m) {
4458 if (!m->confirm_spawn)
4459 return true;
4460
4461 return access("/run/systemd/confirm_spawn_disabled", F_OK) >= 0;
4462 }
4463
4464 static bool manager_should_show_status(Manager *m, StatusType type) {
4465 assert(m);
4466
4467 if (!MANAGER_IS_SYSTEM(m))
4468 return false;
4469
4470 if (m->no_console_output)
4471 return false;
4472
4473 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
4474 return false;
4475
4476 /* If we cannot find out the status properly, just proceed. */
4477 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
4478 return false;
4479
4480 if (type == STATUS_TYPE_NOTICE && m->show_status != SHOW_STATUS_NO)
4481 return true;
4482
4483 return manager_get_show_status_on(m);
4484 }
4485
4486 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
4487 va_list ap;
4488
4489 /* If m is NULL, assume we're after shutdown and let the messages through. */
4490
4491 if (m && !manager_should_show_status(m, type))
4492 return;
4493
4494 /* XXX We should totally drop the check for ephemeral here
4495 * and thus effectively make 'Type=idle' pointless. */
4496 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
4497 return;
4498
4499 va_start(ap, format);
4500 status_vprintf(status, SHOW_STATUS_ELLIPSIZE|(type == STATUS_TYPE_EPHEMERAL ? SHOW_STATUS_EPHEMERAL : 0), format, ap);
4501 va_end(ap);
4502 }
4503
4504 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
4505 char p[strlen(path)+1];
4506
4507 assert(m);
4508 assert(path);
4509
4510 strcpy(p, path);
4511 path_simplify(p, false);
4512
4513 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
4514 }
4515
4516 int manager_update_failed_units(Manager *m, Unit *u, bool failed) {
4517 unsigned size;
4518 int r;
4519
4520 assert(m);
4521 assert(u->manager == m);
4522
4523 size = set_size(m->failed_units);
4524
4525 if (failed) {
4526 r = set_ensure_put(&m->failed_units, NULL, u);
4527 if (r < 0)
4528 return log_oom();
4529 } else
4530 (void) set_remove(m->failed_units, u);
4531
4532 if (set_size(m->failed_units) != size)
4533 bus_manager_send_change_signal(m);
4534
4535 return 0;
4536 }
4537
4538 ManagerState manager_state(Manager *m) {
4539 Unit *u;
4540
4541 assert(m);
4542
4543 /* Is the special shutdown target active or queued? If so, we are in shutdown state */
4544 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
4545 if (u && unit_active_or_pending(u))
4546 return MANAGER_STOPPING;
4547
4548 /* Did we ever finish booting? If not then we are still starting up */
4549 if (!MANAGER_IS_FINISHED(m)) {
4550
4551 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
4552 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
4553 return MANAGER_INITIALIZING;
4554
4555 return MANAGER_STARTING;
4556 }
4557
4558 if (MANAGER_IS_SYSTEM(m)) {
4559 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
4560 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
4561 if (u && unit_active_or_pending(u))
4562 return MANAGER_MAINTENANCE;
4563
4564 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
4565 if (u && unit_active_or_pending(u))
4566 return MANAGER_MAINTENANCE;
4567 }
4568
4569 /* Are there any failed units? If so, we are in degraded mode */
4570 if (set_size(m->failed_units) > 0)
4571 return MANAGER_DEGRADED;
4572
4573 return MANAGER_RUNNING;
4574 }
4575
4576 static void manager_unref_uid_internal(
4577 Hashmap *uid_refs,
4578 uid_t uid,
4579 bool destroy_now,
4580 int (*_clean_ipc)(uid_t uid)) {
4581
4582 uint32_t c, n;
4583
4584 assert(uid_is_valid(uid));
4585 assert(_clean_ipc);
4586
4587 /* A generic implementation, covering both manager_unref_uid() and manager_unref_gid(), under the assumption
4588 * that uid_t and gid_t are actually defined the same way, with the same validity rules.
4589 *
4590 * We store a hashmap where the UID/GID is they key and the value is a 32bit reference counter, whose highest
4591 * bit is used as flag for marking UIDs/GIDs whose IPC objects to remove when the last reference to the UID/GID
4592 * is dropped. The flag is set to on, once at least one reference from a unit where RemoveIPC= is set is added
4593 * on a UID/GID. It is reset when the UID's/GID's reference counter drops to 0 again. */
4594
4595 assert_cc(sizeof(uid_t) == sizeof(gid_t));
4596 assert_cc(UID_INVALID == (uid_t) GID_INVALID);
4597
4598 if (uid == 0) /* We don't keep track of root, and will never destroy it */
4599 return;
4600
4601 c = PTR_TO_UINT32(hashmap_get(uid_refs, UID_TO_PTR(uid)));
4602
4603 n = c & ~DESTROY_IPC_FLAG;
4604 assert(n > 0);
4605 n--;
4606
4607 if (destroy_now && n == 0) {
4608 hashmap_remove(uid_refs, UID_TO_PTR(uid));
4609
4610 if (c & DESTROY_IPC_FLAG) {
4611 log_debug("%s " UID_FMT " is no longer referenced, cleaning up its IPC.",
4612 _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
4613 uid);
4614 (void) _clean_ipc(uid);
4615 }
4616 } else {
4617 c = n | (c & DESTROY_IPC_FLAG);
4618 assert_se(hashmap_update(uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c)) >= 0);
4619 }
4620 }
4621
4622 void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now) {
4623 manager_unref_uid_internal(m->uid_refs, uid, destroy_now, clean_ipc_by_uid);
4624 }
4625
4626 void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now) {
4627 manager_unref_uid_internal(m->gid_refs, (uid_t) gid, destroy_now, clean_ipc_by_gid);
4628 }
4629
4630 static int manager_ref_uid_internal(
4631 Hashmap **uid_refs,
4632 uid_t uid,
4633 bool clean_ipc) {
4634
4635 uint32_t c, n;
4636 int r;
4637
4638 assert(uid_refs);
4639 assert(uid_is_valid(uid));
4640
4641 /* A generic implementation, covering both manager_ref_uid() and manager_ref_gid(), under the assumption
4642 * that uid_t and gid_t are actually defined the same way, with the same validity rules. */
4643
4644 assert_cc(sizeof(uid_t) == sizeof(gid_t));
4645 assert_cc(UID_INVALID == (uid_t) GID_INVALID);
4646
4647 if (uid == 0) /* We don't keep track of root, and will never destroy it */
4648 return 0;
4649
4650 r = hashmap_ensure_allocated(uid_refs, &trivial_hash_ops);
4651 if (r < 0)
4652 return r;
4653
4654 c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
4655
4656 n = c & ~DESTROY_IPC_FLAG;
4657 n++;
4658
4659 if (n & DESTROY_IPC_FLAG) /* check for overflow */
4660 return -EOVERFLOW;
4661
4662 c = n | (c & DESTROY_IPC_FLAG) | (clean_ipc ? DESTROY_IPC_FLAG : 0);
4663
4664 return hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
4665 }
4666
4667 int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc) {
4668 return manager_ref_uid_internal(&m->uid_refs, uid, clean_ipc);
4669 }
4670
4671 int manager_ref_gid(Manager *m, gid_t gid, bool clean_ipc) {
4672 return manager_ref_uid_internal(&m->gid_refs, (uid_t) gid, clean_ipc);
4673 }
4674
4675 static void manager_vacuum_uid_refs_internal(
4676 Hashmap *uid_refs,
4677 int (*_clean_ipc)(uid_t uid)) {
4678
4679 void *p, *k;
4680
4681 assert(_clean_ipc);
4682
4683 HASHMAP_FOREACH_KEY(p, k, uid_refs) {
4684 uint32_t c, n;
4685 uid_t uid;
4686
4687 uid = PTR_TO_UID(k);
4688 c = PTR_TO_UINT32(p);
4689
4690 n = c & ~DESTROY_IPC_FLAG;
4691 if (n > 0)
4692 continue;
4693
4694 if (c & DESTROY_IPC_FLAG) {
4695 log_debug("Found unreferenced %s " UID_FMT " after reload/reexec. Cleaning up.",
4696 _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
4697 uid);
4698 (void) _clean_ipc(uid);
4699 }
4700
4701 assert_se(hashmap_remove(uid_refs, k) == p);
4702 }
4703 }
4704
4705 static void manager_vacuum_uid_refs(Manager *m) {
4706 manager_vacuum_uid_refs_internal(m->uid_refs, clean_ipc_by_uid);
4707 }
4708
4709 static void manager_vacuum_gid_refs(Manager *m) {
4710 manager_vacuum_uid_refs_internal(m->gid_refs, clean_ipc_by_gid);
4711 }
4712
4713 static void manager_vacuum(Manager *m) {
4714 assert(m);
4715
4716 /* Release any dynamic users no longer referenced */
4717 dynamic_user_vacuum(m, true);
4718
4719 /* Release any references to UIDs/GIDs no longer referenced, and destroy any IPC owned by them */
4720 manager_vacuum_uid_refs(m);
4721 manager_vacuum_gid_refs(m);
4722
4723 /* Release any runtimes no longer referenced */
4724 exec_runtime_vacuum(m);
4725 }
4726
4727 int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
4728 struct buffer {
4729 uid_t uid;
4730 gid_t gid;
4731 char unit_name[UNIT_NAME_MAX+1];
4732 } _packed_ buffer;
4733
4734 Manager *m = userdata;
4735 ssize_t l;
4736 size_t n;
4737 Unit *u;
4738
4739 assert_se(source);
4740 assert_se(m);
4741
4742 /* Invoked whenever a child process succeeded resolving its user/group to use and sent us the resulting UID/GID
4743 * in a datagram. We parse the datagram here and pass it off to the unit, so that it can add a reference to the
4744 * UID/GID so that it can destroy the UID/GID's IPC objects when the reference counter drops to 0. */
4745
4746 l = recv(fd, &buffer, sizeof(buffer), MSG_DONTWAIT);
4747 if (l < 0) {
4748 if (IN_SET(errno, EINTR, EAGAIN))
4749 return 0;
4750
4751 return log_error_errno(errno, "Failed to read from user lookup fd: %m");
4752 }
4753
4754 if ((size_t) l <= offsetof(struct buffer, unit_name)) {
4755 log_warning("Received too short user lookup message, ignoring.");
4756 return 0;
4757 }
4758
4759 if ((size_t) l > offsetof(struct buffer, unit_name) + UNIT_NAME_MAX) {
4760 log_warning("Received too long user lookup message, ignoring.");
4761 return 0;
4762 }
4763
4764 if (!uid_is_valid(buffer.uid) && !gid_is_valid(buffer.gid)) {
4765 log_warning("Got user lookup message with invalid UID/GID pair, ignoring.");
4766 return 0;
4767 }
4768
4769 n = (size_t) l - offsetof(struct buffer, unit_name);
4770 if (memchr(buffer.unit_name, 0, n)) {
4771 log_warning("Received lookup message with embedded NUL character, ignoring.");
4772 return 0;
4773 }
4774
4775 buffer.unit_name[n] = 0;
4776 u = manager_get_unit(m, buffer.unit_name);
4777 if (!u) {
4778 log_debug("Got user lookup message but unit doesn't exist, ignoring.");
4779 return 0;
4780 }
4781
4782 log_unit_debug(u, "User lookup succeeded: uid=" UID_FMT " gid=" GID_FMT, buffer.uid, buffer.gid);
4783
4784 unit_notify_user_lookup(u, buffer.uid, buffer.gid);
4785 return 0;
4786 }
4787
4788 char *manager_taint_string(Manager *m) {
4789 _cleanup_free_ char *destination = NULL, *overflowuid = NULL, *overflowgid = NULL;
4790 char *buf, *e;
4791 int r;
4792
4793 /* Returns a "taint string", e.g. "local-hwclock:var-run-bad".
4794 * Only things that are detected at runtime should be tagged
4795 * here. For stuff that is set during compilation, emit a warning
4796 * in the configuration phase. */
4797
4798 assert(m);
4799
4800 buf = new(char, sizeof("split-usr:"
4801 "cgroups-missing:"
4802 "local-hwclock:"
4803 "var-run-bad:"
4804 "overflowuid-not-65534:"
4805 "overflowgid-not-65534:"));
4806 if (!buf)
4807 return NULL;
4808
4809 e = buf;
4810 buf[0] = 0;
4811
4812 if (m->taint_usr)
4813 e = stpcpy(e, "split-usr:");
4814
4815 if (access("/proc/cgroups", F_OK) < 0)
4816 e = stpcpy(e, "cgroups-missing:");
4817
4818 if (clock_is_localtime(NULL) > 0)
4819 e = stpcpy(e, "local-hwclock:");
4820
4821 r = readlink_malloc("/var/run", &destination);
4822 if (r < 0 || !PATH_IN_SET(destination, "../run", "/run"))
4823 e = stpcpy(e, "var-run-bad:");
4824
4825 r = read_one_line_file("/proc/sys/kernel/overflowuid", &overflowuid);
4826 if (r >= 0 && !streq(overflowuid, "65534"))
4827 e = stpcpy(e, "overflowuid-not-65534:");
4828
4829 r = read_one_line_file("/proc/sys/kernel/overflowgid", &overflowgid);
4830 if (r >= 0 && !streq(overflowgid, "65534"))
4831 e = stpcpy(e, "overflowgid-not-65534:");
4832
4833 /* remove the last ':' */
4834 if (e != buf)
4835 e[-1] = 0;
4836
4837 return buf;
4838 }
4839
4840 void manager_ref_console(Manager *m) {
4841 assert(m);
4842
4843 m->n_on_console++;
4844 }
4845
4846 void manager_unref_console(Manager *m) {
4847
4848 assert(m->n_on_console > 0);
4849 m->n_on_console--;
4850
4851 if (m->n_on_console == 0)
4852 m->no_console_output = false; /* unset no_console_output flag, since the console is definitely free now */
4853 }
4854
4855 void manager_override_log_level(Manager *m, int level) {
4856 _cleanup_free_ char *s = NULL;
4857 assert(m);
4858
4859 if (!m->log_level_overridden) {
4860 m->original_log_level = log_get_max_level();
4861 m->log_level_overridden = true;
4862 }
4863
4864 (void) log_level_to_string_alloc(level, &s);
4865 log_info("Setting log level to %s.", strna(s));
4866
4867 log_set_max_level(level);
4868 }
4869
4870 void manager_restore_original_log_level(Manager *m) {
4871 _cleanup_free_ char *s = NULL;
4872 assert(m);
4873
4874 if (!m->log_level_overridden)
4875 return;
4876
4877 (void) log_level_to_string_alloc(m->original_log_level, &s);
4878 log_info("Restoring log level to original (%s).", strna(s));
4879
4880 log_set_max_level(m->original_log_level);
4881 m->log_level_overridden = false;
4882 }
4883
4884 void manager_override_log_target(Manager *m, LogTarget target) {
4885 assert(m);
4886
4887 if (!m->log_target_overridden) {
4888 m->original_log_target = log_get_target();
4889 m->log_target_overridden = true;
4890 }
4891
4892 log_info("Setting log target to %s.", log_target_to_string(target));
4893 log_set_target(target);
4894 }
4895
4896 void manager_restore_original_log_target(Manager *m) {
4897 assert(m);
4898
4899 if (!m->log_target_overridden)
4900 return;
4901
4902 log_info("Restoring log target to original %s.", log_target_to_string(m->original_log_target));
4903
4904 log_set_target(m->original_log_target);
4905 m->log_target_overridden = false;
4906 }
4907
4908 ManagerTimestamp manager_timestamp_initrd_mangle(ManagerTimestamp s) {
4909 if (in_initrd() &&
4910 s >= MANAGER_TIMESTAMP_SECURITY_START &&
4911 s <= MANAGER_TIMESTAMP_UNITS_LOAD_FINISH)
4912 return s - MANAGER_TIMESTAMP_SECURITY_START + MANAGER_TIMESTAMP_INITRD_SECURITY_START;
4913 return s;
4914 }
4915
4916 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
4917 [MANAGER_INITIALIZING] = "initializing",
4918 [MANAGER_STARTING] = "starting",
4919 [MANAGER_RUNNING] = "running",
4920 [MANAGER_DEGRADED] = "degraded",
4921 [MANAGER_MAINTENANCE] = "maintenance",
4922 [MANAGER_STOPPING] = "stopping",
4923 };
4924
4925 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
4926
4927 static const char *const manager_timestamp_table[_MANAGER_TIMESTAMP_MAX] = {
4928 [MANAGER_TIMESTAMP_FIRMWARE] = "firmware",
4929 [MANAGER_TIMESTAMP_LOADER] = "loader",
4930 [MANAGER_TIMESTAMP_KERNEL] = "kernel",
4931 [MANAGER_TIMESTAMP_INITRD] = "initrd",
4932 [MANAGER_TIMESTAMP_USERSPACE] = "userspace",
4933 [MANAGER_TIMESTAMP_FINISH] = "finish",
4934 [MANAGER_TIMESTAMP_SECURITY_START] = "security-start",
4935 [MANAGER_TIMESTAMP_SECURITY_FINISH] = "security-finish",
4936 [MANAGER_TIMESTAMP_GENERATORS_START] = "generators-start",
4937 [MANAGER_TIMESTAMP_GENERATORS_FINISH] = "generators-finish",
4938 [MANAGER_TIMESTAMP_UNITS_LOAD_START] = "units-load-start",
4939 [MANAGER_TIMESTAMP_UNITS_LOAD_FINISH] = "units-load-finish",
4940 [MANAGER_TIMESTAMP_INITRD_SECURITY_START] = "initrd-security-start",
4941 [MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH] = "initrd-security-finish",
4942 [MANAGER_TIMESTAMP_INITRD_GENERATORS_START] = "initrd-generators-start",
4943 [MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH] = "initrd-generators-finish",
4944 [MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START] = "initrd-units-load-start",
4945 [MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH] = "initrd-units-load-finish",
4946 };
4947
4948 DEFINE_STRING_TABLE_LOOKUP(manager_timestamp, ManagerTimestamp);
4949
4950 static const char* const oom_policy_table[_OOM_POLICY_MAX] = {
4951 [OOM_CONTINUE] = "continue",
4952 [OOM_STOP] = "stop",
4953 [OOM_KILL] = "kill",
4954 };
4955
4956 DEFINE_STRING_TABLE_LOOKUP(oom_policy, OOMPolicy);
Unnamed repository; edit this file 'description' to name the repository.