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