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