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