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