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                         _cleanup_free_ char *v = NULL;
 753
 754                         if (a->semantics && a->semantics->map_write)
 755                                 a->semantics->map_write(a->semantics, 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
 761                 if (UNIT_VTABLE(u)->dump)
 762                         UNIT_VTABLE(u)->dump(u, f, prefix2);
 763
 764         } else if (u->load_state == UNIT_MERGED)
 765                 fprintf(f,
 766                         "%s\tMerged into: %s\n",
 767                         prefix, u->merged_into->id);
 768         else if (u->load_state == UNIT_ERROR)
 769                 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
 770
 771
 772         if (u->job)
 773                 job_dump(u->job, f, prefix2);
 774
 775         if (u->nop_job)
 776                 job_dump(u->nop_job, f, prefix2);
 777
 778         free(p2);
 779 }
 780
 781 /* Common implementation for multiple backends */
 782 int unit_load_fragment_and_dropin(Unit *u) {
 783         int r;
 784
 785         assert(u);
 786
 787         /* Load a .service file */
 788         if ((r = unit_load_fragment(u)) < 0)
 789                 return r;
 790
 791         if (u->load_state == UNIT_STUB)
 792                 return -ENOENT;
 793
 794         /* Load drop-in directory data */
 795         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
 796                 return r;
 797
 798         return 0;
 799 }
 800
 801 /* Common implementation for multiple backends */
 802 int unit_load_fragment_and_dropin_optional(Unit *u) {
 803         int r;
 804
 805         assert(u);
 806
 807         /* Same as unit_load_fragment_and_dropin(), but whether
 808          * something can be loaded or not doesn't matter. */
 809
 810         /* Load a .service file */
 811         if ((r = unit_load_fragment(u)) < 0)
 812                 return r;
 813
 814         if (u->load_state == UNIT_STUB)
 815                 u->load_state = UNIT_LOADED;
 816
 817         /* Load drop-in directory data */
 818         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
 819                 return r;
 820
 821         return 0;
 822 }
 823
 824 int unit_add_default_target_dependency(Unit *u, Unit *target) {
 825         assert(u);
 826         assert(target);
 827
 828         if (target->type != UNIT_TARGET)
 829                 return 0;
 830
 831         /* Only add the dependency if both units are loaded, so that
 832          * that loop check below is reliable */
 833         if (u->load_state != UNIT_LOADED ||
 834             target->load_state != UNIT_LOADED)
 835                 return 0;
 836
 837         /* If either side wants no automatic dependencies, then let's
 838          * skip this */
 839         if (!u->default_dependencies ||
 840             !target->default_dependencies)
 841                 return 0;
 842
 843         /* Don't create loops */
 844         if (set_get(target->dependencies[UNIT_BEFORE], u))
 845                 return 0;
 846
 847         return unit_add_dependency(target, UNIT_AFTER, u, true);
 848 }
 849
 850 static int unit_add_default_dependencies(Unit *u) {
 851         static const UnitDependency deps[] = {
 852                 UNIT_REQUIRED_BY,
 853                 UNIT_REQUIRED_BY_OVERRIDABLE,
 854                 UNIT_WANTED_BY,
 855                 UNIT_BOUND_BY
 856         };
 857
 858         Unit *target;
 859         Iterator i;
 860         int r;
 861         unsigned k;
 862
 863         assert(u);
 864
 865         for (k = 0; k < ELEMENTSOF(deps); k++)
 866                 SET_FOREACH(target, u->dependencies[deps[k]], i)
 867                         if ((r = unit_add_default_target_dependency(u, target)) < 0)
 868                                 return r;
 869
 870         return 0;
 871 }
 872
 873 int unit_load(Unit *u) {
 874         int r;
 875
 876         assert(u);
 877
 878         if (u->in_load_queue) {
 879                 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
 880                 u->in_load_queue = false;
 881         }
 882
 883         if (u->type == _UNIT_TYPE_INVALID)
 884                 return -EINVAL;
 885
 886         if (u->load_state != UNIT_STUB)
 887                 return 0;
 888
 889         if (UNIT_VTABLE(u)->load)
 890                 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
 891                         goto fail;
 892
 893         if (u->load_state == UNIT_STUB) {
 894                 r = -ENOENT;
 895                 goto fail;
 896         }
 897
 898         if (u->load_state == UNIT_LOADED &&
 899             u->default_dependencies)
 900                 if ((r = unit_add_default_dependencies(u)) < 0)
 901                         goto fail;
 902
 903         if (u->load_state == UNIT_LOADED) {
 904                 r = unit_add_mount_links(u);
 905                 if (r < 0)
 906                         return r;
 907         }
 908
 909         if (u->on_failure_isolate &&
 910             set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
 911
 912                 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
 913                           u->id);
 914
 915                 r = -EINVAL;
 916                 goto fail;
 917         }
 918
 919         assert((u->load_state != UNIT_MERGED) == !u->merged_into);
 920
 921         unit_add_to_dbus_queue(unit_follow_merge(u));
 922         unit_add_to_gc_queue(u);
 923
 924         return 0;
 925
 926 fail:
 927         u->load_state = UNIT_ERROR;
 928         u->load_error = r;
 929         unit_add_to_dbus_queue(u);
 930         unit_add_to_gc_queue(u);
 931
 932         log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
 933
 934         return r;
 935 }
 936
 937 bool unit_condition_test(Unit *u) {
 938         assert(u);
 939
 940         dual_timestamp_get(&u->condition_timestamp);
 941         u->condition_result = condition_test_list(u->conditions);
 942
 943         return u->condition_result;
 944 }
 945
 946 static const char* unit_get_status_message_format(Unit *u, JobType t) {
 947         const UnitStatusMessageFormats *format_table;
 948
 949         assert(u);
 950         assert(t >= 0);
 951         assert(t < _JOB_TYPE_MAX);
 952
 953         if (t != JOB_START && t != JOB_STOP)
 954                 return NULL;
 955
 956         format_table = &UNIT_VTABLE(u)->status_message_formats;
 957         if (!format_table)
 958                 return NULL;
 959
 960         return format_table->starting_stopping[t == JOB_STOP];
 961 }
 962
 963 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
 964         const char *format;
 965
 966         assert(u);
 967         assert(t >= 0);
 968         assert(t < _JOB_TYPE_MAX);
 969
 970         format = unit_get_status_message_format(u, t);
 971         if (format)
 972                 return format;
 973
 974         /* Return generic strings */
 975         if (t == JOB_START)
 976                 return "Starting %s.";
 977         else if (t == JOB_STOP)
 978                 return "Stopping %s.";
 979         else if (t == JOB_RELOAD)
 980                 return "Reloading %s.";
 981
 982         return NULL;
 983 }
 984
 985 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
 986         const char *format;
 987
 988         assert(u);
 989
 990         /* We only print status messages for selected units on
 991          * selected operations. */
 992
 993         format = unit_get_status_message_format(u, t);
 994         if (!format)
 995                 return;
 996
 997         unit_status_printf(u, "", format, unit_description(u));
 998 }
 999
