]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/manager.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
log: introduce a macro to format message id
[thirdparty/systemd.git] / src / core / manager.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <sys/epoll.h>
26 #include <signal.h>
27 #include <sys/signalfd.h>
28 #include <sys/wait.h>
29 #include <unistd.h>
30 #include <sys/poll.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
33 #include <linux/kd.h>
34 #include <termios.h>
35 #include <fcntl.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <dirent.h>
39
40 #ifdef HAVE_AUDIT
41 #include <libaudit.h>
42 #endif
43
44 #include "systemd/sd-daemon.h"
45 #include "systemd/sd-id128.h"
46 #include "systemd/sd-messages.h"
47
48 #include "manager.h"
49 #include "transaction.h"
50 #include "hashmap.h"
51 #include "macro.h"
52 #include "strv.h"
53 #include "log.h"
54 #include "util.h"
55 #include "mkdir.h"
56 #include "ratelimit.h"
57 #include "cgroup.h"
58 #include "mount-setup.h"
59 #include "unit-name.h"
60 #include "dbus-unit.h"
61 #include "dbus-job.h"
62 #include "missing.h"
63 #include "path-lookup.h"
64 #include "special.h"
65 #include "bus-errors.h"
66 #include "exit-status.h"
67 #include "virt.h"
68 #include "watchdog.h"
69 #include "cgroup-util.h"
70 #include "path-util.h"
71 #include "audit-fd.h"
72
73 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
74 #define GC_QUEUE_ENTRIES_MAX 16
75
76 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
78
79 /* Where clients shall send notification messages to */
80 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
81
82 static int manager_setup_notify(Manager *m) {
83 union {
84 struct sockaddr sa;
85 struct sockaddr_un un;
86 } sa;
87 struct epoll_event ev;
88 int one = 1;
89
90 assert(m);
91
92 m->notify_watch.type = WATCH_NOTIFY;
93 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
94 if (m->notify_watch.fd < 0) {
95 log_error("Failed to allocate notification socket: %m");
96 return -errno;
97 }
98
99 zero(sa);
100 sa.sa.sa_family = AF_UNIX;
101
102 if (getpid() != 1 || detect_container(NULL) > 0)
103 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
104 else
105 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
106
107 sa.un.sun_path[0] = 0;
108
109 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
110 log_error("bind() failed: %m");
111 return -errno;
112 }
113
114 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
115 log_error("SO_PASSCRED failed: %m");
116 return -errno;
117 }
118
119 zero(ev);
120 ev.events = EPOLLIN;
121 ev.data.ptr = &m->notify_watch;
122
123 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
124 return -errno;
125
126 sa.un.sun_path[0] = '@';
127 m->notify_socket = strdup(sa.un.sun_path);
128 if (!m->notify_socket)
129 return -ENOMEM;
130
131 log_debug("Using notification socket %s", m->notify_socket);
132
133 return 0;
134 }
135
136 static int enable_special_signals(Manager *m) {
137 int fd;
138
139 assert(m);
140
141 /* Enable that we get SIGINT on control-alt-del. In containers
142 * this will fail with EPERM (older) or EINVAL (newer), so
143 * ignore that. */
144 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
145 log_warning("Failed to enable ctrl-alt-del handling: %m");
146
147 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
148 if (fd < 0) {
149 /* Support systems without virtual console */
150 if (fd != -ENOENT)
151 log_warning("Failed to open /dev/tty0: %m");
152 } else {
153 /* Enable that we get SIGWINCH on kbrequest */
154 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
155 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
156
157 close_nointr_nofail(fd);
158 }
159
160 return 0;
161 }
162
163 static int manager_setup_signals(Manager *m) {
164 sigset_t mask;
165 struct epoll_event ev;
166 struct sigaction sa;
167
168 assert(m);
169
170 /* We are not interested in SIGSTOP and friends. */
171 zero(sa);
172 sa.sa_handler = SIG_DFL;
173 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
174 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
175
176 assert_se(sigemptyset(&mask) == 0);
177
178 sigset_add_many(&mask,
179 SIGCHLD, /* Child died */
180 SIGTERM, /* Reexecute daemon */
181 SIGHUP, /* Reload configuration */
182 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
183 SIGUSR2, /* systemd: dump status */
184 SIGINT, /* Kernel sends us this on control-alt-del */
185 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
186 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
187 SIGRTMIN+0, /* systemd: start default.target */
188 SIGRTMIN+1, /* systemd: isolate rescue.target */
189 SIGRTMIN+2, /* systemd: isolate emergency.target */
190 SIGRTMIN+3, /* systemd: start halt.target */
191 SIGRTMIN+4, /* systemd: start poweroff.target */
192 SIGRTMIN+5, /* systemd: start reboot.target */
193 SIGRTMIN+6, /* systemd: start kexec.target */
194 SIGRTMIN+13, /* systemd: Immediate halt */
195 SIGRTMIN+14, /* systemd: Immediate poweroff */
196 SIGRTMIN+15, /* systemd: Immediate reboot */
197 SIGRTMIN+16, /* systemd: Immediate kexec */
198 SIGRTMIN+20, /* systemd: enable status messages */
199 SIGRTMIN+21, /* systemd: disable status messages */
200 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
201 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
202 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
203 SIGRTMIN+27, /* systemd: set log target to console */
204 SIGRTMIN+28, /* systemd: set log target to kmsg */
205 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
206 -1);
207 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
208
209 m->signal_watch.type = WATCH_SIGNAL;
210 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
211 return -errno;
212
213 zero(ev);
214 ev.events = EPOLLIN;
215 ev.data.ptr = &m->signal_watch;
216
217 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
218 return -errno;
219
220 if (m->running_as == SYSTEMD_SYSTEM)
221 return enable_special_signals(m);
222
223 return 0;
224 }
225
226 static void manager_strip_environment(Manager *m) {
227 assert(m);
228
229 /* Remove variables from the inherited set that are part of
230 * the container interface:
231 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
232 strv_remove_prefix(m->environment, "container=");
233 strv_remove_prefix(m->environment, "container_");
234
235 /* Remove variables from the inherited set that are part of
236 * the initrd interface:
237 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
238 strv_remove_prefix(m->environment, "RD_");
239 }
240
241 int manager_new(SystemdRunningAs running_as, Manager **_m) {
242 Manager *m;
243 int r = -ENOMEM;
244
245 assert(_m);
246 assert(running_as >= 0);
247 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
248
249 m = new0(Manager, 1);
250 if (!m)
251 return -ENOMEM;
252
253 dual_timestamp_get(&m->userspace_timestamp);
254
255 m->running_as = running_as;
256 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
257 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
258 m->pin_cgroupfs_fd = -1;
259 m->idle_pipe[0] = m->idle_pipe[1] = -1;
260
261 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
262 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
263
264 m->environment = strv_copy(environ);
265 if (!m->environment)
266 goto fail;
267
268 manager_strip_environment(m);
269
270 if (running_as == SYSTEMD_SYSTEM) {
271 m->default_controllers = strv_new("cpu", NULL);
272 if (!m->default_controllers)
273 goto fail;
274 }
275
276 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
277 goto fail;
278
279 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
280 goto fail;
281
282 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
283 goto fail;
284
285 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
286 goto fail;
287
288 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
289 goto fail;
290
291 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
292 goto fail;
293
294 if ((r = manager_setup_signals(m)) < 0)
295 goto fail;
296
297 if ((r = manager_setup_cgroup(m)) < 0)
298 goto fail;
299
300 if ((r = manager_setup_notify(m)) < 0)
301 goto fail;
302
303 /* Try to connect to the busses, if possible. */
304 if ((r = bus_init(m, running_as != SYSTEMD_SYSTEM)) < 0)
305 goto fail;
306
307 m->taint_usr = dir_is_empty("/usr") > 0;
308
309 *_m = m;
310 return 0;
311
312 fail:
313 manager_free(m);
314 return r;
315 }
316
317 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
318 Unit *u;
319 unsigned n = 0;
320
321 assert(m);
322
323 while ((u = m->cleanup_queue)) {
324 assert(u->in_cleanup_queue);
325
326 unit_free(u);
327 n++;
328 }
329
330 return n;
331 }
332
333 enum {
334 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
335 GC_OFFSET_UNSURE, /* No clue */
336 GC_OFFSET_GOOD, /* We still need this unit */
337 GC_OFFSET_BAD, /* We don't need this unit anymore */
338 _GC_OFFSET_MAX
339 };
340
341 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
342 Iterator i;
343 Unit *other;
344 bool is_bad;
345
346 assert(u);
347
348 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
349 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
350 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
351 return;
352
353 if (u->in_cleanup_queue)
354 goto bad;
355
356 if (unit_check_gc(u))
357 goto good;
358
359 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
360
361 is_bad = true;
362
363 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
364 unit_gc_sweep(other, gc_marker);
365
366 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
367 goto good;
368
369 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
370 is_bad = false;
371 }
372
373 if (is_bad)
374 goto bad;
375
376 /* We were unable to find anything out about this entry, so
377 * let's investigate it later */
378 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
379 unit_add_to_gc_queue(u);
380 return;
381
382 bad:
383 /* We definitely know that this one is not useful anymore, so
384 * let's mark it for deletion */
385 u->gc_marker = gc_marker + GC_OFFSET_BAD;
386 unit_add_to_cleanup_queue(u);
387 return;
388
389 good:
390 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
391 }
392
393 static unsigned manager_dispatch_gc_queue(Manager *m) {
394 Unit *u;
395 unsigned n = 0;
396 unsigned gc_marker;
397
398 assert(m);
399
400 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
401 (m->gc_queue_timestamp <= 0 ||
402 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
403 return 0;
404
405 log_debug("Running GC...");
406
407 m->gc_marker += _GC_OFFSET_MAX;
408 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
409 m->gc_marker = 1;
410
411 gc_marker = m->gc_marker;
412
413 while ((u = m->gc_queue)) {
414 assert(u->in_gc_queue);
415
416 unit_gc_sweep(u, gc_marker);
417
418 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
419 u->in_gc_queue = false;
420
421 n++;
422
423 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
424 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
425 log_debug("Collecting %s", u->id);
426 u->gc_marker = gc_marker + GC_OFFSET_BAD;
427 unit_add_to_cleanup_queue(u);
428 }
429 }
430
431 m->n_in_gc_queue = 0;
432 m->gc_queue_timestamp = 0;
433
434 return n;
435 }
436
437 static void manager_clear_jobs_and_units(Manager *m) {
438 Unit *u;
439
440 assert(m);
441
442 while ((u = hashmap_first(m->units)))
443 unit_free(u);
444
445 manager_dispatch_cleanup_queue(m);
446
447 assert(!m->load_queue);
448 assert(!m->run_queue);
449 assert(!m->dbus_unit_queue);
450 assert(!m->dbus_job_queue);
451 assert(!m->cleanup_queue);
452 assert(!m->gc_queue);
453
454 assert(hashmap_isempty(m->jobs));
455 assert(hashmap_isempty(m->units));
456 }
457
458 void manager_free(Manager *m) {
459 UnitType c;
460 int i;
461
462 assert(m);
463
464 manager_clear_jobs_and_units(m);
465
466 for (c = 0; c < _UNIT_TYPE_MAX; c++)
467 if (unit_vtable[c]->shutdown)
468 unit_vtable[c]->shutdown(m);
469
470 /* If we reexecute ourselves, we keep the root cgroup
471 * around */
472 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
473
474 manager_undo_generators(m);
475
476 bus_done(m);
477
478 hashmap_free(m->units);
479 hashmap_free(m->jobs);
480 hashmap_free(m->watch_pids);
481 hashmap_free(m->watch_bus);
482
483 if (m->epoll_fd >= 0)
484 close_nointr_nofail(m->epoll_fd);
485 if (m->signal_watch.fd >= 0)
486 close_nointr_nofail(m->signal_watch.fd);
487 if (m->notify_watch.fd >= 0)
488 close_nointr_nofail(m->notify_watch.fd);
489
490 free(m->notify_socket);
491
492 lookup_paths_free(&m->lookup_paths);
493 strv_free(m->environment);
494
495 strv_free(m->default_controllers);
496
497 hashmap_free(m->cgroup_bondings);
498 set_free_free(m->unit_path_cache);
499
500 close_pipe(m->idle_pipe);
501
502 free(m->switch_root);
503 free(m->switch_root_init);
504
505 for (i = 0; i < RLIMIT_NLIMITS; i++)
506 free(m->rlimit[i]);
507
508 free(m);
509 }
510
511 int manager_enumerate(Manager *m) {
512 int r = 0, q;
513 UnitType c;
514
515 assert(m);
516
517 /* Let's ask every type to load all units from disk/kernel
518 * that it might know */
519 for (c = 0; c < _UNIT_TYPE_MAX; c++)
520 if (unit_vtable[c]->enumerate)
521 if ((q = unit_vtable[c]->enumerate(m)) < 0)
522 r = q;
523
524 manager_dispatch_load_queue(m);
525 return r;
526 }
527
528 int manager_coldplug(Manager *m) {
529 int r = 0, q;
530 Iterator i;
531 Unit *u;
532 char *k;
533
534 assert(m);
535
536 /* Then, let's set up their initial state. */
537 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
538
539 /* ignore aliases */
540 if (u->id != k)
541 continue;
542
543 if ((q = unit_coldplug(u)) < 0)
544 r = q;
545 }
546
547 return r;
548 }
549
550 static void manager_build_unit_path_cache(Manager *m) {
551 char **i;
552 DIR *d = NULL;
553 int r;
554
555 assert(m);
556
557 set_free_free(m->unit_path_cache);
558
559 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
560 log_error("Failed to allocate unit path cache.");
561 return;
562 }
563
564 /* This simply builds a list of files we know exist, so that
565 * we don't always have to go to disk */
566
567 STRV_FOREACH(i, m->lookup_paths.unit_path) {
568 struct dirent *de;
569
570 if (!(d = opendir(*i))) {
571 log_error("Failed to open directory: %m");
572 continue;
573 }
574
575 while ((de = readdir(d))) {
576 char *p;
577
578 if (ignore_file(de->d_name))
579 continue;
580
581 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
582 if (!p) {
583 r = -ENOMEM;
584 goto fail;
585 }
586
587 if ((r = set_put(m->unit_path_cache, p)) < 0) {
588 free(p);
589 goto fail;
590 }
591 }
592
593 closedir(d);
594 d = NULL;
595 }
596
597 return;
598
599 fail:
600 log_error("Failed to build unit path cache: %s", strerror(-r));
601
602 set_free_free(m->unit_path_cache);
603 m->unit_path_cache = NULL;
604
605 if (d)
606 closedir(d);
607 }
608
609 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
610 int r, q;
611
612 assert(m);
613
614 manager_run_generators(m);
615
616 r = lookup_paths_init(
617 &m->lookup_paths, m->running_as, true,
618 m->generator_unit_path,
619 m->generator_unit_path_early,
620 m->generator_unit_path_late);
621 if (r < 0)
622 return r;
623
624 manager_build_unit_path_cache(m);
625
626 /* If we will deserialize make sure that during enumeration
627 * this is already known, so we increase the counter here
628 * already */
629 if (serialization)
630 m->n_reloading ++;
631
632 /* First, enumerate what we can from all config files */
633 r = manager_enumerate(m);
634
635 /* Second, deserialize if there is something to deserialize */
636 if (serialization) {
637 q = manager_deserialize(m, serialization, fds);
638 if (q < 0)
639 r = q;
640 }
641
642 /* Third, fire things up! */
643 q = manager_coldplug(m);
644 if (q < 0)
645 r = q;
646
647 if (serialization) {
648 assert(m->n_reloading > 0);
649 m->n_reloading --;
650 }
651
652 return r;
653 }
654
655 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
656 int r;
657 Transaction *tr;
658
659 assert(m);
660 assert(type < _JOB_TYPE_MAX);
661 assert(unit);
662 assert(mode < _JOB_MODE_MAX);
663
664 if (mode == JOB_ISOLATE && type != JOB_START) {
665 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
666 return -EINVAL;
667 }
668
669 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
670 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
671 return -EPERM;
672 }
673
674 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
675
676 job_type_collapse(&type, unit);
677
678 tr = transaction_new();
679 if (!tr)
680 return -ENOMEM;
681
682 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
683 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
684 mode == JOB_IGNORE_DEPENDENCIES, e);
685 if (r < 0)
686 goto tr_abort;
687
688 if (mode == JOB_ISOLATE) {
689 r = transaction_add_isolate_jobs(tr, m);
690 if (r < 0)
691 goto tr_abort;
692 }
693
694 r = transaction_activate(tr, m, mode, e);
695 if (r < 0)
696 goto tr_abort;
697
698 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
699
700 if (_ret)
701 *_ret = tr->anchor_job;
702
703 transaction_free(tr);
704 return 0;
705
706 tr_abort:
707 transaction_abort(tr);
708 transaction_free(tr);
709 return r;
710 }
711
712 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
713 Unit *unit;
714 int r;
715
716 assert(m);
717 assert(type < _JOB_TYPE_MAX);
718 assert(name);
719 assert(mode < _JOB_MODE_MAX);
720
721 r = manager_load_unit(m, name, NULL, NULL, &unit);
722 if (r < 0)
723 return r;
724
725 return manager_add_job(m, type, unit, mode, override, e, _ret);
726 }
727
728 Job *manager_get_job(Manager *m, uint32_t id) {
729 assert(m);
730
731 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
732 }
733
734 Unit *manager_get_unit(Manager *m, const char *name) {
735 assert(m);
736 assert(name);
737
738 return hashmap_get(m->units, name);
739 }
740
741 unsigned manager_dispatch_load_queue(Manager *m) {
742 Unit *u;
743 unsigned n = 0;
744
745 assert(m);
746
747 /* Make sure we are not run recursively */
748 if (m->dispatching_load_queue)
749 return 0;
750
751 m->dispatching_load_queue = true;
752
753 /* Dispatches the load queue. Takes a unit from the queue and
754 * tries to load its data until the queue is empty */
755
756 while ((u = m->load_queue)) {
757 assert(u->in_load_queue);
758
759 unit_load(u);
760 n++;
761 }
762
763 m->dispatching_load_queue = false;
764 return n;
765 }
766
767 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
768 Unit *ret;
769 UnitType t;
770 int r;
771
772 assert(m);
773 assert(name || path);
774
775 /* This will prepare the unit for loading, but not actually
776 * load anything from disk. */
777
778 if (path && !is_path(path)) {
779 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
780 return -EINVAL;
781 }
782
783 if (!name)
784 name = path_get_file_name(path);
785
786 t = unit_name_to_type(name);
787
788 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
789 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
790 return -EINVAL;
791 }
792
793 ret = manager_get_unit(m, name);
794 if (ret) {
795 *_ret = ret;
796 return 1;
797 }
798
799 ret = unit_new(m, unit_vtable[t]->object_size);
800 if (!ret)
801 return -ENOMEM;
802
803 if (path) {
804 ret->fragment_path = strdup(path);
805 if (!ret->fragment_path) {
806 unit_free(ret);
807 return -ENOMEM;
808 }
809 }
810
811 if ((r = unit_add_name(ret, name)) < 0) {
812 unit_free(ret);
813 return r;
814 }
815
816 unit_add_to_load_queue(ret);
817 unit_add_to_dbus_queue(ret);
818 unit_add_to_gc_queue(ret);
819
820 if (_ret)
821 *_ret = ret;
822
823 return 0;
824 }
825
826 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
827 int r;
828
829 assert(m);
830
831 /* This will load the service information files, but not actually
832 * start any services or anything. */
833
834 r = manager_load_unit_prepare(m, name, path, e, _ret);
835 if (r != 0)
836 return r;
837
838 manager_dispatch_load_queue(m);
839
840 if (_ret)
841 *_ret = unit_follow_merge(*_ret);
842
843 return 0;
844 }
845
846 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
847 Iterator i;
848 Job *j;
849
850 assert(s);
851 assert(f);
852
853 HASHMAP_FOREACH(j, s->jobs, i)
854 job_dump(j, f, prefix);
855 }
856
857 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
858 Iterator i;
859 Unit *u;
860 const char *t;
861
862 assert(s);
863 assert(f);
864
865 HASHMAP_FOREACH_KEY(u, t, s->units, i)
866 if (u->id == t)
867 unit_dump(u, f, prefix);
868 }
869
870 void manager_clear_jobs(Manager *m) {
871 Job *j;
872
873 assert(m);
874
875 while ((j = hashmap_first(m->jobs)))
876 /* No need to recurse. We're cancelling all jobs. */
877 job_finish_and_invalidate(j, JOB_CANCELED, false);
878 }
879
880 unsigned manager_dispatch_run_queue(Manager *m) {
881 Job *j;
882 unsigned n = 0;
883
884 if (m->dispatching_run_queue)
885 return 0;
886
887 m->dispatching_run_queue = true;
888
889 while ((j = m->run_queue)) {
890 assert(j->installed);
891 assert(j->in_run_queue);
892
893 job_run_and_invalidate(j);
894 n++;
895 }
896
897 m->dispatching_run_queue = false;
898 return n;
899 }
900
901 unsigned manager_dispatch_dbus_queue(Manager *m) {
902 Job *j;
903 Unit *u;
904 unsigned n = 0;
905
906 assert(m);
907
908 if (m->dispatching_dbus_queue)
909 return 0;
910
911 m->dispatching_dbus_queue = true;
912
913 while ((u = m->dbus_unit_queue)) {
914 assert(u->in_dbus_queue);
915
916 bus_unit_send_change_signal(u);
917 n++;
918 }
919
920 while ((j = m->dbus_job_queue)) {
921 assert(j->in_dbus_queue);
922
923 bus_job_send_change_signal(j);
924 n++;
925 }
926
927 m->dispatching_dbus_queue = false;
928 return n;
929 }
930
931 static int manager_process_notify_fd(Manager *m) {
932 ssize_t n;
933
934 assert(m);
935
936 for (;;) {
937 char buf[4096];
938 struct msghdr msghdr;
939 struct iovec iovec;
940 struct ucred *ucred;
941 union {
942 struct cmsghdr cmsghdr;
943 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
944 } control;
945 Unit *u;
946 char **tags;
947
948 zero(iovec);
949 iovec.iov_base = buf;
950 iovec.iov_len = sizeof(buf)-1;
951
952 zero(control);
953 zero(msghdr);
954 msghdr.msg_iov = &iovec;
955 msghdr.msg_iovlen = 1;
956 msghdr.msg_control = &control;
957 msghdr.msg_controllen = sizeof(control);
958
959 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
960 if (n >= 0)
961 return -EIO;
962
963 if (errno == EAGAIN || errno == EINTR)
964 break;
965
966 return -errno;
967 }
968
969 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
970 control.cmsghdr.cmsg_level != SOL_SOCKET ||
971 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
972 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
973 log_warning("Received notify message without credentials. Ignoring.");
974 continue;
975 }
976
977 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
978
979 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
980 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
981 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
982 continue;
983 }
984
985 assert((size_t) n < sizeof(buf));
986 buf[n] = 0;
987 if (!(tags = strv_split(buf, "\n\r")))
988 return -ENOMEM;
989
990 log_debug("Got notification message for unit %s", u->id);
991
992 if (UNIT_VTABLE(u)->notify_message)
993 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
994
995 strv_free(tags);
996 }
997
998 return 0;
999 }
1000
1001 static int manager_dispatch_sigchld(Manager *m) {
1002 assert(m);
1003
1004 for (;;) {
1005 siginfo_t si;
1006 Unit *u;
1007 int r;
1008
1009 zero(si);
1010
1011 /* First we call waitd() for a PID and do not reap the
1012 * zombie. That way we can still access /proc/$PID for
1013 * it while it is a zombie. */
1014 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1015
1016 if (errno == ECHILD)
1017 break;
1018
1019 if (errno == EINTR)
1020 continue;
1021
1022 return -errno;
1023 }
1024
1025 if (si.si_pid <= 0)
1026 break;
1027
1028 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1029 char *name = NULL;
1030
1031 get_process_comm(si.si_pid, &name);
1032 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1033 free(name);
1034 }
1035
1036 /* Let's flush any message the dying child might still
1037 * have queued for us. This ensures that the process
1038 * still exists in /proc so that we can figure out
1039 * which cgroup and hence unit it belongs to. */
1040 if ((r = manager_process_notify_fd(m)) < 0)
1041 return r;
1042
1043 /* And now figure out the unit this belongs to */
1044 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1045 u = cgroup_unit_by_pid(m, si.si_pid);
1046
1047 /* And now, we actually reap the zombie. */
1048 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1049 if (errno == EINTR)
1050 continue;
1051
1052 return -errno;
1053 }
1054
1055 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1056 continue;
1057
1058 log_debug("Child %lu died (code=%s, status=%i/%s)",
1059 (long unsigned) si.si_pid,
1060 sigchld_code_to_string(si.si_code),
1061 si.si_status,
1062 strna(si.si_code == CLD_EXITED
1063 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1064 : signal_to_string(si.si_status)));
1065
1066 if (!u)
1067 continue;
1068
1069 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1070
1071 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1072 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1073 }
1074
1075 return 0;
1076 }
1077
1078 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1079 int r;
1080 DBusError error;
1081
1082 dbus_error_init(&error);
1083
1084 log_debug("Activating special unit %s", name);
1085
1086 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1087 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1088
1089 dbus_error_free(&error);
1090
1091 return r;
1092 }
1093
1094 static int manager_process_signal_fd(Manager *m) {
1095 ssize_t n;
1096 struct signalfd_siginfo sfsi;
1097 bool sigchld = false;
1098
1099 assert(m);
1100
1101 for (;;) {
1102 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1103
1104 if (n >= 0)
1105 return -EIO;
1106
1107 if (errno == EINTR || errno == EAGAIN)
1108 break;
1109
1110 return -errno;
1111 }
1112
1113 if (sfsi.ssi_pid > 0) {
1114 char *p = NULL;
1115
1116 get_process_comm(sfsi.ssi_pid, &p);
1117
1118 log_debug("Received SIG%s from PID %lu (%s).",
1119 signal_to_string(sfsi.ssi_signo),
1120 (unsigned long) sfsi.ssi_pid, strna(p));
1121 free(p);
1122 } else
1123 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1124
1125 switch (sfsi.ssi_signo) {
1126
1127 case SIGCHLD:
1128 sigchld = true;
1129 break;
1130
1131 case SIGTERM:
1132 if (m->running_as == SYSTEMD_SYSTEM) {
1133 /* This is for compatibility with the
1134 * original sysvinit */
1135 m->exit_code = MANAGER_REEXECUTE;
1136 break;
1137 }
1138
1139 /* Fall through */
1140
1141 case SIGINT:
1142 if (m->running_as == SYSTEMD_SYSTEM) {
1143 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1144 break;
1145 }
1146
1147 /* Run the exit target if there is one, if not, just exit. */
1148 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1149 m->exit_code = MANAGER_EXIT;
1150 return 0;
1151 }
1152
1153 break;
1154
1155 case SIGWINCH:
1156 if (m->running_as == SYSTEMD_SYSTEM)
1157 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1158
1159 /* This is a nop on non-init */
1160 break;
1161
1162 case SIGPWR:
1163 if (m->running_as == SYSTEMD_SYSTEM)
1164 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1165
1166 /* This is a nop on non-init */
1167 break;
1168
1169 case SIGUSR1: {
1170 Unit *u;
1171
1172 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1173
1174 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1175 log_info("Trying to reconnect to bus...");
1176 bus_init(m, true);
1177 }
1178
1179 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1180 log_info("Loading D-Bus service...");
1181 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1182 }
1183
1184 break;
1185 }
1186
1187 case SIGUSR2: {
1188 FILE *f;
1189 char *dump = NULL;
1190 size_t size;
1191
1192 if (!(f = open_memstream(&dump, &size))) {
1193 log_warning("Failed to allocate memory stream.");
1194 break;
1195 }
1196
1197 manager_dump_units(m, f, "\t");
1198 manager_dump_jobs(m, f, "\t");
1199
1200 if (ferror(f)) {
1201 fclose(f);
1202 free(dump);
1203 log_warning("Failed to write status stream");
1204 break;
1205 }
1206
1207 fclose(f);
1208 log_dump(LOG_INFO, dump);
1209 free(dump);
1210
1211 break;
1212 }
1213
1214 case SIGHUP:
1215 m->exit_code = MANAGER_RELOAD;
1216 break;
1217
1218 default: {
1219
1220 /* Starting SIGRTMIN+0 */
1221 static const char * const target_table[] = {
1222 [0] = SPECIAL_DEFAULT_TARGET,
1223 [1] = SPECIAL_RESCUE_TARGET,
1224 [2] = SPECIAL_EMERGENCY_TARGET,
1225 [3] = SPECIAL_HALT_TARGET,
1226 [4] = SPECIAL_POWEROFF_TARGET,
1227 [5] = SPECIAL_REBOOT_TARGET,
1228 [6] = SPECIAL_KEXEC_TARGET
1229 };
1230
1231 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1232 static const ManagerExitCode code_table[] = {
1233 [0] = MANAGER_HALT,
1234 [1] = MANAGER_POWEROFF,
1235 [2] = MANAGER_REBOOT,
1236 [3] = MANAGER_KEXEC
1237 };
1238
1239 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1240 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1241 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1242 manager_start_target(m, target_table[idx],
1243 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1244 break;
1245 }
1246
1247 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1248 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1249 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1250 break;
1251 }
1252
1253 switch (sfsi.ssi_signo - SIGRTMIN) {
1254
1255 case 20:
1256 log_debug("Enabling showing of status.");
1257 manager_set_show_status(m, true);
1258 break;
1259
1260 case 21:
1261 log_debug("Disabling showing of status.");
1262 manager_set_show_status(m, false);
1263 break;
1264
1265 case 22:
1266 log_set_max_level(LOG_DEBUG);
1267 log_notice("Setting log level to debug.");
1268 break;
1269
1270 case 23:
1271 log_set_max_level(LOG_INFO);
1272 log_notice("Setting log level to info.");
1273 break;
1274
1275 case 26:
1276 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1277 log_notice("Setting log target to journal-or-kmsg.");
1278 break;
1279
1280 case 27:
1281 log_set_target(LOG_TARGET_CONSOLE);
1282 log_notice("Setting log target to console.");
1283 break;
1284
1285 case 28:
1286 log_set_target(LOG_TARGET_KMSG);
1287 log_notice("Setting log target to kmsg.");
1288 break;
1289
1290 case 29:
1291 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1292 log_notice("Setting log target to syslog-or-kmsg.");
1293 break;
1294
1295 default:
1296 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1297 }
1298 }
1299 }
1300 }
1301
1302 if (sigchld)
1303 return manager_dispatch_sigchld(m);
1304
1305 return 0;
1306 }
1307
1308 static int process_event(Manager *m, struct epoll_event *ev) {
1309 int r;
1310 Watch *w;
1311
1312 assert(m);
1313 assert(ev);
1314
1315 assert_se(w = ev->data.ptr);
1316
1317 if (w->type == WATCH_INVALID)
1318 return 0;
1319
1320 switch (w->type) {
1321
1322 case WATCH_SIGNAL:
1323
1324 /* An incoming signal? */
1325 if (ev->events != EPOLLIN)
1326 return -EINVAL;
1327
1328 if ((r = manager_process_signal_fd(m)) < 0)
1329 return r;
1330
1331 break;
1332
1333 case WATCH_NOTIFY:
1334
1335 /* An incoming daemon notification event? */
1336 if (ev->events != EPOLLIN)
1337 return -EINVAL;
1338
1339 if ((r = manager_process_notify_fd(m)) < 0)
1340 return r;
1341
1342 break;
1343
1344 case WATCH_FD:
1345
1346 /* Some fd event, to be dispatched to the units */
1347 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1348 break;
1349
1350 case WATCH_UNIT_TIMER:
1351 case WATCH_JOB_TIMER: {
1352 uint64_t v;
1353 ssize_t k;
1354
1355 /* Some timer event, to be dispatched to the units */
1356 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1357
1358 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1359 break;
1360
1361 return k < 0 ? -errno : -EIO;
1362 }
1363
1364 if (w->type == WATCH_UNIT_TIMER)
1365 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1366 else
1367 job_timer_event(w->data.job, v, w);
1368 break;
1369 }
1370
1371 case WATCH_MOUNT:
1372 /* Some mount table change, intended for the mount subsystem */
1373 mount_fd_event(m, ev->events);
1374 break;
1375
1376 case WATCH_SWAP:
1377 /* Some swap table change, intended for the swap subsystem */
1378 swap_fd_event(m, ev->events);
1379 break;
1380
1381 case WATCH_UDEV:
1382 /* Some notification from udev, intended for the device subsystem */
1383 device_fd_event(m, ev->events);
1384 break;
1385
1386 case WATCH_DBUS_WATCH:
1387 bus_watch_event(m, w, ev->events);
1388 break;
1389
1390 case WATCH_DBUS_TIMEOUT:
1391 bus_timeout_event(m, w, ev->events);
1392 break;
1393
1394 default:
1395 log_error("event type=%i", w->type);
1396 assert_not_reached("Unknown epoll event type.");
1397 }
1398
1399 return 0;
1400 }
1401
1402 int manager_loop(Manager *m) {
1403 int r;
1404
1405 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1406
1407 assert(m);
1408 m->exit_code = MANAGER_RUNNING;
1409
1410 /* Release the path cache */
1411 set_free_free(m->unit_path_cache);
1412 m->unit_path_cache = NULL;
1413
1414 manager_check_finished(m);
1415
1416 /* There might still be some zombies hanging around from
1417 * before we were exec()'ed. Leat's reap them */
1418 r = manager_dispatch_sigchld(m);
1419 if (r < 0)
1420 return r;
1421
1422 while (m->exit_code == MANAGER_RUNNING) {
1423 struct epoll_event event;
1424 int n;
1425 int wait_msec = -1;
1426
1427 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1428 watchdog_ping();
1429
1430 if (!ratelimit_test(&rl)) {
1431 /* Yay, something is going seriously wrong, pause a little */
1432 log_warning("Looping too fast. Throttling execution a little.");
1433 sleep(1);
1434 continue;
1435 }
1436
1437 if (manager_dispatch_load_queue(m) > 0)
1438 continue;
1439
1440 if (manager_dispatch_run_queue(m) > 0)
1441 continue;
1442
1443 if (bus_dispatch(m) > 0)
1444 continue;
1445
1446 if (manager_dispatch_cleanup_queue(m) > 0)
1447 continue;
1448
1449 if (manager_dispatch_gc_queue(m) > 0)
1450 continue;
1451
1452 if (manager_dispatch_dbus_queue(m) > 0)
1453 continue;
1454
1455 if (swap_dispatch_reload(m) > 0)
1456 continue;
1457
1458 /* Sleep for half the watchdog time */
1459 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1460 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1461 if (wait_msec <= 0)
1462 wait_msec = 1;
1463 } else
1464 wait_msec = -1;
1465
1466 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1467 if (n < 0) {
1468
1469 if (errno == EINTR)
1470 continue;
1471
1472 return -errno;
1473 } else if (n == 0)
1474 continue;
1475
1476 assert(n == 1);
1477
1478 r = process_event(m, &event);
1479 if (r < 0)
1480 return r;
1481 }
1482
1483 return m->exit_code;
1484 }
1485
1486 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1487 char *n;
1488 Unit *u;
1489 int r;
1490
1491 assert(m);
1492 assert(s);
1493 assert(_u);
1494
1495 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1496 return -EINVAL;
1497
1498 n = bus_path_unescape(s+31);
1499 if (!n)
1500 return -ENOMEM;
1501
1502 r = manager_load_unit(m, n, NULL, e, &u);
1503 free(n);
1504
1505 if (r < 0)
1506 return r;
1507
1508 *_u = u;
1509
1510 return 0;
1511 }
1512
1513 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1514 Job *j;
1515 unsigned id;
1516 int r;
1517
1518 assert(m);
1519 assert(s);
1520 assert(_j);
1521
1522 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1523 return -EINVAL;
1524
1525 if ((r = safe_atou(s + 30, &id)) < 0)
1526 return r;
1527
1528 if (!(j = manager_get_job(m, id)))
1529 return -ENOENT;
1530
1531 *_j = j;
1532
1533 return 0;
1534 }
1535
1536 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1537
1538 #ifdef HAVE_AUDIT
1539 char *p;
1540 int audit_fd;
1541
1542 audit_fd = get_audit_fd();
1543 if (audit_fd < 0)
1544 return;
1545
1546 /* Don't generate audit events if the service was already
1547 * started and we're just deserializing */
1548 if (m->n_reloading > 0)
1549 return;
1550
1551 if (m->running_as != SYSTEMD_SYSTEM)
1552 return;
1553
1554 if (u->type != UNIT_SERVICE)
1555 return;
1556
1557 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1558 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1559 return;
1560 }
1561
1562 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1563 if (errno == EPERM) {
1564 /* We aren't allowed to send audit messages?
1565 * Then let's not retry again. */
1566 close_audit_fd();
1567 } else
1568 log_warning("Failed to send audit message: %m");
1569 }
1570
1571 free(p);
1572 #endif
1573
1574 }
1575
1576 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1577 int fd = -1;
1578 union sockaddr_union sa;
1579 int n = 0;
1580 char *message = NULL;
1581
1582 /* Don't generate plymouth events if the service was already
1583 * started and we're just deserializing */
1584 if (m->n_reloading > 0)
1585 return;
1586
1587 if (m->running_as != SYSTEMD_SYSTEM)
1588 return;
1589
1590 if (u->type != UNIT_SERVICE &&
1591 u->type != UNIT_MOUNT &&
1592 u->type != UNIT_SWAP)
1593 return;
1594
1595 /* We set SOCK_NONBLOCK here so that we rather drop the
1596 * message then wait for plymouth */
1597 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1598 log_error("socket() failed: %m");
1599 return;
1600 }
1601
1602 zero(sa);
1603 sa.sa.sa_family = AF_UNIX;
1604 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1605 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1606
1607 if (errno != EPIPE &&
1608 errno != EAGAIN &&
1609 errno != ENOENT &&
1610 errno != ECONNREFUSED &&
1611 errno != ECONNRESET &&
1612 errno != ECONNABORTED)
1613 log_error("connect() failed: %m");
1614
1615 goto finish;
1616 }
1617
1618 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1619 log_oom();
1620 goto finish;
1621 }
1622
1623 errno = 0;
1624 if (write(fd, message, n + 1) != n + 1) {
1625
1626 if (errno != EPIPE &&
1627 errno != EAGAIN &&
1628 errno != ENOENT &&
1629 errno != ECONNREFUSED &&
1630 errno != ECONNRESET &&
1631 errno != ECONNABORTED)
1632 log_error("Failed to write Plymouth message: %m");
1633
1634 goto finish;
1635 }
1636
1637 finish:
1638 if (fd >= 0)
1639 close_nointr_nofail(fd);
1640
1641 free(message);
1642 }
1643
1644 void manager_dispatch_bus_name_owner_changed(
1645 Manager *m,
1646 const char *name,
1647 const char* old_owner,
1648 const char *new_owner) {
1649
1650 Unit *u;
1651
1652 assert(m);
1653 assert(name);
1654
1655 if (!(u = hashmap_get(m->watch_bus, name)))
1656 return;
1657
1658 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1659 }
1660
1661 void manager_dispatch_bus_query_pid_done(
1662 Manager *m,
1663 const char *name,
1664 pid_t pid) {
1665
1666 Unit *u;
1667
1668 assert(m);
1669 assert(name);
1670 assert(pid >= 1);
1671
1672 if (!(u = hashmap_get(m->watch_bus, name)))
1673 return;
1674
1675 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1676 }
1677
1678 int manager_open_serialization(Manager *m, FILE **_f) {
1679 char *path = NULL;
1680 mode_t saved_umask;
1681 int fd;
1682 FILE *f;
1683
1684 assert(_f);
1685
1686 if (m->running_as == SYSTEMD_SYSTEM)
1687 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1688 else
1689 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1690
1691 if (!path)
1692 return -ENOMEM;
1693
1694 saved_umask = umask(0077);
1695 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1696 umask(saved_umask);
1697
1698 if (fd < 0) {
1699 free(path);
1700 return -errno;
1701 }
1702
1703 unlink(path);
1704
1705 log_debug("Serializing state to %s", path);
1706 free(path);
1707
1708 if (!(f = fdopen(fd, "w+")))
1709 return -errno;
1710
1711 *_f = f;
1712
1713 return 0;
1714 }
1715
1716 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1717 Iterator i;
1718 Unit *u;
1719 const char *t;
1720 int r;
1721
1722 assert(m);
1723 assert(f);
1724 assert(fds);
1725
1726 m->n_reloading ++;
1727
1728 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1729 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1730 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1731 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1732
1733 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1734 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1735 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1736 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1737
1738 if (!in_initrd()) {
1739 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1740 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1741 }
1742
1743 fputc('\n', f);
1744
1745 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1746 if (u->id != t)
1747 continue;
1748
1749 if (!unit_can_serialize(u))
1750 continue;
1751
1752 /* Start marker */
1753 fputs(u->id, f);
1754 fputc('\n', f);
1755
1756 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1757 m->n_reloading --;
1758 return r;
1759 }
1760 }
1761
1762 assert(m->n_reloading > 0);
1763 m->n_reloading --;
1764
1765 if (ferror(f))
1766 return -EIO;
1767
1768 r = bus_fdset_add_all(m, fds);
1769 if (r < 0)
1770 return r;
1771
1772 return 0;
1773 }
1774
1775 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1776 int r = 0;
1777
1778 assert(m);
1779 assert(f);
1780
1781 log_debug("Deserializing state...");
1782
1783 m->n_reloading ++;
1784
1785 for (;;) {
1786 char line[LINE_MAX], *l;
1787
1788 if (!fgets(line, sizeof(line), f)) {
1789 if (feof(f))
1790 r = 0;
1791 else
1792 r = -errno;
1793
1794 goto finish;
1795 }
1796
1797 char_array_0(line);
1798 l = strstrip(line);
1799
1800 if (l[0] == 0)
1801 break;
1802
1803 if (startswith(l, "current-job-id=")) {
1804 uint32_t id;
1805
1806 if (safe_atou32(l+15, &id) < 0)
1807 log_debug("Failed to parse current job id value %s", l+15);
1808 else
1809 m->current_job_id = MAX(m->current_job_id, id);
1810 } else if (startswith(l, "n-installed-jobs=")) {
1811 uint32_t n;
1812
1813 if (safe_atou32(l+17, &n) < 0)
1814 log_debug("Failed to parse installed jobs counter %s", l+17);
1815 else
1816 m->n_installed_jobs += n;
1817 } else if (startswith(l, "n-failed-jobs=")) {
1818 uint32_t n;
1819
1820 if (safe_atou32(l+14, &n) < 0)
1821 log_debug("Failed to parse failed jobs counter %s", l+14);
1822 else
1823 m->n_failed_jobs += n;
1824 } else if (startswith(l, "taint-usr=")) {
1825 int b;
1826
1827 if ((b = parse_boolean(l+10)) < 0)
1828 log_debug("Failed to parse taint /usr flag %s", l+10);
1829 else
1830 m->taint_usr = m->taint_usr || b;
1831 } else if (startswith(l, "firmware-timestamp="))
1832 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1833 else if (startswith(l, "loader-timestamp="))
1834 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1835 else if (startswith(l, "kernel-timestamp="))
1836 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1837 else if (startswith(l, "initrd-timestamp="))
1838 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1839 else if (startswith(l, "userspace-timestamp="))
1840 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1841 else if (startswith(l, "finish-timestamp="))
1842 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1843 else
1844 log_debug("Unknown serialization item '%s'", l);
1845 }
1846
1847 for (;;) {
1848 Unit *u;
1849 char name[UNIT_NAME_MAX+2];
1850
1851 /* Start marker */
1852 if (!fgets(name, sizeof(name), f)) {
1853 if (feof(f))
1854 r = 0;
1855 else
1856 r = -errno;
1857
1858 goto finish;
1859 }
1860
1861 char_array_0(name);
1862
1863 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1864 goto finish;
1865
1866 if ((r = unit_deserialize(u, f, fds)) < 0)
1867 goto finish;
1868 }
1869
1870 finish:
1871 if (ferror(f)) {
1872 r = -EIO;
1873 goto finish;
1874 }
1875
1876 assert(m->n_reloading > 0);
1877 m->n_reloading --;
1878
1879 return r;
1880 }
1881
1882 int manager_reload(Manager *m) {
1883 int r, q;
1884 FILE *f;
1885 FDSet *fds;
1886
1887 assert(m);
1888
1889 r = manager_open_serialization(m, &f);
1890 if (r < 0)
1891 return r;
1892
1893 m->n_reloading ++;
1894
1895 fds = fdset_new();
1896 if (!fds) {
1897 m->n_reloading --;
1898 r = -ENOMEM;
1899 goto finish;
1900 }
1901
1902 r = manager_serialize(m, f, fds, true);
1903 if (r < 0) {
1904 m->n_reloading --;
1905 goto finish;
1906 }
1907
1908 if (fseeko(f, 0, SEEK_SET) < 0) {
1909 m->n_reloading --;
1910 r = -errno;
1911 goto finish;
1912 }
1913
1914 /* From here on there is no way back. */
1915 manager_clear_jobs_and_units(m);
1916 manager_undo_generators(m);
1917 lookup_paths_free(&m->lookup_paths);
1918
1919 /* Find new unit paths */
1920 manager_run_generators(m);
1921
1922 q = lookup_paths_init(
1923 &m->lookup_paths, m->running_as, true,
1924 m->generator_unit_path,
1925 m->generator_unit_path_early,
1926 m->generator_unit_path_late);
1927 if (q < 0)
1928 r = q;
1929
1930 manager_build_unit_path_cache(m);
1931
1932 /* First, enumerate what we can from all config files */
1933 q = manager_enumerate(m);
1934 if (q < 0)
1935 r = q;
1936
1937 /* Second, deserialize our stored data */
1938 q = manager_deserialize(m, f, fds);
1939 if (q < 0)
1940 r = q;
1941
1942 fclose(f);
1943 f = NULL;
1944
1945 /* Third, fire things up! */
1946 q = manager_coldplug(m);
1947 if (q < 0)
1948 r = q;
1949
1950 assert(m->n_reloading > 0);
1951 m->n_reloading--;
1952
1953 finish:
1954 if (f)
1955 fclose(f);
1956
1957 if (fds)
1958 fdset_free(fds);
1959
1960 return r;
1961 }
1962
1963 bool manager_is_booting_or_shutting_down(Manager *m) {
1964 Unit *u;
1965
1966 assert(m);
1967
1968 /* Is the initial job still around? */
1969 if (manager_get_job(m, m->default_unit_job_id))
1970 return true;
1971
1972 /* Is there a job for the shutdown target? */
1973 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1974 if (u)
1975 return !!u->job;
1976
1977 return false;
1978 }
1979
1980 void manager_reset_failed(Manager *m) {
1981 Unit *u;
1982 Iterator i;
1983
1984 assert(m);
1985
1986 HASHMAP_FOREACH(u, m->units, i)
1987 unit_reset_failed(u);
1988 }
1989
1990 bool manager_unit_pending_inactive(Manager *m, const char *name) {
1991 Unit *u;
1992
1993 assert(m);
1994 assert(name);
1995
1996 /* Returns true if the unit is inactive or going down */
1997 if (!(u = manager_get_unit(m, name)))
1998 return true;
1999
2000 return unit_pending_inactive(u);
2001 }
2002
2003 void manager_check_finished(Manager *m) {
2004 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2005 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2006
2007 assert(m);
2008
2009 if (hashmap_size(m->jobs) > 0)
2010 return;
2011
2012 /* Notify Type=idle units that we are done now */
2013 close_pipe(m->idle_pipe);
2014
2015 /* Turn off confirm spawn now */
2016 m->confirm_spawn = false;
2017
2018 if (dual_timestamp_is_set(&m->finish_timestamp))
2019 return;
2020
2021 dual_timestamp_get(&m->finish_timestamp);
2022
2023 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2024
2025 /* Note that m->kernel_usec.monotonic is always at 0,
2026 * and m->firmware_usec.monotonic and
2027 * m->loader_usec.monotonic should be considered
2028 * negative values. */
2029
2030 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2031 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2032 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2033 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2034
2035 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2036
2037 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2038 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2039
2040 if (!log_on_console())
2041 log_struct(LOG_INFO,
2042 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2043 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2044 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2045 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2046 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2047 format_timespan(kernel, sizeof(kernel), kernel_usec),
2048 format_timespan(initrd, sizeof(initrd), initrd_usec),
2049 format_timespan(userspace, sizeof(userspace), userspace_usec),
2050 format_timespan(sum, sizeof(sum), total_usec),
2051 NULL);
2052 } else {
2053 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2054 initrd_usec = 0;
2055
2056 if (!log_on_console())
2057 log_struct(LOG_INFO,
2058 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2059 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2060 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2061 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2062 format_timespan(kernel, sizeof(kernel), kernel_usec),
2063 format_timespan(userspace, sizeof(userspace), userspace_usec),
2064 format_timespan(sum, sizeof(sum), total_usec),
2065 NULL);
2066 }
2067 } else {
2068 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2069 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2070
2071 if (!log_on_console())
2072 log_struct(LOG_INFO,
2073 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2074 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2075 "MESSAGE=Startup finished in %s.",
2076 format_timespan(sum, sizeof(sum), total_usec),
2077 NULL);
2078 }
2079
2080 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2081
2082 sd_notifyf(false,
2083 "READY=1\nSTATUS=Startup finished in %s.",
2084 format_timespan(sum, sizeof(sum), total_usec));
2085 }
2086
2087 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2088 char *p;
2089 int r;
2090
2091 assert(m);
2092 assert(generator);
2093 assert(name);
2094
2095 if (*generator)
2096 return 0;
2097
2098 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2099
2100 p = strappend("/run/systemd/", name);
2101 if (!p)
2102 return log_oom();
2103
2104 r = mkdir_p_label(p, 0755);
2105 if (r < 0) {
2106 log_error("Failed to create generator directory: %s", strerror(-r));
2107 free(p);
2108 return r;
2109 }
2110 } else {
2111 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2112 if (!p)
2113 return log_oom();
2114
2115 if (!mkdtemp(p)) {
2116 free(p);
2117 log_error("Failed to create generator directory: %m");
2118 return -errno;
2119 }
2120 }
2121
2122 *generator = p;
2123 return 0;
2124 }
2125
2126 static void trim_generator_dir(Manager *m, char **generator) {
2127 assert(m);
2128 assert(generator);
2129
2130 if (!*generator)
2131 return;
2132
2133 if (rmdir(*generator) >= 0) {
2134 free(*generator);
2135 *generator = NULL;
2136 }
2137
2138 return;
2139 }
2140
2141 void manager_run_generators(Manager *m) {
2142 DIR *d = NULL;
2143 const char *generator_path;
2144 const char *argv[5];
2145 mode_t u;
2146 int r;
2147
2148 assert(m);
2149
2150 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2151 d = opendir(generator_path);
2152 if (!d) {
2153 if (errno == ENOENT)
2154 return;
2155
2156 log_error("Failed to enumerate generator directory: %m");
2157 return;
2158 }
2159
2160 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2161 if (r < 0)
2162 goto finish;
2163
2164 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2165 if (r < 0)
2166 goto finish;
2167
2168 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2169 if (r < 0)
2170 goto finish;
2171
2172 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2173 argv[1] = m->generator_unit_path;
2174 argv[2] = m->generator_unit_path_early;
2175 argv[3] = m->generator_unit_path_late;
2176 argv[4] = NULL;
2177
2178 u = umask(0022);
2179 execute_directory(generator_path, d, (char**) argv);
2180 umask(u);
2181
2182 trim_generator_dir(m, &m->generator_unit_path);
2183 trim_generator_dir(m, &m->generator_unit_path_early);
2184 trim_generator_dir(m, &m->generator_unit_path_late);
2185
2186 finish:
2187 if (d)
2188 closedir(d);
2189 }
2190
2191 static void remove_generator_dir(Manager *m, char **generator) {
2192 assert(m);
2193 assert(generator);
2194
2195 if (!*generator)
2196 return;
2197
2198 strv_remove(m->lookup_paths.unit_path, *generator);
2199 rm_rf(*generator, false, true, false);
2200
2201 free(*generator);
2202 *generator = NULL;
2203 }
2204
2205 void manager_undo_generators(Manager *m) {
2206 assert(m);
2207
2208 remove_generator_dir(m, &m->generator_unit_path);
2209 remove_generator_dir(m, &m->generator_unit_path_early);
2210 remove_generator_dir(m, &m->generator_unit_path_late);
2211 }
2212
2213 int manager_set_default_controllers(Manager *m, char **controllers) {
2214 char **l;
2215
2216 assert(m);
2217
2218 l = strv_copy(controllers);
2219 if (!l)
2220 return -ENOMEM;
2221
2222 strv_free(m->default_controllers);
2223 m->default_controllers = l;
2224
2225 cg_shorten_controllers(m->default_controllers);
2226
2227 return 0;
2228 }
2229
2230 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2231 int i;
2232
2233 assert(m);
2234
2235 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2236 if (!default_rlimit[i])
2237 continue;
2238
2239 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2240 if (!m->rlimit[i])
2241 return -ENOMEM;
2242 }
2243
2244 return 0;
2245 }
2246
2247 void manager_recheck_journal(Manager *m) {
2248 Unit *u;
2249
2250 assert(m);
2251
2252 if (m->running_as != SYSTEMD_SYSTEM)
2253 return;
2254
2255 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2256 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2257 log_close_journal();
2258 return;
2259 }
2260
2261 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2262 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2263 log_close_journal();
2264 return;
2265 }
2266
2267 /* Hmm, OK, so the socket is fully up and the service is up
2268 * too, then let's make use of the thing. */
2269 log_open();
2270 }
2271
2272 void manager_set_show_status(Manager *m, bool b) {
2273 assert(m);
2274
2275 if (m->running_as != SYSTEMD_SYSTEM)
2276 return;
2277
2278 m->show_status = b;
2279
2280 if (b)
2281 touch("/run/systemd/show-status");
2282 else
2283 unlink("/run/systemd/show-status");
2284 }
2285
2286 bool manager_get_show_status(Manager *m) {
2287 assert(m);
2288
2289 if (m->running_as != SYSTEMD_SYSTEM)
2290 return false;
2291
2292 if (m->show_status)
2293 return true;
2294
2295 /* If Plymouth is running make sure we show the status, so
2296 * that there's something nice to see when people press Esc */
2297
2298 return plymouth_running();
2299 }
Unnamed repository; edit this file 'description' to name the repository.