src/core/manager.c

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