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