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