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