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