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