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