src/core/manager.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <linux/kd.h>
  23 #include <signal.h>
  24 #include <string.h>
  25 #include <sys/epoll.h>
  26 #include <sys/inotify.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/reboot.h>
  29 #include <sys/timerfd.h>
  30 #include <sys/wait.h>
  31 #include <unistd.h>
  32
  33 #ifdef HAVE_AUDIT
  34 #include <libaudit.h>
  35 #endif
  36
  37 #include "sd-daemon.h"
  38 #include "sd-messages.h"
  39 #include "sd-path.h"
  40
  41 #include "alloc-util.h"
  42 #include "audit-fd.h"
  43 #include "boot-timestamps.h"
  44 #include "bus-common-errors.h"
  45 #include "bus-error.h"
  46 #include "bus-kernel.h"
  47 #include "bus-util.h"
  48 #include "clean-ipc.h"
  49 #include "dbus-job.h"
  50 #include "dbus-manager.h"
  51 #include "dbus-unit.h"
  52 #include "dbus.h"
  53 #include "dirent-util.h"
  54 #include "env-util.h"
  55 #include "escape.h"
  56 #include "execute.h"
  57 #include "exec-util.h"
  58 #include "exit-status.h"
  59 #include "fd-util.h"
  60 #include "fileio.h"
  61 #include "fs-util.h"
  62 #include "hashmap.h"
  63 #include "io-util.h"
  64 #include "locale-setup.h"
  65 #include "log.h"
  66 #include "macro.h"
  67 #include "manager.h"
  68 #include "missing.h"
  69 #include "mkdir.h"
  70 #include "parse-util.h"
  71 #include "path-lookup.h"
  72 #include "path-util.h"
  73 #include "process-util.h"
  74 #include "ratelimit.h"
  75 #include "rm-rf.h"
  76 #include "signal-util.h"
  77 #include "special.h"
  78 #include "stat-util.h"
  79 #include "string-table.h"
  80 #include "string-util.h"
  81 #include "strv.h"
  82 #include "terminal-util.h"
  83 #include "time-util.h"
  84 #include "transaction.h"
  85 #include "umask-util.h"
  86 #include "unit-name.h"
  87 #include "user-util.h"
  88 #include "util.h"
  89 #include "virt.h"
  90 #include "watchdog.h"
  91
  92 #define NOTIFY_RCVBUF_SIZE (8*1024*1024)
  93 #define CGROUPS_AGENT_RCVBUF_SIZE (8*1024*1024)
  94
  95 /* Initial delay and the interval for printing status messages about running jobs */
  96 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
  97 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
  98 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
  99
 100 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 101 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 102 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 103 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 104 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 105 static int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 106 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
 107 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
 108 static int manager_run_environment_generators(Manager *m);
 109 static int manager_run_generators(Manager *m);
 110
 111 static void manager_watch_jobs_in_progress(Manager *m) {
 112         usec_t next;
 113         int r;
 114
 115         assert(m);
 116
 117         /* We do not want to show the cylon animation if the user
 118          * needs to confirm service executions otherwise confirmation
 119          * messages will be screwed by the cylon animation. */
 120         if (!manager_is_confirm_spawn_disabled(m))
 121                 return;
 122
 123         if (m->jobs_in_progress_event_source)
 124                 return;
 125
 126         next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
 127         r = sd_event_add_time(
 128                         m->event,
 129                         &m->jobs_in_progress_event_source,
 130                         CLOCK_MONOTONIC,
 131                         next, 0,
 132                         manager_dispatch_jobs_in_progress, m);
 133         if (r < 0)
 134                 return;
 135
 136         (void) sd_event_source_set_description(m->jobs_in_progress_event_source, "manager-jobs-in-progress");
 137 }
 138
 139 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED)-1) + sizeof(ANSI_HIGHLIGHT_RED)-1 + 2*(sizeof(ANSI_NORMAL)-1))
 140
 141 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
 142         char *p = buffer;
 143
 144         assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
 145         assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
 146
 147         if (pos > 1) {
 148                 if (pos > 2)
 149                         p = mempset(p, ' ', pos-2);
 150                 if (log_get_show_color())
 151                         p = stpcpy(p, ANSI_RED);
 152                 *p++ = '*';
 153         }
 154
 155         if (pos > 0 && pos <= width) {
 156                 if (log_get_show_color())
 157                         p = stpcpy(p, ANSI_HIGHLIGHT_RED);
 158                 *p++ = '*';
 159         }
 160
 161         if (log_get_show_color())
 162                 p = stpcpy(p, ANSI_NORMAL);
 163
 164         if (pos < width) {
 165                 if (log_get_show_color())
 166                         p = stpcpy(p, ANSI_RED);
 167                 *p++ = '*';
 168                 if (pos < width-1)
 169                         p = mempset(p, ' ', width-1-pos);
 170                 if (log_get_show_color())
 171                         strcpy(p, ANSI_NORMAL);
 172         }
 173 }
 174
 175 void manager_flip_auto_status(Manager *m, bool enable) {
 176         assert(m);
 177
 178         if (enable) {
 179                 if (m->show_status == SHOW_STATUS_AUTO)
 180                         manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
 181         } else {
 182                 if (m->show_status == SHOW_STATUS_TEMPORARY)
 183                         manager_set_show_status(m, SHOW_STATUS_AUTO);
 184         }
 185 }
 186
 187 static void manager_print_jobs_in_progress(Manager *m) {
 188         _cleanup_free_ char *job_of_n = NULL;
 189         Iterator i;
 190         Job *j;
 191         unsigned counter = 0, print_nr;
 192         char cylon[6 + CYLON_BUFFER_EXTRA + 1];
 193         unsigned cylon_pos;
 194         char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
 195         uint64_t x;
 196
 197         assert(m);
 198         assert(m->n_running_jobs > 0);
 199
 200         manager_flip_auto_status(m, true);
 201
 202         print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
 203
 204         HASHMAP_FOREACH(j, m->jobs, i)
 205                 if (j->state == JOB_RUNNING && counter++ == print_nr)
 206                         break;
 207
 208         /* m->n_running_jobs must be consistent with the contents of m->jobs,
 209          * so the above loop must have succeeded in finding j. */
 210         assert(counter == print_nr + 1);
 211         assert(j);
 212
 213         cylon_pos = m->jobs_in_progress_iteration % 14;
 214         if (cylon_pos >= 8)
 215                 cylon_pos = 14 - cylon_pos;
 216         draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
 217
 218         m->jobs_in_progress_iteration++;
 219
 220         if (m->n_running_jobs > 1) {
 221                 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
 222                         job_of_n = NULL;
 223         }
 224
 225         format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
 226         if (job_get_timeout(j, &x) > 0)
 227                 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
 228
 229         manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
 230                               "%sA %s job is running for %s (%s / %s)",
 231                               strempty(job_of_n),
 232                               job_type_to_string(j->type),
 233                               unit_description(j->unit),
 234                               time, limit);
 235 }
 236
 237 static int have_ask_password(void) {
 238         _cleanup_closedir_ DIR *dir;
 239         struct dirent *de;
 240
 241         dir = opendir("/run/systemd/ask-password");
 242         if (!dir) {
 243                 if (errno == ENOENT)
 244                         return false;
 245                 else
 246                         return -errno;
 247         }
 248
 249         FOREACH_DIRENT_ALL(de, dir, return -errno) {
 250                 if (startswith(de->d_name, "ask."))
 251                         return true;
 252         }
 253         return false;
 254 }
 255
 256 static int manager_dispatch_ask_password_fd(sd_event_source *source,
 257                                             int fd, uint32_t revents, void *userdata) {
 258         Manager *m = userdata;
 259
 260         assert(m);
 261
 262         flush_fd(fd);
 263
 264         m->have_ask_password = have_ask_password();
 265         if (m->have_ask_password < 0)
 266                 /* Log error but continue. Negative have_ask_password
 267                  * is treated as unknown status. */
 268                 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
 269
 270         return 0;
 271 }
 272
 273 static void manager_close_ask_password(Manager *m) {
 274         assert(m);
 275
 276         m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
 277         m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
 278         m->have_ask_password = -EINVAL;
 279 }
 280
 281 static int manager_check_ask_password(Manager *m) {
 282         int r;
 283
 284         assert(m);
 285
 286         if (!m->ask_password_event_source) {
 287                 assert(m->ask_password_inotify_fd < 0);
 288
 289                 mkdir_p_label("/run/systemd/ask-password", 0755);
 290
 291                 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
 292                 if (m->ask_password_inotify_fd < 0)
 293                         return log_error_errno(errno, "inotify_init1() failed: %m");
 294
 295                 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
 296                         log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
 297                         manager_close_ask_password(m);
 298                         return -errno;
 299                 }
 300
 301                 r = sd_event_add_io(m->event, &m->ask_password_event_source,
 302                                     m->ask_password_inotify_fd, EPOLLIN,
 303                                     manager_dispatch_ask_password_fd, m);
 304                 if (r < 0) {
 305                         log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
 306                         manager_close_ask_password(m);
 307                         return -errno;
 308                 }
 309
 310                 (void) sd_event_source_set_description(m->ask_password_event_source, "manager-ask-password");
 311
 312                 /* Queries might have been added meanwhile... */
 313                 manager_dispatch_ask_password_fd(m->ask_password_event_source,
 314                                                  m->ask_password_inotify_fd, EPOLLIN, m);
 315         }
 316
 317         return m->have_ask_password;
 318 }
 319
 320 static int manager_watch_idle_pipe(Manager *m) {
 321         int r;
 322
 323         assert(m);
 324
 325         if (m->idle_pipe_event_source)
 326                 return 0;
 327
 328         if (m->idle_pipe[2] < 0)
 329                 return 0;
 330
 331         r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
 332         if (r < 0)
 333                 return log_error_errno(r, "Failed to watch idle pipe: %m");
 334
 335         (void) sd_event_source_set_description(m->idle_pipe_event_source, "manager-idle-pipe");
 336
 337         return 0;
 338 }
 339
 340 static void manager_close_idle_pipe(Manager *m) {
 341         assert(m);
 342
 343         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
 344
 345         safe_close_pair(m->idle_pipe);
 346         safe_close_pair(m->idle_pipe + 2);
 347 }
 348
 349 static int manager_setup_time_change(Manager *m) {
 350         int r;
 351
 352         /* We only care for the cancellation event, hence we set the
 353          * timeout to the latest possible value. */
 354         struct itimerspec its = {
 355                 .it_value.tv_sec = TIME_T_MAX,
 356         };
 357
 358         assert(m);
 359         assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
 360
 361         if (m->test_run)
 362                 return 0;
 363
 364         /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
 365          * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
 366
 367         m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 368         if (m->time_change_fd < 0)
 369                 return log_error_errno(errno, "Failed to create timerfd: %m");
 370
 371         if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 372                 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
 373                 m->time_change_fd = safe_close(m->time_change_fd);
 374                 return 0;
 375         }
 376
 377         r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
 378         if (r < 0)
 379                 return log_error_errno(r, "Failed to create time change event source: %m");
 380
 381         (void) sd_event_source_set_description(m->time_change_event_source, "manager-time-change");
 382
 383         log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
 384
 385         return 0;
 386 }
 387
 388 static int enable_special_signals(Manager *m) {
 389         _cleanup_close_ int fd = -1;
 390
 391         assert(m);
 392
 393         if (m->test_run)
 394                 return 0;
 395
 396         /* Enable that we get SIGINT on control-alt-del. In containers
 397          * this will fail with EPERM (older) or EINVAL (newer), so
 398          * ignore that. */
 399         if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
 400                 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
 401
 402         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 403         if (fd < 0) {
 404                 /* Support systems without virtual console */
 405                 if (fd != -ENOENT)
 406                         log_warning_errno(errno, "Failed to open /dev/tty0: %m");
 407         } else {
 408                 /* Enable that we get SIGWINCH on kbrequest */
 409                 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
 410                         log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
 411         }
 412
 413         return 0;
 414 }
 415
 416 static int manager_setup_signals(Manager *m) {
 417         struct sigaction sa = {
 418                 .sa_handler = SIG_DFL,
 419                 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
 420         };
 421         sigset_t mask;
 422         int r;
 423
 424         assert(m);
 425
 426         assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 427
 428         /* We make liberal use of realtime signals here. On
 429          * Linux/glibc we have 30 of them (with the exception of Linux
 430          * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
 431          * (aka SIGRTMAX). */
 432
 433         assert_se(sigemptyset(&mask) == 0);
 434         sigset_add_many(&mask,
 435                         SIGCHLD,     /* Child died */
 436                         SIGTERM,     /* Reexecute daemon */
 437                         SIGHUP,      /* Reload configuration */
 438                         SIGUSR1,     /* systemd/upstart: reconnect to D-Bus */
 439                         SIGUSR2,     /* systemd: dump status */
 440                         SIGINT,      /* Kernel sends us this on control-alt-del */
 441                         SIGWINCH,    /* Kernel sends us this on kbrequest (alt-arrowup) */
 442                         SIGPWR,      /* Some kernel drivers and upsd send us this on power failure */
 443
 444                         SIGRTMIN+0,  /* systemd: start default.target */
 445                         SIGRTMIN+1,  /* systemd: isolate rescue.target */
 446                         SIGRTMIN+2,  /* systemd: isolate emergency.target */
 447                         SIGRTMIN+3,  /* systemd: start halt.target */
 448                         SIGRTMIN+4,  /* systemd: start poweroff.target */
 449                         SIGRTMIN+5,  /* systemd: start reboot.target */
 450                         SIGRTMIN+6,  /* systemd: start kexec.target */
 451
 452                         /* ... space for more special targets ... */
 453
 454                         SIGRTMIN+13, /* systemd: Immediate halt */
 455                         SIGRTMIN+14, /* systemd: Immediate poweroff */
 456                         SIGRTMIN+15, /* systemd: Immediate reboot */
 457                         SIGRTMIN+16, /* systemd: Immediate kexec */
 458
 459                         /* ... space for more immediate system state changes ... */
 460
 461                         SIGRTMIN+20, /* systemd: enable status messages */
 462                         SIGRTMIN+21, /* systemd: disable status messages */
 463                         SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
 464                         SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
 465                         SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
 466
 467                         /* .. one free signal here ... */
 468
 469 #if !defined(__hppa64__) && !defined(__hppa__)
 470                         /* Apparently Linux on hppa has fewer RT
 471                          * signals (SIGRTMAX is SIGRTMIN+25 there),
 472                          * hence let's not try to make use of them
 473                          * here. Since these commands are accessible
 474                          * by different means and only really a safety
 475                          * net, the missing functionality on hppa
 476                          * shouldn't matter. */
 477
 478                         SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
 479                         SIGRTMIN+27, /* systemd: set log target to console */
 480                         SIGRTMIN+28, /* systemd: set log target to kmsg */
 481                         SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
 482
 483                         /* ... one free signal here SIGRTMIN+30 ... */
 484 #endif
 485                         -1);
 486         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
 487
 488         m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 489         if (m->signal_fd < 0)
 490                 return -errno;
 491
 492         r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
 493         if (r < 0)
 494                 return r;
 495
 496         (void) sd_event_source_set_description(m->signal_event_source, "manager-signal");
 497
 498         /* Process signals a bit earlier than the rest of things, but later than notify_fd processing, so that the
 499          * notify processing can still figure out to which process/service a message belongs, before we reap the
 500          * process. Also, process this before handling cgroup notifications, so that we always collect child exit
 501          * status information before detecting that there's no process in a cgroup. */
 502         r = sd_event_source_set_priority(m->signal_event_source, SD_EVENT_PRIORITY_NORMAL-6);
 503         if (r < 0)
 504                 return r;
 505
 506         if (MANAGER_IS_SYSTEM(m))
 507                 return enable_special_signals(m);
 508
 509         return 0;
 510 }
 511
 512 static void manager_clean_environment(Manager *m) {
 513         assert(m);
 514
 515         /* Let's remove some environment variables that we
 516          * need ourselves to communicate with our clients */
 517         strv_env_unset_many(
 518                         m->environment,
 519                         "NOTIFY_SOCKET",
 520                         "MAINPID",
 521                         "MANAGERPID",
 522                         "LISTEN_PID",
 523                         "LISTEN_FDS",
 524                         "LISTEN_FDNAMES",
 525                         "WATCHDOG_PID",
 526                         "WATCHDOG_USEC",
 527                         "INVOCATION_ID",
 528                         NULL);
 529 }
 530
 531 static int manager_default_environment(Manager *m) {
 532         assert(m);
 533
 534         if (MANAGER_IS_SYSTEM(m)) {
 535                 /* The system manager always starts with a clean
 536                  * environment for its children. It does not import
 537                  * the kernel's or the parents' exported variables.
 538                  *
 539                  * The initial passed environment is untouched to keep
 540                  * /proc/self/environ valid; it is used for tagging
 541                  * the init process inside containers. */
 542                 m->environment = strv_new("PATH=" DEFAULT_PATH,
 543                                           NULL);
 544
 545                 /* Import locale variables LC_*= from configuration */
 546                 locale_setup(&m->environment);
 547         } else
 548                 /* The user manager passes its own environment
 549                  * along to its children. */
 550                 m->environment = strv_copy(environ);
 551
 552         if (!m->environment)
 553                 return -ENOMEM;
 554
 555         manager_clean_environment(m);
 556         strv_sort(m->environment);
 557
 558         return 0;
 559 }
 560
 561 static int manager_setup_prefix(Manager *m) {
 562         struct table_entry {
 563                 uint64_t type;
 564                 const char *suffix;
 565         };
 566
 567         static const struct table_entry paths_system[_EXEC_DIRECTORY_MAX] = {
 568                 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_SYSTEM_RUNTIME, NULL },
 569                 [EXEC_DIRECTORY_STATE] = { SD_PATH_SYSTEM_STATE_PRIVATE, NULL },
 570                 [EXEC_DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE, NULL },
 571                 [EXEC_DIRECTORY_LOGS] = { SD_PATH_SYSTEM_STATE_LOGS, NULL },
 572                 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_SYSTEM_CONFIGURATION, NULL },
 573         };
 574
 575         static const struct table_entry paths_user[_EXEC_DIRECTORY_MAX] = {
 576                 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_USER_RUNTIME, NULL },
 577                 [EXEC_DIRECTORY_STATE] = { SD_PATH_USER_CONFIGURATION, NULL },
 578                 [EXEC_DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE, NULL },
 579                 [EXEC_DIRECTORY_LOGS] = { SD_PATH_SYSTEM_CONFIGURATION, "log" },
 580                 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_SYSTEM_CONFIGURATION, NULL },
 581         };
 582
 583         const struct table_entry *p;
 584         ExecDirectoryType i;
 585         int r;
 586
 587         assert(m);
 588
 589         if (MANAGER_IS_SYSTEM(m))
 590                 p = paths_system;
 591         else
 592                 p = paths_user;
 593
 594         for (i = 0; i < _EXEC_DIRECTORY_MAX; i++) {
 595                 r = sd_path_home(p[i].type, p[i].suffix, &m->prefix[i]);
 596                 if (r < 0)
 597                         return r;
 598         }
 599
 600         return 0;
 601 }
 602
 603 int manager_new(UnitFileScope scope, bool test_run, Manager **_m) {
 604         Manager *m;
 605         int r;
 606
 607         assert(_m);
 608         assert(IN_SET(scope, UNIT_FILE_SYSTEM, UNIT_FILE_USER));
 609
 610         m = new0(Manager, 1);
 611         if (!m)
 612                 return -ENOMEM;
 613
 614         m->unit_file_scope = scope;
 615         m->exit_code = _MANAGER_EXIT_CODE_INVALID;
 616         m->default_timer_accuracy_usec = USEC_PER_MINUTE;
 617         m->default_tasks_accounting = true;
 618         m->default_tasks_max = UINT64_MAX;
 619
 620 #ifdef ENABLE_EFI
 621         if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
 622                 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
 623 #endif
 624
 625         /* Prepare log fields we can use for structured logging */
 626         if (MANAGER_IS_SYSTEM(m)) {
 627                 m->unit_log_field = "UNIT=";
 628                 m->unit_log_format_string = "UNIT=%s";
 629
 630                 m->invocation_log_field = "INVOCATION_ID=";
 631                 m->invocation_log_format_string = "INVOCATION_ID=" SD_ID128_FORMAT_STR;
 632         } else {
 633                 m->unit_log_field = "USER_UNIT=";
 634                 m->unit_log_format_string = "USER_UNIT=%s";
 635
 636                 m->invocation_log_field = "USER_INVOCATION_ID=";
 637                 m->invocation_log_format_string = "USER_INVOCATION_ID=" SD_ID128_FORMAT_STR;
 638         }
 639
 640         m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
 641
 642         m->pin_cgroupfs_fd = m->notify_fd = m->cgroups_agent_fd = m->signal_fd = m->time_change_fd =
 643                 m->dev_autofs_fd = m->private_listen_fd = m->cgroup_inotify_fd =
 644                 m->ask_password_inotify_fd = -1;
 645
 646         m->user_lookup_fds[0] = m->user_lookup_fds[1] = -1;
 647
 648         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
 649
 650         m->have_ask_password = -EINVAL; /* we don't know */
 651         m->first_boot = -1;
 652
 653         m->test_run = test_run;
 654
 655         /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
 656         RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7);
 657
 658         r = manager_default_environment(m);
 659         if (r < 0)
 660                 goto fail;
 661
 662         r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
 663         if (r < 0)
 664                 goto fail;
 665
 666         r = hashmap_ensure_allocated(&m->jobs, NULL);
 667         if (r < 0)
 668                 goto fail;
 669
 670         r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
 671         if (r < 0)
 672                 goto fail;
 673
 674         r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
 675         if (r < 0)
 676                 goto fail;
 677
 678         r = sd_event_default(&m->event);
 679         if (r < 0)
 680                 goto fail;
 681
 682         r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
 683         if (r < 0)
 684                 goto fail;
 685
 686         r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
 687         if (r < 0)
 688                 goto fail;
 689
 690         r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
 691         if (r < 0)
 692                 goto fail;
 693
 694         (void) sd_event_source_set_description(m->run_queue_event_source, "manager-run-queue");
 695
 696         r = manager_setup_signals(m);
 697         if (r < 0)
 698                 goto fail;
 699
 700         r = manager_setup_cgroup(m);
 701         if (r < 0)
 702                 goto fail;
 703
 704         r = manager_setup_time_change(m);
 705         if (r < 0)
 706                 goto fail;
 707
 708         m->udev = udev_new();
 709         if (!m->udev) {
 710                 r = -ENOMEM;
 711                 goto fail;
 712         }
 713
 714         /* Note that we do not set up the notify fd here. We do that after deserialization,
 715          * since they might have gotten serialized across the reexec. */
 716
 717         m->taint_usr = dir_is_empty("/usr") > 0;
 718
 719         r = manager_setup_prefix(m);
 720         if (r < 0)
 721                 goto fail;
 722
 723         *_m = m;
 724         return 0;
 725
 726 fail:
 727         manager_free(m);
 728         return r;
 729 }
 730
 731 static int manager_setup_notify(Manager *m) {
 732         int r;
 733
 734         if (m->test_run)
 735                 return 0;
 736
 737         if (m->notify_fd < 0) {
 738                 _cleanup_close_ int fd = -1;
 739                 union sockaddr_union sa = {
 740                         .sa.sa_family = AF_UNIX,
 741                 };
 742                 static const int one = 1;
 743
 744                 /* First free all secondary fields */
 745                 m->notify_socket = mfree(m->notify_socket);
 746                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
 747
 748                 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 749                 if (fd < 0)
 750                         return log_error_errno(errno, "Failed to allocate notification socket: %m");
 751
 752                 fd_inc_rcvbuf(fd, NOTIFY_RCVBUF_SIZE);
 753
 754                 m->notify_socket = strappend(m->prefix[EXEC_DIRECTORY_RUNTIME], "/systemd/notify");
 755                 if (!m->notify_socket)
 756                         return log_oom();
 757
 758                 (void) mkdir_parents_label(m->notify_socket, 0755);
 759                 (void) unlink(m->notify_socket);
 760
 761                 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
 762                 r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
 763                 if (r < 0)
 764                         return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
 765
 766                 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
 767                 if (r < 0)
 768                         return log_error_errno(errno, "SO_PASSCRED failed: %m");
 769
 770                 m->notify_fd = fd;
 771                 fd = -1;
 772
 773                 log_debug("Using notification socket %s", m->notify_socket);
 774         }
 775
 776         if (!m->notify_event_source) {
 777                 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
 778                 if (r < 0)
 779                         return log_error_errno(r, "Failed to allocate notify event source: %m");
 780
 781                 /* Process notification messages a bit earlier than SIGCHLD, so that we can still identify to which
 782                  * service an exit message belongs. */
 783                 r = sd_event_source_set_priority(m->notify_event_source, SD_EVENT_PRIORITY_NORMAL-7);
 784                 if (r < 0)
 785                         return log_error_errno(r, "Failed to set priority of notify event source: %m");
 786
 787                 (void) sd_event_source_set_description(m->notify_event_source, "manager-notify");
 788         }
 789
 790         return 0;
 791 }
 792
 793 static int manager_setup_cgroups_agent(Manager *m) {
 794
 795         static const union sockaddr_union sa = {
 796                 .un.sun_family = AF_UNIX,
 797                 .un.sun_path = "/run/systemd/cgroups-agent",
 798         };
 799         int r;
 800
 801         /* This creates a listening socket we receive cgroups agent messages on. We do not use D-Bus for delivering
 802          * these messages from the cgroups agent binary to PID 1, as the cgroups agent binary is very short-living, and
 803          * each instance of it needs a new D-Bus connection. Since D-Bus connections are SOCK_STREAM/AF_UNIX, on
 804          * overloaded systems the backlog of the D-Bus socket becomes relevant, as not more than the configured number
 805          * of D-Bus connections may be queued until the kernel will start dropping further incoming connections,
 806          * possibly resulting in lost cgroups agent messages. To avoid this, we'll use a private SOCK_DGRAM/AF_UNIX
 807          * socket, where no backlog is relevant as communication may take place without an actual connect() cycle, and
 808          * we thus won't lose messages.
 809          *
 810          * Note that PID 1 will forward the agent message to system bus, so that the user systemd instance may listen
 811          * to it. The system instance hence listens on this special socket, but the user instances listen on the system
 812          * bus for these messages. */
 813
 814         if (m->test_run)
 815                 return 0;
 816
 817         if (!MANAGER_IS_SYSTEM(m))
 818                 return 0;
 819
 820         r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
 821         if (r < 0)
 822                 return log_error_errno(r, "Failed to determine whether unified cgroups hierarchy is used: %m");
 823         if (r > 0) /* We don't need this anymore on the unified hierarchy */
 824                 return 0;
 825
 826         if (m->cgroups_agent_fd < 0) {
 827                 _cleanup_close_ int fd = -1;
 828
 829                 /* First free all secondary fields */
 830                 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
 831
 832                 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 833                 if (fd < 0)
 834                         return log_error_errno(errno, "Failed to allocate cgroups agent socket: %m");
 835
 836                 fd_inc_rcvbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE);
 837
 838                 (void) unlink(sa.un.sun_path);
 839
 840                 /* Only allow root to connect to this socket */
 841                 RUN_WITH_UMASK(0077)
 842                         r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
 843                 if (r < 0)
 844                         return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
 845
 846                 m->cgroups_agent_fd = fd;
 847                 fd = -1;
 848         }
 849
 850         if (!m->cgroups_agent_event_source) {
 851                 r = sd_event_add_io(m->event, &m->cgroups_agent_event_source, m->cgroups_agent_fd, EPOLLIN, manager_dispatch_cgroups_agent_fd, m);
 852                 if (r < 0)
 853                         return log_error_errno(r, "Failed to allocate cgroups agent event source: %m");
 854
 855                 /* Process cgroups notifications early, but after having processed service notification messages or
 856                  * SIGCHLD signals, so that a cgroup running empty is always just the last safety net of notification,
 857                  * and we collected the metadata the notification and SIGCHLD stuff offers first. Also see handling of
 858                  * cgroup inotify for the unified cgroup stuff. */
 859                 r = sd_event_source_set_priority(m->cgroups_agent_event_source, SD_EVENT_PRIORITY_NORMAL-5);
 860                 if (r < 0)
 861                         return log_error_errno(r, "Failed to set priority of cgroups agent event source: %m");
 862
 863                 (void) sd_event_source_set_description(m->cgroups_agent_event_source, "manager-cgroups-agent");
 864         }
 865
 866         return 0;
 867 }
 868
 869 static int manager_setup_user_lookup_fd(Manager *m) {
 870         int r;
 871
 872         assert(m);
 873
 874         /* Set up the socket pair used for passing UID/GID resolution results from forked off processes to PID
 875          * 1. Background: we can't do name lookups (NSS) from PID 1, since it might involve IPC and thus activation,
 876          * and we might hence deadlock on ourselves. Hence we do all user/group lookups asynchronously from the forked
 877          * off processes right before executing the binaries to start. In order to be able to clean up any IPC objects
 878          * created by a unit (see RemoveIPC=) we need to know in PID 1 the used UID/GID of the executed processes,
 879          * hence we establish this communication channel so that forked off processes can pass their UID/GID
 880          * information back to PID 1. The forked off processes send their resolved UID/GID to PID 1 in a simple
 881          * datagram, along with their unit name, so that we can share one communication socket pair among all units for
 882          * this purpose.
 883          *
 884          * You might wonder why we need a communication channel for this that is independent of the usual notification
 885          * socket scheme (i.e. $NOTIFY_SOCKET). The primary difference is about trust: data sent via the $NOTIFY_SOCKET
 886          * channel is only accepted if it originates from the right unit and if reception was enabled for it. The user
 887          * lookup socket OTOH is only accessible by PID 1 and its children until they exec(), and always available.
 888          *
 889          * Note that this function is called under two circumstances: when we first initialize (in which case we
 890          * allocate both the socket pair and the event source to listen on it), and when we deserialize after a reload
 891          * (in which case the socket pair already exists but we still need to allocate the event source for it). */
 892
 893         if (m->user_lookup_fds[0] < 0) {
 894
 895                 /* Free all secondary fields */
 896                 safe_close_pair(m->user_lookup_fds);
 897                 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
 898
 899                 if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, m->user_lookup_fds) < 0)
 900                         return log_error_errno(errno, "Failed to allocate user lookup socket: %m");
 901
 902                 (void) fd_inc_rcvbuf(m->user_lookup_fds[0], NOTIFY_RCVBUF_SIZE);
 903         }
 904
 905         if (!m->user_lookup_event_source) {
 906                 r = sd_event_add_io(m->event, &m->user_lookup_event_source, m->user_lookup_fds[0], EPOLLIN, manager_dispatch_user_lookup_fd, m);
 907                 if (r < 0)
 908                         return log_error_errno(errno, "Failed to allocate user lookup event source: %m");
 909
 910                 /* Process even earlier than the notify event source, so that we always know first about valid UID/GID
 911                  * resolutions */
 912                 r = sd_event_source_set_priority(m->user_lookup_event_source, SD_EVENT_PRIORITY_NORMAL-8);
 913                 if (r < 0)
 914                         return log_error_errno(errno, "Failed to set priority ot user lookup event source: %m");
 915
 916                 (void) sd_event_source_set_description(m->user_lookup_event_source, "user-lookup");
 917         }
 918
 919         return 0;
 920 }
 921
 922 static int manager_connect_bus(Manager *m, bool reexecuting) {
 923         bool try_bus_connect;
 924
 925         assert(m);
 926
 927         if (m->test_run)
 928                 return 0;
 929
 930         try_bus_connect =
 931                 reexecuting ||
 932                 (MANAGER_IS_USER(m) && getenv("DBUS_SESSION_BUS_ADDRESS"));
 933
 934         /* Try to connect to the buses, if possible. */
 935         return bus_init(m, try_bus_connect);
 936 }
 937
 938 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
 939         Unit *u;
 940         unsigned n = 0;
 941
 942         assert(m);
 943
 944         while ((u = m->cleanup_queue)) {
 945                 assert(u->in_cleanup_queue);
 946
 947                 unit_free(u);
 948                 n++;
 949         }
 950
 951         return n;
 952 }
 953
 954 enum {
 955         GC_OFFSET_IN_PATH,  /* This one is on the path we were traveling */
 956         GC_OFFSET_UNSURE,   /* No clue */
 957         GC_OFFSET_GOOD,     /* We still need this unit */
 958         GC_OFFSET_BAD,      /* We don't need this unit anymore */
 959         _GC_OFFSET_MAX
 960 };
 961
 962 static void unit_gc_mark_good(Unit *u, unsigned gc_marker) {
 963         Iterator i;
 964         Unit *other;
 965
 966         u->gc_marker = gc_marker + GC_OFFSET_GOOD;
 967
 968         /* Recursively mark referenced units as GOOD as well */
 969         SET_FOREACH(other, u->dependencies[UNIT_REFERENCES], i)
 970                 if (other->gc_marker == gc_marker + GC_OFFSET_UNSURE)
 971                         unit_gc_mark_good(other, gc_marker);
 972 }
 973
 974 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
 975         Iterator i;
 976         Unit *other;
 977         bool is_bad;
 978
 979         assert(u);
 980
 981         if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
 982             u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 983             u->gc_marker == gc_marker + GC_OFFSET_UNSURE ||
 984             u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
 985                 return;
 986
 987         if (u->in_cleanup_queue)
 988                 goto bad;
 989
 990         if (unit_check_gc(u))
 991                 goto good;
 992
 993         u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
 994
 995         is_bad = true;
 996
 997         SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
 998                 unit_gc_sweep(other, gc_marker);
 999
