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, false);
  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                 HASHMAP_FOREACH(j, m->jobs, i) {
 550                         assert(j->installed);
 551
 552                         if (hashmap_get(tr->jobs, j->unit))
 553                                 continue;
 554
 555                         /* Not invalidating recursively. Avoids triggering
 556                          * OnFailure= actions of dependent jobs. Also avoids
 557                          * invalidating our iterator. */
 558                         job_finish_and_invalidate(j, JOB_CANCELED, false);
 559                 }
 560         }
 561
 562         HASHMAP_FOREACH(j, tr->jobs, i) {
 563                 /* Assume merged */
 564                 assert(!j->transaction_prev);
 565                 assert(!j->transaction_next);
 566
 567                 r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j);
 568                 if (r < 0)
 569                         goto rollback;
 570         }
 571
 572         while ((j = hashmap_steal_first(tr->jobs))) {
 573                 Job *installed_job;
 574
 575                 /* Clean the job dependencies */
 576                 transaction_unlink_job(tr, j, false);
 577
 578                 installed_job = job_install(j);
 579                 if (installed_job != j) {
 580                         /* j has been merged into a previously installed job */
 581                         if (tr->anchor_job == j)
 582                                 tr->anchor_job = installed_job;
 583                         hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
 584                         job_free(j);
 585                         j = installed_job;
 586                 }
 587
 588                 job_add_to_run_queue(j);
 589                 job_add_to_dbus_queue(j);
 590                 job_start_timer(j);
 591         }
 592
 593         return 0;
 594
 595 rollback:
 596
 597         HASHMAP_FOREACH(j, tr->jobs, i)
 598                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
 599
 600         return r;
 601 }
 602
 603 int transaction_activate(Transaction *tr, Manager *m, JobMode mode, DBusError *e) {
 604         Iterator i;
 605         Job *j;
 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         /* Reset the generation counter of all installed jobs. The detection of cycles
 615          * looks at installed jobs. If they had a non-zero generation from some previous
 616          * walk of the graph, the algorithm would break. */
 617         HASHMAP_FOREACH(j, m->jobs, i)
 618                 j->generation = 0;
 619
 620         /* First step: figure out which jobs matter */
 621         transaction_find_jobs_that_matter_to_anchor(tr->anchor_job, generation++);
 622
 623         /* Second step: Try not to stop any running services if
 624          * we don't have to. Don't try to reverse running
 625          * jobs if we don't have to. */
 626         if (mode == JOB_FAIL)
 627                 transaction_minimize_impact(tr);
 628
 629         /* Third step: Drop redundant jobs */
 630         transaction_drop_redundant(tr);
 631
 632         for (;;) {
 633                 /* Fourth step: Let's remove unneeded jobs that might
 634                  * be lurking. */
 635                 if (mode != JOB_ISOLATE)
 636                         transaction_collect_garbage(tr);
 637
 638                 /* Fifth step: verify order makes sense and correct
 639                  * cycles if necessary and possible */
 640                 r = transaction_verify_order(tr, &generation, e);
 641                 if (r >= 0)
 642                         break;
 643
 644                 if (r != -EAGAIN) {
 645                         log_warning("Requested transaction contains an unfixable cyclic ordering dependency: %s", bus_error(e, r));
 646                         return r;
 647                 }
 648
 649                 /* Let's see if the resulting transaction ordering
 650                  * graph is still cyclic... */
 651         }
 652
 653         for (;;) {
 654                 /* Sixth step: let's drop unmergeable entries if
 655                  * necessary and possible, merge entries we can
 656                  * merge */
 657                 r = transaction_merge_jobs(tr, e);
 658                 if (r >= 0)
 659                         break;
 660
 661                 if (r != -EAGAIN) {
 662                         log_warning("Requested transaction contains unmergeable jobs: %s", bus_error(e, r));
 663                         return r;
 664                 }
 665
 666                 /* Seventh step: an entry got dropped, let's garbage
 667                  * collect its dependencies. */
 668                 if (mode != JOB_ISOLATE)
 669                         transaction_collect_garbage(tr);
 670
 671                 /* Let's see if the resulting transaction still has
 672                  * unmergeable entries ... */
 673         }
 674
 675         /* Eights step: Drop redundant jobs again, if the merging now allows us to drop more. */
 676         transaction_drop_redundant(tr);
 677
 678         /* Ninth step: check whether we can actually apply this */
 679         if (mode == JOB_FAIL) {
 680                 r = transaction_is_destructive(tr, e);
 681                 if (r < 0) {
 682                         log_notice("Requested transaction contradicts existing jobs: %s", bus_error(e, r));
 683                         return r;
 684                 }
 685         }
 686
 687         /* Tenth step: apply changes */
 688         r = transaction_apply(tr, m, mode);
 689         if (r < 0) {
 690                 log_warning("Failed to apply transaction: %s", strerror(-r));
 691                 return r;
 692         }
 693
 694         assert(hashmap_isempty(tr->jobs));
 695
 696         return 0;
 697 }
 698
 699 static Job* transaction_add_one_job(Transaction *tr, JobType type, Unit *unit, bool override, bool *is_new) {
 700         Job *j, *f;
 701
 702         assert(tr);
 703         assert(unit);
 704
 705         /* Looks for an existing prospective job and returns that. If
 706          * it doesn't exist it is created and added to the prospective
 707          * jobs list. */
 708
 709         f = hashmap_get(tr->jobs, unit);
 710
 711         LIST_FOREACH(transaction, j, f) {
 712                 assert(j->unit == unit);
 713
 714                 if (j->type == type) {
 715                         if (is_new)
 716                                 *is_new = false;
 717                         return j;
 718                 }
 719         }
 720
 721         j = job_new(unit, type);
 722         if (!j)
 723                 return NULL;
 724
 725         j->generation = 0;
 726         j->marker = NULL;
 727         j->matters_to_anchor = false;
 728         j->override = override;
 729
 730         LIST_PREPEND(Job, transaction, f, j);
 731
 732         if (hashmap_replace(tr->jobs, unit, f) < 0) {
 733                 LIST_REMOVE(Job, transaction, f, j);
 734                 job_free(j);
 735                 return NULL;
 736         }
 737
 738         if (is_new)
 739                 *is_new = true;
 740
 741         /* log_debug("Added job %s/%s to transaction.", unit->id, job_type_to_string(type)); */
 742
 743         return j;
 744 }
 745
 746 static void transaction_unlink_job(Transaction *tr, Job *j, bool delete_dependencies) {
 747         assert(tr);
 748         assert(j);
 749
 750         if (j->transaction_prev)
 751                 j->transaction_prev->transaction_next = j->transaction_next;
 752         else if (j->transaction_next)
 753                 hashmap_replace(tr->jobs, j->unit, j->transaction_next);
 754         else
 755                 hashmap_remove_value(tr->jobs, j->unit, j);
 756
 757         if (j->transaction_next)
 758                 j->transaction_next->transaction_prev = j->transaction_prev;
 759
 760         j->transaction_prev = j->transaction_next = NULL;
 761
 762         while (j->subject_list)
 763                 job_dependency_free(j->subject_list);
 764
 765         while (j->object_list) {
 766                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
 767
 768                 job_dependency_free(j->object_list);
 769
 770                 if (other && delete_dependencies) {
 771                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
 772                                   other->unit->id, job_type_to_string(other->type),
 773                                   j->unit->id, job_type_to_string(j->type));
 774                         transaction_delete_job(tr, other, delete_dependencies);
 775                 }
 776         }
 777 }
 778
 779 int transaction_add_job_and_dependencies(
 780                 Transaction *tr,
 781                 JobType type,
 782                 Unit *unit,
 783                 Job *by,
 784                 bool matters,
 785                 bool override,
 786                 bool conflicts,
 787                 bool ignore_requirements,
 788                 bool ignore_order,
 789                 DBusError *e) {
 790         Job *ret;
 791         Iterator i;
 792         Unit *dep;
 793         int r;
 794         bool is_new;
 795
 796         assert(tr);
 797         assert(type < _JOB_TYPE_MAX);
 798         assert(unit);
 799
 800         /* log_debug("Pulling in %s/%s from %s/%s", */
 801         /*           unit->id, job_type_to_string(type), */
 802         /*           by ? by->unit->id : "NA", */
 803         /*           by ? job_type_to_string(by->type) : "NA"); */
 804
 805         if (unit->load_state != UNIT_LOADED &&
 806             unit->load_state != UNIT_ERROR &&
 807             unit->load_state != UNIT_MASKED) {
 808                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->id);
 809                 return -EINVAL;
 810         }
 811
 812         if (type != JOB_STOP && unit->load_state == UNIT_ERROR) {
 813                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED,
 814                                "Unit %s failed to load: %s. "
 815                                "See system logs and 'systemctl status %s' for details.",
 816                                unit->id,
 817                                strerror(-unit->load_error),
 818                                unit->id);
 819                 return -EINVAL;
 820         }
 821
 822         if (type != JOB_STOP && unit->load_state == UNIT_MASKED) {
 823                 dbus_set_error(e, BUS_ERROR_MASKED, "Unit %s is masked.", unit->id);
 824                 return -EADDRNOTAVAIL;
 825         }
 826
 827         if (!unit_job_is_applicable(unit, type)) {
 828                 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);
 829                 return -EBADR;
 830         }
 831
 832         /* First add the job. */
 833         ret = transaction_add_one_job(tr, type, unit, override, &is_new);
 834         if (!ret)
 835                 return -ENOMEM;
 836
 837         ret->ignore_order = ret->ignore_order || ignore_order;
 838
 839         /* Then, add a link to the job. */
 840         if (by) {
 841                 if (!job_dependency_new(by, ret, matters, conflicts))
 842                         return -ENOMEM;
 843         } else {
 844                 /* If the job has no parent job, it is the anchor job. */
 845                 assert(!tr->anchor_job);
 846                 tr->anchor_job = ret;
 847         }
 848         if (is_new && !ignore_requirements) {
 849                 Set *following;
 850
 851                 /* If we are following some other unit, make sure we
 852                  * add all dependencies of everybody following. */
 853                 if (unit_following_set(ret->unit, &following) > 0) {
 854                         SET_FOREACH(dep, following, i) {
 855                                 r = transaction_add_job_and_dependencies(tr, type, dep, ret, false, override, false, false, ignore_order, e);
 856                                 if (r < 0) {
 857                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 858
 859                                         if (e)
 860                                                 dbus_error_free(e);
 861                                 }
 862                         }
 863
 864                         set_free(following);
 865                 }
 866
 867                 /* Finally, recursively add in all dependencies. */
 868                 if (type == JOB_START || type == JOB_RELOAD_OR_START || type == JOB_RESTART) {
 869                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES], i) {
 870                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, true, override, false, false, ignore_order, e);
 871                                 if (r < 0) {
 872                                         if (r != -EBADR)
 873                                                 goto fail;
 874
 875                                         if (e)
 876                                                 dbus_error_free(e);
 877                                 }
 878                         }
 879
 880                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BIND_TO], i) {
 881                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, true, override, false, false, ignore_order, e);
 882                                 if (r < 0) {
 883                                         if (r != -EBADR)
 884                                                 goto fail;
 885
 886                                         if (e)
 887                                                 dbus_error_free(e);
 888                                 }
 889                         }
 890
 891                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES_OVERRIDABLE], i) {
 892                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, !override, override, false, false, ignore_order, e);
 893                                 if (r < 0) {
 894                                         log_full(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_WARNING,
 895                                                  "Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 896
 897                                         if (e)
 898                                                 dbus_error_free(e);
 899                                 }
 900                         }
 901
 902                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_WANTS], i) {
 903                                 r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, false, false, false, false, ignore_order, e);
 904                                 if (r < 0) {
 905                                         log_full(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_WARNING,
 906                                                  "Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 907
 908                                         if (e)
 909                                                 dbus_error_free(e);
 910                                 }
 911                         }
 912
 913                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE], i) {
 914                                 r = transaction_add_job_and_dependencies(tr, JOB_VERIFY_ACTIVE, dep, ret, true, override, false, false, ignore_order, e);
 915                                 if (r < 0) {
 916                                         if (r != -EBADR)
 917                                                 goto fail;
 918
 919                                         if (e)
 920                                                 dbus_error_free(e);
 921                                 }
 922                         }
 923
 924                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE_OVERRIDABLE], i) {
 925                                 r = transaction_add_job_and_dependencies(tr, JOB_VERIFY_ACTIVE, dep, ret, !override, override, false, false, ignore_order, e);
 926                                 if (r < 0) {
 927                                         log_full(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_WARNING,
 928                                                  "Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 929
 930                                         if (e)
 931                                                 dbus_error_free(e);
 932                                 }
 933                         }
 934
 935                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTS], i) {
 936                                 r = transaction_add_job_and_dependencies(tr, JOB_STOP, dep, ret, true, override, true, false, ignore_order, e);
 937                                 if (r < 0) {
 938                                         if (r != -EBADR)
 939                                                 goto fail;
 940
 941                                         if (e)
 942                                                 dbus_error_free(e);
 943                                 }
 944                         }
 945
 946                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTED_BY], i) {
 947                                 r = transaction_add_job_and_dependencies(tr, JOB_STOP, dep, ret, false, override, false, false, ignore_order, e);
 948                                 if (r < 0) {
 949                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 950
 951                                         if (e)
 952                                                 dbus_error_free(e);
 953                                 }
 954                         }
 955
 956                 }
 957
 958                 if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
 959
 960                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRED_BY], i) {
 961                                 r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
 962                                 if (r < 0) {
 963                                         if (r != -EBADR)
 964                                                 goto fail;
 965
 966                                         if (e)
 967                                                 dbus_error_free(e);
 968                                 }
 969                         }
 970
 971                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BOUND_BY], i) {
 972                                 r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
 973                                 if (r < 0) {
 974                                         if (r != -EBADR)
 975                                                 goto fail;
 976
 977                                         if (e)
 978                                                 dbus_error_free(e);
 979                                 }
 980                         }
 981                 }
 982
 983                 if (type == JOB_RELOAD || type == JOB_RELOAD_OR_START) {
 984
 985                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_PROPAGATE_RELOAD_TO], i) {
 986                                 r = transaction_add_job_and_dependencies(tr, JOB_RELOAD, dep, ret, false, override, false, false, ignore_order, e);
 987                                 if (r < 0) {
 988                                         log_warning("Cannot add dependency reload job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
 989
 990                                         if (e)
 991                                                 dbus_error_free(e);
 992                                 }
 993                         }
 994                 }
 995
 996                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
 997         }
 998
 999         return 0;
