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