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 == MANAGER_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(ManagerRunningAs running_as, Manager **_m) {
 241         Manager *m;
 242         int r = -ENOMEM;
 243
 244         assert(_m);
 245         assert(running_as >= 0);
 246         assert(running_as < _MANAGER_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 == MANAGER_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 != MANAGER_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         if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
 738                 return r;
 739
 740         return manager_add_job(m, type, unit, mode, override, e, _ret);
 741 }
 742
 743 Job *manager_get_job(Manager *m, uint32_t id) {
 744         assert(m);
 745
 746         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
 747 }
 748
 749 Unit *manager_get_unit(Manager *m, const char *name) {
 750         assert(m);
 751         assert(name);
 752
 753         return hashmap_get(m->units, name);
 754 }
 755
 756 unsigned manager_dispatch_load_queue(Manager *m) {
 757         Unit *u;
 758         unsigned n = 0;
 759
 760         assert(m);
 761
 762         /* Make sure we are not run recursively */
 763         if (m->dispatching_load_queue)
 764                 return 0;
 765
 766         m->dispatching_load_queue = true;
 767
 768         /* Dispatches the load queue. Takes a unit from the queue and
 769          * tries to load its data until the queue is empty */
 770
 771         while ((u = m->load_queue)) {
 772                 assert(u->in_load_queue);
 773
 774                 unit_load(u);
 775                 n++;
 776         }
 777
 778         m->dispatching_load_queue = false;
 779         return n;
 780 }
 781
 782 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
 783         Unit *ret;
 784         UnitType t;
 785         int r;
 786
 787         assert(m);
 788         assert(name || path);
 789
 790         /* This will prepare the unit for loading, but not actually
 791          * load anything from disk. */
 792
 793         if (path && !is_path(path)) {
 794                 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
 795                 return -EINVAL;
 796         }
 797
 798         if (!name)
 799                 name = path_get_file_name(path);
 800
 801         t = unit_name_to_type(name);
 802
 803         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
 804                 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
 805                 return -EINVAL;
 806         }
 807
 808         ret = manager_get_unit(m, name);
 809         if (ret) {
 810                 *_ret = ret;
 811                 return 1;
 812         }
 813
 814         ret = unit_new(m, unit_vtable[t]->object_size);
 815         if (!ret)
 816                 return -ENOMEM;
 817
 818         if (path) {
 819                 ret->fragment_path = strdup(path);
 820                 if (!ret->fragment_path) {
 821                         unit_free(ret);
 822                         return -ENOMEM;
 823                 }
 824         }
 825
 826         if ((r = unit_add_name(ret, name)) < 0) {
 827                 unit_free(ret);
 828                 return r;
 829         }
 830
 831         unit_add_to_load_queue(ret);
 832         unit_add_to_dbus_queue(ret);
 833         unit_add_to_gc_queue(ret);
 834
 835         if (_ret)
 836                 *_ret = ret;
 837
 838         return 0;
 839 }
 840
 841 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
 842         int r;
 843
 844         assert(m);
 845
 846         /* This will load the service information files, but not actually
 847          * start any services or anything. */
 848
 849         if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
 850                 return r;
 851
 852         manager_dispatch_load_queue(m);
 853
 854         if (_ret)
 855                 *_ret = unit_follow_merge(*_ret);
 856
 857         return 0;
 858 }
 859
 860 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
 861         Iterator i;
 862         Job *j;
 863
 864         assert(s);
 865         assert(f);
 866
 867         HASHMAP_FOREACH(j, s->jobs, i)
 868                 job_dump(j, f, prefix);
 869 }
 870
 871 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
 872         Iterator i;
 873         Unit *u;
 874         const char *t;
 875
 876         assert(s);
 877         assert(f);
 878
 879         HASHMAP_FOREACH_KEY(u, t, s->units, i)
 880                 if (u->id == t)
 881                         unit_dump(u, f, prefix);
 882 }
 883
 884 void manager_clear_jobs(Manager *m) {
 885         Job *j;
 886
 887         assert(m);
 888
 889         while ((j = hashmap_first(m->jobs)))
 890                 /* No need to recurse. We're cancelling all jobs. */
 891                 job_finish_and_invalidate(j, JOB_CANCELED, false);
 892 }
 893
 894 unsigned manager_dispatch_run_queue(Manager *m) {
 895         Job *j;
 896         unsigned n = 0;
 897
 898         if (m->dispatching_run_queue)
 899                 return 0;
 900
 901         m->dispatching_run_queue = true;
 902
 903         while ((j = m->run_queue)) {
 904                 assert(j->installed);
 905                 assert(j->in_run_queue);
 906
 907                 job_run_and_invalidate(j);
 908                 n++;
 909         }
 910
 911         m->dispatching_run_queue = false;
 912         return n;
 913 }
 914
 915 unsigned manager_dispatch_dbus_queue(Manager *m) {
 916         Job *j;
 917         Unit *u;
 918         unsigned n = 0;
 919
 920         assert(m);
 921
 922         if (m->dispatching_dbus_queue)
 923                 return 0;
 924
 925         m->dispatching_dbus_queue = true;
 926
 927         while ((u = m->dbus_unit_queue)) {
 928                 assert(u->in_dbus_queue);
 929
 930                 bus_unit_send_change_signal(u);
 931                 n++;
 932         }
 933
 934         while ((j = m->dbus_job_queue)) {
 935                 assert(j->in_dbus_queue);
 936
 937                 bus_job_send_change_signal(j);
 938                 n++;
 939         }
 940
 941         m->dispatching_dbus_queue = false;
 942         return n;
 943 }
 944
 945 static int manager_process_notify_fd(Manager *m) {
 946         ssize_t n;
 947
 948         assert(m);
 949
 950         for (;;) {
 951                 char buf[4096];
 952                 struct msghdr msghdr;
 953                 struct iovec iovec;
 954                 struct ucred *ucred;
 955                 union {
 956                         struct cmsghdr cmsghdr;
 957                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
 958                 } control;
 959                 Unit *u;
 960                 char **tags;
 961
 962                 zero(iovec);
 963                 iovec.iov_base = buf;
 964                 iovec.iov_len = sizeof(buf)-1;
 965
 966                 zero(control);
 967                 zero(msghdr);
 968                 msghdr.msg_iov = &iovec;
 969                 msghdr.msg_iovlen = 1;
 970                 msghdr.msg_control = &control;
 971                 msghdr.msg_controllen = sizeof(control);
 972
 973                 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
 974                         if (n >= 0)
 975                                 return -EIO;
 976
 977                         if (errno == EAGAIN || errno == EINTR)
 978                                 break;
 979
 980                         return -errno;
 981                 }
 982
 983                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
 984                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
 985                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
 986                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
 987                         log_warning("Received notify message without credentials. Ignoring.");
 988                         continue;
 989                 }
 990
 991                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
 992
 993                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
 994                         if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
 995                                 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
 996                                 continue;
 997                         }
 998
 999                 assert((size_t) n < sizeof(buf));
