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
  40 #ifdef HAVE_AUDIT
  41 #include <libaudit.h>
  42 #endif
  43
  44 #include <systemd/sd-daemon.h>
  45
  46 #include "manager.h"
  47 #include "hashmap.h"
  48 #include "macro.h"
  49 #include "strv.h"
  50 #include "log.h"
  51 #include "util.h"
  52 #include "mkdir.h"
  53 #include "ratelimit.h"
  54 #include "cgroup.h"
  55 #include "mount-setup.h"
  56 #include "unit-name.h"
  57 #include "dbus-unit.h"
  58 #include "dbus-job.h"
  59 #include "missing.h"
  60 #include "path-lookup.h"
  61 #include "special.h"
  62 #include "bus-errors.h"
  63 #include "exit-status.h"
  64 #include "virt.h"
  65 #include "watchdog.h"
  66 #include "cgroup-util.h"
  67
  68 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
  69 #define GC_QUEUE_ENTRIES_MAX 16
  70
  71 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
  72 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
  73
  74 /* Where clients shall send notification messages to */
  75 #define NOTIFY_SOCKET_SYSTEM "/run/systemd/notify"
  76 #define NOTIFY_SOCKET_USER "@/org/freedesktop/systemd1/notify"
  77
  78 static int manager_setup_notify(Manager *m) {
  79         union {
  80                 struct sockaddr sa;
  81                 struct sockaddr_un un;
  82         } sa;
  83         struct epoll_event ev;
  84         int one = 1, r;
  85         mode_t u;
  86
  87         assert(m);
  88
  89         m->notify_watch.type = WATCH_NOTIFY;
  90         if ((m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
  91                 log_error("Failed to allocate notification socket: %m");
  92                 return -errno;
  93         }
  94
  95         zero(sa);
  96         sa.sa.sa_family = AF_UNIX;
  97
  98         if (getpid() != 1)
  99                 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET_USER "/%llu", random_ull());
 100         else {
 101                 unlink(NOTIFY_SOCKET_SYSTEM);
 102                 strncpy(sa.un.sun_path, NOTIFY_SOCKET_SYSTEM, sizeof(sa.un.sun_path));
 103         }
 104
 105         if (sa.un.sun_path[0] == '@')
 106                 sa.un.sun_path[0] = 0;
 107
 108         u = umask(0111);
 109         r = bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
 110         umask(u);
 111
 112         if (r < 0) {
 113                 log_error("bind() failed: %m");
 114                 return -errno;
 115         }
 116
 117         if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
 118                 log_error("SO_PASSCRED failed: %m");
 119                 return -errno;
 120         }
 121
 122         zero(ev);
 123         ev.events = EPOLLIN;
 124         ev.data.ptr = &m->notify_watch;
 125
 126         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
 127                 return -errno;
 128
 129         if (sa.un.sun_path[0] == 0)
 130                 sa.un.sun_path[0] = '@';
 131
 132         if (!(m->notify_socket = strdup(sa.un.sun_path)))
 133                 return -ENOMEM;
 134
 135         log_debug("Using notification socket %s", m->notify_socket);
 136
 137         return 0;
 138 }
 139
 140 static int enable_special_signals(Manager *m) {
 141         int fd;
 142
 143         assert(m);
 144
 145         /* Enable that we get SIGINT on control-alt-del. In containers
 146          * this will fail with EPERM, so ignore that. */
 147         if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM)
 148                 log_warning("Failed to enable ctrl-alt-del handling: %m");
 149
 150         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 151         if (fd < 0) {
 152                 /* Support systems without virtual console */
 153                 if (fd != -ENOENT)
 154                         log_warning("Failed to open /dev/tty0: %m");
 155         } else {
 156                 /* Enable that we get SIGWINCH on kbrequest */
 157                 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
 158                         log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
 159
 160                 close_nointr_nofail(fd);
 161         }
 162
 163         return 0;
 164 }
 165
 166 static int manager_setup_signals(Manager *m) {
 167         sigset_t mask;
 168         struct epoll_event ev;
 169         struct sigaction sa;
 170
 171         assert(m);
 172
 173         /* We are not interested in SIGSTOP and friends. */
 174         zero(sa);
 175         sa.sa_handler = SIG_DFL;
 176         sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
 177         assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 178
 179         assert_se(sigemptyset(&mask) == 0);
 180
 181         sigset_add_many(&mask,
 182                         SIGCHLD,     /* Child died */
 183                         SIGTERM,     /* Reexecute daemon */
 184                         SIGHUP,      /* Reload configuration */
 185                         SIGUSR1,     /* systemd/upstart: reconnect to D-Bus */
 186                         SIGUSR2,     /* systemd: dump status */
 187                         SIGINT,      /* Kernel sends us this on control-alt-del */
 188                         SIGWINCH,    /* Kernel sends us this on kbrequest (alt-arrowup) */
 189                         SIGPWR,      /* Some kernel drivers and upsd send us this on power failure */
 190                         SIGRTMIN+0,  /* systemd: start default.target */
 191                         SIGRTMIN+1,  /* systemd: isolate rescue.target */
 192                         SIGRTMIN+2,  /* systemd: isolate emergency.target */
 193                         SIGRTMIN+3,  /* systemd: start halt.target */
 194                         SIGRTMIN+4,  /* systemd: start poweroff.target */
 195                         SIGRTMIN+5,  /* systemd: start reboot.target */
 196                         SIGRTMIN+6,  /* systemd: start kexec.target */
 197                         SIGRTMIN+13, /* systemd: Immediate halt */
 198                         SIGRTMIN+14, /* systemd: Immediate poweroff */
 199                         SIGRTMIN+15, /* systemd: Immediate reboot */
 200                         SIGRTMIN+16, /* systemd: Immediate kexec */
 201                         SIGRTMIN+20, /* systemd: enable status messages */
 202                         SIGRTMIN+21, /* systemd: disable status messages */
 203                         SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
 204                         SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
 205                         SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
 206                         SIGRTMIN+27, /* systemd: set log target to console */
 207                         SIGRTMIN+28, /* systemd: set log target to kmsg */
 208                         SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
 209                         -1);
 210         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
 211
 212         m->signal_watch.type = WATCH_SIGNAL;
 213         if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
 214                 return -errno;
 215
 216         zero(ev);
 217         ev.events = EPOLLIN;
 218         ev.data.ptr = &m->signal_watch;
 219
 220         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
 221                 return -errno;
 222
 223         if (m->running_as == MANAGER_SYSTEM)
 224                 return enable_special_signals(m);
 225
 226         return 0;
 227 }
 228
 229 static void manager_strip_environment(Manager *m) {
 230         assert(m);
 231
 232         /* Remove variables from the inherited set that are part of
 233          * the container interface:
 234          * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
 235         strv_remove_prefix(m->environment, "container=");
 236         strv_remove_prefix(m->environment, "container_");
 237
 238         /* Remove variables from the inherited set that are part of
 239          * the initrd interface:
 240          * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
 241         strv_remove_prefix(m->environment, "RD_");
 242 }
 243
 244 int manager_new(ManagerRunningAs running_as, Manager **_m) {
 245         Manager *m;
 246         int r = -ENOMEM;
 247
 248         assert(_m);
 249         assert(running_as >= 0);
 250         assert(running_as < _MANAGER_RUNNING_AS_MAX);
 251
 252         if (!(m = new0(Manager, 1)))
 253                 return -ENOMEM;
 254
 255         dual_timestamp_get(&m->startup_timestamp);
 256
 257         m->running_as = running_as;
 258         m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
 259         m->exit_code = _MANAGER_EXIT_CODE_INVALID;
 260         m->pin_cgroupfs_fd = -1;
 261
 262 #ifdef HAVE_AUDIT
 263         m->audit_fd = -1;
 264 #endif
 265
 266         m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
 267         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
 268
 269         m->environment = strv_copy(environ);
 270         if (!m->environment)
 271                 goto fail;
 272
 273         manager_strip_environment(m);
 274
 275         if (running_as == MANAGER_SYSTEM) {
 276                 m->default_controllers = strv_new("cpu", NULL);
 277                 if (!m->default_controllers)
 278                         goto fail;
 279         }
 280
 281         if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
 282                 goto fail;
 283
 284         if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
 285                 goto fail;
 286
 287         if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
 288                 goto fail;
 289
 290         if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
 291                 goto fail;
 292
 293         if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
 294                 goto fail;
 295
 296         if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
 297                 goto fail;
 298
 299         if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
 300                 goto fail;
 301
 302         if ((r = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
 303                 goto fail;
 304
 305         if ((r = manager_setup_signals(m)) < 0)
 306                 goto fail;
 307
 308         if ((r = manager_setup_cgroup(m)) < 0)
 309                 goto fail;
 310
 311         if ((r = manager_setup_notify(m)) < 0)
 312                 goto fail;
 313
 314         /* Try to connect to the busses, if possible. */
 315         if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
 316                 goto fail;
 317
 318 #ifdef HAVE_AUDIT
 319         if ((m->audit_fd = audit_open()) < 0 &&
 320             /* If the kernel lacks netlink or audit support,
 321              * don't worry about it. */
 322             errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
 323                 log_error("Failed to connect to audit log: %m");
 324 #endif
 325
 326         m->taint_usr = dir_is_empty("/usr") > 0;
 327
 328         *_m = m;
 329         return 0;
 330
 331 fail:
 332         manager_free(m);
 333         return r;
 334 }
 335
 336 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
 337         Unit *u;
 338         unsigned n = 0;
 339
 340         assert(m);
 341
 342         while ((u = m->cleanup_queue)) {
 343                 assert(u->in_cleanup_queue);
 344
 345                 unit_free(u);
 346                 n++;
 347         }
 348
 349         return n;
 350 }
 351
 352 enum {
 353         GC_OFFSET_IN_PATH,  /* This one is on the path we were traveling */
 354         GC_OFFSET_UNSURE,   /* No clue */
 355         GC_OFFSET_GOOD,     /* We still need this unit */
 356         GC_OFFSET_BAD,      /* We don't need this unit anymore */
 357         _GC_OFFSET_MAX
 358 };
 359
 360 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
 361         Iterator i;
 362         Unit *other;
 363         bool is_bad;
 364
 365         assert(u);
 366
 367         if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
 368             u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 369             u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
 370                 return;
 371
 372         if (u->in_cleanup_queue)
 373                 goto bad;
 374
 375         if (unit_check_gc(u))
 376                 goto good;
 377
 378         u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
 379
 380         is_bad = true;
 381
 382         SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
 383                 unit_gc_sweep(other, gc_marker);
 384
 385                 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
 386                         goto good;
 387
 388                 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
 389                         is_bad = false;
 390         }
 391
 392         if (is_bad)
 393                 goto bad;
 394
 395         /* We were unable to find anything out about this entry, so
 396          * let's investigate it later */
 397         u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
 398         unit_add_to_gc_queue(u);
 399         return;
 400
 401 bad:
 402         /* We definitely know that this one is not useful anymore, so
 403          * let's mark it for deletion */
 404         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 405         unit_add_to_cleanup_queue(u);
 406         return;
 407
 408 good:
 409         u->gc_marker = gc_marker + GC_OFFSET_GOOD;
 410 }
 411
 412 static unsigned manager_dispatch_gc_queue(Manager *m) {
 413         Unit *u;
 414         unsigned n = 0;
 415         unsigned gc_marker;
 416
 417         assert(m);
 418
 419         if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
 420             (m->gc_queue_timestamp <= 0 ||
 421              (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
 422                 return 0;
 423
 424         log_debug("Running GC...");
 425
 426         m->gc_marker += _GC_OFFSET_MAX;
 427         if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
 428                 m->gc_marker = 1;
 429
 430         gc_marker = m->gc_marker;
 431
 432         while ((u = m->gc_queue)) {
 433                 assert(u->in_gc_queue);
 434
 435                 unit_gc_sweep(u, gc_marker);
 436
 437                 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
 438                 u->in_gc_queue = false;
 439
 440                 n++;
 441
 442                 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 443                     u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
 444                         log_debug("Collecting %s", u->id);
 445                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 446                         unit_add_to_cleanup_queue(u);
 447                 }
 448         }
 449
 450         m->n_in_gc_queue = 0;
 451         m->gc_queue_timestamp = 0;
 452
 453         return n;
 454 }
 455
 456 static void manager_clear_jobs_and_units(Manager *m) {
 457         Job *j;
 458         Unit *u;
 459
 460         assert(m);
 461
 462         while ((j = hashmap_first(m->transaction_jobs)))
 463                 job_free(j);
 464
 465         while ((u = hashmap_first(m->units)))
 466                 unit_free(u);
 467
 468         manager_dispatch_cleanup_queue(m);
 469
 470         assert(!m->load_queue);
 471         assert(!m->run_queue);
 472         assert(!m->dbus_unit_queue);
 473         assert(!m->dbus_job_queue);
 474         assert(!m->cleanup_queue);
 475         assert(!m->gc_queue);
 476
 477         assert(hashmap_isempty(m->transaction_jobs));
 478         assert(hashmap_isempty(m->jobs));
 479         assert(hashmap_isempty(m->units));
 480 }
 481
 482 void manager_free(Manager *m) {
 483         UnitType c;
 484
 485         assert(m);
 486
 487         manager_clear_jobs_and_units(m);
 488
 489         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 490                 if (unit_vtable[c]->shutdown)
 491                         unit_vtable[c]->shutdown(m);
 492
 493         /* If we reexecute ourselves, we keep the root cgroup
 494          * around */
 495         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
 496
 497         manager_undo_generators(m);
 498
 499         bus_done(m);
 500
 501         hashmap_free(m->units);
 502         hashmap_free(m->jobs);
 503         hashmap_free(m->transaction_jobs);
 504         hashmap_free(m->watch_pids);
 505         hashmap_free(m->watch_bus);
 506
 507         if (m->epoll_fd >= 0)
 508                 close_nointr_nofail(m->epoll_fd);
 509         if (m->signal_watch.fd >= 0)
 510                 close_nointr_nofail(m->signal_watch.fd);
 511         if (m->notify_watch.fd >= 0)
 512                 close_nointr_nofail(m->notify_watch.fd);
 513
 514 #ifdef HAVE_AUDIT
 515         if (m->audit_fd >= 0)
 516                 audit_close(m->audit_fd);
 517 #endif
 518
 519         free(m->notify_socket);
 520
 521         lookup_paths_free(&m->lookup_paths);
 522         strv_free(m->environment);
 523
 524         strv_free(m->default_controllers);
 525
 526         hashmap_free(m->cgroup_bondings);
 527         set_free_free(m->unit_path_cache);
 528
 529         free(m);
 530 }
 531
 532 int manager_enumerate(Manager *m) {
 533         int r = 0, q;
 534         UnitType c;
 535
 536         assert(m);
 537
 538         /* Let's ask every type to load all units from disk/kernel
 539          * that it might know */
 540         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 541                 if (unit_vtable[c]->enumerate)
 542                         if ((q = unit_vtable[c]->enumerate(m)) < 0)
 543                                 r = q;
 544
 545         manager_dispatch_load_queue(m);
 546         return r;
 547 }
 548
 549 int manager_coldplug(Manager *m) {
 550         int r = 0, q;
 551         Iterator i;
 552         Unit *u;
 553         char *k;
 554
 555         assert(m);
 556
 557         /* Then, let's set up their initial state. */
 558         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 559
 560                 /* ignore aliases */
 561                 if (u->id != k)
 562                         continue;
 563
 564                 if ((q = unit_coldplug(u)) < 0)
 565                         r = q;
 566         }
 567
 568         return r;
 569 }
 570
 571 static void manager_build_unit_path_cache(Manager *m) {
 572         char **i;
 573         DIR *d = NULL;
 574         int r;
 575
 576         assert(m);
 577
 578         set_free_free(m->unit_path_cache);
 579
 580         if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
 581                 log_error("Failed to allocate unit path cache.");
 582                 return;
 583         }
 584
 585         /* This simply builds a list of files we know exist, so that
 586          * we don't always have to go to disk */
 587
 588         STRV_FOREACH(i, m->lookup_paths.unit_path) {
 589                 struct dirent *de;
 590
 591                 if (!(d = opendir(*i))) {
 592                         log_error("Failed to open directory: %m");
 593                         continue;
 594                 }
 595
 596                 while ((de = readdir(d))) {
 597                         char *p;
 598
 599                         if (ignore_file(de->d_name))
 600                                 continue;
 601
 602                         p = join(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
 603                         if (!p) {
 604                                 r = -ENOMEM;
 605                                 goto fail;
 606                         }
 607
 608                         if ((r = set_put(m->unit_path_cache, p)) < 0) {
 609                                 free(p);
 610                                 goto fail;
 611                         }
 612                 }
 613
 614                 closedir(d);
 615                 d = NULL;
 616         }
 617
 618         return;
 619
 620 fail:
 621         log_error("Failed to build unit path cache: %s", strerror(-r));
 622
 623         set_free_free(m->unit_path_cache);
 624         m->unit_path_cache = NULL;
 625
 626         if (d)
 627                 closedir(d);
 628 }
 629
 630 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
 631         int r, q;
 632
 633         assert(m);
 634
 635         manager_run_generators(m);
 636
 637         manager_build_unit_path_cache(m);
 638
 639         /* If we will deserialize make sure that during enumeration
 640          * this is already known, so we increase the counter here
 641          * already */
 642         if (serialization)
 643                 m->n_reloading ++;
 644
 645         /* First, enumerate what we can from all config files */
 646         r = manager_enumerate(m);
 647
 648         /* Second, deserialize if there is something to deserialize */
 649         if (serialization)
 650                 if ((q = manager_deserialize(m, serialization, fds)) < 0)
 651                         r = q;
 652
 653         /* Third, fire things up! */
 654         if ((q = manager_coldplug(m)) < 0)
 655                 r = q;
 656
 657         if (serialization) {
 658                 assert(m->n_reloading > 0);
 659                 m->n_reloading --;
 660         }
 661
 662         return r;
 663 }
 664
 665 static void transaction_delete_job(Manager *m, Job *j, bool delete_dependencies) {
 666         assert(m);
 667         assert(j);
 668
 669         /* Deletes one job from the transaction */
 670
 671         manager_transaction_unlink_job(m, j, delete_dependencies);
 672
 673         if (!j->installed)
 674                 job_free(j);
 675 }
 676
 677 static void transaction_delete_unit(Manager *m, Unit *u) {
 678         Job *j;
 679
 680         /* Deletes all jobs associated with a certain unit from the
 681          * transaction */
 682
 683         while ((j = hashmap_get(m->transaction_jobs, u)))
 684                 transaction_delete_job(m, j, true);
 685 }
 686
 687 static void transaction_clean_dependencies(Manager *m) {
 688         Iterator i;
 689         Job *j;
 690
 691         assert(m);
 692
 693         /* Drops all dependencies of all installed jobs */
 694
 695         HASHMAP_FOREACH(j, m->jobs, i) {
 696                 while (j->subject_list)
 697                         job_dependency_free(j->subject_list);
 698                 while (j->object_list)
 699                         job_dependency_free(j->object_list);
 700         }
 701
 702         assert(!m->transaction_anchor);
 703 }
 704
 705 static void transaction_abort(Manager *m) {
 706         Job *j;
 707
 708         assert(m);
 709
 710         while ((j = hashmap_first(m->transaction_jobs)))
 711                 if (j->installed)
 712                         transaction_delete_job(m, j, true);
 713                 else
 714                         job_free(j);
 715
 716         assert(hashmap_isempty(m->transaction_jobs));
 717
 718         transaction_clean_dependencies(m);
 719 }
 720
 721 static void transaction_find_jobs_that_matter_to_anchor(Manager *m, Job *j, unsigned generation) {
 722         JobDependency *l;
 723
 724         assert(m);
 725
 726         /* A recursive sweep through the graph that marks all units
 727          * that matter to the anchor job, i.e. are directly or
 728          * indirectly a dependency of the anchor job via paths that
 729          * are fully marked as mattering. */
 730
 731         if (j)
 732                 l = j->subject_list;
 733         else
 734                 l = m->transaction_anchor;
 735
 736         LIST_FOREACH(subject, l, l) {
 737
 738                 /* This link does not matter */
 739                 if (!l->matters)
 740                         continue;
 741
 742                 /* This unit has already been marked */
 743                 if (l->object->generation == generation)
 744                         continue;
 745
 746                 l->object->matters_to_anchor = true;
 747                 l->object->generation = generation;
 748
 749                 transaction_find_jobs_that_matter_to_anchor(m, l->object, generation);
 750         }
 751 }
 752
 753 static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, JobType t) {
 754         JobDependency *l, *last;
 755
 756         assert(j);
 757         assert(other);
 758         assert(j->unit == other->unit);
 759         assert(!j->installed);
 760
 761         /* Merges 'other' into 'j' and then deletes 'other'. */
 762
 763         j->type = t;
 764         j->state = JOB_WAITING;
 765         j->override = j->override || other->override;
 766
 767         j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
 768
 769         /* Patch us in as new owner of the JobDependency objects */
 770         last = NULL;
 771         LIST_FOREACH(subject, l, other->subject_list) {
 772                 assert(l->subject == other);
 773                 l->subject = j;
 774                 last = l;
 775         }
 776
 777         /* Merge both lists */
 778         if (last) {
 779                 last->subject_next = j->subject_list;
 780                 if (j->subject_list)
 781                         j->subject_list->subject_prev = last;
 782                 j->subject_list = other->subject_list;
 783         }
 784
 785         /* Patch us in as new owner of the JobDependency objects */
 786         last = NULL;
 787         LIST_FOREACH(object, l, other->object_list) {
 788                 assert(l->object == other);
 789                 l->object = j;
 790                 last = l;
 791         }
 792
 793         /* Merge both lists */
 794         if (last) {
 795                 last->object_next = j->object_list;
 796                 if (j->object_list)
 797                         j->object_list->object_prev = last;
 798                 j->object_list = other->object_list;
 799         }
 800
 801         /* Kill the other job */
 802         other->subject_list = NULL;
 803         other->object_list = NULL;
 804         transaction_delete_job(m, other, true);
 805 }
 806
 807 static bool job_is_conflicted_by(Job *j) {
 808         JobDependency *l;
 809
 810         assert(j);
 811
 812         /* Returns true if this job is pulled in by a least one
 813          * ConflictedBy dependency. */
 814
 815         LIST_FOREACH(object, l, j->object_list)
 816                 if (l->conflicts)
 817                         return true;
 818
 819         return false;
 820 }
 821
 822 static int delete_one_unmergeable_job(Manager *m, Job *j) {
 823         Job *k;
 824
 825         assert(j);
 826
 827         /* Tries to delete one item in the linked list
 828          * j->transaction_next->transaction_next->... that conflicts
 829          * with another one, in an attempt to make an inconsistent
 830          * transaction work. */
 831
 832         /* We rely here on the fact that if a merged with b does not
 833          * merge with c, either a or b merge with c neither */
 834         LIST_FOREACH(transaction, j, j)
 835                 LIST_FOREACH(transaction, k, j->transaction_next) {
 836                         Job *d;
 837
 838                         /* Is this one mergeable? Then skip it */
 839                         if (job_type_is_mergeable(j->type, k->type))
 840                                 continue;
 841
 842                         /* Ok, we found two that conflict, let's see if we can
 843                          * drop one of them */
 844                         if (!j->matters_to_anchor && !k->matters_to_anchor) {
 845
 846                                 /* Both jobs don't matter, so let's
 847                                  * find the one that is smarter to
 848                                  * remove. Let's think positive and
 849                                  * rather remove stops then starts --
 850                                  * except if something is being
 851                                  * stopped because it is conflicted by
 852                                  * another unit in which case we
 853                                  * rather remove the start. */
 854
 855                                 log_debug("Looking at job %s/%s conflicted_by=%s", j->unit->id, job_type_to_string(j->type), yes_no(j->type == JOB_STOP && job_is_conflicted_by(j)));
 856                                 log_debug("Looking at job %s/%s conflicted_by=%s", k->unit->id, job_type_to_string(k->type), yes_no(k->type == JOB_STOP && job_is_conflicted_by(k)));
 857
 858                                 if (j->type == JOB_STOP) {
 859
 860                                         if (job_is_conflicted_by(j))
 861                                                 d = k;
 862                                         else
 863                                                 d = j;
 864
 865                                 } else if (k->type == JOB_STOP) {
 866
 867                                         if (job_is_conflicted_by(k))
 868                                                 d = j;
 869                                         else
 870                                                 d = k;
 871                                 } else
 872                                         d = j;
 873
 874                         } else if (!j->matters_to_anchor)
 875                                 d = j;
 876                         else if (!k->matters_to_anchor)
 877                                 d = k;
 878                         else
 879                                 return -ENOEXEC;
 880
 881                         /* Ok, we can drop one, so let's do so. */
 882                         log_debug("Fixing conflicting jobs by deleting job %s/%s", d->unit->id, job_type_to_string(d->type));
 883                         transaction_delete_job(m, d, true);
 884                         return 0;
 885                 }
 886
 887         return -EINVAL;
 888 }
 889
 890 static int transaction_merge_jobs(Manager *m, DBusError *e) {
 891         Job *j;
 892         Iterator i;
 893         int r;
 894
 895         assert(m);
 896
 897         /* First step, check whether any of the jobs for one specific
 898          * task conflict. If so, try to drop one of them. */
 899         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 900                 JobType t;
 901                 Job *k;
 902
 903                 t = j->type;
 904                 LIST_FOREACH(transaction, k, j->transaction_next) {
 905                         if (job_type_merge(&t, k->type) >= 0)
 906                                 continue;
 907
 908                         /* OK, we could not merge all jobs for this
 909                          * action. Let's see if we can get rid of one
 910                          * of them */
 911
 912                         if ((r = delete_one_unmergeable_job(m, j)) >= 0)
 913                                 /* Ok, we managed to drop one, now
 914                                  * let's ask our callers to call us
 915                                  * again after garbage collecting */
 916                                 return -EAGAIN;
 917
 918                         /* We couldn't merge anything. Failure */
 919                         dbus_set_error(e, BUS_ERROR_TRANSACTION_JOBS_CONFLICTING, "Transaction contains conflicting jobs '%s' and '%s' for %s. Probably contradicting requirement dependencies configured.",
 920                                        job_type_to_string(t), job_type_to_string(k->type), k->unit->id);
 921                         return r;
 922                 }
 923         }
 924
 925         /* Second step, merge the jobs. */
 926         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 927                 JobType t = j->type;
 928                 Job *k;
 929
 930                 /* Merge all transactions */
 931                 LIST_FOREACH(transaction, k, j->transaction_next)
 932                         assert_se(job_type_merge(&t, k->type) == 0);
 933
 934                 /* If an active job is mergeable, merge it too */
 935                 if (j->unit->job)
 936                         job_type_merge(&t, j->unit->job->type); /* Might fail. Which is OK */
 937
 938                 while ((k = j->transaction_next)) {
 939                         if (j->installed) {
 940                                 transaction_merge_and_delete_job(m, k, j, t);
 941                                 j = k;
 942                         } else
 943                                 transaction_merge_and_delete_job(m, j, k, t);
 944                 }
 945
 946                 if (j->unit->job && !j->installed)
 947                         transaction_merge_and_delete_job(m, j, j->unit->job, t);
 948
 949                 assert(!j->transaction_next);
 950                 assert(!j->transaction_prev);
 951         }
 952
 953         return 0;
 954 }
 955
 956 static void transaction_drop_redundant(Manager *m) {
 957         bool again;
 958
 959         assert(m);
 960
 961         /* Goes through the transaction and removes all jobs that are
 962          * a noop */
 963
 964         do {
 965                 Job *j;
 966                 Iterator i;
 967
 968                 again = false;
 969
 970                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 971                         bool changes_something = false;
 972                         Job *k;
 973
 974                         LIST_FOREACH(transaction, k, j) {
 975
 976                                 if (!job_is_anchor(k) &&
 977                                     (k->installed || job_type_is_redundant(k->type, unit_active_state(k->unit))) &&
 978                                     (!k->unit->job || !job_type_is_conflicting(k->type, k->unit->job->type)))
 979                                         continue;
 980
 981                                 changes_something = true;
 982                                 break;
 983                         }
 984
 985                         if (changes_something)
 986                                 continue;
 987
 988                         /* log_debug("Found redundant job %s/%s, dropping.", j->unit->id, job_type_to_string(j->type)); */
 989                         transaction_delete_job(m, j, false);
 990                         again = true;
 991                         break;
 992                 }
 993
 994         } while (again);
 995 }
 996
 997 static bool unit_matters_to_anchor(Unit *u, Job *j) {
 998         assert(u);
 999         assert(!j->transaction_prev);
1000
1001         /* Checks whether at least one of the jobs for this unit
1002          * matters to the anchor. */
1003
1004         LIST_FOREACH(transaction, j, j)
1005                 if (j->matters_to_anchor)
1006                         return true;
1007
1008         return false;
1009 }
1010
1011 static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation, DBusError *e) {
1012         Iterator i;
1013         Unit *u;
1014         int r;
1015
1016         assert(m);
1017         assert(j);
1018         assert(!j->transaction_prev);
1019
1020         /* Does a recursive sweep through the ordering graph, looking
1021          * for a cycle. If we find cycle we try to break it. */
1022
1023         /* Have we seen this before? */
1024         if (j->generation == generation) {
1025                 Job *k, *delete;
1026
1027                 /* If the marker is NULL we have been here already and
1028                  * decided the job was loop-free from here. Hence
1029                  * shortcut things and return right-away. */
1030                 if (!j->marker)
1031                         return 0;
1032
1033                 /* So, the marker is not NULL and we already have been
1034                  * here. We have a cycle. Let's try to break it. We go
1035                  * backwards in our path and try to find a suitable
1036                  * job to remove. We use the marker to find our way
1037                  * back, since smart how we are we stored our way back
1038                  * in there. */
1039                 log_warning("Found ordering cycle on %s/%s", j->unit->id, job_type_to_string(j->type));
1040
1041                 delete = NULL;
1042                 for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) {
1043
1044                         log_info("Walked on cycle path to %s/%s", k->unit->id, job_type_to_string(k->type));
1045
1046                         if (!delete &&
1047                             !k->installed &&
1048                             !unit_matters_to_anchor(k->unit, k)) {
1049                                 /* Ok, we can drop this one, so let's
1050                                  * do so. */
1051                                 delete = k;
1052                         }
1053
1054                         /* Check if this in fact was the beginning of
1055                          * the cycle */
1056                         if (k == j)
1057                                 break;
1058                 }
1059
1060
1061                 if (delete) {
1062                         log_warning("Breaking ordering cycle by deleting job %s/%s", delete->unit->id, job_type_to_string(delete->type));
1063                         transaction_delete_unit(m, delete->unit);
1064                         return -EAGAIN;
1065                 }
1066
1067                 log_error("Unable to break cycle");
1068
1069                 dbus_set_error(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, "Transaction order is cyclic. See system logs for details.");
1070                 return -ENOEXEC;
1071         }
1072
1073         /* Make the marker point to where we come from, so that we can
1074          * find our way backwards if we want to break a cycle. We use
1075          * a special marker for the beginning: we point to
1076          * ourselves. */
1077         j->marker = from ? from : j;
1078         j->generation = generation;
1079
1080         /* We assume that the the dependencies are bidirectional, and
1081          * hence can ignore UNIT_AFTER */
1082         SET_FOREACH(u, j->unit->dependencies[UNIT_BEFORE], i) {
1083                 Job *o;
1084
1085                 /* Is there a job for this unit? */
1086                 if (!(o = hashmap_get(m->transaction_jobs, u)))
1087
1088                         /* Ok, there is no job for this in the
1089                          * transaction, but maybe there is already one
1090                          * running? */
1091                         if (!(o = u->job))
1092                                 continue;
1093
1094                 if ((r = transaction_verify_order_one(m, o, j, generation, e)) < 0)
1095                         return r;
1096         }
1097
1098         /* Ok, let's backtrack, and remember that this entry is not on
1099          * our path anymore. */
1100         j->marker = NULL;
1101
1102         return 0;
1103 }
1104
1105 static int transaction_verify_order(Manager *m, unsigned *generation, DBusError *e) {
1106         Job *j;
1107         int r;
1108         Iterator i;
1109         unsigned g;
1110
1111         assert(m);
1112         assert(generation);
1113
1114         /* Check if the ordering graph is cyclic. If it is, try to fix
1115          * that up by dropping one of the jobs. */
1116
1117         g = (*generation)++;
1118
1119         HASHMAP_FOREACH(j, m->transaction_jobs, i)
1120                 if ((r = transaction_verify_order_one(m, j, NULL, g, e)) < 0)
1121                         return r;
1122
1123         return 0;
1124 }
1125
1126 static void transaction_collect_garbage(Manager *m) {
1127         bool again;
1128
1129         assert(m);
1130
1131         /* Drop jobs that are not required by any other job */
1132
1133         do {
1134                 Iterator i;
1135                 Job *j;
1136
1137                 again = false;
1138
1139                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1140                         if (j->object_list) {
1141                                 /* log_debug("Keeping job %s/%s because of %s/%s", */
1142                                 /*           j->unit->id, job_type_to_string(j->type), */
1143                                 /*           j->object_list->subject ? j->object_list->subject->unit->id : "root", */
1144                                 /*           j->object_list->subject ? job_type_to_string(j->object_list->subject->type) : "root"); */
1145                                 continue;
1146                         }
1147
1148                         /* log_debug("Garbage collecting job %s/%s", j->unit->id, job_type_to_string(j->type)); */
1149                         transaction_delete_job(m, j, true);
1150                         again = true;
1151                         break;
1152                 }
1153
1154         } while (again);
1155 }
1156
1157 static int transaction_is_destructive(Manager *m, DBusError *e) {
1158         Iterator i;
1159         Job *j;
1160
1161         assert(m);
1162
1163         /* Checks whether applying this transaction means that
1164          * existing jobs would be replaced */
1165
1166         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1167
1168                 /* Assume merged */
1169                 assert(!j->transaction_prev);
1170                 assert(!j->transaction_next);
1171
1172                 if (j->unit->job &&
1173                     j->unit->job != j &&
1174                     !job_type_is_superset(j->type, j->unit->job->type)) {
1175
1176                         dbus_set_error(e, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE, "Transaction is destructive.");
1177                         return -EEXIST;
1178                 }
1179         }
1180
1181         return 0;
1182 }
1183
1184 static void transaction_minimize_impact(Manager *m) {
1185         bool again;
1186         assert(m);
1187
1188         /* Drops all unnecessary jobs that reverse already active jobs
1189          * or that stop a running service. */
1190
1191         do {
1192                 Job *j;
1193                 Iterator i;
1194
1195                 again = false;
1196
1197                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1198                         LIST_FOREACH(transaction, j, j) {
1199                                 bool stops_running_service, changes_existing_job;
1200
1201                                 /* If it matters, we shouldn't drop it */
1202                                 if (j->matters_to_anchor)
1203                                         continue;
1204
1205                                 /* Would this stop a running service?
1206                                  * Would this change an existing job?
1207                                  * If so, let's drop this entry */
1208
1209                                 stops_running_service =
1210                                         j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit));
1211
1212                                 changes_existing_job =
1213                                         j->unit->job &&
1214                                         job_type_is_conflicting(j->type, j->unit->job->type);
1215
1216                                 if (!stops_running_service && !changes_existing_job)
1217                                         continue;
1218
1219                                 if (stops_running_service)
1220                                         log_debug("%s/%s would stop a running service.", j->unit->id, job_type_to_string(j->type));
1221
1222                                 if (changes_existing_job)
1223                                         log_debug("%s/%s would change existing job.", j->unit->id, job_type_to_string(j->type));
1224
1225                                 /* Ok, let's get rid of this */
1226                                 log_debug("Deleting %s/%s to minimize impact.", j->unit->id, job_type_to_string(j->type));
1227
1228                                 transaction_delete_job(m, j, true);
1229                                 again = true;
1230                                 break;
1231                         }
1232
1233                         if (again)
1234                                 break;
1235                 }
1236
1237         } while (again);
1238 }
1239
1240 static int transaction_apply(Manager *m, JobMode mode) {
1241         Iterator i;
1242         Job *j;
1243         int r;
1244
1245         /* Moves the transaction jobs to the set of active jobs */
1246
1247         if (mode == JOB_ISOLATE) {
1248
1249                 /* When isolating first kill all installed jobs which
1250                  * aren't part of the new transaction */
1251         rescan:
1252                 HASHMAP_FOREACH(j, m->jobs, i) {
1253                         assert(j->installed);
1254
1255                         if (hashmap_get(m->transaction_jobs, j->unit))
1256                                 continue;
1257
1258                         /* 'j' itself is safe to remove, but if other jobs
1259                            are invalidated recursively, our iterator may become
1260                            invalid and we need to start over. */
1261                         if (job_finish_and_invalidate(j, JOB_CANCELED) > 0)
1262                                 goto rescan;
1263                 }
1264         }
1265
1266         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1267                 /* Assume merged */
1268                 assert(!j->transaction_prev);
1269                 assert(!j->transaction_next);
1270
1271                 if (j->installed)
1272                         continue;
1273
1274                 if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0)
1275                         goto rollback;
1276         }
1277
1278         while ((j = hashmap_steal_first(m->transaction_jobs))) {
1279                 if (j->installed) {
1280                         /* log_debug("Skipping already installed job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id); */
1281                         continue;
1282                 }
1283
1284                 if (j->unit->job)
1285                         job_free(j->unit->job);
1286
1287                 j->unit->job = j;
1288                 j->installed = true;
1289                 m->n_installed_jobs ++;
1290
1291                 /* We're fully installed. Now let's free data we don't
1292                  * need anymore. */
1293
1294                 assert(!j->transaction_next);
1295                 assert(!j->transaction_prev);
1296
1297                 job_add_to_run_queue(j);
1298                 job_add_to_dbus_queue(j);
1299                 job_start_timer(j);
1300
1301                 log_debug("Installed new job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
1302         }
1303
1304         /* As last step, kill all remaining job dependencies. */
1305         transaction_clean_dependencies(m);
1306
1307         return 0;
1308
1309 rollback:
1310
1311         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1312                 if (j->installed)
1313                         continue;
1314
1315                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
1316         }
1317
1318         return r;
1319 }
1320
1321 static int transaction_activate(Manager *m, JobMode mode, DBusError *e) {
1322         int r;
1323         unsigned generation = 1;
1324
1325         assert(m);
1326
1327         /* This applies the changes recorded in transaction_jobs to
1328          * the actual list of jobs, if possible. */
1329
1330         /* First step: figure out which jobs matter */
1331         transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++);
1332
1333         /* Second step: Try not to stop any running services if
1334          * we don't have to. Don't try to reverse running
1335          * jobs if we don't have to. */
1336         if (mode == JOB_FAIL)
1337                 transaction_minimize_impact(m);
1338
1339         /* Third step: Drop redundant jobs */
1340         transaction_drop_redundant(m);
1341
1342         for (;;) {
1343                 /* Fourth step: Let's remove unneeded jobs that might
1344                  * be lurking. */
1345                 if (mode != JOB_ISOLATE)
1346                         transaction_collect_garbage(m);
1347
1348                 /* Fifth step: verify order makes sense and correct
1349                  * cycles if necessary and possible */
1350                 if ((r = transaction_verify_order(m, &generation, e)) >= 0)
1351                         break;
1352
1353                 if (r != -EAGAIN) {
1354                         log_warning("Requested transaction contains an unfixable cyclic ordering dependency: %s", bus_error(e, r));
1355                         goto rollback;
1356                 }
1357
1358                 /* Let's see if the resulting transaction ordering
1359                  * graph is still cyclic... */
1360         }
1361
1362         for (;;) {
1363                 /* Sixth step: let's drop unmergeable entries if
1364                  * necessary and possible, merge entries we can
1365                  * merge */
1366                 if ((r = transaction_merge_jobs(m, e)) >= 0)
1367                         break;
1368
1369                 if (r != -EAGAIN) {
1370                         log_warning("Requested transaction contains unmergeable jobs: %s", bus_error(e, r));
1371                         goto rollback;
1372                 }
1373
1374                 /* Seventh step: an entry got dropped, let's garbage
1375                  * collect its dependencies. */
1376                 if (mode != JOB_ISOLATE)
1377                         transaction_collect_garbage(m);
1378
1379                 /* Let's see if the resulting transaction still has
1380                  * unmergeable entries ... */
1381         }
1382
1383         /* Eights step: Drop redundant jobs again, if the merging now allows us to drop more. */
1384         transaction_drop_redundant(m);
1385
1386         /* Ninth step: check whether we can actually apply this */
1387         if (mode == JOB_FAIL)
1388                 if ((r = transaction_is_destructive(m, e)) < 0) {
1389                         log_notice("Requested transaction contradicts existing jobs: %s", bus_error(e, r));
1390                         goto rollback;
1391                 }
1392
1393         /* Tenth step: apply changes */
1394         if ((r = transaction_apply(m, mode)) < 0) {
1395                 log_warning("Failed to apply transaction: %s", strerror(-r));
1396                 goto rollback;
1397         }
1398
1399         assert(hashmap_isempty(m->transaction_jobs));
1400         assert(!m->transaction_anchor);
1401
1402         return 0;
1403
1404 rollback:
1405         transaction_abort(m);
1406         return r;
1407 }
1408
1409 static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool override, bool *is_new) {
1410         Job *j, *f;
1411
1412         assert(m);
1413         assert(unit);
1414
1415         /* Looks for an existing prospective job and returns that. If
1416          * it doesn't exist it is created and added to the prospective
1417          * jobs list. */
1418
1419         f = hashmap_get(m->transaction_jobs, unit);
1420
1421         LIST_FOREACH(transaction, j, f) {
1422                 assert(j->unit == unit);
1423
1424                 if (j->type == type) {
1425                         if (is_new)
1426                                 *is_new = false;
1427                         return j;
1428                 }
1429         }
1430
1431         if (unit->job && unit->job->type == type)
1432                 j = unit->job;
1433         else if (!(j = job_new(m, type, unit)))
1434                 return NULL;
1435
1436         j->generation = 0;
1437         j->marker = NULL;
1438         j->matters_to_anchor = false;
1439         j->override = override;
1440
1441         LIST_PREPEND(Job, transaction, f, j);
1442
1443         if (hashmap_replace(m->transaction_jobs, unit, f) < 0) {
1444                 job_free(j);
1445                 return NULL;
1446         }
1447
1448         if (is_new)
1449                 *is_new = true;
1450
1451         /* log_debug("Added job %s/%s to transaction.", unit->id, job_type_to_string(type)); */
1452
1453         return j;
1454 }
1455
1456 void manager_transaction_unlink_job(Manager *m, Job *j, bool delete_dependencies) {
1457         assert(m);
1458         assert(j);
1459
1460         if (j->transaction_prev)
1461                 j->transaction_prev->transaction_next = j->transaction_next;
1462         else if (j->transaction_next)
1463                 hashmap_replace(m->transaction_jobs, j->unit, j->transaction_next);
1464         else
1465                 hashmap_remove_value(m->transaction_jobs, j->unit, j);
1466
1467         if (j->transaction_next)
1468                 j->transaction_next->transaction_prev = j->transaction_prev;
1469
1470         j->transaction_prev = j->transaction_next = NULL;
1471
1472         while (j->subject_list)
1473                 job_dependency_free(j->subject_list);
1474
1475         while (j->object_list) {
1476                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
1477
1478                 job_dependency_free(j->object_list);
1479
1480                 if (other && delete_dependencies) {
1481                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
1482                                   other->unit->id, job_type_to_string(other->type),
1483                                   j->unit->id, job_type_to_string(j->type));
1484                         transaction_delete_job(m, other, delete_dependencies);
1485                 }
1486         }
1487 }
1488
1489 static int transaction_add_job_and_dependencies(
1490                 Manager *m,
1491                 JobType type,
1492                 Unit *unit,
1493                 Job *by,
1494                 bool matters,
1495                 bool override,
1496                 bool conflicts,
1497                 bool ignore_requirements,
1498                 bool ignore_order,
1499                 DBusError *e,
1500                 Job **_ret) {
1501         Job *ret;
1502         Iterator i;
1503         Unit *dep;
1504         int r;
1505         bool is_new;
1506
1507         assert(m);
1508         assert(type < _JOB_TYPE_MAX);
1509         assert(unit);
1510
1511         /* log_debug("Pulling in %s/%s from %s/%s", */
1512         /*           unit->id, job_type_to_string(type), */
1513         /*           by ? by->unit->id : "NA", */
1514         /*           by ? job_type_to_string(by->type) : "NA"); */
1515
1516         if (unit->load_state != UNIT_LOADED &&
1517             unit->load_state != UNIT_ERROR &&
1518             unit->load_state != UNIT_MASKED) {
1519                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->id);
1520                 return -EINVAL;
1521         }
1522
1523         if (type != JOB_STOP && unit->load_state == UNIT_ERROR) {
1524                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED,
1525                                "Unit %s failed to load: %s. "
1526                                "See system logs and 'systemctl status %s' for details.",
1527                                unit->id,
1528                                strerror(-unit->load_error),
1529                                unit->id);
1530                 return -EINVAL;
1531         }
1532
1533         if (type != JOB_STOP && unit->load_state == UNIT_MASKED) {
1534                 dbus_set_error(e, BUS_ERROR_MASKED, "Unit %s is masked.", unit->id);
1535                 return -EINVAL;
1536         }
1537
1538         if (!unit_job_is_applicable(unit, type)) {
1539                 dbus_set_error(e, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE, "Job type %s is not applicable for unit %s.", job_type_to_string(type), unit->id);
1540                 return -EBADR;
1541         }
1542
1543         /* First add the job. */
1544         if (!(ret = transaction_add_one_job(m, type, unit, override, &is_new)))
1545                 return -ENOMEM;
1546
1547         ret->ignore_order = ret->ignore_order || ignore_order;
1548
1549         /* Then, add a link to the job. */
1550         if (!job_dependency_new(by, ret, matters, conflicts))
1551                 return -ENOMEM;
1552
1553         if (is_new && !ignore_requirements) {
1554                 Set *following;
1555
1556                 /* If we are following some other unit, make sure we
1557                  * add all dependencies of everybody following. */
1558                 if (unit_following_set(ret->unit, &following) > 0) {
1559                         SET_FOREACH(dep, following, i)
1560                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1561                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1562
1563                                         if (e)
1564                                                 dbus_error_free(e);
1565                                 }
1566
1567                         set_free(following);
1568                 }
1569
1570                 /* Finally, recursively add in all dependencies. */
1571                 if (type == JOB_START || type == JOB_RELOAD_OR_START) {
1572                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES], i)
1573                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1574                                         if (r != -EBADR)
1575                                                 goto fail;
1576
1577                                         if (e)
1578                                                 dbus_error_free(e);
1579                                 }
1580
1581                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BIND_TO], i)
1582                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1583
1584                                         if (r != -EBADR)
1585                                                 goto fail;
1586
1587                                         if (e)
1588                                                 dbus_error_free(e);
1589                                 }
1590
1591                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1592                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1593                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1594
1595                                         if (e)
1596                                                 dbus_error_free(e);
1597                                 }
1598
1599                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_WANTS], i)
1600                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, false, false, false, ignore_order, e, NULL)) < 0) {
1601                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1602
1603                                         if (e)
1604                                                 dbus_error_free(e);
1605                                 }
1606
1607                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE], i)
1608                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1609
1610                                         if (r != -EBADR)
1611                                                 goto fail;
1612
1613                                         if (e)
1614                                                 dbus_error_free(e);
1615                                 }
1616
1617                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1618                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1619                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1620
1621                                         if (e)
1622                                                 dbus_error_free(e);
1623                                 }
1624
1625                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTS], i)
1626                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, override, true, false, ignore_order, e, NULL)) < 0) {
1627
1628                                         if (r != -EBADR)
1629                                                 goto fail;
1630
1631                                         if (e)
1632                                                 dbus_error_free(e);
1633                                 }
1634
1635                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTED_BY], i)
1636                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1637                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1638
1639                                         if (e)
1640                                                 dbus_error_free(e);
1641                                 }
1642
1643                 }
1644
1645                 if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
1646
1647                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRED_BY], i)
1648                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1649
1650                                         if (r != -EBADR)
1651                                                 goto fail;
1652
1653                                         if (e)
1654                                                 dbus_error_free(e);
1655                                 }
1656
1657                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BOUND_BY], i)
1658                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1659
1660                                         if (r != -EBADR)
1661                                                 goto fail;
1662
1663                                         if (e)
1664                                                 dbus_error_free(e);
1665                                 }
1666                 }
1667
1668                 if (type == JOB_RELOAD || type == JOB_RELOAD_OR_START) {
1669
1670                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_PROPAGATE_RELOAD_TO], i) {
1671                                 r = transaction_add_job_and_dependencies(m, JOB_RELOAD, dep, ret, false, override, false, false, ignore_order, e, NULL);
1672
1673                                 if (r < 0) {
1674                                         log_warning("Cannot add dependency reload job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1675
1676                                         if (e)
1677                                                 dbus_error_free(e);
1678                                 }
1679                         }
1680                 }
1681
1682                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
1683         }
1684
1685         if (_ret)
1686                 *_ret = ret;
1687
1688         return 0;
1689
1690 fail:
1691         return r;
1692 }
1693
1694 static int transaction_add_isolate_jobs(Manager *m) {
1695         Iterator i;
1696         Unit *u;
1697         char *k;
1698         int r;
1699
1700         assert(m);
1701
1702         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1703
1704                 /* ignore aliases */
1705                 if (u->id != k)
1706                         continue;
1707
1708                 if (u->ignore_on_isolate)
1709                         continue;
1710
1711                 /* No need to stop inactive jobs */
1712                 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)) && !u->job)
1713                         continue;
1714
1715                 /* Is there already something listed for this? */
1716                 if (hashmap_get(m->transaction_jobs, u))
1717                         continue;
1718
1719                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, u, NULL, true, false, false, false, false, NULL, NULL)) < 0)
1720                         log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->id, strerror(-r));
1721         }
1722
1723         return 0;
1724 }
1725
1726 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
1727         int r;
1728         Job *ret;
1729
1730         assert(m);
1731         assert(type < _JOB_TYPE_MAX);
1732         assert(unit);
1733         assert(mode < _JOB_MODE_MAX);
1734
1735         if (mode == JOB_ISOLATE && type != JOB_START) {
1736                 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
1737                 return -EINVAL;
1738         }
1739
1740         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1741                 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1742                 return -EPERM;
1743         }
1744
1745         log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1746
1747         if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, override, false,
1748                                                       mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1749                                                       mode == JOB_IGNORE_DEPENDENCIES, e, &ret)) < 0) {
1750                 transaction_abort(m);
1751                 return r;
1752         }
1753
1754         if (mode == JOB_ISOLATE)
1755                 if ((r = transaction_add_isolate_jobs(m)) < 0) {
1756                         transaction_abort(m);
1757                         return r;
1758                 }
1759
1760         if ((r = transaction_activate(m, mode, e)) < 0)
1761                 return r;
1762
1763         log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) ret->id);
1764
1765         if (_ret)
1766                 *_ret = ret;
1767
1768         return 0;
1769 }
1770
1771 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1772         Unit *unit;
1773         int r;
1774
1775         assert(m);
1776         assert(type < _JOB_TYPE_MAX);
1777         assert(name);
1778         assert(mode < _JOB_MODE_MAX);
1779
1780         if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
1781                 return r;
1782
1783         return manager_add_job(m, type, unit, mode, override, e, _ret);
1784 }
1785
1786 Job *manager_get_job(Manager *m, uint32_t id) {
1787         assert(m);
1788
1789         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1790 }
1791
1792 Unit *manager_get_unit(Manager *m, const char *name) {
1793         assert(m);
1794         assert(name);
1795
1796         return hashmap_get(m->units, name);
1797 }
1798
1799 unsigned manager_dispatch_load_queue(Manager *m) {
1800         Unit *u;
1801         unsigned n = 0;
1802
1803         assert(m);
1804
1805         /* Make sure we are not run recursively */
1806         if (m->dispatching_load_queue)
1807                 return 0;
1808
1809         m->dispatching_load_queue = true;
1810
1811         /* Dispatches the load queue. Takes a unit from the queue and
1812          * tries to load its data until the queue is empty */
1813
1814         while ((u = m->load_queue)) {
1815                 assert(u->in_load_queue);
1816
1817                 unit_load(u);
1818                 n++;
1819         }
1820
1821         m->dispatching_load_queue = false;
1822         return n;
1823 }
1824
1825 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1826         Unit *ret;
1827         UnitType t;
1828         int r;
1829
1830         assert(m);
1831         assert(name || path);
1832
1833         /* This will prepare the unit for loading, but not actually
1834          * load anything from disk. */
1835
1836         if (path && !is_path(path)) {
1837                 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1838                 return -EINVAL;
1839         }
1840
1841         if (!name)
1842                 name = file_name_from_path(path);
1843
1844         t = unit_name_to_type(name);
1845
1846         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid_no_type(name, false)) {
1847                 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1848                 return -EINVAL;
1849         }
1850
1851         ret = manager_get_unit(m, name);
1852         if (ret) {
1853                 *_ret = ret;
1854                 return 1;
1855         }
1856
1857         ret = unit_new(m, unit_vtable[t]->object_size);
1858         if (!ret)
1859                 return -ENOMEM;
1860
1861         if (path) {
1862                 ret->fragment_path = strdup(path);
1863                 if (!ret->fragment_path) {
1864                         unit_free(ret);
1865                         return -ENOMEM;
1866                 }
1867         }
1868
1869         if ((r = unit_add_name(ret, name)) < 0) {
1870                 unit_free(ret);
1871                 return r;
1872         }
1873
1874         unit_add_to_load_queue(ret);
1875         unit_add_to_dbus_queue(ret);
1876         unit_add_to_gc_queue(ret);
1877
1878         if (_ret)
1879                 *_ret = ret;
1880
1881         return 0;
1882 }
1883
1884 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1885         int r;
1886
1887         assert(m);
1888
1889         /* This will load the service information files, but not actually
1890          * start any services or anything. */
1891
1892         if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
1893                 return r;
1894
1895         manager_dispatch_load_queue(m);
1896
1897         if (_ret)
1898                 *_ret = unit_follow_merge(*_ret);
1899
1900         return 0;
1901 }
1902
1903 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1904         Iterator i;
1905         Job *j;
1906
1907         assert(s);
1908         assert(f);
1909
1910         HASHMAP_FOREACH(j, s->jobs, i)
1911                 job_dump(j, f, prefix);
1912 }
1913
1914 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1915         Iterator i;
1916         Unit *u;
1917         const char *t;
1918
1919         assert(s);
1920         assert(f);
1921
1922         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1923                 if (u->id == t)
1924                         unit_dump(u, f, prefix);
1925 }
1926
1927 void manager_clear_jobs(Manager *m) {
1928         Job *j;
1929
1930         assert(m);
1931
1932         transaction_abort(m);
1933
1934         while ((j = hashmap_first(m->jobs)))
1935                 job_finish_and_invalidate(j, JOB_CANCELED);
1936 }
1937
1938 unsigned manager_dispatch_run_queue(Manager *m) {
1939         Job *j;
1940         unsigned n = 0;
1941
1942         if (m->dispatching_run_queue)
1943                 return 0;
1944
1945         m->dispatching_run_queue = true;
1946
1947         while ((j = m->run_queue)) {
1948                 assert(j->installed);
1949                 assert(j->in_run_queue);
1950
1951                 job_run_and_invalidate(j);
1952                 n++;
1953         }
1954
1955         m->dispatching_run_queue = false;
1956         return n;
1957 }
1958
1959 unsigned manager_dispatch_dbus_queue(Manager *m) {
1960         Job *j;
1961         Unit *u;
1962         unsigned n = 0;
1963
1964         assert(m);
1965
1966         if (m->dispatching_dbus_queue)
1967                 return 0;
1968
1969         m->dispatching_dbus_queue = true;
1970
1971         while ((u = m->dbus_unit_queue)) {
1972                 assert(u->in_dbus_queue);
1973
1974                 bus_unit_send_change_signal(u);
1975                 n++;
1976         }
1977
1978         while ((j = m->dbus_job_queue)) {
1979                 assert(j->in_dbus_queue);
1980
1981                 bus_job_send_change_signal(j);
1982                 n++;
1983         }
1984
1985         m->dispatching_dbus_queue = false;
1986         return n;
1987 }
1988
1989 static int manager_process_notify_fd(Manager *m) {
1990         ssize_t n;
1991
1992         assert(m);
1993
1994         for (;;) {
1995                 char buf[4096];
1996                 struct msghdr msghdr;
1997                 struct iovec iovec;
1998                 struct ucred *ucred;
1999                 union {
2000                         struct cmsghdr cmsghdr;
2001                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
2002                 } control;
2003                 Unit *u;
2004                 char **tags;
2005
2006                 zero(iovec);
2007                 iovec.iov_base = buf;
2008                 iovec.iov_len = sizeof(buf)-1;
2009
2010                 zero(control);
2011                 zero(msghdr);
2012                 msghdr.msg_iov = &iovec;
2013                 msghdr.msg_iovlen = 1;
2014                 msghdr.msg_control = &control;
2015                 msghdr.msg_controllen = sizeof(control);
2016
2017                 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
2018                         if (n >= 0)
2019                                 return -EIO;
2020
2021                         if (errno == EAGAIN || errno == EINTR)
2022                                 break;
2023
2024                         return -errno;
2025                 }
2026
2027                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
2028                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
2029                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
2030                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
2031                         log_warning("Received notify message without credentials. Ignoring.");
2032                         continue;
2033                 }
2034
2035                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
2036
2037                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
2038                         if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
2039                                 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
2040                                 continue;
2041                         }
2042
2043                 assert((size_t) n < sizeof(buf));
2044                 buf[n] = 0;
2045                 if (!(tags = strv_split(buf, "\n\r")))
2046                         return -ENOMEM;
2047
2048                 log_debug("Got notification message for unit %s", u->id);
2049
2050                 if (UNIT_VTABLE(u)->notify_message)
2051                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
2052
2053                 strv_free(tags);
2054         }
2055
2056         return 0;
2057 }
2058
2059 static int manager_dispatch_sigchld(Manager *m) {
2060         assert(m);
2061
2062         for (;;) {
2063                 siginfo_t si;
2064                 Unit *u;
2065                 int r;
2066
2067                 zero(si);
2068
2069                 /* First we call waitd() for a PID and do not reap the
2070                  * zombie. That way we can still access /proc/$PID for
2071                  * it while it is a zombie. */
2072                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
2073
2074                         if (errno == ECHILD)
2075                                 break;
2076
2077                         if (errno == EINTR)
2078                                 continue;
2079
2080                         return -errno;
2081                 }
2082
2083                 if (si.si_pid <= 0)
2084                         break;
2085
2086                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
2087                         char *name = NULL;
2088
2089                         get_process_comm(si.si_pid, &name);
2090                         log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
2091                         free(name);
2092                 }
2093
2094                 /* Let's flush any message the dying child might still
2095                  * have queued for us. This ensures that the process
2096                  * still exists in /proc so that we can figure out
2097                  * which cgroup and hence unit it belongs to. */
2098                 if ((r = manager_process_notify_fd(m)) < 0)
2099                         return r;
2100
2101                 /* And now figure out the unit this belongs to */
2102                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
2103                         u = cgroup_unit_by_pid(m, si.si_pid);
2104
2105                 /* And now, we actually reap the zombie. */
2106                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
2107                         if (errno == EINTR)
2108                                 continue;
2109
2110                         return -errno;
2111                 }
2112
2113                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
2114                         continue;
2115
2116                 log_debug("Child %lu died (code=%s, status=%i/%s)",
2117                           (long unsigned) si.si_pid,
2118                           sigchld_code_to_string(si.si_code),
2119                           si.si_status,
2120                           strna(si.si_code == CLD_EXITED
2121                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
2122                                 : signal_to_string(si.si_status)));
2123
2124                 if (!u)
2125                         continue;
2126
2127                 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
2128
2129                 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
2130                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
2131         }
2132
2133         return 0;
2134 }
2135
2136 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
2137         int r;
2138         DBusError error;
2139
2140         dbus_error_init(&error);
2141
2142         log_debug("Activating special unit %s", name);
2143
2144         if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
2145                 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
2146
2147         dbus_error_free(&error);
2148
2149         return r;
2150 }
2151
2152 static int manager_process_signal_fd(Manager *m) {
2153         ssize_t n;
2154         struct signalfd_siginfo sfsi;
2155         bool sigchld = false;
2156
2157         assert(m);
2158
2159         for (;;) {
2160                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
2161
2162                         if (n >= 0)
2163                                 return -EIO;
2164
2165                         if (errno == EINTR || errno == EAGAIN)
2166                                 break;
2167
2168                         return -errno;
2169                 }
2170
2171                 if (sfsi.ssi_pid > 0) {
2172                         char *p = NULL;
2173
2174                         get_process_comm(sfsi.ssi_pid, &p);
2175
2176                         log_debug("Received SIG%s from PID %lu (%s).",
2177                                   signal_to_string(sfsi.ssi_signo),
2178                                   (unsigned long) sfsi.ssi_pid, strna(p));
2179                         free(p);
2180                 } else
2181                         log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
2182
2183                 switch (sfsi.ssi_signo) {
2184
2185                 case SIGCHLD:
2186                         sigchld = true;
2187                         break;
2188
2189                 case SIGTERM:
2190                         if (m->running_as == MANAGER_SYSTEM) {
2191                                 /* This is for compatibility with the
2192                                  * original sysvinit */
2193                                 m->exit_code = MANAGER_REEXECUTE;
2194                                 break;
2195                         }
2196
2197                         /* Fall through */
2198
2199                 case SIGINT:
2200                         if (m->running_as == MANAGER_SYSTEM) {
2201                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
2202                                 break;
2203                         }
2204
2205                         /* Run the exit target if there is one, if not, just exit. */
2206                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
2207                                 m->exit_code = MANAGER_EXIT;
2208                                 return 0;
2209                         }
2210
2211                         break;
2212
2213                 case SIGWINCH:
2214                         if (m->running_as == MANAGER_SYSTEM)
2215                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2216
2217                         /* This is a nop on non-init */
2218                         break;
2219
2220                 case SIGPWR:
2221                         if (m->running_as == MANAGER_SYSTEM)
2222                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2223
2224                         /* This is a nop on non-init */
2225                         break;
2226
2227                 case SIGUSR1: {
2228                         Unit *u;
2229
2230                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
2231
2232                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
2233                                 log_info("Trying to reconnect to bus...");
2234                                 bus_init(m, true);
2235                         }
2236
2237                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
2238                                 log_info("Loading D-Bus service...");
2239                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2240                         }
2241
2242                         break;
2243                 }
2244
2245                 case SIGUSR2: {
2246                         FILE *f;
2247                         char *dump = NULL;
2248                         size_t size;
2249
2250                         if (!(f = open_memstream(&dump, &size))) {
2251                                 log_warning("Failed to allocate memory stream.");
2252                                 break;
2253                         }
2254
2255                         manager_dump_units(m, f, "\t");
2256                         manager_dump_jobs(m, f, "\t");
2257
2258                         if (ferror(f)) {
2259                                 fclose(f);
2260                                 free(dump);
2261                                 log_warning("Failed to write status stream");
2262                                 break;
2263                         }
2264
2265                         fclose(f);
2266                         log_dump(LOG_INFO, dump);
2267                         free(dump);
2268
2269                         break;
2270                 }
2271
2272                 case SIGHUP:
2273                         m->exit_code = MANAGER_RELOAD;
2274                         break;
2275
2276                 default: {
2277
2278                         /* Starting SIGRTMIN+0 */
2279                         static const char * const target_table[] = {
2280                                 [0] = SPECIAL_DEFAULT_TARGET,
2281                                 [1] = SPECIAL_RESCUE_TARGET,
2282                                 [2] = SPECIAL_EMERGENCY_TARGET,
2283                                 [3] = SPECIAL_HALT_TARGET,
2284                                 [4] = SPECIAL_POWEROFF_TARGET,
2285                                 [5] = SPECIAL_REBOOT_TARGET,
2286                                 [6] = SPECIAL_KEXEC_TARGET
2287                         };
2288
2289                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2290                         static const ManagerExitCode code_table[] = {
2291                                 [0] = MANAGER_HALT,
2292                                 [1] = MANAGER_POWEROFF,
2293                                 [2] = MANAGER_REBOOT,
2294                                 [3] = MANAGER_KEXEC
2295                         };
2296
2297                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2298                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2299                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2300                                 manager_start_target(m, target_table[idx],
2301                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
2302                                 break;
2303                         }
2304
2305                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2306                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
2307                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
2308                                 break;
2309                         }
2310
2311                         switch (sfsi.ssi_signo - SIGRTMIN) {
2312
2313                         case 20:
2314                                 log_debug("Enabling showing of status.");
2315                                 manager_set_show_status(m, true);
2316                                 break;
2317
2318                         case 21:
2319                                 log_debug("Disabling showing of status.");
2320                                 manager_set_show_status(m, false);
2321                                 break;
2322
2323                         case 22:
2324                                 log_set_max_level(LOG_DEBUG);
2325                                 log_notice("Setting log level to debug.");
2326                                 break;
2327
2328                         case 23:
2329                                 log_set_max_level(LOG_INFO);
2330                                 log_notice("Setting log level to info.");
2331                                 break;
2332
2333                         case 26:
2334                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
2335                                 log_notice("Setting log target to journal-or-kmsg.");
2336                                 break;
2337
2338                         case 27:
2339                                 log_set_target(LOG_TARGET_CONSOLE);
2340                                 log_notice("Setting log target to console.");
2341                                 break;
2342
2343                         case 28:
2344                                 log_set_target(LOG_TARGET_KMSG);
2345                                 log_notice("Setting log target to kmsg.");
2346                                 break;
2347
2348                         case 29:
2349                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
2350                                 log_notice("Setting log target to syslog-or-kmsg.");
2351                                 break;
2352
2353                         default:
2354                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2355                         }
2356                 }
2357                 }
2358         }
2359
2360         if (sigchld)
2361                 return manager_dispatch_sigchld(m);
2362
2363         return 0;
2364 }
2365
2366 static int process_event(Manager *m, struct epoll_event *ev) {
2367         int r;
2368         Watch *w;
2369
2370         assert(m);
2371         assert(ev);
2372
2373         assert_se(w = ev->data.ptr);
2374
2375         if (w->type == WATCH_INVALID)
2376                 return 0;
2377
2378         switch (w->type) {
2379
2380         case WATCH_SIGNAL:
2381
2382                 /* An incoming signal? */
2383                 if (ev->events != EPOLLIN)
2384                         return -EINVAL;
2385
2386                 if ((r = manager_process_signal_fd(m)) < 0)
2387                         return r;
2388
2389                 break;
2390
2391         case WATCH_NOTIFY:
2392
2393                 /* An incoming daemon notification event? */
2394                 if (ev->events != EPOLLIN)
2395                         return -EINVAL;
2396
2397                 if ((r = manager_process_notify_fd(m)) < 0)
2398                         return r;
2399
2400                 break;
2401
2402         case WATCH_FD:
2403
2404                 /* Some fd event, to be dispatched to the units */
2405                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
2406                 break;
2407
2408         case WATCH_UNIT_TIMER:
2409         case WATCH_JOB_TIMER: {
2410                 uint64_t v;
2411                 ssize_t k;
2412
2413                 /* Some timer event, to be dispatched to the units */
2414                 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
2415
2416                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
2417                                 break;
2418
2419                         return k < 0 ? -errno : -EIO;
2420                 }
2421
2422                 if (w->type == WATCH_UNIT_TIMER)
2423                         UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
2424                 else
2425                         job_timer_event(w->data.job, v, w);
2426                 break;
2427         }
2428
2429         case WATCH_MOUNT:
2430                 /* Some mount table change, intended for the mount subsystem */
2431                 mount_fd_event(m, ev->events);
2432                 break;
2433
2434         case WATCH_SWAP:
2435                 /* Some swap table change, intended for the swap subsystem */
2436                 swap_fd_event(m, ev->events);
2437                 break;
2438
2439         case WATCH_UDEV:
2440                 /* Some notification from udev, intended for the device subsystem */
2441                 device_fd_event(m, ev->events);
2442                 break;
2443
2444         case WATCH_DBUS_WATCH:
2445                 bus_watch_event(m, w, ev->events);
2446                 break;
2447
2448         case WATCH_DBUS_TIMEOUT:
2449                 bus_timeout_event(m, w, ev->events);
2450                 break;
2451
2452         default:
2453                 log_error("event type=%i", w->type);
2454                 assert_not_reached("Unknown epoll event type.");
2455         }
2456
2457         return 0;
2458 }
2459
2460 int manager_loop(Manager *m) {
2461         int r;
2462
2463         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
2464
2465         assert(m);
2466         m->exit_code = MANAGER_RUNNING;
2467
2468         /* Release the path cache */
2469         set_free_free(m->unit_path_cache);
2470         m->unit_path_cache = NULL;
2471
2472         manager_check_finished(m);
2473
2474         /* There might still be some zombies hanging around from
2475          * before we were exec()'ed. Leat's reap them */
2476         r = manager_dispatch_sigchld(m);
2477         if (r < 0)
2478                 return r;
2479
2480         while (m->exit_code == MANAGER_RUNNING) {
2481                 struct epoll_event event;
2482                 int n;
2483                 int wait_msec = -1;
2484
2485                 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
2486                         watchdog_ping();
2487
2488                 if (!ratelimit_test(&rl)) {
2489                         /* Yay, something is going seriously wrong, pause a little */
2490                         log_warning("Looping too fast. Throttling execution a little.");
2491                         sleep(1);
2492                         continue;
2493                 }
2494
2495                 if (manager_dispatch_load_queue(m) > 0)
2496                         continue;
2497
2498                 if (manager_dispatch_run_queue(m) > 0)
2499                         continue;
2500
2501                 if (bus_dispatch(m) > 0)
2502                         continue;
2503
2504                 if (manager_dispatch_cleanup_queue(m) > 0)
2505                         continue;
2506
2507                 if (manager_dispatch_gc_queue(m) > 0)
2508                         continue;
2509
2510                 if (manager_dispatch_dbus_queue(m) > 0)
2511                         continue;
2512
2513                 if (swap_dispatch_reload(m) > 0)
2514                         continue;
2515
2516                 /* Sleep for half the watchdog time */
2517                 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
2518                         wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
2519                         if (wait_msec <= 0)
2520                                 wait_msec = 1;
2521                 } else
2522                         wait_msec = -1;
2523
2524                 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
2525                 if (n < 0) {
2526
2527                         if (errno == EINTR)
2528                                 continue;
2529
2530                         return -errno;
2531                 } else if (n == 0)
2532                         continue;
2533
2534                 assert(n == 1);
2535
2536                 r = process_event(m, &event);
2537                 if (r < 0)
2538                         return r;
2539         }
2540
2541         return m->exit_code;
2542 }
2543
2544 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
2545         char *n;
2546         Unit *u;
2547
2548         assert(m);
2549         assert(s);
2550         assert(_u);
2551
2552         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
2553                 return -EINVAL;
2554
2555         if (!(n = bus_path_unescape(s+31)))
2556                 return -ENOMEM;
2557
2558         u = manager_get_unit(m, n);
2559         free(n);
2560
2561         if (!u)
2562                 return -ENOENT;
2563
2564         *_u = u;
2565
2566         return 0;
2567 }
2568
2569 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2570         Job *j;
2571         unsigned id;
2572         int r;
2573
2574         assert(m);
2575         assert(s);
2576         assert(_j);
2577
2578         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
2579                 return -EINVAL;
2580
2581         if ((r = safe_atou(s + 30, &id)) < 0)
2582                 return r;
2583
2584         if (!(j = manager_get_job(m, id)))
2585                 return -ENOENT;
2586
2587         *_j = j;
2588
2589         return 0;
2590 }
2591
2592 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2593
2594 #ifdef HAVE_AUDIT
2595         char *p;
2596
2597         if (m->audit_fd < 0)
2598                 return;
2599
2600         /* Don't generate audit events if the service was already
2601          * started and we're just deserializing */
2602         if (m->n_reloading > 0)
2603                 return;
2604
2605         if (m->running_as != MANAGER_SYSTEM)
2606                 return;
2607
2608         if (u->type != UNIT_SERVICE)
2609                 return;
2610
2611         if (!(p = unit_name_to_prefix_and_instance(u->id))) {
2612                 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
2613                 return;
2614         }
2615
2616         if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
2617                 if (errno == EPERM) {
2618                         /* We aren't allowed to send audit messages?
2619                          * Then let's not retry again. */
2620                         audit_close(m->audit_fd);
2621                         m->audit_fd = -1;
2622                 } else
2623                         log_warning("Failed to send audit message: %m");
2624         }
2625
2626         free(p);
2627 #endif
2628
2629 }
2630
2631 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2632         int fd = -1;
2633         union sockaddr_union sa;
2634         int n = 0;
2635         char *message = NULL;
2636
2637         /* Don't generate plymouth events if the service was already
2638          * started and we're just deserializing */
2639         if (m->n_reloading > 0)
2640                 return;
2641
2642         if (m->running_as != MANAGER_SYSTEM)
2643                 return;
2644
2645         if (u->type != UNIT_SERVICE &&
2646             u->type != UNIT_MOUNT &&
2647             u->type != UNIT_SWAP)
2648                 return;
2649
2650         /* We set SOCK_NONBLOCK here so that we rather drop the
2651          * message then wait for plymouth */
2652         if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
2653                 log_error("socket() failed: %m");
2654                 return;
2655         }
2656
2657         zero(sa);
2658         sa.sa.sa_family = AF_UNIX;
2659         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
2660         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2661
2662                 if (errno != EPIPE &&
2663                     errno != EAGAIN &&
2664                     errno != ENOENT &&
2665                     errno != ECONNREFUSED &&
2666                     errno != ECONNRESET &&
2667                     errno != ECONNABORTED)
2668                         log_error("connect() failed: %m");
2669
2670                 goto finish;
2671         }
2672
2673         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2674                 log_error("Out of memory");
2675                 goto finish;
2676         }
2677
2678         errno = 0;
2679         if (write(fd, message, n + 1) != n + 1) {
2680
2681                 if (errno != EPIPE &&
2682                     errno != EAGAIN &&
2683                     errno != ENOENT &&
2684                     errno != ECONNREFUSED &&
2685                     errno != ECONNRESET &&
2686                     errno != ECONNABORTED)
2687                         log_error("Failed to write Plymouth message: %m");
2688
2689                 goto finish;
2690         }
2691
2692 finish:
2693         if (fd >= 0)
2694                 close_nointr_nofail(fd);
2695
2696         free(message);
2697 }
2698
2699 void manager_dispatch_bus_name_owner_changed(
2700                 Manager *m,
2701                 const char *name,
2702                 const char* old_owner,
2703                 const char *new_owner) {
2704
2705         Unit *u;
2706
2707         assert(m);
2708         assert(name);
2709
2710         if (!(u = hashmap_get(m->watch_bus, name)))
2711                 return;
2712
2713         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2714 }
2715
2716 void manager_dispatch_bus_query_pid_done(
2717                 Manager *m,
2718                 const char *name,
2719                 pid_t pid) {
2720
2721         Unit *u;
2722
2723         assert(m);
2724         assert(name);
2725         assert(pid >= 1);
2726
2727         if (!(u = hashmap_get(m->watch_bus, name)))
2728                 return;
2729
2730         UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2731 }
2732
2733 int manager_open_serialization(Manager *m, FILE **_f) {
2734         char *path = NULL;
2735         mode_t saved_umask;
2736         int fd;
2737         FILE *f;
2738
2739         assert(_f);
2740
2741         if (m->running_as == MANAGER_SYSTEM)
2742                 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2743         else
2744                 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2745
2746         if (!path)
2747                 return -ENOMEM;
2748
2749         saved_umask = umask(0077);
2750         fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2751         umask(saved_umask);
2752
2753         if (fd < 0) {
2754                 free(path);
2755                 return -errno;
2756         }
2757
2758         unlink(path);
2759
2760         log_debug("Serializing state to %s", path);
2761         free(path);
2762
2763         if (!(f = fdopen(fd, "w+")))
2764                 return -errno;
2765
2766         *_f = f;
2767
2768         return 0;
2769 }
2770
2771 int manager_serialize(Manager *m, FILE *f, FDSet *fds) {
2772         Iterator i;
2773         Unit *u;
2774         const char *t;
2775         int r;
2776
2777         assert(m);
2778         assert(f);
2779         assert(fds);
2780
2781         m->n_reloading ++;
2782
2783         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2784         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2785
2786         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2787         dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
2788         dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2789
2790         fputc('\n', f);
2791
2792         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2793                 if (u->id != t)
2794                         continue;
2795
2796                 if (!unit_can_serialize(u))
2797                         continue;
2798
2799                 /* Start marker */
2800                 fputs(u->id, f);
2801                 fputc('\n', f);
2802
2803                 if ((r = unit_serialize(u, f, fds)) < 0) {
2804                         m->n_reloading --;
2805                         return r;
2806                 }
2807         }
2808
2809         assert(m->n_reloading > 0);
2810         m->n_reloading --;
2811
2812         if (ferror(f))
2813                 return -EIO;
2814
2815         r = bus_fdset_add_all(m, fds);
2816         if (r < 0)
2817                 return r;
2818
2819         return 0;
2820 }
2821
2822 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2823         int r = 0;
2824
2825         assert(m);
2826         assert(f);
2827
2828         log_debug("Deserializing state...");
2829
2830         m->n_reloading ++;
2831
2832         for (;;) {
2833                 char line[LINE_MAX], *l;
2834
2835                 if (!fgets(line, sizeof(line), f)) {
2836                         if (feof(f))
2837                                 r = 0;
2838                         else
2839                                 r = -errno;
2840
2841                         goto finish;
2842                 }
2843
2844                 char_array_0(line);
2845                 l = strstrip(line);
2846
2847                 if (l[0] == 0)
2848                         break;
2849
2850                 if (startswith(l, "current-job-id=")) {
2851                         uint32_t id;
2852
2853                         if (safe_atou32(l+15, &id) < 0)
2854                                 log_debug("Failed to parse current job id value %s", l+15);
2855                         else
2856                                 m->current_job_id = MAX(m->current_job_id, id);
2857                 } else if (startswith(l, "taint-usr=")) {
2858                         int b;
2859
2860                         if ((b = parse_boolean(l+10)) < 0)
2861                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2862                         else
2863                                 m->taint_usr = m->taint_usr || b;
2864                 } else if (startswith(l, "initrd-timestamp="))
2865                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2866                 else if (startswith(l, "startup-timestamp="))
2867                         dual_timestamp_deserialize(l+18, &m->startup_timestamp);
2868                 else if (startswith(l, "finish-timestamp="))
2869                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2870                 else
2871                         log_debug("Unknown serialization item '%s'", l);
2872         }
2873
2874         for (;;) {
2875                 Unit *u;
2876                 char name[UNIT_NAME_MAX+2];
2877
2878                 /* Start marker */
2879                 if (!fgets(name, sizeof(name), f)) {
2880                         if (feof(f))
2881                                 r = 0;
2882                         else
2883                                 r = -errno;
2884
2885                         goto finish;
2886                 }
2887
2888                 char_array_0(name);
2889
2890                 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
2891                         goto finish;
2892
2893                 if ((r = unit_deserialize(u, f, fds)) < 0)
2894                         goto finish;
2895         }
2896
2897 finish:
2898         if (ferror(f)) {
2899                 r = -EIO;
2900                 goto finish;
2901         }
2902
2903         assert(m->n_reloading > 0);
2904         m->n_reloading --;
2905
2906         return r;
2907 }
2908
2909 int manager_reload(Manager *m) {
2910         int r, q;
2911         FILE *f;
2912         FDSet *fds;
2913
2914         assert(m);
2915
2916         if ((r = manager_open_serialization(m, &f)) < 0)
2917                 return r;
2918
2919         m->n_reloading ++;
2920
2921         if (!(fds = fdset_new())) {
2922                 m->n_reloading --;
2923                 r = -ENOMEM;
2924                 goto finish;
2925         }
2926
2927         if ((r = manager_serialize(m, f, fds)) < 0) {
2928                 m->n_reloading --;
2929                 goto finish;
2930         }
2931
2932         if (fseeko(f, 0, SEEK_SET) < 0) {
2933                 m->n_reloading --;
2934                 r = -errno;
2935                 goto finish;
2936         }
2937
2938         /* From here on there is no way back. */
2939         manager_clear_jobs_and_units(m);
2940         manager_undo_generators(m);
2941
2942         /* Find new unit paths */
2943         lookup_paths_free(&m->lookup_paths);
2944         if ((q = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
2945                 r = q;
2946
2947         manager_run_generators(m);
2948
2949         manager_build_unit_path_cache(m);
2950
2951         /* First, enumerate what we can from all config files */
2952         if ((q = manager_enumerate(m)) < 0)
2953                 r = q;
2954
2955         /* Second, deserialize our stored data */
2956         if ((q = manager_deserialize(m, f, fds)) < 0)
2957                 r = q;
2958
2959         fclose(f);
2960         f = NULL;
2961
2962         /* Third, fire things up! */
2963         if ((q = manager_coldplug(m)) < 0)
2964                 r = q;
2965
2966         assert(m->n_reloading > 0);
2967         m->n_reloading--;
2968
2969 finish:
2970         if (f)
2971                 fclose(f);
2972
2973         if (fds)
2974                 fdset_free(fds);
2975
2976         return r;
2977 }
2978
2979 bool manager_is_booting_or_shutting_down(Manager *m) {
2980         Unit *u;
2981
2982         assert(m);
2983
2984         /* Is the initial job still around? */
2985         if (manager_get_job(m, m->default_unit_job_id))
2986                 return true;
2987
2988         /* Is there a job for the shutdown target? */
2989         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2990         if (u)
2991                 return !!u->job;
2992
2993         return false;
2994 }
2995
2996 void manager_reset_failed(Manager *m) {
2997         Unit *u;
2998         Iterator i;
2999
3000         assert(m);
3001
3002         HASHMAP_FOREACH(u, m->units, i)
3003                 unit_reset_failed(u);
3004 }
3005
3006 bool manager_unit_pending_inactive(Manager *m, const char *name) {
3007         Unit *u;
3008
3009         assert(m);
3010         assert(name);
3011
3012         /* Returns true if the unit is inactive or going down */
3013         if (!(u = manager_get_unit(m, name)))
3014                 return true;
3015
3016         return unit_pending_inactive(u);
3017 }
3018
3019 void manager_check_finished(Manager *m) {
3020         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
3021         usec_t kernel_usec, initrd_usec, userspace_usec, total_usec;
3022
3023         assert(m);
3024
3025         if (dual_timestamp_is_set(&m->finish_timestamp))
3026                 return;
3027
3028         if (hashmap_size(m->jobs) > 0)
3029                 return;
3030
3031         dual_timestamp_get(&m->finish_timestamp);
3032
3033         if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
3034
3035                 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3036                 total_usec = m->finish_timestamp.monotonic;
3037
3038                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
3039
3040                         kernel_usec = m->initrd_timestamp.monotonic;
3041                         initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
3042
3043                         log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
3044                                  format_timespan(kernel, sizeof(kernel), kernel_usec),
3045                                  format_timespan(initrd, sizeof(initrd), initrd_usec),
3046                                  format_timespan(userspace, sizeof(userspace), userspace_usec),
3047                                  format_timespan(sum, sizeof(sum), total_usec));
3048                 } else {
3049                         kernel_usec = m->startup_timestamp.monotonic;
3050                         initrd_usec = 0;
3051
3052                         log_info("Startup finished in %s (kernel) + %s (userspace) = %s.",
3053                                  format_timespan(kernel, sizeof(kernel), kernel_usec),
3054                                  format_timespan(userspace, sizeof(userspace), userspace_usec),
3055                                  format_timespan(sum, sizeof(sum), total_usec));
3056                 }
3057         } else {
3058                 userspace_usec = initrd_usec = kernel_usec = 0;
3059                 total_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3060
3061                 log_debug("Startup finished in %s.",
3062                           format_timespan(sum, sizeof(sum), total_usec));
3063         }
3064
3065         bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
3066
3067         sd_notifyf(false,
3068                    "READY=1\nSTATUS=Startup finished in %s.",
3069                    format_timespan(sum, sizeof(sum), total_usec));
3070 }
3071
3072 void manager_run_generators(Manager *m) {
3073         DIR *d = NULL;
3074         const char *generator_path;
3075         const char *argv[3];
3076         mode_t u;
3077
3078         assert(m);
3079
3080         generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
3081         if (!(d = opendir(generator_path))) {
3082
3083                 if (errno == ENOENT)
3084                         return;
3085
3086                 log_error("Failed to enumerate generator directory: %m");
3087                 return;
3088         }
3089
3090         if (!m->generator_unit_path) {
3091                 const char *p;
3092                 char user_path[] = "/tmp/systemd-generator-XXXXXX";
3093
3094                 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
3095                         p = "/run/systemd/generator";
3096
3097                         if (mkdir_p(p, 0755) < 0) {
3098                                 log_error("Failed to create generator directory: %m");
3099                                 goto finish;
3100                         }
3101
3102                 } else {
3103                         if (!(p = mkdtemp(user_path))) {
3104                                 log_error("Failed to create generator directory: %m");
3105                                 goto finish;
3106                         }
3107                 }
3108
3109                 if (!(m->generator_unit_path = strdup(p))) {
3110                         log_error("Failed to allocate generator unit path.");
3111                         goto finish;
3112                 }
3113         }
3114
3115         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
3116         argv[1] = m->generator_unit_path;
3117         argv[2] = NULL;
3118
3119         u = umask(0022);
3120         execute_directory(generator_path, d, (char**) argv);
3121         umask(u);
3122
3123         if (rmdir(m->generator_unit_path) >= 0) {
3124                 /* Uh? we were able to remove this dir? I guess that
3125                  * means the directory was empty, hence let's shortcut
3126                  * this */
3127
3128                 free(m->generator_unit_path);
3129                 m->generator_unit_path = NULL;
3130                 goto finish;
3131         }
3132
3133         if (!strv_find(m->lookup_paths.unit_path, m->generator_unit_path)) {
3134                 char **l;
3135
3136                 if (!(l = strv_append(m->lookup_paths.unit_path, m->generator_unit_path))) {
3137                         log_error("Failed to add generator directory to unit search path: %m");
3138                         goto finish;
3139                 }
3140
3141                 strv_free(m->lookup_paths.unit_path);
3142                 m->lookup_paths.unit_path = l;
3143
3144                 log_debug("Added generator unit path %s to search path.", m->generator_unit_path);
3145         }
3146
3147 finish:
3148         if (d)
3149                 closedir(d);
3150 }
3151
3152 void manager_undo_generators(Manager *m) {
3153         assert(m);
3154
3155         if (!m->generator_unit_path)
3156                 return;
3157
3158         strv_remove(m->lookup_paths.unit_path, m->generator_unit_path);
3159         rm_rf(m->generator_unit_path, false, true, false);
3160
3161         free(m->generator_unit_path);
3162         m->generator_unit_path = NULL;
3163 }
3164
3165 int manager_set_default_controllers(Manager *m, char **controllers) {
3166         char **l;
3167
3168         assert(m);
3169
3170         l = strv_copy(controllers);
3171         if (!l)
3172                 return -ENOMEM;
3173
3174         strv_free(m->default_controllers);
3175         m->default_controllers = l;
3176
3177         cg_shorten_controllers(m->default_controllers);
3178
3179         return 0;
3180 }
3181
3182 void manager_recheck_journal(Manager *m) {
3183         Unit *u;
3184
3185         assert(m);
3186
3187         if (m->running_as != MANAGER_SYSTEM)
3188                 return;
3189
3190         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
3191         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
3192                 log_close_journal();
3193                 return;
3194         }
3195
3196         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
3197         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
3198                 log_close_journal();
3199                 return;
3200         }
3201
3202         /* Hmm, OK, so the socket is fully up and the service is up
3203          * too, then let's make use of the thing. */
3204         log_open();
3205 }
3206
3207 void manager_set_show_status(Manager *m, bool b) {
3208         assert(m);
3209
3210         if (m->running_as != MANAGER_SYSTEM)
3211                 return;
3212
3213         m->show_status = b;
3214
3215         if (b)
3216                 touch("/run/systemd/show-status");
3217         else
3218                 unlink("/run/systemd/show-status");
3219 }
3220
3221 bool manager_get_show_status(Manager *m) {
3222         assert(m);
3223
3224         if (m->running_as != MANAGER_SYSTEM)
3225                 return false;
3226
3227         if (m->show_status)
3228                 return true;
3229
3230         /* If Plymouth is running make sure we show the status, so
3231          * that there's something nice to see when people press Esc */
3232
3233         return plymouth_running();
3234 }
3235
3236 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
3237         [MANAGER_SYSTEM] = "system",
3238         [MANAGER_USER] = "user"
3239 };
3240
3241 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);