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