manager.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #include <assert.h>
   4 #include <errno.h>
   5 #include <string.h>
   6 #include <sys/epoll.h>
   7 #include <signal.h>
   8 #include <sys/signalfd.h>
   9 #include <sys/wait.h>
  10 #include <unistd.h>
  11 #include <sys/poll.h>
  12
  13 #include "manager.h"
  14 #include "hashmap.h"
  15 #include "macro.h"
  16 #include "strv.h"
  17 #include "log.h"
  18 #include "util.h"
  19
  20 static int manager_setup_signals(Manager *m) {
  21         sigset_t mask;
  22         struct epoll_event ev;
  23
  24         assert(m);
  25
  26         assert_se(reset_all_signal_handlers() == 0);
  27
  28         assert_se(sigemptyset(&mask) == 0);
  29         assert_se(sigaddset(&mask, SIGCHLD) == 0);
  30         assert_se(sigaddset(&mask, SIGINT) == 0);   /* Kernel sends us this on control-alt-del */
  31         assert_se(sigaddset(&mask, SIGWINCH) == 0); /* Kernel sends us this on kbrequest (alt-arrowup) */
  32         assert_se(sigaddset(&mask, SIGTERM) == 0);
  33         assert_se(sigaddset(&mask, SIGHUP) == 0);
  34         assert_se(sigaddset(&mask, SIGUSR1) == 0);
  35         assert_se(sigaddset(&mask, SIGUSR2) == 0);
  36         assert_se(sigaddset(&mask, SIGPIPE) == 0);
  37         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
  38
  39         m->signal_watch.type = WATCH_SIGNAL_FD;
  40         if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
  41                 return -errno;
  42
  43         zero(ev);
  44         ev.events = EPOLLIN;
  45         ev.data.ptr = &m->signal_watch;
  46
  47         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
  48                 return -errno;
  49
  50         return 0;
  51 }
  52
  53 Manager* manager_new(void) {
  54         Manager *m;
  55
  56         if (!(m = new0(Manager, 1)))
  57                 return NULL;
  58
  59         m->signal_watch.fd = m->epoll_fd = -1;
  60
  61         if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
  62                 goto fail;
  63
  64         if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
  65                 goto fail;
  66
  67         if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
  68                 goto fail;
  69
  70         if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
  71                 goto fail;
  72
  73         if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
  74                 goto fail;
  75
  76         if (manager_setup_signals(m) < 0)
  77                 goto fail;
  78
  79         return m;
  80
  81 fail:
  82         manager_free(m);
  83         return NULL;
  84 }
  85
  86 void manager_free(Manager *m) {
  87         UnitType c;
  88         Unit *u;
  89         Job *j;
  90
  91         assert(m);
  92
  93         while ((j = hashmap_first(m->transaction_jobs)))
  94                 job_free(j);
  95
  96         while ((u = hashmap_first(m->units)))
  97                 unit_free(u);
  98
  99         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 100                 if (unit_vtable[c]->shutdown)
 101                         unit_vtable[c]->shutdown(m);
 102
 103         hashmap_free(m->units);
 104         hashmap_free(m->jobs);
 105         hashmap_free(m->transaction_jobs);
 106         hashmap_free(m->watch_pids);
 107
 108         if (m->epoll_fd >= 0)
 109                 close_nointr(m->epoll_fd);
 110         if (m->signal_watch.fd >= 0)
 111                 close_nointr(m->signal_watch.fd);
 112
 113         free(m);
 114 }
 115
 116 int manager_coldplug(Manager *m) {
 117         int r;
 118         UnitType c;
 119         Iterator i;
 120         Unit *u;
 121         char *k;
 122
 123         assert(m);
 124
 125         /* First, let's ask every type to load all units from
 126          * disk/kernel that it might know */
 127         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 128                 if (unit_vtable[c]->enumerate)
 129                         if ((r = unit_vtable[c]->enumerate(m)) < 0)
 130                                 return r;
 131
 132         manager_dispatch_load_queue(m);
 133
 134         /* Then, let's set up their initial state. */
 135         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 136
 137                 /* ignore aliases */
 138                 if (unit_id(u) != k)
 139                         continue;
 140
 141                 if (UNIT_VTABLE(u)->coldplug)
 142                         if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
 143                                 return r;
 144         }
 145
 146         return 0;
 147 }
 148
 149 static void transaction_delete_job(Manager *m, Job *j) {
 150         assert(m);
 151         assert(j);
 152
 153         /* Deletes one job from the transaction */
 154
 155         manager_transaction_unlink_job(m, j);
 156
 157         if (!j->installed)
 158                 job_free(j);
 159 }
 160
 161 static void transaction_delete_unit(Manager *m, Unit *u) {
 162         Job *j;
 163
 164         /* Deletes all jobs associated with a certain unit from the
 165          * transaction */
 166
 167         while ((j = hashmap_get(m->transaction_jobs, u)))
 168                 transaction_delete_job(m, j);
 169 }
 170
 171 static void transaction_clean_dependencies(Manager *m) {
 172         Iterator i;
 173         Job *j;
 174
 175         assert(m);
 176
 177         /* Drops all dependencies of all installed jobs */
 178
 179         HASHMAP_FOREACH(j, m->jobs, i) {
 180                 while (j->subject_list)
 181                         job_dependency_free(j->subject_list);
 182                 while (j->object_list)
 183                         job_dependency_free(j->object_list);
 184         }
 185
 186         assert(!m->transaction_anchor);
 187 }
 188
 189 static void transaction_abort(Manager *m) {
 190         Job *j;
 191
 192         assert(m);
 193
 194         while ((j = hashmap_first(m->transaction_jobs)))
 195                 if (j->installed)
 196                         transaction_delete_job(m, j);
 197                 else
 198                         job_free(j);
 199
 200         assert(hashmap_isempty(m->transaction_jobs));
 201
 202         transaction_clean_dependencies(m);
 203 }
 204
 205 static void transaction_find_jobs_that_matter_to_anchor(Manager *m, Job *j, unsigned generation) {
 206         JobDependency *l;
 207
 208         assert(m);
 209
 210         /* A recursive sweep through the graph that marks all units
 211          * that matter to the anchor job, i.e. are directly or
 212          * indirectly a dependency of the anchor job via paths that
 213          * are fully marked as mattering. */
 214
 215         if (j)
 216                 l = j->subject_list;
 217         else
 218                 l = m->transaction_anchor;
 219
 220         LIST_FOREACH(subject, l, l) {
 221
 222                 /* This link does not matter */
 223                 if (!l->matters)
 224                         continue;
 225
 226                 /* This unit has already been marked */
 227                 if (l->object->generation == generation)
 228                         continue;
 229
 230                 l->object->matters_to_anchor = true;
 231                 l->object->generation = generation;
 232
 233                 transaction_find_jobs_that_matter_to_anchor(m, l->object, generation);
 234         }
 235 }
 236
 237 static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, JobType t) {
 238         JobDependency *l, *last;
 239
 240         assert(j);
 241         assert(other);
 242         assert(j->unit == other->unit);
 243         assert(!j->installed);
 244
 245         /* Merges 'other' into 'j' and then deletes j. */
 246
 247         j->type = t;
 248         j->state = JOB_WAITING;
 249         j->forced = j->forced || other->forced;
 250
 251         j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
 252
 253         /* Patch us in as new owner of the JobDependency objects */
 254         last = NULL;
 255         LIST_FOREACH(subject, l, other->subject_list) {
 256                 assert(l->subject == other);
 257                 l->subject = j;
 258                 last = l;
 259         }
 260
 261         /* Merge both lists */
 262         if (last) {
 263                 last->subject_next = j->subject_list;
 264                 if (j->subject_list)
 265                         j->subject_list->subject_prev = last;
 266                 j->subject_list = other->subject_list;
 267         }
 268
 269         /* Patch us in as new owner of the JobDependency objects */
 270         last = NULL;
 271         LIST_FOREACH(object, l, other->object_list) {
 272                 assert(l->object == other);
 273                 l->object = j;
 274                 last = l;
 275         }
 276
 277         /* Merge both lists */
 278         if (last) {
 279                 last->object_next = j->object_list;
 280                 if (j->object_list)
 281                         j->object_list->object_prev = last;
 282                 j->object_list = other->object_list;
 283         }
 284
 285         /* Kill the other job */
 286         other->subject_list = NULL;
 287         other->object_list = NULL;
 288         transaction_delete_job(m, other);
 289 }
 290
 291 static int delete_one_unmergeable_job(Manager *m, Job *j) {
 292         Job *k;
 293
 294         assert(j);
 295
 296         /* Tries to delete one item in the linked list
 297          * j->transaction_next->transaction_next->... that conflicts
 298          * whith another one, in an attempt to make an inconsistent
 299          * transaction work. */
 300
 301         /* We rely here on the fact that if a merged with b does not
 302          * merge with c, either a or b merge with c neither */
 303         LIST_FOREACH(transaction, j, j)
 304                 LIST_FOREACH(transaction, k, j->transaction_next) {
 305                         Job *d;
 306
 307                         /* Is this one mergeable? Then skip it */
 308                         if (job_type_is_mergeable(j->type, k->type))
 309                                 continue;
 310
 311                         /* Ok, we found two that conflict, let's see if we can
 312                          * drop one of them */
 313                         if (!j->matters_to_anchor)
 314                                 d = j;
 315                         else if (!k->matters_to_anchor)
 316                                 d = k;
 317                         else
 318                                 return -ENOEXEC;
 319
 320                         /* Ok, we can drop one, so let's do so. */
 321                         log_debug("Try to fix job merging by deleting job %s/%s", unit_id(d->unit), job_type_to_string(d->type));
 322                         transaction_delete_job(m, d);
 323                         return 0;
 324                 }
 325
 326         return -EINVAL;
 327 }
 328
 329 static int transaction_merge_jobs(Manager *m) {
 330         Job *j;
 331         Iterator i;
 332         int r;
 333
 334         assert(m);
 335
 336         /* First step, check whether any of the jobs for one specific
 337          * task conflict. If so, try to drop one of them. */
 338         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 339                 JobType t;
 340                 Job *k;
 341
 342                 t = j->type;
 343                 LIST_FOREACH(transaction, k, j->transaction_next) {
 344                         if ((r = job_type_merge(&t, k->type)) >= 0)
 345                                 continue;
 346
 347                         /* OK, we could not merge all jobs for this
 348                          * action. Let's see if we can get rid of one
 349                          * of them */
 350
 351                         if ((r = delete_one_unmergeable_job(m, j)) >= 0)
 352                                 /* Ok, we managed to drop one, now
 353                                  * let's ask our callers to call us
 354                                  * again after garbage collecting */
 355                                 return -EAGAIN;
 356
 357                         /* We couldn't merge anything. Failure */
 358                         return r;
 359                 }
 360         }
 361
 362         /* Second step, merge the jobs. */
 363         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 364                 JobType t = j->type;
 365                 Job *k;
 366
 367                 /* Merge all transactions */
 368                 LIST_FOREACH(transaction, k, j->transaction_next)
 369                         assert_se(job_type_merge(&t, k->type) == 0);
 370
 371                 /* If an active job is mergeable, merge it too */
 372                 if (j->unit->meta.job)
 373                         job_type_merge(&t, j->unit->meta.job->type); /* Might fail. Which is OK */
 374
 375                 while ((k = j->transaction_next)) {
 376                         if (j->installed) {
 377                                 transaction_merge_and_delete_job(m, k, j, t);
 378                                 j = k;
 379                         } else
 380                                 transaction_merge_and_delete_job(m, j, k, t);
 381                 }
 382
 383                 assert(!j->transaction_next);
 384                 assert(!j->transaction_prev);
 385         }
 386
 387         return 0;
 388 }
 389
 390 static bool unit_matters_to_anchor(Unit *u, Job *j) {
 391         assert(u);
 392         assert(!j->transaction_prev);
 393
 394         /* Checks whether at least one of the jobs for this unit
 395          * matters to the anchor. */
 396
 397         LIST_FOREACH(transaction, j, j)
 398                 if (j->matters_to_anchor)
 399                         return true;
 400
 401         return false;
 402 }
 403
 404 static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation) {
 405         Iterator i;
 406         Unit *u;
 407         int r;
 408
 409         assert(m);
 410         assert(j);
 411         assert(!j->transaction_prev);
 412
 413         /* Does a recursive sweep through the ordering graph, looking
 414          * for a cycle. If we find cycle we try to break it. */
 415
 416         /* Did we find a cycle? */
 417         if (j->marker && j->generation == generation) {
 418                 Job *k;
 419
 420                 /* So, we already have been here. We have a
 421                  * cycle. Let's try to break it. We go backwards in
 422                  * our path and try to find a suitable job to
 423                  * remove. We use the marker to find our way back,
 424                  * since smart how we are we stored our way back in
 425                  * there. */
 426
 427                 for (k = from; k; k = (k->generation == generation ? k->marker : NULL)) {
 428
 429                         if (!k->installed &&
 430                             !unit_matters_to_anchor(k->unit, k)) {
 431                                 /* Ok, we can drop this one, so let's
 432                                  * do so. */
 433                                 log_debug("Breaking order cycle by deleting job %s/%s", unit_id(k->unit), job_type_to_string(k->type));
 434                                 transaction_delete_unit(m, k->unit);
 435                                 return -EAGAIN;
 436                         }
 437
 438                         /* Check if this in fact was the beginning of
 439                          * the cycle */
 440                         if (k == j)
 441                                 break;
 442                 }
 443
 444                 return -ENOEXEC;
 445         }
 446
 447         /* Make the marker point to where we come from, so that we can
 448          * find our way backwards if we want to break a cycle */
 449         j->marker = from;
 450         j->generation = generation;
 451
 452         /* We assume that the the dependencies are bidirectional, and
 453          * hence can ignore UNIT_AFTER */
 454         SET_FOREACH(u, j->unit->meta.dependencies[UNIT_BEFORE], i) {
 455                 Job *o;
 456
 457                 /* Is there a job for this unit? */
 458                 if (!(o = hashmap_get(m->transaction_jobs, u)))
 459
 460                         /* Ok, there is no job for this in the
 461                          * transaction, but maybe there is already one
 462                          * running? */
 463                         if (!(o = u->meta.job))
 464                                 continue;
 465
 466                 if ((r = transaction_verify_order_one(m, o, j, generation)) < 0)
 467                         return r;
 468         }
 469
 470         return 0;
 471 }
 472
 473 static int transaction_verify_order(Manager *m, unsigned *generation) {
 474         Job *j;
 475         int r;
 476         Iterator i;
 477
 478         assert(m);
 479         assert(generation);
 480
 481         /* Check if the ordering graph is cyclic. If it is, try to fix
 482          * that up by dropping one of the jobs. */
 483
 484         HASHMAP_FOREACH(j, m->transaction_jobs, i)
 485                 if ((r = transaction_verify_order_one(m, j, NULL, (*generation)++)) < 0)
 486                         return r;
 487
 488         return 0;
 489 }
 490
 491 static void transaction_collect_garbage(Manager *m) {
 492         bool again;
 493
 494         assert(m);
 495
 496         /* Drop jobs that are not required by any other job */
 497
 498         do {
 499                 Iterator i;
 500                 Job *j;
 501
 502                 again = false;
 503
 504                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 505                         if (j->object_list)
 506                                 continue;
 507
 508                         log_debug("Garbage collecting job %s/%s", unit_id(j->unit), job_type_to_string(j->type));
 509                         transaction_delete_job(m, j);
 510                         again = true;
 511                         break;
 512                 }
 513
 514         } while (again);
 515 }
 516
 517 static int transaction_is_destructive(Manager *m, JobMode mode) {
 518         Iterator i;
 519         Job *j;
 520
 521         assert(m);
 522
 523         /* Checks whether applying this transaction means that
 524          * existing jobs would be replaced */
 525
 526         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 527
 528                 /* Assume merged */
 529                 assert(!j->transaction_prev);
 530                 assert(!j->transaction_next);
 531
 532                 if (j->unit->meta.job &&
 533                     j->unit->meta.job != j &&
 534                     !job_type_is_superset(j->type, j->unit->meta.job->type))
 535                         return -EEXIST;
 536         }
 537
 538         return 0;
 539 }
 540
 541 static void transaction_minimize_impact(Manager *m) {
 542         bool again;
 543         assert(m);
 544
 545         /* Drops all unnecessary jobs that reverse already active jobs
 546          * or that stop a running service. */
 547
 548         do {
 549                 Job *j;
 550                 Iterator i;
 551
 552                 again = false;
 553
 554                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 555                         LIST_FOREACH(transaction, j, j) {
 556
 557                                 /* If it matters, we shouldn't drop it */
 558                                 if (j->matters_to_anchor)
 559                                         continue;
 560
 561                                 /* Would this stop a running service?
 562                                  * Would this change an existing job?
 563                                  * If so, let's drop this entry */
 564                                 if ((j->type != JOB_STOP || UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(j->unit))) &&
 565                                     (!j->unit->meta.job  || job_type_is_conflicting(j->type, j->unit->meta.job->state)))
 566                                         continue;
 567
 568                                 /* Ok, let's get rid of this */
 569                                 log_debug("Deleting %s/%s to minimize impact", unit_id(j->unit), job_type_to_string(j->type));
 570                                 transaction_delete_job(m, j);
 571                                 again = true;
 572                                 break;
 573                         }
 574
 575                         if (again)
 576                                 break;
 577                 }
 578
 579         } while (again);
 580 }
 581
 582 static int transaction_apply(Manager *m, JobMode mode) {
 583         Iterator i;
 584         Job *j;
 585         int r;
 586
 587         /* Moves the transaction jobs to the set of active jobs */
 588
 589         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 590                 /* Assume merged */
 591                 assert(!j->transaction_prev);
 592                 assert(!j->transaction_next);
 593
 594                 if (j->installed)
 595                         continue;
 596
 597                 if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0)
 598                         goto rollback;
 599         }
 600
 601         while ((j = hashmap_steal_first(m->transaction_jobs))) {
 602                 if (j->installed)
 603                         continue;
 604
 605                 if (j->unit->meta.job)
 606                         job_free(j->unit->meta.job);
 607
 608                 j->unit->meta.job = j;
 609                 j->installed = true;
 610
 611                 /* We're fully installed. Now let's free data we don't
 612                  * need anymore. */
 613
 614                 assert(!j->transaction_next);
 615                 assert(!j->transaction_prev);
 616
 617                 job_schedule_run(j);
 618         }
 619
 620         /* As last step, kill all remaining job dependencies. */
 621         transaction_clean_dependencies(m);
 622
 623         return 0;
 624
 625 rollback:
 626
 627         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 628                 if (j->installed)
 629                         continue;
 630
 631                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
 632         }
 633
 634         return r;
 635 }
 636
 637 static int transaction_activate(Manager *m, JobMode mode) {
 638         int r;
 639         unsigned generation = 1;
 640
 641         assert(m);
 642
 643         /* This applies the changes recorded in transaction_jobs to
 644          * the actual list of jobs, if possible. */
 645
 646         /* First step: figure out which jobs matter */
 647         transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++);
 648
 649         /* Second step: Try not to stop any running services if
 650          * we don't have to. Don't try to reverse running
 651          * jobs if we don't have to. */
 652         transaction_minimize_impact(m);
 653
 654         for (;;) {
 655                 /* Third step: Let's remove unneeded jobs that might
 656                  * be lurking. */
 657                 transaction_collect_garbage(m);
 658
 659                 /* Fourth step: verify order makes sense and correct
 660                  * cycles if necessary and possible */
 661                 if ((r = transaction_verify_order(m, &generation)) >= 0)
 662                         break;
 663
 664                 if (r != -EAGAIN)
 665                         goto rollback;
 666
 667                 /* Let's see if the resulting transaction ordering
 668                  * graph is still cyclic... */
 669         }
 670
 671         for (;;) {
 672                 /* Fifth step: let's drop unmergeable entries if
 673                  * necessary and possible, merge entries we can
 674                  * merge */
 675                 if ((r = transaction_merge_jobs(m)) >= 0)
 676                         break;
 677
 678                 if (r != -EAGAIN)
 679                         goto rollback;
 680
 681                 /* Sixth step: an entry got dropped, let's garbage
 682                  * collect its dependencies. */
 683                 transaction_collect_garbage(m);
 684
 685                 /* Let's see if the resulting transaction still has
 686                  * unmergeable entries ... */
 687         }
 688
 689         /* Seventh step: check whether we can actually apply this */
 690         if (mode == JOB_FAIL)
 691                 if ((r = transaction_is_destructive(m, mode)) < 0)
 692                         goto rollback;
 693
 694         /* Eights step: apply changes */
 695         if ((r = transaction_apply(m, mode)) < 0)
 696                 goto rollback;
 697
 698         assert(hashmap_isempty(m->transaction_jobs));
 699         assert(!m->transaction_anchor);
 700
 701         return 0;
 702
 703 rollback:
 704         transaction_abort(m);
 705         return r;
 706 }
 707
 708 static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool force, bool *is_new) {
 709         Job *j, *f;
 710         int r;
 711
 712         assert(m);
 713         assert(unit);
 714
 715         /* Looks for an axisting prospective job and returns that. If
 716          * it doesn't exist it is created and added to the prospective
 717          * jobs list. */
 718
 719         f = hashmap_get(m->transaction_jobs, unit);
 720
 721         LIST_FOREACH(transaction, j, f) {
 722                 assert(j->unit == unit);
 723
 724                 if (j->type == type) {
 725                         if (is_new)
 726                                 *is_new = false;
 727                         return j;
 728                 }
 729         }
 730
 731         if (unit->meta.job && unit->meta.job->type == type)
 732                 j = unit->meta.job;
 733         else if (!(j = job_new(m, type, unit)))
 734                 return NULL;
 735
 736         j->generation = 0;
 737         j->marker = NULL;
 738         j->matters_to_anchor = false;
 739         j->forced = force;
 740
 741         LIST_PREPEND(Job, transaction, f, j);
 742
 743         if ((r = hashmap_replace(m->transaction_jobs, unit, f)) < 0) {
 744                 job_free(j);
 745                 return NULL;
 746         }
 747
 748         if (is_new)
 749                 *is_new = true;
 750
 751         return j;
 752 }
 753
 754 void manager_transaction_unlink_job(Manager *m, Job *j) {
 755         assert(m);
 756         assert(j);
 757
 758         if (j->transaction_prev)
 759                 j->transaction_prev->transaction_next = j->transaction_next;
 760         else if (j->transaction_next)
 761                 hashmap_replace(m->transaction_jobs, j->unit, j->transaction_next);
 762         else
 763                 hashmap_remove_value(m->transaction_jobs, j->unit, j);
 764
 765         if (j->transaction_next)
 766                 j->transaction_next->transaction_prev = j->transaction_prev;
 767
 768         j->transaction_prev = j->transaction_next = NULL;
 769
 770         while (j->subject_list)
 771                 job_dependency_free(j->subject_list);
 772
 773         while (j->object_list) {
 774                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
 775
 776                 job_dependency_free(j->object_list);
 777
 778                 if (other) {
 779                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
 780                                   unit_id(other->unit), job_type_to_string(other->type),
 781                                   unit_id(j->unit), job_type_to_string(j->type));
 782                         transaction_delete_job(m, other);
 783                 }
 784         }
 785 }
 786
 787 static int transaction_add_job_and_dependencies(Manager *m, JobType type, Unit *unit, Job *by, bool matters, bool force, Job **_ret) {
 788         Job *ret;
 789         Iterator i;
 790         Unit *dep;
 791         int r;
 792         bool is_new;
 793
 794         assert(m);
 795         assert(type < _JOB_TYPE_MAX);
 796         assert(unit);
 797
 798         if (unit->meta.load_state != UNIT_LOADED)
 799                 return -EINVAL;
 800
 801         if (!unit_job_is_applicable(unit, type))
 802                 return -EBADR;
 803
 804         /* First add the job. */
 805         if (!(ret = transaction_add_one_job(m, type, unit, force, &is_new)))
 806                 return -ENOMEM;
 807
 808         /* Then, add a link to the job. */
 809         if (!job_dependency_new(by, ret, matters))
 810                 return -ENOMEM;
 811
 812         if (is_new) {
 813                 /* Finally, recursively add in all dependencies. */
 814                 if (type == JOB_START || type == JOB_RELOAD_OR_START) {
 815                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRES], i)
 816                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
 817                                         goto fail;
 818                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_SOFT_REQUIRES], i)
 819                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
 820                                         goto fail;
 821                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_WANTS], i)
 822                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, force, NULL)) < 0 && r != -EBADR)
 823                                         goto fail;
 824                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUISITE], i)
 825                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
 826                                         goto fail;
 827                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_SOFT_REQUISITE], i)
 828                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
 829                                         goto fail;
 830                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_CONFLICTS], i)
 831                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
 832                                         goto fail;
 833
 834                 } else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
 835
 836                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRED_BY], i)
 837                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
 838                                         goto fail;
 839                 }
 840
 841                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
 842         }
 843
 844         return 0;
 845
 846 fail:
 847         return r;
 848 }
 849
 850 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool force, Job **_ret) {
 851         int r;
 852         Job *ret;
 853
 854         assert(m);
 855         assert(type < _JOB_TYPE_MAX);
 856         assert(unit);
 857         assert(mode < _JOB_MODE_MAX);
 858
 859         if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, force, &ret))) {
 860                 transaction_abort(m);
 861                 return r;
 862         }
 863
 864         if ((r = transaction_activate(m, mode)) < 0)
 865                 return r;
 866
 867         log_debug("Enqueued job %s/%s", unit_id(unit), job_type_to_string(type));
 868
 869         if (_ret)
 870                 *_ret = ret;
 871
 872         return 0;
 873 }
 874
 875 Job *manager_get_job(Manager *m, uint32_t id) {
 876         assert(m);
 877
 878         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
 879 }
 880
 881 Unit *manager_get_unit(Manager *m, const char *name) {
 882         assert(m);
 883         assert(name);
 884
 885         return hashmap_get(m->units, name);
 886 }
 887
 888 void manager_dispatch_load_queue(Manager *m) {
 889         Meta *meta;
 890
 891         assert(m);
 892
 893         /* Make sure we are not run recursively */
 894         if (m->dispatching_load_queue)
 895                 return;
 896
 897         m->dispatching_load_queue = true;
 898
 899         /* Dispatches the load queue. Takes a unit from the queue and
 900          * tries to load its data until the queue is empty */
 901
 902         while ((meta = m->load_queue)) {
 903                 assert(meta->in_load_queue);
 904
 905                 unit_load(UNIT(meta));
 906         }
 907
 908         m->dispatching_load_queue = false;
 909 }
 910
 911 int manager_load_unit(Manager *m, const char *path, Unit **_ret) {
 912         Unit *ret;
 913         int r;
 914         const char *name;
 915
 916         assert(m);
 917         assert(path);
 918         assert(_ret);
 919
 920         /* This will load the service information files, but not actually
 921          * start any services or anything. */
 922
 923         name = file_name_from_path(path);
 924
 925         if ((ret = manager_get_unit(m, name))) {
 926                 *_ret = ret;
 927                 return 0;
 928         }
 929
 930         if (!(ret = unit_new(m)))
 931                 return -ENOMEM;
 932
 933         if (is_path(path)) {
 934                 if (!(ret->meta.load_path = strdup(path))) {
 935                         unit_free(ret);
 936                         return -ENOMEM;
 937                 }
 938         }
 939
 940         if ((r = unit_add_name(ret, name)) < 0) {
 941                 unit_free(ret);
 942                 return r;
 943         }
 944
 945         unit_add_to_load_queue(ret);
 946         manager_dispatch_load_queue(m);
 947
 948         *_ret = ret;
 949         return 0;
 950 }
 951
 952 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
 953         Iterator i;
 954         Job *j;
 955
 956         assert(s);
 957         assert(f);
 958
 959         HASHMAP_FOREACH(j, s->jobs, i)
 960                 job_dump(j, f, prefix);
 961 }
 962
 963 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
 964         Iterator i;
 965         Unit *u;
 966         const char *t;
 967
 968         assert(s);
 969         assert(f);
 970
 971         HASHMAP_FOREACH_KEY(u, t, s->units, i)
 972                 if (unit_id(u) == t)
 973                         unit_dump(u, f, prefix);
 974 }
 975
 976 void manager_clear_jobs(Manager *m) {
 977         Job *j;
 978
 979         assert(m);
 980
 981         transaction_abort(m);
 982
 983         while ((j = hashmap_first(m->jobs)))
 984                 job_free(j);
 985 }
 986
 987 void manager_dispatch_run_queue(Manager *m) {
 988         Job *j;
 989
 990         if (m->dispatching_run_queue)
 991                 return;
 992
 993         m->dispatching_run_queue = true;
 994
 995         while ((j = m->run_queue)) {
 996                 assert(j->installed);
 997                 assert(j->in_run_queue);
 998
 999                 job_run_and_invalidate(j);
1000         }
1001
1002         m->dispatching_run_queue = false;
1003 }
1004
1005 static int manager_dispatch_sigchld(Manager *m) {
1006         assert(m);
1007
1008         log_debug("dispatching SIGCHLD");
1009
1010         for (;;) {
1011                 siginfo_t si;
1012                 Unit *u;
1013
1014                 zero(si);
1015                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG) < 0) {
1016
1017                         if (errno == ECHILD)
1018                                 break;
1019
1020                         return -errno;
1021                 }
1022
1023                 if (si.si_pid == 0)
1024                         break;
1025
1026                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1027                         continue;
1028
1029                 log_debug("child %llu died (code=%s, status=%i)", (long long unsigned) si.si_pid, sigchld_code(si.si_code), si.si_status);
1030
1031                 if (!(u = hashmap_remove(m->watch_pids, UINT32_TO_PTR(si.si_pid))))
1032                         continue;
1033
1034                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1035         }
1036
1037         return 0;
1038 }
1039
1040 static int manager_process_signal_fd(Manager *m, bool *quit) {
1041         ssize_t n;
1042         struct signalfd_siginfo sfsi;
1043         bool sigchld = false;
1044
1045         assert(m);
1046
1047         for (;;) {
1048                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1049
1050                         if (n >= 0)
1051                                 return -EIO;
1052
1053                         if (errno == EAGAIN)
1054                                 break;
1055
1056                         return -errno;
1057                 }
1058
1059                 switch (sfsi.ssi_signo) {
1060
1061                 case SIGCHLD:
1062                         sigchld = true;
1063                         break;
1064
1065                 case SIGINT:
1066                 case SIGTERM:
1067                         *quit = true;
1068                         return 0;
1069
1070                 default:
1071                         log_info("Got unhandled signal <%s>.", strsignal(sfsi.ssi_signo));
1072                 }
1073         }
1074
1075         if (sigchld)
1076                 return manager_dispatch_sigchld(m);
1077
1078         return 0;
1079 }
1080
1081 static int process_event(Manager *m, struct epoll_event *ev, bool *quit) {
1082         int r;
1083         Watch *w;
1084
1085         assert(m);
1086         assert(ev);
1087
1088         assert(w = ev->data.ptr);
1089
1090         switch (w->type) {
1091
1092         case WATCH_SIGNAL_FD:
1093
1094                 /* An incoming signal? */
1095                 if (ev->events != POLLIN)
1096                         return -EINVAL;
1097
1098                 if ((r = manager_process_signal_fd(m, quit)) < 0)
1099                         return r;
1100
1101                 break;
1102
1103         case WATCH_FD:
1104
1105                 /* Some fd event, to be dispatched to the units */
1106                 UNIT_VTABLE(w->unit)->fd_event(w->unit, w->fd, ev->events, w);
1107                 break;
1108
1109         case WATCH_TIMER: {
1110                 uint64_t v;
1111                 ssize_t k;
1112
1113                 /* Some timer event, to be dispatched to the units */
1114                 if ((k = read(ev->data.fd, &v, sizeof(v))) != sizeof(v)) {
1115
1116                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
1117                                 break;
1118
1119                         return k < 0 ? -errno : -EIO;
1120                 }
1121
1122                 UNIT_VTABLE(w->unit)->timer_event(w->unit, v, w);
1123                 break;
1124         }
1125
1126         default:
1127                 assert_not_reached("Unknown epoll event type.");
1128         }
1129
1130         return 0;
1131 }
1132
1133 int manager_loop(Manager *m) {
1134         int r;
1135         bool quit = false;
1136
1137         assert(m);
1138
1139         for (;;) {
1140                 struct epoll_event event;
1141                 int n;
1142
1143                 manager_dispatch_run_queue(m);
1144
1145                 if ((n = epoll_wait(m->epoll_fd, &event, 1, -1)) < 0) {
1146
1147                         if (errno == -EINTR)
1148                                 continue;
1149
1150                         return -errno;
1151                 }
1152
1153                 assert(n == 1);
1154
1155                 if ((r = process_event(m, &event, &quit)) < 0)
1156                         return r;
1157
1158                 if (quit)
1159                         return 0;
1160         }
1161 }