1000                 buf[n] = 0;
1001                 if (!(tags = strv_split(buf, "\n\r")))
1002                         return -ENOMEM;
1003
1004                 log_debug("Got notification message for unit %s", u->id);
1005
1006                 if (UNIT_VTABLE(u)->notify_message)
1007                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1008
1009                 strv_free(tags);
1010         }
1011
1012         return 0;
1013 }
1014
1015 static int manager_dispatch_sigchld(Manager *m) {
1016         assert(m);
1017
1018         for (;;) {
1019                 siginfo_t si;
1020                 Unit *u;
1021                 int r;
1022
1023                 zero(si);
1024
1025                 /* First we call waitd() for a PID and do not reap the
1026                  * zombie. That way we can still access /proc/$PID for
1027                  * it while it is a zombie. */
1028                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1029
1030                         if (errno == ECHILD)
1031                                 break;
1032
1033                         if (errno == EINTR)
1034                                 continue;
1035
1036                         return -errno;
1037                 }
1038
1039                 if (si.si_pid <= 0)
1040                         break;
1041
1042                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1043                         char *name = NULL;
1044
1045                         get_process_comm(si.si_pid, &name);
1046                         log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1047                         free(name);
1048                 }
1049
1050                 /* Let's flush any message the dying child might still
1051                  * have queued for us. This ensures that the process
1052                  * still exists in /proc so that we can figure out
1053                  * which cgroup and hence unit it belongs to. */
1054                 if ((r = manager_process_notify_fd(m)) < 0)
1055                         return r;
1056
1057                 /* And now figure out the unit this belongs to */
1058                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1059                         u = cgroup_unit_by_pid(m, si.si_pid);
1060
1061                 /* And now, we actually reap the zombie. */
1062                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1063                         if (errno == EINTR)
1064                                 continue;
1065
1066                         return -errno;
1067                 }
1068
1069                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1070                         continue;
1071
1072                 log_debug("Child %lu died (code=%s, status=%i/%s)",
1073                           (long unsigned) si.si_pid,
1074                           sigchld_code_to_string(si.si_code),
1075                           si.si_status,
1076                           strna(si.si_code == CLD_EXITED
1077                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1078                                 : signal_to_string(si.si_status)));
1079
1080                 if (!u)
1081                         continue;
1082
1083                 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1084
1085                 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1086                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1087         }
1088
1089         return 0;
1090 }
1091
1092 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1093         int r;
1094         DBusError error;
1095
1096         dbus_error_init(&error);
1097
1098         log_debug("Activating special unit %s", name);
1099
1100         if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1101                 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1102
1103         dbus_error_free(&error);
1104
1105         return r;
1106 }
1107
1108 static int manager_process_signal_fd(Manager *m) {
1109         ssize_t n;
1110         struct signalfd_siginfo sfsi;
1111         bool sigchld = false;
1112
1113         assert(m);
1114
1115         for (;;) {
1116                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1117
1118                         if (n >= 0)
1119                                 return -EIO;
1120
1121                         if (errno == EINTR || errno == EAGAIN)
1122                                 break;
1123
1124                         return -errno;
1125                 }
1126
1127                 if (sfsi.ssi_pid > 0) {
1128                         char *p = NULL;
1129
1130                         get_process_comm(sfsi.ssi_pid, &p);
1131
1132                         log_debug("Received SIG%s from PID %lu (%s).",
1133                                   signal_to_string(sfsi.ssi_signo),
1134                                   (unsigned long) sfsi.ssi_pid, strna(p));
1135                         free(p);
1136                 } else
1137                         log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1138
1139                 switch (sfsi.ssi_signo) {
1140
1141                 case SIGCHLD:
1142                         sigchld = true;
1143                         break;
1144
1145                 case SIGTERM:
1146                         if (m->running_as == MANAGER_SYSTEM) {
1147                                 /* This is for compatibility with the
1148                                  * original sysvinit */
1149                                 m->exit_code = MANAGER_REEXECUTE;
1150                                 break;
1151                         }
1152
1153                         /* Fall through */
1154
1155                 case SIGINT:
1156                         if (m->running_as == MANAGER_SYSTEM) {
1157                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1158                                 break;
1159                         }
1160
1161                         /* Run the exit target if there is one, if not, just exit. */
1162                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1163                                 m->exit_code = MANAGER_EXIT;
1164                                 return 0;
1165                         }
1166
1167                         break;
1168
1169                 case SIGWINCH:
1170                         if (m->running_as == MANAGER_SYSTEM)
1171                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1172
1173                         /* This is a nop on non-init */
1174                         break;
1175
1176                 case SIGPWR:
1177                         if (m->running_as == MANAGER_SYSTEM)
1178                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1179
1180                         /* This is a nop on non-init */
1181                         break;
1182
1183                 case SIGUSR1: {
1184                         Unit *u;
1185
1186                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1187
1188                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1189                                 log_info("Trying to reconnect to bus...");
1190                                 bus_init(m, true);
1191                         }
1192
1193                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1194                                 log_info("Loading D-Bus service...");
1195                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1196                         }
1197
1198                         break;
1199                 }
1200
1201                 case SIGUSR2: {
1202                         FILE *f;
1203                         char *dump = NULL;
1204                         size_t size;
1205
1206                         if (!(f = open_memstream(&dump, &size))) {
1207                                 log_warning("Failed to allocate memory stream.");
1208                                 break;
1209                         }
1210
1211                         manager_dump_units(m, f, "\t");
1212                         manager_dump_jobs(m, f, "\t");
1213
1214                         if (ferror(f)) {
1215                                 fclose(f);
1216                                 free(dump);
1217                                 log_warning("Failed to write status stream");
1218                                 break;
1219                         }
1220
1221                         fclose(f);
1222                         log_dump(LOG_INFO, dump);
1223                         free(dump);
1224
1225                         break;
1226                 }
1227
1228                 case SIGHUP:
1229                         m->exit_code = MANAGER_RELOAD;
1230                         break;
1231
1232                 default: {
1233
1234                         /* Starting SIGRTMIN+0 */
1235                         static const char * const target_table[] = {
1236                                 [0] = SPECIAL_DEFAULT_TARGET,
1237                                 [1] = SPECIAL_RESCUE_TARGET,
1238                                 [2] = SPECIAL_EMERGENCY_TARGET,
1239                                 [3] = SPECIAL_HALT_TARGET,
1240                                 [4] = SPECIAL_POWEROFF_TARGET,
1241                                 [5] = SPECIAL_REBOOT_TARGET,
1242                                 [6] = SPECIAL_KEXEC_TARGET
1243                         };
1244
1245                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1246                         static const ManagerExitCode code_table[] = {
1247                                 [0] = MANAGER_HALT,
1248                                 [1] = MANAGER_POWEROFF,
1249                                 [2] = MANAGER_REBOOT,
1250                                 [3] = MANAGER_KEXEC
1251                         };
1252
1253                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1254                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1255                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1256                                 manager_start_target(m, target_table[idx],
1257                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1258                                 break;
1259                         }
1260
1261                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1262                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1263                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1264                                 break;
1265                         }
1266
1267                         switch (sfsi.ssi_signo - SIGRTMIN) {
1268
1269                         case 20:
1270                                 log_debug("Enabling showing of status.");
1271                                 manager_set_show_status(m, true);
1272                                 break;
1273
1274                         case 21:
1275                                 log_debug("Disabling showing of status.");
1276                                 manager_set_show_status(m, false);
1277                                 break;
1278
1279                         case 22:
1280                                 log_set_max_level(LOG_DEBUG);
1281                                 log_notice("Setting log level to debug.");
1282                                 break;
1283
1284                         case 23:
1285                                 log_set_max_level(LOG_INFO);
1286                                 log_notice("Setting log level to info.");
1287                                 break;
1288
1289                         case 26:
1290                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1291                                 log_notice("Setting log target to journal-or-kmsg.");
1292                                 break;
1293
1294                         case 27:
1295                                 log_set_target(LOG_TARGET_CONSOLE);
1296                                 log_notice("Setting log target to console.");
1297                                 break;
1298
1299                         case 28:
1300                                 log_set_target(LOG_TARGET_KMSG);
1301                                 log_notice("Setting log target to kmsg.");
1302                                 break;
1303
1304                         case 29:
1305                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1306                                 log_notice("Setting log target to syslog-or-kmsg.");
1307                                 break;
1308
1309                         default:
1310                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1311                         }
1312                 }
1313                 }
1314         }
1315
1316         if (sigchld)
1317                 return manager_dispatch_sigchld(m);
1318
1319         return 0;
1320 }
1321
1322 static int process_event(Manager *m, struct epoll_event *ev) {
1323         int r;
1324         Watch *w;
1325
1326         assert(m);
1327         assert(ev);
1328
1329         assert_se(w = ev->data.ptr);
1330
1331         if (w->type == WATCH_INVALID)
1332                 return 0;
1333
1334         switch (w->type) {
1335
1336         case WATCH_SIGNAL:
1337
1338                 /* An incoming signal? */
1339                 if (ev->events != EPOLLIN)
1340                         return -EINVAL;
1341
1342                 if ((r = manager_process_signal_fd(m)) < 0)
1343                         return r;
1344
1345                 break;
1346
1347         case WATCH_NOTIFY:
1348
1349                 /* An incoming daemon notification event? */
1350                 if (ev->events != EPOLLIN)
1351                         return -EINVAL;
1352
1353                 if ((r = manager_process_notify_fd(m)) < 0)
1354                         return r;
1355
1356                 break;
1357
1358         case WATCH_FD:
1359
1360                 /* Some fd event, to be dispatched to the units */
1361                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1362                 break;
1363
1364         case WATCH_UNIT_TIMER:
1365         case WATCH_JOB_TIMER: {
1366                 uint64_t v;
1367                 ssize_t k;
1368
1369                 /* Some timer event, to be dispatched to the units */
1370                 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1371
1372                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
1373                                 break;
1374
1375                         return k < 0 ? -errno : -EIO;
1376                 }
1377
1378                 if (w->type == WATCH_UNIT_TIMER)
1379                         UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1380                 else
1381                         job_timer_event(w->data.job, v, w);
1382                 break;
1383         }
1384
1385         case WATCH_MOUNT:
1386                 /* Some mount table change, intended for the mount subsystem */
1387                 mount_fd_event(m, ev->events);
1388                 break;
1389
1390         case WATCH_SWAP:
1391                 /* Some swap table change, intended for the swap subsystem */
1392                 swap_fd_event(m, ev->events);
1393                 break;
1394
1395         case WATCH_UDEV:
1396                 /* Some notification from udev, intended for the device subsystem */
1397                 device_fd_event(m, ev->events);
1398                 break;
1399
1400         case WATCH_DBUS_WATCH:
1401                 bus_watch_event(m, w, ev->events);
1402                 break;
1403
1404         case WATCH_DBUS_TIMEOUT:
1405                 bus_timeout_event(m, w, ev->events);
1406                 break;
1407
1408         default:
1409                 log_error("event type=%i", w->type);
1410                 assert_not_reached("Unknown epoll event type.");
1411         }
1412
1413         return 0;
1414 }
1415
1416 int manager_loop(Manager *m) {
1417         int r;
1418
1419         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1420
1421         assert(m);
1422         m->exit_code = MANAGER_RUNNING;
1423
1424         /* Release the path cache */
1425         set_free_free(m->unit_path_cache);
1426         m->unit_path_cache = NULL;
1427
1428         manager_check_finished(m);
1429
1430         /* There might still be some zombies hanging around from
1431          * before we were exec()'ed. Leat's reap them */
1432         r = manager_dispatch_sigchld(m);
1433         if (r < 0)
1434                 return r;
1435
1436         while (m->exit_code == MANAGER_RUNNING) {
1437                 struct epoll_event event;
1438                 int n;
1439                 int wait_msec = -1;
1440
1441                 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
1442                         watchdog_ping();
1443
1444                 if (!ratelimit_test(&rl)) {
1445                         /* Yay, something is going seriously wrong, pause a little */
1446                         log_warning("Looping too fast. Throttling execution a little.");
1447                         sleep(1);
1448                         continue;
1449                 }
1450
1451                 if (manager_dispatch_load_queue(m) > 0)
1452                         continue;
1453
1454                 if (manager_dispatch_run_queue(m) > 0)
1455                         continue;
1456
1457                 if (bus_dispatch(m) > 0)
1458                         continue;
1459
1460                 if (manager_dispatch_cleanup_queue(m) > 0)
1461                         continue;
1462
1463                 if (manager_dispatch_gc_queue(m) > 0)
1464                         continue;
1465
1466                 if (manager_dispatch_dbus_queue(m) > 0)
1467                         continue;
1468
1469                 if (swap_dispatch_reload(m) > 0)
1470                         continue;
1471
1472                 /* Sleep for half the watchdog time */
1473                 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
1474                         wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1475                         if (wait_msec <= 0)
1476                                 wait_msec = 1;
1477                 } else
1478                         wait_msec = -1;
1479
1480                 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1481                 if (n < 0) {
1482
1483                         if (errno == EINTR)
1484                                 continue;
1485
1486                         return -errno;
1487                 } else if (n == 0)
1488                         continue;
1489
1490                 assert(n == 1);
1491
1492                 r = process_event(m, &event);
1493                 if (r < 0)
1494                         return r;
1495         }
1496
1497         return m->exit_code;
1498 }
1499
1500 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1501         char *n;
1502         Unit *u;
1503         int r;
1504
1505         assert(m);
1506         assert(s);
1507         assert(_u);
1508
1509         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1510                 return -EINVAL;
1511
1512         n = bus_path_unescape(s+31);
1513         if (!n)
1514                 return -ENOMEM;
1515
1516         r = manager_load_unit(m, n, NULL, e, &u);
1517         free(n);
1518
1519         if (r < 0)
1520                 return r;
1521
1522         *_u = u;
1523
1524         return 0;
1525 }
1526
1527 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1528         Job *j;
1529         unsigned id;
1530         int r;
1531
1532         assert(m);
1533         assert(s);
1534         assert(_j);
1535
1536         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1537                 return -EINVAL;
1538
1539         if ((r = safe_atou(s + 30, &id)) < 0)
1540                 return r;
1541
1542         if (!(j = manager_get_job(m, id)))
1543                 return -ENOENT;
1544
1545         *_j = j;
1546
1547         return 0;
1548 }
1549
1550 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1551
1552 #ifdef HAVE_AUDIT
1553         char *p;
1554
1555         if (m->audit_fd < 0)
1556                 return;
1557
1558         /* Don't generate audit events if the service was already
1559          * started and we're just deserializing */
1560         if (m->n_reloading > 0)
1561                 return;
1562
1563         if (m->running_as != MANAGER_SYSTEM)
1564                 return;
1565
1566         if (u->type != UNIT_SERVICE)
1567                 return;
1568
1569         if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1570                 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1571                 return;
1572         }
1573
1574         if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1575                 if (errno == EPERM) {
1576                         /* We aren't allowed to send audit messages?
1577                          * Then let's not retry again. */
1578                         audit_close(m->audit_fd);
1579                         m->audit_fd = -1;
1580                 } else
1581                         log_warning("Failed to send audit message: %m");
1582         }
1583
1584         free(p);
1585 #endif
1586
1587 }
1588
1589 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1590         int fd = -1;
1591         union sockaddr_union sa;
1592         int n = 0;
1593         char *message = NULL;
1594
1595         /* Don't generate plymouth events if the service was already
1596          * started and we're just deserializing */
1597         if (m->n_reloading > 0)
1598                 return;
1599
1600         if (m->running_as != MANAGER_SYSTEM)
1601                 return;
1602
1603         if (u->type != UNIT_SERVICE &&
1604             u->type != UNIT_MOUNT &&
1605             u->type != UNIT_SWAP)
1606                 return;
1607
1608         /* We set SOCK_NONBLOCK here so that we rather drop the
1609          * message then wait for plymouth */
1610         if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1611                 log_error("socket() failed: %m");
1612                 return;
1613         }
1614
1615         zero(sa);
1616         sa.sa.sa_family = AF_UNIX;
1617         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1618         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1619
1620                 if (errno != EPIPE &&
1621                     errno != EAGAIN &&
1622                     errno != ENOENT &&
1623                     errno != ECONNREFUSED &&
1624                     errno != ECONNRESET &&
1625                     errno != ECONNABORTED)
1626                         log_error("connect() failed: %m");
1627
1628                 goto finish;
1629         }
1630
1631         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1632                 log_oom();
1633                 goto finish;
1634         }
1635
1636         errno = 0;
1637         if (write(fd, message, n + 1) != n + 1) {
1638
1639                 if (errno != EPIPE &&
1640                     errno != EAGAIN &&
1641                     errno != ENOENT &&
1642                     errno != ECONNREFUSED &&
1643                     errno != ECONNRESET &&
1644                     errno != ECONNABORTED)
1645                         log_error("Failed to write Plymouth message: %m");
1646
1647                 goto finish;
1648         }
1649
1650 finish:
1651         if (fd >= 0)
1652                 close_nointr_nofail(fd);
1653
1654         free(message);
1655 }
1656
1657 void manager_dispatch_bus_name_owner_changed(
1658                 Manager *m,
1659                 const char *name,
1660                 const char* old_owner,
1661                 const char *new_owner) {
1662
1663         Unit *u;
1664
1665         assert(m);
1666         assert(name);
1667
1668         if (!(u = hashmap_get(m->watch_bus, name)))
1669                 return;
1670
1671         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1672 }
1673
1674 void manager_dispatch_bus_query_pid_done(
1675                 Manager *m,
1676                 const char *name,
1677                 pid_t pid) {
1678
1679         Unit *u;
1680
1681         assert(m);
1682         assert(name);
1683         assert(pid >= 1);
1684
1685         if (!(u = hashmap_get(m->watch_bus, name)))
1686                 return;
1687
1688         UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1689 }
1690
1691 int manager_open_serialization(Manager *m, FILE **_f) {
1692         char *path = NULL;
1693         mode_t saved_umask;
1694         int fd;
1695         FILE *f;
1696
1697         assert(_f);
1698
1699         if (m->running_as == MANAGER_SYSTEM)
1700                 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1701         else
1702                 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1703
1704         if (!path)
1705                 return -ENOMEM;
1706
1707         saved_umask = umask(0077);
1708         fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1709         umask(saved_umask);
1710
1711         if (fd < 0) {
1712                 free(path);
1713                 return -errno;
1714         }
1715
1716         unlink(path);
1717
1718         log_debug("Serializing state to %s", path);
1719         free(path);
1720
1721         if (!(f = fdopen(fd, "w+")))
1722                 return -errno;
1723
1724         *_f = f;
1725
1726         return 0;
1727 }
1728
1729 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1730         Iterator i;
1731         Unit *u;
1732         const char *t;
1733         int r;
1734
1735         assert(m);
1736         assert(f);
1737         assert(fds);
1738
1739         m->n_reloading ++;
1740
1741         fprintf(f, "current-job-id=%i\n", m->current_job_id);
1742         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1743         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1744         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1745
1746         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1747         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1748         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1749         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1750
1751         if (!in_initrd()) {
1752                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1753                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1754         }
1755
1756         fputc('\n', f);
1757
1758         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1759                 if (u->id != t)
1760                         continue;
1761
1762                 if (!unit_can_serialize(u))
1763                         continue;
1764
1765                 /* Start marker */
1766                 fputs(u->id, f);
1767                 fputc('\n', f);
1768
1769                 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1770                         m->n_reloading --;
1771                         return r;
1772                 }
1773         }
1774
1775         assert(m->n_reloading > 0);
1776         m->n_reloading --;
1777
1778         if (ferror(f))
1779                 return -EIO;
1780
1781         r = bus_fdset_add_all(m, fds);
1782         if (r < 0)
1783                 return r;
1784
1785         return 0;
1786 }
1787
1788 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1789         int r = 0;
1790
1791         assert(m);
1792         assert(f);
1793
1794         log_debug("Deserializing state...");
1795
1796         m->n_reloading ++;
1797
1798         for (;;) {
1799                 char line[LINE_MAX], *l;
1800
1801                 if (!fgets(line, sizeof(line), f)) {
1802                         if (feof(f))
1803                                 r = 0;
1804                         else
1805                                 r = -errno;
1806
1807                         goto finish;
1808                 }
1809
1810                 char_array_0(line);
1811                 l = strstrip(line);
1812
1813                 if (l[0] == 0)
1814                         break;
1815
1816                 if (startswith(l, "current-job-id=")) {
1817                         uint32_t id;
1818
1819                         if (safe_atou32(l+15, &id) < 0)
1820                                 log_debug("Failed to parse current job id value %s", l+15);
1821                         else
1822                                 m->current_job_id = MAX(m->current_job_id, id);
1823                 } else if (startswith(l, "n-installed-jobs=")) {
1824                         uint32_t n;
1825
1826                         if (safe_atou32(l+17, &n) < 0)
1827                                 log_debug("Failed to parse installed jobs counter %s", l+17);
1828                         else
1829                                 m->n_installed_jobs += n;
1830                 } else if (startswith(l, "n-failed-jobs=")) {
1831                         uint32_t n;
1832
1833                         if (safe_atou32(l+14, &n) < 0)
1834                                 log_debug("Failed to parse failed jobs counter %s", l+14);
1835                         else
1836                                 m->n_failed_jobs += n;
1837                 } else if (startswith(l, "taint-usr=")) {
1838                         int b;
1839
1840                         if ((b = parse_boolean(l+10)) < 0)
1841                                 log_debug("Failed to parse taint /usr flag %s", l+10);
1842                         else
1843                                 m->taint_usr = m->taint_usr || b;
1844                 } else if (startswith(l, "firmware-timestamp="))
1845                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1846                 else if (startswith(l, "loader-timestamp="))
1847                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1848                 else if (startswith(l, "kernel-timestamp="))
1849                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1850                 else if (startswith(l, "initrd-timestamp="))
1851                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1852                 else if (startswith(l, "userspace-timestamp="))
1853                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1854                 else if (startswith(l, "finish-timestamp="))
1855                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1856                 else
1857                         log_debug("Unknown serialization item '%s'", l);
1858         }
1859
1860         for (;;) {
1861                 Unit *u;
1862                 char name[UNIT_NAME_MAX+2];
1863
1864                 /* Start marker */
1865                 if (!fgets(name, sizeof(name), f)) {
1866                         if (feof(f))
1867                                 r = 0;
1868                         else
1869                                 r = -errno;
1870
1871                         goto finish;
1872                 }
1873
1874                 char_array_0(name);
1875
1876                 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1877                         goto finish;
1878
1879                 if ((r = unit_deserialize(u, f, fds)) < 0)
1880                         goto finish;
1881         }
1882
1883 finish:
1884         if (ferror(f)) {
1885                 r = -EIO;
1886                 goto finish;
1887         }
1888
1889         assert(m->n_reloading > 0);
1890         m->n_reloading --;
1891
1892         return r;
1893 }
1894
1895 int manager_reload(Manager *m) {
1896         int r, q;
1897         FILE *f;
1898         FDSet *fds;
1899
1900         assert(m);
1901
1902         r = manager_open_serialization(m, &f);
1903         if (r < 0)
1904                 return r;
1905
1906         m->n_reloading ++;
1907
1908         fds = fdset_new();
1909         if (!fds) {
1910                 m->n_reloading --;
1911                 r = -ENOMEM;
1912                 goto finish;
1913         }
1914
1915         r = manager_serialize(m, f, fds, true);
1916         if (r < 0) {
1917                 m->n_reloading --;
1918                 goto finish;
1919         }
1920
1921         if (fseeko(f, 0, SEEK_SET) < 0) {
1922                 m->n_reloading --;
1923                 r = -errno;
1924                 goto finish;
1925         }
1926
1927         /* From here on there is no way back. */
1928         manager_clear_jobs_and_units(m);
1929         manager_undo_generators(m);
1930         lookup_paths_free(&m->lookup_paths);
1931
1932         /* Find new unit paths */
1933         manager_run_generators(m);
1934
1935         q = lookup_paths_init(
1936                         &m->lookup_paths, m->running_as, true,
1937                         m->generator_unit_path,
1938                         m->generator_unit_path_early,
1939                         m->generator_unit_path_late);
1940         if (q < 0)
1941                 r = q;
1942
1943         manager_build_unit_path_cache(m);
1944
1945         /* First, enumerate what we can from all config files */
1946         q = manager_enumerate(m);
1947         if (q < 0)
1948                 r = q;
1949
1950         /* Second, deserialize our stored data */
1951         q = manager_deserialize(m, f, fds);
1952         if (q < 0)
1953                 r = q;
1954
1955         fclose(f);
1956         f = NULL;
1957
1958         /* Third, fire things up! */
1959         q = manager_coldplug(m);
1960         if (q < 0)
1961                 r = q;
1962
1963         assert(m->n_reloading > 0);
1964         m->n_reloading--;
1965
1966 finish:
1967         if (f)
1968                 fclose(f);
1969
1970         if (fds)
1971                 fdset_free(fds);
1972
1973         return r;
1974 }
1975
1976 bool manager_is_booting_or_shutting_down(Manager *m) {
1977         Unit *u;
1978
1979         assert(m);
1980
1981         /* Is the initial job still around? */
1982         if (manager_get_job(m, m->default_unit_job_id))
1983                 return true;
1984
1985         /* Is there a job for the shutdown target? */
1986         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1987         if (u)
1988                 return !!u->job;
1989
1990         return false;
1991 }
1992
1993 void manager_reset_failed(Manager *m) {
1994         Unit *u;
1995         Iterator i;
1996
1997         assert(m);
1998
1999         HASHMAP_FOREACH(u, m->units, i)
2000                 unit_reset_failed(u);
2001 }
2002
2003 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2004         Unit *u;
2005
2006         assert(m);
2007         assert(name);
2008
2009         /* Returns true if the unit is inactive or going down */
2010         if (!(u = manager_get_unit(m, name)))
2011                 return true;
2012
2013         return unit_pending_inactive(u);
2014 }
2015
2016 void manager_check_finished(Manager *m) {
2017         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2018         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2019
2020         assert(m);
2021
2022         if (hashmap_size(m->jobs) > 0)
2023                 return;
2024
2025         /* Notify Type=idle units that we are done now */
2026         close_pipe(m->idle_pipe);
2027
2028         /* Turn off confirm spawn now */
2029         m->confirm_spawn = false;
2030
2031         if (dual_timestamp_is_set(&m->finish_timestamp))
2032                 return;
2033
2034         dual_timestamp_get(&m->finish_timestamp);
2035
2036         if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
2037
2038                 /* Note that m->kernel_usec.monotonic is always at 0,
2039                  * and m->firmware_usec.monotonic and
2040                  * m->loader_usec.monotonic should be considered
2041                  * negative values. */
2042
2043                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2044                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2045                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2046                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2047
2048                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2049
2050                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2051                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2052
2053                         if (!log_on_console())
2054                                 log_struct(LOG_INFO,
2055                                            "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2056                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2057                                            "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2058                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2059                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2060                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2061                                            format_timespan(initrd, sizeof(initrd), initrd_usec),
2062                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2063                                            format_timespan(sum, sizeof(sum), total_usec),
2064                                            NULL);
2065                 } else {
2066                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2067                         initrd_usec = 0;
2068
2069                         if (!log_on_console())
2070                                 log_struct(LOG_INFO,
2071                                            "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2072                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2073                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2074                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2075                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2076                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2077                                            format_timespan(sum, sizeof(sum), total_usec),
2078                                            NULL);
2079                 }
2080         } else {
2081                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2082                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2083
2084                 if (!log_on_console())
2085                         log_struct(LOG_INFO,
2086                                    "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2087                                    "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2088                                    "MESSAGE=Startup finished in %s.",
2089                                    format_timespan(sum, sizeof(sum), total_usec),
2090                                    NULL);
2091         }
2092
2093         bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2094
2095         sd_notifyf(false,
2096                    "READY=1\nSTATUS=Startup finished in %s.",
2097                    format_timespan(sum, sizeof(sum), total_usec));
2098 }
2099
2100 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2101         char *p;
2102         int r;
2103
2104         assert(m);
2105         assert(generator);
2106         assert(name);
2107
2108         if (*generator)
2109                 return 0;
2110
2111         if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2112
2113                 p = strappend("/run/systemd/", name);
2114                 if (!p)
2115                         return log_oom();
2116
2117                 r = mkdir_p_label(p, 0755);
2118                 if (r < 0) {
2119                         log_error("Failed to create generator directory: %s", strerror(-r));
2120                         free(p);
2121                         return r;
2122                 }
2123         } else {
2124                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2125                 if (!p)
2126                         return log_oom();
2127
2128                 if (!mkdtemp(p)) {
2129                         free(p);
2130                         log_error("Failed to create generator directory: %m");
2131                         return -errno;
2132                 }
2133         }
2134
2135         *generator = p;
2136         return 0;
2137 }
2138
2139 static void trim_generator_dir(Manager *m, char **generator) {
2140         assert(m);
2141         assert(generator);
2142
2143         if (!*generator)
2144                 return;
2145
2146         if (rmdir(*generator) >= 0) {
2147                 free(*generator);
2148                 *generator = NULL;
2149         }
2150
2151         return;
2152 }
2153
2154 void manager_run_generators(Manager *m) {
2155         DIR *d = NULL;
2156         const char *generator_path;
2157         const char *argv[5];
2158         mode_t u;
2159         int r;
2160
2161         assert(m);
2162
2163         generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2164         d = opendir(generator_path);
2165         if (!d) {
2166                 if (errno == ENOENT)
2167                         return;
2168
2169                 log_error("Failed to enumerate generator directory: %m");
2170                 return;
2171         }
2172
2173         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2174         if (r < 0)
2175                 goto finish;
2176
2177         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2178         if (r < 0)
2179                 goto finish;
2180
2181         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2182         if (r < 0)
2183                 goto finish;
2184
2185         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2186         argv[1] = m->generator_unit_path;
2187         argv[2] = m->generator_unit_path_early;
2188         argv[3] = m->generator_unit_path_late;
2189         argv[4] = NULL;
2190
2191         u = umask(0022);
2192         execute_directory(generator_path, d, (char**) argv);
2193         umask(u);
2194
2195         trim_generator_dir(m, &m->generator_unit_path);
2196         trim_generator_dir(m, &m->generator_unit_path_early);
2197         trim_generator_dir(m, &m->generator_unit_path_late);
2198
2199 finish:
2200         if (d)
2201                 closedir(d);
2202 }
2203
2204 static void remove_generator_dir(Manager *m, char **generator) {
2205         assert(m);
2206         assert(generator);
2207
2208         if (!*generator)
2209                 return;
2210
2211         strv_remove(m->lookup_paths.unit_path, *generator);
2212         rm_rf(*generator, false, true, false);
2213
2214         free(*generator);
2215         *generator = NULL;
2216 }
2217
2218 void manager_undo_generators(Manager *m) {
2219         assert(m);
2220
2221         remove_generator_dir(m, &m->generator_unit_path);
2222         remove_generator_dir(m, &m->generator_unit_path_early);
2223         remove_generator_dir(m, &m->generator_unit_path_late);
2224 }
2225
2226 int manager_set_default_controllers(Manager *m, char **controllers) {
2227         char **l;
2228
2229         assert(m);
2230
2231         l = strv_copy(controllers);
2232         if (!l)
2233                 return -ENOMEM;
2234
2235         strv_free(m->default_controllers);
2236         m->default_controllers = l;
2237
2238         cg_shorten_controllers(m->default_controllers);
2239
2240         return 0;
2241 }
2242
2243 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2244         int i;
2245
2246         assert(m);
2247
2248         for (i = 0; i < RLIMIT_NLIMITS; i++) {
2249                 if (!default_rlimit[i])
2250                         continue;
2251
2252                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2253                 if (!m->rlimit[i])
2254                         return -ENOMEM;
2255         }
2256
2257         return 0;
2258 }
2259
2260 void manager_recheck_journal(Manager *m) {
2261         Unit *u;
2262
2263         assert(m);
2264
2265         if (m->running_as != MANAGER_SYSTEM)
2266                 return;
2267
2268         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2269         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2270                 log_close_journal();
2271                 return;
2272         }
2273
2274         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2275         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2276                 log_close_journal();
2277                 return;
2278         }
2279
2280         /* Hmm, OK, so the socket is fully up and the service is up
2281          * too, then let's make use of the thing. */
2282         log_open();
2283 }
2284
2285 void manager_set_show_status(Manager *m, bool b) {
2286         assert(m);
2287
2288         if (m->running_as != MANAGER_SYSTEM)
2289                 return;
2290
2291         m->show_status = b;
2292
2293         if (b)
2294                 touch("/run/systemd/show-status");
2295         else
2296                 unlink("/run/systemd/show-status");
2297 }
2298
2299 bool manager_get_show_status(Manager *m) {
2300         assert(m);
2301
2302         if (m->running_as != MANAGER_SYSTEM)
2303                 return false;
2304
2305         if (m->show_status)
2306                 return true;
2307
2308         /* If Plymouth is running make sure we show the status, so
2309          * that there's something nice to see when people press Esc */
2310
2311         return plymouth_running();
2312 }
2313
2314 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
2315         [MANAGER_SYSTEM] = "system",
2316         [MANAGER_USER] = "user"
2317 };
2318
2319 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);