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 j. */
 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 static bool job_is_conflicted_by(Job *j) {
 807         JobDependency *l;
 808
 809         assert(j);
 810
 811         /* Returns true if this job is pulled in by a least one
 812          * ConflictedBy dependency. */
 813
 814         LIST_FOREACH(object, l, j->object_list)
 815                 if (l->conflicts)
 816                         return true;
 817
 818         return false;
 819 }
 820
 821 static int delete_one_unmergeable_job(Manager *m, Job *j) {
 822         Job *k;
 823
 824         assert(j);
 825
 826         /* Tries to delete one item in the linked list
 827          * j->transaction_next->transaction_next->... that conflicts
 828          * with another one, in an attempt to make an inconsistent
 829          * transaction work. */
 830
 831         /* We rely here on the fact that if a merged with b does not
 832          * merge with c, either a or b merge with c neither */
 833         LIST_FOREACH(transaction, j, j)
 834                 LIST_FOREACH(transaction, k, j->transaction_next) {
 835                         Job *d;
 836
 837                         /* Is this one mergeable? Then skip it */
 838                         if (job_type_is_mergeable(j->type, k->type))
 839                                 continue;
 840
 841                         /* Ok, we found two that conflict, let's see if we can
 842                          * drop one of them */
 843                         if (!j->matters_to_anchor && !k->matters_to_anchor) {
 844
 845                                 /* Both jobs don't matter, so let's
 846                                  * find the one that is smarter to
 847                                  * remove. Let's think positive and
 848                                  * rather remove stops then starts --
 849                                  * except if something is being
 850                                  * stopped because it is conflicted by
 851                                  * another unit in which case we
 852                                  * rather remove the start. */
 853
 854                                 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)));
 855                                 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)));
 856
 857                                 if (j->type == JOB_STOP) {
 858
 859                                         if (job_is_conflicted_by(j))
 860                                                 d = k;
 861                                         else
 862                                                 d = j;
 863
 864                                 } else if (k->type == JOB_STOP) {
 865
 866                                         if (job_is_conflicted_by(k))
 867                                                 d = j;
 868                                         else
 869                                                 d = k;
 870                                 } else
 871                                         d = j;
 872
 873                         } else if (!j->matters_to_anchor)
 874                                 d = j;
 875                         else if (!k->matters_to_anchor)
 876                                 d = k;
 877                         else
 878                                 return -ENOEXEC;
 879
 880                         /* Ok, we can drop one, so let's do so. */
 881                         log_debug("Fixing conflicting jobs by deleting job %s/%s", d->unit->id, job_type_to_string(d->type));
 882                         transaction_delete_job(m, d, true);
 883                         return 0;
 884                 }
 885
 886         return -EINVAL;
 887 }
 888
 889 static int transaction_merge_jobs(Manager *m, DBusError *e) {
 890         Job *j;
 891         Iterator i;
 892         int r;
 893
 894         assert(m);
 895
 896         /* First step, check whether any of the jobs for one specific
 897          * task conflict. If so, try to drop one of them. */
 898         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 899                 JobType t;
 900                 Job *k;
 901
 902                 t = j->type;
 903                 LIST_FOREACH(transaction, k, j->transaction_next) {
 904                         if (job_type_merge(&t, k->type) >= 0)
 905                                 continue;
 906
 907                         /* OK, we could not merge all jobs for this
 908                          * action. Let's see if we can get rid of one
 909                          * of them */
 910
 911                         if ((r = delete_one_unmergeable_job(m, j)) >= 0)
 912                                 /* Ok, we managed to drop one, now
 913                                  * let's ask our callers to call us
 914                                  * again after garbage collecting */
 915                                 return -EAGAIN;
 916
 917                         /* We couldn't merge anything. Failure */
 918                         dbus_set_error(e, BUS_ERROR_TRANSACTION_JOBS_CONFLICTING, "Transaction contains conflicting jobs '%s' and '%s' for %s. Probably contradicting requirement dependencies configured.",
 919                                        job_type_to_string(t), job_type_to_string(k->type), k->unit->id);
 920                         return r;
 921                 }
 922         }
 923
 924         /* Second step, merge the jobs. */
 925         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 926                 JobType t = j->type;
 927                 Job *k;
 928
 929                 /* Merge all transactions */
 930                 LIST_FOREACH(transaction, k, j->transaction_next)
 931                         assert_se(job_type_merge(&t, k->type) == 0);
 932
 933                 /* If an active job is mergeable, merge it too */
 934                 if (j->unit->job)
 935                         job_type_merge(&t, j->unit->job->type); /* Might fail. Which is OK */
 936
 937                 while ((k = j->transaction_next)) {
 938                         if (j->installed) {
 939                                 transaction_merge_and_delete_job(m, k, j, t);
 940                                 j = k;
 941                         } else
 942                                 transaction_merge_and_delete_job(m, j, k, t);
 943                 }
 944
 945                 if (j->unit->job && !j->installed)
 946                         transaction_merge_and_delete_job(m, j, j->unit->job, t);
 947
 948                 assert(!j->transaction_next);
 949                 assert(!j->transaction_prev);
 950         }
 951
 952         return 0;
 953 }
 954
 955 static void transaction_drop_redundant(Manager *m) {
 956         bool again;
 957
 958         assert(m);
 959
 960         /* Goes through the transaction and removes all jobs that are
 961          * a noop */
 962
 963         do {
 964                 Job *j;
 965                 Iterator i;
 966
 967                 again = false;
 968
 969                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 970                         bool changes_something = false;
 971                         Job *k;
 972
 973                         LIST_FOREACH(transaction, k, j) {
 974
 975                                 if (!job_is_anchor(k) &&
 976                                     (k->installed || job_type_is_redundant(k->type, unit_active_state(k->unit))) &&
 977                                     (!k->unit->job || !job_type_is_conflicting(k->type, k->unit->job->type)))
 978                                         continue;
 979
 980                                 changes_something = true;
 981                                 break;
 982                         }
 983
 984                         if (changes_something)
 985                                 continue;
 986
 987                         /* log_debug("Found redundant job %s/%s, dropping.", j->unit->id, job_type_to_string(j->type)); */
 988                         transaction_delete_job(m, j, false);
 989                         again = true;
 990                         break;
 991                 }
 992
 993         } while (again);
 994 }
 995
 996 static bool unit_matters_to_anchor(Unit *u, Job *j) {
 997         assert(u);
 998         assert(!j->transaction_prev);
 999
1000         /* Checks whether at least one of the jobs for this unit
1001          * matters to the anchor. */
1002
1003         LIST_FOREACH(transaction, j, j)
1004                 if (j->matters_to_anchor)
1005                         return true;
1006
1007         return false;
1008 }
1009
1010 static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation, DBusError *e) {
1011         Iterator i;
1012         Unit *u;
1013         int r;
1014
1015         assert(m);
1016         assert(j);
1017         assert(!j->transaction_prev);
1018
1019         /* Does a recursive sweep through the ordering graph, looking
1020          * for a cycle. If we find cycle we try to break it. */
1021
1022         /* Have we seen this before? */
1023         if (j->generation == generation) {
1024                 Job *k, *delete;
1025
1026                 /* If the marker is NULL we have been here already and
1027                  * decided the job was loop-free from here. Hence
1028                  * shortcut things and return right-away. */
1029                 if (!j->marker)
1030                         return 0;
1031
1032                 /* So, the marker is not NULL and we already have been
1033                  * here. We have a cycle. Let's try to break it. We go
1034                  * backwards in our path and try to find a suitable
1035                  * job to remove. We use the marker to find our way
1036                  * back, since smart how we are we stored our way back
1037                  * in there. */
1038                 log_warning("Found ordering cycle on %s/%s", j->unit->id, job_type_to_string(j->type));
1039
1040                 delete = NULL;
1041                 for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) {
1042
1043                         log_info("Walked on cycle path to %s/%s", k->unit->id, job_type_to_string(k->type));
1044
1045                         if (!delete &&
1046                             !k->installed &&
1047                             !unit_matters_to_anchor(k->unit, k)) {
1048                                 /* Ok, we can drop this one, so let's
1049                                  * do so. */
1050                                 delete = k;
1051                         }
1052
1053                         /* Check if this in fact was the beginning of
1054                          * the cycle */
1055                         if (k == j)
1056                                 break;
1057                 }
1058
1059
1060                 if (delete) {
1061                         log_warning("Breaking ordering cycle by deleting job %s/%s", delete->unit->id, job_type_to_string(delete->type));
1062                         transaction_delete_unit(m, delete->unit);
1063                         return -EAGAIN;
1064                 }
1065
1066                 log_error("Unable to break cycle");
1067
1068                 dbus_set_error(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, "Transaction order is cyclic. See system logs for details.");
1069                 return -ENOEXEC;
1070         }
1071
1072         /* Make the marker point to where we come from, so that we can
1073          * find our way backwards if we want to break a cycle. We use
1074          * a special marker for the beginning: we point to
1075          * ourselves. */
1076         j->marker = from ? from : j;
1077         j->generation = generation;
1078
1079         /* We assume that the the dependencies are bidirectional, and
1080          * hence can ignore UNIT_AFTER */
1081         SET_FOREACH(u, j->unit->dependencies[UNIT_BEFORE], i) {
1082                 Job *o;
1083
1084                 /* Is there a job for this unit? */
1085                 if (!(o = hashmap_get(m->transaction_jobs, u)))
1086
1087                         /* Ok, there is no job for this in the
1088                          * transaction, but maybe there is already one
1089                          * running? */
1090                         if (!(o = u->job))
1091                                 continue;
1092
1093                 if ((r = transaction_verify_order_one(m, o, j, generation, e)) < 0)
1094                         return r;
1095         }
1096
1097         /* Ok, let's backtrack, and remember that this entry is not on
1098          * our path anymore. */
1099         j->marker = NULL;
1100
1101         return 0;
1102 }
1103
1104 static int transaction_verify_order(Manager *m, unsigned *generation, DBusError *e) {
1105         Job *j;
1106         int r;
1107         Iterator i;
1108         unsigned g;
1109
1110         assert(m);
1111         assert(generation);
1112
1113         /* Check if the ordering graph is cyclic. If it is, try to fix
1114          * that up by dropping one of the jobs. */
1115
1116         g = (*generation)++;
1117
1118         HASHMAP_FOREACH(j, m->transaction_jobs, i)
1119                 if ((r = transaction_verify_order_one(m, j, NULL, g, e)) < 0)
1120                         return r;
1121
1122         return 0;
1123 }
1124
1125 static void transaction_collect_garbage(Manager *m) {
1126         bool again;
1127
1128         assert(m);
1129
1130         /* Drop jobs that are not required by any other job */
1131
1132         do {
1133                 Iterator i;
1134                 Job *j;
1135
1136                 again = false;
1137
1138                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1139                         if (j->object_list) {
1140                                 /* log_debug("Keeping job %s/%s because of %s/%s", */
1141                                 /*           j->unit->id, job_type_to_string(j->type), */
1142                                 /*           j->object_list->subject ? j->object_list->subject->unit->id : "root", */
1143                                 /*           j->object_list->subject ? job_type_to_string(j->object_list->subject->type) : "root"); */
1144                                 continue;
1145                         }
1146
1147                         /* log_debug("Garbage collecting job %s/%s", j->unit->id, job_type_to_string(j->type)); */
1148                         transaction_delete_job(m, j, true);
1149                         again = true;
1150                         break;
1151                 }
1152
1153         } while (again);
1154 }
1155
1156 static int transaction_is_destructive(Manager *m, DBusError *e) {
1157         Iterator i;
1158         Job *j;
1159
1160         assert(m);
1161
1162         /* Checks whether applying this transaction means that
1163          * existing jobs would be replaced */
1164
1165         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1166
1167                 /* Assume merged */
1168                 assert(!j->transaction_prev);
1169                 assert(!j->transaction_next);
1170
1171                 if (j->unit->job &&
1172                     j->unit->job != j &&
1173                     !job_type_is_superset(j->type, j->unit->job->type)) {
1174
1175                         dbus_set_error(e, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE, "Transaction is destructive.");
1176                         return -EEXIST;
1177                 }
1178         }
1179
1180         return 0;
1181 }
1182
1183 static void transaction_minimize_impact(Manager *m) {
1184         bool again;
1185         assert(m);
1186
1187         /* Drops all unnecessary jobs that reverse already active jobs
1188          * or that stop a running service. */
1189
1190         do {
1191                 Job *j;
1192                 Iterator i;
1193
1194                 again = false;
1195
1196                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1197                         LIST_FOREACH(transaction, j, j) {
1198                                 bool stops_running_service, changes_existing_job;
1199
1200                                 /* If it matters, we shouldn't drop it */
1201                                 if (j->matters_to_anchor)
1202                                         continue;
1203
1204                                 /* Would this stop a running service?
1205                                  * Would this change an existing job?
1206                                  * If so, let's drop this entry */
1207
1208                                 stops_running_service =
1209                                         j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit));
1210
1211                                 changes_existing_job =
1212                                         j->unit->job &&
1213                                         job_type_is_conflicting(j->type, j->unit->job->type);
1214
1215                                 if (!stops_running_service && !changes_existing_job)
1216                                         continue;
1217
1218                                 if (stops_running_service)
1219                                         log_debug("%s/%s would stop a running service.", j->unit->id, job_type_to_string(j->type));
1220
1221                                 if (changes_existing_job)
1222                                         log_debug("%s/%s would change existing job.", j->unit->id, job_type_to_string(j->type));
1223
1224                                 /* Ok, let's get rid of this */
1225                                 log_debug("Deleting %s/%s to minimize impact.", j->unit->id, job_type_to_string(j->type));
1226
1227                                 transaction_delete_job(m, j, true);
1228                                 again = true;
1229                                 break;
1230                         }
1231
1232                         if (again)
1233                                 break;
1234                 }
1235
1236         } while (again);
1237 }
1238
1239 static int transaction_apply(Manager *m, JobMode mode) {
1240         Iterator i;
1241         Job *j;
1242         int r;
1243
1244         /* Moves the transaction jobs to the set of active jobs */
1245
1246         if (mode == JOB_ISOLATE) {
1247
1248                 /* When isolating first kill all installed jobs which
1249                  * aren't part of the new transaction */
1250         rescan:
1251                 HASHMAP_FOREACH(j, m->jobs, i) {
1252                         assert(j->installed);
1253
1254                         if (hashmap_get(m->transaction_jobs, j->unit))
1255                                 continue;
1256
1257                         /* 'j' itself is safe to remove, but if other jobs
1258                            are invalidated recursively, our iterator may become
1259                            invalid and we need to start over. */
1260                         if (job_finish_and_invalidate(j, JOB_CANCELED) > 0)
1261                                 goto rescan;
1262                 }
1263         }
1264
1265         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1266                 /* Assume merged */
1267                 assert(!j->transaction_prev);
1268                 assert(!j->transaction_next);
1269
1270                 if (j->installed)
1271                         continue;
1272
1273                 if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0)
1274                         goto rollback;
1275         }
1276
1277         while ((j = hashmap_steal_first(m->transaction_jobs))) {
1278                 if (j->installed) {
1279                         /* log_debug("Skipping already installed job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id); */
1280                         continue;
1281                 }
1282
1283                 if (j->unit->job)
1284                         job_free(j->unit->job);
1285
1286                 j->unit->job = j;
1287                 j->installed = true;
1288                 m->n_installed_jobs ++;
1289
1290                 /* We're fully installed. Now let's free data we don't
1291                  * need anymore. */
1292
1293                 assert(!j->transaction_next);
1294                 assert(!j->transaction_prev);
1295
1296                 job_add_to_run_queue(j);
1297                 job_add_to_dbus_queue(j);
1298                 job_start_timer(j);
1299
1300                 log_debug("Installed new job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
1301         }
1302
1303         /* As last step, kill all remaining job dependencies. */
1304         transaction_clean_dependencies(m);
1305
1306         return 0;
1307
1308 rollback:
1309
1310         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1311                 if (j->installed)
1312                         continue;
1313
1314                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
1315         }
1316
1317         return r;
1318 }
1319
1320 static int transaction_activate(Manager *m, JobMode mode, DBusError *e) {
1321         int r;
1322         unsigned generation = 1;
1323
1324         assert(m);
1325
1326         /* This applies the changes recorded in transaction_jobs to
1327          * the actual list of jobs, if possible. */
1328
1329         /* First step: figure out which jobs matter */
1330         transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++);
1331
1332         /* Second step: Try not to stop any running services if
1333          * we don't have to. Don't try to reverse running
1334          * jobs if we don't have to. */
1335         if (mode == JOB_FAIL)
1336                 transaction_minimize_impact(m);
1337
1338         /* Third step: Drop redundant jobs */
1339         transaction_drop_redundant(m);
1340
1341         for (;;) {
1342                 /* Fourth step: Let's remove unneeded jobs that might
1343                  * be lurking. */
1344                 if (mode != JOB_ISOLATE)
1345                         transaction_collect_garbage(m);
1346
1347                 /* Fifth step: verify order makes sense and correct
1348                  * cycles if necessary and possible */
1349                 if ((r = transaction_verify_order(m, &generation, e)) >= 0)
1350                         break;
1351
1352                 if (r != -EAGAIN) {
1353                         log_warning("Requested transaction contains an unfixable cyclic ordering dependency: %s", bus_error(e, r));
1354                         goto rollback;
1355                 }
1356
1357                 /* Let's see if the resulting transaction ordering
1358                  * graph is still cyclic... */
1359         }
1360
1361         for (;;) {
1362                 /* Sixth step: let's drop unmergeable entries if
1363                  * necessary and possible, merge entries we can
1364                  * merge */
1365                 if ((r = transaction_merge_jobs(m, e)) >= 0)
1366                         break;
1367
1368                 if (r != -EAGAIN) {
1369                         log_warning("Requested transaction contains unmergeable jobs: %s", bus_error(e, r));
1370                         goto rollback;
1371                 }
1372
1373                 /* Seventh step: an entry got dropped, let's garbage
1374                  * collect its dependencies. */
1375                 if (mode != JOB_ISOLATE)
1376                         transaction_collect_garbage(m);
1377
1378                 /* Let's see if the resulting transaction still has
1379                  * unmergeable entries ... */
1380         }
1381
1382         /* Eights step: Drop redundant jobs again, if the merging now allows us to drop more. */
1383         transaction_drop_redundant(m);
1384
1385         /* Ninth step: check whether we can actually apply this */
1386         if (mode == JOB_FAIL)
1387                 if ((r = transaction_is_destructive(m, e)) < 0) {
1388                         log_notice("Requested transaction contradicts existing jobs: %s", bus_error(e, r));
1389                         goto rollback;
1390                 }
1391
1392         /* Tenth step: apply changes */
1393         if ((r = transaction_apply(m, mode)) < 0) {
1394                 log_warning("Failed to apply transaction: %s", strerror(-r));
1395                 goto rollback;
1396         }
1397
1398         assert(hashmap_isempty(m->transaction_jobs));
1399         assert(!m->transaction_anchor);
1400
1401         return 0;
1402
1403 rollback:
1404         transaction_abort(m);
1405         return r;
1406 }
1407
1408 static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool override, bool *is_new) {
1409         Job *j, *f;
1410
1411         assert(m);
1412         assert(unit);
1413
1414         /* Looks for an existing prospective job and returns that. If
1415          * it doesn't exist it is created and added to the prospective
1416          * jobs list. */
1417
1418         f = hashmap_get(m->transaction_jobs, unit);
1419
1420         LIST_FOREACH(transaction, j, f) {
1421                 assert(j->unit == unit);
1422
1423                 if (j->type == type) {
1424                         if (is_new)
1425                                 *is_new = false;
1426                         return j;
1427                 }
1428         }
1429
1430         if (unit->job && unit->job->type == type)
1431                 j = unit->job;
1432         else if (!(j = job_new(m, type, unit)))
1433                 return NULL;
1434
1435         j->generation = 0;
1436         j->marker = NULL;
1437         j->matters_to_anchor = false;
1438         j->override = override;
1439
1440         LIST_PREPEND(Job, transaction, f, j);
1441
1442         if (hashmap_replace(m->transaction_jobs, unit, f) < 0) {
1443                 job_free(j);
1444                 return NULL;
1445         }
1446
1447         if (is_new)
1448                 *is_new = true;
1449
1450         /* log_debug("Added job %s/%s to transaction.", unit->id, job_type_to_string(type)); */
1451
1452         return j;
1453 }
1454
1455 void manager_transaction_unlink_job(Manager *m, Job *j, bool delete_dependencies) {
1456         assert(m);
1457         assert(j);
1458
1459         if (j->transaction_prev)
1460                 j->transaction_prev->transaction_next = j->transaction_next;
1461         else if (j->transaction_next)
1462                 hashmap_replace(m->transaction_jobs, j->unit, j->transaction_next);
1463         else
1464                 hashmap_remove_value(m->transaction_jobs, j->unit, j);
1465
1466         if (j->transaction_next)
1467                 j->transaction_next->transaction_prev = j->transaction_prev;
1468
1469         j->transaction_prev = j->transaction_next = NULL;
1470
1471         while (j->subject_list)
1472                 job_dependency_free(j->subject_list);
1473
1474         while (j->object_list) {
1475                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
1476
1477                 job_dependency_free(j->object_list);
1478
1479                 if (other && delete_dependencies) {
1480                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
1481                                   other->unit->id, job_type_to_string(other->type),
1482                                   j->unit->id, job_type_to_string(j->type));
1483                         transaction_delete_job(m, other, delete_dependencies);
1484                 }
1485         }
1486 }
1487
1488 static int transaction_add_job_and_dependencies(
1489                 Manager *m,
1490                 JobType type,
1491                 Unit *unit,
1492                 Job *by,
1493                 bool matters,
1494                 bool override,
1495                 bool conflicts,
1496                 bool ignore_requirements,
1497                 bool ignore_order,
1498                 DBusError *e,
1499                 Job **_ret) {
1500         Job *ret;
1501         Iterator i;
1502         Unit *dep;
1503         int r;
1504         bool is_new;
1505
1506         assert(m);
1507         assert(type < _JOB_TYPE_MAX);
1508         assert(unit);
1509
1510         /* log_debug("Pulling in %s/%s from %s/%s", */
1511         /*           unit->id, job_type_to_string(type), */
1512         /*           by ? by->unit->id : "NA", */
1513         /*           by ? job_type_to_string(by->type) : "NA"); */
1514
1515         if (unit->load_state != UNIT_LOADED &&
1516             unit->load_state != UNIT_ERROR &&
1517             unit->load_state != UNIT_MASKED) {
1518                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->id);
1519                 return -EINVAL;
1520         }
1521
1522         if (type != JOB_STOP && unit->load_state == UNIT_ERROR) {
1523                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED,
1524                                "Unit %s failed to load: %s. "
1525                                "See system logs and 'systemctl status %s' for details.",
1526                                unit->id,
1527                                strerror(-unit->load_error),
1528                                unit->id);
1529                 return -EINVAL;
1530         }
1531
1532         if (type != JOB_STOP && unit->load_state == UNIT_MASKED) {
1533                 dbus_set_error(e, BUS_ERROR_MASKED, "Unit %s is masked.", unit->id);
1534                 return -EINVAL;
1535         }
1536
1537         if (!unit_job_is_applicable(unit, type)) {
1538                 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);
1539                 return -EBADR;
1540         }
1541
1542         /* First add the job. */
1543         if (!(ret = transaction_add_one_job(m, type, unit, override, &is_new)))
1544                 return -ENOMEM;
1545
1546         ret->ignore_order = ret->ignore_order || ignore_order;
1547
1548         /* Then, add a link to the job. */
1549         if (!job_dependency_new(by, ret, matters, conflicts))
1550                 return -ENOMEM;
1551
1552         if (is_new && !ignore_requirements) {
1553                 Set *following;
1554
1555                 /* If we are following some other unit, make sure we
1556                  * add all dependencies of everybody following. */
1557                 if (unit_following_set(ret->unit, &following) > 0) {
1558                         SET_FOREACH(dep, following, i)
1559                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1560                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1561
1562                                         if (e)
1563                                                 dbus_error_free(e);
1564                                 }
1565
1566                         set_free(following);
1567                 }
1568
1569                 /* Finally, recursively add in all dependencies. */
1570                 if (type == JOB_START || type == JOB_RELOAD_OR_START) {
1571                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES], i)
1572                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1573                                         if (r != -EBADR)
1574                                                 goto fail;
1575
1576                                         if (e)
1577                                                 dbus_error_free(e);
1578                                 }
1579
1580                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BIND_TO], i)
1581                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1582
1583                                         if (r != -EBADR)
1584                                                 goto fail;
1585
1586                                         if (e)
1587                                                 dbus_error_free(e);
1588                                 }
1589
1590                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1591                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1592                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1593
1594                                         if (e)
1595                                                 dbus_error_free(e);
1596                                 }
1597
1598                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_WANTS], i)
1599                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, false, false, false, ignore_order, e, NULL)) < 0) {
1600                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1601
1602                                         if (e)
1603                                                 dbus_error_free(e);
1604                                 }
1605
1606                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE], i)
1607                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1608
1609                                         if (r != -EBADR)
1610                                                 goto fail;
1611
1612                                         if (e)
1613                                                 dbus_error_free(e);
1614                                 }
1615
1616                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1617                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1618                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1619
1620                                         if (e)
1621                                                 dbus_error_free(e);
1622                                 }
1623
1624                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTS], i)
1625                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, override, true, false, ignore_order, e, NULL)) < 0) {
1626
1627                                         if (r != -EBADR)
1628                                                 goto fail;
1629
1630                                         if (e)
1631                                                 dbus_error_free(e);
1632                                 }
1633
1634                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTED_BY], i)
1635                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1636                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1637
1638                                         if (e)
1639                                                 dbus_error_free(e);
1640                                 }
1641
1642                 }
1643
1644                 if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
1645
1646                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRED_BY], i)
1647                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1648
1649                                         if (r != -EBADR)
1650                                                 goto fail;
1651
1652                                         if (e)
1653                                                 dbus_error_free(e);
1654                                 }
1655
1656                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BOUND_BY], i)
1657                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1658
1659                                         if (r != -EBADR)
1660                                                 goto fail;
1661
1662                                         if (e)
1663                                                 dbus_error_free(e);
1664                                 }
1665                 }
1666
1667                 if (type == JOB_RELOAD || type == JOB_RELOAD_OR_START) {
1668
1669                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_PROPAGATE_RELOAD_TO], i) {
1670                                 r = transaction_add_job_and_dependencies(m, JOB_RELOAD, dep, ret, false, override, false, false, ignore_order, e, NULL);
1671
1672                                 if (r < 0) {
1673                                         log_warning("Cannot add dependency reload job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1674
1675                                         if (e)
1676                                                 dbus_error_free(e);
1677                                 }
1678                         }
1679                 }
1680
1681                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
1682         }
1683
1684         if (_ret)
1685                 *_ret = ret;
1686
1687         return 0;
1688
1689 fail:
1690         return r;
1691 }
1692
1693 static int transaction_add_isolate_jobs(Manager *m) {
1694         Iterator i;
1695         Unit *u;
1696         char *k;
1697         int r;
1698
1699         assert(m);
1700
1701         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1702
1703                 /* ignore aliases */
1704                 if (u->id != k)
1705                         continue;
1706
1707                 if (u->ignore_on_isolate)
1708                         continue;
1709
1710                 /* No need to stop inactive jobs */
1711                 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)) && !u->job)
1712                         continue;
1713
1714                 /* Is there already something listed for this? */
1715                 if (hashmap_get(m->transaction_jobs, u))
1716                         continue;
1717
1718                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, u, NULL, true, false, false, false, false, NULL, NULL)) < 0)
1719                         log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->id, strerror(-r));
1720         }
1721
1722         return 0;
1723 }
1724
1725 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
1726         int r;
1727         Job *ret;
1728
1729         assert(m);
1730         assert(type < _JOB_TYPE_MAX);
1731         assert(unit);
1732         assert(mode < _JOB_MODE_MAX);
1733
1734         if (mode == JOB_ISOLATE && type != JOB_START) {
1735                 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
1736                 return -EINVAL;
1737         }
1738
1739         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1740                 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1741                 return -EPERM;
1742         }
1743
1744         log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1745
1746         if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, override, false,
1747                                                       mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1748                                                       mode == JOB_IGNORE_DEPENDENCIES, e, &ret)) < 0) {
1749                 transaction_abort(m);
1750                 return r;
1751         }
1752
1753         if (mode == JOB_ISOLATE)
1754                 if ((r = transaction_add_isolate_jobs(m)) < 0) {
1755                         transaction_abort(m);
1756                         return r;
1757                 }
1758
1759         if ((r = transaction_activate(m, mode, e)) < 0)
1760                 return r;
1761
1762         log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) ret->id);
1763
1764         if (_ret)
1765                 *_ret = ret;
1766
1767         return 0;
1768 }
1769
1770 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1771         Unit *unit;
1772         int r;
1773
1774         assert(m);
1775         assert(type < _JOB_TYPE_MAX);
1776         assert(name);
1777         assert(mode < _JOB_MODE_MAX);
1778
1779         if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
1780                 return r;
1781
1782         return manager_add_job(m, type, unit, mode, override, e, _ret);
1783 }
1784
1785 Job *manager_get_job(Manager *m, uint32_t id) {
1786         assert(m);
1787
1788         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1789 }
1790
1791 Unit *manager_get_unit(Manager *m, const char *name) {
1792         assert(m);
1793         assert(name);
1794
1795         return hashmap_get(m->units, name);
1796 }
1797
1798 unsigned manager_dispatch_load_queue(Manager *m) {
1799         Unit *u;
1800         unsigned n = 0;
1801
1802         assert(m);
1803
1804         /* Make sure we are not run recursively */
1805         if (m->dispatching_load_queue)
1806                 return 0;
1807
1808         m->dispatching_load_queue = true;
1809
1810         /* Dispatches the load queue. Takes a unit from the queue and
1811          * tries to load its data until the queue is empty */
1812
1813         while ((u = m->load_queue)) {
1814                 assert(u->in_load_queue);
1815
1816                 unit_load(u);
1817                 n++;
1818         }
1819
1820         m->dispatching_load_queue = false;
1821         return n;
1822 }
1823
1824 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1825         Unit *ret;
1826         UnitType t;
1827         int r;
1828
1829         assert(m);
1830         assert(name || path);
1831
1832         /* This will prepare the unit for loading, but not actually
1833          * load anything from disk. */
1834
1835         if (path && !is_path(path)) {
1836                 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1837                 return -EINVAL;
1838         }
1839
1840         if (!name)
1841                 name = file_name_from_path(path);
1842
1843         t = unit_name_to_type(name);
1844
1845         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid_no_type(name, false)) {
1846                 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1847                 return -EINVAL;
1848         }
1849
1850         ret = manager_get_unit(m, name);
1851         if (ret) {
1852                 *_ret = ret;
1853                 return 1;
1854         }
1855
1856         ret = unit_new(m, unit_vtable[t]->object_size);
1857         if (!ret)
1858                 return -ENOMEM;
1859
1860         if (path) {
1861                 ret->fragment_path = strdup(path);
1862                 if (!ret->fragment_path) {
1863                         unit_free(ret);
1864                         return -ENOMEM;
1865                 }
1866         }
1867
1868         if ((r = unit_add_name(ret, name)) < 0) {
1869                 unit_free(ret);
1870                 return r;
1871         }
1872
1873         unit_add_to_load_queue(ret);
1874         unit_add_to_dbus_queue(ret);
1875         unit_add_to_gc_queue(ret);
1876
1877         if (_ret)
1878                 *_ret = ret;
1879
1880         return 0;
1881 }
1882
1883 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1884         int r;
1885
1886         assert(m);
1887
1888         /* This will load the service information files, but not actually
1889          * start any services or anything. */
1890
1891         if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
1892                 return r;
1893
1894         manager_dispatch_load_queue(m);
1895
1896         if (_ret)
1897                 *_ret = unit_follow_merge(*_ret);
1898
1899         return 0;
1900 }
1901
1902 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1903         Iterator i;
1904         Job *j;
1905
1906         assert(s);
1907         assert(f);
1908
1909         HASHMAP_FOREACH(j, s->jobs, i)
1910                 job_dump(j, f, prefix);
1911 }
1912
1913 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1914         Iterator i;
1915         Unit *u;
1916         const char *t;
1917
1918         assert(s);
1919         assert(f);
1920
1921         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1922                 if (u->id == t)
1923                         unit_dump(u, f, prefix);
1924 }
1925
1926 void manager_clear_jobs(Manager *m) {
1927         Job *j;
1928
1929         assert(m);
1930
1931         transaction_abort(m);
1932
1933         while ((j = hashmap_first(m->jobs)))
1934                 job_finish_and_invalidate(j, JOB_CANCELED);
1935 }
1936
1937 unsigned manager_dispatch_run_queue(Manager *m) {
1938         Job *j;
1939         unsigned n = 0;
1940
1941         if (m->dispatching_run_queue)
1942                 return 0;
1943
1944         m->dispatching_run_queue = true;
1945
1946         while ((j = m->run_queue)) {
1947                 assert(j->installed);
1948                 assert(j->in_run_queue);
1949
1950                 job_run_and_invalidate(j);
1951                 n++;
1952         }
1953
1954         m->dispatching_run_queue = false;
1955         return n;
1956 }
1957
1958 unsigned manager_dispatch_dbus_queue(Manager *m) {
1959         Job *j;
1960         Unit *u;
1961         unsigned n = 0;
1962
1963         assert(m);
1964
1965         if (m->dispatching_dbus_queue)
1966                 return 0;
1967
1968         m->dispatching_dbus_queue = true;
1969
1970         while ((u = m->dbus_unit_queue)) {
1971                 assert(u->in_dbus_queue);
1972
1973                 bus_unit_send_change_signal(u);
1974                 n++;
1975         }
1976
1977         while ((j = m->dbus_job_queue)) {
1978                 assert(j->in_dbus_queue);
1979
1980                 bus_job_send_change_signal(j);
1981                 n++;
1982         }
1983
1984         m->dispatching_dbus_queue = false;
1985         return n;
1986 }
1987
1988 static int manager_process_notify_fd(Manager *m) {
1989         ssize_t n;
1990
1991         assert(m);
1992
1993         for (;;) {
1994                 char buf[4096];
1995                 struct msghdr msghdr;
1996                 struct iovec iovec;
1997                 struct ucred *ucred;
1998                 union {
1999                         struct cmsghdr cmsghdr;
2000                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
2001                 } control;
2002                 Unit *u;
2003                 char **tags;
2004
2005                 zero(iovec);
2006                 iovec.iov_base = buf;
2007                 iovec.iov_len = sizeof(buf)-1;
2008
2009                 zero(control);
2010                 zero(msghdr);
2011                 msghdr.msg_iov = &iovec;
2012                 msghdr.msg_iovlen = 1;
2013                 msghdr.msg_control = &control;
2014                 msghdr.msg_controllen = sizeof(control);
2015
2016                 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
2017                         if (n >= 0)
2018                                 return -EIO;
2019
2020                         if (errno == EAGAIN || errno == EINTR)
2021                                 break;
2022
2023                         return -errno;
2024                 }
2025
2026                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
2027                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
2028                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
2029                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
2030                         log_warning("Received notify message without credentials. Ignoring.");
2031                         continue;
2032                 }
2033
2034                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
2035
2036                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
2037                         if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
2038                                 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
2039                                 continue;
2040                         }
2041
2042                 assert((size_t) n < sizeof(buf));
2043                 buf[n] = 0;
2044                 if (!(tags = strv_split(buf, "\n\r")))
2045                         return -ENOMEM;
2046
2047                 log_debug("Got notification message for unit %s", u->id);
2048
2049                 if (UNIT_VTABLE(u)->notify_message)
2050                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
2051
2052                 strv_free(tags);
2053         }
2054
2055         return 0;
2056 }
2057
2058 static int manager_dispatch_sigchld(Manager *m) {
2059         assert(m);
2060
2061         for (;;) {
2062                 siginfo_t si;
2063                 Unit *u;
2064                 int r;
2065
2066                 zero(si);
2067
2068                 /* First we call waitd() for a PID and do not reap the
2069                  * zombie. That way we can still access /proc/$PID for
2070                  * it while it is a zombie. */
2071                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
2072
2073                         if (errno == ECHILD)
2074                                 break;
2075
2076                         if (errno == EINTR)
2077                                 continue;
2078
2079                         return -errno;
2080                 }
2081
2082                 if (si.si_pid <= 0)
2083                         break;
2084
2085                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
2086                         char *name = NULL;
2087
2088                         get_process_comm(si.si_pid, &name);
2089                         log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
2090                         free(name);
2091                 }
2092
2093                 /* Let's flush any message the dying child might still
2094                  * have queued for us. This ensures that the process
2095                  * still exists in /proc so that we can figure out
2096                  * which cgroup and hence unit it belongs to. */
2097                 if ((r = manager_process_notify_fd(m)) < 0)
2098                         return r;
2099
2100                 /* And now figure out the unit this belongs to */
2101                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
2102                         u = cgroup_unit_by_pid(m, si.si_pid);
2103
2104                 /* And now, we actually reap the zombie. */
2105                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
2106                         if (errno == EINTR)
2107                                 continue;
2108
2109                         return -errno;
2110                 }
2111
2112                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
2113                         continue;
2114
2115                 log_debug("Child %lu died (code=%s, status=%i/%s)",
2116                           (long unsigned) si.si_pid,
2117                           sigchld_code_to_string(si.si_code),
2118                           si.si_status,
2119                           strna(si.si_code == CLD_EXITED
2120                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
2121                                 : signal_to_string(si.si_status)));
2122
2123                 if (!u)
2124                         continue;
2125
2126                 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
2127
2128                 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
2129                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
2130         }
2131
2132         return 0;
2133 }
2134
2135 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
2136         int r;
2137         DBusError error;
2138
2139         dbus_error_init(&error);
2140
2141         log_debug("Activating special unit %s", name);
2142
2143         if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
2144                 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
2145
2146         dbus_error_free(&error);
2147
2148         return r;
2149 }
2150
2151 static int manager_process_signal_fd(Manager *m) {
2152         ssize_t n;
2153         struct signalfd_siginfo sfsi;
2154         bool sigchld = false;
2155
2156         assert(m);
2157
2158         for (;;) {
2159                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
2160
2161                         if (n >= 0)
2162                                 return -EIO;
2163
2164                         if (errno == EINTR || errno == EAGAIN)
2165                                 break;
2166
2167                         return -errno;
2168                 }
2169
2170                 if (sfsi.ssi_pid > 0) {
2171                         char *p = NULL;
2172
2173                         get_process_comm(sfsi.ssi_pid, &p);
2174
2175                         log_debug("Received SIG%s from PID %lu (%s).",
2176                                   signal_to_string(sfsi.ssi_signo),
2177                                   (unsigned long) sfsi.ssi_pid, strna(p));
2178                         free(p);
2179                 } else
2180                         log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
2181
2182                 switch (sfsi.ssi_signo) {
2183
2184                 case SIGCHLD:
2185                         sigchld = true;
2186                         break;
2187
2188                 case SIGTERM:
2189                         if (m->running_as == MANAGER_SYSTEM) {
2190                                 /* This is for compatibility with the
2191                                  * original sysvinit */
2192                                 m->exit_code = MANAGER_REEXECUTE;
2193                                 break;
2194                         }
2195
2196                         /* Fall through */
2197
2198                 case SIGINT:
2199                         if (m->running_as == MANAGER_SYSTEM) {
2200                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
2201                                 break;
2202                         }
2203
2204                         /* Run the exit target if there is one, if not, just exit. */
2205                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
2206                                 m->exit_code = MANAGER_EXIT;
2207                                 return 0;
2208                         }
2209
2210                         break;
2211
2212                 case SIGWINCH:
2213                         if (m->running_as == MANAGER_SYSTEM)
2214                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2215
2216                         /* This is a nop on non-init */
2217                         break;
2218
2219                 case SIGPWR:
2220                         if (m->running_as == MANAGER_SYSTEM)
2221                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2222
2223                         /* This is a nop on non-init */
2224                         break;
2225
2226                 case SIGUSR1: {
2227                         Unit *u;
2228
2229                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
2230
2231                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
2232                                 log_info("Trying to reconnect to bus...");
2233                                 bus_init(m, true);
2234                         }
2235
2236                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
2237                                 log_info("Loading D-Bus service...");
2238                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2239                         }
2240
2241                         break;
2242                 }
2243
2244                 case SIGUSR2: {
2245                         FILE *f;
2246                         char *dump = NULL;
2247                         size_t size;
2248
2249                         if (!(f = open_memstream(&dump, &size))) {
2250                                 log_warning("Failed to allocate memory stream.");
2251                                 break;
2252                         }
2253
2254                         manager_dump_units(m, f, "\t");
2255                         manager_dump_jobs(m, f, "\t");
2256
2257                         if (ferror(f)) {
2258                                 fclose(f);
2259                                 free(dump);
2260                                 log_warning("Failed to write status stream");
2261                                 break;
2262                         }
2263
2264                         fclose(f);
2265                         log_dump(LOG_INFO, dump);
2266                         free(dump);
2267
2268                         break;
2269                 }
2270
2271                 case SIGHUP:
2272                         m->exit_code = MANAGER_RELOAD;
2273                         break;
2274
2275                 default: {
2276
2277                         /* Starting SIGRTMIN+0 */
2278                         static const char * const target_table[] = {
2279                                 [0] = SPECIAL_DEFAULT_TARGET,
2280                                 [1] = SPECIAL_RESCUE_TARGET,
2281                                 [2] = SPECIAL_EMERGENCY_TARGET,
2282                                 [3] = SPECIAL_HALT_TARGET,
2283                                 [4] = SPECIAL_POWEROFF_TARGET,
2284                                 [5] = SPECIAL_REBOOT_TARGET,
2285                                 [6] = SPECIAL_KEXEC_TARGET
2286                         };
2287
2288                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2289                         static const ManagerExitCode code_table[] = {
2290                                 [0] = MANAGER_HALT,
2291                                 [1] = MANAGER_POWEROFF,
2292                                 [2] = MANAGER_REBOOT,
2293                                 [3] = MANAGER_KEXEC
2294                         };
2295
2296                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2297                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2298                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2299                                 manager_start_target(m, target_table[idx],
2300                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
2301                                 break;
2302                         }
2303
2304                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2305                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
2306                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
2307                                 break;
2308                         }
2309
2310                         switch (sfsi.ssi_signo - SIGRTMIN) {
2311
2312                         case 20:
2313                                 log_debug("Enabling showing of status.");
2314                                 manager_set_show_status(m, true);
2315                                 break;
2316
2317                         case 21:
2318                                 log_debug("Disabling showing of status.");
2319                                 manager_set_show_status(m, false);
2320                                 break;
2321
2322                         case 22:
2323                                 log_set_max_level(LOG_DEBUG);
2324                                 log_notice("Setting log level to debug.");
2325                                 break;
2326
2327                         case 23:
2328                                 log_set_max_level(LOG_INFO);
2329                                 log_notice("Setting log level to info.");
2330                                 break;
2331
2332                         case 26:
2333                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
2334                                 log_notice("Setting log target to journal-or-kmsg.");
2335                                 break;
2336
2337                         case 27:
2338                                 log_set_target(LOG_TARGET_CONSOLE);
2339                                 log_notice("Setting log target to console.");
2340                                 break;
2341
2342                         case 28:
2343                                 log_set_target(LOG_TARGET_KMSG);
2344                                 log_notice("Setting log target to kmsg.");
2345                                 break;
2346
2347                         case 29:
2348                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
2349                                 log_notice("Setting log target to syslog-or-kmsg.");
2350                                 break;
2351
2352                         default:
2353                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2354                         }
2355                 }
2356                 }
2357         }
2358
2359         if (sigchld)
2360                 return manager_dispatch_sigchld(m);
2361
2362         return 0;
2363 }
2364
2365 static int process_event(Manager *m, struct epoll_event *ev) {
2366         int r;
2367         Watch *w;
2368
2369         assert(m);
2370         assert(ev);
2371
2372         assert_se(w = ev->data.ptr);
2373
2374         if (w->type == WATCH_INVALID)
2375                 return 0;
2376
2377         switch (w->type) {
2378
2379         case WATCH_SIGNAL:
2380
2381                 /* An incoming signal? */
2382                 if (ev->events != EPOLLIN)
2383                         return -EINVAL;
2384
2385                 if ((r = manager_process_signal_fd(m)) < 0)
2386                         return r;
2387
2388                 break;
2389
2390         case WATCH_NOTIFY:
2391
2392                 /* An incoming daemon notification event? */
2393                 if (ev->events != EPOLLIN)
2394                         return -EINVAL;
2395
2396                 if ((r = manager_process_notify_fd(m)) < 0)
2397                         return r;
2398
2399                 break;
2400
2401         case WATCH_FD:
2402
2403                 /* Some fd event, to be dispatched to the units */
2404                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
2405                 break;
2406
2407         case WATCH_UNIT_TIMER:
2408         case WATCH_JOB_TIMER: {
2409                 uint64_t v;
2410                 ssize_t k;
2411
2412                 /* Some timer event, to be dispatched to the units */
2413                 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
2414
2415                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
2416                                 break;
2417
2418                         return k < 0 ? -errno : -EIO;
2419                 }
2420
2421                 if (w->type == WATCH_UNIT_TIMER)
2422                         UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
2423                 else
2424                         job_timer_event(w->data.job, v, w);
2425                 break;
2426         }
2427
2428         case WATCH_MOUNT:
2429                 /* Some mount table change, intended for the mount subsystem */
2430                 mount_fd_event(m, ev->events);
2431                 break;
2432
2433         case WATCH_SWAP:
2434                 /* Some swap table change, intended for the swap subsystem */
2435                 swap_fd_event(m, ev->events);
2436                 break;
2437
2438         case WATCH_UDEV:
2439                 /* Some notification from udev, intended for the device subsystem */
2440                 device_fd_event(m, ev->events);
2441                 break;
2442
2443         case WATCH_DBUS_WATCH:
2444                 bus_watch_event(m, w, ev->events);
2445                 break;
2446
2447         case WATCH_DBUS_TIMEOUT:
2448                 bus_timeout_event(m, w, ev->events);
2449                 break;
2450
2451         default:
2452                 log_error("event type=%i", w->type);
2453                 assert_not_reached("Unknown epoll event type.");
2454         }
2455
2456         return 0;
2457 }
2458
2459 int manager_loop(Manager *m) {
2460         int r;
2461
2462         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
2463
2464         assert(m);
2465         m->exit_code = MANAGER_RUNNING;
2466
2467         /* Release the path cache */
2468         set_free_free(m->unit_path_cache);
2469         m->unit_path_cache = NULL;
2470
2471         manager_check_finished(m);
2472
2473         /* There might still be some zombies hanging around from
2474          * before we were exec()'ed. Leat's reap them */
2475         r = manager_dispatch_sigchld(m);
2476         if (r < 0)
2477                 return r;
2478
2479         while (m->exit_code == MANAGER_RUNNING) {
2480                 struct epoll_event event;
2481                 int n;
2482                 int wait_msec = -1;
2483
2484                 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
2485                         watchdog_ping();
2486
2487                 if (!ratelimit_test(&rl)) {
2488                         /* Yay, something is going seriously wrong, pause a little */
2489                         log_warning("Looping too fast. Throttling execution a little.");
2490                         sleep(1);
2491                         continue;
2492                 }
2493
2494                 if (manager_dispatch_load_queue(m) > 0)
2495                         continue;
2496
2497                 if (manager_dispatch_run_queue(m) > 0)
2498                         continue;
2499
2500                 if (bus_dispatch(m) > 0)
2501                         continue;
2502
2503                 if (manager_dispatch_cleanup_queue(m) > 0)
2504                         continue;
2505
2506                 if (manager_dispatch_gc_queue(m) > 0)
2507                         continue;
2508
2509                 if (manager_dispatch_dbus_queue(m) > 0)
2510                         continue;
2511
2512                 if (swap_dispatch_reload(m) > 0)
2513                         continue;
2514
2515                 /* Sleep for half the watchdog time */
2516                 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
2517                         wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
2518                         if (wait_msec <= 0)
2519                                 wait_msec = 1;
2520                 } else
2521                         wait_msec = -1;
2522
2523                 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
2524                 if (n < 0) {
2525
2526                         if (errno == EINTR)
2527                                 continue;
2528
2529                         return -errno;
2530                 } else if (n == 0)
2531                         continue;
2532
2533                 assert(n == 1);
2534
2535                 r = process_event(m, &event);
2536                 if (r < 0)
2537                         return r;
2538         }
2539
2540         return m->exit_code;
2541 }
2542
2543 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
2544         char *n;
2545         Unit *u;
2546
2547         assert(m);
2548         assert(s);
2549         assert(_u);
2550
2551         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
2552                 return -EINVAL;
2553
2554         if (!(n = bus_path_unescape(s+31)))
2555                 return -ENOMEM;
2556
2557         u = manager_get_unit(m, n);
2558         free(n);
2559
2560         if (!u)
2561                 return -ENOENT;
2562
2563         *_u = u;
2564
2565         return 0;
2566 }
2567
2568 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2569         Job *j;
2570         unsigned id;
2571         int r;
2572
2573         assert(m);
2574         assert(s);
2575         assert(_j);
2576
2577         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
2578                 return -EINVAL;
2579
2580         if ((r = safe_atou(s + 30, &id)) < 0)
2581                 return r;
2582
2583         if (!(j = manager_get_job(m, id)))
2584                 return -ENOENT;
2585
2586         *_j = j;
2587
2588         return 0;
2589 }
2590
2591 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2592
2593 #ifdef HAVE_AUDIT
2594         char *p;
2595
2596         if (m->audit_fd < 0)
2597                 return;
2598
2599         /* Don't generate audit events if the service was already
2600          * started and we're just deserializing */
2601         if (m->n_reloading > 0)
2602                 return;
2603
2604         if (m->running_as != MANAGER_SYSTEM)
2605                 return;
2606
2607         if (u->type != UNIT_SERVICE)
2608                 return;
2609
2610         if (!(p = unit_name_to_prefix_and_instance(u->id))) {
2611                 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
2612                 return;
2613         }
2614
2615         if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
2616                 if (errno == EPERM) {
2617                         /* We aren't allowed to send audit messages?
2618                          * Then let's not retry again. */
2619                         audit_close(m->audit_fd);
2620                         m->audit_fd = -1;
2621                 } else
2622                         log_warning("Failed to send audit message: %m");
2623         }
2624
2625         free(p);
2626 #endif
2627
2628 }
2629
2630 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2631         int fd = -1;
2632         union sockaddr_union sa;
2633         int n = 0;
2634         char *message = NULL;
2635
2636         /* Don't generate plymouth events if the service was already
2637          * started and we're just deserializing */
2638         if (m->n_reloading > 0)
2639                 return;
2640
2641         if (m->running_as != MANAGER_SYSTEM)
2642                 return;
2643
2644         if (u->type != UNIT_SERVICE &&
2645             u->type != UNIT_MOUNT &&
2646             u->type != UNIT_SWAP)
2647                 return;
2648
2649         /* We set SOCK_NONBLOCK here so that we rather drop the
2650          * message then wait for plymouth */
2651         if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
2652                 log_error("socket() failed: %m");
2653                 return;
2654         }
2655
2656         zero(sa);
2657         sa.sa.sa_family = AF_UNIX;
2658         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
2659         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2660
2661                 if (errno != EPIPE &&
2662                     errno != EAGAIN &&
2663                     errno != ENOENT &&
2664                     errno != ECONNREFUSED &&
2665                     errno != ECONNRESET &&
2666                     errno != ECONNABORTED)
2667                         log_error("connect() failed: %m");
2668
2669                 goto finish;
2670         }
2671
2672         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2673                 log_error("Out of memory");
2674                 goto finish;
2675         }
2676
2677         errno = 0;
2678         if (write(fd, message, n + 1) != n + 1) {
2679
2680                 if (errno != EPIPE &&
2681                     errno != EAGAIN &&
2682                     errno != ENOENT &&
2683                     errno != ECONNREFUSED &&
2684                     errno != ECONNRESET &&
2685                     errno != ECONNABORTED)
2686                         log_error("Failed to write Plymouth message: %m");
2687
2688                 goto finish;
2689         }
2690
2691 finish:
2692         if (fd >= 0)
2693                 close_nointr_nofail(fd);
2694
2695         free(message);
2696 }
2697
2698 void manager_dispatch_bus_name_owner_changed(
2699                 Manager *m,
2700                 const char *name,
2701                 const char* old_owner,
2702                 const char *new_owner) {
2703
2704         Unit *u;
2705
2706         assert(m);
2707         assert(name);
2708
2709         if (!(u = hashmap_get(m->watch_bus, name)))
2710                 return;
2711
2712         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2713 }
2714
2715 void manager_dispatch_bus_query_pid_done(
2716                 Manager *m,
2717                 const char *name,
2718                 pid_t pid) {
2719
2720         Unit *u;
2721
2722         assert(m);
2723         assert(name);
2724         assert(pid >= 1);
2725
2726         if (!(u = hashmap_get(m->watch_bus, name)))
2727                 return;
2728
2729         UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2730 }
2731
2732 int manager_open_serialization(Manager *m, FILE **_f) {
2733         char *path = NULL;
2734         mode_t saved_umask;
2735         int fd;
2736         FILE *f;
2737
2738         assert(_f);
2739
2740         if (m->running_as == MANAGER_SYSTEM)
2741                 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2742         else
2743                 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2744
2745         if (!path)
2746                 return -ENOMEM;
2747
2748         saved_umask = umask(0077);
2749         fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2750         umask(saved_umask);
2751
2752         if (fd < 0) {
2753                 free(path);
2754                 return -errno;
2755         }
2756
2757         unlink(path);
2758
2759         log_debug("Serializing state to %s", path);
2760         free(path);
2761
2762         if (!(f = fdopen(fd, "w+")))
2763                 return -errno;
2764
2765         *_f = f;
2766
2767         return 0;
2768 }
2769
2770 int manager_serialize(Manager *m, FILE *f, FDSet *fds) {
2771         Iterator i;
2772         Unit *u;
2773         const char *t;
2774         int r;
2775
2776         assert(m);
2777         assert(f);
2778         assert(fds);
2779
2780         m->n_reloading ++;
2781
2782         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2783         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2784
2785         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2786         dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
2787         dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2788
2789         fputc('\n', f);
2790
2791         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2792                 if (u->id != t)
2793                         continue;
2794
2795                 if (!unit_can_serialize(u))
2796                         continue;
2797
2798                 /* Start marker */
2799                 fputs(u->id, f);
2800                 fputc('\n', f);
2801
2802                 if ((r = unit_serialize(u, f, fds)) < 0) {
2803                         m->n_reloading --;
2804                         return r;
2805                 }
2806         }
2807
2808         assert(m->n_reloading > 0);
2809         m->n_reloading --;
2810
2811         if (ferror(f))
2812                 return -EIO;
2813
2814         r = bus_fdset_add_all(m, fds);
2815         if (r < 0)
2816                 return r;
2817
2818         return 0;
2819 }
2820
2821 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2822         int r = 0;
2823
2824         assert(m);
2825         assert(f);
2826
2827         log_debug("Deserializing state...");
2828
2829         m->n_reloading ++;
2830
2831         for (;;) {
2832                 char line[LINE_MAX], *l;
2833
2834                 if (!fgets(line, sizeof(line), f)) {
2835                         if (feof(f))
2836                                 r = 0;
2837                         else
2838                                 r = -errno;
2839
2840                         goto finish;
2841                 }
2842
2843                 char_array_0(line);
2844                 l = strstrip(line);
2845
2846                 if (l[0] == 0)
2847                         break;
2848
2849                 if (startswith(l, "current-job-id=")) {
2850                         uint32_t id;
2851
2852                         if (safe_atou32(l+15, &id) < 0)
2853                                 log_debug("Failed to parse current job id value %s", l+15);
2854                         else
2855                                 m->current_job_id = MAX(m->current_job_id, id);
2856                 } else if (startswith(l, "taint-usr=")) {
2857                         int b;
2858
2859                         if ((b = parse_boolean(l+10)) < 0)
2860                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2861                         else
2862                                 m->taint_usr = m->taint_usr || b;
2863                 } else if (startswith(l, "initrd-timestamp="))
2864                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2865                 else if (startswith(l, "startup-timestamp="))
2866                         dual_timestamp_deserialize(l+18, &m->startup_timestamp);
2867                 else if (startswith(l, "finish-timestamp="))
2868                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2869                 else
2870                         log_debug("Unknown serialization item '%s'", l);
2871         }
2872
2873         for (;;) {
2874                 Unit *u;
2875                 char name[UNIT_NAME_MAX+2];
2876
2877                 /* Start marker */
2878                 if (!fgets(name, sizeof(name), f)) {
2879                         if (feof(f))
2880                                 r = 0;
2881                         else
2882                                 r = -errno;
2883
2884                         goto finish;
2885                 }
2886
2887                 char_array_0(name);
2888
2889                 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
2890                         goto finish;
2891
2892                 if ((r = unit_deserialize(u, f, fds)) < 0)
2893                         goto finish;
2894         }
2895
2896 finish:
2897         if (ferror(f)) {
2898                 r = -EIO;
2899                 goto finish;
2900         }
2901
2902         assert(m->n_reloading > 0);
2903         m->n_reloading --;
2904
2905         return r;
2906 }
2907
2908 int manager_reload(Manager *m) {
2909         int r, q;
2910         FILE *f;
2911         FDSet *fds;
2912
2913         assert(m);
2914
2915         if ((r = manager_open_serialization(m, &f)) < 0)
2916                 return r;
2917
2918         m->n_reloading ++;
2919
2920         if (!(fds = fdset_new())) {
2921                 m->n_reloading --;
2922                 r = -ENOMEM;
2923                 goto finish;
2924         }
2925
2926         if ((r = manager_serialize(m, f, fds)) < 0) {
2927                 m->n_reloading --;
2928                 goto finish;
2929         }
2930
2931         if (fseeko(f, 0, SEEK_SET) < 0) {
2932                 m->n_reloading --;
2933                 r = -errno;
2934                 goto finish;
2935         }
2936
2937         /* From here on there is no way back. */
2938         manager_clear_jobs_and_units(m);
2939         manager_undo_generators(m);
2940
2941         /* Find new unit paths */
2942         lookup_paths_free(&m->lookup_paths);
2943         if ((q = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
2944                 r = q;
2945
2946         manager_run_generators(m);
2947
2948         manager_build_unit_path_cache(m);
2949
2950         /* First, enumerate what we can from all config files */
2951         if ((q = manager_enumerate(m)) < 0)
2952                 r = q;
2953
2954         /* Second, deserialize our stored data */
2955         if ((q = manager_deserialize(m, f, fds)) < 0)
2956                 r = q;
2957
2958         fclose(f);
2959         f = NULL;
2960
2961         /* Third, fire things up! */
2962         if ((q = manager_coldplug(m)) < 0)
2963                 r = q;
2964
2965         assert(m->n_reloading > 0);
2966         m->n_reloading--;
2967
2968 finish:
2969         if (f)
2970                 fclose(f);
2971
2972         if (fds)
2973                 fdset_free(fds);
2974
2975         return r;
2976 }
2977
2978 bool manager_is_booting_or_shutting_down(Manager *m) {
2979         Unit *u;
2980
2981         assert(m);
2982
2983         /* Is the initial job still around? */
2984         if (manager_get_job(m, m->default_unit_job_id))
2985                 return true;
2986
2987         /* Is there a job for the shutdown target? */
2988         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2989         if (u)
2990                 return !!u->job;
2991
2992         return false;
2993 }
2994
2995 void manager_reset_failed(Manager *m) {
2996         Unit *u;
2997         Iterator i;
2998
2999         assert(m);
3000
3001         HASHMAP_FOREACH(u, m->units, i)
3002                 unit_reset_failed(u);
3003 }
3004
3005 bool manager_unit_pending_inactive(Manager *m, const char *name) {
3006         Unit *u;
3007
3008         assert(m);
3009         assert(name);
3010
3011         /* Returns true if the unit is inactive or going down */
3012         if (!(u = manager_get_unit(m, name)))
3013                 return true;
3014
3015         return unit_pending_inactive(u);
3016 }
3017
3018 void manager_check_finished(Manager *m) {
3019         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
3020         usec_t kernel_usec, initrd_usec, userspace_usec, total_usec;
3021
3022         assert(m);
3023
3024         if (dual_timestamp_is_set(&m->finish_timestamp))
3025                 return;
3026
3027         if (hashmap_size(m->jobs) > 0)
3028                 return;
3029
3030         dual_timestamp_get(&m->finish_timestamp);
3031
3032         if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
3033
3034                 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3035                 total_usec = m->finish_timestamp.monotonic;
3036
3037                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
3038
3039                         kernel_usec = m->initrd_timestamp.monotonic;
3040                         initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
3041
3042                         log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
3043                                  format_timespan(kernel, sizeof(kernel), kernel_usec),
3044                                  format_timespan(initrd, sizeof(initrd), initrd_usec),
3045                                  format_timespan(userspace, sizeof(userspace), userspace_usec),
3046                                  format_timespan(sum, sizeof(sum), total_usec));
3047                 } else {
3048                         kernel_usec = m->startup_timestamp.monotonic;
3049                         initrd_usec = 0;
3050
3051                         log_info("Startup finished in %s (kernel) + %s (userspace) = %s.",
3052                                  format_timespan(kernel, sizeof(kernel), kernel_usec),
3053                                  format_timespan(userspace, sizeof(userspace), userspace_usec),
3054                                  format_timespan(sum, sizeof(sum), total_usec));
3055                 }
3056         } else {
3057                 userspace_usec = initrd_usec = kernel_usec = 0;
3058                 total_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3059
3060                 log_debug("Startup finished in %s.",
3061                           format_timespan(sum, sizeof(sum), total_usec));
3062         }
3063
3064         bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
3065
3066         sd_notifyf(false,
3067                    "READY=1\nSTATUS=Startup finished in %s.",
3068                    format_timespan(sum, sizeof(sum), total_usec));
3069 }
3070
3071 void manager_run_generators(Manager *m) {
3072         DIR *d = NULL;
3073         const char *generator_path;
3074         const char *argv[3];
3075         mode_t u;
3076
3077         assert(m);
3078
3079         generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
3080         if (!(d = opendir(generator_path))) {
3081
3082                 if (errno == ENOENT)
3083                         return;
3084
3085                 log_error("Failed to enumerate generator directory: %m");
3086                 return;
3087         }
3088
3089         if (!m->generator_unit_path) {
3090                 const char *p;
3091                 char user_path[] = "/tmp/systemd-generator-XXXXXX";
3092
3093                 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
3094                         p = "/run/systemd/generator";
3095
3096                         if (mkdir_p(p, 0755) < 0) {
3097                                 log_error("Failed to create generator directory: %m");
3098                                 goto finish;
3099                         }
3100
3101                 } else {
3102                         if (!(p = mkdtemp(user_path))) {
3103                                 log_error("Failed to create generator directory: %m");
3104                                 goto finish;
3105                         }
3106                 }
3107
3108                 if (!(m->generator_unit_path = strdup(p))) {
3109                         log_error("Failed to allocate generator unit path.");
3110                         goto finish;
3111                 }
3112         }
3113
3114         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
3115         argv[1] = m->generator_unit_path;
3116         argv[2] = NULL;
3117
3118         u = umask(0022);
3119         execute_directory(generator_path, d, (char**) argv);
3120         umask(u);
3121
3122         if (rmdir(m->generator_unit_path) >= 0) {
3123                 /* Uh? we were able to remove this dir? I guess that
3124                  * means the directory was empty, hence let's shortcut
3125                  * this */
3126
3127                 free(m->generator_unit_path);
3128                 m->generator_unit_path = NULL;
3129                 goto finish;
3130         }
3131
3132         if (!strv_find(m->lookup_paths.unit_path, m->generator_unit_path)) {
3133                 char **l;
3134
3135                 if (!(l = strv_append(m->lookup_paths.unit_path, m->generator_unit_path))) {
3136                         log_error("Failed to add generator directory to unit search path: %m");
3137                         goto finish;
3138                 }
3139
3140                 strv_free(m->lookup_paths.unit_path);
3141                 m->lookup_paths.unit_path = l;
3142
3143                 log_debug("Added generator unit path %s to search path.", m->generator_unit_path);
3144         }
3145
3146 finish:
3147         if (d)
3148                 closedir(d);
3149 }
3150
3151 void manager_undo_generators(Manager *m) {
3152         assert(m);
3153
3154         if (!m->generator_unit_path)
3155                 return;
3156
3157         strv_remove(m->lookup_paths.unit_path, m->generator_unit_path);
3158         rm_rf(m->generator_unit_path, false, true, false);
3159
3160         free(m->generator_unit_path);
3161         m->generator_unit_path = NULL;
3162 }
3163
3164 int manager_set_default_controllers(Manager *m, char **controllers) {
3165         char **l;
3166
3167         assert(m);
3168
3169         l = strv_copy(controllers);
3170         if (!l)
3171                 return -ENOMEM;
3172
3173         strv_free(m->default_controllers);
3174         m->default_controllers = l;
3175
3176         cg_shorten_controllers(m->default_controllers);
3177
3178         return 0;
3179 }
3180
3181 void manager_recheck_journal(Manager *m) {
3182         Unit *u;
3183
3184         assert(m);
3185
3186         if (m->running_as != MANAGER_SYSTEM)
3187                 return;
3188
3189         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
3190         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
3191                 log_close_journal();
3192                 return;
3193         }
3194
3195         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
3196         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
3197                 log_close_journal();
3198                 return;
3199         }
3200
3201         /* Hmm, OK, so the socket is fully up and the service is up
3202          * too, then let's make use of the thing. */
3203         log_open();
3204 }
3205
3206 void manager_set_show_status(Manager *m, bool b) {
3207         assert(m);
3208
3209         if (m->running_as != MANAGER_SYSTEM)
3210                 return;
3211
3212         m->show_status = b;
3213
3214         if (b)
3215                 touch("/run/systemd/show-status");
3216         else
3217                 unlink("/run/systemd/show-status");
3218 }
3219
3220 bool manager_get_show_status(Manager *m) {
3221         assert(m);
3222
3223         if (m->running_as != MANAGER_SYSTEM)
3224                 return false;
3225
3226         if (m->show_status)
3227                 return true;
3228
3229         /* If Plymouth is running make sure we show the status, so
3230          * that there's something nice to see when people press Esc */
3231
3232         return plymouth_running();
3233 }
3234
3235 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
3236         [MANAGER_SYSTEM] = "system",
3237         [MANAGER_USER] = "user"
3238 };
3239
3240 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);