src/core/unit.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 <string.h>
  25 #include <sys/epoll.h>
  26 #include <sys/timerfd.h>
  27 #include <sys/poll.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31
  32 #include "systemd/sd-id128.h"
  33 #include "systemd/sd-messages.h"
  34 #include "set.h"
  35 #include "unit.h"
  36 #include "macro.h"
  37 #include "strv.h"
  38 #include "path-util.h"
  39 #include "load-fragment.h"
  40 #include "load-dropin.h"
  41 #include "log.h"
  42 #include "unit-name.h"
  43 #include "dbus-unit.h"
  44 #include "special.h"
  45 #include "cgroup-util.h"
  46 #include "missing.h"
  47 #include "cgroup-attr.h"
  48 #include "mkdir.h"
  49 #include "label.h"
  50 #include "fileio-label.h"
  51
  52 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
  53         [UNIT_SERVICE] = &service_vtable,
  54         [UNIT_TIMER] = &timer_vtable,
  55         [UNIT_SOCKET] = &socket_vtable,
  56         [UNIT_TARGET] = &target_vtable,
  57         [UNIT_DEVICE] = &device_vtable,
  58         [UNIT_MOUNT] = &mount_vtable,
  59         [UNIT_AUTOMOUNT] = &automount_vtable,
  60         [UNIT_SNAPSHOT] = &snapshot_vtable,
  61         [UNIT_SWAP] = &swap_vtable,
  62         [UNIT_PATH] = &path_vtable
  63 };
  64
  65 Unit *unit_new(Manager *m, size_t size) {
  66         Unit *u;
  67
  68         assert(m);
  69         assert(size >= sizeof(Unit));
  70
  71         u = malloc0(size);
  72         if (!u)
  73                 return NULL;
  74
  75         u->names = set_new(string_hash_func, string_compare_func);
  76         if (!u->names) {
  77                 free(u);
  78                 return NULL;
  79         }
  80
  81         u->manager = m;
  82         u->type = _UNIT_TYPE_INVALID;
  83         u->deserialized_job = _JOB_TYPE_INVALID;
  84         u->default_dependencies = true;
  85         u->unit_file_state = _UNIT_FILE_STATE_INVALID;
  86
  87         return u;
  88 }
  89
  90 bool unit_has_name(Unit *u, const char *name) {
  91         assert(u);
  92         assert(name);
  93
  94         return !!set_get(u->names, (char*) name);
  95 }
  96
  97 int unit_add_name(Unit *u, const char *text) {
  98         UnitType t;
  99         char *s, *i = NULL;
 100         int r;
 101
 102         assert(u);
 103         assert(text);
 104
 105         if (unit_name_is_template(text)) {
 106                 if (!u->instance)
 107                         return -EINVAL;
 108
 109                 s = unit_name_replace_instance(text, u->instance);
 110         } else
 111                 s = strdup(text);
 112
 113         if (!s)
 114                 return -ENOMEM;
 115
 116         if (!unit_name_is_valid(s, false)) {
 117                 r = -EINVAL;
 118                 goto fail;
 119         }
 120
 121         assert_se((t = unit_name_to_type(s)) >= 0);
 122
 123         if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
 124                 r = -EINVAL;
 125                 goto fail;
 126         }
 127
 128         if ((r = unit_name_to_instance(s, &i)) < 0)
 129                 goto fail;
 130
 131         if (i && unit_vtable[t]->no_instances) {
 132                 r = -EINVAL;
 133                 goto fail;
 134         }
 135
 136         /* Ensure that this unit is either instanced or not instanced,
 137          * but not both. */
 138         if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
 139                 r = -EINVAL;
 140                 goto fail;
 141         }
 142
 143         if (unit_vtable[t]->no_alias &&
 144             !set_isempty(u->names) &&
 145             !set_get(u->names, s)) {
 146                 r = -EEXIST;
 147                 goto fail;
 148         }
 149
 150         if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
 151                 r = -E2BIG;
 152                 goto fail;
 153         }
 154
 155         if ((r = set_put(u->names, s)) < 0) {
 156                 if (r == -EEXIST)
 157                         r = 0;
 158                 goto fail;
 159         }
 160
 161         if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
 162                 set_remove(u->names, s);
 163                 goto fail;
 164         }
 165
 166         if (u->type == _UNIT_TYPE_INVALID) {
 167
 168                 u->type = t;
 169                 u->id = s;
 170                 u->instance = i;
 171
 172                 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
 173
 174                 if (UNIT_VTABLE(u)->init)
 175                         UNIT_VTABLE(u)->init(u);
 176         } else
 177                 free(i);
 178
 179         unit_add_to_dbus_queue(u);
 180         return 0;
 181
 182 fail:
 183         free(s);
 184         free(i);
 185
 186         return r;
 187 }
 188
 189 int unit_choose_id(Unit *u, const char *name) {
 190         char *s, *t = NULL, *i;
 191         int r;
 192
 193         assert(u);
 194         assert(name);
 195
 196         if (unit_name_is_template(name)) {
 197
 198                 if (!u->instance)
 199                         return -EINVAL;
 200
 201                 if (!(t = unit_name_replace_instance(name, u->instance)))
 202                         return -ENOMEM;
 203
 204                 name = t;
 205         }
 206
 207         /* Selects one of the names of this unit as the id */
 208         s = set_get(u->names, (char*) name);
 209         free(t);
 210
 211         if (!s)
 212                 return -ENOENT;
 213
 214         if ((r = unit_name_to_instance(s, &i)) < 0)
 215                 return r;
 216
 217         u->id = s;
 218
 219         free(u->instance);
 220         u->instance = i;
 221
 222         unit_add_to_dbus_queue(u);
 223
 224         return 0;
 225 }
 226
 227 int unit_set_description(Unit *u, const char *description) {
 228         char *s;
 229
 230         assert(u);
 231
 232         if (!(s = strdup(description)))
 233                 return -ENOMEM;
 234
 235         free(u->description);
 236         u->description = s;
 237
 238         unit_add_to_dbus_queue(u);
 239         return 0;
 240 }
 241
 242 bool unit_check_gc(Unit *u) {
 243         assert(u);
 244
 245         if (u->load_state == UNIT_STUB)
 246                 return true;
 247
 248         if (UNIT_VTABLE(u)->no_gc)
 249                 return true;
 250
 251         if (u->no_gc)
 252                 return true;
 253
 254         if (u->job)
 255                 return true;
 256
 257         if (u->nop_job)
 258                 return true;
 259
 260         if (unit_active_state(u) != UNIT_INACTIVE)
 261                 return true;
 262
 263         if (u->refs)
 264                 return true;
 265
 266         if (UNIT_VTABLE(u)->check_gc)
 267                 if (UNIT_VTABLE(u)->check_gc(u))
 268                         return true;
 269
 270         return false;
 271 }
 272
 273 void unit_add_to_load_queue(Unit *u) {
 274         assert(u);
 275         assert(u->type != _UNIT_TYPE_INVALID);
 276
 277         if (u->load_state != UNIT_STUB || u->in_load_queue)
 278                 return;
 279
 280         LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
 281         u->in_load_queue = true;
 282 }
 283
 284 void unit_add_to_cleanup_queue(Unit *u) {
 285         assert(u);
 286
 287         if (u->in_cleanup_queue)
 288                 return;
 289
 290         LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
 291         u->in_cleanup_queue = true;
 292 }
 293
 294 void unit_add_to_gc_queue(Unit *u) {
 295         assert(u);
 296
 297         if (u->in_gc_queue || u->in_cleanup_queue)
 298                 return;
 299
 300         if (unit_check_gc(u))
 301                 return;
 302
 303         LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
 304         u->in_gc_queue = true;
 305
 306         u->manager->n_in_gc_queue ++;
 307
 308         if (u->manager->gc_queue_timestamp <= 0)
 309                 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
 310 }
 311
 312 void unit_add_to_dbus_queue(Unit *u) {
 313         assert(u);
 314         assert(u->type != _UNIT_TYPE_INVALID);
 315
 316         if (u->load_state == UNIT_STUB || u->in_dbus_queue)
 317                 return;
 318
 319         /* Shortcut things if nobody cares */
 320         if (!bus_has_subscriber(u->manager)) {
 321                 u->sent_dbus_new_signal = true;
 322                 return;
 323         }
 324
 325         LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
 326         u->in_dbus_queue = true;
 327 }
 328
 329 static void bidi_set_free(Unit *u, Set *s) {
 330         Iterator i;
 331         Unit *other;
 332
 333         assert(u);
 334
 335         /* Frees the set and makes sure we are dropped from the
 336          * inverse pointers */
 337
 338         SET_FOREACH(other, s, i) {
 339                 UnitDependency d;
 340
 341                 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 342                         set_remove(other->dependencies[d], u);
 343
 344                 unit_add_to_gc_queue(other);
 345         }
 346
 347         set_free(s);
 348 }
 349
 350 void unit_free(Unit *u) {
 351         UnitDependency d;
 352         Iterator i;
 353         char *t;
 354
 355         assert(u);
 356
 357         bus_unit_send_removed_signal(u);
 358
 359         if (u->load_state != UNIT_STUB)
 360                 if (UNIT_VTABLE(u)->done)
 361                         UNIT_VTABLE(u)->done(u);
 362
 363         SET_FOREACH(t, u->names, i)
 364                 hashmap_remove_value(u->manager->units, t, u);
 365
 366         if (u->job) {
 367                 Job *j = u->job;
 368                 job_uninstall(j);
 369                 job_free(j);
 370         }
 371
 372         if (u->nop_job) {
 373                 Job *j = u->nop_job;
 374                 job_uninstall(j);
 375                 job_free(j);
 376         }
 377
 378         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 379                 bidi_set_free(u, u->dependencies[d]);
 380
 381         if (u->requires_mounts_for) {
 382                 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
 383                 strv_free(u->requires_mounts_for);
 384         }
 385
 386         if (u->type != _UNIT_TYPE_INVALID)
 387                 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
 388
 389         if (u->in_load_queue)
 390                 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
 391
 392         if (u->in_dbus_queue)
 393                 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
 394
 395         if (u->in_cleanup_queue)
 396                 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
 397
 398         if (u->in_gc_queue) {
 399                 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
 400                 u->manager->n_in_gc_queue--;
 401         }
 402
 403         cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
 404         cgroup_attribute_free_list(u->cgroup_attributes);
 405
 406         free(u->description);
 407         strv_free(u->documentation);
 408         free(u->fragment_path);
 409         free(u->source_path);
 410         free(u->instance);
 411
 412         set_free_free(u->names);
 413
 414         condition_free_list(u->conditions);
 415
 416         while (u->refs)
 417                 unit_ref_unset(u->refs);
 418
 419         free(u);
 420 }
 421
 422 UnitActiveState unit_active_state(Unit *u) {
 423         assert(u);
 424
 425         if (u->load_state == UNIT_MERGED)
 426                 return unit_active_state(unit_follow_merge(u));
 427
 428         /* After a reload it might happen that a unit is not correctly
 429          * loaded but still has a process around. That's why we won't
 430          * shortcut failed loading to UNIT_INACTIVE_FAILED. */
 431
 432         return UNIT_VTABLE(u)->active_state(u);
 433 }
 434
 435 const char* unit_sub_state_to_string(Unit *u) {
 436         assert(u);
 437
 438         return UNIT_VTABLE(u)->sub_state_to_string(u);
 439 }
 440
 441 static void complete_move(Set **s, Set **other) {
 442         assert(s);
 443         assert(other);
 444
 445         if (!*other)
 446                 return;
 447
 448         if (*s)
 449                 set_move(*s, *other);
 450         else {
 451                 *s = *other;
 452                 *other = NULL;
 453         }
 454 }
 455
 456 static void merge_names(Unit *u, Unit *other) {
 457         char *t;
 458         Iterator i;
 459
 460         assert(u);
 461         assert(other);
 462
 463         complete_move(&u->names, &other->names);
 464
 465         set_free_free(other->names);
 466         other->names = NULL;
 467         other->id = NULL;
 468
 469         SET_FOREACH(t, u->names, i)
 470                 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
 471 }
 472
 473 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
 474         Iterator i;
 475         Unit *back;
 476         int r;
 477
 478         assert(u);
 479         assert(other);
 480         assert(d < _UNIT_DEPENDENCY_MAX);
 481
 482         /* Fix backwards pointers */
 483         SET_FOREACH(back, other->dependencies[d], i) {
 484                 UnitDependency k;
 485
 486                 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
 487                         if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
 488
 489                                 if (r == -EEXIST)
 490                                         set_remove(back->dependencies[k], other);
 491                                 else
 492                                         assert(r == -ENOENT);
 493                         }
 494         }
 495
 496         complete_move(&u->dependencies[d], &other->dependencies[d]);
 497
 498         set_free(other->dependencies[d]);
 499         other->dependencies[d] = NULL;
 500 }
 501
 502 int unit_merge(Unit *u, Unit *other) {
 503         UnitDependency d;
 504
 505         assert(u);
 506         assert(other);
 507         assert(u->manager == other->manager);
 508         assert(u->type != _UNIT_TYPE_INVALID);
 509
 510         other = unit_follow_merge(other);
 511
 512         if (other == u)
 513                 return 0;
 514
 515         if (u->type != other->type)
 516                 return -EINVAL;
 517
 518         if (!u->instance != !other->instance)
 519                 return -EINVAL;
 520
 521         if (other->load_state != UNIT_STUB &&
 522             other->load_state != UNIT_ERROR)
 523                 return -EEXIST;
 524
 525         if (other->job)
 526                 return -EEXIST;
 527
 528         if (other->nop_job)
 529                 return -EEXIST;
 530
 531         if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
 532                 return -EEXIST;
 533
 534         /* Merge names */
 535         merge_names(u, other);
 536
 537         /* Redirect all references */
 538         while (other->refs)
 539                 unit_ref_set(other->refs, u);
 540
 541         /* Merge dependencies */
 542         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 543                 merge_dependencies(u, other, d);
 544
 545         other->load_state = UNIT_MERGED;
 546         other->merged_into = u;
 547
 548         /* If there is still some data attached to the other node, we
 549          * don't need it anymore, and can free it. */
 550         if (other->load_state != UNIT_STUB)
 551                 if (UNIT_VTABLE(other)->done)
 552                         UNIT_VTABLE(other)->done(other);
 553
 554         unit_add_to_dbus_queue(u);
 555         unit_add_to_cleanup_queue(other);
 556
 557         return 0;
 558 }
 559
 560 int unit_merge_by_name(Unit *u, const char *name) {
 561         Unit *other;
 562         int r;
 563         char *s = NULL;
 564
 565         assert(u);
 566         assert(name);
 567
 568         if (unit_name_is_template(name)) {
 569                 if (!u->instance)
 570                         return -EINVAL;
 571
 572                 if (!(s = unit_name_replace_instance(name, u->instance)))
 573                         return -ENOMEM;
 574
 575                 name = s;
 576         }
 577
 578         if (!(other = manager_get_unit(u->manager, name)))
 579                 r = unit_add_name(u, name);
 580         else
 581                 r = unit_merge(u, other);
 582
 583         free(s);
 584         return r;
 585 }
 586
 587 Unit* unit_follow_merge(Unit *u) {
 588         assert(u);
 589
 590         while (u->load_state == UNIT_MERGED)
 591                 assert_se(u = u->merged_into);
 592
 593         return u;
 594 }
 595
 596 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
 597         int r;
 598
 599         assert(u);
 600         assert(c);
 601
 602         if (c->std_output != EXEC_OUTPUT_KMSG &&
 603             c->std_output != EXEC_OUTPUT_SYSLOG &&
 604             c->std_output != EXEC_OUTPUT_JOURNAL &&
 605             c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 606             c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
 607             c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 608             c->std_error != EXEC_OUTPUT_KMSG &&
 609             c->std_error != EXEC_OUTPUT_SYSLOG &&
 610             c->std_error != EXEC_OUTPUT_JOURNAL &&
 611             c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 612             c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 613             c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
 614                 return 0;
 615
 616         /* If syslog or kernel logging is requested, make sure our own
 617          * logging daemon is run first. */
 618
 619         if (u->manager->running_as == SYSTEMD_SYSTEM) {
 620                 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
 621                 if (r < 0)
 622                         return r;
 623         }
 624
 625         return 0;
 626 }
 627
 628 const char *unit_description(Unit *u) {
 629         assert(u);
 630
 631         if (u->description)
 632                 return u->description;
 633
 634         return strna(u->id);
 635 }
 636
 637 void unit_dump(Unit *u, FILE *f, const char *prefix) {
 638         char *t, **j;
 639         UnitDependency d;
 640         Iterator i;
 641         char *p2;
 642         const char *prefix2;
 643         char
 644                 timestamp1[FORMAT_TIMESTAMP_MAX],
 645                 timestamp2[FORMAT_TIMESTAMP_MAX],
 646                 timestamp3[FORMAT_TIMESTAMP_MAX],
 647                 timestamp4[FORMAT_TIMESTAMP_MAX],
 648                 timespan[FORMAT_TIMESPAN_MAX];
 649         Unit *following;
 650
 651         assert(u);
 652         assert(u->type >= 0);
 653
 654         if (!prefix)
 655                 prefix = "";
 656         p2 = strappend(prefix, "\t");
 657         prefix2 = p2 ? p2 : prefix;
 658
 659         fprintf(f,
 660                 "%s-> Unit %s:\n"
 661                 "%s\tDescription: %s\n"
 662                 "%s\tInstance: %s\n"
 663                 "%s\tUnit Load State: %s\n"
 664                 "%s\tUnit Active State: %s\n"
 665                 "%s\tInactive Exit Timestamp: %s\n"
 666                 "%s\tActive Enter Timestamp: %s\n"
 667                 "%s\tActive Exit Timestamp: %s\n"
 668                 "%s\tInactive Enter Timestamp: %s\n"
 669                 "%s\tGC Check Good: %s\n"
 670                 "%s\tNeed Daemon Reload: %s\n",
 671                 prefix, u->id,
 672                 prefix, unit_description(u),
 673                 prefix, strna(u->instance),
 674                 prefix, unit_load_state_to_string(u->load_state),
 675                 prefix, unit_active_state_to_string(unit_active_state(u)),
 676                 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
 677                 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
 678                 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
 679                 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
 680                 prefix, yes_no(unit_check_gc(u)),
 681                 prefix, yes_no(unit_need_daemon_reload(u)));
 682
 683         SET_FOREACH(t, u->names, i)
 684                 fprintf(f, "%s\tName: %s\n", prefix, t);
 685
 686         STRV_FOREACH(j, u->documentation)
 687                 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
 688
 689         if ((following = unit_following(u)))
 690                 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
 691
 692         if (u->fragment_path)
 693                 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
 694
 695         if (u->source_path)
 696                 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
 697
 698         if (u->job_timeout > 0)
 699                 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
 700
 701         condition_dump_list(u->conditions, f, prefix);
 702
 703         if (dual_timestamp_is_set(&u->condition_timestamp))
 704                 fprintf(f,
 705                         "%s\tCondition Timestamp: %s\n"
 706                         "%s\tCondition Result: %s\n",
 707                         prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
 708                         prefix, yes_no(u->condition_result));
 709
 710         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
 711                 Unit *other;
 712
 713                 SET_FOREACH(other, u->dependencies[d], i)
 714                         fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
 715         }
 716
 717         if (!strv_isempty(u->requires_mounts_for)) {
 718                 fprintf(f,
 719                         "%s\tRequiresMountsFor:", prefix);
 720
 721                 STRV_FOREACH(j, u->requires_mounts_for)
 722                         fprintf(f, " %s", *j);
 723
 724                 fputs("\n", f);
 725         }
 726
 727         if (u->load_state == UNIT_LOADED) {
 728                 CGroupBonding *b;
 729                 CGroupAttribute *a;
 730
 731                 fprintf(f,
 732                         "%s\tStopWhenUnneeded: %s\n"
 733                         "%s\tRefuseManualStart: %s\n"
 734                         "%s\tRefuseManualStop: %s\n"
 735                         "%s\tDefaultDependencies: %s\n"
 736                         "%s\tOnFailureIsolate: %s\n"
 737                         "%s\tIgnoreOnIsolate: %s\n"
 738                         "%s\tIgnoreOnSnapshot: %s\n",
 739                         prefix, yes_no(u->stop_when_unneeded),
 740                         prefix, yes_no(u->refuse_manual_start),
 741                         prefix, yes_no(u->refuse_manual_stop),
 742                         prefix, yes_no(u->default_dependencies),
 743                         prefix, yes_no(u->on_failure_isolate),
 744                         prefix, yes_no(u->ignore_on_isolate),
 745                         prefix, yes_no(u->ignore_on_snapshot));
 746
 747                 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
 748                         fprintf(f, "%s\tControlGroup: %s:%s\n",
 749                                 prefix, b->controller, b->path);
 750
 751                 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
 752                         char *v = NULL;
 753
 754                         if (a->map_callback)
 755                                 a->map_callback(a->controller, a->name, a->value, &v);
 756
 757                         fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
 758                                 prefix, a->controller, a->name, v ? v : a->value);
 759
 760                         free(v);
 761                 }
 762
 763                 if (UNIT_VTABLE(u)->dump)
 764                         UNIT_VTABLE(u)->dump(u, f, prefix2);
 765
 766         } else if (u->load_state == UNIT_MERGED)
 767                 fprintf(f,
 768                         "%s\tMerged into: %s\n",
 769                         prefix, u->merged_into->id);
 770         else if (u->load_state == UNIT_ERROR)
 771                 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
 772
 773
 774         if (u->job)
 775                 job_dump(u->job, f, prefix2);
 776
 777         if (u->nop_job)
 778                 job_dump(u->nop_job, f, prefix2);
 779
 780         free(p2);
 781 }
 782
 783 /* Common implementation for multiple backends */
 784 int unit_load_fragment_and_dropin(Unit *u) {
 785         int r;
 786
 787         assert(u);
 788
 789         /* Load a .service file */
 790         if ((r = unit_load_fragment(u)) < 0)
 791                 return r;
 792
 793         if (u->load_state == UNIT_STUB)
 794                 return -ENOENT;
 795
 796         /* Load drop-in directory data */
 797         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
 798                 return r;
 799
 800         return 0;
 801 }
 802
 803 /* Common implementation for multiple backends */
 804 int unit_load_fragment_and_dropin_optional(Unit *u) {
 805         int r;
 806
 807         assert(u);
 808
 809         /* Same as unit_load_fragment_and_dropin(), but whether
 810          * something can be loaded or not doesn't matter. */
 811
 812         /* Load a .service file */
 813         if ((r = unit_load_fragment(u)) < 0)
 814                 return r;
 815
 816         if (u->load_state == UNIT_STUB)
 817                 u->load_state = UNIT_LOADED;
 818
 819         /* Load drop-in directory data */
 820         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
 821                 return r;
 822
 823         return 0;
 824 }
 825
 826 int unit_add_default_target_dependency(Unit *u, Unit *target) {
 827         assert(u);
 828         assert(target);
 829
 830         if (target->type != UNIT_TARGET)
 831                 return 0;
 832
 833         /* Only add the dependency if both units are loaded, so that
 834          * that loop check below is reliable */
 835         if (u->load_state != UNIT_LOADED ||
 836             target->load_state != UNIT_LOADED)
 837                 return 0;
 838
 839         /* If either side wants no automatic dependencies, then let's
 840          * skip this */
 841         if (!u->default_dependencies ||
 842             !target->default_dependencies)
 843                 return 0;
 844
 845         /* Don't create loops */
 846         if (set_get(target->dependencies[UNIT_BEFORE], u))
 847                 return 0;
 848
 849         return unit_add_dependency(target, UNIT_AFTER, u, true);
 850 }
 851
 852 static int unit_add_default_dependencies(Unit *u) {
 853         static const UnitDependency deps[] = {
 854                 UNIT_REQUIRED_BY,
 855                 UNIT_REQUIRED_BY_OVERRIDABLE,
 856                 UNIT_WANTED_BY,
 857                 UNIT_BOUND_BY
 858         };
 859
 860         Unit *target;
 861         Iterator i;
 862         int r;
 863         unsigned k;
 864
 865         assert(u);
 866
 867         for (k = 0; k < ELEMENTSOF(deps); k++)
 868                 SET_FOREACH(target, u->dependencies[deps[k]], i)
 869                         if ((r = unit_add_default_target_dependency(u, target)) < 0)
 870                                 return r;
 871
 872         return 0;
 873 }
 874
 875 int unit_load(Unit *u) {
 876         int r;
 877
 878         assert(u);
 879
 880         if (u->in_load_queue) {
 881                 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
 882                 u->in_load_queue = false;
 883         }
 884
 885         if (u->type == _UNIT_TYPE_INVALID)
 886                 return -EINVAL;
 887
 888         if (u->load_state != UNIT_STUB)
 889                 return 0;
 890
 891         if (UNIT_VTABLE(u)->load)
 892                 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
 893                         goto fail;
 894
 895         if (u->load_state == UNIT_STUB) {
 896                 r = -ENOENT;
 897                 goto fail;
 898         }
 899
 900         if (u->load_state == UNIT_LOADED &&
 901             u->default_dependencies)
 902                 if ((r = unit_add_default_dependencies(u)) < 0)
 903                         goto fail;
 904
 905         if (u->load_state == UNIT_LOADED) {
 906                 r = unit_add_mount_links(u);
 907                 if (r < 0)
 908                         return r;
 909         }
 910
 911         if (u->on_failure_isolate &&
 912             set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
 913
 914                 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
 915                           u->id);
 916
 917                 r = -EINVAL;
 918                 goto fail;
 919         }
 920
 921         assert((u->load_state != UNIT_MERGED) == !u->merged_into);
 922
 923         unit_add_to_dbus_queue(unit_follow_merge(u));
 924         unit_add_to_gc_queue(u);
 925
 926         return 0;
 927
 928 fail:
 929         u->load_state = UNIT_ERROR;
 930         u->load_error = r;
 931         unit_add_to_dbus_queue(u);
 932         unit_add_to_gc_queue(u);
 933
 934         log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
 935
 936         return r;
 937 }
 938
 939 bool unit_condition_test(Unit *u) {
 940         assert(u);
 941
 942         dual_timestamp_get(&u->condition_timestamp);
 943         u->condition_result = condition_test_list(u->conditions);
 944
 945         return u->condition_result;
 946 }
 947
 948 static const char* unit_get_status_message_format(Unit *u, JobType t) {
 949         const UnitStatusMessageFormats *format_table;
 950
 951         assert(u);
 952         assert(t >= 0);
 953         assert(t < _JOB_TYPE_MAX);
 954
 955         if (t != JOB_START && t != JOB_STOP)
 956                 return NULL;
 957
 958         format_table = &UNIT_VTABLE(u)->status_message_formats;
 959         if (!format_table)
 960                 return NULL;
 961
 962         return format_table->starting_stopping[t == JOB_STOP];
 963 }
 964
 965 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
 966         const char *format;
 967
 968         assert(u);
 969         assert(t >= 0);
 970         assert(t < _JOB_TYPE_MAX);
 971
 972         format = unit_get_status_message_format(u, t);
 973         if (format)
 974                 return format;
 975
 976         /* Return generic strings */
 977         if (t == JOB_START)
 978                 return "Starting %s.";
 979         else if (t == JOB_STOP)
 980                 return "Stopping %s.";
 981         else if (t == JOB_RELOAD)
 982                 return "Reloading %s.";
 983
 984         return NULL;
 985 }
 986
 987 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
 988         const char *format;
 989
 990         assert(u);
 991
 992         /* We only print status messages for selected units on
 993          * selected operations. */
 994
 995         format = unit_get_status_message_format(u, t);
 996         if (!format)
 997                 return;
 998
 999         unit_status_printf(u, "", format, unit_description(u));
