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