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