1000 }
1001
1002 #pragma GCC diagnostic push
1003 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1004 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1005         const char *format;
1006         char buf[LINE_MAX];
1007         sd_id128_t mid;
1008
1009         assert(u);
1010
1011         if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1012                 return;
1013
1014         if (log_on_console())
1015                 return;
1016
1017         /* We log status messages for all units and all operations. */
1018
1019         format = unit_get_status_message_format_try_harder(u, t);
1020         if (!format)
1021                 return;
1022
1023         snprintf(buf, sizeof(buf), format, unit_description(u));
1024         char_array_0(buf);
1025
1026         mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1027               t == JOB_STOP  ? SD_MESSAGE_UNIT_STOPPING :
1028                                SD_MESSAGE_UNIT_RELOADING;
1029
1030         log_struct_unit(LOG_INFO,
1031                    u->id,
1032                    MESSAGE_ID(mid),
1033                    "MESSAGE=%s", buf,
1034                    NULL);
1035 }
1036 #pragma GCC diagnostic pop
1037
1038 /* Errors:
1039  *         -EBADR:     This unit type does not support starting.
1040  *         -EALREADY:  Unit is already started.
1041  *         -EAGAIN:    An operation is already in progress. Retry later.
1042  *         -ECANCELED: Too many requests for now.
1043  */
1044 int unit_start(Unit *u) {
1045         UnitActiveState state;
1046         Unit *following;
1047
1048         assert(u);
1049
1050         if (u->load_state != UNIT_LOADED)
1051                 return -EINVAL;
1052
1053         /* If this is already started, then this will succeed. Note
1054          * that this will even succeed if this unit is not startable
1055          * by the user. This is relied on to detect when we need to
1056          * wait for units and when waiting is finished. */
1057         state = unit_active_state(u);
1058         if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1059                 return -EALREADY;
1060
1061         /* If the conditions failed, don't do anything at all. If we
1062          * already are activating this call might still be useful to
1063          * speed up activation in case there is some hold-off time,
1064          * but we don't want to recheck the condition in that case. */
1065         if (state != UNIT_ACTIVATING &&
1066             !unit_condition_test(u)) {
1067                 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1068                 return -EALREADY;
1069         }
1070
1071         /* Forward to the main object, if we aren't it. */
1072         if ((following = unit_following(u))) {
1073                 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1074                 return unit_start(following);
1075         }
1076
1077         unit_status_log_starting_stopping_reloading(u, JOB_START);
1078         unit_status_print_starting_stopping(u, JOB_START);
1079
1080         /* If it is stopped, but we cannot start it, then fail */
1081         if (!UNIT_VTABLE(u)->start)
1082                 return -EBADR;
1083
1084         /* We don't suppress calls to ->start() here when we are
1085          * already starting, to allow this request to be used as a
1086          * "hurry up" call, for example when the unit is in some "auto
1087          * restart" state where it waits for a holdoff timer to elapse
1088          * before it will start again. */
1089
1090         unit_add_to_dbus_queue(u);
1091
1092         return UNIT_VTABLE(u)->start(u);
1093 }
1094
1095 bool unit_can_start(Unit *u) {
1096         assert(u);
1097
1098         return !!UNIT_VTABLE(u)->start;
1099 }
1100
1101 bool unit_can_isolate(Unit *u) {
1102         assert(u);
1103
1104         return unit_can_start(u) &&
1105                 u->allow_isolate;
1106 }
1107
1108 /* Errors:
1109  *         -EBADR:    This unit type does not support stopping.
1110  *         -EALREADY: Unit is already stopped.
1111  *         -EAGAIN:   An operation is already in progress. Retry later.
1112  */
1113 int unit_stop(Unit *u) {
1114         UnitActiveState state;
1115         Unit *following;
1116
1117         assert(u);
1118
1119         state = unit_active_state(u);
1120         if (UNIT_IS_INACTIVE_OR_FAILED(state))
1121                 return -EALREADY;
1122
1123         if ((following = unit_following(u))) {
1124                 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1125                 return unit_stop(following);
1126         }
1127
1128         unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1129         unit_status_print_starting_stopping(u, JOB_STOP);
1130
1131         if (!UNIT_VTABLE(u)->stop)
1132                 return -EBADR;
1133
1134         unit_add_to_dbus_queue(u);
1135
1136         return UNIT_VTABLE(u)->stop(u);
1137 }
1138
1139 /* Errors:
1140  *         -EBADR:    This unit type does not support reloading.
1141  *         -ENOEXEC:  Unit is not started.
1142  *         -EAGAIN:   An operation is already in progress. Retry later.
1143  */
1144 int unit_reload(Unit *u) {
1145         UnitActiveState state;
1146         Unit *following;
1147
1148         assert(u);
1149
1150         if (u->load_state != UNIT_LOADED)
1151                 return -EINVAL;
1152
1153         if (!unit_can_reload(u))
1154                 return -EBADR;
1155
1156         state = unit_active_state(u);
1157         if (state == UNIT_RELOADING)
1158                 return -EALREADY;
1159
1160         if (state != UNIT_ACTIVE)
1161                 return -ENOEXEC;
1162
1163         if ((following = unit_following(u))) {
1164                 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1165                 return unit_reload(following);
1166         }
1167
1168         unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1169
1170         unit_add_to_dbus_queue(u);
1171         return UNIT_VTABLE(u)->reload(u);
1172 }
1173
1174 bool unit_can_reload(Unit *u) {
1175         assert(u);
1176
1177         if (!UNIT_VTABLE(u)->reload)
1178                 return false;
1179
1180         if (!UNIT_VTABLE(u)->can_reload)
1181                 return true;
1182
1183         return UNIT_VTABLE(u)->can_reload(u);
1184 }
1185
1186 static void unit_check_unneeded(Unit *u) {
1187         Iterator i;
1188         Unit *other;
1189
1190         assert(u);
1191
1192         /* If this service shall be shut down when unneeded then do
1193          * so. */
1194
1195         if (!u->stop_when_unneeded)
1196                 return;
1197
1198         if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1199                 return;
1200
1201         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1202                 if (unit_pending_active(other))
1203                         return;
1204
1205         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1206                 if (unit_pending_active(other))
1207                         return;
1208
1209         SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1210                 if (unit_pending_active(other))
1211                         return;
1212
1213         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1214                 if (unit_pending_active(other))
1215                         return;
1216
1217         log_info("Service %s is not needed anymore. Stopping.", u->id);
1218
1219         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1220         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1221 }
1222
1223 static void retroactively_start_dependencies(Unit *u) {
1224         Iterator i;
1225         Unit *other;
1226
1227         assert(u);
1228         assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1229
1230         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1231                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1232                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1233                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1234
1235         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1236                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1237                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1238                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1239
1240         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1241                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1242                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1243                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1244
1245         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1246                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1247                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1248                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1249
1250         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1251                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1252                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1253                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1254
1255         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1256                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1257                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1258
1259         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1260                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1261                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1262 }
1263
1264 static void retroactively_stop_dependencies(Unit *u) {
1265         Iterator i;
1266         Unit *other;
1267
1268         assert(u);
1269         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1270
1271         /* Pull down units which are bound to us recursively if enabled */
1272         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1273                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1274                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1275 }
1276
1277 static void check_unneeded_dependencies(Unit *u) {
1278         Iterator i;
1279         Unit *other;
1280
1281         assert(u);
1282         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1283
1284         /* Garbage collect services that might not be needed anymore, if enabled */
1285         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1286                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1287                         unit_check_unneeded(other);
1288         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1289                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1290                         unit_check_unneeded(other);
1291         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1292                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1293                         unit_check_unneeded(other);
1294         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1295                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1296                         unit_check_unneeded(other);
1297         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1298                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1299                         unit_check_unneeded(other);
1300         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1301                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1302                         unit_check_unneeded(other);
1303 }
1304
1305 void unit_trigger_on_failure(Unit *u) {
1306         Unit *other;
1307         Iterator i;
1308
1309         assert(u);
1310
1311         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1312                 return;
1313
1314         log_info("Triggering OnFailure= dependencies of %s.", u->id);
1315
1316         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1317                 int r;
1318
1319                 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1320                         log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1321         }
1322 }
1323
1324 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1325         bool unexpected;
1326
1327         assert(u);
1328         assert(os < _UNIT_ACTIVE_STATE_MAX);
1329         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1330
1331         /* Note that this is called for all low-level state changes,
1332          * even if they might map to the same high-level
1333          * UnitActiveState! That means that ns == os is OK an expected
1334          * behavior here. For example: if a mount point is remounted
1335          * this function will be called too! */
1336
1337         if (u->manager->n_reloading <= 0) {
1338                 dual_timestamp ts;
1339
1340                 dual_timestamp_get(&ts);
1341
1342                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1343                         u->inactive_exit_timestamp = ts;
1344                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1345                         u->inactive_enter_timestamp = ts;
1346
1347                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1348                         u->active_enter_timestamp = ts;
1349                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1350                         u->active_exit_timestamp = ts;
1351
1352                 timer_unit_notify(u, ns);
1353                 path_unit_notify(u, ns);
1354         }
1355
1356         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1357                 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1358
1359         if (u->job) {
1360                 unexpected = false;
1361
1362                 if (u->job->state == JOB_WAITING)
1363
1364                         /* So we reached a different state for this
1365                          * job. Let's see if we can run it now if it
1366                          * failed previously due to EAGAIN. */
1367                         job_add_to_run_queue(u->job);
1368
1369                 /* Let's check whether this state change constitutes a
1370                  * finished job, or maybe contradicts a running job and
1371                  * hence needs to invalidate jobs. */
1372
1373                 switch (u->job->type) {
1374
1375                 case JOB_START:
1376                 case JOB_VERIFY_ACTIVE:
1377
1378                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1379                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1380                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1381                                 unexpected = true;
1382
1383                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1384                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1385                         }
1386
1387                         break;
1388
1389                 case JOB_RELOAD:
1390                 case JOB_RELOAD_OR_START:
1391
1392                         if (u->job->state == JOB_RUNNING) {
1393                                 if (ns == UNIT_ACTIVE)
1394                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1395                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1396                                         unexpected = true;
1397
1398                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1399                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1400                                 }
1401                         }
1402
1403                         break;
1404
1405                 case JOB_STOP:
1406                 case JOB_RESTART:
1407                 case JOB_TRY_RESTART:
1408
1409                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1410                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1411                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1412                                 unexpected = true;
1413                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1414                         }
1415
1416                         break;
1417
1418                 default:
1419                         assert_not_reached("Job type unknown");
1420                 }
1421
1422         } else
1423                 unexpected = true;
1424
1425         if (u->manager->n_reloading <= 0) {
1426
1427                 /* If this state change happened without being
1428                  * requested by a job, then let's retroactively start
1429                  * or stop dependencies. We skip that step when
1430                  * deserializing, since we don't want to create any
1431                  * additional jobs just because something is already
1432                  * activated. */
1433
1434                 if (unexpected) {
1435                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1436                                 retroactively_start_dependencies(u);
1437                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1438                                 retroactively_stop_dependencies(u);
1439                 }
1440
1441                 /* stop unneeded units regardless if going down was expected or not */
1442                 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1443                         check_unneeded_dependencies(u);
1444
1445                 if (ns != os && ns == UNIT_FAILED) {
1446                         log_struct_unit(LOG_NOTICE,
1447                                    u->id,
1448                                    "MESSAGE=Unit %s entered failed state", u->id,
1449                                    NULL);
1450                         unit_trigger_on_failure(u);
1451                 }
1452         }
1453
1454         /* Some names are special */
1455         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1456
1457                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1458                         /* The bus just might have become available,
1459                          * hence try to connect to it, if we aren't
1460                          * yet connected. */
1461                         bus_init(u->manager, true);
1462
1463                 if (u->type == UNIT_SERVICE &&
1464                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1465                     u->manager->n_reloading <= 0) {
1466                         /* Write audit record if we have just finished starting up */
1467                         manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1468                         u->in_audit = true;
1469                 }
1470
1471                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1472                         manager_send_unit_plymouth(u->manager, u);
1473
1474         } else {
1475
1476                 /* We don't care about D-Bus here, since we'll get an
1477                  * asynchronous notification for it anyway. */
1478
1479                 if (u->type == UNIT_SERVICE &&
1480                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1481                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1482                     u->manager->n_reloading <= 0) {
1483
1484                         /* Hmm, if there was no start record written
1485                          * write it now, so that we always have a nice
1486                          * pair */
1487                         if (!u->in_audit) {
1488                                 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1489
1490                                 if (ns == UNIT_INACTIVE)
1491                                         manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1492                         } else
1493                                 /* Write audit record if we have just finished shutting down */
1494                                 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1495
1496                         u->in_audit = false;
1497                 }
1498         }
1499
1500         manager_recheck_journal(u->manager);
1501
1502         /* Maybe we finished startup and are now ready for being
1503          * stopped because unneeded? */
1504         unit_check_unneeded(u);
1505
1506         unit_add_to_dbus_queue(u);
1507         unit_add_to_gc_queue(u);
1508 }
1509
1510 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1511         struct epoll_event ev;
1512
1513         assert(u);
1514         assert(fd >= 0);
1515         assert(w);
1516         assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1517
1518         zero(ev);
1519         ev.data.ptr = w;
1520         ev.events = events;
1521
1522         if (epoll_ctl(u->manager->epoll_fd,
1523                       w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1524                       fd,
1525                       &ev) < 0)
1526                 return -errno;
1527
1528         w->fd = fd;
1529         w->type = WATCH_FD;
1530         w->data.unit = u;
1531
1532         return 0;
1533 }
1534
1535 void unit_unwatch_fd(Unit *u, Watch *w) {
1536         assert(u);
1537         assert(w);
1538
1539         if (w->type == WATCH_INVALID)
1540                 return;
1541
1542         assert(w->type == WATCH_FD);
1543         assert(w->data.unit == u);
1544         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1545
1546         w->fd = -1;
1547         w->type = WATCH_INVALID;
1548         w->data.unit = NULL;
1549 }
1550
1551 int unit_watch_pid(Unit *u, pid_t pid) {
1552         assert(u);
1553         assert(pid >= 1);
1554
1555         /* Watch a specific PID. We only support one unit watching
1556          * each PID for now. */
1557
1558         return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1559 }
1560
1561 void unit_unwatch_pid(Unit *u, pid_t pid) {
1562         assert(u);
1563         assert(pid >= 1);
1564
1565         hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1566 }
1567
1568 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1569         struct itimerspec its;
1570         int flags, fd;
1571         bool ours;
1572
1573         assert(u);
1574         assert(w);
1575         assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1576
1577         /* This will try to reuse the old timer if there is one */
1578
1579         if (w->type == WATCH_UNIT_TIMER) {
1580                 assert(w->data.unit == u);
1581                 assert(w->fd >= 0);
1582
1583                 ours = false;
1584                 fd = w->fd;
1585         } else if (w->type == WATCH_INVALID) {
1586
1587                 ours = true;
1588                 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1589                 if (fd < 0)
1590                         return -errno;
1591         } else
1592                 assert_not_reached("Invalid watch type");
1593
1594         zero(its);
1595
1596         if (usec <= 0) {
1597                 /* Set absolute time in the past, but not 0, since we
1598                  * don't want to disarm the timer */
1599                 its.it_value.tv_sec = 0;
1600                 its.it_value.tv_nsec = 1;
1601
1602                 flags = TFD_TIMER_ABSTIME;
1603         } else {
1604                 timespec_store(&its.it_value, usec);
1605                 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1606         }
1607
1608         /* This will also flush the elapse counter */
1609         if (timerfd_settime(fd, flags, &its, NULL) < 0)
1610                 goto fail;
1611
1612         if (w->type == WATCH_INVALID) {
1613                 struct epoll_event ev;
1614
1615                 zero(ev);
1616                 ev.data.ptr = w;
1617                 ev.events = EPOLLIN;
1618
1619                 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1620                         goto fail;
1621         }
1622
1623         w->type = WATCH_UNIT_TIMER;
1624         w->fd = fd;
1625         w->data.unit = u;
1626
1627         return 0;
1628
1629 fail:
1630         if (ours)
1631                 close_nointr_nofail(fd);
1632
1633         return -errno;
1634 }
1635
1636 void unit_unwatch_timer(Unit *u, Watch *w) {
1637         assert(u);
1638         assert(w);
1639
1640         if (w->type == WATCH_INVALID)
1641                 return;
1642
1643         assert(w->type == WATCH_UNIT_TIMER);
1644         assert(w->data.unit == u);
1645         assert(w->fd >= 0);
1646
1647         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1648         close_nointr_nofail(w->fd);
1649
1650         w->fd = -1;
1651         w->type = WATCH_INVALID;
1652         w->data.unit = NULL;
1653 }
1654
1655 bool unit_job_is_applicable(Unit *u, JobType j) {
1656         assert(u);
1657         assert(j >= 0 && j < _JOB_TYPE_MAX);
1658
1659         switch (j) {
1660
1661         case JOB_VERIFY_ACTIVE:
1662         case JOB_START:
1663         case JOB_STOP:
1664         case JOB_NOP:
1665                 return true;
1666
1667         case JOB_RESTART:
1668         case JOB_TRY_RESTART:
1669                 return unit_can_start(u);
1670
1671         case JOB_RELOAD:
1672                 return unit_can_reload(u);
1673
1674         case JOB_RELOAD_OR_START:
1675                 return unit_can_reload(u) && unit_can_start(u);
1676
1677         default:
1678                 assert_not_reached("Invalid job type");
1679         }
1680 }
1681
1682 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1683
1684         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1685                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1686                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1687                 [UNIT_WANTS] = UNIT_WANTED_BY,
1688                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1689                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1690                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1691                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1692                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1693                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1694                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1695                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1696                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1697                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1698                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1699                 [UNIT_BEFORE] = UNIT_AFTER,
1700                 [UNIT_AFTER] = UNIT_BEFORE,
1701                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1702                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1703                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1704                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1705                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1706                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1707                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1708         };
1709         int r, q = 0, v = 0, w = 0;
1710
1711         assert(u);
1712         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1713         assert(other);
1714
1715         u = unit_follow_merge(u);
1716         other = unit_follow_merge(other);
1717
1718         /* We won't allow dependencies on ourselves. We will not
1719          * consider them an error however. */
1720         if (u == other)
1721                 return 0;
1722
1723         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1724                 return r;
1725
1726         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1727                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1728                         return r;
1729
1730         if (add_reference)
1731                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1732                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1733                         return r;
1734
1735         if ((q = set_put(u->dependencies[d], other)) < 0)
1736                 return q;
1737
1738         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1739                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1740                         r = v;
1741                         goto fail;
1742                 }
1743
1744         if (add_reference) {
1745                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1746                         r = w;
1747                         goto fail;
1748                 }
1749
1750                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1751                         goto fail;
1752         }
1753
1754         unit_add_to_dbus_queue(u);
1755         return 0;
1756
1757 fail:
1758         if (q > 0)
1759                 set_remove(u->dependencies[d], other);
1760
1761         if (v > 0)
1762                 set_remove(other->dependencies[inverse_table[d]], u);
1763
1764         if (w > 0)
1765                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1766
1767         return r;
1768 }
1769
1770 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1771         int r;
1772
1773         assert(u);
1774
1775         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1776                 return r;
1777
1778         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1779                 return r;
1780
1781         return 0;
1782 }
1783
1784 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1785         char *s;
1786
1787         assert(u);
1788         assert(name || path);
1789         assert(p);
1790
1791         if (!name)
1792                 name = path_get_file_name(path);
1793
1794         if (!unit_name_is_template(name)) {
1795                 *p = NULL;
1796                 return name;
1797         }
1798
1799         if (u->instance)
1800                 s = unit_name_replace_instance(name, u->instance);
1801         else {
1802                 char *i;
1803
1804                 i = unit_name_to_prefix(u->id);
1805                 if (!i)
1806                         return NULL;
1807
1808                 s = unit_name_replace_instance(name, i);
1809                 free(i);
1810         }
1811
1812         if (!s)
1813                 return NULL;
1814
1815         *p = s;
1816         return s;
1817 }
1818
1819 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1820         Unit *other;
1821         int r;
1822         _cleanup_free_ char *s = NULL;
1823
1824         assert(u);
1825         assert(name || path);
1826
1827         name = resolve_template(u, name, path, &s);
1828         if (!name)
1829                 return -ENOMEM;
1830
1831         r = manager_load_unit(u->manager, name, path, NULL, &other);
1832         if (r < 0)
1833                 return r;
1834
1835         return unit_add_dependency(u, d, other, add_reference);
1836 }
1837
1838 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1839         Unit *other;
1840         int r;
1841         char *s;
1842
1843         assert(u);
1844         assert(name || path);
1845
1846         if (!(name = resolve_template(u, name, path, &s)))
1847                 return -ENOMEM;
1848
1849         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1850                 goto finish;
1851
1852         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1853
1854 finish:
1855         free(s);
1856         return r;
1857 }
1858
1859 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1860         Unit *other;
1861         int r;
1862         char *s;
1863
1864         assert(u);
1865         assert(name || path);
1866
1867         if (!(name = resolve_template(u, name, path, &s)))
1868                 return -ENOMEM;
1869
1870         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1871                 goto finish;
1872
1873         r = unit_add_dependency(other, d, u, add_reference);
1874
1875 finish:
1876         free(s);
1877         return r;
1878 }
1879
1880 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1881         Unit *other;
1882         int r;
1883         char *s;
1884
1885         assert(u);
1886         assert(name || path);
1887
1888         if (!(name = resolve_template(u, name, path, &s)))
1889                 return -ENOMEM;
1890
1891         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1892                 goto finish;
1893
1894         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1895                 goto finish;
1896
1897 finish:
1898         free(s);
1899         return r;
1900 }
1901
1902 int set_unit_path(const char *p) {
1903         char *cwd, *c;
1904         int r;
1905
1906         /* This is mostly for debug purposes */
1907
1908         if (path_is_absolute(p)) {
1909                 if (!(c = strdup(p)))
1910                         return -ENOMEM;
1911         } else {
1912                 if (!(cwd = get_current_dir_name()))
1913                         return -errno;
1914
1915                 r = asprintf(&c, "%s/%s", cwd, p);
1916                 free(cwd);
1917
1918                 if (r < 0)
1919                         return -ENOMEM;
1920         }
1921
1922         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1923                 r = -errno;
1924                 free(c);
1925                 return r;
1926         }
1927
1928         return 0;
1929 }
1930
1931 char *unit_dbus_path(Unit *u) {
1932         assert(u);
1933
1934         if (!u->id)
1935                 return NULL;
1936
1937         return unit_dbus_path_from_name(u->id);
1938 }
1939
1940 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1941         int r;
1942
1943         assert(u);
1944         assert(b);
1945
1946         assert(b->path);
1947
1948         if (!b->controller) {
1949                 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1950                 if (!b->controller)
1951                         return log_oom();
1952
1953                 b->ours = true;
1954         }
1955
1956         /* Ensure this hasn't been added yet */
1957         assert(!b->unit);
1958
1959         if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1960                 CGroupBonding *l;
1961
1962                 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1963                 LIST_PREPEND(CGroupBonding, by_path, l, b);
1964
1965                 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1966                 if (r < 0) {
1967                         LIST_REMOVE(CGroupBonding, by_path, l, b);
1968                         return r;
1969                 }
1970         }
1971
1972         LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1973         b->unit = u;
1974
1975         return 0;
1976 }
1977
1978 char *unit_default_cgroup_path(Unit *u) {
1979         assert(u);
1980
1981         if (u->instance) {
1982                 _cleanup_free_ char *t = NULL;
1983
1984                 t = unit_name_template(u->id);
1985                 if (!t)
1986                         return NULL;
1987
1988                 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1989         } else
1990                 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1991 }
1992
1993 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1994         char *controller = NULL, *path = NULL;
1995         CGroupBonding *b = NULL;
1996         bool ours = false;
1997         int r;
1998
1999         assert(u);
2000         assert(name);
2001
2002         r = cg_split_spec(name, &controller, &path);
2003         if (r < 0)
2004                 return r;
2005
2006         if (!path) {
2007                 path = unit_default_cgroup_path(u);
2008                 ours = true;
2009         }
2010
2011         if (!controller) {
2012                 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2013                 ours = true;
2014         }
2015
2016         if (!path || !controller) {
2017                 free(path);
2018                 free(controller);
2019                 return log_oom();
2020         }
2021
2022         b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2023         if (b) {
2024                 if (streq(path, b->path)) {
2025                         free(path);
2026                         free(controller);
2027
2028                         if (ret)
2029                                 *ret = b;
2030                         return 0;
2031                 }
2032
2033                 if (overwrite && !b->essential) {
2034                         free(controller);
2035
2036                         free(b->path);
2037                         b->path = path;
2038
2039                         b->ours = ours;
2040                         b->realized = false;
2041
2042                         if (ret)
2043                                 *ret = b;
2044
2045                         return 1;
2046                 }
2047
2048                 r = -EEXIST;
2049                 b = NULL;
2050                 goto fail;
2051         }
2052
2053         b = new0(CGroupBonding, 1);
2054         if (!b) {
2055                 r = -ENOMEM;
2056                 goto fail;
2057         }
2058
2059         b->controller = controller;
2060         b->path = path;
2061         b->ours = ours;
2062         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2063
2064         r = unit_add_cgroup(u, b);
2065         if (r < 0)
2066                 goto fail;
2067
2068         if (ret)
2069                 *ret = b;
2070
2071         return 1;
2072
2073 fail:
2074         free(path);
2075         free(controller);
2076         free(b);
2077
2078         return r;
2079 }
2080
2081 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2082         CGroupBonding *b = NULL;
2083         int r = -ENOMEM;
2084
2085         assert(u);
2086
2087         if (!controller)
2088                 controller = SYSTEMD_CGROUP_CONTROLLER;
2089
2090         if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2091                 return 0;
2092
2093         b = new0(CGroupBonding, 1);
2094         if (!b)
2095                 return -ENOMEM;
2096
2097         b->controller = strdup(controller);
2098         if (!b->controller)
2099                 goto fail;
2100
2101         b->path = unit_default_cgroup_path(u);
2102         if (!b->path)
2103                 goto fail;
2104
2105         b->ours = true;
2106         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2107
2108         r = unit_add_cgroup(u, b);
2109         if (r < 0)
2110                 goto fail;
2111
2112         return 0;
2113
2114 fail:
2115         free(b->path);
2116         free(b->controller);
2117         free(b);
2118
2119         return r;
2120 }
2121
2122 int unit_add_default_cgroups(Unit *u) {
2123         CGroupAttribute *a;
2124         char **c;
2125         int r;
2126
2127         assert(u);
2128
2129         /* Adds in the default cgroups, if they weren't specified
2130          * otherwise. */
2131
2132         if (!u->manager->cgroup_hierarchy)
2133                 return 0;
2134
2135         r = unit_add_one_default_cgroup(u, NULL);
2136         if (r < 0)
2137                 return r;
2138
2139         STRV_FOREACH(c, u->manager->default_controllers)
2140                 unit_add_one_default_cgroup(u, *c);
2141
2142         LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2143                 unit_add_one_default_cgroup(u, a->controller);
2144
2145         return 0;
2146 }
2147
2148 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2149         assert(u);
2150
2151         return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2152 }
2153
2154 int unit_add_cgroup_attribute(
2155                 Unit *u,
2156                 const char *controller,
2157                 const char *name,
2158                 const char *value,
2159                 CGroupAttributeMapCallback map_callback,
2160                 CGroupAttribute **ret) {
2161
2162         _cleanup_free_ char *c = NULL;
2163         CGroupAttribute *a;
2164         int r;
2165
2166         assert(u);
2167         assert(name);
2168         assert(value);
2169
2170         if (!controller) {
2171                 r = cg_controller_from_attr(name, &c);
2172                 if (r < 0)
2173                         return -EINVAL;
2174
2175                 controller = c;
2176         } else {
2177                 if (!filename_is_safe(name))
2178                         return -EINVAL;
2179
2180                 if (!filename_is_safe(controller))
2181                         return -EINVAL;
2182         }
2183
2184         if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2185                 return -EINVAL;
2186
2187         a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2188         if (a) {
2189                 char *v;
2190
2191                 if (streq(value, a->value)) {
2192                         if (ret)
2193                                 *ret = a;
2194
2195                         return 0;
2196                 }
2197
2198                 v = strdup(value);
2199                 if (!v)
2200                         return -ENOMEM;
2201
2202                 free(a->value);
2203                 a->value = v;
2204
2205                 if (ret)
2206                         *ret = a;
2207
2208                 return 1;
2209         }
2210
2211         a = new0(CGroupAttribute, 1);
2212         if (!a)
2213                 return -ENOMEM;
2214
2215         if (c) {
2216                 a->controller = c;
2217                 c = NULL;
2218         } else
2219                 a->controller = strdup(controller);
2220
2221         a->name = strdup(name);
2222         a->value = strdup(value);
2223
2224         if (!a->controller || !a->name || !a->value) {
2225                 free(a->controller);
2226                 free(a->name);
2227                 free(a->value);
2228                 free(a);
2229
2230                 return -ENOMEM;
2231         }
2232
2233         a->map_callback = map_callback;
2234         a->unit = u;
2235
2236         LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2237
2238         if (ret)
2239                 *ret = a;
2240
2241         return 1;
2242 }
2243
2244 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2245         char *t;
2246         int r;
2247
2248         assert(u);
2249         assert(type);
2250         assert(_found);
2251
2252         if (!(t = unit_name_change_suffix(u->id, type)))
2253                 return -ENOMEM;
2254
2255         assert(!unit_has_name(u, t));
2256
2257         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2258         free(t);
2259
2260         assert(r < 0 || *_found != u);
2261
2262         return r;
2263 }
2264
2265 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2266         Unit *found;
2267         char *t;
2268
2269         assert(u);
2270         assert(type);
2271         assert(_found);
2272
2273         if (!(t = unit_name_change_suffix(u->id, type)))
2274                 return -ENOMEM;
2275
2276         assert(!unit_has_name(u, t));
2277
2278         found = manager_get_unit(u->manager, t);
2279         free(t);
2280
2281         if (!found)
2282                 return -ENOENT;
2283
2284         *_found = found;
2285         return 0;
2286 }
2287
2288 int unit_watch_bus_name(Unit *u, const char *name) {
2289         assert(u);
2290         assert(name);
2291
2292         /* Watch a specific name on the bus. We only support one unit
2293          * watching each name for now. */
2294
2295         return hashmap_put(u->manager->watch_bus, name, u);
2296 }
2297
2298 void unit_unwatch_bus_name(Unit *u, const char *name) {
2299         assert(u);
2300         assert(name);
2301
2302         hashmap_remove_value(u->manager->watch_bus, name, u);
2303 }
2304
2305 bool unit_can_serialize(Unit *u) {
2306         assert(u);
2307
2308         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2309 }
2310
2311 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2312         int r;
2313
2314         assert(u);
2315         assert(f);
2316         assert(fds);
2317
2318         if (!unit_can_serialize(u))
2319                 return 0;
2320
2321         if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2322                 return r;
2323
2324
2325         if (serialize_jobs) {
2326                 if (u->job) {
2327                         fprintf(f, "job\n");
2328                         job_serialize(u->job, f, fds);
2329                 }
2330
2331                 if (u->nop_job) {
2332                         fprintf(f, "job\n");
2333                         job_serialize(u->nop_job, f, fds);
2334                 }
2335         }
2336
2337         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2338         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2339         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2340         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2341         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2342
2343         if (dual_timestamp_is_set(&u->condition_timestamp))
2344                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2345
2346         /* End marker */
2347         fputc('\n', f);
2348         return 0;
2349 }
2350
2351 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2352         va_list ap;
2353
2354         assert(u);
2355         assert(f);
2356         assert(key);
2357         assert(format);
2358
2359         fputs(key, f);
2360         fputc('=', f);
2361
2362         va_start(ap, format);
2363         vfprintf(f, format, ap);
2364         va_end(ap);
2365
2366         fputc('\n', f);
2367 }
2368
2369 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2370         assert(u);
2371         assert(f);
2372         assert(key);
2373         assert(value);
2374
2375         fprintf(f, "%s=%s\n", key, value);
2376 }
2377
2378 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2379         int r;
2380
2381         assert(u);
2382         assert(f);
2383         assert(fds);
2384
2385         if (!unit_can_serialize(u))
2386                 return 0;
2387
2388         for (;;) {
2389                 char line[LINE_MAX], *l, *v;
2390                 size_t k;
2391
2392                 if (!fgets(line, sizeof(line), f)) {
2393                         if (feof(f))
2394                                 return 0;
2395                         return -errno;
2396                 }
2397
2398                 char_array_0(line);
2399                 l = strstrip(line);
2400
2401                 /* End marker */
2402                 if (l[0] == 0)
2403                         return 0;
2404
2405                 k = strcspn(l, "=");
2406
2407                 if (l[k] == '=') {
2408                         l[k] = 0;
2409                         v = l+k+1;
2410                 } else
2411                         v = l+k;
2412
2413                 if (streq(l, "job")) {
2414                         if (v[0] == '\0') {
2415                                 /* new-style serialized job */
2416                                 Job *j = job_new_raw(u);
2417                                 if (!j)
2418                                         return -ENOMEM;
2419
2420                                 r = job_deserialize(j, f, fds);
2421                                 if (r < 0) {
2422                                         job_free(j);
2423                                         return r;
2424                                 }
2425
2426                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2427                                 if (r < 0) {
2428                                         job_free(j);
2429                                         return r;
2430                                 }
2431
2432                                 r = job_install_deserialized(j);
2433                                 if (r < 0) {
2434                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2435                                         job_free(j);
2436                                         return r;
2437                                 }
2438                         } else {
2439                                 /* legacy */
2440                                 JobType type = job_type_from_string(v);
2441                                 if (type < 0)
2442                                         log_debug("Failed to parse job type value %s", v);
2443                                 else
2444                                         u->deserialized_job = type;
2445                         }
2446                         continue;
2447                 } else if (streq(l, "inactive-exit-timestamp")) {
2448                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2449                         continue;
2450                 } else if (streq(l, "active-enter-timestamp")) {
2451                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2452                         continue;
2453                 } else if (streq(l, "active-exit-timestamp")) {
2454                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2455                         continue;
2456                 } else if (streq(l, "inactive-enter-timestamp")) {
2457                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2458                         continue;
2459                 } else if (streq(l, "condition-timestamp")) {
2460                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2461                         continue;
2462                 } else if (streq(l, "condition-result")) {
2463                         int b;
2464
2465                         if ((b = parse_boolean(v)) < 0)
2466                                 log_debug("Failed to parse condition result value %s", v);
2467                         else
2468                                 u->condition_result = b;
2469
2470                         continue;
2471                 }
2472
2473                 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2474                         return r;
2475         }
2476 }
2477
2478 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2479         Unit *device;
2480         char *e;
2481         int r;
2482
2483         assert(u);
2484
2485         if (!what)
2486                 return 0;
2487
2488         /* Adds in links to the device node that this unit is based on */
2489
2490         if (!is_device_path(what))
2491                 return 0;
2492
2493         e = unit_name_from_path(what, ".device");
2494         if (!e)
2495                 return -ENOMEM;
2496
2497         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2498         free(e);
2499         if (r < 0)
2500                 return r;
2501
2502         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2503         if (r < 0)
2504                 return r;
2505
2506         if (wants) {
2507                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2508                 if (r < 0)
2509                         return r;
2510         }
2511
2512         return 0;
2513 }
2514
2515 int unit_coldplug(Unit *u) {
2516         int r;
2517
2518         assert(u);
2519
2520         if (UNIT_VTABLE(u)->coldplug)
2521                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2522                         return r;
2523
2524         if (u->job) {
2525                 r = job_coldplug(u->job);
2526                 if (r < 0)
2527                         return r;
2528         } else if (u->deserialized_job >= 0) {
2529                 /* legacy */
2530                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2531                 if (r < 0)
2532                         return r;
2533
2534                 u->deserialized_job = _JOB_TYPE_INVALID;
2535         }
2536
2537         return 0;
2538 }
2539
2540 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2541         va_list ap;
2542
2543         assert(u);
2544         assert(format);
2545
2546         if (!manager_get_show_status(u->manager))
2547                 return;
2548
2549         if (!manager_is_booting_or_shutting_down(u->manager))
2550                 return;
2551
2552         va_start(ap, format);
2553         status_vprintf(status, true, format, ap);
2554         va_end(ap);
2555 }
2556
2557 bool unit_need_daemon_reload(Unit *u) {
2558         struct stat st;
2559
2560         assert(u);
2561
2562         if (u->fragment_path) {
2563                 zero(st);
2564                 if (stat(u->fragment_path, &st) < 0)
2565                         /* What, cannot access this anymore? */
2566                         return true;
2567
2568                 if (u->fragment_mtime > 0 &&
2569                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2570                         return true;
2571         }
2572
2573         if (u->source_path) {
2574                 zero(st);
2575                 if (stat(u->source_path, &st) < 0)
2576                         return true;
2577
2578                 if (u->source_mtime > 0 &&
2579                     timespec_load(&st.st_mtim) != u->source_mtime)
2580                         return true;
2581         }
2582
2583         return false;
2584 }
2585
2586 void unit_reset_failed(Unit *u) {
2587         assert(u);
2588
2589         if (UNIT_VTABLE(u)->reset_failed)
2590                 UNIT_VTABLE(u)->reset_failed(u);
2591 }
2592
2593 Unit *unit_following(Unit *u) {
2594         assert(u);
2595
2596         if (UNIT_VTABLE(u)->following)
2597                 return UNIT_VTABLE(u)->following(u);
2598
2599         return NULL;
2600 }
2601
2602 bool unit_pending_inactive(Unit *u) {
2603         assert(u);
2604
2605         /* Returns true if the unit is inactive or going down */
2606
2607         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2608                 return true;
2609
2610         if (u->job && u->job->type == JOB_STOP)
2611                 return true;
2612
2613         return false;
2614 }
2615
2616 bool unit_pending_active(Unit *u) {
2617         assert(u);
2618
2619         /* Returns true if the unit is active or going up */
2620
2621         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2622                 return true;
2623
2624         if (u->job &&
2625             (u->job->type == JOB_START ||
2626              u->job->type == JOB_RELOAD_OR_START ||
2627              u->job->type == JOB_RESTART))
2628                 return true;
2629
2630         return false;
2631 }
2632
2633 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2634         assert(u);
2635         assert(w >= 0 && w < _KILL_WHO_MAX);
2636         assert(signo > 0);
2637         assert(signo < _NSIG);
2638
2639         if (!UNIT_VTABLE(u)->kill)
2640                 return -ENOTSUP;
2641
2642         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2643 }
2644
2645 int unit_following_set(Unit *u, Set **s) {
2646         assert(u);
2647         assert(s);
2648
2649         if (UNIT_VTABLE(u)->following_set)
2650                 return UNIT_VTABLE(u)->following_set(u, s);
2651
2652         *s = NULL;
2653         return 0;
2654 }
2655
2656 UnitFileState unit_get_unit_file_state(Unit *u) {
2657         assert(u);
2658
2659         if (u->unit_file_state < 0 && u->fragment_path)
2660                 u->unit_file_state = unit_file_get_state(
2661                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2662                                 NULL, path_get_file_name(u->fragment_path));
2663
2664         return u->unit_file_state;
2665 }
2666
2667 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2668         assert(ref);
2669         assert(u);
2670
2671         if (ref->unit)
2672                 unit_ref_unset(ref);
2673
2674         ref->unit = u;
2675         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2676         return u;
2677 }
2678
2679 void unit_ref_unset(UnitRef *ref) {
2680         assert(ref);
2681
2682         if (!ref->unit)
2683                 return;
2684
2685         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2686         ref->unit = NULL;
2687 }
2688
2689 int unit_add_one_mount_link(Unit *u, Mount *m) {
2690         char **i;
2691
2692         assert(u);
2693         assert(m);
2694
2695         if (u->load_state != UNIT_LOADED ||
2696             UNIT(m)->load_state != UNIT_LOADED)
2697                 return 0;
2698
2699         STRV_FOREACH(i, u->requires_mounts_for) {
2700
2701                 if (UNIT(m) == u)
2702                         continue;
2703
2704                 if (!path_startswith(*i, m->where))
2705                         continue;
2706
2707                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2708         }
2709
2710         return 0;
2711 }
2712
2713 int unit_add_mount_links(Unit *u) {
2714         Unit *other;
2715         int r;
2716
2717         assert(u);
2718
2719         LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2720                 r = unit_add_one_mount_link(u, MOUNT(other));
2721                 if (r < 0)
2722                         return r;
2723         }
2724
2725         return 0;
2726 }
2727
2728 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2729         unsigned i;
2730         int r;
2731
2732         assert(u);
2733         assert(c);
2734
2735         /* This only copies in the ones that need memory */
2736
2737         for (i = 0; i < RLIMIT_NLIMITS; i++)
2738                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2739                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2740                         if (!c->rlimit[i])
2741                                 return -ENOMEM;
2742                 }
2743
2744         if (u->manager->running_as == SYSTEMD_USER &&
2745             !c->working_directory) {
2746
2747                 r = get_home_dir(&c->working_directory);
2748                 if (r < 0)
2749                         return r;
2750         }
2751
2752         return 0;
2753 }
2754
2755 ExecContext *unit_get_exec_context(Unit *u) {
2756         size_t offset;
2757         assert(u);
2758
2759         offset = UNIT_VTABLE(u)->exec_context_offset;
2760         if (offset <= 0)
2761                 return NULL;
2762
2763         return (ExecContext*) ((uint8_t*) u + offset);
2764 }
2765
2766 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2767         _cleanup_free_ char *p = NULL, *q = NULL;
2768         assert(u);
2769
2770         if (u->manager->running_as != SYSTEMD_SYSTEM)
2771                 return -ENOTSUP;
2772
2773         if (!filename_is_safe(name))
2774                 return -EINVAL;
2775
2776         p = strjoin(runtime ? "/run/systemd/system/" : "/etc/systemd/system/", u->id, ".d", NULL);
2777         if (!p)
2778                 return -ENOMEM;
2779
2780         q = strjoin(p, "/50-", name, ".conf", NULL);
2781         if (!q)
2782                 return -ENOMEM;
2783
2784         mkdir_p(p, 0755);
2785         return write_one_line_file_atomic_label(q, data);
2786 }
2787
2788 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2789         _cleanup_free_ char *p = NULL, *q = NULL;
2790
2791         assert(u);
2792
2793         if (u->manager->running_as != SYSTEMD_SYSTEM)
2794                 return -ENOTSUP;
2795
2796         if (!filename_is_safe(name))
2797                 return -EINVAL;
2798
2799         p = strjoin(runtime ? "/run/systemd/system/" : "/etc/systemd/system/", u->id, ".d", NULL);
2800         if (!p)
2801                 return -ENOMEM;
2802
2803         q = strjoin(p, "/50-", name, ".conf", NULL);
2804         if (!q)
2805                 return -ENOMEM;
2806
2807         if (unlink(q) < 0)
2808                 return -errno;
2809
2810         rmdir(p);
2811         return 0;
2812 }
2813
2814 int unit_kill_context(
2815                 Unit *u,
2816                 KillContext *c,
2817                 bool sigkill,
2818                 pid_t main_pid,
2819                 pid_t control_pid,
2820                 bool main_pid_alien) {
2821
2822         int sig, wait_for_exit = 0, r;
2823
2824         assert(u);
2825         assert(c);
2826
2827         if (c->kill_mode == KILL_NONE)
2828                 return 0;
2829
2830         sig = sigkill ? SIGKILL : c->kill_signal;
2831
2832         if (main_pid > 0) {
2833                 r = kill_and_sigcont(main_pid, sig);
2834
2835                 if (r < 0 && r != -ESRCH) {
2836                         _cleanup_free_ char *comm = NULL;
2837                         get_process_comm(main_pid, &comm);
2838
2839                         log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2840                                          (long) main_pid, strna(comm), strerror(-r));
2841                 } else
2842                         wait_for_exit = !main_pid_alien;
2843         }
2844
2845         if (control_pid > 0) {
2846                 r = kill_and_sigcont(control_pid, sig);
2847
2848                 if (r < 0 && r != -ESRCH) {
2849                         _cleanup_free_ char *comm = NULL;
2850                         get_process_comm(control_pid, &comm);
2851
2852                         log_warning_unit(u->id,
2853                                          "Failed to kill control process %li (%s): %s",
2854                                          (long) control_pid, strna(comm), strerror(-r));
2855                 } else
2856                         wait_for_exit = true;
2857         }
2858
2859         if (c->kill_mode == KILL_CONTROL_GROUP) {
2860                 _cleanup_set_free_ Set *pid_set = NULL;
2861
2862                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2863                 if (!pid_set)
2864                         return -ENOMEM;
2865
2866                 /* Exclude the main/control pids from being killed via the cgroup */
2867                 if (main_pid > 0) {
2868                         r = set_put(pid_set, LONG_TO_PTR(main_pid));
2869                         if (r < 0)
2870                                 return r;
2871                 }
2872
2873                 if (control_pid > 0) {
2874                         r = set_put(pid_set, LONG_TO_PTR(control_pid));
2875                         if (r < 0)
2876                                 return r;
2877                 }
2878
2879                 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2880                 if (r < 0) {
2881                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2882                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2883                 } else if (r > 0)
2884                         wait_for_exit = true;
2885         }
2886
2887         return wait_for_exit;
2888 }
2889
2890 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2891         [UNIT_ACTIVE] = "active",
2892         [UNIT_RELOADING] = "reloading",
2893         [UNIT_INACTIVE] = "inactive",
2894         [UNIT_FAILED] = "failed",
2895         [UNIT_ACTIVATING] = "activating",
2896         [UNIT_DEACTIVATING] = "deactivating"
2897 };
2898
2899 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2900
2901 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2902         [UNIT_REQUIRES] = "Requires",
2903         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2904         [UNIT_REQUISITE] = "Requisite",
2905         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2906         [UNIT_WANTS] = "Wants",
2907         [UNIT_BINDS_TO] = "BindsTo",
2908         [UNIT_PART_OF] = "PartOf",
2909         [UNIT_REQUIRED_BY] = "RequiredBy",
2910         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2911         [UNIT_WANTED_BY] = "WantedBy",
2912         [UNIT_BOUND_BY] = "BoundBy",
2913         [UNIT_CONSISTS_OF] = "ConsistsOf",
2914         [UNIT_CONFLICTS] = "Conflicts",
2915         [UNIT_CONFLICTED_BY] = "ConflictedBy",
2916         [UNIT_BEFORE] = "Before",
2917         [UNIT_AFTER] = "After",
2918         [UNIT_ON_FAILURE] = "OnFailure",
2919         [UNIT_TRIGGERS] = "Triggers",
2920         [UNIT_TRIGGERED_BY] = "TriggeredBy",
2921         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2922         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2923         [UNIT_REFERENCES] = "References",
2924         [UNIT_REFERENCED_BY] = "ReferencedBy",
2925 };
2926
2927 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);