src/core/manager.c

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