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