src/core/manager.c

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