src/core/manager.c

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