src/core/manager.c

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