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