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