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