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