src/core/manager.c

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