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