src/core/transaction.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include "transaction.h"
  23 #include "bus-errors.h"
  24
  25 static void transaction_unlink_job(Transaction *tr, Job *j, bool delete_dependencies);
  26
  27 static void transaction_delete_job(Transaction *tr, Job *j, bool delete_dependencies) {
  28         assert(tr);
  29         assert(j);
  30
  31         /* Deletes one job from the transaction */
  32
  33         transaction_unlink_job(tr, j, delete_dependencies);
  34
  35         job_free(j);
  36 }
  37
  38 static void transaction_delete_unit(Transaction *tr, Unit *u) {
  39         Job *j;
  40
  41         /* Deletes all jobs associated with a certain unit from the
  42          * transaction */
  43
  44         while ((j = hashmap_get(tr->jobs, u)))
  45                 transaction_delete_job(tr, j, true);
  46 }
  47
  48 void transaction_abort(Transaction *tr) {
  49         Job *j;
  50
  51         assert(tr);
  52
  53         while ((j = hashmap_first(tr->jobs)))
  54                 transaction_delete_job(tr, j, true);
  55
  56         assert(hashmap_isempty(tr->jobs));
  57 }
  58
  59 static void transaction_find_jobs_that_matter_to_anchor(Job *j, unsigned generation) {
  60         JobDependency *l;
  61
  62         /* A recursive sweep through the graph that marks all units
  63          * that matter to the anchor job, i.e. are directly or
  64          * indirectly a dependency of the anchor job via paths that
  65          * are fully marked as mattering. */
  66
  67         j->matters_to_anchor = true;
  68         j->generation = generation;
  69
  70         LIST_FOREACH(subject, l, j->subject_list) {
  71
  72                 /* This link does not matter */
  73                 if (!l->matters)
  74                         continue;
  75
  76                 /* This unit has already been marked */
  77                 if (l->object->generation == generation)
  78                         continue;
  79
  80                 transaction_find_jobs_that_matter_to_anchor(l->object, generation);
  81         }
  82 }
  83
  84 static void transaction_merge_and_delete_job(Transaction *tr, Job *j, Job *other, JobType t) {
  85         JobDependency *l, *last;
  86
  87         assert(j);
  88         assert(other);
  89         assert(j->unit == other->unit);
  90         assert(!j->installed);
  91
  92         /* Merges 'other' into 'j' and then deletes 'other'. */
  93
  94         j->type = t;
  95         j->state = JOB_WAITING;
  96         j->override = j->override || other->override;
  97
  98         j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
  99
 100         /* Patch us in as new owner of the JobDependency objects */
 101         last = NULL;
 102         LIST_FOREACH(subject, l, other->subject_list) {
 103                 assert(l->subject == other);
 104                 l->subject = j;
 105                 last = l;
 106         }
 107
 108         /* Merge both lists */
 109         if (last) {
 110                 last->subject_next = j->subject_list;
 111                 if (j->subject_list)
 112                         j->subject_list->subject_prev = last;
 113                 j->subject_list = other->subject_list;
 114         }
 115
 116         /* Patch us in as new owner of the JobDependency objects */
 117         last = NULL;
 118         LIST_FOREACH(object, l, other->object_list) {
 119                 assert(l->object == other);
 120                 l->object = j;
 121                 last = l;
 122         }
 123
 124         /* Merge both lists */
 125         if (last) {
 126                 last->object_next = j->object_list;
 127                 if (j->object_list)
 128                         j->object_list->object_prev = last;
 129                 j->object_list = other->object_list;
 130         }
 131
 132         /* Kill the other job */
 133         other->subject_list = NULL;
 134         other->object_list = NULL;
 135         transaction_delete_job(tr, other, true);
 136 }
 137
 138 static bool job_is_conflicted_by(Job *j) {
 139         JobDependency *l;
 140
 141         assert(j);
 142
 143         /* Returns true if this job is pulled in by a least one
 144          * ConflictedBy dependency. */
 145
 146         LIST_FOREACH(object, l, j->object_list)
 147                 if (l->conflicts)
 148                         return true;
 149
 150         return false;
 151 }
 152
 153 static int delete_one_unmergeable_job(Transaction *tr, Job *j) {
 154         Job *k;
 155
 156         assert(j);
 157
 158         /* Tries to delete one item in the linked list
 159          * j->transaction_next->transaction_next->... that conflicts
 160          * with another one, in an attempt to make an inconsistent
 161          * transaction work. */
 162
 163         /* We rely here on the fact that if a merged with b does not
 164          * merge with c, either a or b merge with c neither */
 165         LIST_FOREACH(transaction, j, j)
 166                 LIST_FOREACH(transaction, k, j->transaction_next) {
 167                         Job *d;
 168
 169                         /* Is this one mergeable? Then skip it */
 170                         if (job_type_is_mergeable(j->type, k->type))
 171                                 continue;
 172
 173                         /* Ok, we found two that conflict, let's see if we can
 174                          * drop one of them */
 175                         if (!j->matters_to_anchor && !k->matters_to_anchor) {
 176
 177                                 /* Both jobs don't matter, so let's
 178                                  * find the one that is smarter to
 179                                  * remove. Let's think positive and
 180                                  * rather remove stops then starts --
 181                                  * except if something is being
 182                                  * stopped because it is conflicted by
 183                                  * another unit in which case we
 184                                  * rather remove the start. */
 185
 186                                 log_debug("Looking at job %s/%s conflicted_by=%s", j->unit->id, job_type_to_string(j->type), yes_no(j->type == JOB_STOP && job_is_conflicted_by(j)));
 187                                 log_debug("Looking at job %s/%s conflicted_by=%s", k->unit->id, job_type_to_string(k->type), yes_no(k->type == JOB_STOP && job_is_conflicted_by(k)));
 188
 189                                 if (j->type == JOB_STOP) {
 190
 191                                         if (job_is_conflicted_by(j))
 192                                                 d = k;
 193                                         else
 194                                                 d = j;
 195
 196                                 } else if (k->type == JOB_STOP) {
 197
 198                                         if (job_is_conflicted_by(k))
 199                                                 d = j;
 200                                         else
 201                                                 d = k;
 202                                 } else
 203                                         d = j;
 204
 205                         } else if (!j->matters_to_anchor)
 206                                 d = j;
 207                         else if (!k->matters_to_anchor)
 208                                 d = k;
 209                         else
 210                                 return -ENOEXEC;
 211
 212                         /* Ok, we can drop one, so let's do so. */
 213                         log_debug("Fixing conflicting jobs by deleting job %s/%s", d->unit->id, job_type_to_string(d->type));
 214                         transaction_delete_job(tr, d, true);
 215                         return 0;
 216                 }
 217
 218         return -EINVAL;
 219 }
 220
 221 static int transaction_merge_jobs(Transaction *tr, DBusError *e) {
 222         Job *j;
 223         Iterator i;
 224         int r;
 225
 226         assert(tr);
 227
 228         /* First step, check whether any of the jobs for one specific
 229          * task conflict. If so, try to drop one of them. */
 230         HASHMAP_FOREACH(j, tr->jobs, i) {
 231                 JobType t;
 232                 Job *k;
 233
 234                 t = j->type;
 235                 LIST_FOREACH(transaction, k, j->transaction_next) {
 236                         if (job_type_merge(&t, k->type) >= 0)
 237                                 continue;
 238
 239                         /* OK, we could not merge all jobs for this
 240                          * action. Let's see if we can get rid of one
 241                          * of them */
 242
 243                         r = delete_one_unmergeable_job(tr, j);
 244                         if (r >= 0)
 245                                 /* Ok, we managed to drop one, now
 246                                  * let's ask our callers to call us
 247                                  * again after garbage collecting */
 248                                 return -EAGAIN;
 249
 250                         /* We couldn't merge anything. Failure */
 251                         dbus_set_error(e, BUS_ERROR_TRANSACTION_JOBS_CONFLICTING, "Transaction contains conflicting jobs '%s' and '%s' for %s. Probably contradicting requirement dependencies configured.",
 252                                        job_type_to_string(t), job_type_to_string(k->type), k->unit->id);
 253                         return r;
 254                 }
 255         }
 256
 257         /* Second step, merge the jobs. */
 258         HASHMAP_FOREACH(j, tr->jobs, i) {
 259                 JobType t = j->type;
 260                 Job *k;
 261
 262                 /* Merge all transactions */
 263                 LIST_FOREACH(transaction, k, j->transaction_next)
 264                         assert_se(job_type_merge(&t, k->type) == 0);
 265
 266                 while ((k = j->transaction_next)) {
 267                         if (tr->anchor_job == k) {
 268                                 transaction_merge_and_delete_job(tr, k, j, t);
 269                                 j = k;
 270                         } else
 271                                 transaction_merge_and_delete_job(tr, j, k, t);
 272                 }
 273
 274                 assert(!j->transaction_next);
 275                 assert(!j->transaction_prev);
 276         }
 277
 278         return 0;
 279 }
 280
 281 static void transaction_drop_redundant(Transaction *tr) {
 282         Job *j;
 283         Iterator i;
 284
 285         /* Goes through the transaction and removes all jobs of the units
 286          * whose jobs are all noops. If not all of a unit's jobs are
 287          * redundant, they are kept. */
 288
 289         assert(tr);
 290
 291 rescan:
 292         HASHMAP_FOREACH(j, tr->jobs, i) {
 293                 Job *k;
 294
 295                 LIST_FOREACH(transaction, k, j) {
 296
 297                         if (tr->anchor_job == k ||
 298                             !job_type_is_redundant(k->type, unit_active_state(k->unit)) ||
 299                             (k->unit->job && job_type_is_conflicting(k->type, k->unit->job->type)))
 300                                 goto next_unit;
 301                 }
 302
 303                 /* log_debug("Found redundant job %s/%s, dropping.", j->unit->id, job_type_to_string(j->type)); */
 304                 transaction_delete_job(tr, j, false);
 305                 goto rescan;
 306         next_unit:;
 307         }
 308 }
 309
 310 static bool unit_matters_to_anchor(Unit *u, Job *j) {
 311         assert(u);
 312         assert(!j->transaction_prev);
 313
 314         /* Checks whether at least one of the jobs for this unit
 315          * matters to the anchor. */
 316
 317         LIST_FOREACH(transaction, j, j)
 318                 if (j->matters_to_anchor)
 319                         return true;
 320
 321         return false;
 322 }
 323
 324 static int transaction_verify_order_one(Transaction *tr, Job *j, Job *from, unsigned generation, DBusError *e) {
 325         Iterator i;
 326         Unit *u;
 327         int r;
 328
 329         assert(tr);
 330         assert(j);
 331         assert(!j->transaction_prev);
 332
 333         /* Does a recursive sweep through the ordering graph, looking
 334          * for a cycle. If we find cycle we try to break it. */
 335
 336         /* Have we seen this before? */
 337         if (j->generation == generation) {
 338                 Job *k, *delete;
 339
 340                 /* If the marker is NULL we have been here already and
 341                  * decided the job was loop-free from here. Hence
 342                  * shortcut things and return right-away. */
 343                 if (!j->marker)
 344                         return 0;
 345
 346                 /* So, the marker is not NULL and we already have been
 347                  * here. We have a cycle. Let's try to break it. We go
 348                  * backwards in our path and try to find a suitable
 349                  * job to remove. We use the marker to find our way
 350                  * back, since smart how we are we stored our way back
 351                  * in there. */
 352                 log_warning("Found ordering cycle on %s/%s", j->unit->id, job_type_to_string(j->type));
 353
 354                 delete = NULL;
 355                 for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) {
 356
 357                         log_info("Walked on cycle path to %s/%s", k->unit->id, job_type_to_string(k->type));
 358
 359                         if (!delete &&
 360                             !unit_matters_to_anchor(k->unit, k)) {
 361                                 /* Ok, we can drop this one, so let's
 362                                  * do so. */
 363                                 delete = k;
 364                         }
 365
 366                         /* Check if this in fact was the beginning of
 367                          * the cycle */
 368                         if (k == j)
 369                                 break;
 370                 }
 371
 372
 373                 if (delete) {
 374                         log_warning("Breaking ordering cycle by deleting job %s/%s", delete->unit->id, job_type_to_string(delete->type));
 375                         transaction_delete_unit(tr, delete->unit);
 376                         return -EAGAIN;
 377                 }
 378
 379                 log_error("Unable to break cycle");
 380
 381                 dbus_set_error(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, "Transaction order is cyclic. See system logs for details.");
 382                 return -ENOEXEC;
 383         }
 384
 385         /* Make the marker point to where we come from, so that we can
 386          * find our way backwards if we want to break a cycle. We use
 387          * a special marker for the beginning: we point to
 388          * ourselves. */
 389         j->marker = from ? from : j;
 390         j->generation = generation;
 391
 392         /* We assume that the the dependencies are bidirectional, and
 393          * hence can ignore UNIT_AFTER */
 394         SET_FOREACH(u, j->unit->dependencies[UNIT_BEFORE], i) {
 395                 Job *o;
 396
 397                 /* Is there a job for this unit? */
 398                 o = hashmap_get(tr->jobs, u);
 399                 if (!o) {
 400                         /* Ok, there is no job for this in the
 401                          * transaction, but maybe there is already one
 402                          * running? */
 403                         o = u->job;
 404                         if (!o)
 405                                 continue;
 406                 }
 407
 408                 r = transaction_verify_order_one(tr, o, j, generation, e);
 409                 if (r < 0)
 410                         return r;
 411         }
 412
 413         /* Ok, let's backtrack, and remember that this entry is not on
 414          * our path anymore. */
 415         j->marker = NULL;
 416
 417         return 0;
 418 }
 419
 420 static int transaction_verify_order(Transaction *tr, unsigned *generation, DBusError *e) {
 421         Job *j;
 422         int r;
 423         Iterator i;
 424         unsigned g;
 425
 426         assert(tr);
 427         assert(generation);
 428
 429         /* Check if the ordering graph is cyclic. If it is, try to fix
 430          * that up by dropping one of the jobs. */
 431
 432         g = (*generation)++;
 433
 434         HASHMAP_FOREACH(j, tr->jobs, i)
 435                 if ((r = transaction_verify_order_one(tr, j, NULL, g, e)) < 0)
 436                         return r;
 437
 438         return 0;
 439 }
 440
 441 static void transaction_collect_garbage(Transaction *tr) {
 442         Iterator i;
 443         Job *j;
 444
 445         assert(tr);
 446
 447         /* Drop jobs that are not required by any other job */
 448
 449 rescan:
 450         HASHMAP_FOREACH(j, tr->jobs, i) {
 451                 if (tr->anchor_job == j || j->object_list) {
 452                         /* log_debug("Keeping job %s/%s because of %s/%s", */
 453                         /*           j->unit->id, job_type_to_string(j->type), */
 454                         /*           j->object_list->subject ? j->object_list->subject->unit->id : "root", */
 455                         /*           j->object_list->subject ? job_type_to_string(j->object_list->subject->type) : "root"); */
 456                         continue;
 457                 }
 458
 459                 /* log_debug("Garbage collecting job %s/%s", j->unit->id, job_type_to_string(j->type)); */
 460                 transaction_delete_job(tr, j, true);
 461                 goto rescan;
 462         }
 463 }
 464
 465 static int transaction_is_destructive(Transaction *tr, DBusError *e) {
 466         Iterator i;
 467         Job *j;
 468
 469         assert(tr);
 470
 471         /* Checks whether applying this transaction means that
 472          * existing jobs would be replaced */
 473
 474         HASHMAP_FOREACH(j, tr->jobs, i) {
 475
 476                 /* Assume merged */
 477                 assert(!j->transaction_prev);
 478                 assert(!j->transaction_next);
 479
 480                 if (j->unit->job &&
 481                     !job_type_is_superset(j->type, j->unit->job->type)) {
 482
 483                         dbus_set_error(e, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE, "Transaction is destructive.");
 484                         return -EEXIST;
 485                 }
 486         }
 487
 488         return 0;
 489 }
 490
 491 static void transaction_minimize_impact(Transaction *tr) {
 492         Job *j;
 493         Iterator i;
 494
 495         assert(tr);
 496
 497         /* Drops all unnecessary jobs that reverse already active jobs
 498          * or that stop a running service. */
 499
 500 rescan:
 501         HASHMAP_FOREACH(j, tr->jobs, i) {
 502                 LIST_FOREACH(transaction, j, j) {
 503                         bool stops_running_service, changes_existing_job;
 504
 505                         /* If it matters, we shouldn't drop it */
 506                         if (j->matters_to_anchor)
 507                                 continue;
 508
 509                         /* Would this stop a running service?
 510                          * Would this change an existing job?
 511                          * If so, let's drop this entry */
 512
 513                         stops_running_service =
 514                                 j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit));
 515
 516                         changes_existing_job =
 517                                 j->unit->job &&
 518                                 job_type_is_conflicting(j->type, j->unit->job->type);
 519
 520                         if (!stops_running_service && !changes_existing_job)
 521                                 continue;
 522
 523                         if (stops_running_service)
 524                                 log_debug("%s/%s would stop a running service.", j->unit->id, job_type_to_string(j->type));
 525
 526                         if (changes_existing_job)
 527                                 log_debug("%s/%s would change existing job.", j->unit->id, job_type_to_string(j->type));
 528
 529                         /* Ok, let's get rid of this */
 530                         log_debug("Deleting %s/%s to minimize impact.", j->unit->id, job_type_to_string(j->type));
 531
 532                         transaction_delete_job(tr, j, true);
 533                         goto rescan;
 534                 }
 535         }
 536 }
 537
 538 static int transaction_apply(Transaction *tr, Manager *m, JobMode mode) {
 539         Iterator i;
 540         Job *j;
 541         int r;
 542
 543         /* Moves the transaction jobs to the set of active jobs */
 544
 545         if (mode == JOB_ISOLATE) {
 546
 547                 /* When isolating first kill all installed jobs which
 548                  * aren't part of the new transaction */
 549         rescan:
 550                 HASHMAP_FOREACH(j, m->jobs, i) {
 551                         assert(j->installed);
 552
 553                         if (hashmap_get(tr->jobs, j->unit))
 554                                 continue;
 555
 556                         /* 'j' itself is safe to remove, but if other jobs
 557                            are invalidated recursively, our iterator may become
 558                            invalid and we need to start over. */
 559                         if (job_finish_and_invalidate(j, JOB_CANCELED) > 0)
 560                                 goto rescan;
 561                 }
 562         }
 563
 564         HASHMAP_FOREACH(j, tr->jobs, i) {
 565                 /* Assume merged */
 566                 assert(!j->transaction_prev);
 567                 assert(!j->transaction_next);
 568
 569                 r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j);
 570                 if (r < 0)
 571                         goto rollback;
 572         }
 573
 574         while ((j = hashmap_steal_first(tr->jobs))) {
 575                 Job *installed_job;
 576
 577                 /* Clean the job dependencies */
 578                 transaction_unlink_job(tr, j, false);
 579
 580                 installed_job = job_install(j);
 581                 if (installed_job != j) {
 582                         /* j has been merged into a previously installed job */
 583                         if (tr->anchor_job == j)
 584                                 tr->anchor_job = installed_job;
 585                         hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
 586                         job_free(j);
 587                         j = installed_job;
 588                 }
 589
 590                 job_add_to_run_queue(j);
 591                 job_add_to_dbus_queue(j);
 592                 job_start_timer(j);
 593         }
 594
 595         return 0;
 596
 597 rollback:
 598
 599         HASHMAP_FOREACH(j, tr->jobs, i)
 600                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
 601
 602         return r;
 603 }
 604
 605 int transaction_activate(Transaction *tr, Manager *m, JobMode mode, DBusError *e) {
 606         int r;
 607         unsigned generation = 1;
 608
 609         assert(tr);
 610
 611         /* This applies the changes recorded in tr->jobs to
 612          * the actual list of jobs, if possible. */
 613
 614         /* First step: figure out which jobs matter */
 615         transaction_find_jobs_that_matter_to_anchor(tr->anchor_job, generation++);
 616
 617         /* Second step: Try not to stop any running services if
 618          * we don't have to. Don't try to reverse running
 619          * jobs if we don't have to. */
 620         if (mode == JOB_FAIL)
 621                 transaction_minimize_impact(tr);
 622
 623         /* Third step: Drop redundant jobs */
 624         transaction_drop_redundant(tr);
 625
 626         for (;;) {
 627                 /* Fourth step: Let's remove unneeded jobs that might
 628                  * be lurking. */
 629                 if (mode != JOB_ISOLATE)
 630                         transaction_collect_garbage(tr);
 631
 632                 /* Fifth step: verify order makes sense and correct
 633                  * cycles if necessary and possible */
 634                 r = transaction_verify_order(tr, &generation, e);
 635                 if (r >= 0)
 636                         break;
 637
 638                 if (r != -EAGAIN) {
 639                         log_warning("Requested transaction contains an unfixable cyclic ordering dependency: %s", bus_error(e, r));
 640                         return r;
 641                 }
 642
 643                 /* Let's see if the resulting transaction ordering
 644                  * graph is still cyclic... */
 645         }
 646
 647         for (;;) {
 648                 /* Sixth step: let's drop unmergeable entries if
 649                  * necessary and possible, merge entries we can
 650                  * merge */
 651                 r = transaction_merge_jobs(tr, e);
 652                 if (r >= 0)
 653                         break;
 654
 655                 if (r != -EAGAIN) {
 656                         log_warning("Requested transaction contains unmergeable jobs: %s", bus_error(e, r));
 657                         return r;
 658                 }
 659
 660                 /* Seventh step: an entry got dropped, let's garbage
 661                  * collect its dependencies. */
 662                 if (mode != JOB_ISOLATE)
 663                         transaction_collect_garbage(tr);
 664
 665                 /* Let's see if the resulting transaction still has
 666                  * unmergeable entries ... */
 667         }
 668
 669         /* Eights step: Drop redundant jobs again, if the merging now allows us to drop more. */
 670         transaction_drop_redundant(tr);
 671
 672         /* Ninth step: check whether we can actually apply this */
 673         if (mode == JOB_FAIL) {
 674                 r = transaction_is_destructive(tr, e);
 675                 if (r < 0) {
 676                         log_notice("Requested transaction contradicts existing jobs: %s", bus_error(e, r));
 677                         return r;
 678                 }
 679         }
 680
 681         /* Tenth step: apply changes */
 682         r = transaction_apply(tr, m, mode);
 683         if (r < 0) {
 684                 log_warning("Failed to apply transaction: %s", strerror(-r));
 685                 return r;
 686         }
 687
 688         assert(hashmap_isempty(tr->jobs));
 689
 690         return 0;
 691 }
 692
 693 static Job* transaction_add_one_job(Transaction *tr, JobType type, Unit *unit, bool override, bool *is_new) {
 694         Job *j, *f;
 695
 696         assert(tr);
 697         assert(unit);
 698
 699         /* Looks for an existing prospective job and returns that. If
 700          * it doesn't exist it is created and added to the prospective
 701          * jobs list. */
 702
 703         f = hashmap_get(tr->jobs, unit);
 704
 705         LIST_FOREACH(transaction, j, f) {
 706                 assert(j->unit == unit);
 707
 708                 if (j->type == type) {
 709                         if (is_new)
 710                                 *is_new = false;
 711                         return j;
 712                 }
 713         }
 714
 715         j = job_new(unit, type);
 716         if (!j)
 717                 return NULL;
 718
 719         j->generation = 0;
 720         j->marker = NULL;
 721         j->matters_to_anchor = false;
 722         j->override = override;
 723
 724         LIST_PREPEND(Job, transaction, f, j);
 725
 726         if (hashmap_replace(tr->jobs, unit, f) < 0) {
 727                 LIST_REMOVE(Job, transaction, f, j);
 728                 job_free(j);
 729                 return NULL;
 730         }
 731
 732         if (is_new)
 733                 *is_new = true;
 734
 735         /* log_debug("Added job %s/%s to transaction.", unit->id, job_type_to_string(type)); */
 736
 737         return j;
 738 }
 739
 740 static void transaction_unlink_job(Transaction *tr, Job *j, bool delete_dependencies) {
 741         assert(tr);
 742         assert(j);
 743
 744         if (j->transaction_prev)
 745                 j->transaction_prev->transaction_next = j->transaction_next;
 746         else if (j->transaction_next)
 747                 hashmap_replace(tr->jobs, j->unit, j->transaction_next);
 748         else
 749                 hashmap_remove_value(tr->jobs, j->unit, j);
 750
 751         if (j->transaction_next)
 752                 j->transaction_next->transaction_prev = j->transaction_prev;
 753
 754         j->transaction_prev = j->transaction_next = NULL;
 755
 756         while (j->subject_list)
 757                 job_dependency_free(j->subject_list);
 758
 759         while (j->object_list) {
 760                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
 761
 762                 job_dependency_free(j->object_list);
 763
 764                 if (other && delete_dependencies) {
 765                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
 766                                   other->unit->id, job_type_to_string(other->type),
 767                                   j->unit->id, job_type_to_string(j->type));
 768                         transaction_delete_job(tr, other, delete_dependencies);
 769                 }
 770         }
 771 }
 772
 773 int transaction_add_job_and_dependencies(
 774                 Transaction *tr,
 775                 JobType type,
 776                 Unit *unit,
 777                 Job *by,
 778                 bool matters,
 779                 bool override,
 780                 bool conflicts,
 781                 bool ignore_requirements,
 782                 bool ignore_order,
 783                 DBusError *e) {
 784         Job *ret;
 785         Iterator i;
 786         Unit *dep;
 787         int r;
 788         bool is_new;
 789
 790         assert(tr);
 791         assert(type < _JOB_TYPE_MAX);
 792         assert(unit);
 793
 794         /* log_debug("Pulling in %s/%s from %s/%s", */
 795         /*           unit->id, job_type_to_string(type), */
 796         /*           by ? by->unit->id : "NA", */
 797         /*           by ? job_type_to_string(by->type) : "NA"); */
 798
 799         if (unit->load_state != UNIT_LOADED &&
 800             unit->load_state != UNIT_ERROR &&
 801             unit->load_state != UNIT_MASKED) {
 802                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->id);
 803                 return -EINVAL;
 804         }
 805
 806         if (type != JOB_STOP && unit->load_state == UNIT_ERROR) {
 807                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED,
 808                                "Unit %s failed to load: %s. "
 809                                "See system logs and 'systemctl status %s' for details.",
 810                                unit->id,
 811                                strerror(-unit->load_error),
 812                                unit->id);
 813                 return -EINVAL;
 814         }
 815
 816         if (type != JOB_STOP && unit->load_state == UNIT_MASKED) {
 817                 dbus_set_error(e, BUS_ERROR_MASKED, "Unit %s is masked.", unit->id);
 818                 return -EADDRNOTAVAIL;
 819         }
 820
 821         if (!unit_job_is_applicable(unit, type)) {
 822                 dbus_set_error(e, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE, "Job type %s is not applicable for unit %s.", job_type_to_string(type), unit->id);
 823                 return -EBADR;
 824         }
 825
 826         /* First add the job. */
 827         ret = transaction_add_one_job(tr, type, unit, override, &is_new);
 828         if (!ret)
 829                 return -ENOMEM;
 830
 831         ret->ignore_order = ret->ignore_order || ignore_order;
 832
 833         /* Then, add a link to the job. */
 834         if (by) {
 835                 if (!job_dependency_new(by, ret, matters, conflicts))
 836                         return -ENOMEM;
 837         } else {
 838                 /* If the job has no parent job, it is the anchor job. */
 839                 assert(!tr->anchor_job);
 840                 tr->anchor_job = ret;
 841         }
 842         if (is_new && !ignore_requirements) {
 843                 Set *following;
 844
 845                 /* If we are following some other unit, make sure we
 846                  * add all dependencies of everybody following. */
 847                 if (unit_following_set(ret->unit, &following) > 0) {
 848                         SET_FOREACH(dep, following, i) {
 849                                 r = transaction_add_job_and_dependencies(tr, type, dep, ret, false, override, false, false, ignore_order, e);
 850                                 if (r < 0) {
 851                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 852
 853                                         if (e)
 854                                                 dbus_error_free(e);
 855                                 }
 856                         }
 857
 858                         set_free(following);
 859                 }
 860
 861                 /* Finally, recursively add in all dependencies. */
 862                 if (type == JOB_START || type == JOB_RELOAD_OR_START || type == JOB_RESTART) {
 863                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES], i) {
 864                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, true, override, false, false, ignore_order, e);
 865                                 if (r < 0) {
 866                                         if (r != -EBADR)
 867                                                 goto fail;
 868
 869                                         if (e)
 870                                                 dbus_error_free(e);
 871                                 }
 872                         }
 873
 874                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BIND_TO], i) {
 875                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, true, override, false, false, ignore_order, e);
 876                                 if (r < 0) {
 877                                         if (r != -EBADR)
 878                                                 goto fail;
 879
 880                                         if (e)
 881                                                 dbus_error_free(e);
 882                                 }
 883                         }
 884
 885                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES_OVERRIDABLE], i) {
 886                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, !override, override, false, false, ignore_order, e);
 887                                 if (r < 0) {
 888                                         log_full(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_WARNING,
 889                                                  "Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 890
 891                                         if (e)
 892                                                 dbus_error_free(e);
 893                                 }
 894                         }
 895
 896                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_WANTS], i) {
 897                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, false, false, false, false, ignore_order, e);
 898                                 if (r < 0) {
 899                                         log_full(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_WARNING,
 900                                                  "Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 901
 902                                         if (e)
 903                                                 dbus_error_free(e);
 904                                 }
 905                         }
 906
 907                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE], i) {
 908                                 r = transaction_add_job_and_dependencies(tr, JOB_VERIFY_ACTIVE, dep, ret, true, override, false, false, ignore_order, e);
 909                                 if (r < 0) {
 910                                         if (r != -EBADR)
 911                                                 goto fail;
 912
 913                                         if (e)
 914                                                 dbus_error_free(e);
 915                                 }
 916                         }
 917
 918                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE_OVERRIDABLE], i) {
 919                                 r = transaction_add_job_and_dependencies(tr, JOB_VERIFY_ACTIVE, dep, ret, !override, override, false, false, ignore_order, e);
 920                                 if (r < 0) {
 921                                         log_full(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_WARNING,
 922                                                  "Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 923
 924                                         if (e)
 925                                                 dbus_error_free(e);
 926                                 }
 927                         }
 928
 929                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTS], i) {
 930                                 r = transaction_add_job_and_dependencies(tr, JOB_STOP, dep, ret, true, override, true, false, ignore_order, e);
 931                                 if (r < 0) {
 932                                         if (r != -EBADR)
 933                                                 goto fail;
 934
 935                                         if (e)
 936                                                 dbus_error_free(e);
 937                                 }
 938                         }
 939
 940                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTED_BY], i) {
 941                                 r = transaction_add_job_and_dependencies(tr, JOB_STOP, dep, ret, false, override, false, false, ignore_order, e);
 942                                 if (r < 0) {
 943                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 944
 945                                         if (e)
 946                                                 dbus_error_free(e);
 947                                 }
 948                         }
 949
 950                 }
 951
 952                 if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
 953
 954                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRED_BY], i) {
 955                                 r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
 956                                 if (r < 0) {
 957                                         if (r != -EBADR)
 958                                                 goto fail;
 959
 960                                         if (e)
 961                                                 dbus_error_free(e);
 962                                 }
 963                         }
 964
 965                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BOUND_BY], i) {
 966                                 r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
 967                                 if (r < 0) {
 968                                         if (r != -EBADR)
 969                                                 goto fail;
 970
 971                                         if (e)
 972                                                 dbus_error_free(e);
 973                                 }
 974                         }
 975                 }
 976
 977                 if (type == JOB_RELOAD || type == JOB_RELOAD_OR_START) {
 978
 979                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_PROPAGATE_RELOAD_TO], i) {
 980                                 r = transaction_add_job_and_dependencies(tr, JOB_RELOAD, dep, ret, false, override, false, false, ignore_order, e);
 981                                 if (r < 0) {
 982                                         log_warning("Cannot add dependency reload job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 983
 984                                         if (e)
 985                                                 dbus_error_free(e);
 986                                 }
 987                         }
 988                 }
 989
 990                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
 991         }
 992
 993         return 0;
 994
 995 fail:
 996         return r;
 997 }
 998
 999 int transaction_add_isolate_jobs(Transaction *tr, Manager *m) {
1000         Iterator i;
1001         Unit *u;
1002         char *k;
1003         int r;
1004
1005         assert(tr);
1006         assert(m);
1007
1008         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1009
1010                 /* ignore aliases */
1011                 if (u->id != k)
1012                         continue;
1013
1014                 if (u->ignore_on_isolate)
1015                         continue;
1016
1017                 /* No need to stop inactive jobs */
1018                 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)) && !u->job)
1019                         continue;
1020
1021                 /* Is there already something listed for this? */
1022                 if (hashmap_get(tr->jobs, u))
1023                         continue;
1024
1025                 r = transaction_add_job_and_dependencies(tr, JOB_STOP, u, tr->anchor_job, true, false, false, false, false, NULL);
1026                 if (r < 0)
1027                         log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->id, strerror(-r));
1028         }
1029
1030         return 0;
1031 }
1032
1033 Transaction *transaction_new(void) {
1034         Transaction *tr;
1035
1036         tr = new0(Transaction, 1);
1037         if (!tr)
1038                 return NULL;
1039
1040         tr->jobs = hashmap_new(trivial_hash_func, trivial_compare_func);
1041         if (!tr->jobs) {
1042                 free(tr);
1043                 return NULL;
1044         }
1045
1046         return tr;
1047 }
1048
1049 void transaction_free(Transaction *tr) {
1050         assert(hashmap_isempty(tr->jobs));
1051         hashmap_free(tr->jobs);
1052         free(tr);
1053 }