1000                 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
1001                         goto good;
1002
1003                 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
1004                         is_bad = false;
1005         }
1006
1007         if (is_bad)
1008                 goto bad;
1009
1010         /* We were unable to find anything out about this entry, so
1011          * let's investigate it later */
1012         u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
1013         unit_add_to_gc_queue(u);
1014         return;
1015
1016 bad:
1017         /* We definitely know that this one is not useful anymore, so
1018          * let's mark it for deletion */
1019         u->gc_marker = gc_marker + GC_OFFSET_BAD;
1020         unit_add_to_cleanup_queue(u);
1021         return;
1022
1023 good:
1024         unit_gc_mark_good(u, gc_marker);
1025 }
1026
1027 static unsigned manager_dispatch_gc_unit_queue(Manager *m) {
1028         unsigned n = 0, gc_marker;
1029         Unit *u;
1030
1031         assert(m);
1032
1033         /* log_debug("Running GC..."); */
1034
1035         m->gc_marker += _GC_OFFSET_MAX;
1036         if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
1037                 m->gc_marker = 1;
1038
1039         gc_marker = m->gc_marker;
1040
1041         while ((u = m->gc_unit_queue)) {
1042                 assert(u->in_gc_queue);
1043
1044                 unit_gc_sweep(u, gc_marker);
1045
1046                 LIST_REMOVE(gc_queue, m->gc_unit_queue, u);
1047                 u->in_gc_queue = false;
1048
1049                 n++;
1050
1051                 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
1052                     u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
1053                         if (u->id)
1054                                 log_unit_debug(u, "Collecting.");
1055                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
1056                         unit_add_to_cleanup_queue(u);
1057                 }
1058         }
1059
1060         return n;
1061 }
1062
1063 static unsigned manager_dispatch_gc_job_queue(Manager *m) {
1064         unsigned n = 0;
1065         Job *j;
1066
1067         assert(m);
1068
1069         while ((j = m->gc_job_queue)) {
1070                 assert(j->in_gc_queue);
1071
1072                 LIST_REMOVE(gc_queue, m->gc_job_queue, j);
1073                 j->in_gc_queue = false;
1074
1075                 n++;
1076
1077                 if (job_check_gc(j))
1078                         continue;
1079
1080                 log_unit_debug(j->unit, "Collecting job.");
1081                 (void) job_finish_and_invalidate(j, JOB_COLLECTED, false, false);
1082         }
1083
1084         return n;
1085 }
1086
1087 static void manager_clear_jobs_and_units(Manager *m) {
1088         Unit *u;
1089
1090         assert(m);
1091
1092         while ((u = hashmap_first(m->units)))
1093                 unit_free(u);
1094
1095         manager_dispatch_cleanup_queue(m);
1096
1097         assert(!m->load_queue);
1098         assert(!m->run_queue);
1099         assert(!m->dbus_unit_queue);
1100         assert(!m->dbus_job_queue);
1101         assert(!m->cleanup_queue);
1102         assert(!m->gc_unit_queue);
1103         assert(!m->gc_job_queue);
1104
1105         assert(hashmap_isempty(m->jobs));
1106         assert(hashmap_isempty(m->units));
1107
1108         m->n_on_console = 0;
1109         m->n_running_jobs = 0;
1110 }
1111
1112 Manager* manager_free(Manager *m) {
1113         UnitType c;
1114         int i;
1115         ExecDirectoryType dt;
1116
1117         if (!m)
1118                 return NULL;
1119
1120         manager_clear_jobs_and_units(m);
1121
1122         for (c = 0; c < _UNIT_TYPE_MAX; c++)
1123                 if (unit_vtable[c]->shutdown)
1124                         unit_vtable[c]->shutdown(m);
1125
1126         /* If we reexecute ourselves, we keep the root cgroup
1127          * around */
1128         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
1129
1130         lookup_paths_flush_generator(&m->lookup_paths);
1131
1132         bus_done(m);
1133
1134         dynamic_user_vacuum(m, false);
1135         hashmap_free(m->dynamic_users);
1136
1137         hashmap_free(m->units);
1138         hashmap_free(m->units_by_invocation_id);
1139         hashmap_free(m->jobs);
1140         hashmap_free(m->watch_pids1);
1141         hashmap_free(m->watch_pids2);
1142         hashmap_free(m->watch_bus);
1143
1144         set_free(m->startup_units);
1145         set_free(m->failed_units);
1146
1147         sd_event_source_unref(m->signal_event_source);
1148         sd_event_source_unref(m->notify_event_source);
1149         sd_event_source_unref(m->cgroups_agent_event_source);
1150         sd_event_source_unref(m->time_change_event_source);
1151         sd_event_source_unref(m->jobs_in_progress_event_source);
1152         sd_event_source_unref(m->run_queue_event_source);
1153         sd_event_source_unref(m->user_lookup_event_source);
1154
1155         safe_close(m->signal_fd);
1156         safe_close(m->notify_fd);
1157         safe_close(m->cgroups_agent_fd);
1158         safe_close(m->time_change_fd);
1159         safe_close_pair(m->user_lookup_fds);
1160
1161         manager_close_ask_password(m);
1162
1163         manager_close_idle_pipe(m);
1164
1165         udev_unref(m->udev);
1166         sd_event_unref(m->event);
1167
1168         free(m->notify_socket);
1169
1170         lookup_paths_free(&m->lookup_paths);
1171         strv_free(m->environment);
1172
1173         hashmap_free(m->cgroup_unit);
1174         set_free_free(m->unit_path_cache);
1175
1176         free(m->switch_root);
1177         free(m->switch_root_init);
1178
1179         for (i = 0; i < _RLIMIT_MAX; i++)
1180                 m->rlimit[i] = mfree(m->rlimit[i]);
1181
1182         assert(hashmap_isempty(m->units_requiring_mounts_for));
1183         hashmap_free(m->units_requiring_mounts_for);
1184
1185         hashmap_free(m->uid_refs);
1186         hashmap_free(m->gid_refs);
1187
1188         for (dt = 0; dt < _EXEC_DIRECTORY_MAX; dt++)
1189                 m->prefix[dt] = mfree(m->prefix[dt]);
1190
1191         return mfree(m);
1192 }
1193
1194 void manager_enumerate(Manager *m) {
1195         UnitType c;
1196
1197         assert(m);
1198
1199         /* Let's ask every type to load all units from disk/kernel
1200          * that it might know */
1201         for (c = 0; c < _UNIT_TYPE_MAX; c++) {
1202                 if (!unit_type_supported(c)) {
1203                         log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
1204                         continue;
1205                 }
1206
1207                 if (!unit_vtable[c]->enumerate)
1208                         continue;
1209
1210                 unit_vtable[c]->enumerate(m);
1211         }
1212
1213         manager_dispatch_load_queue(m);
1214 }
1215
1216 static void manager_coldplug(Manager *m) {
1217         Iterator i;
1218         Unit *u;
1219         char *k;
1220         int r;
1221
1222         assert(m);
1223
1224         /* Then, let's set up their initial state. */
1225         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1226
1227                 /* ignore aliases */
1228                 if (u->id != k)
1229                         continue;
1230
1231                 r = unit_coldplug(u);
1232                 if (r < 0)
1233                         log_warning_errno(r, "We couldn't coldplug %s, proceeding anyway: %m", u->id);
1234         }
1235 }
1236
1237 static void manager_build_unit_path_cache(Manager *m) {
1238         char **i;
1239         int r;
1240
1241         assert(m);
1242
1243         set_free_free(m->unit_path_cache);
1244
1245         m->unit_path_cache = set_new(&string_hash_ops);
1246         if (!m->unit_path_cache) {
1247                 r = -ENOMEM;
1248                 goto fail;
1249         }
1250
1251         /* This simply builds a list of files we know exist, so that
1252          * we don't always have to go to disk */
1253
1254         STRV_FOREACH(i, m->lookup_paths.search_path) {
1255                 _cleanup_closedir_ DIR *d = NULL;
1256                 struct dirent *de;
1257
1258                 d = opendir(*i);
1259                 if (!d) {
1260                         if (errno != ENOENT)
1261                                 log_warning_errno(errno, "Failed to open directory %s, ignoring: %m", *i);
1262                         continue;
1263                 }
1264
1265                 FOREACH_DIRENT(de, d, r = -errno; goto fail) {
1266                         char *p;
1267
1268                         p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name);
1269                         if (!p) {
1270                                 r = -ENOMEM;
1271                                 goto fail;
1272                         }
1273
1274                         r = set_consume(m->unit_path_cache, p);
1275                         if (r < 0)
1276                                 goto fail;
1277                 }
1278         }
1279
1280         return;
1281
1282 fail:
1283         log_warning_errno(r, "Failed to build unit path cache, proceeding without: %m");
1284         m->unit_path_cache = set_free_free(m->unit_path_cache);
1285 }
1286
1287 static void manager_distribute_fds(Manager *m, FDSet *fds) {
1288         Iterator i;
1289         Unit *u;
1290
1291         assert(m);
1292
1293         HASHMAP_FOREACH(u, m->units, i) {
1294
1295                 if (fdset_size(fds) <= 0)
1296                         break;
1297
1298                 if (!UNIT_VTABLE(u)->distribute_fds)
1299                         continue;
1300
1301                 UNIT_VTABLE(u)->distribute_fds(u, fds);
1302         }
1303 }
1304
1305 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1306         int r, q;
1307
1308         assert(m);
1309
1310         r = lookup_paths_init(&m->lookup_paths, m->unit_file_scope, 0, NULL);
1311         if (r < 0)
1312                 return r;
1313
1314         r = manager_run_environment_generators(m);
1315         if (r < 0)
1316                 return r;
1317
1318         /* Make sure the transient directory always exists, so that it remains in the search path */
1319         if (!m->test_run) {
1320                 r = mkdir_p_label(m->lookup_paths.transient, 0755);
1321                 if (r < 0)
1322                         return r;
1323         }
1324
1325         dual_timestamp_get(&m->generators_start_timestamp);
1326         r = manager_run_generators(m);
1327         dual_timestamp_get(&m->generators_finish_timestamp);
1328         if (r < 0)
1329                 return r;
1330
1331         lookup_paths_reduce(&m->lookup_paths);
1332         manager_build_unit_path_cache(m);
1333
1334         /* If we will deserialize make sure that during enumeration
1335          * this is already known, so we increase the counter here
1336          * already */
1337         if (serialization)
1338                 m->n_reloading++;
1339
1340         /* First, enumerate what we can from all config files */
1341         dual_timestamp_get(&m->units_load_start_timestamp);
1342         manager_enumerate(m);
1343         dual_timestamp_get(&m->units_load_finish_timestamp);
1344
1345         /* Second, deserialize if there is something to deserialize */
1346         if (serialization) {
1347                 r = manager_deserialize(m, serialization, fds);
1348                 if (r < 0)
1349                         log_error_errno(r, "Deserialization failed: %m");
1350         }
1351
1352         /* Any fds left? Find some unit which wants them. This is
1353          * useful to allow container managers to pass some file
1354          * descriptors to us pre-initialized. This enables
1355          * socket-based activation of entire containers. */
1356         manager_distribute_fds(m, fds);
1357
1358         /* We might have deserialized the notify fd, but if we didn't
1359          * then let's create the bus now */
1360         q = manager_setup_notify(m);
1361         if (q < 0 && r == 0)
1362                 r = q;
1363
1364         q = manager_setup_cgroups_agent(m);
1365         if (q < 0 && r == 0)
1366                 r = q;
1367
1368         q = manager_setup_user_lookup_fd(m);
1369         if (q < 0 && r == 0)
1370                 r = q;
1371
1372         /* Let's connect to the bus now. */
1373         (void) manager_connect_bus(m, !!serialization);
1374
1375         (void) bus_track_coldplug(m, &m->subscribed, false, m->deserialized_subscribed);
1376         m->deserialized_subscribed = strv_free(m->deserialized_subscribed);
1377
1378         /* Third, fire things up! */
1379         manager_coldplug(m);
1380
1381         /* Release any dynamic users no longer referenced */
1382         dynamic_user_vacuum(m, true);
1383
1384         /* Release any references to UIDs/GIDs no longer referenced, and destroy any IPC owned by them */
1385         manager_vacuum_uid_refs(m);
1386         manager_vacuum_gid_refs(m);
1387
1388         if (serialization) {
1389                 assert(m->n_reloading > 0);
1390                 m->n_reloading--;
1391
1392                 /* Let's wait for the UnitNew/JobNew messages being
1393                  * sent, before we notify that the reload is
1394                  * finished */
1395                 m->send_reloading_done = true;
1396         }
1397
1398         return r;
1399 }
1400
1401 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, sd_bus_error *e, Job **_ret) {
1402         int r;
1403         Transaction *tr;
1404
1405         assert(m);
1406         assert(type < _JOB_TYPE_MAX);
1407         assert(unit);
1408         assert(mode < _JOB_MODE_MAX);
1409
1410         if (mode == JOB_ISOLATE && type != JOB_START)
1411                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1412
1413         if (mode == JOB_ISOLATE && !unit->allow_isolate)
1414                 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1415
1416         log_unit_debug(unit, "Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1417
1418         type = job_type_collapse(type, unit);
1419
1420         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1421         if (!tr)
1422                 return -ENOMEM;
1423
1424         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, false,
1425                                                  mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1426                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
1427         if (r < 0)
1428                 goto tr_abort;
1429
1430         if (mode == JOB_ISOLATE) {
1431                 r = transaction_add_isolate_jobs(tr, m);
1432                 if (r < 0)
1433                         goto tr_abort;
1434         }
1435
1436         r = transaction_activate(tr, m, mode, e);
1437         if (r < 0)
1438                 goto tr_abort;
1439
1440         log_unit_debug(unit,
1441                        "Enqueued job %s/%s as %u", unit->id,
1442                        job_type_to_string(type), (unsigned) tr->anchor_job->id);
1443
1444         if (_ret)
1445                 *_ret = tr->anchor_job;
1446
1447         transaction_free(tr);
1448         return 0;
1449
1450 tr_abort:
1451         transaction_abort(tr);
1452         transaction_free(tr);
1453         return r;
1454 }
1455
1456 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, sd_bus_error *e, Job **ret) {
1457         Unit *unit = NULL;  /* just to appease gcc, initialization is not really necessary */
1458         int r;
1459
1460         assert(m);
1461         assert(type < _JOB_TYPE_MAX);
1462         assert(name);
1463         assert(mode < _JOB_MODE_MAX);
1464
1465         r = manager_load_unit(m, name, NULL, NULL, &unit);
1466         if (r < 0)
1467                 return r;
1468         assert(unit);
1469
1470         return manager_add_job(m, type, unit, mode, e, ret);
1471 }
1472
1473 int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Job **ret) {
1474         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1475         int r;
1476
1477         assert(m);
1478         assert(type < _JOB_TYPE_MAX);
1479         assert(name);
1480         assert(mode < _JOB_MODE_MAX);
1481
1482         r = manager_add_job_by_name(m, type, name, mode, &error, ret);
1483         if (r < 0)
1484                 return log_warning_errno(r, "Failed to enqueue %s job for %s: %s", job_mode_to_string(mode), name, bus_error_message(&error, r));
1485
1486         return r;
1487 }
1488
1489 Job *manager_get_job(Manager *m, uint32_t id) {
1490         assert(m);
1491
1492         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1493 }
1494
1495 Unit *manager_get_unit(Manager *m, const char *name) {
1496         assert(m);
1497         assert(name);
1498
1499         return hashmap_get(m->units, name);
1500 }
1501
1502 unsigned manager_dispatch_load_queue(Manager *m) {
1503         Unit *u;
1504         unsigned n = 0;
1505
1506         assert(m);
1507
1508         /* Make sure we are not run recursively */
1509         if (m->dispatching_load_queue)
1510                 return 0;
1511
1512         m->dispatching_load_queue = true;
1513
1514         /* Dispatches the load queue. Takes a unit from the queue and
1515          * tries to load its data until the queue is empty */
1516
1517         while ((u = m->load_queue)) {
1518                 assert(u->in_load_queue);
1519
1520                 unit_load(u);
1521                 n++;
1522         }
1523
1524         m->dispatching_load_queue = false;
1525         return n;
1526 }
1527
1528 int manager_load_unit_prepare(
1529                 Manager *m,
1530                 const char *name,
1531                 const char *path,
1532                 sd_bus_error *e,
1533                 Unit **_ret) {
1534
1535         Unit *ret;
1536         UnitType t;
1537         int r;
1538
1539         assert(m);
1540         assert(name || path);
1541         assert(_ret);
1542
1543         /* This will prepare the unit for loading, but not actually
1544          * load anything from disk. */
1545
1546         if (path && !is_path(path))
1547                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1548
1549         if (!name)
1550                 name = basename(path);
1551
1552         t = unit_name_to_type(name);
1553
1554         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE)) {
1555                 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE))
1556                         return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is missing the instance name.", name);
1557
1558                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1559         }
1560
1561         ret = manager_get_unit(m, name);
1562         if (ret) {
1563                 *_ret = ret;
1564                 return 1;
1565         }
1566
1567         ret = unit_new(m, unit_vtable[t]->object_size);
1568         if (!ret)
1569                 return -ENOMEM;
1570
1571         if (path) {
1572                 ret->fragment_path = strdup(path);
1573                 if (!ret->fragment_path) {
1574                         unit_free(ret);
1575                         return -ENOMEM;
1576                 }
1577         }
1578
1579         r = unit_add_name(ret, name);
1580         if (r < 0) {
1581                 unit_free(ret);
1582                 return r;
1583         }
1584
1585         unit_add_to_load_queue(ret);
1586         unit_add_to_dbus_queue(ret);
1587         unit_add_to_gc_queue(ret);
1588
1589         *_ret = ret;
1590
1591         return 0;
1592 }
1593
1594 int manager_load_unit(
1595                 Manager *m,
1596                 const char *name,
1597                 const char *path,
1598                 sd_bus_error *e,
1599                 Unit **_ret) {
1600
1601         int r;
1602
1603         assert(m);
1604         assert(_ret);
1605
1606         /* This will load the service information files, but not actually
1607          * start any services or anything. */
1608
1609         r = manager_load_unit_prepare(m, name, path, e, _ret);
1610         if (r != 0)
1611                 return r;
1612
1613         manager_dispatch_load_queue(m);
1614
1615         *_ret = unit_follow_merge(*_ret);
1616
1617         return 0;
1618 }
1619
1620 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1621         Iterator i;
1622         Job *j;
1623
1624         assert(s);
1625         assert(f);
1626
1627         HASHMAP_FOREACH(j, s->jobs, i)
1628                 job_dump(j, f, prefix);
1629 }
1630
1631 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1632         Iterator i;
1633         Unit *u;
1634         const char *t;
1635
1636         assert(s);
1637         assert(f);
1638
1639         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1640                 if (u->id == t)
1641                         unit_dump(u, f, prefix);
1642 }
1643
1644 void manager_clear_jobs(Manager *m) {
1645         Job *j;
1646
1647         assert(m);
1648
1649         while ((j = hashmap_first(m->jobs)))
1650                 /* No need to recurse. We're cancelling all jobs. */
1651                 job_finish_and_invalidate(j, JOB_CANCELED, false, false);
1652 }
1653
1654 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1655         Manager *m = userdata;
1656         Job *j;
1657
1658         assert(source);
1659         assert(m);
1660
1661         while ((j = m->run_queue)) {
1662                 assert(j->installed);
1663                 assert(j->in_run_queue);
1664
1665                 job_run_and_invalidate(j);
1666         }
1667
1668         if (m->n_running_jobs > 0)
1669                 manager_watch_jobs_in_progress(m);
1670
1671         if (m->n_on_console > 0)
1672                 manager_watch_idle_pipe(m);
1673
1674         return 1;
1675 }
1676
1677 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1678         Job *j;
1679         Unit *u;
1680         unsigned n = 0;
1681
1682         assert(m);
1683
1684         if (m->dispatching_dbus_queue)
1685                 return 0;
1686
1687         m->dispatching_dbus_queue = true;
1688
1689         while ((u = m->dbus_unit_queue)) {
1690                 assert(u->in_dbus_queue);
1691
1692                 bus_unit_send_change_signal(u);
1693                 n++;
1694         }
1695
1696         while ((j = m->dbus_job_queue)) {
1697                 assert(j->in_dbus_queue);
1698
1699                 bus_job_send_change_signal(j);
1700                 n++;
1701         }
1702
1703         m->dispatching_dbus_queue = false;
1704
1705         if (m->send_reloading_done) {
1706                 m->send_reloading_done = false;
1707
1708                 bus_manager_send_reloading(m, false);
1709         }
1710
1711         if (m->queued_message)
1712                 bus_send_queued_message(m);
1713
1714         return n;
1715 }
1716
1717 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1718         Manager *m = userdata;
1719         char buf[PATH_MAX+1];
1720         ssize_t n;
1721
1722         n = recv(fd, buf, sizeof(buf), 0);
1723         if (n < 0)
1724                 return log_error_errno(errno, "Failed to read cgroups agent message: %m");
1725         if (n == 0) {
1726                 log_error("Got zero-length cgroups agent message, ignoring.");
1727                 return 0;
1728         }
1729         if ((size_t) n >= sizeof(buf)) {
1730                 log_error("Got overly long cgroups agent message, ignoring.");
1731                 return 0;
1732         }
1733
1734         if (memchr(buf, 0, n)) {
1735                 log_error("Got cgroups agent message with embedded NUL byte, ignoring.");
1736                 return 0;
1737         }
1738         buf[n] = 0;
1739
1740         manager_notify_cgroup_empty(m, buf);
1741         bus_forward_agent_released(m, buf);
1742
1743         return 0;
1744 }
1745
1746 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, const char *buf, FDSet *fds) {
1747         _cleanup_strv_free_ char **tags = NULL;
1748
1749         assert(m);
1750         assert(u);
1751         assert(buf);
1752
1753         tags = strv_split(buf, "\n\r");
1754         if (!tags) {
1755                 log_oom();
1756                 return;
1757         }
1758
1759         if (UNIT_VTABLE(u)->notify_message)
1760                 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1761         else if (_unlikely_(log_get_max_level() >= LOG_DEBUG)) {
1762                 _cleanup_free_ char *x = NULL, *y = NULL;
1763
1764                 x = cescape(buf);
1765                 if (x)
1766                         y = ellipsize(x, 20, 90);
1767                 log_unit_debug(u, "Got notification message \"%s\", ignoring.", strnull(y));
1768         }
1769 }
1770
1771 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1772
1773         _cleanup_fdset_free_ FDSet *fds = NULL;
1774         Manager *m = userdata;
1775         char buf[NOTIFY_BUFFER_MAX+1];
1776         struct iovec iovec = {
1777                 .iov_base = buf,
1778                 .iov_len = sizeof(buf)-1,
1779         };
1780         union {
1781                 struct cmsghdr cmsghdr;
1782                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1783                             CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1784         } control = {};
1785         struct msghdr msghdr = {
1786                 .msg_iov = &iovec,
1787                 .msg_iovlen = 1,
1788                 .msg_control = &control,
1789                 .msg_controllen = sizeof(control),
1790         };
1791
1792         struct cmsghdr *cmsg;
1793         struct ucred *ucred = NULL;
1794         Unit *u1, *u2, *u3;
1795         int r, *fd_array = NULL;
1796         unsigned n_fds = 0;
1797         ssize_t n;
1798
1799         assert(m);
1800         assert(m->notify_fd == fd);
1801
1802         if (revents != EPOLLIN) {
1803                 log_warning("Got unexpected poll event for notify fd.");
1804                 return 0;
1805         }
1806
1807         n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC|MSG_TRUNC);
1808         if (n < 0) {
1809                 if (IN_SET(errno, EAGAIN, EINTR))
1810                         return 0; /* Spurious wakeup, try again */
1811
1812                 /* If this is any other, real error, then let's stop processing this socket. This of course means we
1813                  * won't take notification messages anymore, but that's still better than busy looping around this:
1814                  * being woken up over and over again but being unable to actually read the message off the socket. */
1815                 return log_error_errno(errno, "Failed to receive notification message: %m");
1816         }
1817
1818         CMSG_FOREACH(cmsg, &msghdr) {
1819                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1820
1821                         fd_array = (int*) CMSG_DATA(cmsg);
1822                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1823
1824                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1825                            cmsg->cmsg_type == SCM_CREDENTIALS &&
1826                            cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1827
1828                         ucred = (struct ucred*) CMSG_DATA(cmsg);
1829                 }
1830         }
1831
1832         if (n_fds > 0) {
1833                 assert(fd_array);
1834
1835                 r = fdset_new_array(&fds, fd_array, n_fds);
1836                 if (r < 0) {
1837                         close_many(fd_array, n_fds);
1838                         log_oom();
1839                         return 0;
1840                 }
1841         }
1842
1843         if (!ucred || ucred->pid <= 0) {
1844                 log_warning("Received notify message without valid credentials. Ignoring.");
1845                 return 0;
1846         }
1847
1848         if ((size_t) n >= sizeof(buf) || (msghdr.msg_flags & MSG_TRUNC)) {
1849                 log_warning("Received notify message exceeded maximum size. Ignoring.");
1850                 return 0;
1851         }
1852
1853         /* As extra safety check, let's make sure the string we get doesn't contain embedded NUL bytes. We permit one
1854          * trailing NUL byte in the message, but don't expect it. */
1855         if (n > 1 && memchr(buf, 0, n-1)) {
1856                 log_warning("Received notify message with embedded NUL bytes. Ignoring.");
1857                 return 0;
1858         }
1859
1860         /* Make sure it's NUL-terminated. */
1861         buf[n] = 0;
1862
1863         /* Notify every unit that might be interested, but try
1864          * to avoid notifying the same one multiple times. */
1865         u1 = manager_get_unit_by_pid_cgroup(m, ucred->pid);
1866         if (u1)
1867                 manager_invoke_notify_message(m, u1, ucred->pid, buf, fds);
1868
1869         u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(ucred->pid));
1870         if (u2 && u2 != u1)
1871                 manager_invoke_notify_message(m, u2, ucred->pid, buf, fds);
1872
1873         u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(ucred->pid));
1874         if (u3 && u3 != u2 && u3 != u1)
1875                 manager_invoke_notify_message(m, u3, ucred->pid, buf, fds);
1876
1877         if (!u1 && !u2 && !u3)
1878                 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1879
1880         if (fdset_size(fds) > 0)
1881                 log_warning("Got extra auxiliary fds with notification message, closing them.");
1882
1883         return 0;
1884 }
1885
1886 static void invoke_sigchld_event(Manager *m, Unit *u, const siginfo_t *si) {
1887         uint64_t iteration;
1888
1889         assert(m);
1890         assert(u);
1891         assert(si);
1892
1893         sd_event_get_iteration(m->event, &iteration);
1894
1895         log_unit_debug(u, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1896
1897         unit_unwatch_pid(u, si->si_pid);
1898
1899         if (UNIT_VTABLE(u)->sigchld_event) {
1900                 if (set_size(u->pids) <= 1 ||
1901                     iteration != u->sigchldgen ||
1902                     unit_main_pid(u) == si->si_pid ||
1903                     unit_control_pid(u) == si->si_pid) {
1904                         UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1905                         u->sigchldgen = iteration;
1906                 } else
1907                         log_debug("%s already issued a sigchld this iteration %" PRIu64 ", skipping. Pids still being watched %d", u->id, iteration, set_size(u->pids));
1908          }
1909 }
1910
1911 static int manager_dispatch_sigchld(Manager *m) {
1912         assert(m);
1913
1914         for (;;) {
1915                 siginfo_t si = {};
1916
1917                 /* First we call waitd() for a PID and do not reap the
1918                  * zombie. That way we can still access /proc/$PID for
1919                  * it while it is a zombie. */
1920                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1921
1922                         if (errno == ECHILD)
1923                                 break;
1924
1925                         if (errno == EINTR)
1926                                 continue;
1927
1928                         return -errno;
1929                 }
1930
1931                 if (si.si_pid <= 0)
1932                         break;
1933
1934                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1935                         _cleanup_free_ char *name = NULL;
1936                         Unit *u1, *u2, *u3;
1937
1938                         get_process_comm(si.si_pid, &name);
1939
1940                         log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1941                                   si.si_pid, strna(name),
1942                                   sigchld_code_to_string(si.si_code),
1943                                   si.si_status,
1944                                   strna(si.si_code == CLD_EXITED
1945                                         ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1946                                         : signal_to_string(si.si_status)));
1947
1948                         /* And now figure out the unit this belongs
1949                          * to, it might be multiple... */
1950                         u1 = manager_get_unit_by_pid_cgroup(m, si.si_pid);
1951                         if (u1)
1952                                 invoke_sigchld_event(m, u1, &si);
1953                         u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(si.si_pid));
1954                         if (u2 && u2 != u1)
1955                                 invoke_sigchld_event(m, u2, &si);
1956                         u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(si.si_pid));
1957                         if (u3 && u3 != u2 && u3 != u1)
1958                                 invoke_sigchld_event(m, u3, &si);
1959                 }
1960
1961                 /* And now, we actually reap the zombie. */
1962                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1963                         if (errno == EINTR)
1964                                 continue;
1965
1966                         return -errno;
1967                 }
1968         }
1969
1970         return 0;
1971 }
1972
1973 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1974         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1975         int r;
1976
1977         log_debug("Activating special unit %s", name);
1978
1979         r = manager_add_job_by_name(m, JOB_START, name, mode, &error, NULL);
1980         if (r < 0)
1981                 log_error("Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1982
1983         return r;
1984 }
1985
1986 static void manager_handle_ctrl_alt_del(Manager *m) {
1987         /* If the user presses C-A-D more than
1988          * 7 times within 2s, we reboot/shutdown immediately,
1989          * unless it was disabled in system.conf */
1990
1991         if (ratelimit_test(&m->ctrl_alt_del_ratelimit) || m->cad_burst_action == EMERGENCY_ACTION_NONE)
1992                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1993         else
1994                 emergency_action(m, m->cad_burst_action, NULL,
1995                                 "Ctrl-Alt-Del was pressed more than 7 times within 2s");
1996 }
1997
1998 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1999         Manager *m = userdata;
2000         ssize_t n;
2001         struct signalfd_siginfo sfsi;
2002         bool sigchld = false;
2003         int r;
2004
2005         assert(m);
2006         assert(m->signal_fd == fd);
2007
2008         if (revents != EPOLLIN) {
2009                 log_warning("Got unexpected events from signal file descriptor.");
2010                 return 0;
2011         }
2012
2013         for (;;) {
2014                 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
2015                 if (n != sizeof(sfsi)) {
2016                         if (n >= 0) {
2017                                 log_warning("Truncated read from signal fd (%zu bytes)!", n);
2018                                 return 0;
2019                         }
2020
2021                         if (IN_SET(errno, EINTR, EAGAIN))
2022                                 break;
2023
2024                         /* We return an error here, which will kill this handler,
2025                          * to avoid a busy loop on read error. */
2026                         return log_error_errno(errno, "Reading from signal fd failed: %m");
2027                 }
2028
2029                 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
2030                                     (sfsi.ssi_signo == SIGTERM && MANAGER_IS_USER(m))
2031                                     ? LOG_DEBUG : LOG_INFO,
2032                                     &sfsi);
2033
2034                 switch (sfsi.ssi_signo) {
2035
2036                 case SIGCHLD:
2037                         sigchld = true;
2038                         break;
2039
2040                 case SIGTERM:
2041                         if (MANAGER_IS_SYSTEM(m)) {
2042                                 /* This is for compatibility with the
2043                                  * original sysvinit */
2044                                 r = verify_run_space_and_log("Refusing to reexecute");
2045                                 if (r >= 0)
2046                                         m->exit_code = MANAGER_REEXECUTE;
2047                                 break;
2048                         }
2049
2050                         /* Fall through */
2051
2052                 case SIGINT:
2053                         if (MANAGER_IS_SYSTEM(m)) {
2054                                 manager_handle_ctrl_alt_del(m);
2055                                 break;
2056                         }
2057
2058                         /* Run the exit target if there is one, if not, just exit. */
2059                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
2060                                 m->exit_code = MANAGER_EXIT;
2061                                 return 0;
2062                         }
2063
2064                         break;
2065
2066                 case SIGWINCH:
2067                         if (MANAGER_IS_SYSTEM(m))
2068                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2069
2070                         /* This is a nop on non-init */
2071                         break;
2072
2073                 case SIGPWR:
2074                         if (MANAGER_IS_SYSTEM(m))
2075                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2076
2077                         /* This is a nop on non-init */
2078                         break;
2079
2080                 case SIGUSR1: {
2081                         Unit *u;
2082
2083                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
2084
2085                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
2086                                 log_info("Trying to reconnect to bus...");
2087                                 bus_init(m, true);
2088                         }
2089
2090                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
2091                                 log_info("Loading D-Bus service...");
2092                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2093                         }
2094
2095                         break;
2096                 }
2097
2098                 case SIGUSR2: {
2099                         _cleanup_free_ char *dump = NULL;
2100                         _cleanup_fclose_ FILE *f = NULL;
2101                         size_t size;
2102
2103                         f = open_memstream(&dump, &size);
2104                         if (!f) {
2105                                 log_warning_errno(errno, "Failed to allocate memory stream: %m");
2106                                 break;
2107                         }
2108
2109                         manager_dump_units(m, f, "\t");
2110                         manager_dump_jobs(m, f, "\t");
2111
2112                         r = fflush_and_check(f);
2113                         if (r < 0) {
2114                                 log_warning_errno(r, "Failed to write status stream: %m");
2115                                 break;
2116                         }
2117
2118                         log_dump(LOG_INFO, dump);
2119                         break;
2120                 }
2121
2122                 case SIGHUP:
2123                         r = verify_run_space_and_log("Refusing to reload");
2124                         if (r >= 0)
2125                                 m->exit_code = MANAGER_RELOAD;
2126                         break;
2127
2128                 default: {
2129
2130                         /* Starting SIGRTMIN+0 */
2131                         static const char * const target_table[] = {
2132                                 [0] = SPECIAL_DEFAULT_TARGET,
2133                                 [1] = SPECIAL_RESCUE_TARGET,
2134                                 [2] = SPECIAL_EMERGENCY_TARGET,
2135                                 [3] = SPECIAL_HALT_TARGET,
2136                                 [4] = SPECIAL_POWEROFF_TARGET,
2137                                 [5] = SPECIAL_REBOOT_TARGET,
2138                                 [6] = SPECIAL_KEXEC_TARGET
2139                         };
2140
2141                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2142                         static const ManagerExitCode code_table[] = {
2143                                 [0] = MANAGER_HALT,
2144                                 [1] = MANAGER_POWEROFF,
2145                                 [2] = MANAGER_REBOOT,
2146                                 [3] = MANAGER_KEXEC
2147                         };
2148
2149                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2150                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2151                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2152                                 manager_start_target(m, target_table[idx],
2153                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
2154                                 break;
2155                         }
2156
2157                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2158                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
2159                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
2160                                 break;
2161                         }
2162
2163                         switch (sfsi.ssi_signo - SIGRTMIN) {
2164
2165                         case 20:
2166                                 manager_set_show_status(m, SHOW_STATUS_YES);
2167                                 break;
2168
2169                         case 21:
2170                                 manager_set_show_status(m, SHOW_STATUS_NO);
2171                                 break;
2172
2173                         case 22:
2174                                 log_set_max_level(LOG_DEBUG);
2175                                 log_info("Setting log level to debug.");
2176                                 break;
2177
2178                         case 23:
2179                                 log_set_max_level(LOG_INFO);
2180                                 log_info("Setting log level to info.");
2181                                 break;
2182
2183                         case 24:
2184                                 if (MANAGER_IS_USER(m)) {
2185                                         m->exit_code = MANAGER_EXIT;
2186                                         return 0;
2187                                 }
2188
2189                                 /* This is a nop on init */
2190                                 break;
2191
2192                         case 26:
2193                         case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
2194                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
2195                                 log_notice("Setting log target to journal-or-kmsg.");
2196                                 break;
2197
2198                         case 27:
2199                                 log_set_target(LOG_TARGET_CONSOLE);
2200                                 log_notice("Setting log target to console.");
2201                                 break;
2202
2203                         case 28:
2204                                 log_set_target(LOG_TARGET_KMSG);
2205                                 log_notice("Setting log target to kmsg.");
2206                                 break;
2207
2208                         default:
2209                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2210                         }
2211                 }
2212                 }
2213         }
2214
2215         if (sigchld)
2216                 manager_dispatch_sigchld(m);
2217
2218         return 0;
2219 }
2220
2221 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2222         Manager *m = userdata;
2223         Iterator i;
2224         Unit *u;
2225
2226         assert(m);
2227         assert(m->time_change_fd == fd);
2228
2229         log_struct(LOG_DEBUG,
2230                    "MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
2231                    LOG_MESSAGE("Time has been changed"),
2232                    NULL);
2233
2234         /* Restart the watch */
2235         m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
2236         m->time_change_fd = safe_close(m->time_change_fd);
2237
2238         manager_setup_time_change(m);
2239
2240         HASHMAP_FOREACH(u, m->units, i)
2241                 if (UNIT_VTABLE(u)->time_change)
2242                         UNIT_VTABLE(u)->time_change(u);
2243
2244         return 0;
2245 }
2246
2247 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2248         Manager *m = userdata;
2249
2250         assert(m);
2251         assert(m->idle_pipe[2] == fd);
2252
2253         m->no_console_output = m->n_on_console > 0;
2254
2255         manager_close_idle_pipe(m);
2256
2257         return 0;
2258 }
2259
2260 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
2261         Manager *m = userdata;
2262         int r;
2263         uint64_t next;
2264
2265         assert(m);
2266         assert(source);
2267
2268         manager_print_jobs_in_progress(m);
2269
2270         next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
2271         r = sd_event_source_set_time(source, next);
2272         if (r < 0)
2273                 return r;
2274
2275         return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
2276 }
2277
2278 int manager_loop(Manager *m) {
2279         int r;
2280
2281         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
2282
2283         assert(m);
2284         m->exit_code = MANAGER_OK;
2285
2286         /* Release the path cache */
2287         m->unit_path_cache = set_free_free(m->unit_path_cache);
2288
2289         manager_check_finished(m);
2290
2291         /* There might still be some zombies hanging around from
2292          * before we were exec()'ed. Let's reap them. */
2293         r = manager_dispatch_sigchld(m);
2294         if (r < 0)
2295                 return r;
2296
2297         while (m->exit_code == MANAGER_OK) {
2298                 usec_t wait_usec;
2299
2300                 if (m->runtime_watchdog > 0 && m->runtime_watchdog != USEC_INFINITY && MANAGER_IS_SYSTEM(m))
2301                         watchdog_ping();
2302
2303                 if (!ratelimit_test(&rl)) {
2304                         /* Yay, something is going seriously wrong, pause a little */
2305                         log_warning("Looping too fast. Throttling execution a little.");
2306                         sleep(1);
2307                 }
2308
2309                 if (manager_dispatch_load_queue(m) > 0)
2310                         continue;
2311
2312                 if (manager_dispatch_gc_job_queue(m) > 0)
2313                         continue;
2314
2315                 if (manager_dispatch_gc_unit_queue(m) > 0)
2316                         continue;
2317
2318                 if (manager_dispatch_cleanup_queue(m) > 0)
2319                         continue;
2320
2321                 if (manager_dispatch_cgroup_queue(m) > 0)
2322                         continue;
2323
2324                 if (manager_dispatch_dbus_queue(m) > 0)
2325                         continue;
2326
2327                 /* Sleep for half the watchdog time */
2328                 if (m->runtime_watchdog > 0 && m->runtime_watchdog != USEC_INFINITY && MANAGER_IS_SYSTEM(m)) {
2329                         wait_usec = m->runtime_watchdog / 2;
2330                         if (wait_usec <= 0)
2331                                 wait_usec = 1;
2332                 } else
2333                         wait_usec = USEC_INFINITY;
2334
2335                 r = sd_event_run(m->event, wait_usec);
2336                 if (r < 0)
2337                         return log_error_errno(r, "Failed to run event loop: %m");
2338         }
2339
2340         return m->exit_code;
2341 }
2342
2343 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2344         _cleanup_free_ char *n = NULL;
2345         sd_id128_t invocation_id;
2346         Unit *u;
2347         int r;
2348
2349         assert(m);
2350         assert(s);
2351         assert(_u);
2352
2353         r = unit_name_from_dbus_path(s, &n);
2354         if (r < 0)
2355                 return r;
2356
2357         /* Permit addressing units by invocation ID: if the passed bus path is suffixed by a 128bit ID then we use it
2358          * as invocation ID. */
2359         r = sd_id128_from_string(n, &invocation_id);
2360         if (r >= 0) {
2361                 u = hashmap_get(m->units_by_invocation_id, &invocation_id);
2362                 if (u) {
2363                         *_u = u;
2364                         return 0;
2365                 }
2366
2367                 return sd_bus_error_setf(e, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID, "No unit with the specified invocation ID " SD_ID128_FORMAT_STR " known.", SD_ID128_FORMAT_VAL(invocation_id));
2368         }
2369
2370         /* If this didn't work, we check if this is a unit name */
2371         if (!unit_name_is_valid(n, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
2372                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is neither a valid invocation ID nor unit name.", n);
2373
2374         r = manager_load_unit(m, n, NULL, e, &u);
2375         if (r < 0)
2376                 return r;
2377
2378         *_u = u;
2379         return 0;
2380 }
2381
2382 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2383         const char *p;
2384         unsigned id;
2385         Job *j;
2386         int r;
2387
2388         assert(m);
2389         assert(s);
2390         assert(_j);
2391
2392         p = startswith(s, "/org/freedesktop/systemd1/job/");
2393         if (!p)
2394                 return -EINVAL;
2395
2396         r = safe_atou(p, &id);
2397         if (r < 0)
2398                 return r;
2399
2400         j = manager_get_job(m, id);
2401         if (!j)
2402                 return -ENOENT;
2403
2404         *_j = j;
2405
2406         return 0;
2407 }
2408
2409 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2410
2411 #ifdef HAVE_AUDIT
2412         _cleanup_free_ char *p = NULL;
2413         const char *msg;
2414         int audit_fd, r;
2415
2416         if (!MANAGER_IS_SYSTEM(m))
2417                 return;
2418
2419         audit_fd = get_audit_fd();
2420         if (audit_fd < 0)
2421                 return;
2422
2423         /* Don't generate audit events if the service was already
2424          * started and we're just deserializing */
2425         if (MANAGER_IS_RELOADING(m))
2426                 return;
2427
2428         if (u->type != UNIT_SERVICE)
2429                 return;
2430
2431         r = unit_name_to_prefix_and_instance(u->id, &p);
2432         if (r < 0) {
2433                 log_error_errno(r, "Failed to extract prefix and instance of unit name: %m");
2434                 return;
2435         }
2436
2437         msg = strjoina("unit=", p);
2438         if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2439                 if (errno == EPERM)
2440                         /* We aren't allowed to send audit messages?
2441                          * Then let's not retry again. */
2442                         close_audit_fd();
2443                 else
2444                         log_warning_errno(errno, "Failed to send audit message: %m");
2445         }
2446 #endif
2447
2448 }
2449
2450 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2451         static const union sockaddr_union sa = PLYMOUTH_SOCKET;
2452         _cleanup_free_ char *message = NULL;
2453         _cleanup_close_ int fd = -1;
2454         int n = 0;
2455
2456         /* Don't generate plymouth events if the service was already
2457          * started and we're just deserializing */
2458         if (MANAGER_IS_RELOADING(m))
2459                 return;
2460
2461         if (!MANAGER_IS_SYSTEM(m))
2462                 return;
2463
2464         if (detect_container() > 0)
2465                 return;
2466
2467         if (u->type != UNIT_SERVICE &&
2468             u->type != UNIT_MOUNT &&
2469             u->type != UNIT_SWAP)
2470                 return;
2471
2472         /* We set SOCK_NONBLOCK here so that we rather drop the
2473          * message then wait for plymouth */
2474         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2475         if (fd < 0) {
2476                 log_error_errno(errno, "socket() failed: %m");
2477                 return;
2478         }
2479
2480         if (connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
2481
2482                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2483                         log_error_errno(errno, "connect() failed: %m");
2484                 return;
2485         }
2486
2487         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2488                 log_oom();
2489                 return;
2490         }
2491
2492         errno = 0;
2493         if (write(fd, message, n + 1) != n + 1)
2494                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2495                         log_error_errno(errno, "Failed to write Plymouth message: %m");
2496 }
2497
2498 int manager_open_serialization(Manager *m, FILE **_f) {
2499         int fd;
2500         FILE *f;
2501
2502         assert(_f);
2503
2504         fd = open_serialization_fd("systemd-state");
2505         if (fd < 0)
2506                 return fd;
2507
2508         f = fdopen(fd, "w+");
2509         if (!f) {
2510                 safe_close(fd);
2511                 return -errno;
2512         }
2513
2514         *_f = f;
2515         return 0;
2516 }
2517
2518 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2519         Iterator i;
2520         Unit *u;
2521         const char *t;
2522         int r;
2523
2524         assert(m);
2525         assert(f);
2526         assert(fds);
2527
2528         m->n_reloading++;
2529
2530         fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2531         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2532         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2533         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2534
2535         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2536         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2537         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2538         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2539
2540         if (!in_initrd()) {
2541                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2542                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2543                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2544                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2545                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2546                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2547                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2548                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2549         }
2550
2551         if (!switching_root)
2552                 (void) serialize_environment(f, m->environment);
2553
2554         if (m->notify_fd >= 0) {
2555                 int copy;
2556
2557                 copy = fdset_put_dup(fds, m->notify_fd);
2558                 if (copy < 0)
2559                         return copy;
2560
2561                 fprintf(f, "notify-fd=%i\n", copy);
2562                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2563         }
2564
2565         if (m->cgroups_agent_fd >= 0) {
2566                 int copy;
2567
2568                 copy = fdset_put_dup(fds, m->cgroups_agent_fd);
2569                 if (copy < 0)
2570                         return copy;
2571
2572                 fprintf(f, "cgroups-agent-fd=%i\n", copy);
2573         }
2574
2575         if (m->user_lookup_fds[0] >= 0) {
2576                 int copy0, copy1;
2577
2578                 copy0 = fdset_put_dup(fds, m->user_lookup_fds[0]);
2579                 if (copy0 < 0)
2580                         return copy0;
2581
2582                 copy1 = fdset_put_dup(fds, m->user_lookup_fds[1]);
2583                 if (copy1 < 0)
2584                         return copy1;
2585
2586                 fprintf(f, "user-lookup=%i %i\n", copy0, copy1);
2587         }
2588
2589         bus_track_serialize(m->subscribed, f, "subscribed");
2590
2591         r = dynamic_user_serialize(m, f, fds);
2592         if (r < 0)
2593                 return r;
2594
2595         manager_serialize_uid_refs(m, f);
2596         manager_serialize_gid_refs(m, f);
2597
2598         fputc_unlocked('\n', f);
2599
2600         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2601                 if (u->id != t)
2602                         continue;
2603
2604                 /* Start marker */
2605                 fputs_unlocked(u->id, f);
2606                 fputc_unlocked('\n', f);
2607
2608                 r = unit_serialize(u, f, fds, !switching_root);
2609                 if (r < 0) {
2610                         m->n_reloading--;
2611                         return r;
2612                 }
2613         }
2614
2615         assert(m->n_reloading > 0);
2616         m->n_reloading--;
2617
2618         if (ferror(f))
2619                 return -EIO;
2620
2621         r = bus_fdset_add_all(m, fds);
2622         if (r < 0)
2623                 return r;
2624
2625         return 0;
2626 }
2627
2628 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2629         int r = 0;
2630
2631         assert(m);
2632         assert(f);
2633
2634         log_debug("Deserializing state...");
2635
2636         m->n_reloading++;
2637
2638         for (;;) {
2639                 char line[LINE_MAX];
2640                 const char *val, *l;
2641
2642                 if (!fgets(line, sizeof(line), f)) {
2643                         if (feof(f))
2644                                 r = 0;
2645                         else
2646                                 r = -errno;
2647
2648                         goto finish;
2649                 }
2650
2651                 char_array_0(line);
2652                 l = strstrip(line);
2653
2654                 if (l[0] == 0)
2655                         break;
2656
2657                 if ((val = startswith(l, "current-job-id="))) {
2658                         uint32_t id;
2659
2660                         if (safe_atou32(val, &id) < 0)
2661                                 log_notice("Failed to parse current job id value %s", val);
2662                         else
2663                                 m->current_job_id = MAX(m->current_job_id, id);
2664
2665                 } else if ((val = startswith(l, "n-installed-jobs="))) {
2666                         uint32_t n;
2667
2668                         if (safe_atou32(val, &n) < 0)
2669                                 log_notice("Failed to parse installed jobs counter %s", val);
2670                         else
2671                                 m->n_installed_jobs += n;
2672
2673                 } else if ((val = startswith(l, "n-failed-jobs="))) {
2674                         uint32_t n;
2675
2676                         if (safe_atou32(val, &n) < 0)
2677                                 log_notice("Failed to parse failed jobs counter %s", val);
2678                         else
2679                                 m->n_failed_jobs += n;
2680
2681                 } else if ((val = startswith(l, "taint-usr="))) {
2682                         int b;
2683
2684                         b = parse_boolean(val);
2685                         if (b < 0)
2686                                 log_notice("Failed to parse taint /usr flag %s", val);
2687                         else
2688                                 m->taint_usr = m->taint_usr || b;
2689
2690                 } else if ((val = startswith(l, "firmware-timestamp=")))
2691                         dual_timestamp_deserialize(val, &m->firmware_timestamp);
2692                 else if ((val = startswith(l, "loader-timestamp=")))
2693                         dual_timestamp_deserialize(val, &m->loader_timestamp);
2694                 else if ((val = startswith(l, "kernel-timestamp=")))
2695                         dual_timestamp_deserialize(val, &m->kernel_timestamp);
2696                 else if ((val = startswith(l, "initrd-timestamp=")))
2697                         dual_timestamp_deserialize(val, &m->initrd_timestamp);
2698                 else if ((val = startswith(l, "userspace-timestamp=")))
2699                         dual_timestamp_deserialize(val, &m->userspace_timestamp);
2700                 else if ((val = startswith(l, "finish-timestamp=")))
2701                         dual_timestamp_deserialize(val, &m->finish_timestamp);
2702                 else if ((val = startswith(l, "security-start-timestamp=")))
2703                         dual_timestamp_deserialize(val, &m->security_start_timestamp);
2704                 else if ((val = startswith(l, "security-finish-timestamp=")))
2705                         dual_timestamp_deserialize(val, &m->security_finish_timestamp);
2706                 else if ((val = startswith(l, "generators-start-timestamp=")))
2707                         dual_timestamp_deserialize(val, &m->generators_start_timestamp);
2708                 else if ((val = startswith(l, "generators-finish-timestamp=")))
2709                         dual_timestamp_deserialize(val, &m->generators_finish_timestamp);
2710                 else if ((val = startswith(l, "units-load-start-timestamp=")))
2711                         dual_timestamp_deserialize(val, &m->units_load_start_timestamp);
2712                 else if ((val = startswith(l, "units-load-finish-timestamp=")))
2713                         dual_timestamp_deserialize(val, &m->units_load_finish_timestamp);
2714                 else if (startswith(l, "env=")) {
2715                         r = deserialize_environment(&m->environment, l);
2716                         if (r == -ENOMEM)
2717                                 goto finish;
2718                         if (r < 0)
2719                                 log_notice_errno(r, "Failed to parse environment entry: \"%s\": %m", l);
2720
2721                 } else if ((val = startswith(l, "notify-fd="))) {
2722                         int fd;
2723
2724                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2725                                 log_notice("Failed to parse notify fd: \"%s\"", val);
2726                         else {
2727                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2728                                 safe_close(m->notify_fd);
2729                                 m->notify_fd = fdset_remove(fds, fd);
2730                         }
2731
2732                 } else if ((val = startswith(l, "notify-socket="))) {
2733                         char *n;
2734
2735                         n = strdup(val);
2736                         if (!n) {
2737                                 r = -ENOMEM;
2738                                 goto finish;
2739                         }
2740
2741                         free(m->notify_socket);
2742                         m->notify_socket = n;
2743
2744                 } else if ((val = startswith(l, "cgroups-agent-fd="))) {
2745                         int fd;
2746
2747                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2748                                 log_notice("Failed to parse cgroups agent fd: %s", val);
2749                         else {
2750                                 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
2751                                 safe_close(m->cgroups_agent_fd);
2752                                 m->cgroups_agent_fd = fdset_remove(fds, fd);
2753                         }
2754
2755                 } else if ((val = startswith(l, "user-lookup="))) {
2756                         int fd0, fd1;
2757
2758                         if (sscanf(val, "%i %i", &fd0, &fd1) != 2 || fd0 < 0 || fd1 < 0 || fd0 == fd1 || !fdset_contains(fds, fd0) || !fdset_contains(fds, fd1))
2759                                 log_notice("Failed to parse user lookup fd: %s", val);
2760                         else {
2761                                 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
2762                                 safe_close_pair(m->user_lookup_fds);
2763                                 m->user_lookup_fds[0] = fdset_remove(fds, fd0);
2764                                 m->user_lookup_fds[1] = fdset_remove(fds, fd1);
2765                         }
2766
2767                 } else if ((val = startswith(l, "dynamic-user=")))
2768                         dynamic_user_deserialize_one(m, val, fds);
2769                 else if ((val = startswith(l, "destroy-ipc-uid=")))
2770                         manager_deserialize_uid_refs_one(m, val);
2771                 else if ((val = startswith(l, "destroy-ipc-gid=")))
2772                         manager_deserialize_gid_refs_one(m, val);
2773                 else if ((val = startswith(l, "subscribed="))) {
2774
2775                         if (strv_extend(&m->deserialized_subscribed, val) < 0)
2776                                 log_oom();
2777
2778                 } else if (!startswith(l, "kdbus-fd=")) /* ignore this one */
2779                         log_notice("Unknown serialization item '%s'", l);
2780         }
2781
2782         for (;;) {
2783                 Unit *u;
2784                 char name[UNIT_NAME_MAX+2];
2785                 const char* unit_name;
2786
2787                 /* Start marker */
2788                 if (!fgets(name, sizeof(name), f)) {
2789                         if (feof(f))
2790                                 r = 0;
2791                         else
2792                                 r = -errno;
2793
2794                         goto finish;
2795                 }
2796
2797                 char_array_0(name);
2798                 unit_name = strstrip(name);
2799
2800                 r = manager_load_unit(m, unit_name, NULL, NULL, &u);
2801                 if (r < 0) {
2802                         log_notice_errno(r, "Failed to load unit \"%s\", skipping deserialization: %m", unit_name);
2803                         if (r == -ENOMEM)
2804                                 goto finish;
2805                         unit_deserialize_skip(f);
2806                         continue;
2807                 }
2808
2809                 r = unit_deserialize(u, f, fds);
2810                 if (r < 0) {
2811                         log_notice_errno(r, "Failed to deserialize unit \"%s\": %m", unit_name);
2812                         if (r == -ENOMEM)
2813                                 goto finish;
2814                 }
2815         }
2816
2817 finish:
2818         if (ferror(f))
2819                 r = -EIO;
2820
2821         assert(m->n_reloading > 0);
2822         m->n_reloading--;
2823
2824         return r;
2825 }
2826
2827 int manager_reload(Manager *m) {
2828         int r, q;
2829         _cleanup_fclose_ FILE *f = NULL;
2830         _cleanup_fdset_free_ FDSet *fds = NULL;
2831
2832         assert(m);
2833
2834         r = manager_open_serialization(m, &f);
2835         if (r < 0)
2836                 return r;
2837
2838         m->n_reloading++;
2839         bus_manager_send_reloading(m, true);
2840
2841         fds = fdset_new();
2842         if (!fds) {
2843                 m->n_reloading--;
2844                 return -ENOMEM;
2845         }
2846
2847         r = manager_serialize(m, f, fds, false);
2848         if (r < 0) {
2849                 m->n_reloading--;
2850                 return r;
2851         }
2852
2853         if (fseeko(f, 0, SEEK_SET) < 0) {
2854                 m->n_reloading--;
2855                 return -errno;
2856         }
2857
2858         /* From here on there is no way back. */
2859         manager_clear_jobs_and_units(m);
2860         lookup_paths_flush_generator(&m->lookup_paths);
2861         lookup_paths_free(&m->lookup_paths);
2862         dynamic_user_vacuum(m, false);
2863         m->uid_refs = hashmap_free(m->uid_refs);
2864         m->gid_refs = hashmap_free(m->gid_refs);
2865
2866         q = lookup_paths_init(&m->lookup_paths, m->unit_file_scope, 0, NULL);
2867         if (q < 0 && r >= 0)
2868                 r = q;
2869
2870         q = manager_run_environment_generators(m);
2871         if (q < 0 && r >= 0)
2872                 r = q;
2873
2874         /* Find new unit paths */
2875         q = manager_run_generators(m);
2876         if (q < 0 && r >= 0)
2877                 r = q;
2878
2879         lookup_paths_reduce(&m->lookup_paths);
2880         manager_build_unit_path_cache(m);
2881
2882         /* First, enumerate what we can from all config files */
2883         manager_enumerate(m);
2884
2885         /* Second, deserialize our stored data */
2886         q = manager_deserialize(m, f, fds);
2887         if (q < 0) {
2888                 log_error_errno(q, "Deserialization failed: %m");
2889
2890                 if (r >= 0)
2891                         r = q;
2892         }
2893
2894         fclose(f);
2895         f = NULL;
2896
2897         /* Re-register notify_fd as event source */
2898         q = manager_setup_notify(m);
2899         if (q < 0 && r >= 0)
2900                 r = q;
2901
2902         q = manager_setup_cgroups_agent(m);
2903         if (q < 0 && r >= 0)
2904                 r = q;
2905
2906         q = manager_setup_user_lookup_fd(m);
2907         if (q < 0 && r >= 0)
2908                 r = q;
2909
2910         /* Third, fire things up! */
2911         manager_coldplug(m);
2912
2913         /* Release any dynamic users no longer referenced */
2914         dynamic_user_vacuum(m, true);
2915
2916         /* Release any references to UIDs/GIDs no longer referenced, and destroy any IPC owned by them */
2917         manager_vacuum_uid_refs(m);
2918         manager_vacuum_gid_refs(m);
2919
2920         /* Sync current state of bus names with our set of listening units */
2921         if (m->api_bus)
2922                 manager_sync_bus_names(m, m->api_bus);
2923
2924         assert(m->n_reloading > 0);
2925         m->n_reloading--;
2926
2927         m->send_reloading_done = true;
2928
2929         return r;
2930 }
2931
2932 void manager_reset_failed(Manager *m) {
2933         Unit *u;
2934         Iterator i;
2935
2936         assert(m);
2937
2938         HASHMAP_FOREACH(u, m->units, i)
2939                 unit_reset_failed(u);
2940 }
2941
2942 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2943         Unit *u;
2944
2945         assert(m);
2946         assert(name);
2947
2948         /* Returns true if the unit is inactive or going down */
2949         u = manager_get_unit(m, name);
2950         if (!u)
2951                 return true;
2952
2953         return unit_inactive_or_pending(u);
2954 }
2955
2956 static void manager_notify_finished(Manager *m) {
2957         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2958         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2959
2960         if (m->test_run)
2961                 return;
2962
2963         if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0) {
2964
2965                 /* Note that m->kernel_usec.monotonic is always at 0,
2966                  * and m->firmware_usec.monotonic and
2967                  * m->loader_usec.monotonic should be considered
2968                  * negative values. */
2969
2970                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2971                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2972                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2973                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2974
2975                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2976
2977                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2978                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2979
2980                         log_struct(LOG_INFO,
2981                                    "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
2982                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2983                                    "INITRD_USEC="USEC_FMT, initrd_usec,
2984                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2985                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2986                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2987                                                format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2988                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2989                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2990                                    NULL);
2991                 } else {
2992                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2993                         initrd_usec = 0;
2994
2995                         log_struct(LOG_INFO,
2996                                    "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
2997                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2998                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2999                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
3000                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
3001                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
3002                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3003                                    NULL);
3004                 }
3005         } else {
3006                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
3007                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
3008
3009                 log_struct(LOG_INFO,
3010                            "MESSAGE_ID=" SD_MESSAGE_USER_STARTUP_FINISHED_STR,
3011                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
3012                            LOG_MESSAGE("Startup finished in %s.",
3013                                        format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3014                            NULL);
3015         }
3016
3017         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
3018
3019         sd_notifyf(false,
3020                    "READY=1\n"
3021                    "STATUS=Startup finished in %s.",
3022                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
3023 }
3024
3025 void manager_check_finished(Manager *m) {
3026         assert(m);
3027
3028         if (MANAGER_IS_RELOADING(m))
3029                 return;
3030
3031         /* Verify that we are actually running currently. Initially
3032          * the exit code is set to invalid, and during operation it is
3033          * then set to MANAGER_OK */
3034         if (m->exit_code != MANAGER_OK)
3035                 return;
3036
3037         if (hashmap_size(m->jobs) > 0) {
3038                 if (m->jobs_in_progress_event_source)
3039                         /* Ignore any failure, this is only for feedback */
3040                         (void) sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
3041
3042                 return;
3043         }
3044
3045         manager_flip_auto_status(m, false);
3046
3047         /* Notify Type=idle units that we are done now */
3048         manager_close_idle_pipe(m);
3049
3050         /* Turn off confirm spawn now */
3051         m->confirm_spawn = NULL;
3052
3053         /* No need to update ask password status when we're going non-interactive */
3054         manager_close_ask_password(m);
3055
3056         /* This is no longer the first boot */
3057         manager_set_first_boot(m, false);
3058
3059         if (dual_timestamp_is_set(&m->finish_timestamp))
3060                 return;
3061
3062         dual_timestamp_get(&m->finish_timestamp);
3063
3064         manager_notify_finished(m);
3065
3066         manager_invalidate_startup_units(m);
3067 }
3068
3069 static bool generator_path_any(const char* const* paths) {
3070         char **path;
3071         bool found = false;
3072
3073         /* Optimize by skipping the whole process by not creating output directories
3074          * if no generators are found. */
3075         STRV_FOREACH(path, (char**) paths)
3076                 if (access(*path, F_OK) == 0)
3077                         found = true;
3078                 else if (errno != ENOENT)
3079                         log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
3080
3081         return found;
3082 }
3083
3084 static const char* system_env_generator_binary_paths[] = {
3085         "/run/systemd/system-environment-generators",
3086         "/etc/systemd/system-environment-generators",
3087         "/usr/local/lib/systemd/system-environment-generators",
3088         SYSTEM_ENV_GENERATOR_PATH,
3089         NULL
3090 };
3091
3092 static const char* user_env_generator_binary_paths[] = {
3093         "/run/systemd/user-environment-generators",
3094         "/etc/systemd/user-environment-generators",
3095         "/usr/local/lib/systemd/user-environment-generators",
3096         USER_ENV_GENERATOR_PATH,
3097         NULL
3098 };
3099
3100 static int manager_run_environment_generators(Manager *m) {
3101         char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
3102         const char **paths;
3103         void* args[] = {&tmp, &tmp, &m->environment};
3104
3105         if (m->test_run)
3106                 return 0;
3107
3108         paths = MANAGER_IS_SYSTEM(m) ? system_env_generator_binary_paths : user_env_generator_binary_paths;
3109
3110         if (!generator_path_any(paths))
3111                 return 0;
3112
3113         return execute_directories(paths, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL);
3114 }
3115
3116 static int manager_run_generators(Manager *m) {
3117         _cleanup_strv_free_ char **paths = NULL;
3118         const char *argv[5];
3119         int r;
3120
3121         assert(m);
3122
3123         if (m->test_run)
3124                 return 0;
3125
3126         paths = generator_binary_paths(m->unit_file_scope);
3127         if (!paths)
3128                 return log_oom();
3129
3130         if (!generator_path_any((const char* const*) paths))
3131                 return 0;
3132
3133         r = lookup_paths_mkdir_generator(&m->lookup_paths);
3134         if (r < 0)
3135                 goto finish;
3136
3137         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
3138         argv[1] = m->lookup_paths.generator;
3139         argv[2] = m->lookup_paths.generator_early;
3140         argv[3] = m->lookup_paths.generator_late;
3141         argv[4] = NULL;
3142
3143         RUN_WITH_UMASK(0022)
3144                 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC,
3145                                     NULL, NULL, (char**) argv);
3146
3147 finish:
3148         lookup_paths_trim_generator(&m->lookup_paths);
3149         return r;
3150 }
3151
3152 int manager_environment_add(Manager *m, char **minus, char **plus) {
3153         char **a = NULL, **b = NULL, **l;
3154         assert(m);
3155
3156         l = m->environment;
3157
3158         if (!strv_isempty(minus)) {
3159                 a = strv_env_delete(l, 1, minus);
3160                 if (!a)
3161                         return -ENOMEM;
3162
3163                 l = a;
3164         }
3165
3166         if (!strv_isempty(plus)) {
3167                 b = strv_env_merge(2, l, plus);
3168                 if (!b) {
3169                         strv_free(a);
3170                         return -ENOMEM;
3171                 }
3172
3173                 l = b;
3174         }
3175
3176         if (m->environment != l)
3177                 strv_free(m->environment);
3178         if (a != l)
3179                 strv_free(a);
3180         if (b != l)
3181                 strv_free(b);
3182
3183         m->environment = l;
3184         manager_clean_environment(m);
3185         strv_sort(m->environment);
3186
3187         return 0;
3188 }
3189
3190 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
3191         int i;
3192
3193         assert(m);
3194
3195         for (i = 0; i < _RLIMIT_MAX; i++) {
3196                 m->rlimit[i] = mfree(m->rlimit[i]);
3197
3198                 if (!default_rlimit[i])
3199                         continue;
3200
3201                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
3202                 if (!m->rlimit[i])
3203                         return log_oom();
3204         }
3205
3206         return 0;
3207 }
3208
3209 void manager_recheck_journal(Manager *m) {
3210         Unit *u;
3211
3212         assert(m);
3213
3214         if (!MANAGER_IS_SYSTEM(m))
3215                 return;
3216
3217         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
3218         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
3219                 log_close_journal();
3220                 return;
3221         }
3222
3223         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
3224         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
3225                 log_close_journal();
3226                 return;
3227         }
3228
3229         /* Hmm, OK, so the socket is fully up and the service is up
3230          * too, then let's make use of the thing. */
3231         log_open();
3232 }
3233
3234 void manager_set_show_status(Manager *m, ShowStatus mode) {
3235         assert(m);
3236         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
3237
3238         if (!MANAGER_IS_SYSTEM(m))
3239                 return;
3240
3241         if (m->show_status != mode)
3242                 log_debug("%s showing of status.",
3243                           mode == SHOW_STATUS_NO ? "Disabling" : "Enabling");
3244         m->show_status = mode;
3245
3246         if (mode > 0)
3247                 (void) touch("/run/systemd/show-status");
3248         else
3249                 (void) unlink("/run/systemd/show-status");
3250 }
3251
3252 static bool manager_get_show_status(Manager *m, StatusType type) {
3253         assert(m);
3254
3255         if (!MANAGER_IS_SYSTEM(m))
3256                 return false;
3257
3258         if (m->no_console_output)
3259                 return false;
3260
3261         if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
3262                 return false;
3263
3264         /* If we cannot find out the status properly, just proceed. */
3265         if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
3266                 return false;
3267
3268         if (m->show_status > 0)
3269                 return true;
3270
3271         return false;
3272 }
3273
3274 const char *manager_get_confirm_spawn(Manager *m) {
3275         static int last_errno = 0;
3276         const char *vc = m->confirm_spawn;
3277         struct stat st;
3278         int r;
3279
3280         /* Here's the deal: we want to test the validity of the console but don't want
3281          * PID1 to go through the whole console process which might block. But we also
3282          * want to warn the user only once if something is wrong with the console so we
3283          * cannot do the sanity checks after spawning our children. So here we simply do
3284          * really basic tests to hopefully trap common errors.
3285          *
3286          * If the console suddenly disappear at the time our children will really it
3287          * then they will simply fail to acquire it and a positive answer will be
3288          * assumed. New children will fallback to /dev/console though.
3289          *
3290          * Note: TTYs are devices that can come and go any time, and frequently aren't
3291          * available yet during early boot (consider a USB rs232 dongle...). If for any
3292          * reason the configured console is not ready, we fallback to the default
3293          * console. */
3294
3295         if (!vc || path_equal(vc, "/dev/console"))
3296                 return vc;
3297
3298         r = stat(vc, &st);
3299         if (r < 0)
3300                 goto fail;
3301
3302         if (!S_ISCHR(st.st_mode)) {
3303                 errno = ENOTTY;
3304                 goto fail;
3305         }
3306
3307         last_errno = 0;
3308         return vc;
3309 fail:
3310         if (last_errno != errno) {
3311                 last_errno = errno;
3312                 log_warning_errno(errno, "Failed to open %s: %m, using default console", vc);
3313         }
3314         return "/dev/console";
3315 }
3316
3317 void manager_set_first_boot(Manager *m, bool b) {
3318         assert(m);
3319
3320         if (!MANAGER_IS_SYSTEM(m))
3321                 return;
3322
3323         if (m->first_boot != (int) b) {
3324                 if (b)
3325                         (void) touch("/run/systemd/first-boot");
3326                 else
3327                         (void) unlink("/run/systemd/first-boot");
3328         }
3329
3330         m->first_boot = b;
3331 }
3332
3333 void manager_disable_confirm_spawn(void) {
3334         (void) touch("/run/systemd/confirm_spawn_disabled");
3335 }
3336
3337 bool manager_is_confirm_spawn_disabled(Manager *m) {
3338         if (!m->confirm_spawn)
3339                 return true;
3340
3341         return access("/run/systemd/confirm_spawn_disabled", F_OK) >= 0;
3342 }
3343
3344 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3345         va_list ap;
3346
3347         /* If m is NULL, assume we're after shutdown and let the messages through. */
3348
3349         if (m && !manager_get_show_status(m, type))
3350                 return;
3351
3352         /* XXX We should totally drop the check for ephemeral here
3353          * and thus effectively make 'Type=idle' pointless. */
3354         if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3355                 return;
3356
3357         va_start(ap, format);
3358         status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3359         va_end(ap);
3360 }
3361
3362 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3363         char p[strlen(path)+1];
3364
3365         assert(m);
3366         assert(path);
3367
3368         strcpy(p, path);
3369         path_kill_slashes(p);
3370
3371         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3372 }
3373
3374 int manager_set_exec_params(Manager *m, ExecParameters *p) {
3375         assert(m);
3376         assert(p);
3377
3378         p->environment = m->environment;
3379         p->confirm_spawn = manager_get_confirm_spawn(m);
3380         p->cgroup_supported = m->cgroup_supported;
3381         p->prefix = m->prefix;
3382
3383         return 0;
3384 }
3385
3386 int manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3387         unsigned size;
3388         int r;
3389
3390         assert(m);
3391         assert(u->manager == m);
3392
3393         size = set_size(m->failed_units);
3394
3395         if (failed) {
3396                 r = set_ensure_allocated(&m->failed_units, NULL);
3397                 if (r < 0)
3398                         return log_oom();
3399
3400                 if (set_put(m->failed_units, u) < 0)
3401                         return log_oom();
3402         } else
3403                 (void) set_remove(m->failed_units, u);
3404
3405         if (set_size(m->failed_units) != size)
3406                 bus_manager_send_change_signal(m);
3407
3408         return 0;
3409 }
3410
3411 ManagerState manager_state(Manager *m) {
3412         Unit *u;
3413
3414         assert(m);
3415
3416         /* Did we ever finish booting? If not then we are still starting up */
3417         if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3418
3419                 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3420                 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3421                         return MANAGER_INITIALIZING;
3422
3423                 return MANAGER_STARTING;
3424         }
3425
3426         /* Is the special shutdown target queued? If so, we are in shutdown state */
3427         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3428         if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_RELOAD_OR_START))
3429                 return MANAGER_STOPPING;
3430
3431         /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3432         u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3433         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3434                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_RELOAD_OR_START))))
3435                 return MANAGER_MAINTENANCE;
3436
3437         u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3438         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3439                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_RELOAD_OR_START))))
3440                 return MANAGER_MAINTENANCE;
3441
3442         /* Are there any failed units? If so, we are in degraded mode */
3443         if (set_size(m->failed_units) > 0)
3444                 return MANAGER_DEGRADED;
3445
3446         return MANAGER_RUNNING;
3447 }
3448
3449 #define DESTROY_IPC_FLAG (UINT32_C(1) << 31)
3450
3451 static void manager_unref_uid_internal(
3452                 Manager *m,
3453                 Hashmap **uid_refs,
3454                 uid_t uid,
3455                 bool destroy_now,
3456                 int (*_clean_ipc)(uid_t uid)) {
3457
3458         uint32_t c, n;
3459
3460         assert(m);
3461         assert(uid_refs);
3462         assert(uid_is_valid(uid));
3463         assert(_clean_ipc);
3464
3465         /* A generic implementation, covering both manager_unref_uid() and manager_unref_gid(), under the assumption
3466          * that uid_t and gid_t are actually defined the same way, with the same validity rules.
3467          *
3468          * We store a hashmap where the UID/GID is they key and the value is a 32bit reference counter, whose highest
3469          * bit is used as flag for marking UIDs/GIDs whose IPC objects to remove when the last reference to the UID/GID
3470          * is dropped. The flag is set to on, once at least one reference from a unit where RemoveIPC= is set is added
3471          * on a UID/GID. It is reset when the UID's/GID's reference counter drops to 0 again. */
3472
3473         assert_cc(sizeof(uid_t) == sizeof(gid_t));
3474         assert_cc(UID_INVALID == (uid_t) GID_INVALID);
3475
3476         if (uid == 0) /* We don't keep track of root, and will never destroy it */
3477                 return;
3478
3479         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3480
3481         n = c & ~DESTROY_IPC_FLAG;
3482         assert(n > 0);
3483         n--;
3484
3485         if (destroy_now && n == 0) {
3486                 hashmap_remove(*uid_refs, UID_TO_PTR(uid));
3487
3488                 if (c & DESTROY_IPC_FLAG) {
3489                         log_debug("%s " UID_FMT " is no longer referenced, cleaning up its IPC.",
3490                                   _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
3491                                   uid);
3492                         (void) _clean_ipc(uid);
3493                 }
3494         } else {
3495                 c = n | (c & DESTROY_IPC_FLAG);
3496                 assert_se(hashmap_update(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c)) >= 0);
3497         }
3498 }
3499
3500 void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now) {
3501         manager_unref_uid_internal(m, &m->uid_refs, uid, destroy_now, clean_ipc_by_uid);
3502 }
3503
3504 void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now) {
3505         manager_unref_uid_internal(m, &m->gid_refs, (uid_t) gid, destroy_now, clean_ipc_by_gid);
3506 }
3507
3508 static int manager_ref_uid_internal(
3509                 Manager *m,
3510                 Hashmap **uid_refs,
3511                 uid_t uid,
3512                 bool clean_ipc) {
3513
3514         uint32_t c, n;
3515         int r;
3516
3517         assert(m);
3518         assert(uid_refs);
3519         assert(uid_is_valid(uid));
3520
3521         /* A generic implementation, covering both manager_ref_uid() and manager_ref_gid(), under the assumption
3522          * that uid_t and gid_t are actually defined the same way, with the same validity rules. */
3523
3524         assert_cc(sizeof(uid_t) == sizeof(gid_t));
3525         assert_cc(UID_INVALID == (uid_t) GID_INVALID);
3526
3527         if (uid == 0) /* We don't keep track of root, and will never destroy it */
3528                 return 0;
3529
3530         r = hashmap_ensure_allocated(uid_refs, &trivial_hash_ops);
3531         if (r < 0)
3532                 return r;
3533
3534         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3535
3536         n = c & ~DESTROY_IPC_FLAG;
3537         n++;
3538
3539         if (n & DESTROY_IPC_FLAG) /* check for overflow */
3540                 return -EOVERFLOW;
3541
3542         c = n | (c & DESTROY_IPC_FLAG) | (clean_ipc ? DESTROY_IPC_FLAG : 0);
3543
3544         return hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
3545 }
3546
3547 int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc) {
3548         return manager_ref_uid_internal(m, &m->uid_refs, uid, clean_ipc);
3549 }
3550
3551 int manager_ref_gid(Manager *m, gid_t gid, bool clean_ipc) {
3552         return manager_ref_uid_internal(m, &m->gid_refs, (uid_t) gid, clean_ipc);
3553 }
3554
3555 static void manager_vacuum_uid_refs_internal(
3556                 Manager *m,
3557                 Hashmap **uid_refs,
3558                 int (*_clean_ipc)(uid_t uid)) {
3559
3560         Iterator i;
3561         void *p, *k;
3562
3563         assert(m);
3564         assert(uid_refs);
3565         assert(_clean_ipc);
3566
3567         HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
3568                 uint32_t c, n;
3569                 uid_t uid;
3570
3571                 uid = PTR_TO_UID(k);
3572                 c = PTR_TO_UINT32(p);
3573
3574                 n = c & ~DESTROY_IPC_FLAG;
3575                 if (n > 0)
3576                         continue;
3577
3578                 if (c & DESTROY_IPC_FLAG) {
3579                         log_debug("Found unreferenced %s " UID_FMT " after reload/reexec. Cleaning up.",
3580                                   _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
3581                                   uid);
3582                         (void) _clean_ipc(uid);
3583                 }
3584
3585                 assert_se(hashmap_remove(*uid_refs, k) == p);
3586         }
3587 }
3588
3589 void manager_vacuum_uid_refs(Manager *m) {
3590         manager_vacuum_uid_refs_internal(m, &m->uid_refs, clean_ipc_by_uid);
3591 }
3592
3593 void manager_vacuum_gid_refs(Manager *m) {
3594         manager_vacuum_uid_refs_internal(m, &m->gid_refs, clean_ipc_by_gid);
3595 }
3596
3597 static void manager_serialize_uid_refs_internal(
3598                 Manager *m,
3599                 FILE *f,
3600                 Hashmap **uid_refs,
3601                 const char *field_name) {
3602
3603         Iterator i;
3604         void *p, *k;
3605
3606         assert(m);
3607         assert(f);
3608         assert(uid_refs);
3609         assert(field_name);
3610
3611         /* Serialize the UID reference table. Or actually, just the IPC destruction flag of it, as the actual counter
3612          * of it is better rebuild after a reload/reexec. */
3613
3614         HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
3615                 uint32_t c;
3616                 uid_t uid;
3617
3618                 uid = PTR_TO_UID(k);
3619                 c = PTR_TO_UINT32(p);
3620
3621                 if (!(c & DESTROY_IPC_FLAG))
3622                         continue;
3623
3624                 fprintf(f, "%s=" UID_FMT "\n", field_name, uid);
3625         }
3626 }
3627
3628 void manager_serialize_uid_refs(Manager *m, FILE *f) {
3629         manager_serialize_uid_refs_internal(m, f, &m->uid_refs, "destroy-ipc-uid");
3630 }
3631
3632 void manager_serialize_gid_refs(Manager *m, FILE *f) {
3633         manager_serialize_uid_refs_internal(m, f, &m->gid_refs, "destroy-ipc-gid");
3634 }
3635
3636 static void manager_deserialize_uid_refs_one_internal(
3637                 Manager *m,
3638                 Hashmap** uid_refs,
3639                 const char *value) {
3640
3641         uid_t uid;
3642         uint32_t c;
3643         int r;
3644
3645         assert(m);
3646         assert(uid_refs);
3647         assert(value);
3648
3649         r = parse_uid(value, &uid);
3650         if (r < 0 || uid == 0) {
3651                 log_debug("Unable to parse UID reference serialization");
3652                 return;
3653         }
3654
3655         r = hashmap_ensure_allocated(uid_refs, &trivial_hash_ops);
3656         if (r < 0) {
3657                 log_oom();
3658                 return;
3659         }
3660
3661         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3662         if (c & DESTROY_IPC_FLAG)
3663                 return;
3664
3665         c |= DESTROY_IPC_FLAG;
3666
3667         r = hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
3668         if (r < 0) {
3669                 log_debug("Failed to add UID reference entry");
3670                 return;
3671         }
3672 }
3673
3674 void manager_deserialize_uid_refs_one(Manager *m, const char *value) {
3675         manager_deserialize_uid_refs_one_internal(m, &m->uid_refs, value);
3676 }
3677
3678 void manager_deserialize_gid_refs_one(Manager *m, const char *value) {
3679         manager_deserialize_uid_refs_one_internal(m, &m->gid_refs, value);
3680 }
3681
3682 int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
3683         struct buffer {
3684                 uid_t uid;
3685                 gid_t gid;
3686                 char unit_name[UNIT_NAME_MAX+1];
3687         } _packed_ buffer;
3688
3689         Manager *m = userdata;
3690         ssize_t l;
3691         size_t n;
3692         Unit *u;
3693
3694         assert_se(source);
3695         assert_se(m);
3696
3697         /* Invoked whenever a child process succeeded resolving its user/group to use and sent us the resulting UID/GID
3698          * in a datagram. We parse the datagram here and pass it off to the unit, so that it can add a reference to the
3699          * UID/GID so that it can destroy the UID/GID's IPC objects when the reference counter drops to 0. */
3700
3701         l = recv(fd, &buffer, sizeof(buffer), MSG_DONTWAIT);
3702         if (l < 0) {
3703                 if (errno == EINTR || errno == EAGAIN)
3704                         return 0;
3705
3706                 return log_error_errno(errno, "Failed to read from user lookup fd: %m");
3707         }
3708
3709         if ((size_t) l <= offsetof(struct buffer, unit_name)) {
3710                 log_warning("Received too short user lookup message, ignoring.");
3711                 return 0;
3712         }
3713
3714         if ((size_t) l > offsetof(struct buffer, unit_name) + UNIT_NAME_MAX) {
3715                 log_warning("Received too long user lookup message, ignoring.");
3716                 return 0;
3717         }
3718
3719         if (!uid_is_valid(buffer.uid) && !gid_is_valid(buffer.gid)) {
3720                 log_warning("Got user lookup message with invalid UID/GID pair, ignoring.");
3721                 return 0;
3722         }
3723
3724         n = (size_t) l - offsetof(struct buffer, unit_name);
3725         if (memchr(buffer.unit_name, 0, n)) {
3726                 log_warning("Received lookup message with embedded NUL character, ignoring.");
3727                 return 0;
3728         }
3729
3730         buffer.unit_name[n] = 0;
3731         u = manager_get_unit(m, buffer.unit_name);
3732         if (!u) {
3733                 log_debug("Got user lookup message but unit doesn't exist, ignoring.");
3734                 return 0;
3735         }
3736
3737         log_unit_debug(u, "User lookup succeeded: uid=" UID_FMT " gid=" GID_FMT, buffer.uid, buffer.gid);
3738
3739         unit_notify_user_lookup(u, buffer.uid, buffer.gid);
3740         return 0;
3741 }
3742
3743 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3744         [MANAGER_INITIALIZING] = "initializing",
3745         [MANAGER_STARTING] = "starting",
3746         [MANAGER_RUNNING] = "running",
3747         [MANAGER_DEGRADED] = "degraded",
3748         [MANAGER_MAINTENANCE] = "maintenance",
3749         [MANAGER_STOPPING] = "stopping",
3750 };
3751
3752 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);