src/core/manager.c

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