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         _cleanup_free_ char *n = NULL;
1787         Unit *u;
1788         int r;
1789
1790         assert(m);
1791         assert(s);
1792         assert(_u);
1793
1794         r = unit_name_from_dbus_path(s, &n);
1795         if (r < 0)
1796                 return r;
1797
1798         r = manager_load_unit(m, n, NULL, e, &u);
1799         if (r < 0)
1800                 return r;
1801
1802         *_u = u;
1803
1804         return 0;
1805 }
1806
1807 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1808         Job *j;
1809         unsigned id;
1810         int r;
1811
1812         assert(m);
1813         assert(s);
1814         assert(_j);
1815
1816         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1817                 return -EINVAL;
1818
1819         r = safe_atou(s + 30, &id);
1820         if (r < 0)
1821                 return r;
1822
1823         j = manager_get_job(m, id);
1824         if (!j)
1825                 return -ENOENT;
1826
1827         *_j = j;
1828
1829         return 0;
1830 }
1831
1832 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1833
1834 #ifdef HAVE_AUDIT
1835         char *p;
1836         int audit_fd;
1837
1838         audit_fd = get_audit_fd();
1839         if (audit_fd < 0)
1840                 return;
1841
1842         /* Don't generate audit events if the service was already
1843          * started and we're just deserializing */
1844         if (m->n_reloading > 0)
1845                 return;
1846
1847         if (m->running_as != SYSTEMD_SYSTEM)
1848                 return;
1849
1850         if (u->type != UNIT_SERVICE)
1851                 return;
1852
1853         p = unit_name_to_prefix_and_instance(u->id);
1854         if (!p) {
1855                 log_error_unit(u->id,
1856                                "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1857                 return;
1858         }
1859
1860         if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1861                 if (errno == EPERM) {
1862                         /* We aren't allowed to send audit messages?
1863                          * Then let's not retry again. */
1864                         close_audit_fd();
1865                 } else
1866                         log_warning("Failed to send audit message: %m");
1867         }
1868
1869         free(p);
1870 #endif
1871
1872 }
1873
1874 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1875         int fd = -1;
1876         union sockaddr_union sa;
1877         int n = 0;
1878         char *message = NULL;
1879
1880         /* Don't generate plymouth events if the service was already
1881          * started and we're just deserializing */
1882         if (m->n_reloading > 0)
1883                 return;
1884
1885         if (m->running_as != SYSTEMD_SYSTEM)
1886                 return;
1887
1888         if (u->type != UNIT_SERVICE &&
1889             u->type != UNIT_MOUNT &&
1890             u->type != UNIT_SWAP)
1891                 return;
1892
1893         /* We set SOCK_NONBLOCK here so that we rather drop the
1894          * message then wait for plymouth */
1895         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1896         if (fd < 0) {
1897                 log_error("socket() failed: %m");
1898                 return;
1899         }
1900
1901         zero(sa);
1902         sa.sa.sa_family = AF_UNIX;
1903         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1904         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1905
1906                 if (errno != EPIPE &&
1907                     errno != EAGAIN &&
1908                     errno != ENOENT &&
1909                     errno != ECONNREFUSED &&
1910                     errno != ECONNRESET &&
1911                     errno != ECONNABORTED)
1912                         log_error("connect() failed: %m");
1913
1914                 goto finish;
1915         }
1916
1917         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1918                 log_oom();
1919                 goto finish;
1920         }
1921
1922         errno = 0;
1923         if (write(fd, message, n + 1) != n + 1) {
1924
1925                 if (errno != EPIPE &&
1926                     errno != EAGAIN &&
1927                     errno != ENOENT &&
1928                     errno != ECONNREFUSED &&
1929                     errno != ECONNRESET &&
1930                     errno != ECONNABORTED)
1931                         log_error("Failed to write Plymouth message: %m");
1932
1933                 goto finish;
1934         }
1935
1936 finish:
1937         if (fd >= 0)
1938                 close_nointr_nofail(fd);
1939
1940         free(message);
1941 }
1942
1943 void manager_dispatch_bus_name_owner_changed(
1944                 Manager *m,
1945                 const char *name,
1946                 const char* old_owner,
1947                 const char *new_owner) {
1948
1949         Unit *u;
1950
1951         assert(m);
1952         assert(name);
1953
1954         if (!(u = hashmap_get(m->watch_bus, name)))
1955                 return;
1956
1957         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1958 }
1959
1960 void manager_dispatch_bus_query_pid_done(
1961                 Manager *m,
1962                 const char *name,
1963                 pid_t pid) {
1964
1965         Unit *u;
1966
1967         assert(m);
1968         assert(name);
1969         assert(pid >= 1);
1970
1971         if (!(u = hashmap_get(m->watch_bus, name)))
1972                 return;
1973
1974         UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1975 }
1976
1977 int manager_open_serialization(Manager *m, FILE **_f) {
1978         char *path = NULL;
1979         int fd;
1980         FILE *f;
1981
1982         assert(_f);
1983
1984         if (m->running_as == SYSTEMD_SYSTEM)
1985                 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1986         else
1987                 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1988
1989         if (!path)
1990                 return -ENOMEM;
1991
1992         RUN_WITH_UMASK(0077) {
1993                 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1994         }
1995
1996         if (fd < 0) {
1997                 free(path);
1998                 return -errno;
1999         }
2000
2001         unlink(path);
2002
2003         log_debug("Serializing state to %s", path);
2004         free(path);
2005
2006         f = fdopen(fd, "w+");
2007         if (!f)
2008                 return -errno;
2009
2010         *_f = f;
2011
2012         return 0;
2013 }
2014
2015 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2016         Iterator i;
2017         Unit *u;
2018         const char *t;
2019         char **e;
2020         int r;
2021
2022         assert(m);
2023         assert(f);
2024         assert(fds);
2025
2026         m->n_reloading ++;
2027
2028         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2029         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2030         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2031         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2032
2033         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2034         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2035         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2036         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2037
2038         if (!in_initrd()) {
2039                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2040                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2041         }
2042
2043         if (!switching_root) {
2044                 STRV_FOREACH(e, m->environment) {
2045                         _cleanup_free_ char *ce;
2046
2047                         ce = cescape(*e);
2048                         if (ce)
2049                                 fprintf(f, "env=%s\n", *e);
2050                 }
2051         }
2052
2053         fputc('\n', f);
2054
2055         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2056                 if (u->id != t)
2057                         continue;
2058
2059                 if (!unit_can_serialize(u))
2060                         continue;
2061
2062                 /* Start marker */
2063                 fputs(u->id, f);
2064                 fputc('\n', f);
2065
2066                 if ((r = unit_serialize(u, f, fds, !switching_root)) < 0) {
2067                         m->n_reloading --;
2068                         return r;
2069                 }
2070         }
2071
2072         assert(m->n_reloading > 0);
2073         m->n_reloading --;
2074
2075         if (ferror(f))
2076                 return -EIO;
2077
2078         r = bus_fdset_add_all(m, fds);
2079         if (r < 0)
2080                 return r;
2081
2082         return 0;
2083 }
2084
2085 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2086         int r = 0;
2087
2088         assert(m);
2089         assert(f);
2090
2091         log_debug("Deserializing state...");
2092
2093         m->n_reloading ++;
2094
2095         for (;;) {
2096                 char line[LINE_MAX], *l;
2097
2098                 if (!fgets(line, sizeof(line), f)) {
2099                         if (feof(f))
2100                                 r = 0;
2101                         else
2102                                 r = -errno;
2103
2104                         goto finish;
2105                 }
2106
2107                 char_array_0(line);
2108                 l = strstrip(line);
2109
2110                 if (l[0] == 0)
2111                         break;
2112
2113                 if (startswith(l, "current-job-id=")) {
2114                         uint32_t id;
2115
2116                         if (safe_atou32(l+15, &id) < 0)
2117                                 log_debug("Failed to parse current job id value %s", l+15);
2118                         else
2119                                 m->current_job_id = MAX(m->current_job_id, id);
2120                 } else if (startswith(l, "n-installed-jobs=")) {
2121                         uint32_t n;
2122
2123                         if (safe_atou32(l+17, &n) < 0)
2124                                 log_debug("Failed to parse installed jobs counter %s", l+17);
2125                         else
2126                                 m->n_installed_jobs += n;
2127                 } else if (startswith(l, "n-failed-jobs=")) {
2128                         uint32_t n;
2129
2130                         if (safe_atou32(l+14, &n) < 0)
2131                                 log_debug("Failed to parse failed jobs counter %s", l+14);
2132                         else
2133                                 m->n_failed_jobs += n;
2134                 } else if (startswith(l, "taint-usr=")) {
2135                         int b;
2136
2137                         if ((b = parse_boolean(l+10)) < 0)
2138                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2139                         else
2140                                 m->taint_usr = m->taint_usr || b;
2141                 } else if (startswith(l, "firmware-timestamp="))
2142                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2143                 else if (startswith(l, "loader-timestamp="))
2144                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2145                 else if (startswith(l, "kernel-timestamp="))
2146                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2147                 else if (startswith(l, "initrd-timestamp="))
2148                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2149                 else if (startswith(l, "userspace-timestamp="))
2150                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2151                 else if (startswith(l, "finish-timestamp="))
2152                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2153                 else if (startswith(l, "env=")) {
2154                         _cleanup_free_ char *uce = NULL;
2155                         char **e;
2156
2157                         uce = cunescape(l+4);
2158                         if (!uce) {
2159                                 r = -ENOMEM;
2160                                 goto finish;
2161                         }
2162
2163                         e = strv_env_set(m->environment, uce);
2164                         if (!e) {
2165                                 r = -ENOMEM;
2166                                 goto finish;
2167                         }
2168
2169                         strv_free(m->environment);
2170                         m->environment = e;
2171                 } else
2172                         log_debug("Unknown serialization item '%s'", l);
2173         }
2174
2175         for (;;) {
2176                 Unit *u;
2177                 char name[UNIT_NAME_MAX+2];
2178
2179                 /* Start marker */
2180                 if (!fgets(name, sizeof(name), f)) {
2181                         if (feof(f))
2182                                 r = 0;
2183                         else
2184                                 r = -errno;
2185
2186                         goto finish;
2187                 }
2188
2189                 char_array_0(name);
2190
2191                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2192                 if (r < 0)
2193                         goto finish;
2194
2195                 r = unit_deserialize(u, f, fds);
2196                 if (r < 0)
2197                         goto finish;
2198         }
2199
2200 finish:
2201         if (ferror(f)) {
2202                 r = -EIO;
2203                 goto finish;
2204         }
2205
2206         assert(m->n_reloading > 0);
2207         m->n_reloading --;
2208
2209         return r;
2210 }
2211
2212 int manager_distribute_fds(Manager *m, FDSet *fds) {
2213         Unit *u;
2214         Iterator i;
2215         int r;
2216
2217         assert(m);
2218
2219         HASHMAP_FOREACH(u, m->units, i) {
2220
2221                 if (fdset_size(fds) <= 0)
2222                         break;
2223
2224                 if (UNIT_VTABLE(u)->distribute_fds) {
2225                         r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2226                         if (r < 0)
2227                                 return r;
2228                 }
2229         }
2230
2231         return 0;
2232 }
2233
2234 int manager_reload(Manager *m) {
2235         int r, q;
2236         FILE *f;
2237         FDSet *fds;
2238
2239         assert(m);
2240
2241         r = manager_open_serialization(m, &f);
2242         if (r < 0)
2243                 return r;
2244
2245         m->n_reloading ++;
2246
2247         fds = fdset_new();
2248         if (!fds) {
2249                 m->n_reloading --;
2250                 r = -ENOMEM;
2251                 goto finish;
2252         }
2253
2254         r = manager_serialize(m, f, fds, false);
2255         if (r < 0) {
2256                 m->n_reloading --;
2257                 goto finish;
2258         }
2259
2260         if (fseeko(f, 0, SEEK_SET) < 0) {
2261                 m->n_reloading --;
2262                 r = -errno;
2263                 goto finish;
2264         }
2265
2266         /* From here on there is no way back. */
2267         manager_clear_jobs_and_units(m);
2268         manager_undo_generators(m);
2269         lookup_paths_free(&m->lookup_paths);
2270
2271         /* Find new unit paths */
2272         manager_run_generators(m);
2273
2274         q = lookup_paths_init(
2275                         &m->lookup_paths, m->running_as, true,
2276                         m->generator_unit_path,
2277                         m->generator_unit_path_early,
2278                         m->generator_unit_path_late);
2279         if (q < 0)
2280                 r = q;
2281
2282         manager_build_unit_path_cache(m);
2283
2284         /* First, enumerate what we can from all config files */
2285         q = manager_enumerate(m);
2286         if (q < 0)
2287                 r = q;
2288
2289         /* Second, deserialize our stored data */
2290         q = manager_deserialize(m, f, fds);
2291         if (q < 0)
2292                 r = q;
2293
2294         fclose(f);
2295         f = NULL;
2296
2297         /* Third, fire things up! */
2298         q = manager_coldplug(m);
2299         if (q < 0)
2300                 r = q;
2301
2302         assert(m->n_reloading > 0);
2303         m->n_reloading--;
2304
2305 finish:
2306         if (f)
2307                 fclose(f);
2308
2309         if (fds)
2310                 fdset_free(fds);
2311
2312         return r;
2313 }
2314
2315 static bool manager_is_booting_or_shutting_down(Manager *m) {
2316         Unit *u;
2317
2318         assert(m);
2319
2320         /* Is the initial job still around? */
2321         if (manager_get_job(m, m->default_unit_job_id))
2322                 return true;
2323
2324         /* Is there a job for the shutdown target? */
2325         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2326         if (u)
2327                 return !!u->job;
2328
2329         return false;
2330 }
2331
2332 bool manager_is_reloading_or_reexecuting(Manager *m) {
2333         assert(m);
2334
2335         return m->n_reloading != 0;
2336 }
2337
2338 void manager_reset_failed(Manager *m) {
2339         Unit *u;
2340         Iterator i;
2341
2342         assert(m);
2343
2344         HASHMAP_FOREACH(u, m->units, i)
2345                 unit_reset_failed(u);
2346 }
2347
2348 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2349         Unit *u;
2350
2351         assert(m);
2352         assert(name);
2353
2354         /* Returns true if the unit is inactive or going down */
2355         u = manager_get_unit(m, name);
2356         if (!u)
2357                 return true;
2358
2359         return unit_inactive_or_pending(u);
2360 }
2361
2362 void manager_check_finished(Manager *m) {
2363         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2364         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2365
2366         assert(m);
2367
2368         if (m->n_running_jobs == 0)
2369                 manager_unwatch_jobs_in_progress(m);
2370
2371         if (hashmap_size(m->jobs) > 0) {
2372                 manager_jobs_in_progress_mod_timer(m);
2373                 return;
2374         }
2375
2376         /* Notify Type=idle units that we are done now */
2377         close_pipe(m->idle_pipe);
2378
2379         /* Turn off confirm spawn now */
2380         m->confirm_spawn = false;
2381
2382         if (dual_timestamp_is_set(&m->finish_timestamp))
2383                 return;
2384
2385         dual_timestamp_get(&m->finish_timestamp);
2386
2387         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2388
2389                 /* Note that m->kernel_usec.monotonic is always at 0,
2390                  * and m->firmware_usec.monotonic and
2391                  * m->loader_usec.monotonic should be considered
2392                  * negative values. */
2393
2394                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2395                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2396                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2397                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2398
2399                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2400
2401                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2402                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2403
2404                         if (!log_on_console())
2405                                 log_struct(LOG_INFO,
2406                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2407                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2408                                            "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2409                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2410                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2411                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2412                                            format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2413                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2414                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2415                                            NULL);
2416                 } else {
2417                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2418                         initrd_usec = 0;
2419
2420                         if (!log_on_console())
2421                                 log_struct(LOG_INFO,
2422                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2423                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2424                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2425                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2426                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2427                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2428                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2429                                            NULL);
2430                 }
2431         } else {
2432                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2433                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2434
2435                 if (!log_on_console())
2436                         log_struct(LOG_INFO,
2437                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2438                                    "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2439                                    "MESSAGE=Startup finished in %s.",
2440                                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2441                                    NULL);
2442         }
2443
2444         bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2445
2446         sd_notifyf(false,
2447                    "READY=1\nSTATUS=Startup finished in %s.",
2448                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2449 }
2450
2451 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2452         char *p;
2453         int r;
2454
2455         assert(m);
2456         assert(generator);
2457         assert(name);
2458
2459         if (*generator)
2460                 return 0;
2461
2462         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2463
2464                 p = strappend("/run/systemd/", name);
2465                 if (!p)
2466                         return log_oom();
2467
2468                 r = mkdir_p_label(p, 0755);
2469                 if (r < 0) {
2470                         log_error("Failed to create generator directory %s: %s",
2471                                   p, strerror(-r));
2472                         free(p);
2473                         return r;
2474                 }
2475         } else {
2476                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2477                 if (!p)
2478                         return log_oom();
2479
2480                 if (!mkdtemp(p)) {
2481                         log_error("Failed to create generator directory %s: %m",
2482                                   p);
2483                         free(p);
2484                         return -errno;
2485                 }
2486         }
2487
2488         *generator = p;
2489         return 0;
2490 }
2491
2492 static void trim_generator_dir(Manager *m, char **generator) {
2493         assert(m);
2494         assert(generator);
2495
2496         if (!*generator)
2497                 return;
2498
2499         if (rmdir(*generator) >= 0) {
2500                 free(*generator);
2501                 *generator = NULL;
2502         }
2503
2504         return;
2505 }
2506
2507 void manager_run_generators(Manager *m) {
2508         DIR *d = NULL;
2509         const char *generator_path;
2510         const char *argv[5];
2511         int r;
2512
2513         assert(m);
2514
2515         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2516         d = opendir(generator_path);
2517         if (!d) {
2518                 if (errno == ENOENT)
2519                         return;
2520
2521                 log_error("Failed to enumerate generator directory %s: %m",
2522                           generator_path);
2523                 return;
2524         }
2525
2526         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2527         if (r < 0)
2528                 goto finish;
2529
2530         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2531         if (r < 0)
2532                 goto finish;
2533
2534         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2535         if (r < 0)
2536                 goto finish;
2537
2538         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2539         argv[1] = m->generator_unit_path;
2540         argv[2] = m->generator_unit_path_early;
2541         argv[3] = m->generator_unit_path_late;
2542         argv[4] = NULL;
2543
2544         RUN_WITH_UMASK(0022) {
2545                 execute_directory(generator_path, d, (char**) argv);
2546         }
2547
2548         trim_generator_dir(m, &m->generator_unit_path);
2549         trim_generator_dir(m, &m->generator_unit_path_early);
2550         trim_generator_dir(m, &m->generator_unit_path_late);
2551
2552 finish:
2553         if (d)
2554                 closedir(d);
2555 }
2556
2557 static void remove_generator_dir(Manager *m, char **generator) {
2558         assert(m);
2559         assert(generator);
2560
2561         if (!*generator)
2562                 return;
2563
2564         strv_remove(m->lookup_paths.unit_path, *generator);
2565         rm_rf(*generator, false, true, false);
2566
2567         free(*generator);
2568         *generator = NULL;
2569 }
2570
2571 void manager_undo_generators(Manager *m) {
2572         assert(m);
2573
2574         remove_generator_dir(m, &m->generator_unit_path);
2575         remove_generator_dir(m, &m->generator_unit_path_early);
2576         remove_generator_dir(m, &m->generator_unit_path_late);
2577 }
2578
2579 int manager_set_default_environment(Manager *m, char **environment) {
2580
2581         char **e = NULL;
2582         assert(m);
2583         e = strv_env_merge(2, m->environment, environment);
2584         if (!e)
2585                 return -ENOMEM;
2586         strv_free(m->environment);
2587         m->environment = e;
2588         return 0;
2589 }
2590
2591 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2592         int i;
2593
2594         assert(m);
2595
2596         for (i = 0; i < RLIMIT_NLIMITS; i++) {
2597                 if (!default_rlimit[i])
2598                         continue;
2599
2600                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2601                 if (!m->rlimit[i])
2602                         return -ENOMEM;
2603         }
2604
2605         return 0;
2606 }
2607
2608 void manager_recheck_journal(Manager *m) {
2609         Unit *u;
2610
2611         assert(m);
2612
2613         if (m->running_as != SYSTEMD_SYSTEM)
2614                 return;
2615
2616         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2617         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2618                 log_close_journal();
2619                 return;
2620         }
2621
2622         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2623         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2624                 log_close_journal();
2625                 return;
2626         }
2627
2628         /* Hmm, OK, so the socket is fully up and the service is up
2629          * too, then let's make use of the thing. */
2630         log_open();
2631 }
2632
2633 void manager_set_show_status(Manager *m, bool b) {
2634         assert(m);
2635
2636         if (m->running_as != SYSTEMD_SYSTEM)
2637                 return;
2638
2639         m->show_status = b;
2640
2641         if (b)
2642                 touch("/run/systemd/show-status");
2643         else
2644                 unlink("/run/systemd/show-status");
2645 }
2646
2647 static bool manager_get_show_status(Manager *m) {
2648         assert(m);
2649
2650         if (m->running_as != SYSTEMD_SYSTEM)
2651                 return false;
2652
2653         if (m->show_status)
2654                 return true;
2655
2656         /* If Plymouth is running make sure we show the status, so
2657          * that there's something nice to see when people press Esc */
2658
2659         return plymouth_running();
2660 }
2661
2662 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2663         va_list ap;
2664
2665         if (!manager_get_show_status(m))
2666                 return;
2667
2668         /* XXX We should totally drop the check for ephemeral here
2669          * and thus effectively make 'Type=idle' pointless. */
2670         if (ephemeral && m->n_on_console > 0)
2671                 return;
2672
2673         if (!manager_is_booting_or_shutting_down(m))
2674                 return;
2675
2676         va_start(ap, format);
2677         status_vprintf(status, true, ephemeral, format, ap);
2678         va_end(ap);
2679 }
2680
2681 void watch_init(Watch *w) {
2682         assert(w);
2683
2684         w->type = WATCH_INVALID;
2685         w->fd = -1;
2686 }