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