1000 #pragma GCC diagnostic push
1001 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1002 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1003         const char *format;
1004         char buf[LINE_MAX];
1005         sd_id128_t mid;
1006
1007         assert(u);
1008
1009         if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1010                 return;
1011
1012         if (log_on_console())
1013                 return;
1014
1015         /* We log status messages for all units and all operations. */
1016
1017         format = unit_get_status_message_format_try_harder(u, t);
1018         if (!format)
1019                 return;
1020
1021         snprintf(buf, sizeof(buf), format, unit_description(u));
1022         char_array_0(buf);
1023
1024         mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1025               t == JOB_STOP  ? SD_MESSAGE_UNIT_STOPPING :
1026                                SD_MESSAGE_UNIT_RELOADING;
1027
1028         log_struct_unit(LOG_INFO,
1029                    u->id,
1030                    MESSAGE_ID(mid),
1031                    "MESSAGE=%s", buf,
1032                    NULL);
1033 }
1034 #pragma GCC diagnostic pop
1035
1036 /* Errors:
1037  *         -EBADR:     This unit type does not support starting.
1038  *         -EALREADY:  Unit is already started.
1039  *         -EAGAIN:    An operation is already in progress. Retry later.
1040  *         -ECANCELED: Too many requests for now.
1041  */
1042 int unit_start(Unit *u) {
1043         UnitActiveState state;
1044         Unit *following;
1045
1046         assert(u);
1047
1048         if (u->load_state != UNIT_LOADED)
1049                 return -EINVAL;
1050
1051         /* If this is already started, then this will succeed. Note
1052          * that this will even succeed if this unit is not startable
1053          * by the user. This is relied on to detect when we need to
1054          * wait for units and when waiting is finished. */
1055         state = unit_active_state(u);
1056         if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1057                 return -EALREADY;
1058
1059         /* If the conditions failed, don't do anything at all. If we
1060          * already are activating this call might still be useful to
1061          * speed up activation in case there is some hold-off time,
1062          * but we don't want to recheck the condition in that case. */
1063         if (state != UNIT_ACTIVATING &&
1064             !unit_condition_test(u)) {
1065                 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1066                 return -EALREADY;
1067         }
1068
1069         /* Forward to the main object, if we aren't it. */
1070         if ((following = unit_following(u))) {
1071                 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1072                 return unit_start(following);
1073         }
1074
1075         unit_status_log_starting_stopping_reloading(u, JOB_START);
1076         unit_status_print_starting_stopping(u, JOB_START);
1077
1078         /* If it is stopped, but we cannot start it, then fail */
1079         if (!UNIT_VTABLE(u)->start)
1080                 return -EBADR;
1081
1082         /* We don't suppress calls to ->start() here when we are
1083          * already starting, to allow this request to be used as a
1084          * "hurry up" call, for example when the unit is in some "auto
1085          * restart" state where it waits for a holdoff timer to elapse
1086          * before it will start again. */
1087
1088         unit_add_to_dbus_queue(u);
1089
1090         return UNIT_VTABLE(u)->start(u);
1091 }
1092
1093 bool unit_can_start(Unit *u) {
1094         assert(u);
1095
1096         return !!UNIT_VTABLE(u)->start;
1097 }
1098
1099 bool unit_can_isolate(Unit *u) {
1100         assert(u);
1101
1102         return unit_can_start(u) &&
1103                 u->allow_isolate;
1104 }
1105
1106 /* Errors:
1107  *         -EBADR:    This unit type does not support stopping.
1108  *         -EALREADY: Unit is already stopped.
1109  *         -EAGAIN:   An operation is already in progress. Retry later.
1110  */
1111 int unit_stop(Unit *u) {
1112         UnitActiveState state;
1113         Unit *following;
1114
1115         assert(u);
1116
1117         state = unit_active_state(u);
1118         if (UNIT_IS_INACTIVE_OR_FAILED(state))
1119                 return -EALREADY;
1120
1121         if ((following = unit_following(u))) {
1122                 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1123                 return unit_stop(following);
1124         }
1125
1126         unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1127         unit_status_print_starting_stopping(u, JOB_STOP);
1128
1129         if (!UNIT_VTABLE(u)->stop)
1130                 return -EBADR;
1131
1132         unit_add_to_dbus_queue(u);
1133
1134         return UNIT_VTABLE(u)->stop(u);
1135 }
1136
1137 /* Errors:
1138  *         -EBADR:    This unit type does not support reloading.
1139  *         -ENOEXEC:  Unit is not started.
1140  *         -EAGAIN:   An operation is already in progress. Retry later.
1141  */
1142 int unit_reload(Unit *u) {
1143         UnitActiveState state;
1144         Unit *following;
1145
1146         assert(u);
1147
1148         if (u->load_state != UNIT_LOADED)
1149                 return -EINVAL;
1150
1151         if (!unit_can_reload(u))
1152                 return -EBADR;
1153
1154         state = unit_active_state(u);
1155         if (state == UNIT_RELOADING)
1156                 return -EALREADY;
1157
1158         if (state != UNIT_ACTIVE)
1159                 return -ENOEXEC;
1160
1161         if ((following = unit_following(u))) {
1162                 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1163                 return unit_reload(following);
1164         }
1165
1166         unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1167
1168         unit_add_to_dbus_queue(u);
1169         return UNIT_VTABLE(u)->reload(u);
1170 }
1171
1172 bool unit_can_reload(Unit *u) {
1173         assert(u);
1174
1175         if (!UNIT_VTABLE(u)->reload)
1176                 return false;
1177
1178         if (!UNIT_VTABLE(u)->can_reload)
1179                 return true;
1180
1181         return UNIT_VTABLE(u)->can_reload(u);
1182 }
1183
1184 static void unit_check_unneeded(Unit *u) {
1185         Iterator i;
1186         Unit *other;
1187
1188         assert(u);
1189
1190         /* If this service shall be shut down when unneeded then do
1191          * so. */
1192
1193         if (!u->stop_when_unneeded)
1194                 return;
1195
1196         if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1197                 return;
1198
1199         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1200                 if (unit_pending_active(other))
1201                         return;
1202
1203         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1204                 if (unit_pending_active(other))
1205                         return;
1206
1207         SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1208                 if (unit_pending_active(other))
1209                         return;
1210
1211         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1212                 if (unit_pending_active(other))
1213                         return;
1214
1215         log_info("Service %s is not needed anymore. Stopping.", u->id);
1216
1217         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1218         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1219 }
1220
1221 static void retroactively_start_dependencies(Unit *u) {
1222         Iterator i;
1223         Unit *other;
1224
1225         assert(u);
1226         assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1227
1228         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1229                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1230                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1231                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1232
1233         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1234                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1235                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1236                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1237
1238         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1239                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1240                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1241                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1242
1243         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1244                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1245                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1246                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1247
1248         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1249                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1250                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1251                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1252
1253         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1254                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1255                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1256
1257         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1258                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1259                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1260 }
1261
1262 static void retroactively_stop_dependencies(Unit *u) {
1263         Iterator i;
1264         Unit *other;
1265
1266         assert(u);
1267         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1268
1269         /* Pull down units which are bound to us recursively if enabled */
1270         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1271                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1272                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1273 }
1274
1275 static void check_unneeded_dependencies(Unit *u) {
1276         Iterator i;
1277         Unit *other;
1278
1279         assert(u);
1280         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1281
1282         /* Garbage collect services that might not be needed anymore, if enabled */
1283         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1284                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1285                         unit_check_unneeded(other);
1286         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1287                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1288                         unit_check_unneeded(other);
1289         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1290                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1291                         unit_check_unneeded(other);
1292         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1293                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1294                         unit_check_unneeded(other);
1295         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1296                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1297                         unit_check_unneeded(other);
1298         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1299                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1300                         unit_check_unneeded(other);
1301 }
1302
1303 void unit_trigger_on_failure(Unit *u) {
1304         Unit *other;
1305         Iterator i;
1306
1307         assert(u);
1308
1309         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1310                 return;
1311
1312         log_info("Triggering OnFailure= dependencies of %s.", u->id);
1313
1314         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1315                 int r;
1316
1317                 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1318                         log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1319         }
1320 }
1321
1322 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1323         bool unexpected;
1324
1325         assert(u);
1326         assert(os < _UNIT_ACTIVE_STATE_MAX);
1327         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1328
1329         /* Note that this is called for all low-level state changes,
1330          * even if they might map to the same high-level
1331          * UnitActiveState! That means that ns == os is OK an expected
1332          * behavior here. For example: if a mount point is remounted
1333          * this function will be called too! */
1334
1335         if (u->manager->n_reloading <= 0) {
1336                 dual_timestamp ts;
1337
1338                 dual_timestamp_get(&ts);
1339
1340                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1341                         u->inactive_exit_timestamp = ts;
1342                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1343                         u->inactive_enter_timestamp = ts;
1344
1345                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1346                         u->active_enter_timestamp = ts;
1347                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1348                         u->active_exit_timestamp = ts;
1349
1350                 timer_unit_notify(u, ns);
1351                 path_unit_notify(u, ns);
1352         }
1353
1354         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1355                 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1356
1357         if (u->job) {
1358                 unexpected = false;
1359
1360                 if (u->job->state == JOB_WAITING)
1361
1362                         /* So we reached a different state for this
1363                          * job. Let's see if we can run it now if it
1364                          * failed previously due to EAGAIN. */
1365                         job_add_to_run_queue(u->job);
1366
1367                 /* Let's check whether this state change constitutes a
1368                  * finished job, or maybe contradicts a running job and
1369                  * hence needs to invalidate jobs. */
1370
1371                 switch (u->job->type) {
1372
1373                 case JOB_START:
1374                 case JOB_VERIFY_ACTIVE:
1375
1376                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1377                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1378                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1379                                 unexpected = true;
1380
1381                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1382                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1383                         }
1384
1385                         break;
1386
1387                 case JOB_RELOAD:
1388                 case JOB_RELOAD_OR_START:
1389
1390                         if (u->job->state == JOB_RUNNING) {
1391                                 if (ns == UNIT_ACTIVE)
1392                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1393                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1394                                         unexpected = true;
1395
1396                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1397                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1398                                 }
1399                         }
1400
1401                         break;
1402
1403                 case JOB_STOP:
1404                 case JOB_RESTART:
1405                 case JOB_TRY_RESTART:
1406
1407                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1408                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1409                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1410                                 unexpected = true;
1411                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1412                         }
1413
1414                         break;
1415
1416                 default:
1417                         assert_not_reached("Job type unknown");
1418                 }
1419
1420         } else
1421                 unexpected = true;
1422
1423         if (u->manager->n_reloading <= 0) {
1424
1425                 /* If this state change happened without being
1426                  * requested by a job, then let's retroactively start
1427                  * or stop dependencies. We skip that step when
1428                  * deserializing, since we don't want to create any
1429                  * additional jobs just because something is already
1430                  * activated. */
1431
1432                 if (unexpected) {
1433                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1434                                 retroactively_start_dependencies(u);
1435                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1436                                 retroactively_stop_dependencies(u);
1437                 }
1438
1439                 /* stop unneeded units regardless if going down was expected or not */
1440                 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1441                         check_unneeded_dependencies(u);
1442
1443                 if (ns != os && ns == UNIT_FAILED) {
1444                         log_struct_unit(LOG_NOTICE,
1445                                    u->id,
1446                                    "MESSAGE=Unit %s entered failed state", u->id,
1447                                    NULL);
1448                         unit_trigger_on_failure(u);
1449                 }
1450         }
1451
1452         /* Some names are special */
1453         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1454
1455                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1456                         /* The bus just might have become available,
1457                          * hence try to connect to it, if we aren't
1458                          * yet connected. */
1459                         bus_init(u->manager, true);
1460
1461                 if (u->type == UNIT_SERVICE &&
1462                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1463                     u->manager->n_reloading <= 0) {
1464                         /* Write audit record if we have just finished starting up */
1465                         manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1466                         u->in_audit = true;
1467                 }
1468
1469                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1470                         manager_send_unit_plymouth(u->manager, u);
1471
1472         } else {
1473
1474                 /* We don't care about D-Bus here, since we'll get an
1475                  * asynchronous notification for it anyway. */
1476
1477                 if (u->type == UNIT_SERVICE &&
1478                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1479                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1480                     u->manager->n_reloading <= 0) {
1481
1482                         /* Hmm, if there was no start record written
1483                          * write it now, so that we always have a nice
1484                          * pair */
1485                         if (!u->in_audit) {
1486                                 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1487
1488                                 if (ns == UNIT_INACTIVE)
1489                                         manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1490                         } else
1491                                 /* Write audit record if we have just finished shutting down */
1492                                 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1493
1494                         u->in_audit = false;
1495                 }
1496         }
1497
1498         manager_recheck_journal(u->manager);
1499
1500         /* Maybe we finished startup and are now ready for being
1501          * stopped because unneeded? */
1502         unit_check_unneeded(u);
1503
1504         unit_add_to_dbus_queue(u);
1505         unit_add_to_gc_queue(u);
1506 }
1507
1508 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1509         struct epoll_event ev;
1510
1511         assert(u);
1512         assert(fd >= 0);
1513         assert(w);
1514         assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1515
1516         zero(ev);
1517         ev.data.ptr = w;
1518         ev.events = events;
1519
1520         if (epoll_ctl(u->manager->epoll_fd,
1521                       w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1522                       fd,
1523                       &ev) < 0)
1524                 return -errno;
1525
1526         w->fd = fd;
1527         w->type = WATCH_FD;
1528         w->data.unit = u;
1529
1530         return 0;
1531 }
1532
1533 void unit_unwatch_fd(Unit *u, Watch *w) {
1534         assert(u);
1535         assert(w);
1536
1537         if (w->type == WATCH_INVALID)
1538                 return;
1539
1540         assert(w->type == WATCH_FD);
1541         assert(w->data.unit == u);
1542         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1543
1544         w->fd = -1;
1545         w->type = WATCH_INVALID;
1546         w->data.unit = NULL;
1547 }
1548
1549 int unit_watch_pid(Unit *u, pid_t pid) {
1550         assert(u);
1551         assert(pid >= 1);
1552
1553         /* Watch a specific PID. We only support one unit watching
1554          * each PID for now. */
1555
1556         return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1557 }
1558
1559 void unit_unwatch_pid(Unit *u, pid_t pid) {
1560         assert(u);
1561         assert(pid >= 1);
1562
1563         hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1564 }
1565
1566 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1567         struct itimerspec its;
1568         int flags, fd;
1569         bool ours;
1570
1571         assert(u);
1572         assert(w);
1573         assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1574
1575         /* This will try to reuse the old timer if there is one */
1576
1577         if (w->type == WATCH_UNIT_TIMER) {
1578                 assert(w->data.unit == u);
1579                 assert(w->fd >= 0);
1580
1581                 ours = false;
1582                 fd = w->fd;
1583         } else if (w->type == WATCH_INVALID) {
1584
1585                 ours = true;
1586                 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1587                 if (fd < 0)
1588                         return -errno;
1589         } else
1590                 assert_not_reached("Invalid watch type");
1591
1592         zero(its);
1593
1594         if (usec <= 0) {
1595                 /* Set absolute time in the past, but not 0, since we
1596                  * don't want to disarm the timer */
1597                 its.it_value.tv_sec = 0;
1598                 its.it_value.tv_nsec = 1;
1599
1600                 flags = TFD_TIMER_ABSTIME;
1601         } else {
1602                 timespec_store(&its.it_value, usec);
1603                 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1604         }
1605
1606         /* This will also flush the elapse counter */
1607         if (timerfd_settime(fd, flags, &its, NULL) < 0)
1608                 goto fail;
1609
1610         if (w->type == WATCH_INVALID) {
1611                 struct epoll_event ev;
1612
1613                 zero(ev);
1614                 ev.data.ptr = w;
1615                 ev.events = EPOLLIN;
1616
1617                 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1618                         goto fail;
1619         }
1620
1621         w->type = WATCH_UNIT_TIMER;
1622         w->fd = fd;
1623         w->data.unit = u;
1624
1625         return 0;
1626
1627 fail:
1628         if (ours)
1629                 close_nointr_nofail(fd);
1630
1631         return -errno;
1632 }
1633
1634 void unit_unwatch_timer(Unit *u, Watch *w) {
1635         assert(u);
1636         assert(w);
1637
1638         if (w->type == WATCH_INVALID)
1639                 return;
1640
1641         assert(w->type == WATCH_UNIT_TIMER);
1642         assert(w->data.unit == u);
1643         assert(w->fd >= 0);
1644
1645         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1646         close_nointr_nofail(w->fd);
1647
1648         w->fd = -1;
1649         w->type = WATCH_INVALID;
1650         w->data.unit = NULL;
1651 }
1652
1653 bool unit_job_is_applicable(Unit *u, JobType j) {
1654         assert(u);
1655         assert(j >= 0 && j < _JOB_TYPE_MAX);
1656
1657         switch (j) {
1658
1659         case JOB_VERIFY_ACTIVE:
1660         case JOB_START:
1661         case JOB_STOP:
1662         case JOB_NOP:
1663                 return true;
1664
1665         case JOB_RESTART:
1666         case JOB_TRY_RESTART:
1667                 return unit_can_start(u);
1668
1669         case JOB_RELOAD:
1670                 return unit_can_reload(u);
1671
1672         case JOB_RELOAD_OR_START:
1673                 return unit_can_reload(u) && unit_can_start(u);
1674
1675         default:
1676                 assert_not_reached("Invalid job type");
1677         }
1678 }
1679
1680 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1681
1682         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1683                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1684                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1685                 [UNIT_WANTS] = UNIT_WANTED_BY,
1686                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1687                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1688                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1689                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1690                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1691                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1692                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1693                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1694                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1695                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1696                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1697                 [UNIT_BEFORE] = UNIT_AFTER,
1698                 [UNIT_AFTER] = UNIT_BEFORE,
1699                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1700                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1701                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1702                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1703                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1704                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1705                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1706         };
1707         int r, q = 0, v = 0, w = 0;
1708
1709         assert(u);
1710         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1711         assert(other);
1712
1713         u = unit_follow_merge(u);
1714         other = unit_follow_merge(other);
1715
1716         /* We won't allow dependencies on ourselves. We will not
1717          * consider them an error however. */
1718         if (u == other)
1719                 return 0;
1720
1721         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1722                 return r;
1723
1724         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1725                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1726                         return r;
1727
1728         if (add_reference)
1729                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1730                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1731                         return r;
1732
1733         if ((q = set_put(u->dependencies[d], other)) < 0)
1734                 return q;
1735
1736         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1737                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1738                         r = v;
1739                         goto fail;
1740                 }
1741
1742         if (add_reference) {
1743                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1744                         r = w;
1745                         goto fail;
1746                 }
1747
1748                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1749                         goto fail;
1750         }
1751
1752         unit_add_to_dbus_queue(u);
1753         return 0;
1754
1755 fail:
1756         if (q > 0)
1757                 set_remove(u->dependencies[d], other);
1758
1759         if (v > 0)
1760                 set_remove(other->dependencies[inverse_table[d]], u);
1761
1762         if (w > 0)
1763                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1764
1765         return r;
1766 }
1767
1768 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1769         int r;
1770
1771         assert(u);
1772
1773         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1774                 return r;
1775
1776         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1777                 return r;
1778
1779         return 0;
1780 }
1781
1782 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1783         char *s;
1784
1785         assert(u);
1786         assert(name || path);
1787         assert(p);
1788
1789         if (!name)
1790                 name = path_get_file_name(path);
1791
1792         if (!unit_name_is_template(name)) {
1793                 *p = NULL;
1794                 return name;
1795         }
1796
1797         if (u->instance)
1798                 s = unit_name_replace_instance(name, u->instance);
1799         else {
1800                 char *i;
1801
1802                 i = unit_name_to_prefix(u->id);
1803                 if (!i)
1804                         return NULL;
1805
1806                 s = unit_name_replace_instance(name, i);
1807                 free(i);
1808         }
1809
1810         if (!s)
1811                 return NULL;
1812
1813         *p = s;
1814         return s;
1815 }
1816
1817 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1818         Unit *other;
1819         int r;
1820         _cleanup_free_ char *s = NULL;
1821
1822         assert(u);
1823         assert(name || path);
1824
1825         name = resolve_template(u, name, path, &s);
1826         if (!name)
1827                 return -ENOMEM;
1828
1829         r = manager_load_unit(u->manager, name, path, NULL, &other);
1830         if (r < 0)
1831                 return r;
1832
1833         return unit_add_dependency(u, d, other, add_reference);
1834 }
1835
1836 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1837         Unit *other;
1838         int r;
1839         char *s;
1840
1841         assert(u);
1842         assert(name || path);
1843
1844         if (!(name = resolve_template(u, name, path, &s)))
1845                 return -ENOMEM;
1846
1847         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1848                 goto finish;
1849
1850         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1851
1852 finish:
1853         free(s);
1854         return r;
1855 }
1856
1857 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1858         Unit *other;
1859         int r;
1860         char *s;
1861
1862         assert(u);
1863         assert(name || path);
1864
1865         if (!(name = resolve_template(u, name, path, &s)))
1866                 return -ENOMEM;
1867
1868         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1869                 goto finish;
1870
1871         r = unit_add_dependency(other, d, u, add_reference);
1872
1873 finish:
1874         free(s);
1875         return r;
1876 }
1877
1878 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1879         Unit *other;
1880         int r;
1881         char *s;
1882
1883         assert(u);
1884         assert(name || path);
1885
1886         if (!(name = resolve_template(u, name, path, &s)))
1887                 return -ENOMEM;
1888
1889         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1890                 goto finish;
1891
1892         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1893                 goto finish;
1894
1895 finish:
1896         free(s);
1897         return r;
1898 }
1899
1900 int set_unit_path(const char *p) {
1901         _cleanup_free_ char *c = NULL;
1902
1903         /* This is mostly for debug purposes */
1904         c = path_make_absolute_cwd(p);
1905         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1906                 return -errno;
1907
1908         return 0;
1909 }
1910
1911 char *unit_dbus_path(Unit *u) {
1912         assert(u);
1913
1914         if (!u->id)
1915                 return NULL;
1916
1917         return unit_dbus_path_from_name(u->id);
1918 }
1919
1920 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1921         int r;
1922
1923         assert(u);
1924         assert(b);
1925
1926         assert(b->path);
1927
1928         if (!b->controller) {
1929                 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1930                 if (!b->controller)
1931                         return log_oom();
1932
1933                 b->ours = true;
1934         }
1935
1936         /* Ensure this hasn't been added yet */
1937         assert(!b->unit);
1938
1939         if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1940                 CGroupBonding *l;
1941
1942                 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1943                 LIST_PREPEND(CGroupBonding, by_path, l, b);
1944
1945                 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1946                 if (r < 0) {
1947                         LIST_REMOVE(CGroupBonding, by_path, l, b);
1948                         return r;
1949                 }
1950         }
1951
1952         LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1953         b->unit = u;
1954
1955         return 0;
1956 }
1957
1958 char *unit_default_cgroup_path(Unit *u) {
1959         assert(u);
1960
1961         if (u->instance) {
1962                 _cleanup_free_ char *t = NULL;
1963
1964                 t = unit_name_template(u->id);
1965                 if (!t)
1966                         return NULL;
1967
1968                 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1969         } else
1970                 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1971 }
1972
1973 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1974         char *controller = NULL, *path = NULL;
1975         CGroupBonding *b = NULL;
1976         bool ours = false;
1977         int r;
1978
1979         assert(u);
1980         assert(name);
1981
1982         r = cg_split_spec(name, &controller, &path);
1983         if (r < 0)
1984                 return r;
1985
1986         if (!path) {
1987                 path = unit_default_cgroup_path(u);
1988                 ours = true;
1989         }
1990
1991         if (!controller) {
1992                 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1993                 ours = true;
1994         }
1995
1996         if (!path || !controller) {
1997                 free(path);
1998                 free(controller);
1999                 return log_oom();
2000         }
2001
2002         b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2003         if (b) {
2004                 if (streq(path, b->path)) {
2005                         free(path);
2006                         free(controller);
2007
2008                         if (ret)
2009                                 *ret = b;
2010                         return 0;
2011                 }
2012
2013                 if (overwrite && !b->essential) {
2014                         free(controller);
2015
2016                         free(b->path);
2017                         b->path = path;
2018
2019                         b->ours = ours;
2020                         b->realized = false;
2021
2022                         if (ret)
2023                                 *ret = b;
2024
2025                         return 1;
2026                 }
2027
2028                 r = -EEXIST;
2029                 b = NULL;
2030                 goto fail;
2031         }
2032
2033         b = new0(CGroupBonding, 1);
2034         if (!b) {
2035                 r = -ENOMEM;
2036                 goto fail;
2037         }
2038
2039         b->controller = controller;
2040         b->path = path;
2041         b->ours = ours;
2042         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2043
2044         r = unit_add_cgroup(u, b);
2045         if (r < 0)
2046                 goto fail;
2047
2048         if (ret)
2049                 *ret = b;
2050
2051         return 1;
2052
2053 fail:
2054         free(path);
2055         free(controller);
2056         free(b);
2057
2058         return r;
2059 }
2060
2061 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2062         CGroupBonding *b = NULL;
2063         int r = -ENOMEM;
2064
2065         assert(u);
2066
2067         if (!controller)
2068                 controller = SYSTEMD_CGROUP_CONTROLLER;
2069
2070         if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2071                 return 0;
2072
2073         b = new0(CGroupBonding, 1);
2074         if (!b)
2075                 return -ENOMEM;
2076
2077         b->controller = strdup(controller);
2078         if (!b->controller)
2079                 goto fail;
2080
2081         b->path = unit_default_cgroup_path(u);
2082         if (!b->path)
2083                 goto fail;
2084
2085         b->ours = true;
2086         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2087
2088         r = unit_add_cgroup(u, b);
2089         if (r < 0)
2090                 goto fail;
2091
2092         return 1;
2093
2094 fail:
2095         free(b->path);
2096         free(b->controller);
2097         free(b);
2098
2099         return r;
2100 }
2101
2102 int unit_add_default_cgroups(Unit *u) {
2103         CGroupAttribute *a;
2104         char **c;
2105         int r;
2106
2107         assert(u);
2108
2109         /* Adds in the default cgroups, if they weren't specified
2110          * otherwise. */
2111
2112         if (!u->manager->cgroup_hierarchy)
2113                 return 0;
2114
2115         r = unit_add_one_default_cgroup(u, NULL);
2116         if (r < 0)
2117                 return r;
2118
2119         STRV_FOREACH(c, u->manager->default_controllers)
2120                 unit_add_one_default_cgroup(u, *c);
2121
2122         LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2123                 unit_add_one_default_cgroup(u, a->controller);
2124
2125         return 0;
2126 }
2127
2128 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2129         assert(u);
2130
2131         return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2132 }
2133
2134 int unit_add_cgroup_attribute(
2135                 Unit *u,
2136                 const CGroupSemantics *semantics,
2137                 const char *controller,
2138                 const char *name,
2139                 const char *value,
2140                 CGroupAttribute **ret) {
2141
2142         _cleanup_free_ char *c = NULL;
2143         CGroupAttribute *a;
2144         int r;
2145
2146         assert(u);
2147         assert(value);
2148
2149         if (semantics) {
2150                 /* Semantics always take precedence */
2151                 if (semantics->name)
2152                         name = semantics->name;
2153
2154                 if (semantics->controller)
2155                         controller = semantics->controller;
2156         }
2157
2158         if (!name)
2159                 return -EINVAL;
2160
2161         if (!controller) {
2162                 r = cg_controller_from_attr(name, &c);
2163                 if (r < 0)
2164                         return -EINVAL;
2165
2166                 controller = c;
2167         }
2168
2169         if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2170                 return -EINVAL;
2171
2172         if (!filename_is_safe(name))
2173                 return -EINVAL;
2174
2175         if (!filename_is_safe(controller))
2176                 return -EINVAL;
2177
2178         /* Check if this attribute already exists. Note that we will
2179          * explicitly check for the value here too, as there are
2180          * attributes which accept multiple values. */
2181         a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2182         if (a) {
2183                 if (streq(value, a->value)) {
2184                         /* Exactly the same value is always OK, let's ignore this */
2185                         if (ret)
2186                                 *ret = a;
2187
2188                         return 0;
2189                 }
2190
2191                 if (semantics && !semantics->multiple) {
2192                         char *v;
2193
2194                         /* If this is a single-item entry, we can
2195                          * simply patch the existing attribute */
2196
2197                         v = strdup(value);
2198                         if (!v)
2199                                 return -ENOMEM;
2200
2201                         free(a->value);
2202                         a->value = v;
2203
2204                         if (ret)
2205                                 *ret = a;
2206                         return 1;
2207                 }
2208         }
2209
2210         a = new0(CGroupAttribute, 1);
2211         if (!a)
2212                 return -ENOMEM;
2213
2214         if (c) {
2215                 a->controller = c;
2216                 c = NULL;
2217         } else
2218                 a->controller = strdup(controller);
2219
2220         a->name = strdup(name);
2221         a->value = strdup(value);
2222
2223         if (!a->controller || !a->name || !a->value) {
2224                 free(a->controller);
2225                 free(a->name);
2226                 free(a->value);
2227                 free(a);
2228                 return -ENOMEM;
2229         }
2230
2231         a->semantics = semantics;
2232         a->unit = u;
2233
2234         LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2235
2236         if (ret)
2237                 *ret = a;
2238
2239         return 1;
2240 }
2241
2242 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2243         char *t;
2244         int r;
2245
2246         assert(u);
2247         assert(type);
2248         assert(_found);
2249
2250         if (!(t = unit_name_change_suffix(u->id, type)))
2251                 return -ENOMEM;
2252
2253         assert(!unit_has_name(u, t));
2254
2255         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2256         free(t);
2257
2258         assert(r < 0 || *_found != u);
2259
2260         return r;
2261 }
2262
2263 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2264         Unit *found;
2265         char *t;
2266
2267         assert(u);
2268         assert(type);
2269         assert(_found);
2270
2271         if (!(t = unit_name_change_suffix(u->id, type)))
2272                 return -ENOMEM;
2273
2274         assert(!unit_has_name(u, t));
2275
2276         found = manager_get_unit(u->manager, t);
2277         free(t);
2278
2279         if (!found)
2280                 return -ENOENT;
2281
2282         *_found = found;
2283         return 0;
2284 }
2285
2286 int unit_watch_bus_name(Unit *u, const char *name) {
2287         assert(u);
2288         assert(name);
2289
2290         /* Watch a specific name on the bus. We only support one unit
2291          * watching each name for now. */
2292
2293         return hashmap_put(u->manager->watch_bus, name, u);
2294 }
2295
2296 void unit_unwatch_bus_name(Unit *u, const char *name) {
2297         assert(u);
2298         assert(name);
2299
2300         hashmap_remove_value(u->manager->watch_bus, name, u);
2301 }
2302
2303 bool unit_can_serialize(Unit *u) {
2304         assert(u);
2305
2306         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2307 }
2308
2309 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2310         int r;
2311
2312         assert(u);
2313         assert(f);
2314         assert(fds);
2315
2316         if (!unit_can_serialize(u))
2317                 return 0;
2318
2319         if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2320                 return r;
2321
2322
2323         if (serialize_jobs) {
2324                 if (u->job) {
2325                         fprintf(f, "job\n");
2326                         job_serialize(u->job, f, fds);
2327                 }
2328
2329                 if (u->nop_job) {
2330                         fprintf(f, "job\n");
2331                         job_serialize(u->nop_job, f, fds);
2332                 }
2333         }
2334
2335         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2336         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2337         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2338         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2339         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2340
2341         if (dual_timestamp_is_set(&u->condition_timestamp))
2342                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2343
2344         /* End marker */
2345         fputc('\n', f);
2346         return 0;
2347 }
2348
2349 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2350         va_list ap;
2351
2352         assert(u);
2353         assert(f);
2354         assert(key);
2355         assert(format);
2356
2357         fputs(key, f);
2358         fputc('=', f);
2359
2360         va_start(ap, format);
2361         vfprintf(f, format, ap);
2362         va_end(ap);
2363
2364         fputc('\n', f);
2365 }
2366
2367 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2368         assert(u);
2369         assert(f);
2370         assert(key);
2371         assert(value);
2372
2373         fprintf(f, "%s=%s\n", key, value);
2374 }
2375
2376 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2377         int r;
2378
2379         assert(u);
2380         assert(f);
2381         assert(fds);
2382
2383         if (!unit_can_serialize(u))
2384                 return 0;
2385
2386         for (;;) {
2387                 char line[LINE_MAX], *l, *v;
2388                 size_t k;
2389
2390                 if (!fgets(line, sizeof(line), f)) {
2391                         if (feof(f))
2392                                 return 0;
2393                         return -errno;
2394                 }
2395
2396                 char_array_0(line);
2397                 l = strstrip(line);
2398
2399                 /* End marker */
2400                 if (l[0] == 0)
2401                         return 0;
2402
2403                 k = strcspn(l, "=");
2404
2405                 if (l[k] == '=') {
2406                         l[k] = 0;
2407                         v = l+k+1;
2408                 } else
2409                         v = l+k;
2410
2411                 if (streq(l, "job")) {
2412                         if (v[0] == '\0') {
2413                                 /* new-style serialized job */
2414                                 Job *j = job_new_raw(u);
2415                                 if (!j)
2416                                         return -ENOMEM;
2417
2418                                 r = job_deserialize(j, f, fds);
2419                                 if (r < 0) {
2420                                         job_free(j);
2421                                         return r;
2422                                 }
2423
2424                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2425                                 if (r < 0) {
2426                                         job_free(j);
2427                                         return r;
2428                                 }
2429
2430                                 r = job_install_deserialized(j);
2431                                 if (r < 0) {
2432                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2433                                         job_free(j);
2434                                         return r;
2435                                 }
2436                         } else {
2437                                 /* legacy */
2438                                 JobType type = job_type_from_string(v);
2439                                 if (type < 0)
2440                                         log_debug("Failed to parse job type value %s", v);
2441                                 else
2442                                         u->deserialized_job = type;
2443                         }
2444                         continue;
2445                 } else if (streq(l, "inactive-exit-timestamp")) {
2446                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2447                         continue;
2448                 } else if (streq(l, "active-enter-timestamp")) {
2449                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2450                         continue;
2451                 } else if (streq(l, "active-exit-timestamp")) {
2452                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2453                         continue;
2454                 } else if (streq(l, "inactive-enter-timestamp")) {
2455                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2456                         continue;
2457                 } else if (streq(l, "condition-timestamp")) {
2458                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2459                         continue;
2460                 } else if (streq(l, "condition-result")) {
2461                         int b;
2462
2463                         if ((b = parse_boolean(v)) < 0)
2464                                 log_debug("Failed to parse condition result value %s", v);
2465                         else
2466                                 u->condition_result = b;
2467
2468                         continue;
2469                 }
2470
2471                 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2472                         return r;
2473         }
2474 }
2475
2476 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2477         Unit *device;
2478         char *e;
2479         int r;
2480
2481         assert(u);
2482
2483         if (!what)
2484                 return 0;
2485
2486         /* Adds in links to the device node that this unit is based on */
2487
2488         if (!is_device_path(what))
2489                 return 0;
2490
2491         e = unit_name_from_path(what, ".device");
2492         if (!e)
2493                 return -ENOMEM;
2494
2495         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2496         free(e);
2497         if (r < 0)
2498                 return r;
2499
2500         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2501         if (r < 0)
2502                 return r;
2503
2504         if (wants) {
2505                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2506                 if (r < 0)
2507                         return r;
2508         }
2509
2510         return 0;
2511 }
2512
2513 int unit_coldplug(Unit *u) {
2514         int r;
2515
2516         assert(u);
2517
2518         if (UNIT_VTABLE(u)->coldplug)
2519                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2520                         return r;
2521
2522         if (u->job) {
2523                 r = job_coldplug(u->job);
2524                 if (r < 0)
2525                         return r;
2526         } else if (u->deserialized_job >= 0) {
2527                 /* legacy */
2528                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2529                 if (r < 0)
2530                         return r;
2531
2532                 u->deserialized_job = _JOB_TYPE_INVALID;
2533         }
2534
2535         return 0;
2536 }
2537
2538 bool unit_need_daemon_reload(Unit *u) {
2539         struct stat st;
2540
2541         assert(u);
2542
2543         if (u->fragment_path) {
2544                 zero(st);
2545                 if (stat(u->fragment_path, &st) < 0)
2546                         /* What, cannot access this anymore? */
2547                         return true;
2548
2549                 if (u->fragment_mtime > 0 &&
2550                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2551                         return true;
2552         }
2553
2554         if (u->source_path) {
2555                 zero(st);
2556                 if (stat(u->source_path, &st) < 0)
2557                         return true;
2558
2559                 if (u->source_mtime > 0 &&
2560                     timespec_load(&st.st_mtim) != u->source_mtime)
2561                         return true;
2562         }
2563
2564         return false;
2565 }
2566
2567 void unit_reset_failed(Unit *u) {
2568         assert(u);
2569
2570         if (UNIT_VTABLE(u)->reset_failed)
2571                 UNIT_VTABLE(u)->reset_failed(u);
2572 }
2573
2574 Unit *unit_following(Unit *u) {
2575         assert(u);
2576
2577         if (UNIT_VTABLE(u)->following)
2578                 return UNIT_VTABLE(u)->following(u);
2579
2580         return NULL;
2581 }
2582
2583 bool unit_pending_inactive(Unit *u) {
2584         assert(u);
2585
2586         /* Returns true if the unit is inactive or going down */
2587
2588         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2589                 return true;
2590
2591         if (u->job && u->job->type == JOB_STOP)
2592                 return true;
2593
2594         return false;
2595 }
2596
2597 bool unit_pending_active(Unit *u) {
2598         assert(u);
2599
2600         /* Returns true if the unit is active or going up */
2601
2602         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2603                 return true;
2604
2605         if (u->job &&
2606             (u->job->type == JOB_START ||
2607              u->job->type == JOB_RELOAD_OR_START ||
2608              u->job->type == JOB_RESTART))
2609                 return true;
2610
2611         return false;
2612 }
2613
2614 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2615         assert(u);
2616         assert(w >= 0 && w < _KILL_WHO_MAX);
2617         assert(signo > 0);
2618         assert(signo < _NSIG);
2619
2620         if (!UNIT_VTABLE(u)->kill)
2621                 return -ENOTSUP;
2622
2623         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2624 }
2625
2626 int unit_following_set(Unit *u, Set **s) {
2627         assert(u);
2628         assert(s);
2629
2630         if (UNIT_VTABLE(u)->following_set)
2631                 return UNIT_VTABLE(u)->following_set(u, s);
2632
2633         *s = NULL;
2634         return 0;
2635 }
2636
2637 UnitFileState unit_get_unit_file_state(Unit *u) {
2638         assert(u);
2639
2640         if (u->unit_file_state < 0 && u->fragment_path)
2641                 u->unit_file_state = unit_file_get_state(
2642                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2643                                 NULL, path_get_file_name(u->fragment_path));
2644
2645         return u->unit_file_state;
2646 }
2647
2648 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2649         assert(ref);
2650         assert(u);
2651
2652         if (ref->unit)
2653                 unit_ref_unset(ref);
2654
2655         ref->unit = u;
2656         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2657         return u;
2658 }
2659
2660 void unit_ref_unset(UnitRef *ref) {
2661         assert(ref);
2662
2663         if (!ref->unit)
2664                 return;
2665
2666         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2667         ref->unit = NULL;
2668 }
2669
2670 int unit_add_one_mount_link(Unit *u, Mount *m) {
2671         char **i;
2672
2673         assert(u);
2674         assert(m);
2675
2676         if (u->load_state != UNIT_LOADED ||
2677             UNIT(m)->load_state != UNIT_LOADED)
2678                 return 0;
2679
2680         STRV_FOREACH(i, u->requires_mounts_for) {
2681
2682                 if (UNIT(m) == u)
2683                         continue;
2684
2685                 if (!path_startswith(*i, m->where))
2686                         continue;
2687
2688                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2689         }
2690
2691         return 0;
2692 }
2693
2694 int unit_add_mount_links(Unit *u) {
2695         Unit *other;
2696         int r;
2697
2698         assert(u);
2699
2700         LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2701                 r = unit_add_one_mount_link(u, MOUNT(other));
2702                 if (r < 0)
2703                         return r;
2704         }
2705
2706         return 0;
2707 }
2708
2709 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2710         unsigned i;
2711         int r;
2712
2713         assert(u);
2714         assert(c);
2715
2716         /* This only copies in the ones that need memory */
2717
2718         for (i = 0; i < RLIMIT_NLIMITS; i++)
2719                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2720                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2721                         if (!c->rlimit[i])
2722                                 return -ENOMEM;
2723                 }
2724
2725         if (u->manager->running_as == SYSTEMD_USER &&
2726             !c->working_directory) {
2727
2728                 r = get_home_dir(&c->working_directory);
2729                 if (r < 0)
2730                         return r;
2731         }
2732
2733         return 0;
2734 }
2735
2736 ExecContext *unit_get_exec_context(Unit *u) {
2737         size_t offset;
2738         assert(u);
2739
2740         offset = UNIT_VTABLE(u)->exec_context_offset;
2741         if (offset <= 0)
2742                 return NULL;
2743
2744         return (ExecContext*) ((uint8_t*) u + offset);
2745 }
2746
2747 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2748         char *p, *q;
2749         int r;
2750
2751         assert(u);
2752         assert(name);
2753         assert(_p);
2754         assert(_q);
2755
2756         if (u->manager->running_as == SYSTEMD_USER && runtime)
2757                 return -ENOTSUP;
2758
2759         if (!filename_is_safe(name))
2760                 return -EINVAL;
2761
2762         if (u->manager->running_as == SYSTEMD_USER) {
2763                 _cleanup_free_ char *c = NULL;
2764
2765                 r = user_config_home(&c);
2766                 if (r < 0)
2767                         return r;
2768                 if (r == 0)
2769                         return -ENOENT;
2770
2771                 p = strjoin(c, "/", u->id, ".d", NULL);
2772         } else  if (runtime)
2773                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2774         else
2775                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2776         if (!p)
2777                 return -ENOMEM;
2778
2779         q = strjoin(p, "/50-", name, ".conf", NULL);
2780         if (!q) {
2781                 free(p);
2782                 return -ENOMEM;
2783         }
2784
2785         *_p = p;
2786         *_q = q;
2787         return 0;
2788 }
2789
2790 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2791         _cleanup_free_ char *p = NULL, *q = NULL;
2792         int r;
2793
2794         assert(u);
2795
2796         r = drop_in_file(u, runtime, name, &p, &q);
2797         if (r < 0)
2798                 return r;
2799
2800         mkdir_p(p, 0755);
2801         return write_one_line_file_atomic_label(q, data);
2802 }
2803
2804 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2805         _cleanup_free_ char *p = NULL, *q = NULL;
2806         int r;
2807
2808         assert(u);
2809
2810         r = drop_in_file(u, runtime, name, &p, &q);
2811         if (unlink(q) < 0)
2812                 r = -errno;
2813         else
2814                 r = 0;
2815
2816         rmdir(p);
2817         return r;
2818 }
2819
2820 int unit_kill_context(
2821                 Unit *u,
2822                 KillContext *c,
2823                 bool sigkill,
2824                 pid_t main_pid,
2825                 pid_t control_pid,
2826                 bool main_pid_alien) {
2827
2828         int sig, wait_for_exit = 0, r;
2829
2830         assert(u);
2831         assert(c);
2832
2833         if (c->kill_mode == KILL_NONE)
2834                 return 0;
2835
2836         sig = sigkill ? SIGKILL : c->kill_signal;
2837
2838         if (main_pid > 0) {
2839                 r = kill_and_sigcont(main_pid, sig);
2840
2841                 if (r < 0 && r != -ESRCH) {
2842                         _cleanup_free_ char *comm = NULL;
2843                         get_process_comm(main_pid, &comm);
2844
2845                         log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2846                                          (long) main_pid, strna(comm), strerror(-r));
2847                 } else
2848                         wait_for_exit = !main_pid_alien;
2849         }
2850
2851         if (control_pid > 0) {
2852                 r = kill_and_sigcont(control_pid, sig);
2853
2854                 if (r < 0 && r != -ESRCH) {
2855                         _cleanup_free_ char *comm = NULL;
2856                         get_process_comm(control_pid, &comm);
2857
2858                         log_warning_unit(u->id,
2859                                          "Failed to kill control process %li (%s): %s",
2860                                          (long) control_pid, strna(comm), strerror(-r));
2861                 } else
2862                         wait_for_exit = true;
2863         }
2864
2865         if (c->kill_mode == KILL_CONTROL_GROUP) {
2866                 _cleanup_set_free_ Set *pid_set = NULL;
2867
2868                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2869                 if (!pid_set)
2870                         return -ENOMEM;
2871
2872                 /* Exclude the main/control pids from being killed via the cgroup */
2873                 if (main_pid > 0) {
2874                         r = set_put(pid_set, LONG_TO_PTR(main_pid));
2875                         if (r < 0)
2876                                 return r;
2877                 }
2878
2879                 if (control_pid > 0) {
2880                         r = set_put(pid_set, LONG_TO_PTR(control_pid));
2881                         if (r < 0)
2882                                 return r;
2883                 }
2884
2885                 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2886                 if (r < 0) {
2887                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2888                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2889                 } else if (r > 0)
2890                         wait_for_exit = true;
2891         }
2892
2893         return wait_for_exit;
2894 }
2895
2896 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2897         [UNIT_ACTIVE] = "active",
2898         [UNIT_RELOADING] = "reloading",
2899         [UNIT_INACTIVE] = "inactive",
2900         [UNIT_FAILED] = "failed",
2901         [UNIT_ACTIVATING] = "activating",
2902         [UNIT_DEACTIVATING] = "deactivating"
2903 };
2904
2905 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2906
2907 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2908         [UNIT_REQUIRES] = "Requires",
2909         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2910         [UNIT_REQUISITE] = "Requisite",
2911         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2912         [UNIT_WANTS] = "Wants",
2913         [UNIT_BINDS_TO] = "BindsTo",
2914         [UNIT_PART_OF] = "PartOf",
2915         [UNIT_REQUIRED_BY] = "RequiredBy",
2916         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2917         [UNIT_WANTED_BY] = "WantedBy",
2918         [UNIT_BOUND_BY] = "BoundBy",
2919         [UNIT_CONSISTS_OF] = "ConsistsOf",
2920         [UNIT_CONFLICTS] = "Conflicts",
2921         [UNIT_CONFLICTED_BY] = "ConflictedBy",
2922         [UNIT_BEFORE] = "Before",
2923         [UNIT_AFTER] = "After",
2924         [UNIT_ON_FAILURE] = "OnFailure",
2925         [UNIT_TRIGGERS] = "Triggers",
2926         [UNIT_TRIGGERED_BY] = "TriggeredBy",
2927         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2928         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2929         [UNIT_REFERENCES] = "References",
2930         [UNIT_REFERENCED_BY] = "ReferencedBy",
2931 };
2932
2933 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);