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