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