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