src/core/manager.c

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