src/core/job.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 <assert.h>
  23 #include <errno.h>
  24 #include <sys/timerfd.h>
  25 #include <sys/epoll.h>
  26
  27 #include "sd-id128.h"
  28 #include "sd-messages.h"
  29 #include "set.h"
  30 #include "unit.h"
  31 #include "macro.h"
  32 #include "strv.h"
  33 #include "load-fragment.h"
  34 #include "load-dropin.h"
  35 #include "log.h"
  36 #include "dbus-job.h"
  37 #include "special.h"
  38 #include "async.h"
  39 #include "virt.h"
  40 #include "dbus-client-track.h"
  41
  42 Job* job_new_raw(Unit *unit) {
  43         Job *j;
  44
  45         /* used for deserialization */
  46
  47         assert(unit);
  48
  49         j = new0(Job, 1);
  50         if (!j)
  51                 return NULL;
  52
  53         j->manager = unit->manager;
  54         j->unit = unit;
  55         j->type = _JOB_TYPE_INVALID;
  56
  57         return j;
  58 }
  59
  60 Job* job_new(Unit *unit, JobType type) {
  61         Job *j;
  62
  63         assert(type < _JOB_TYPE_MAX);
  64
  65         j = job_new_raw(unit);
  66         if (!j)
  67                 return NULL;
  68
  69         j->id = j->manager->current_job_id++;
  70         j->type = type;
  71
  72         /* We don't link it here, that's what job_dependency() is for */
  73
  74         return j;
  75 }
  76
  77 void job_free(Job *j) {
  78         assert(j);
  79         assert(!j->installed);
  80         assert(!j->transaction_prev);
  81         assert(!j->transaction_next);
  82         assert(!j->subject_list);
  83         assert(!j->object_list);
  84
  85         if (j->in_run_queue)
  86                 LIST_REMOVE(run_queue, j->manager->run_queue, j);
  87
  88         if (j->in_dbus_queue)
  89                 LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
  90
  91         sd_event_source_unref(j->timer_event_source);
  92
  93         bus_client_track_free(j->subscribed);
  94
  95         free(j);
  96 }
  97
  98 void job_uninstall(Job *j) {
  99         Job **pj;
 100
 101         assert(j->installed);
 102
 103         pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
 104         assert(*pj == j);
 105
 106         /* Detach from next 'bigger' objects */
 107
 108         /* daemon-reload should be transparent to job observers */
 109         if (j->manager->n_reloading <= 0)
 110                 bus_job_send_removed_signal(j);
 111
 112         *pj = NULL;
 113
 114         unit_add_to_gc_queue(j->unit);
 115
 116         hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id));
 117         j->installed = false;
 118 }
 119
 120 static bool job_type_allows_late_merge(JobType t) {
 121         /* Tells whether it is OK to merge a job of type 't' with an already
 122          * running job.
 123          * Reloads cannot be merged this way. Think of the sequence:
 124          * 1. Reload of a daemon is in progress; the daemon has already loaded
 125          *    its config file, but hasn't completed the reload operation yet.
 126          * 2. Edit foo's config file.
 127          * 3. Trigger another reload to have the daemon use the new config.
 128          * Should the second reload job be merged into the first one, the daemon
 129          * would not know about the new config.
 130          * JOB_RESTART jobs on the other hand can be merged, because they get
 131          * patched into JOB_START after stopping the unit. So if we see a
 132          * JOB_RESTART running, it means the unit hasn't stopped yet and at
 133          * this time the merge is still allowed. */
 134         return t != JOB_RELOAD;
 135 }
 136
 137 static void job_merge_into_installed(Job *j, Job *other) {
 138         assert(j->installed);
 139         assert(j->unit == other->unit);
 140
 141         if (j->type != JOB_NOP)
 142                 job_type_merge_and_collapse(&j->type, other->type, j->unit);
 143         else
 144                 assert(other->type == JOB_NOP);
 145
 146         j->override = j->override || other->override;
 147         j->irreversible = j->irreversible || other->irreversible;
 148         j->ignore_order = j->ignore_order || other->ignore_order;
 149 }
 150
 151 Job* job_install(Job *j) {
 152         Job **pj;
 153         Job *uj;
 154
 155         assert(!j->installed);
 156         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
 157
 158         pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
 159         uj = *pj;
 160
 161         if (uj) {
 162                 if (j->type != JOB_NOP && job_type_is_conflicting(uj->type, j->type))
 163                         job_finish_and_invalidate(uj, JOB_CANCELED, false);
 164                 else {
 165                         /* not conflicting, i.e. mergeable */
 166
 167                         if (j->type == JOB_NOP || uj->state == JOB_WAITING ||
 168                             (job_type_allows_late_merge(j->type) && job_type_is_superset(uj->type, j->type))) {
 169                                 job_merge_into_installed(uj, j);
 170                                 log_debug_unit(uj->unit->id,
 171                                                "Merged into installed job %s/%s as %u",
 172                                                uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
 173                                 return uj;
 174                         } else {
 175                                 /* already running and not safe to merge into */
 176                                 /* Patch uj to become a merged job and re-run it. */
 177                                 /* XXX It should be safer to queue j to run after uj finishes, but it is
 178                                  * not currently possible to have more than one installed job per unit. */
 179                                 job_merge_into_installed(uj, j);
 180                                 log_debug_unit(uj->unit->id,
 181                                                "Merged into running job, re-running: %s/%s as %u",
 182                                                uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
 183                                 uj->state = JOB_WAITING;
 184                                 uj->manager->n_running_jobs--;
 185                                 return uj;
 186                         }
 187                 }
 188         }
 189
 190         /* Install the job */
 191         *pj = j;
 192         j->installed = true;
 193         j->manager->n_installed_jobs ++;
 194         log_debug_unit(j->unit->id,
 195                        "Installed new job %s/%s as %u",
 196                        j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
 197         return j;
 198 }
 199
 200 int job_install_deserialized(Job *j) {
 201         Job **pj;
 202
 203         assert(!j->installed);
 204
 205         if (j->type < 0 || j->type >= _JOB_TYPE_MAX_IN_TRANSACTION) {
 206                 log_debug("Invalid job type %s in deserialization.", strna(job_type_to_string(j->type)));
 207                 return -EINVAL;
 208         }
 209
 210         pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
 211
 212         if (*pj) {
 213                 log_debug_unit(j->unit->id,
 214                                "Unit %s already has a job installed. Not installing deserialized job.",
 215                                j->unit->id);
 216                 return -EEXIST;
 217         }
 218         *pj = j;
 219         j->installed = true;
 220         log_debug_unit(j->unit->id,
 221                        "Reinstalled deserialized job %s/%s as %u",
 222                        j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
 223         return 0;
 224 }
 225
 226 JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool conflicts) {
 227         JobDependency *l;
 228
 229         assert(object);
 230
 231         /* Adds a new job link, which encodes that the 'subject' job
 232          * needs the 'object' job in some way. If 'subject' is NULL
 233          * this means the 'anchor' job (i.e. the one the user
 234          * explicitly asked for) is the requester. */
 235
 236         if (!(l = new0(JobDependency, 1)))
 237                 return NULL;
 238
 239         l->subject = subject;
 240         l->object = object;
 241         l->matters = matters;
 242         l->conflicts = conflicts;
 243
 244         if (subject)
 245                 LIST_PREPEND(subject, subject->subject_list, l);
 246
 247         LIST_PREPEND(object, object->object_list, l);
 248
 249         return l;
 250 }
 251
 252 void job_dependency_free(JobDependency *l) {
 253         assert(l);
 254
 255         if (l->subject)
 256                 LIST_REMOVE(subject, l->subject->subject_list, l);
 257
 258         LIST_REMOVE(object, l->object->object_list, l);
 259
 260         free(l);
 261 }
 262
 263 void job_dump(Job *j, FILE*f, const char *prefix) {
 264         assert(j);
 265         assert(f);
 266
 267         if (!prefix)
 268                 prefix = "";
 269
 270         fprintf(f,
 271                 "%s-> Job %u:\n"
 272                 "%s\tAction: %s -> %s\n"
 273                 "%s\tState: %s\n"
 274                 "%s\tForced: %s\n"
 275                 "%s\tIrreversible: %s\n",
 276                 prefix, j->id,
 277                 prefix, j->unit->id, job_type_to_string(j->type),
 278                 prefix, job_state_to_string(j->state),
 279                 prefix, yes_no(j->override),
 280                 prefix, yes_no(j->irreversible));
 281 }
 282
 283 /*
 284  * Merging is commutative, so imagine the matrix as symmetric. We store only
 285  * its lower triangle to avoid duplication. We don't store the main diagonal,
 286  * because A merged with A is simply A.
 287  *
 288  * If the resulting type is collapsed immediately afterwards (to get rid of
 289  * the JOB_RELOAD_OR_START, which lies outside the lookup function's domain),
 290  * the following properties hold:
 291  *
 292  * Merging is associative! A merged with B merged with C is the same as
 293  * A merged with C merged with B.
 294  *
 295  * Mergeability is transitive! If A can be merged with B and B with C then
 296  * A also with C.
 297  *
 298  * Also, if A merged with B cannot be merged with C, then either A or B cannot
 299  * be merged with C either.
 300  */
 301 static const JobType job_merging_table[] = {
 302 /* What \ With       *  JOB_START         JOB_VERIFY_ACTIVE  JOB_STOP JOB_RELOAD */
 303 /*********************************************************************************/
 304 /*JOB_START          */
 305 /*JOB_VERIFY_ACTIVE  */ JOB_START,
 306 /*JOB_STOP           */ -1,                  -1,
 307 /*JOB_RELOAD         */ JOB_RELOAD_OR_START, JOB_RELOAD,          -1,
 308 /*JOB_RESTART        */ JOB_RESTART,         JOB_RESTART,         -1, JOB_RESTART,
 309 };
 310
 311 JobType job_type_lookup_merge(JobType a, JobType b) {
 312         assert_cc(ELEMENTSOF(job_merging_table) == _JOB_TYPE_MAX_MERGING * (_JOB_TYPE_MAX_MERGING - 1) / 2);
 313         assert(a >= 0 && a < _JOB_TYPE_MAX_MERGING);
 314         assert(b >= 0 && b < _JOB_TYPE_MAX_MERGING);
 315
 316         if (a == b)
 317                 return a;
 318
 319         if (a < b) {
 320                 JobType tmp = a;
 321                 a = b;
 322                 b = tmp;
 323         }
 324
 325         return job_merging_table[(a - 1) * a / 2 + b];
 326 }
 327
 328 bool job_type_is_redundant(JobType a, UnitActiveState b) {
 329         switch (a) {
 330
 331         case JOB_START:
 332                 return
 333                         b == UNIT_ACTIVE ||
 334                         b == UNIT_RELOADING;
 335
 336         case JOB_STOP:
 337                 return
 338                         b == UNIT_INACTIVE ||
 339                         b == UNIT_FAILED;
 340
 341         case JOB_VERIFY_ACTIVE:
 342                 return
 343                         b == UNIT_ACTIVE ||
 344                         b == UNIT_RELOADING;
 345
 346         case JOB_RELOAD:
 347                 return
 348                         b == UNIT_RELOADING;
 349
 350         case JOB_RESTART:
 351                 return
 352                         b == UNIT_ACTIVATING;
 353
 354         default:
 355                 assert_not_reached("Invalid job type");
 356         }
 357 }
 358
 359 void job_type_collapse(JobType *t, Unit *u) {
 360         UnitActiveState s;
 361
 362         switch (*t) {
 363
 364         case JOB_TRY_RESTART:
 365                 s = unit_active_state(u);
 366                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
 367                         *t = JOB_NOP;
 368                 else
 369                         *t = JOB_RESTART;
 370                 break;
 371
 372         case JOB_RELOAD_OR_START:
 373                 s = unit_active_state(u);
 374                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
 375                         *t = JOB_START;
 376                 else
 377                         *t = JOB_RELOAD;
 378                 break;
 379
 380         default:
 381                 ;
 382         }
 383 }
 384
 385 int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u) {
 386         JobType t = job_type_lookup_merge(*a, b);
 387         if (t < 0)
 388                 return -EEXIST;
 389         *a = t;
 390         job_type_collapse(a, u);
 391         return 0;
 392 }
 393
 394 static bool job_is_runnable(Job *j) {
 395         Iterator i;
 396         Unit *other;
 397
 398         assert(j);
 399         assert(j->installed);
 400
 401         /* Checks whether there is any job running for the units this
 402          * job needs to be running after (in the case of a 'positive'
 403          * job type) or before (in the case of a 'negative' job
 404          * type. */
 405
 406         /* First check if there is an override */
 407         if (j->ignore_order)
 408                 return true;
 409
 410         if (j->type == JOB_NOP)
 411                 return true;
 412
 413         if (j->type == JOB_START ||
 414             j->type == JOB_VERIFY_ACTIVE ||
 415             j->type == JOB_RELOAD) {
 416
 417                 /* Immediate result is that the job is or might be
 418                  * started. In this case lets wait for the
 419                  * dependencies, regardless whether they are
 420                  * starting or stopping something. */
 421
 422                 SET_FOREACH(other, j->unit->dependencies[UNIT_AFTER], i)
 423                         if (other->job)
 424                                 return false;
 425         }
 426
 427         /* Also, if something else is being stopped and we should
 428          * change state after it, then lets wait. */
 429
 430         SET_FOREACH(other, j->unit->dependencies[UNIT_BEFORE], i)
 431                 if (other->job &&
 432                     (other->job->type == JOB_STOP ||
 433                      other->job->type == JOB_RESTART))
 434                         return false;
 435
 436         /* This means that for a service a and a service b where b
 437          * shall be started after a:
 438          *
 439          *  start a + start b → 1st step start a, 2nd step start b
 440          *  start a + stop b  → 1st step stop b,  2nd step start a
 441          *  stop a  + start b → 1st step stop a,  2nd step start b
 442          *  stop a  + stop b  → 1st step stop b,  2nd step stop a
 443          *
 444          *  This has the side effect that restarts are properly
 445          *  synchronized too. */
 446
 447         return true;
 448 }
 449
 450 static void job_change_type(Job *j, JobType newtype) {
 451         log_debug_unit(j->unit->id,
 452                        "Converting job %s/%s -> %s/%s",
 453                        j->unit->id, job_type_to_string(j->type),
 454                        j->unit->id, job_type_to_string(newtype));
 455
 456         j->type = newtype;
 457 }
 458
 459 int job_run_and_invalidate(Job *j) {
 460         int r;
 461         uint32_t id;
 462         Manager *m = j->manager;
 463
 464         assert(j);
 465         assert(j->installed);
 466         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
 467         assert(j->in_run_queue);
 468
 469         LIST_REMOVE(run_queue, j->manager->run_queue, j);
 470         j->in_run_queue = false;
 471
 472         if (j->state != JOB_WAITING)
 473                 return 0;
 474
 475         if (!job_is_runnable(j))
 476                 return -EAGAIN;
 477
 478         j->state = JOB_RUNNING;
 479         m->n_running_jobs++;
 480         job_add_to_dbus_queue(j);
 481
 482         /* While we execute this operation the job might go away (for
 483          * example: because it is replaced by a new, conflicting
 484          * job.) To make sure we don't access a freed job later on we
 485          * store the id here, so that we can verify the job is still
 486          * valid. */
 487         id = j->id;
 488
 489         switch (j->type) {
 490
 491                 case JOB_START:
 492                         r = unit_start(j->unit);
 493
 494                         /* If this unit cannot be started, then simply wait */
 495                         if (r == -EBADR)
 496                                 r = 0;
 497                         break;
 498
 499                 case JOB_VERIFY_ACTIVE: {
 500                         UnitActiveState t = unit_active_state(j->unit);
 501                         if (UNIT_IS_ACTIVE_OR_RELOADING(t))
 502                                 r = -EALREADY;
 503                         else if (t == UNIT_ACTIVATING)
 504                                 r = -EAGAIN;
 505                         else
 506                                 r = -ENOEXEC;
 507                         break;
 508                 }
 509
 510                 case JOB_STOP:
 511                 case JOB_RESTART:
 512                         r = unit_stop(j->unit);
 513
 514                         /* If this unit cannot stopped, then simply wait. */
 515                         if (r == -EBADR)
 516                                 r = 0;
 517                         break;
 518
 519                 case JOB_RELOAD:
 520                         r = unit_reload(j->unit);
 521                         break;
 522
 523                 case JOB_NOP:
 524                         r = -EALREADY;
 525                         break;
 526
 527                 default:
 528                         assert_not_reached("Unknown job type");
 529         }
 530
 531         j = manager_get_job(m, id);
 532         if (j) {
 533                 if (r == -EALREADY)
 534                         r = job_finish_and_invalidate(j, JOB_DONE, true);
 535                 else if (r == -ENOEXEC)
 536                         r = job_finish_and_invalidate(j, JOB_SKIPPED, true);
 537                 else if (r == -EAGAIN) {
 538                         j->state = JOB_WAITING;
 539                         m->n_running_jobs--;
 540                 } else if (r < 0)
 541                         r = job_finish_and_invalidate(j, JOB_FAILED, true);
 542         }
 543
 544         return r;
 545 }
 546
 547 _pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
 548         const UnitStatusMessageFormats *format_table;
 549
 550         assert(u);
 551         assert(t >= 0);
 552         assert(t < _JOB_TYPE_MAX);
 553
 554         format_table = &UNIT_VTABLE(u)->status_message_formats;
 555         if (!format_table)
 556                 return NULL;
 557
 558         if (t == JOB_START)
 559                 return format_table->finished_start_job[result];
 560         else if (t == JOB_STOP || t == JOB_RESTART)
 561                 return format_table->finished_stop_job[result];
 562
 563         return NULL;
 564 }
 565
 566 _pure_ static const char *job_get_status_message_format_try_harder(Unit *u, JobType t, JobResult result) {
 567         const char *format;
 568
 569         assert(u);
 570         assert(t >= 0);
 571         assert(t < _JOB_TYPE_MAX);
 572
 573         format = job_get_status_message_format(u, t, result);
 574         if (format)
 575                 return format;
 576
 577         /* Return generic strings */
 578         if (t == JOB_START) {
 579                 if (result == JOB_DONE)
 580                         return "Started %s.";
 581                 else if (result == JOB_FAILED)
 582                         return "Failed to start %s.";
 583                 else if (result == JOB_DEPENDENCY)
 584                         return "Dependency failed for %s.";
 585                 else if (result == JOB_TIMEOUT)
 586                         return "Timed out starting %s.";
 587         } else if (t == JOB_STOP || t == JOB_RESTART) {
 588                 if (result == JOB_DONE)
 589                         return "Stopped %s.";
 590                 else if (result == JOB_FAILED)
 591                         return "Stopped (with error) %s.";
 592                 else if (result == JOB_TIMEOUT)
 593                         return "Timed out stoppping %s.";
 594         } else if (t == JOB_RELOAD) {
 595                 if (result == JOB_DONE)
 596                         return "Reloaded %s.";
 597                 else if (result == JOB_FAILED)
 598                         return "Reload failed for %s.";
 599                 else if (result == JOB_TIMEOUT)
 600                         return "Timed out reloading %s.";
 601         }
 602
 603         return NULL;
 604 }
 605
 606 static void job_print_status_message(Unit *u, JobType t, JobResult result) {
 607         const char *format;
 608
 609         assert(u);
 610         assert(t >= 0);
 611         assert(t < _JOB_TYPE_MAX);
 612
 613         if (t == JOB_START) {
 614                 format = job_get_status_message_format(u, t, result);
 615                 if (!format)
 616                         return;
 617
 618                 switch (result) {
 619
 620                 case JOB_DONE:
 621                         if (u->condition_result)
 622                                 unit_status_printf(u, ANSI_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, format);
 623                         break;
 624
 625                 case JOB_FAILED:
 626                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, format);
 627                         manager_status_printf(u->manager, false, NULL, "See 'systemctl status %s' for details.", u->id);
 628                         break;
 629
 630                 case JOB_DEPENDENCY:
 631                         unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "DEPEND" ANSI_HIGHLIGHT_OFF, format);
 632                         break;
 633
 634                 case JOB_TIMEOUT:
 635                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
 636                         break;
 637
 638                 default:
 639                         ;
 640                 }
 641
 642         } else if (t == JOB_STOP || t == JOB_RESTART) {
 643
 644                 format = job_get_status_message_format(u, t, result);
 645                 if (!format)
 646                         return;
 647
 648                 switch (result) {
 649
 650                 case JOB_TIMEOUT:
 651                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
 652                         break;
 653
 654                 case JOB_DONE:
 655                 case JOB_FAILED:
 656                         unit_status_printf(u, ANSI_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, format);
 657                         break;
 658
 659                 default:
 660                         ;
 661                 }
 662
 663         } else if (t == JOB_VERIFY_ACTIVE) {
 664
 665                 /* When verify-active detects the unit is inactive, report it.
 666                  * Most likely a DEPEND warning from a requisiting unit will
 667                  * occur next and it's nice to see what was requisited. */
 668                 if (result == JOB_SKIPPED)
 669                         unit_status_printf(u, ANSI_HIGHLIGHT_ON " INFO " ANSI_HIGHLIGHT_OFF, "%s is not active.");
 670         }
 671 }
 672
 673 #pragma GCC diagnostic push
 674 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 675 static void job_log_status_message(Unit *u, JobType t, JobResult result) {
 676         const char *format;
 677         char buf[LINE_MAX];
 678
 679         assert(u);
 680         assert(t >= 0);
 681         assert(t < _JOB_TYPE_MAX);
 682
 683         /* Skip this if it goes to the console. since we already print
 684          * to the console anyway... */
 685
 686         if (log_on_console())
 687                 return;
 688
 689         format = job_get_status_message_format_try_harder(u, t, result);
 690         if (!format)
 691                 return;
 692
 693         snprintf(buf, sizeof(buf), format, unit_description(u));
 694         char_array_0(buf);
 695
 696         if (t == JOB_START) {
 697                 sd_id128_t mid;
 698
 699                 mid = result == JOB_DONE ? SD_MESSAGE_UNIT_STARTED : SD_MESSAGE_UNIT_FAILED;
 700                 log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR,
 701                            u->id,
 702                            MESSAGE_ID(mid),
 703                            "RESULT=%s", job_result_to_string(result),
 704                            "MESSAGE=%s", buf,
 705                            NULL);
 706
 707         } else if (t == JOB_STOP)
 708                 log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR,
 709                            u->id,
 710                            MESSAGE_ID(SD_MESSAGE_UNIT_STOPPED),
 711                            "RESULT=%s", job_result_to_string(result),
 712                            "MESSAGE=%s", buf,
 713                            NULL);
 714
 715         else if (t == JOB_RELOAD)
 716                 log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR,
 717                            u->id,
 718                            MESSAGE_ID(SD_MESSAGE_UNIT_RELOADED),
 719                            "RESULT=%s", job_result_to_string(result),
 720                            "MESSAGE=%s", buf,
 721                            NULL);
 722 }
 723 #pragma GCC diagnostic pop
 724
 725 int job_finish_and_invalidate(Job *j, JobResult result, bool recursive) {
 726         Unit *u;
 727         Unit *other;
 728         JobType t;
 729         Iterator i;
 730
 731         assert(j);
 732         assert(j->installed);
 733         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
 734
 735         u = j->unit;
 736         t = j->type;
 737
 738         j->result = result;
 739
 740         if (j->state == JOB_RUNNING)
 741                 j->manager->n_running_jobs--;
 742
 743         log_debug_unit(u->id, "Job %s/%s finished, result=%s",
 744                        u->id, job_type_to_string(t), job_result_to_string(result));
 745
 746         job_print_status_message(u, t, result);
 747         job_log_status_message(u, t, result);
 748
 749         job_add_to_dbus_queue(j);
 750
 751         /* Patch restart jobs so that they become normal start jobs */
 752         if (result == JOB_DONE && t == JOB_RESTART) {
 753
 754                 job_change_type(j, JOB_START);
 755                 j->state = JOB_WAITING;
 756
 757                 job_add_to_run_queue(j);
 758
 759                 goto finish;
 760         }
 761
 762         if (result == JOB_FAILED)
 763                 j->manager->n_failed_jobs ++;
 764
 765         job_uninstall(j);
 766         job_free(j);
 767
 768         /* Fail depending jobs on failure */
 769         if (result != JOB_DONE && recursive) {
 770
 771                 if (t == JOB_START ||
 772                     t == JOB_VERIFY_ACTIVE) {
 773
 774                         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
 775                                 if (other->job &&
 776                                     (other->job->type == JOB_START ||
 777                                      other->job->type == JOB_VERIFY_ACTIVE))
 778                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 779
 780                         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
 781                                 if (other->job &&
 782                                     (other->job->type == JOB_START ||
 783                                      other->job->type == JOB_VERIFY_ACTIVE))
 784                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 785
 786                         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
 787                                 if (other->job &&
 788                                     !other->job->override &&
 789                                     (other->job->type == JOB_START ||
 790                                      other->job->type == JOB_VERIFY_ACTIVE))
 791                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 792
 793                 } else if (t == JOB_STOP) {
 794
 795                         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
 796                                 if (other->job &&
 797                                     (other->job->type == JOB_START ||
 798                                      other->job->type == JOB_VERIFY_ACTIVE))
 799                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 800                 }
 801         }
 802
 803         /* Trigger OnFailure dependencies that are not generated by
 804          * the unit itself. We don't treat JOB_CANCELED as failure in
 805          * this context. And JOB_FAILURE is already handled by the
 806          * unit itself. */
 807         if (result == JOB_TIMEOUT || result == JOB_DEPENDENCY) {
 808                 log_struct_unit(LOG_NOTICE,
 809                            u->id,
 810                            "JOB_TYPE=%s", job_type_to_string(t),
 811                            "JOB_RESULT=%s", job_result_to_string(result),
 812                            "Job %s/%s failed with result '%s'.",
 813                            u->id,
 814                            job_type_to_string(t),
 815                            job_result_to_string(result),
 816                            NULL);
 817
 818                 unit_start_on_failure(u);
 819         }
 820
 821         unit_trigger_notify(u);
 822
 823 finish:
 824         /* Try to start the next jobs that can be started */
 825         SET_FOREACH(other, u->dependencies[UNIT_AFTER], i)
 826                 if (other->job)
 827                         job_add_to_run_queue(other->job);
 828         SET_FOREACH(other, u->dependencies[UNIT_BEFORE], i)
 829                 if (other->job)
 830                         job_add_to_run_queue(other->job);
 831
 832         manager_check_finished(u->manager);
 833
 834         return 0;
 835 }
 836
 837 static int job_dispatch_timer(sd_event_source *s, uint64_t monotonic, void *userdata) {
 838         Job *j = userdata;
 839
 840         assert(j);
 841         assert(s == j->timer_event_source);
 842
 843         log_warning_unit(j->unit->id, "Job %s/%s timed out.",
 844                          j->unit->id, job_type_to_string(j->type));
 845
 846         job_finish_and_invalidate(j, JOB_TIMEOUT, true);
 847         return 0;
 848 }
 849
 850 int job_start_timer(Job *j) {
 851         int r;
 852
 853         if (j->unit->job_timeout <= 0 || j->timer_event_source)
 854                 return 0;
 855
 856         j->begin_usec = now(CLOCK_MONOTONIC);
 857
 858         r = sd_event_add_monotonic(j->manager->event, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j, &j->timer_event_source);
 859         if (r < 0)
 860                 return r;
 861
 862         return 0;
 863 }
 864
 865 void job_add_to_run_queue(Job *j) {
 866         assert(j);
 867         assert(j->installed);
 868
 869         if (j->in_run_queue)
 870                 return;
 871
 872         LIST_PREPEND(run_queue, j->manager->run_queue, j);
 873         j->in_run_queue = true;
 874 }
 875
 876 void job_add_to_dbus_queue(Job *j) {
 877         assert(j);
 878         assert(j->installed);
 879
 880         if (j->in_dbus_queue)
 881                 return;
 882
 883         /* We don't check if anybody is subscribed here, since this
 884          * job might just have been created and not yet assigned to a
 885          * connection/client. */
 886
 887         LIST_PREPEND(dbus_queue, j->manager->dbus_job_queue, j);
 888         j->in_dbus_queue = true;
 889 }
 890
 891 char *job_dbus_path(Job *j) {
 892         char *p;
 893
 894         assert(j);
 895
 896         if (asprintf(&p, "/org/freedesktop/systemd1/job/%lu", (unsigned long) j->id) < 0)
 897                 return NULL;
 898
 899         return p;
 900 }
 901
 902 int job_serialize(Job *j, FILE *f, FDSet *fds) {
 903         fprintf(f, "job-id=%u\n", j->id);
 904         fprintf(f, "job-type=%s\n", job_type_to_string(j->type));
 905         fprintf(f, "job-state=%s\n", job_state_to_string(j->state));
 906         fprintf(f, "job-override=%s\n", yes_no(j->override));
 907         fprintf(f, "job-irreversible=%s\n", yes_no(j->irreversible));
 908         fprintf(f, "job-sent-dbus-new-signal=%s\n", yes_no(j->sent_dbus_new_signal));
 909         fprintf(f, "job-ignore-order=%s\n", yes_no(j->ignore_order));
 910
 911         if (j->begin_usec > 0)
 912                 fprintf(f, "job-begin=%llu", (unsigned long long) j->begin_usec);
 913
 914         bus_client_track_serialize(j->manager, f, j->subscribed);
 915
 916         /* End marker */
 917         fputc('\n', f);
 918         return 0;
 919 }
 920
 921 int job_deserialize(Job *j, FILE *f, FDSet *fds) {
 922         assert(j);
 923
 924         for (;;) {
 925                 char line[LINE_MAX], *l, *v;
 926                 size_t k;
 927
 928                 if (!fgets(line, sizeof(line), f)) {
 929                         if (feof(f))
 930                                 return 0;
 931                         return -errno;
 932                 }
 933
 934                 char_array_0(line);
 935                 l = strstrip(line);
 936
 937                 /* End marker */
 938                 if (l[0] == 0)
 939                         return 0;
 940
 941                 k = strcspn(l, "=");
 942
 943                 if (l[k] == '=') {
 944                         l[k] = 0;
 945                         v = l+k+1;
 946                 } else
 947                         v = l+k;
 948
 949                 if (streq(l, "job-id")) {
 950
 951                         if (safe_atou32(v, &j->id) < 0)
 952                                 log_debug("Failed to parse job id value %s", v);
 953
 954                 } else if (streq(l, "job-type")) {
 955                         JobType t;
 956
 957                         t = job_type_from_string(v);
 958                         if (t < 0)
 959                                 log_debug("Failed to parse job type %s", v);
 960                         else if (t >= _JOB_TYPE_MAX_IN_TRANSACTION)
 961                                 log_debug("Cannot deserialize job of type %s", v);
 962                         else
 963                                 j->type = t;
 964
 965                 } else if (streq(l, "job-state")) {
 966                         JobState s;
 967
 968                         s = job_state_from_string(v);
 969                         if (s < 0)
 970                                 log_debug("Failed to parse job state %s", v);
 971                         else
 972                                 j->state = s;
 973
 974                 } else if (streq(l, "job-override")) {
 975                         int b;
 976
 977                         b = parse_boolean(v);
 978                         if (b < 0)
 979                                 log_debug("Failed to parse job override flag %s", v);
 980                         else
 981                                 j->override = j->override || b;
 982
 983                 } else if (streq(l, "job-irreversible")) {
 984                         int b;
 985
 986                         b = parse_boolean(v);
 987                         if (b < 0)
 988                                 log_debug("Failed to parse job irreversible flag %s", v);
 989                         else
 990                                 j->irreversible = j->irreversible || b;
 991
 992                 } else if (streq(l, "job-sent-dbus-new-signal")) {
 993                         int b;
 994
 995                         b = parse_boolean(v);
 996                         if (b < 0)
 997                                 log_debug("Failed to parse job sent_dbus_new_signal flag %s", v);
 998                         else
 999                                 j->sent_dbus_new_signal = j->sent_dbus_new_signal || b;
1000
1001                 } else if (streq(l, "job-ignore-order")) {
1002                         int b;
1003
1004                         b = parse_boolean(v);
1005                         if (b < 0)
1006                                 log_debug("Failed to parse job ignore_order flag %s", v);
1007                         else
1008                                 j->ignore_order = j->ignore_order || b;
1009
1010                 } else if (streq(l, "job-begin")) {
1011                         unsigned long long ull;
1012
1013                         if (sscanf(v, "%llu", &ull) != 1)
1014                                 log_debug("Failed to parse job-begin value %s", v);
1015                         else
1016                                 j->begin_usec = ull;
1017
1018                 } else {
1019                         char t[strlen(l) + 1 + strlen(v) + 1];
1020
1021                         strcpy(stpcpy(stpcpy(t, l), "="), v);
1022
1023                         if (bus_client_track_deserialize_item(j->manager, &j->subscribed, t) == 0)
1024                                 log_debug("Unknown deserialization key '%s'", l);
1025                 }
1026         }
1027 }
1028
1029 int job_coldplug(Job *j) {
1030         int r;
1031
1032         assert(j);
1033
1034         if (j->begin_usec <= 0)
1035                 return 0;
1036
1037         if (j->timer_event_source)
1038                 j->timer_event_source = sd_event_source_unref(j->timer_event_source);
1039
1040         r = sd_event_add_monotonic(j->manager->event, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j, &j->timer_event_source);
1041         if (r < 0)
1042                 log_debug("Failed to restart timeout for job: %s", strerror(-r));
1043
1044         return r;
1045 }
1046
1047 void job_shutdown_magic(Job *j) {
1048         assert(j);
1049
1050         /* The shutdown target gets some special treatment here: we
1051          * tell the kernel to begin with flushing its disk caches, to
1052          * optimize shutdown time a bit. Ideally we wouldn't hardcode
1053          * this magic into PID 1. However all other processes aren't
1054          * options either since they'd exit much sooner than PID 1 and
1055          * asynchronous sync() would cause their exit to be
1056          * delayed. */
1057
1058         if (j->type != JOB_START)
1059                 return;
1060
1061         if (j->unit->manager->running_as != SYSTEMD_SYSTEM)
1062                 return;
1063
1064         if (!unit_has_name(j->unit, SPECIAL_SHUTDOWN_TARGET))
1065                 return;
1066
1067         /* In case messages on console has been disabled on boot */
1068         j->unit->manager->no_console_output = false;
1069
1070         if (detect_container(NULL) > 0)
1071                 return;
1072
1073         asynchronous_sync();
1074 }
1075
1076 static const char* const job_state_table[_JOB_STATE_MAX] = {
1077         [JOB_WAITING] = "waiting",
1078         [JOB_RUNNING] = "running"
1079 };
1080
1081 DEFINE_STRING_TABLE_LOOKUP(job_state, JobState);
1082
1083 static const char* const job_type_table[_JOB_TYPE_MAX] = {
1084         [JOB_START] = "start",
1085         [JOB_VERIFY_ACTIVE] = "verify-active",
1086         [JOB_STOP] = "stop",
1087         [JOB_RELOAD] = "reload",
1088         [JOB_RELOAD_OR_START] = "reload-or-start",
1089         [JOB_RESTART] = "restart",
1090         [JOB_TRY_RESTART] = "try-restart",
1091         [JOB_NOP] = "nop",
1092 };
1093
1094 DEFINE_STRING_TABLE_LOOKUP(job_type, JobType);
1095
1096 static const char* const job_mode_table[_JOB_MODE_MAX] = {
1097         [JOB_FAIL] = "fail",
1098         [JOB_REPLACE] = "replace",
1099         [JOB_REPLACE_IRREVERSIBLY] = "replace-irreversibly",
1100         [JOB_ISOLATE] = "isolate",
1101         [JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies",
1102         [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements"
1103 };
1104
1105 DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);
1106
1107 static const char* const job_result_table[_JOB_RESULT_MAX] = {
1108         [JOB_DONE] = "done",
1109         [JOB_CANCELED] = "canceled",
1110         [JOB_TIMEOUT] = "timeout",
1111         [JOB_FAILED] = "failed",
1112         [JOB_DEPENDENCY] = "dependency",
1113         [JOB_SKIPPED] = "skipped"
1114 };
1115
1116 DEFINE_STRING_TABLE_LOOKUP(job_result, JobResult);