src/core/manager.c

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