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