src/core/manager.c

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