src/core/manager.c

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