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 (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 (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_unit_debug(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_unit_debug(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_unit_debug(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_unit_debug(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_unit_debug(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         case JOB_NOP:
 356                 return true;
 357
 358         default:
 359                 assert_not_reached("Invalid job type");
 360         }
 361 }
 362
 363 void job_type_collapse(JobType *t, Unit *u) {
 364         UnitActiveState s;
 365
 366         switch (*t) {
 367
 368         case JOB_TRY_RESTART:
 369                 s = unit_active_state(u);
 370                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
 371                         *t = JOB_NOP;
 372                 else
 373                         *t = JOB_RESTART;
 374                 break;
 375
 376         case JOB_RELOAD_OR_START:
 377                 s = unit_active_state(u);
 378                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
 379                         *t = JOB_START;
 380                 else
 381                         *t = JOB_RELOAD;
 382                 break;
 383
 384         default:
 385                 ;
 386         }
 387 }
 388
 389 int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u) {
 390         JobType t = job_type_lookup_merge(*a, b);
 391         if (t < 0)
 392                 return -EEXIST;
 393         *a = t;
 394         job_type_collapse(a, u);
 395         return 0;
 396 }
 397
 398 static bool job_is_runnable(Job *j) {
 399         Iterator i;
 400         Unit *other;
 401
 402         assert(j);
 403         assert(j->installed);
 404
 405         /* Checks whether there is any job running for the units this
 406          * job needs to be running after (in the case of a 'positive'
 407          * job type) or before (in the case of a 'negative' job
 408          * type. */
 409
 410         /* Note that unit types have a say in what is runnable,
 411          * too. For example, if they return -EAGAIN from
 412          * unit_start() they can indicate they are not
 413          * runnable yet. */
 414
 415         /* First check if there is an override */
 416         if (j->ignore_order)
 417                 return true;
 418
 419         if (j->type == JOB_NOP)
 420                 return true;
 421
 422         if (j->type == JOB_START ||
 423             j->type == JOB_VERIFY_ACTIVE ||
 424             j->type == JOB_RELOAD) {
 425
 426                 /* Immediate result is that the job is or might be
 427                  * started. In this case lets wait for the
 428                  * dependencies, regardless whether they are
 429                  * starting or stopping something. */
 430
 431                 SET_FOREACH(other, j->unit->dependencies[UNIT_AFTER], i)
 432                         if (other->job)
 433                                 return false;
 434         }
 435
 436         /* Also, if something else is being stopped and we should
 437          * change state after it, then lets wait. */
 438
 439         SET_FOREACH(other, j->unit->dependencies[UNIT_BEFORE], i)
 440                 if (other->job &&
 441                     (other->job->type == JOB_STOP ||
 442                      other->job->type == JOB_RESTART))
 443                         return false;
 444
 445         /* This means that for a service a and a service b where b
 446          * shall be started after a:
 447          *
 448          *  start a + start b → 1st step start a, 2nd step start b
 449          *  start a + stop b  → 1st step stop b,  2nd step start a
 450          *  stop a  + start b → 1st step stop a,  2nd step start b
 451          *  stop a  + stop b  → 1st step stop b,  2nd step stop a
 452          *
 453          *  This has the side effect that restarts are properly
 454          *  synchronized too. */
 455
 456         return true;
 457 }
 458
 459 static void job_change_type(Job *j, JobType newtype) {
 460         log_unit_debug(j->unit->id,
 461                        "Converting job %s/%s -> %s/%s",
 462                        j->unit->id, job_type_to_string(j->type),
 463                        j->unit->id, job_type_to_string(newtype));
 464
 465         j->type = newtype;
 466 }
 467
 468 int job_run_and_invalidate(Job *j) {
 469         int r;
 470         uint32_t id;
 471         Manager *m = j->manager;
 472
 473         assert(j);
 474         assert(j->installed);
 475         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
 476         assert(j->in_run_queue);
 477
 478         LIST_REMOVE(run_queue, j->manager->run_queue, j);
 479         j->in_run_queue = false;
 480
 481         if (j->state != JOB_WAITING)
 482                 return 0;
 483
 484         if (!job_is_runnable(j))
 485                 return -EAGAIN;
 486
 487         j->state = JOB_RUNNING;
 488         m->n_running_jobs++;
 489         job_add_to_dbus_queue(j);
 490
 491         /* While we execute this operation the job might go away (for
 492          * example: because it is replaced by a new, conflicting
 493          * job.) To make sure we don't access a freed job later on we
 494          * store the id here, so that we can verify the job is still
 495          * valid. */
 496         id = j->id;
 497
 498         switch (j->type) {
 499
 500                 case JOB_START:
 501                         r = unit_start(j->unit);
 502
 503                         /* If this unit cannot be started, then simply wait */
 504                         if (r == -EBADR)
 505                                 r = 0;
 506                         break;
 507
 508                 case JOB_VERIFY_ACTIVE: {
 509                         UnitActiveState t = unit_active_state(j->unit);
 510                         if (UNIT_IS_ACTIVE_OR_RELOADING(t))
 511                                 r = -EALREADY;
 512                         else if (t == UNIT_ACTIVATING)
 513                                 r = -EAGAIN;
 514                         else
 515                                 r = -EBADR;
 516                         break;
 517                 }
 518
 519                 case JOB_STOP:
 520                 case JOB_RESTART:
 521                         r = unit_stop(j->unit);
 522
 523                         /* If this unit cannot stopped, then simply wait. */
 524                         if (r == -EBADR)
 525                                 r = 0;
 526                         break;
 527
 528                 case JOB_RELOAD:
 529                         r = unit_reload(j->unit);
 530                         break;
 531
 532                 case JOB_NOP:
 533                         r = -EALREADY;
 534                         break;
 535
 536                 default:
 537                         assert_not_reached("Unknown job type");
 538         }
 539
 540         j = manager_get_job(m, id);
 541         if (j) {
 542                 if (r == -EALREADY)
 543                         r = job_finish_and_invalidate(j, JOB_DONE, true);
 544                 else if (r == -EBADR)
 545                         r = job_finish_and_invalidate(j, JOB_SKIPPED, true);
 546                 else if (r == -ENOEXEC)
 547                         r = job_finish_and_invalidate(j, JOB_INVALID, true);
 548                 else if (r == -EPROTO)
 549                         r = job_finish_and_invalidate(j, JOB_ASSERT, true);
 550                 else if (r == -EAGAIN) {
 551                         j->state = JOB_WAITING;
 552                         m->n_running_jobs--;
 553                 } else if (r < 0)
 554                         r = job_finish_and_invalidate(j, JOB_FAILED, true);
 555         }
 556
 557         return r;
 558 }
 559
 560 _pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
 561         const UnitStatusMessageFormats *format_table;
 562
 563         assert(u);
 564         assert(t >= 0);
 565         assert(t < _JOB_TYPE_MAX);
 566
 567         format_table = &UNIT_VTABLE(u)->status_message_formats;
 568         if (!format_table)
 569                 return NULL;
 570
 571         if (t == JOB_START)
 572                 return format_table->finished_start_job[result];
 573         else if (t == JOB_STOP || t == JOB_RESTART)
 574                 return format_table->finished_stop_job[result];
 575
 576         return NULL;
 577 }
 578
 579 _pure_ static const char *job_get_status_message_format_try_harder(Unit *u, JobType t, JobResult result) {
 580         const char *format;
 581
 582         assert(u);
 583         assert(t >= 0);
 584         assert(t < _JOB_TYPE_MAX);
 585
 586         format = job_get_status_message_format(u, t, result);
 587         if (format)
 588                 return format;
 589
 590         /* Return generic strings */
 591         if (t == JOB_START) {
 592                 if (result == JOB_DONE)
 593                         return "Started %s.";
 594                 else if (result == JOB_FAILED)
 595                         return "Failed to start %s.";
 596                 else if (result == JOB_DEPENDENCY)
 597                         return "Dependency failed for %s.";
 598                 else if (result == JOB_TIMEOUT)
 599                         return "Timed out starting %s.";
 600         } else if (t == JOB_STOP || t == JOB_RESTART) {
 601                 if (result == JOB_DONE)
 602                         return "Stopped %s.";
 603                 else if (result == JOB_FAILED)
 604                         return "Stopped (with error) %s.";
 605                 else if (result == JOB_TIMEOUT)
 606                         return "Timed out stoppping %s.";
 607         } else if (t == JOB_RELOAD) {
 608                 if (result == JOB_DONE)
 609                         return "Reloaded %s.";
 610                 else if (result == JOB_FAILED)
 611                         return "Reload failed for %s.";
 612                 else if (result == JOB_TIMEOUT)
 613                         return "Timed out reloading %s.";
 614         }
 615
 616         return NULL;
 617 }
 618
 619 static void job_print_status_message(Unit *u, JobType t, JobResult result) {
 620         const char *format;
 621
 622         assert(u);
 623         assert(t >= 0);
 624         assert(t < _JOB_TYPE_MAX);
 625
 626         DISABLE_WARNING_FORMAT_NONLITERAL;
 627
 628         if (t == JOB_START) {
 629                 format = job_get_status_message_format(u, t, result);
 630                 if (!format)
 631                         return;
 632
 633                 switch (result) {
 634
 635                 case JOB_DONE:
 636                         if (u->condition_result)
 637                                 unit_status_printf(u, ANSI_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, format);
 638                         break;
 639
 640                 case JOB_FAILED: {
 641                         bool quotes;
 642
 643                         quotes = chars_intersect(u->id, SHELL_NEED_QUOTES);
 644
 645                         manager_flip_auto_status(u->manager, true);
 646                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, format);
 647                         manager_status_printf(u->manager, STATUS_TYPE_NORMAL, NULL,
 648                                               "See \"systemctl status %s%s%s\" for details.",
 649                                               quotes ? "'" : "", u->id, quotes ? "'" : "");
 650                         break;
 651                 }
 652
 653                 case JOB_DEPENDENCY:
 654                         manager_flip_auto_status(u->manager, true);
 655                         unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "DEPEND" ANSI_HIGHLIGHT_OFF, format);
 656                         break;
 657
 658                 case JOB_TIMEOUT:
 659                         manager_flip_auto_status(u->manager, true);
 660                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
 661                         break;
 662
 663                 case JOB_ASSERT:
 664                         manager_flip_auto_status(u->manager, true);
 665                         unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "ASSERT" ANSI_HIGHLIGHT_OFF, format);
 666                         break;
 667
 668                 default:
 669                         ;
 670                 }
 671
 672         } else if (t == JOB_STOP || t == JOB_RESTART) {
 673
 674                 format = job_get_status_message_format(u, t, result);
 675                 if (!format)
 676                         return;
 677
 678                 switch (result) {
 679
 680                 case JOB_TIMEOUT:
 681                         manager_flip_auto_status(u->manager, true);
 682                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
 683                         break;
 684
 685                 case JOB_DONE:
 686                 case JOB_FAILED:
 687                         unit_status_printf(u, ANSI_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, format);
 688                         break;
 689
 690                 default:
 691                         ;
 692                 }
 693
 694         } else if (t == JOB_VERIFY_ACTIVE) {
 695
 696                 /* When verify-active detects the unit is inactive, report it.
 697                  * Most likely a DEPEND warning from a requisiting unit will
 698                  * occur next and it's nice to see what was requisited. */
 699                 if (result == JOB_SKIPPED)
 700                         unit_status_printf(u, ANSI_HIGHLIGHT_ON " INFO " ANSI_HIGHLIGHT_OFF, "%s is not active.");
 701         }
 702
 703         REENABLE_WARNING;
 704 }
 705
 706 static void job_log_status_message(Unit *u, JobType t, JobResult result) {
 707         const char *format;
 708         char buf[LINE_MAX];
 709
 710         assert(u);
 711         assert(t >= 0);
 712         assert(t < _JOB_TYPE_MAX);
 713
 714         /* Skip this if it goes to the console. since we already print
 715          * to the console anyway... */
 716
 717         if (log_on_console())
 718                 return;
 719
 720         format = job_get_status_message_format_try_harder(u, t, result);
 721         if (!format)
 722                 return;
 723
 724         DISABLE_WARNING_FORMAT_NONLITERAL;
 725         snprintf(buf, sizeof(buf), format, unit_description(u));
 726         char_array_0(buf);
 727         REENABLE_WARNING;
 728
 729         if (t == JOB_START) {
 730                 sd_id128_t mid;
 731
 732                 mid = result == JOB_DONE ? SD_MESSAGE_UNIT_STARTED : SD_MESSAGE_UNIT_FAILED;
 733                 log_unit_struct(u->id,
 734                                 result == JOB_DONE ? LOG_INFO : LOG_ERR,
 735                                 LOG_MESSAGE_ID(mid),
 736                                 LOG_MESSAGE("%s", buf),
 737                                 "RESULT=%s", job_result_to_string(result),
 738                                 NULL);
 739
 740         } else if (t == JOB_STOP)
 741                 log_unit_struct(u->id,
 742                                 result == JOB_DONE ? LOG_INFO : LOG_ERR,
 743                                 LOG_MESSAGE_ID(SD_MESSAGE_UNIT_STOPPED),
 744                                 LOG_MESSAGE("%s", buf),
 745                                 "RESULT=%s", job_result_to_string(result),
 746                                 NULL);
 747
 748         else if (t == JOB_RELOAD)
 749                 log_unit_struct(u->id,
 750                                 result == JOB_DONE ? LOG_INFO : LOG_ERR,
 751                                 LOG_MESSAGE_ID(SD_MESSAGE_UNIT_RELOADED),
 752                                 LOG_MESSAGE("%s", buf),
 753                                 "RESULT=%s", job_result_to_string(result),
 754                                 NULL);
 755 }
 756
 757 int job_finish_and_invalidate(Job *j, JobResult result, bool recursive) {
 758         Unit *u;
 759         Unit *other;
 760         JobType t;
 761         Iterator i;
 762
 763         assert(j);
 764         assert(j->installed);
 765         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
 766
 767         u = j->unit;
 768         t = j->type;
 769
 770         j->result = result;
 771
 772         if (j->state == JOB_RUNNING)
 773                 j->manager->n_running_jobs--;
 774
 775         log_unit_debug(u->id, "Job %s/%s finished, result=%s",
 776                        u->id, job_type_to_string(t), job_result_to_string(result));
 777
 778         job_print_status_message(u, t, result);
 779         job_log_status_message(u, t, result);
 780
 781         job_add_to_dbus_queue(j);
 782
 783         /* Patch restart jobs so that they become normal start jobs */
 784         if (result == JOB_DONE && t == JOB_RESTART) {
 785
 786                 job_change_type(j, JOB_START);
 787                 j->state = JOB_WAITING;
 788
 789                 job_add_to_run_queue(j);
 790
 791                 goto finish;
 792         }
 793
 794         if (result == JOB_FAILED || result == JOB_INVALID)
 795                 j->manager->n_failed_jobs ++;
 796
 797         job_uninstall(j);
 798         job_free(j);
 799
 800         /* Fail depending jobs on failure */
 801         if (result != JOB_DONE && recursive) {
 802
 803                 if (t == JOB_START ||
 804                     t == JOB_VERIFY_ACTIVE) {
 805
 806                         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
 807                                 if (other->job &&
 808                                     (other->job->type == JOB_START ||
 809                                      other->job->type == JOB_VERIFY_ACTIVE))
 810                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 811
 812                         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
 813                                 if (other->job &&
 814                                     (other->job->type == JOB_START ||
 815                                      other->job->type == JOB_VERIFY_ACTIVE))
 816                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 817
 818                         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
 819                                 if (other->job &&
 820                                     !other->job->override &&
 821                                     (other->job->type == JOB_START ||
 822                                      other->job->type == JOB_VERIFY_ACTIVE))
 823                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 824
 825                 } else if (t == JOB_STOP) {
 826
 827                         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
 828                                 if (other->job &&
 829                                     (other->job->type == JOB_START ||
 830                                      other->job->type == JOB_VERIFY_ACTIVE))
 831                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
 832                 }
 833         }
 834
 835         /* Trigger OnFailure dependencies that are not generated by
 836          * the unit itself. We don't treat JOB_CANCELED as failure in
 837          * this context. And JOB_FAILURE is already handled by the
 838          * unit itself. */
 839         if (result == JOB_TIMEOUT || result == JOB_DEPENDENCY) {
 840                 log_unit_struct(u->id,
 841                                 LOG_NOTICE,
 842                                 "JOB_TYPE=%s", job_type_to_string(t),
 843                                 "JOB_RESULT=%s", job_result_to_string(result),
 844                                 LOG_MESSAGE("Job %s/%s failed with result '%s'.",
 845                                             u->id,
 846                                             job_type_to_string(t),
 847                                             job_result_to_string(result)),
 848                                 NULL);
 849
 850                 unit_start_on_failure(u);
 851         }
 852
 853         unit_trigger_notify(u);
 854
 855 finish:
 856         /* Try to start the next jobs that can be started */
 857         SET_FOREACH(other, u->dependencies[UNIT_AFTER], i)
 858                 if (other->job)
 859                         job_add_to_run_queue(other->job);
 860         SET_FOREACH(other, u->dependencies[UNIT_BEFORE], i)
 861                 if (other->job)
 862                         job_add_to_run_queue(other->job);
 863
 864         manager_check_finished(u->manager);
 865
 866         return 0;
 867 }
 868
 869 static int job_dispatch_timer(sd_event_source *s, uint64_t monotonic, void *userdata) {
 870         Job *j = userdata;
 871         Unit *u;
 872
 873         assert(j);
 874         assert(s == j->timer_event_source);
 875
 876         log_unit_warning(j->unit->id, "Job %s/%s timed out.", j->unit->id, job_type_to_string(j->type));
 877
 878         u = j->unit;
 879         job_finish_and_invalidate(j, JOB_TIMEOUT, true);
 880
 881         failure_action(u->manager, u->job_timeout_action, u->job_timeout_reboot_arg);
 882
 883         return 0;
 884 }
 885
 886 int job_start_timer(Job *j) {
 887         int r;
 888
 889         if (j->timer_event_source)
 890                 return 0;
 891
 892         j->begin_usec = now(CLOCK_MONOTONIC);
 893
 894         if (j->unit->job_timeout <= 0)
 895                 return 0;
 896
 897         r = sd_event_add_time(
 898                         j->manager->event,
 899                         &j->timer_event_source,
 900                         CLOCK_MONOTONIC,
 901                         j->begin_usec + j->unit->job_timeout, 0,
 902                         job_dispatch_timer, j);
 903         if (r < 0)
 904                 return r;
 905
 906         return 0;
 907 }
 908
 909 void job_add_to_run_queue(Job *j) {
 910         assert(j);
 911         assert(j->installed);
 912
 913         if (j->in_run_queue)
 914                 return;
 915
 916         if (!j->manager->run_queue)
 917                 sd_event_source_set_enabled(j->manager->run_queue_event_source, SD_EVENT_ONESHOT);
 918
 919         LIST_PREPEND(run_queue, j->manager->run_queue, j);
 920         j->in_run_queue = true;
 921 }
 922
 923 void job_add_to_dbus_queue(Job *j) {
 924         assert(j);
 925         assert(j->installed);
 926
 927         if (j->in_dbus_queue)
 928                 return;
 929
 930         /* We don't check if anybody is subscribed here, since this
 931          * job might just have been created and not yet assigned to a
 932          * connection/client. */
 933
 934         LIST_PREPEND(dbus_queue, j->manager->dbus_job_queue, j);
 935         j->in_dbus_queue = true;
 936 }
 937
 938 char *job_dbus_path(Job *j) {
 939         char *p;
 940
 941         assert(j);
 942
 943         if (asprintf(&p, "/org/freedesktop/systemd1/job/%"PRIu32, j->id) < 0)
 944                 return NULL;
 945
 946         return p;
 947 }
 948
 949 int job_serialize(Job *j, FILE *f, FDSet *fds) {
 950         fprintf(f, "job-id=%u\n", j->id);
 951         fprintf(f, "job-type=%s\n", job_type_to_string(j->type));
 952         fprintf(f, "job-state=%s\n", job_state_to_string(j->state));
 953         fprintf(f, "job-override=%s\n", yes_no(j->override));
 954         fprintf(f, "job-irreversible=%s\n", yes_no(j->irreversible));
 955         fprintf(f, "job-sent-dbus-new-signal=%s\n", yes_no(j->sent_dbus_new_signal));
 956         fprintf(f, "job-ignore-order=%s\n", yes_no(j->ignore_order));
 957
 958         if (j->begin_usec > 0)
 959                 fprintf(f, "job-begin="USEC_FMT"\n", j->begin_usec);
 960
 961         bus_track_serialize(j->clients, f);
 962
 963         /* End marker */
 964         fputc('\n', f);
 965         return 0;
 966 }
 967
 968 int job_deserialize(Job *j, FILE *f, FDSet *fds) {
 969         assert(j);
 970
 971         for (;;) {
 972                 char line[LINE_MAX], *l, *v;
 973                 size_t k;
 974
 975                 if (!fgets(line, sizeof(line), f)) {
 976                         if (feof(f))
 977                                 return 0;
 978                         return -errno;
 979                 }
 980
 981                 char_array_0(line);
 982                 l = strstrip(line);
 983
 984                 /* End marker */
 985                 if (l[0] == 0)
 986                         return 0;
 987
 988                 k = strcspn(l, "=");
 989
 990                 if (l[k] == '=') {
 991                         l[k] = 0;
 992                         v = l+k+1;
 993                 } else
 994                         v = l+k;
 995
 996                 if (streq(l, "job-id")) {
 997
 998                         if (safe_atou32(v, &j->id) < 0)
 999                                 log_debug("Failed to parse job id value %s", v);
1000
1001                 } else if (streq(l, "job-type")) {
1002                         JobType t;
1003
1004                         t = job_type_from_string(v);
1005                         if (t < 0)
1006                                 log_debug("Failed to parse job type %s", v);
1007                         else if (t >= _JOB_TYPE_MAX_IN_TRANSACTION)
1008                                 log_debug("Cannot deserialize job of type %s", v);
1009                         else
1010                                 j->type = t;
1011
1012                 } else if (streq(l, "job-state")) {
1013                         JobState s;
1014
1015                         s = job_state_from_string(v);
1016                         if (s < 0)
1017                                 log_debug("Failed to parse job state %s", v);
1018                         else
1019                                 j->state = s;
1020
1021                 } else if (streq(l, "job-override")) {
1022                         int b;
1023
1024                         b = parse_boolean(v);
1025                         if (b < 0)
1026                                 log_debug("Failed to parse job override flag %s", v);
1027                         else
1028                                 j->override = j->override || b;
1029
1030                 } else if (streq(l, "job-irreversible")) {
1031                         int b;
1032
1033                         b = parse_boolean(v);
1034                         if (b < 0)
1035                                 log_debug("Failed to parse job irreversible flag %s", v);
1036                         else
1037                                 j->irreversible = j->irreversible || b;
1038
1039                 } else if (streq(l, "job-sent-dbus-new-signal")) {
1040                         int b;
1041
1042                         b = parse_boolean(v);
1043                         if (b < 0)
1044                                 log_debug("Failed to parse job sent_dbus_new_signal flag %s", v);
1045                         else
1046                                 j->sent_dbus_new_signal = j->sent_dbus_new_signal || b;
1047
1048                 } else if (streq(l, "job-ignore-order")) {
1049                         int b;
1050
1051                         b = parse_boolean(v);
1052                         if (b < 0)
1053                                 log_debug("Failed to parse job ignore_order flag %s", v);
1054                         else
1055                                 j->ignore_order = j->ignore_order || b;
1056
1057                 } else if (streq(l, "job-begin")) {
1058                         unsigned long long ull;
1059
1060                         if (sscanf(v, "%llu", &ull) != 1)
1061                                 log_debug("Failed to parse job-begin value %s", v);
1062                         else
1063                                 j->begin_usec = ull;
1064
1065                 } else if (streq(l, "subscribed")) {
1066
1067                         if (strv_extend(&j->deserialized_clients, v) < 0)
1068                                 return log_oom();
1069                 }
1070         }
1071 }
1072
1073 int job_coldplug(Job *j) {
1074         int r;
1075
1076         assert(j);
1077
1078         /* After deserialization is complete and the bus connection
1079          * set up again, let's start watching our subscribers again */
1080         r = bus_track_coldplug(j->manager, &j->clients, &j->deserialized_clients);
1081         if (r < 0)
1082                 return r;
1083
1084         if (j->state == JOB_WAITING)
1085                 job_add_to_run_queue(j);
1086
1087         if (j->begin_usec == 0 || j->unit->job_timeout == 0)
1088                 return 0;
1089
1090         if (j->timer_event_source)
1091                 j->timer_event_source = sd_event_source_unref(j->timer_event_source);
1092
1093         r = sd_event_add_time(
1094                         j->manager->event,
1095                         &j->timer_event_source,
1096                         CLOCK_MONOTONIC,
1097                         j->begin_usec + j->unit->job_timeout, 0,
1098                         job_dispatch_timer, j);
1099         if (r < 0)
1100                 log_debug("Failed to restart timeout for job: %s", strerror(-r));
1101
1102         return r;
1103 }
1104
1105 void job_shutdown_magic(Job *j) {
1106         assert(j);
1107
1108         /* The shutdown target gets some special treatment here: we
1109          * tell the kernel to begin with flushing its disk caches, to
1110          * optimize shutdown time a bit. Ideally we wouldn't hardcode
1111          * this magic into PID 1. However all other processes aren't
1112          * options either since they'd exit much sooner than PID 1 and
1113          * asynchronous sync() would cause their exit to be
1114          * delayed. */
1115
1116         if (j->type != JOB_START)
1117                 return;
1118
1119         if (j->unit->manager->running_as != SYSTEMD_SYSTEM)
1120                 return;
1121
1122         if (!unit_has_name(j->unit, SPECIAL_SHUTDOWN_TARGET))
1123                 return;
1124
1125         /* In case messages on console has been disabled on boot */
1126         j->unit->manager->no_console_output = false;
1127
1128         if (detect_container(NULL) > 0)
1129                 return;
1130
1131         asynchronous_sync();
1132 }
1133
1134 int job_get_timeout(Job *j, uint64_t *timeout) {
1135         Unit *u = j->unit;
1136         uint64_t x = -1, y = -1;
1137         int r = 0, q = 0;
1138
1139         assert(u);
1140
1141         if (j->timer_event_source) {
1142                 r = sd_event_source_get_time(j->timer_event_source, &x);
1143                 if (r < 0)
1144                         return r;
1145                 r = 1;
1146         }
1147
1148         if (UNIT_VTABLE(u)->get_timeout) {
1149                 q = UNIT_VTABLE(u)->get_timeout(u, &y);
1150                 if (q < 0)
1151                         return q;
1152         }
1153
1154         if (r == 0 && q == 0)
1155                 return 0;
1156
1157         *timeout = MIN(x, y);
1158
1159         return 1;
1160 }
1161
1162 static const char* const job_state_table[_JOB_STATE_MAX] = {
1163         [JOB_WAITING] = "waiting",
1164         [JOB_RUNNING] = "running"
1165 };
1166
1167 DEFINE_STRING_TABLE_LOOKUP(job_state, JobState);
1168
1169 static const char* const job_type_table[_JOB_TYPE_MAX] = {
1170         [JOB_START] = "start",
1171         [JOB_VERIFY_ACTIVE] = "verify-active",
1172         [JOB_STOP] = "stop",
1173         [JOB_RELOAD] = "reload",
1174         [JOB_RELOAD_OR_START] = "reload-or-start",
1175         [JOB_RESTART] = "restart",
1176         [JOB_TRY_RESTART] = "try-restart",
1177         [JOB_NOP] = "nop",
1178 };
1179
1180 DEFINE_STRING_TABLE_LOOKUP(job_type, JobType);
1181
1182 static const char* const job_mode_table[_JOB_MODE_MAX] = {
1183         [JOB_FAIL] = "fail",
1184         [JOB_REPLACE] = "replace",
1185         [JOB_REPLACE_IRREVERSIBLY] = "replace-irreversibly",
1186         [JOB_ISOLATE] = "isolate",
1187         [JOB_FLUSH] = "flush",
1188         [JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies",
1189         [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements",
1190 };
1191
1192 DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);
1193
1194 static const char* const job_result_table[_JOB_RESULT_MAX] = {
1195         [JOB_DONE] = "done",
1196         [JOB_CANCELED] = "canceled",
1197         [JOB_TIMEOUT] = "timeout",
1198         [JOB_FAILED] = "failed",
1199         [JOB_DEPENDENCY] = "dependency",
1200         [JOB_SKIPPED] = "skipped",
1201         [JOB_INVALID] = "invalid",
1202         [JOB_ASSERT] = "assert",
1203 };
1204
1205 DEFINE_STRING_TABLE_LOOKUP(job_result, JobResult);