1000
1001 fail:
1002         return r;
1003 }
1004
1005 int transaction_add_isolate_jobs(Transaction *tr, Manager *m) {
1006         Iterator i;
1007         Unit *u;
1008         char *k;
1009         int r;
1010
1011         assert(tr);
1012         assert(m);
1013
1014         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1015
1016                 /* ignore aliases */
1017                 if (u->id != k)
1018                         continue;
1019
1020                 if (u->ignore_on_isolate)
1021                         continue;
1022
1023                 /* No need to stop inactive jobs */
1024                 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)) && !u->job)
1025                         continue;
1026
1027                 /* Is there already something listed for this? */
1028                 if (hashmap_get(tr->jobs, u))
1029                         continue;
1030
1031                 r = transaction_add_job_and_dependencies(tr, JOB_STOP, u, tr->anchor_job, true, false, false, false, false, NULL);
1032                 if (r < 0)
1033                         log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->id, strerror(-r));
1034         }
1035
1036         return 0;
1037 }
1038
1039 Transaction *transaction_new(void) {
1040         Transaction *tr;
1041
1042         tr = new0(Transaction, 1);
1043         if (!tr)
1044                 return NULL;
1045
1046         tr->jobs = hashmap_new(trivial_hash_func, trivial_compare_func);
1047         if (!tr->jobs) {
1048                 free(tr);
1049                 return NULL;
1050         }
1051
1052         return tr;
1053 }
1054
1055 void transaction_free(Transaction *tr) {
1056         assert(hashmap_isempty(tr->jobs));
1057         hashmap_free(tr->jobs);
1058         free(tr);
1059 }