manager.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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 <utmpx.h>
  31 #include <sys/poll.h>
  32 #include <sys/reboot.h>
  33 #include <sys/ioctl.h>
  34 #include <linux/kd.h>
  35 #include <libcgroup.h>
  36
  37 #include "manager.h"
  38 #include "hashmap.h"
  39 #include "macro.h"
  40 #include "strv.h"
  41 #include "log.h"
  42 #include "util.h"
  43 #include "ratelimit.h"
  44 #include "cgroup.h"
  45 #include "mount-setup.h"
  46 #include "utmp-wtmp.h"
  47
  48 static int manager_setup_signals(Manager *m) {
  49         sigset_t mask;
  50         struct epoll_event ev;
  51
  52         assert(m);
  53
  54         assert_se(sigemptyset(&mask) == 0);
  55         assert_se(sigaddset(&mask, SIGCHLD) == 0);
  56         assert_se(sigaddset(&mask, SIGINT) == 0);   /* Kernel sends us this on control-alt-del */
  57         assert_se(sigaddset(&mask, SIGWINCH) == 0); /* Kernel sends us this on kbrequest (alt-arrowup) */
  58         assert_se(sigaddset(&mask, SIGTERM) == 0);
  59         assert_se(sigaddset(&mask, SIGHUP) == 0);
  60         assert_se(sigaddset(&mask, SIGUSR1) == 0);
  61         assert_se(sigaddset(&mask, SIGUSR2) == 0);
  62         assert_se(sigaddset(&mask, SIGPIPE) == 0);
  63         assert_se(sigaddset(&mask, SIGPWR) == 0);
  64         assert_se(sigaddset(&mask, SIGTTIN) == 0);
  65         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
  66
  67         m->signal_watch.type = WATCH_SIGNAL;
  68         if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
  69                 return -errno;
  70
  71         zero(ev);
  72         ev.events = EPOLLIN;
  73         ev.data.ptr = &m->signal_watch;
  74
  75         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
  76                 return -errno;
  77
  78         if (m->running_as == MANAGER_INIT) {
  79                 /* Enable that we get SIGINT on control-alt-del */
  80                 if (reboot(RB_DISABLE_CAD) < 0)
  81                         log_warning("Failed to enable ctrl-alt-del handling: %s", strerror(errno));
  82
  83                 /* Enable that we get SIGWINCH on kbrequest */
  84                 if (ioctl(0, KDSIGACCEPT, SIGWINCH) < 0)
  85                         log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
  86         }
  87
  88         return 0;
  89 }
  90
  91 static char** session_dirs(void) {
  92         const char *home, *e;
  93         char *config_home = NULL, *data_home = NULL;
  94         char **config_dirs = NULL, **data_dirs = NULL;
  95         char **r = NULL, **t;
  96
  97         /* Implement the mechanisms defined in
  98          *
  99          * http://standards.freedesktop.org/basedir-spec/basedir-spec-0.6.html
 100          *
 101          * We look in both the config and the data dirs because we
 102          * want to encourage that distributors ship their unit files
 103          * as data, and allow overriding as configuration.
 104          */
 105
 106         home = getenv("HOME");
 107
 108         if ((e = getenv("XDG_CONFIG_HOME"))) {
 109                 if (asprintf(&config_home, "%s/systemd/session", e) < 0)
 110                         goto fail;
 111
 112         } else if (home) {
 113                 if (asprintf(&config_home, "%s/.config/systemd/session", home) < 0)
 114                         goto fail;
 115         }
 116
 117         if ((e = getenv("XDG_CONFIG_DIRS")))
 118                 config_dirs = strv_split(e, ":");
 119         else
 120                 config_dirs = strv_new("/etc/xdg", NULL);
 121
 122         if (!config_dirs)
 123                 goto fail;
 124
 125         if ((e = getenv("XDG_DATA_HOME"))) {
 126                 if (asprintf(&data_home, "%s/systemd/session", e) < 0)
 127                         goto fail;
 128
 129         } else if (home) {
 130                 if (asprintf(&data_home, "%s/.local/share/systemd/session", home) < 0)
 131                         goto fail;
 132         }
 133
 134         if ((e = getenv("XDG_DATA_DIRS")))
 135                 data_dirs = strv_split(e, ":");
 136         else
 137                 data_dirs = strv_new("/usr/local/share", "/usr/share", NULL);
 138
 139         if (!data_dirs)
 140                 goto fail;
 141
 142         /* Now merge everything we found. */
 143         if (config_home) {
 144                 if (!(t = strv_append(r, config_home)))
 145                         goto fail;
 146                 strv_free(r);
 147                 r = t;
 148         }
 149
 150         if (!(t = strv_merge_concat(r, config_dirs, "/systemd/session")))
 151                 goto finish;
 152         strv_free(r);
 153         r = t;
 154
 155         if (!(t = strv_append(r, SESSION_CONFIG_UNIT_PATH)))
 156                 goto fail;
 157         strv_free(r);
 158         r = t;
 159
 160         if (data_home) {
 161                 if (!(t = strv_append(r, data_home)))
 162                         goto fail;
 163                 strv_free(r);
 164                 r = t;
 165         }
 166
 167         if (!(t = strv_merge_concat(r, data_dirs, "/systemd/session")))
 168                 goto fail;
 169         strv_free(r);
 170         r = t;
 171
 172         if (!(t = strv_append(r, SESSION_DATA_UNIT_PATH)))
 173                 goto fail;
 174         strv_free(r);
 175         r = t;
 176
 177         if (!strv_path_make_absolute_cwd(r))
 178             goto fail;
 179
 180 finish:
 181         free(config_home);
 182         strv_free(config_dirs);
 183         free(data_home);
 184         strv_free(data_dirs);
 185
 186         return r;
 187
 188 fail:
 189         strv_free(r);
 190         r = NULL;
 191         goto finish;
 192 }
 193
 194 static int manager_find_paths(Manager *m) {
 195         const char *e;
 196         char *t;
 197
 198         assert(m);
 199
 200         /* First priority is whatever has been passed to us via env
 201          * vars */
 202         if ((e = getenv("SYSTEMD_UNIT_PATH")))
 203                 if (!(m->unit_path = split_path_and_make_absolute(e)))
 204                         return -ENOMEM;
 205
 206         if (strv_isempty(m->unit_path)) {
 207
 208                 /* Nothing is set, so let's figure something out. */
 209                 strv_free(m->unit_path);
 210
 211                 if (m->running_as == MANAGER_SESSION) {
 212                         if (!(m->unit_path = session_dirs()))
 213                                 return -ENOMEM;
 214                 } else
 215                         if (!(m->unit_path = strv_new(
 216                                               SYSTEM_CONFIG_UNIT_PATH,  /* /etc/systemd/system/ */
 217                                               SYSTEM_DATA_UNIT_PATH,    /* /lib/systemd/system/ */
 218                                               NULL)))
 219                                 return -ENOMEM;
 220         }
 221
 222         if (m->running_as == MANAGER_INIT) {
 223                 /* /etc/init.d/ compativility does not matter to users */
 224
 225                 if ((e = getenv("SYSTEMD_SYSVINIT_PATH")))
 226                         if (!(m->sysvinit_path = split_path_and_make_absolute(e)))
 227                                 return -ENOMEM;
 228
 229                 if (strv_isempty(m->sysvinit_path)) {
 230                         strv_free(m->sysvinit_path);
 231
 232                         if (!(m->sysvinit_path = strv_new(
 233                                               SYSTEM_SYSVINIT_PATH,     /* /etc/init.d/ */
 234                                               NULL)))
 235                                 return -ENOMEM;
 236                 }
 237
 238                 if ((e = getenv("SYSTEMD_SYSVRCND_PATH")))
 239                         if (!(m->sysvrcnd_path = split_path_and_make_absolute(e)))
 240                                 return -ENOMEM;
 241
 242                 if (strv_isempty(m->sysvrcnd_path)) {
 243                         strv_free(m->sysvrcnd_path);
 244
 245                         if (!(m->sysvrcnd_path = strv_new(
 246                                               SYSTEM_SYSVRCND_PATH,     /* /etc/rcN.d/ */
 247                                               NULL)))
 248                                 return -ENOMEM;
 249                 }
 250         }
 251
 252         strv_uniq(m->unit_path);
 253         strv_uniq(m->sysvinit_path);
 254         strv_uniq(m->sysvrcnd_path);
 255
 256         assert(!strv_isempty(m->unit_path));
 257         if (!(t = strv_join(m->unit_path, "\n\t")))
 258                 return -ENOMEM;
 259         log_debug("Looking for unit files in:\n\t%s", t);
 260         free(t);
 261
 262         if (!strv_isempty(m->sysvinit_path)) {
 263
 264                 if (!(t = strv_join(m->sysvinit_path, "\n\t")))
 265                         return -ENOMEM;
 266
 267                 log_debug("Looking for SysV init scripts in:\n\t%s", t);
 268                 free(t);
 269         } else
 270                 log_debug("Ignoring SysV init scripts.");
 271
 272         if (!strv_isempty(m->sysvrcnd_path)) {
 273
 274                 if (!(t = strv_join(m->sysvrcnd_path, "\n\t")))
 275                         return -ENOMEM;
 276
 277                 log_debug("Looking for SysV rcN.d links in:\n\t%s", t);
 278                 free(t);
 279         } else
 280                 log_debug("Ignoring SysV rcN.d links.");
 281
 282         return 0;
 283 }
 284
 285 int manager_new(ManagerRunningAs running_as, Manager **_m) {
 286         Manager *m;
 287         int r = -ENOMEM;
 288
 289         assert(_m);
 290         assert(running_as >= 0);
 291         assert(running_as < _MANAGER_RUNNING_AS_MAX);
 292
 293         if (!(m = new0(Manager, 1)))
 294                 return -ENOMEM;
 295
 296         m->boot_timestamp = now(CLOCK_REALTIME);
 297
 298         m->running_as = running_as;
 299         m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = -1;
 300         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
 301
 302         if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
 303                 goto fail;
 304
 305         if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
 306                 goto fail;
 307
 308         if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
 309                 goto fail;
 310
 311         if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
 312                 goto fail;
 313
 314         if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
 315                 goto fail;
 316
 317         if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
 318                 goto fail;
 319
 320         if ((r = manager_find_paths(m)) < 0)
 321                 goto fail;
 322
 323         if ((r = manager_setup_signals(m)) < 0)
 324                 goto fail;
 325
 326         if ((r = manager_setup_cgroup(m)) < 0)
 327                 goto fail;
 328
 329         /* Try to connect to the busses, if possible. */
 330         if ((r = bus_init_system(m)) < 0 ||
 331             (r = bus_init_api(m)) < 0)
 332                 goto fail;
 333
 334         *_m = m;
 335         return 0;
 336
 337 fail:
 338         manager_free(m);
 339         return r;
 340 }
 341
 342 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
 343         Meta *meta;
 344         unsigned n = 0;
 345
 346         assert(m);
 347
 348         while ((meta = m->cleanup_queue)) {
 349                 assert(meta->in_cleanup_queue);
 350
 351                 unit_free(UNIT(meta));
 352                 n++;
 353         }
 354
 355         return n;
 356 }
 357
 358 void manager_free(Manager *m) {
 359         UnitType c;
 360         Unit *u;
 361         Job *j;
 362
 363         assert(m);
 364
 365         while ((j = hashmap_first(m->transaction_jobs)))
 366                 job_free(j);
 367
 368         while ((u = hashmap_first(m->units)))
 369                 unit_free(u);
 370
 371         manager_dispatch_cleanup_queue(m);
 372
 373         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 374                 if (unit_vtable[c]->shutdown)
 375                         unit_vtable[c]->shutdown(m);
 376
 377         manager_shutdown_cgroup(m);
 378
 379         bus_done_api(m);
 380         bus_done_system(m);
 381
 382         hashmap_free(m->units);
 383         hashmap_free(m->jobs);
 384         hashmap_free(m->transaction_jobs);
 385         hashmap_free(m->watch_pids);
 386
 387         if (m->epoll_fd >= 0)
 388                 close_nointr(m->epoll_fd);
 389         if (m->signal_watch.fd >= 0)
 390                 close_nointr(m->signal_watch.fd);
 391
 392         strv_free(m->unit_path);
 393         strv_free(m->sysvinit_path);
 394         strv_free(m->sysvrcnd_path);
 395
 396         free(m->cgroup_controller);
 397         free(m->cgroup_hierarchy);
 398
 399         assert(hashmap_isempty(m->cgroup_bondings));
 400         hashmap_free(m->cgroup_bondings);
 401
 402         free(m);
 403 }
 404
 405 int manager_coldplug(Manager *m) {
 406         int r;
 407         UnitType c;
 408         Iterator i;
 409         Unit *u;
 410         char *k;
 411
 412         assert(m);
 413
 414         /* First, let's ask every type to load all units from
 415          * disk/kernel that it might know */
 416         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 417                 if (unit_vtable[c]->enumerate)
 418                         if ((r = unit_vtable[c]->enumerate(m)) < 0)
 419                                 return r;
 420
 421         manager_dispatch_load_queue(m);
 422
 423         /* Then, let's set up their initial state. */
 424         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 425
 426                 /* ignore aliases */
 427                 if (unit_id(u) != k)
 428                         continue;
 429
 430                 if (UNIT_VTABLE(u)->coldplug)
 431                         if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
 432                                 return r;
 433         }
 434
 435         /* Now that the initial devices are available, let's see if we
 436          * can write the utmp file */
 437         manager_write_utmp_reboot(m);
 438
 439         return 0;
 440 }
 441
 442 static void transaction_delete_job(Manager *m, Job *j, bool delete_dependencies) {
 443         assert(m);
 444         assert(j);
 445
 446         /* Deletes one job from the transaction */
 447
 448         manager_transaction_unlink_job(m, j, delete_dependencies);
 449
 450         if (!j->installed)
 451                 job_free(j);
 452 }
 453
 454 static void transaction_delete_unit(Manager *m, Unit *u) {
 455         Job *j;
 456
 457         /* Deletes all jobs associated with a certain unit from the
 458          * transaction */
 459
 460         while ((j = hashmap_get(m->transaction_jobs, u)))
 461                 transaction_delete_job(m, j, true);
 462 }
 463
 464 static void transaction_clean_dependencies(Manager *m) {
 465         Iterator i;
 466         Job *j;
 467
 468         assert(m);
 469
 470         /* Drops all dependencies of all installed jobs */
 471
 472         HASHMAP_FOREACH(j, m->jobs, i) {
 473                 while (j->subject_list)
 474                         job_dependency_free(j->subject_list);
 475                 while (j->object_list)
 476                         job_dependency_free(j->object_list);
 477         }
 478
 479         assert(!m->transaction_anchor);
 480 }
 481
 482 static void transaction_abort(Manager *m) {
 483         Job *j;
 484
 485         assert(m);
 486
 487         while ((j = hashmap_first(m->transaction_jobs)))
 488                 if (j->installed)
 489                         transaction_delete_job(m, j, true);
 490                 else
 491                         job_free(j);
 492
 493         assert(hashmap_isempty(m->transaction_jobs));
 494
 495         transaction_clean_dependencies(m);
 496 }
 497
 498 static void transaction_find_jobs_that_matter_to_anchor(Manager *m, Job *j, unsigned generation) {
 499         JobDependency *l;
 500
 501         assert(m);
 502
 503         /* A recursive sweep through the graph that marks all units
 504          * that matter to the anchor job, i.e. are directly or
 505          * indirectly a dependency of the anchor job via paths that
 506          * are fully marked as mattering. */
 507
 508         if (j)
 509                 l = j->subject_list;
 510         else
 511                 l = m->transaction_anchor;
 512
 513         LIST_FOREACH(subject, l, l) {
 514
 515                 /* This link does not matter */
 516                 if (!l->matters)
 517                         continue;
 518
 519                 /* This unit has already been marked */
 520                 if (l->object->generation == generation)
 521                         continue;
 522
 523                 l->object->matters_to_anchor = true;
 524                 l->object->generation = generation;
 525
 526                 transaction_find_jobs_that_matter_to_anchor(m, l->object, generation);
 527         }
 528 }
 529
 530 static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, JobType t) {
 531         JobDependency *l, *last;
 532
 533         assert(j);
 534         assert(other);
 535         assert(j->unit == other->unit);
 536         assert(!j->installed);
 537
 538         /* Merges 'other' into 'j' and then deletes j. */
 539
 540         j->type = t;
 541         j->state = JOB_WAITING;
 542         j->forced = j->forced || other->forced;
 543
 544         j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
 545
 546         /* Patch us in as new owner of the JobDependency objects */
 547         last = NULL;
 548         LIST_FOREACH(subject, l, other->subject_list) {
 549                 assert(l->subject == other);
 550                 l->subject = j;
 551                 last = l;
 552         }
 553
 554         /* Merge both lists */
 555         if (last) {
 556                 last->subject_next = j->subject_list;
 557                 if (j->subject_list)
 558                         j->subject_list->subject_prev = last;
 559                 j->subject_list = other->subject_list;
 560         }
 561
 562         /* Patch us in as new owner of the JobDependency objects */
 563         last = NULL;
 564         LIST_FOREACH(object, l, other->object_list) {
 565                 assert(l->object == other);
 566                 l->object = j;
 567                 last = l;
 568         }
 569
 570         /* Merge both lists */
 571         if (last) {
 572                 last->object_next = j->object_list;
 573                 if (j->object_list)
 574                         j->object_list->object_prev = last;
 575                 j->object_list = other->object_list;
 576         }
 577
 578         /* Kill the other job */
 579         other->subject_list = NULL;
 580         other->object_list = NULL;
 581         transaction_delete_job(m, other, true);
 582 }
 583
 584 static int delete_one_unmergeable_job(Manager *m, Job *j) {
 585         Job *k;
 586
 587         assert(j);
 588
 589         /* Tries to delete one item in the linked list
 590          * j->transaction_next->transaction_next->... that conflicts
 591          * whith another one, in an attempt to make an inconsistent
 592          * transaction work. */
 593
 594         /* We rely here on the fact that if a merged with b does not
 595          * merge with c, either a or b merge with c neither */
 596         LIST_FOREACH(transaction, j, j)
 597                 LIST_FOREACH(transaction, k, j->transaction_next) {
 598                         Job *d;
 599
 600                         /* Is this one mergeable? Then skip it */
 601                         if (job_type_is_mergeable(j->type, k->type))
 602                                 continue;
 603
 604                         /* Ok, we found two that conflict, let's see if we can
 605                          * drop one of them */
 606                         if (!j->matters_to_anchor)
 607                                 d = j;
 608                         else if (!k->matters_to_anchor)
 609                                 d = k;
 610                         else
 611                                 return -ENOEXEC;
 612
 613                         /* Ok, we can drop one, so let's do so. */
 614                         log_debug("Trying to fix job merging by deleting job %s/%s", unit_id(d->unit), job_type_to_string(d->type));
 615                         transaction_delete_job(m, d, true);
 616                         return 0;
 617                 }
 618
 619         return -EINVAL;
 620 }
 621
 622 static int transaction_merge_jobs(Manager *m) {
 623         Job *j;
 624         Iterator i;
 625         int r;
 626
 627         assert(m);
 628
 629         /* First step, check whether any of the jobs for one specific
 630          * task conflict. If so, try to drop one of them. */
 631         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 632                 JobType t;
 633                 Job *k;
 634
 635                 t = j->type;
 636                 LIST_FOREACH(transaction, k, j->transaction_next) {
 637                         if ((r = job_type_merge(&t, k->type)) >= 0)
 638                                 continue;
 639
 640                         /* OK, we could not merge all jobs for this
 641                          * action. Let's see if we can get rid of one
 642                          * of them */
 643
 644                         if ((r = delete_one_unmergeable_job(m, j)) >= 0)
 645                                 /* Ok, we managed to drop one, now
 646                                  * let's ask our callers to call us
 647                                  * again after garbage collecting */
 648                                 return -EAGAIN;
 649
 650                         /* We couldn't merge anything. Failure */
 651                         return r;
 652                 }
 653         }
 654
 655         /* Second step, merge the jobs. */
 656         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 657                 JobType t = j->type;
 658                 Job *k;
 659
 660                 /* Merge all transactions */
 661                 LIST_FOREACH(transaction, k, j->transaction_next)
 662                         assert_se(job_type_merge(&t, k->type) == 0);
 663
 664                 /* If an active job is mergeable, merge it too */
 665                 if (j->unit->meta.job)
 666                         job_type_merge(&t, j->unit->meta.job->type); /* Might fail. Which is OK */
 667
 668                 while ((k = j->transaction_next)) {
 669                         if (j->installed) {
 670                                 transaction_merge_and_delete_job(m, k, j, t);
 671                                 j = k;
 672                         } else
 673                                 transaction_merge_and_delete_job(m, j, k, t);
 674                 }
 675
 676                 assert(!j->transaction_next);
 677                 assert(!j->transaction_prev);
 678         }
 679
 680         return 0;
 681 }
 682
 683 static void transaction_drop_redundant(Manager *m) {
 684         bool again;
 685
 686         assert(m);
 687
 688         /* Goes through the transaction and removes all jobs that are
 689          * a noop */
 690
 691         do {
 692                 Job *j;
 693                 Iterator i;
 694
 695                 again = false;
 696
 697                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 698                         bool changes_something = false;
 699                         Job *k;
 700
 701                         LIST_FOREACH(transaction, k, j) {
 702
 703                                 if (!job_is_anchor(k) &&
 704                                     job_type_is_redundant(k->type, unit_active_state(k->unit)))
 705                                         continue;
 706
 707                                 changes_something = true;
 708                                 break;
 709                         }
 710
 711                         if (changes_something)
 712                                 continue;
 713
 714                         log_debug("Found redundant job %s/%s, dropping.", unit_id(j->unit), job_type_to_string(j->type));
 715                         transaction_delete_job(m, j, false);
 716                         again = true;
 717                         break;
 718                 }
 719
 720         } while (again);
 721 }
 722
 723 static bool unit_matters_to_anchor(Unit *u, Job *j) {
 724         assert(u);
 725         assert(!j->transaction_prev);
 726
 727         /* Checks whether at least one of the jobs for this unit
 728          * matters to the anchor. */
 729
 730         LIST_FOREACH(transaction, j, j)
 731                 if (j->matters_to_anchor)
 732                         return true;
 733
 734         return false;
 735 }
 736
 737 static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation) {
 738         Iterator i;
 739         Unit *u;
 740         int r;
 741
 742         assert(m);
 743         assert(j);
 744         assert(!j->transaction_prev);
 745
 746         /* Does a recursive sweep through the ordering graph, looking
 747          * for a cycle. If we find cycle we try to break it. */
 748
 749         /* Did we find a cycle? */
 750         if (j->marker && j->generation == generation) {
 751                 Job *k;
 752
 753                 /* So, we already have been here. We have a
 754                  * cycle. Let's try to break it. We go backwards in
 755                  * our path and try to find a suitable job to
 756                  * remove. We use the marker to find our way back,
 757                  * since smart how we are we stored our way back in
 758                  * there. */
 759
 760                 log_debug("Found ordering cycle on %s/%s", unit_id(j->unit), job_type_to_string(j->type));
 761
 762                 for (k = from; k; k = (k->generation == generation ? k->marker : NULL)) {
 763
 764                         log_debug("Walked on cycle path to %s/%s", unit_id(k->unit), job_type_to_string(k->type));
 765
 766                         if (!k->installed &&
 767                             !unit_matters_to_anchor(k->unit, k)) {
 768                                 /* Ok, we can drop this one, so let's
 769                                  * do so. */
 770                                 log_debug("Breaking order cycle by deleting job %s/%s", unit_id(k->unit), job_type_to_string(k->type));
 771                                 transaction_delete_unit(m, k->unit);
 772                                 return -EAGAIN;
 773                         }
 774
 775                         /* Check if this in fact was the beginning of
 776                          * the cycle */
 777                         if (k == j)
 778                                 break;
 779                 }
 780
 781                 log_debug("Unable to break cycle");
 782
 783                 return -ENOEXEC;
 784         }
 785
 786         /* Make the marker point to where we come from, so that we can
 787          * find our way backwards if we want to break a cycle */
 788         j->marker = from;
 789         j->generation = generation;
 790
 791         /* We assume that the the dependencies are bidirectional, and
 792          * hence can ignore UNIT_AFTER */
 793         SET_FOREACH(u, j->unit->meta.dependencies[UNIT_BEFORE], i) {
 794                 Job *o;
 795
 796                 /* Is there a job for this unit? */
 797                 if (!(o = hashmap_get(m->transaction_jobs, u)))
 798
 799                         /* Ok, there is no job for this in the
 800                          * transaction, but maybe there is already one
 801                          * running? */
 802                         if (!(o = u->meta.job))
 803                                 continue;
 804
 805                 if ((r = transaction_verify_order_one(m, o, j, generation)) < 0)
 806                         return r;
 807         }
 808
 809         /* Ok, let's backtrack, and remember that this entry is not on
 810          * our path anymore. */
 811         j->marker = NULL;
 812
 813         return 0;
 814 }
 815
 816 static int transaction_verify_order(Manager *m, unsigned *generation) {
 817         Job *j;
 818         int r;
 819         Iterator i;
 820
 821         assert(m);
 822         assert(generation);
 823
 824         /* Check if the ordering graph is cyclic. If it is, try to fix
 825          * that up by dropping one of the jobs. */
 826
 827         HASHMAP_FOREACH(j, m->transaction_jobs, i)
 828                 if ((r = transaction_verify_order_one(m, j, NULL, (*generation)++)) < 0)
 829                         return r;
 830
 831         return 0;
 832 }
 833
 834 static void transaction_collect_garbage(Manager *m) {
 835         bool again;
 836
 837         assert(m);
 838
 839         /* Drop jobs that are not required by any other job */
 840
 841         do {
 842                 Iterator i;
 843                 Job *j;
 844
 845                 again = false;
 846
 847                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 848                         if (j->object_list)
 849                                 continue;
 850
 851                         log_debug("Garbage collecting job %s/%s", unit_id(j->unit), job_type_to_string(j->type));
 852                         transaction_delete_job(m, j, true);
 853                         again = true;
 854                         break;
 855                 }
 856
 857         } while (again);
 858 }
 859
 860 static int transaction_is_destructive(Manager *m, JobMode mode) {
 861         Iterator i;
 862         Job *j;
 863
 864         assert(m);
 865
 866         /* Checks whether applying this transaction means that
 867          * existing jobs would be replaced */
 868
 869         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 870
 871                 /* Assume merged */
 872                 assert(!j->transaction_prev);
 873                 assert(!j->transaction_next);
 874
 875                 if (j->unit->meta.job &&
 876                     j->unit->meta.job != j &&
 877                     !job_type_is_superset(j->type, j->unit->meta.job->type))
 878                         return -EEXIST;
 879         }
 880
 881         return 0;
 882 }
 883
 884 static void transaction_minimize_impact(Manager *m) {
 885         bool again;
 886         assert(m);
 887
 888         /* Drops all unnecessary jobs that reverse already active jobs
 889          * or that stop a running service. */
 890
 891         do {
 892                 Job *j;
 893                 Iterator i;
 894
 895                 again = false;
 896
 897                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 898                         LIST_FOREACH(transaction, j, j) {
 899                                 bool stops_running_service, changes_existing_job;
 900
 901                                 /* If it matters, we shouldn't drop it */
 902                                 if (j->matters_to_anchor)
 903                                         continue;
 904
 905                                 /* Would this stop a running service?
 906                                  * Would this change an existing job?
 907                                  * If so, let's drop this entry */
 908
 909                                 stops_running_service =
 910                                         j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit));
 911
 912                                 changes_existing_job =
 913                                         j->unit->meta.job && job_type_is_conflicting(j->type, j->unit->meta.job->state);
 914
 915                                 if (!stops_running_service && !changes_existing_job)
 916                                         continue;
 917
 918                                 if (stops_running_service)
 919                                         log_debug("%s/%s would stop a running service.", unit_id(j->unit), job_type_to_string(j->type));
 920
 921                                 if (changes_existing_job)
 922                                         log_debug("%s/%s would change existing job.", unit_id(j->unit), job_type_to_string(j->type));
 923
 924                                 /* Ok, let's get rid of this */
 925                                 log_debug("Deleting %s/%s to minimize impact.", unit_id(j->unit), job_type_to_string(j->type));
 926
 927                                 transaction_delete_job(m, j, true);
 928                                 again = true;
 929                                 break;
 930                         }
 931
 932                         if (again)
 933                                 break;
 934                 }
 935
 936         } while (again);
 937 }
 938
 939 static int transaction_apply(Manager *m, JobMode mode) {
 940         Iterator i;
 941         Job *j;
 942         int r;
 943
 944         /* Moves the transaction jobs to the set of active jobs */
 945
 946         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 947                 /* Assume merged */
 948                 assert(!j->transaction_prev);
 949                 assert(!j->transaction_next);
 950
 951                 if (j->installed)
 952                         continue;
 953
 954                 if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0)
 955                         goto rollback;
 956         }
 957
 958         while ((j = hashmap_steal_first(m->transaction_jobs))) {
 959                 if (j->installed)
 960                         continue;
 961
 962                 if (j->unit->meta.job)
 963                         job_free(j->unit->meta.job);
 964
 965                 j->unit->meta.job = j;
 966                 j->installed = true;
 967
 968                 /* We're fully installed. Now let's free data we don't
 969                  * need anymore. */
 970
 971                 assert(!j->transaction_next);
 972                 assert(!j->transaction_prev);
 973
 974                 job_add_to_run_queue(j);
 975                 job_add_to_dbus_queue(j);
 976         }
 977
 978         /* As last step, kill all remaining job dependencies. */
 979         transaction_clean_dependencies(m);
 980
 981         return 0;
 982
 983 rollback:
 984
 985         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 986                 if (j->installed)
 987                         continue;
 988
 989                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
 990         }
 991
 992         return r;
 993 }
 994
 995 static int transaction_activate(Manager *m, JobMode mode) {
 996         int r;
 997         unsigned generation = 1;
 998
 999         assert(m);
1000
1001         /* This applies the changes recorded in transaction_jobs to
1002          * the actual list of jobs, if possible. */
1003
1004         /* First step: figure out which jobs matter */
1005         transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++);
1006
1007         /* Second step: Try not to stop any running services if
1008          * we don't have to. Don't try to reverse running
1009          * jobs if we don't have to. */
1010         transaction_minimize_impact(m);
1011
1012         /* Third step: Drop redundant jobs */
1013         transaction_drop_redundant(m);
1014
1015         for (;;) {
1016                 /* Fourth step: Let's remove unneeded jobs that might
1017                  * be lurking. */
1018                 transaction_collect_garbage(m);
1019
1020                 /* Fifth step: verify order makes sense and correct
1021                  * cycles if necessary and possible */
1022                 if ((r = transaction_verify_order(m, &generation)) >= 0)
1023                         break;
1024
1025                 if (r != -EAGAIN) {
1026                         log_debug("Requested transaction contains an unfixable cyclic ordering dependency: %s", strerror(-r));
1027                         goto rollback;
1028                 }
1029
1030                 /* Let's see if the resulting transaction ordering
1031                  * graph is still cyclic... */
1032         }
1033
1034         for (;;) {
1035                 /* Sixth step: let's drop unmergeable entries if
1036                  * necessary and possible, merge entries we can
1037                  * merge */
1038                 if ((r = transaction_merge_jobs(m)) >= 0)
1039                         break;
1040
1041                 if (r != -EAGAIN) {
1042                         log_debug("Requested transaction contains unmergable jobs: %s", strerror(-r));
1043                         goto rollback;
1044                 }
1045
1046                 /* Seventh step: an entry got dropped, let's garbage
1047                  * collect its dependencies. */
1048                 transaction_collect_garbage(m);
1049
1050                 /* Let's see if the resulting transaction still has
1051                  * unmergeable entries ... */
1052         }
1053
1054         /* Eights step: Drop redundant jobs again, if the merging now allows us to drop more. */
1055         transaction_drop_redundant(m);
1056
1057         /* Ninth step: check whether we can actually apply this */
1058         if (mode == JOB_FAIL)
1059                 if ((r = transaction_is_destructive(m, mode)) < 0) {
1060                         log_debug("Requested transaction contradicts existing jobs: %s", strerror(-r));
1061                         goto rollback;
1062                 }
1063
1064         /* Tenth step: apply changes */
1065         if ((r = transaction_apply(m, mode)) < 0) {
1066                 log_debug("Failed to apply transaction: %s", strerror(-r));
1067                 goto rollback;
1068         }
1069
1070         assert(hashmap_isempty(m->transaction_jobs));
1071         assert(!m->transaction_anchor);
1072
1073         return 0;
1074
1075 rollback:
1076         transaction_abort(m);
1077         return r;
1078 }
1079
1080 static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool force, bool *is_new) {
1081         Job *j, *f;
1082         int r;
1083
1084         assert(m);
1085         assert(unit);
1086
1087         /* Looks for an axisting prospective job and returns that. If
1088          * it doesn't exist it is created and added to the prospective
1089          * jobs list. */
1090
1091         f = hashmap_get(m->transaction_jobs, unit);
1092
1093         LIST_FOREACH(transaction, j, f) {
1094                 assert(j->unit == unit);
1095
1096                 if (j->type == type) {
1097                         if (is_new)
1098                                 *is_new = false;
1099                         return j;
1100                 }
1101         }
1102
1103         if (unit->meta.job && unit->meta.job->type == type)
1104                 j = unit->meta.job;
1105         else if (!(j = job_new(m, type, unit)))
1106                 return NULL;
1107
1108         j->generation = 0;
1109         j->marker = NULL;
1110         j->matters_to_anchor = false;
1111         j->forced = force;
1112
1113         LIST_PREPEND(Job, transaction, f, j);
1114
1115         if ((r = hashmap_replace(m->transaction_jobs, unit, f)) < 0) {
1116                 job_free(j);
1117                 return NULL;
1118         }
1119
1120         if (is_new)
1121                 *is_new = true;
1122
1123         log_debug("Added job %s/%s to transaction.", unit_id(unit), job_type_to_string(type));
1124
1125         return j;
1126 }
1127
1128 void manager_transaction_unlink_job(Manager *m, Job *j, bool delete_dependencies) {
1129         assert(m);
1130         assert(j);
1131
1132         if (j->transaction_prev)
1133                 j->transaction_prev->transaction_next = j->transaction_next;
1134         else if (j->transaction_next)
1135                 hashmap_replace(m->transaction_jobs, j->unit, j->transaction_next);
1136         else
1137                 hashmap_remove_value(m->transaction_jobs, j->unit, j);
1138
1139         if (j->transaction_next)
1140                 j->transaction_next->transaction_prev = j->transaction_prev;
1141
1142         j->transaction_prev = j->transaction_next = NULL;
1143
1144         while (j->subject_list)
1145                 job_dependency_free(j->subject_list);
1146
1147         while (j->object_list) {
1148                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
1149
1150                 job_dependency_free(j->object_list);
1151
1152                 if (other && delete_dependencies) {
1153                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
1154                                   unit_id(other->unit), job_type_to_string(other->type),
1155                                   unit_id(j->unit), job_type_to_string(j->type));
1156                         transaction_delete_job(m, other, delete_dependencies);
1157                 }
1158         }
1159 }
1160
1161 static int transaction_add_job_and_dependencies(Manager *m, JobType type, Unit *unit, Job *by, bool matters, bool force, Job **_ret) {
1162         Job *ret;
1163         Iterator i;
1164         Unit *dep;
1165         int r;
1166         bool is_new;
1167
1168         assert(m);
1169         assert(type < _JOB_TYPE_MAX);
1170         assert(unit);
1171
1172         if (unit->meta.load_state != UNIT_LOADED)
1173                 return -EINVAL;
1174
1175         if (!unit_job_is_applicable(unit, type))
1176                 return -EBADR;
1177
1178         /* First add the job. */
1179         if (!(ret = transaction_add_one_job(m, type, unit, force, &is_new)))
1180                 return -ENOMEM;
1181
1182         /* Then, add a link to the job. */
1183         if (!job_dependency_new(by, ret, matters))
1184                 return -ENOMEM;
1185
1186         if (is_new) {
1187                 /* Finally, recursively add in all dependencies. */
1188                 if (type == JOB_START || type == JOB_RELOAD_OR_START) {
1189                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRES], i)
1190                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1191                                         goto fail;
1192                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_SOFT_REQUIRES], i)
1193                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
1194                                         goto fail;
1195                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_WANTS], i)
1196                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, force, NULL)) < 0)
1197                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", unit_id(dep), strerror(-r));
1198                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUISITE], i)
1199                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1200                                         goto fail;
1201                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_SOFT_REQUISITE], i)
1202                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
1203                                         goto fail;
1204                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_CONFLICTS], i)
1205                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1206                                         goto fail;
1207
1208                 } else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
1209
1210                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRED_BY], i)
1211                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1212                                         goto fail;
1213                 }
1214
1215                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
1216         }
1217
1218         if (_ret)
1219                 *_ret = ret;
1220
1221         return 0;
1222
1223 fail:
1224         return r;
1225 }
1226
1227 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool force, Job **_ret) {
1228         int r;
1229         Job *ret;
1230
1231         assert(m);
1232         assert(type < _JOB_TYPE_MAX);
1233         assert(unit);
1234         assert(mode < _JOB_MODE_MAX);
1235
1236         log_debug("Trying to enqueue job %s/%s", unit_id(unit), job_type_to_string(type));
1237
1238         if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, force, &ret)) < 0) {
1239                 transaction_abort(m);
1240                 return r;
1241         }
1242
1243         if ((r = transaction_activate(m, mode)) < 0)
1244                 return r;
1245
1246         log_debug("Enqueued job %s/%s as %u", unit_id(unit), job_type_to_string(type), (unsigned) ret->id);
1247
1248         if (_ret)
1249                 *_ret = ret;
1250
1251         return 0;
1252 }
1253
1254 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool force, Job **_ret) {
1255         Unit *unit;
1256         int r;
1257
1258         assert(m);
1259         assert(type < _JOB_TYPE_MAX);
1260         assert(name);
1261         assert(mode < _JOB_MODE_MAX);
1262
1263         if ((r = manager_load_unit(m, name, &unit)) < 0)
1264                 return r;
1265
1266         return manager_add_job(m, type, unit, mode, force, _ret);
1267 }
1268
1269 Job *manager_get_job(Manager *m, uint32_t id) {
1270         assert(m);
1271
1272         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1273 }
1274
1275 Unit *manager_get_unit(Manager *m, const char *name) {
1276         assert(m);
1277         assert(name);
1278
1279         return hashmap_get(m->units, name);
1280 }
1281
1282 unsigned manager_dispatch_load_queue(Manager *m) {
1283         Meta *meta;
1284         unsigned n = 0;
1285
1286         assert(m);
1287
1288         /* Make sure we are not run recursively */
1289         if (m->dispatching_load_queue)
1290                 return 0;
1291
1292         m->dispatching_load_queue = true;
1293
1294         /* Dispatches the load queue. Takes a unit from the queue and
1295          * tries to load its data until the queue is empty */
1296
1297         while ((meta = m->load_queue)) {
1298                 assert(meta->in_load_queue);
1299
1300                 unit_load(UNIT(meta));
1301                 n++;
1302         }
1303
1304         m->dispatching_load_queue = false;
1305         return n;
1306 }
1307
1308 int manager_load_unit(Manager *m, const char *path, Unit **_ret) {
1309         Unit *ret;
1310         int r;
1311         const char *name;
1312
1313         assert(m);
1314         assert(path);
1315         assert(_ret);
1316
1317         /* This will load the service information files, but not actually
1318          * start any services or anything. */
1319
1320         name = file_name_from_path(path);
1321
1322         if ((ret = manager_get_unit(m, name))) {
1323                 *_ret = ret;
1324                 return 0;
1325         }
1326
1327         if (!(ret = unit_new(m)))
1328                 return -ENOMEM;
1329
1330         if (is_path(path)) {
1331                 if (!(ret->meta.fragment_path = strdup(path))) {
1332                         unit_free(ret);
1333                         return -ENOMEM;
1334                 }
1335         }
1336
1337         if ((r = unit_add_name(ret, name)) < 0) {
1338                 unit_free(ret);
1339                 return r;
1340         }
1341
1342         unit_add_to_load_queue(ret);
1343         unit_add_to_dbus_queue(ret);
1344
1345         manager_dispatch_load_queue(m);
1346
1347         *_ret = unit_follow_merge(ret);
1348         return 0;
1349 }
1350
1351 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1352         Iterator i;
1353         Job *j;
1354
1355         assert(s);
1356         assert(f);
1357
1358         HASHMAP_FOREACH(j, s->jobs, i)
1359                 job_dump(j, f, prefix);
1360 }
1361
1362 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1363         Iterator i;
1364         Unit *u;
1365         const char *t;
1366
1367         assert(s);
1368         assert(f);
1369
1370         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1371                 if (unit_id(u) == t)
1372                         unit_dump(u, f, prefix);
1373 }
1374
1375 void manager_clear_jobs(Manager *m) {
1376         Job *j;
1377
1378         assert(m);
1379
1380         transaction_abort(m);
1381
1382         while ((j = hashmap_first(m->jobs)))
1383                 job_free(j);
1384 }
1385
1386 unsigned manager_dispatch_run_queue(Manager *m) {
1387         Job *j;
1388         unsigned n = 0;
1389
1390         if (m->dispatching_run_queue)
1391                 return 0;
1392
1393         m->dispatching_run_queue = true;
1394
1395         while ((j = m->run_queue)) {
1396                 assert(j->installed);
1397                 assert(j->in_run_queue);
1398
1399                 job_run_and_invalidate(j);
1400                 n++;
1401         }
1402
1403         m->dispatching_run_queue = false;
1404         return n;
1405 }
1406
1407 unsigned manager_dispatch_dbus_queue(Manager *m) {
1408         Job *j;
1409         Meta *meta;
1410         unsigned n = 0;
1411
1412         assert(m);
1413
1414         if (m->dispatching_dbus_queue)
1415                 return 0;
1416
1417         m->dispatching_dbus_queue = true;
1418
1419         while ((meta = m->dbus_unit_queue)) {
1420                 assert(meta->in_dbus_queue);
1421
1422                 bus_unit_send_change_signal(UNIT(meta));
1423                 n++;
1424         }
1425
1426         while ((j = m->dbus_job_queue)) {
1427                 assert(j->in_dbus_queue);
1428
1429                 bus_job_send_change_signal(j);
1430                 n++;
1431         }
1432
1433         m->dispatching_dbus_queue = false;
1434         return n;
1435 }
1436
1437 static int manager_dispatch_sigchld(Manager *m) {
1438         assert(m);
1439
1440         for (;;) {
1441                 siginfo_t si;
1442                 Unit *u;
1443
1444                 zero(si);
1445                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG) < 0) {
1446
1447                         if (errno == ECHILD)
1448                                 break;
1449
1450                         return -errno;
1451                 }
1452
1453                 if (si.si_pid == 0)
1454                         break;
1455
1456                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1457                         continue;
1458
1459                 log_debug("child %llu died (code=%s, status=%i)", (long long unsigned) si.si_pid, sigchld_code_to_string(si.si_code), si.si_status);
1460
1461                 if (!(u = hashmap_remove(m->watch_pids, UINT32_TO_PTR(si.si_pid))))
1462                         continue;
1463
1464                 log_debug("child %llu belongs to %s", (long long unsigned) si.si_pid, unit_id(u));
1465
1466                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1467         }
1468
1469         return 0;
1470 }
1471
1472 static void manager_start_target(Manager *m, const char *name) {
1473         int r;
1474
1475         if ((r = manager_add_job_by_name(m, JOB_START, name, JOB_REPLACE, true, NULL)) < 0)
1476                 log_error("Failed to enqueue %s job: %s", name, strerror(-r));
1477 }
1478
1479 static int manager_process_signal_fd(Manager *m, bool *quit) {
1480         ssize_t n;
1481         struct signalfd_siginfo sfsi;
1482         bool sigchld = false;
1483
1484         assert(m);
1485
1486         for (;;) {
1487                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1488
1489                         if (n >= 0)
1490                                 return -EIO;
1491
1492                         if (errno == EAGAIN)
1493                                 break;
1494
1495                         return -errno;
1496                 }
1497
1498                 switch (sfsi.ssi_signo) {
1499
1500                 case SIGCHLD: {
1501                         char *name = NULL;
1502
1503                         get_process_name(sfsi.ssi_pid, &name);
1504                         log_debug("Got SIGCHLD for process %llu (%s)", (unsigned long long) sfsi.ssi_pid, strna(name));
1505                         free(name);
1506
1507                         sigchld = true;
1508                         break;
1509                 }
1510
1511                 case SIGINT:
1512                 case SIGTERM:
1513
1514                         if (m->running_as == MANAGER_INIT) {
1515                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET);
1516                                 break;
1517                         }
1518
1519                         *quit = true;
1520                         return 0;
1521
1522                 case SIGWINCH:
1523
1524                         if (m->running_as == MANAGER_INIT)
1525                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET);
1526
1527                         /* This is a nop on non-init */
1528                         break;
1529
1530                 case SIGPWR:
1531                         if (m->running_as == MANAGER_INIT)
1532                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET);
1533
1534                         /* This is a nop on non-init */
1535                         break;
1536
1537                 case SIGUSR1:
1538
1539                         printf("→ By units:\n");
1540                         manager_dump_units(m, stdout, "\t");
1541
1542                         printf("→ By jobs:\n");
1543                         manager_dump_jobs(m, stdout, "\t");
1544
1545                         break;
1546
1547                 default:
1548                         log_info("Got unhandled signal <%s>.", strsignal(sfsi.ssi_signo));
1549                 }
1550         }
1551
1552         if (sigchld)
1553                 return manager_dispatch_sigchld(m);
1554
1555         return 0;
1556 }
1557
1558 static int process_event(Manager *m, struct epoll_event *ev, bool *quit) {
1559         int r;
1560         Watch *w;
1561
1562         assert(m);
1563         assert(ev);
1564
1565         assert(w = ev->data.ptr);
1566
1567         switch (w->type) {
1568
1569         case WATCH_SIGNAL:
1570
1571                 /* An incoming signal? */
1572                 if (ev->events != EPOLLIN)
1573                         return -EINVAL;
1574
1575                 if ((r = manager_process_signal_fd(m, quit)) < 0)
1576                         return r;
1577
1578                 break;
1579
1580         case WATCH_FD:
1581
1582                 /* Some fd event, to be dispatched to the units */
1583                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1584                 break;
1585
1586         case WATCH_TIMER: {
1587                 uint64_t v;
1588                 ssize_t k;
1589
1590                 /* Some timer event, to be dispatched to the units */
1591                 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1592
1593                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
1594                                 break;
1595
1596                         return k < 0 ? -errno : -EIO;
1597                 }
1598
1599                 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1600                 break;
1601         }
1602
1603         case WATCH_MOUNT:
1604                 /* Some mount table change, intended for the mount subsystem */
1605                 mount_fd_event(m, ev->events);
1606                 break;
1607
1608         case WATCH_UDEV:
1609                 /* Some notification from udev, intended for the device subsystem */
1610                 device_fd_event(m, ev->events);
1611                 break;
1612
1613         case WATCH_DBUS_WATCH:
1614                 bus_watch_event(m, w, ev->events);
1615                 break;
1616
1617         case WATCH_DBUS_TIMEOUT:
1618                 bus_timeout_event(m, w, ev->events);
1619                 break;
1620
1621         default:
1622                 assert_not_reached("Unknown epoll event type.");
1623         }
1624
1625         return 0;
1626 }
1627
1628 int manager_loop(Manager *m) {
1629         int r;
1630         bool quit = false;
1631
1632         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 1000);
1633
1634         assert(m);
1635
1636         do {
1637                 struct epoll_event event;
1638                 int n;
1639
1640                 if (!ratelimit_test(&rl)) {
1641                         /* Yay, something is going seriously wrong, pause a little */
1642                         log_warning("Looping too fast. Throttling execution a little.");
1643                         sleep(1);
1644                 }
1645
1646                 if (manager_dispatch_cleanup_queue(m) > 0)
1647                         continue;
1648
1649                 if (manager_dispatch_load_queue(m) > 0)
1650                         continue;
1651
1652                 if (manager_dispatch_run_queue(m) > 0)
1653                         continue;
1654
1655                 if (bus_dispatch(m) > 0)
1656                         continue;
1657
1658                 if (manager_dispatch_dbus_queue(m) > 0)
1659                         continue;
1660
1661                 if ((n = epoll_wait(m->epoll_fd, &event, 1, -1)) < 0) {
1662
1663                         if (errno == -EINTR)
1664                                 continue;
1665
1666                         return -errno;
1667                 }
1668
1669                 assert(n == 1);
1670
1671                 if ((r = process_event(m, &event, &quit)) < 0)
1672                         return r;
1673         } while (!quit);
1674
1675         return 0;
1676 }
1677
1678 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
1679         char *n;
1680         Unit *u;
1681
1682         assert(m);
1683         assert(s);
1684         assert(_u);
1685
1686         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1687                 return -EINVAL;
1688
1689         if (!(n = bus_path_unescape(s+31)))
1690                 return -ENOMEM;
1691
1692         u = manager_get_unit(m, n);
1693         free(n);
1694
1695         if (!u)
1696                 return -ENOENT;
1697
1698         *_u = u;
1699
1700         return 0;
1701 }
1702
1703 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1704         Job *j;
1705         unsigned id;
1706         int r;
1707
1708         assert(m);
1709         assert(s);
1710         assert(_j);
1711
1712         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1713                 return -EINVAL;
1714
1715         if ((r = safe_atou(s + 30, &id)) < 0)
1716                 return r;
1717
1718         if (!(j = manager_get_job(m, id)))
1719                 return -ENOENT;
1720
1721         *_j = j;
1722
1723         return 0;
1724 }
1725
1726 static bool manager_utmp_good(Manager *m) {
1727         int r;
1728
1729         assert(m);
1730
1731         if ((r = mount_path_is_mounted(m, _PATH_UTMPX)) <= 0) {
1732
1733                 if (r < 0)
1734                         log_warning("Failed to determine whether " _PATH_UTMPX " is mounted: %s", strerror(-r));
1735
1736                 return false;
1737         }
1738
1739         return true;
1740 }
1741
1742 void manager_write_utmp_reboot(Manager *m) {
1743         int r;
1744
1745         assert(m);
1746
1747         if (m->utmp_reboot_written)
1748                 return;
1749
1750         if (m->running_as != MANAGER_INIT)
1751                 return;
1752
1753         if (!manager_utmp_good(m))
1754                 return;
1755
1756         if ((r = utmp_put_reboot(m->boot_timestamp)) < 0) {
1757
1758                 if (r != -ENOENT && r != -EROFS)
1759                         log_warning("Failed to write utmp/wtmp: %s", strerror(-r));
1760
1761                 return;
1762         }
1763
1764         m->utmp_reboot_written = true;
1765 }
1766
1767 void manager_write_utmp_runlevel(Manager *m, Unit *u) {
1768         int runlevel, r;
1769
1770         assert(m);
1771         assert(u);
1772
1773         if (u->meta.type != UNIT_TARGET)
1774                 return;
1775
1776         if (m->running_as != MANAGER_INIT)
1777                 return;
1778
1779         if (!manager_utmp_good(m))
1780                 return;
1781
1782         if ((runlevel = target_get_runlevel(TARGET(u))) <= 0)
1783                 return;
1784
1785         if ((r = utmp_put_runlevel(0, runlevel, 0)) < 0) {
1786
1787                 if (r != -ENOENT && r != -EROFS)
1788                         log_warning("Failed to write utmp/wtmp: %s", strerror(-r));
1789         }
1790 }
1791
1792 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
1793         [MANAGER_INIT] = "init",
1794         [MANAGER_SYSTEM] = "system",
1795         [MANAGER_SESSION] = "session"
1796 };
1797
1798 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);