src/core/manager.c

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