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);
 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         Manager *m;
1324         bool unexpected;
1325
1326         assert(u);
1327         assert(os < _UNIT_ACTIVE_STATE_MAX);
1328         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1329
1330         /* Note that this is called for all low-level state changes,
1331          * even if they might map to the same high-level
1332          * UnitActiveState! That means that ns == os is OK an expected
1333          * behavior here. For example: if a mount point is remounted
1334          * this function will be called too! */
1335
1336         m = u->manager;
1337
1338         if (m->n_reloading <= 0) {
1339                 dual_timestamp ts;
1340
1341                 dual_timestamp_get(&ts);
1342
1343                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1344                         u->inactive_exit_timestamp = ts;
1345                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1346                         u->inactive_enter_timestamp = ts;
1347
1348                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1349                         u->active_enter_timestamp = ts;
1350                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1351                         u->active_exit_timestamp = ts;
1352
1353                 timer_unit_notify(u, ns);
1354                 path_unit_notify(u, ns);
1355         }
1356
1357         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1358                 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1359
1360         if (u->job) {
1361                 unexpected = false;
1362
1363                 if (u->job->state == JOB_WAITING)
1364
1365                         /* So we reached a different state for this
1366                          * job. Let's see if we can run it now if it
1367                          * failed previously due to EAGAIN. */
1368                         job_add_to_run_queue(u->job);
1369
1370                 /* Let's check whether this state change constitutes a
1371                  * finished job, or maybe contradicts a running job and
1372                  * hence needs to invalidate jobs. */
1373
1374                 switch (u->job->type) {
1375
1376                 case JOB_START:
1377                 case JOB_VERIFY_ACTIVE:
1378
1379                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1380                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1381                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1382                                 unexpected = true;
1383
1384                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1385                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1386                         }
1387
1388                         break;
1389
1390                 case JOB_RELOAD:
1391                 case JOB_RELOAD_OR_START:
1392
1393                         if (u->job->state == JOB_RUNNING) {
1394                                 if (ns == UNIT_ACTIVE)
1395                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1396                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1397                                         unexpected = true;
1398
1399                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1400                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1401                                 }
1402                         }
1403
1404                         break;
1405
1406                 case JOB_STOP:
1407                 case JOB_RESTART:
1408                 case JOB_TRY_RESTART:
1409
1410                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1411                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1412                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1413                                 unexpected = true;
1414                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1415                         }
1416
1417                         break;
1418
1419                 default:
1420                         assert_not_reached("Job type unknown");
1421                 }
1422
1423         } else
1424                 unexpected = true;
1425
1426         if (m->n_reloading <= 0) {
1427
1428                 /* If this state change happened without being
1429                  * requested by a job, then let's retroactively start
1430                  * or stop dependencies. We skip that step when
1431                  * deserializing, since we don't want to create any
1432                  * additional jobs just because something is already
1433                  * activated. */
1434
1435                 if (unexpected) {
1436                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1437                                 retroactively_start_dependencies(u);
1438                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1439                                 retroactively_stop_dependencies(u);
1440                 }
1441
1442                 /* stop unneeded units regardless if going down was expected or not */
1443                 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1444                         check_unneeded_dependencies(u);
1445
1446                 if (ns != os && ns == UNIT_FAILED) {
1447                         log_struct_unit(LOG_NOTICE,
1448                                    u->id,
1449                                    "MESSAGE=Unit %s entered failed state", u->id,
1450                                    NULL);
1451                         unit_trigger_on_failure(u);
1452                 }
1453         }
1454
1455         /* Some names are special */
1456         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1457
1458                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1459                         /* The bus just might have become available,
1460                          * hence try to connect to it, if we aren't
1461                          * yet connected. */
1462                         bus_init(m, true);
1463
1464                 if (u->type == UNIT_SERVICE &&
1465                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1466                     m->n_reloading <= 0) {
1467                         /* Write audit record if we have just finished starting up */
1468                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1469                         u->in_audit = true;
1470                 }
1471
1472                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1473                         manager_send_unit_plymouth(m, u);
1474
1475         } else {
1476
1477                 /* We don't care about D-Bus here, since we'll get an
1478                  * asynchronous notification for it anyway. */
1479
1480                 if (u->type == UNIT_SERVICE &&
1481                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1482                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1483                     m->n_reloading <= 0) {
1484
1485                         /* Hmm, if there was no start record written
1486                          * write it now, so that we always have a nice
1487                          * pair */
1488                         if (!u->in_audit) {
1489                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1490
1491                                 if (ns == UNIT_INACTIVE)
1492                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1493                         } else
1494                                 /* Write audit record if we have just finished shutting down */
1495                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1496
1497                         u->in_audit = false;
1498                 }
1499         }
1500
1501         manager_recheck_journal(m);
1502
1503         /* Maybe we finished startup and are now ready for being
1504          * stopped because unneeded? */
1505         unit_check_unneeded(u);
1506
1507         unit_add_to_dbus_queue(u);
1508         unit_add_to_gc_queue(u);
1509 }
1510
1511 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1512         struct epoll_event ev;
1513
1514         assert(u);
1515         assert(fd >= 0);
1516         assert(w);
1517         assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1518
1519         zero(ev);
1520         ev.data.ptr = w;
1521         ev.events = events;
1522
1523         if (epoll_ctl(u->manager->epoll_fd,
1524                       w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1525                       fd,
1526                       &ev) < 0)
1527                 return -errno;
1528
1529         w->fd = fd;
1530         w->type = WATCH_FD;
1531         w->data.unit = u;
1532
1533         return 0;
1534 }
1535
1536 void unit_unwatch_fd(Unit *u, Watch *w) {
1537         assert(u);
1538         assert(w);
1539
1540         if (w->type == WATCH_INVALID)
1541                 return;
1542
1543         assert(w->type == WATCH_FD);
1544         assert(w->data.unit == u);
1545         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1546
1547         w->fd = -1;
1548         w->type = WATCH_INVALID;
1549         w->data.unit = NULL;
1550 }
1551
1552 int unit_watch_pid(Unit *u, pid_t pid) {
1553         assert(u);
1554         assert(pid >= 1);
1555
1556         /* Watch a specific PID. We only support one unit watching
1557          * each PID for now. */
1558
1559         return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1560 }
1561
1562 void unit_unwatch_pid(Unit *u, pid_t pid) {
1563         assert(u);
1564         assert(pid >= 1);
1565
1566         hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1567 }
1568
1569 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1570         struct itimerspec its;
1571         int flags, fd;
1572         bool ours;
1573
1574         assert(u);
1575         assert(w);
1576         assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1577
1578         /* This will try to reuse the old timer if there is one */
1579
1580         if (w->type == WATCH_UNIT_TIMER) {
1581                 assert(w->data.unit == u);
1582                 assert(w->fd >= 0);
1583
1584                 ours = false;
1585                 fd = w->fd;
1586         } else if (w->type == WATCH_INVALID) {
1587
1588                 ours = true;
1589                 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1590                 if (fd < 0)
1591                         return -errno;
1592         } else
1593                 assert_not_reached("Invalid watch type");
1594
1595         zero(its);
1596
1597         if (usec <= 0) {
1598                 /* Set absolute time in the past, but not 0, since we
1599                  * don't want to disarm the timer */
1600                 its.it_value.tv_sec = 0;
1601                 its.it_value.tv_nsec = 1;
1602
1603                 flags = TFD_TIMER_ABSTIME;
1604         } else {
1605                 timespec_store(&its.it_value, usec);
1606                 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1607         }
1608
1609         /* This will also flush the elapse counter */
1610         if (timerfd_settime(fd, flags, &its, NULL) < 0)
1611                 goto fail;
1612
1613         if (w->type == WATCH_INVALID) {
1614                 struct epoll_event ev;
1615
1616                 zero(ev);
1617                 ev.data.ptr = w;
1618                 ev.events = EPOLLIN;
1619
1620                 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1621                         goto fail;
1622         }
1623
1624         w->type = WATCH_UNIT_TIMER;
1625         w->fd = fd;
1626         w->data.unit = u;
1627
1628         return 0;
1629
1630 fail:
1631         if (ours)
1632                 close_nointr_nofail(fd);
1633
1634         return -errno;
1635 }
1636
1637 void unit_unwatch_timer(Unit *u, Watch *w) {
1638         assert(u);
1639         assert(w);
1640
1641         if (w->type == WATCH_INVALID)
1642                 return;
1643
1644         assert(w->type == WATCH_UNIT_TIMER);
1645         assert(w->data.unit == u);
1646         assert(w->fd >= 0);
1647
1648         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1649         close_nointr_nofail(w->fd);
1650
1651         w->fd = -1;
1652         w->type = WATCH_INVALID;
1653         w->data.unit = NULL;
1654 }
1655
1656 bool unit_job_is_applicable(Unit *u, JobType j) {
1657         assert(u);
1658         assert(j >= 0 && j < _JOB_TYPE_MAX);
1659
1660         switch (j) {
1661
1662         case JOB_VERIFY_ACTIVE:
1663         case JOB_START:
1664         case JOB_STOP:
1665         case JOB_NOP:
1666                 return true;
1667
1668         case JOB_RESTART:
1669         case JOB_TRY_RESTART:
1670                 return unit_can_start(u);
1671
1672         case JOB_RELOAD:
1673                 return unit_can_reload(u);
1674
1675         case JOB_RELOAD_OR_START:
1676                 return unit_can_reload(u) && unit_can_start(u);
1677
1678         default:
1679                 assert_not_reached("Invalid job type");
1680         }
1681 }
1682
1683 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1684
1685         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1686                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1687                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1688                 [UNIT_WANTS] = UNIT_WANTED_BY,
1689                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1690                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1691                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1692                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1693                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1694                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1695                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1696                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1697                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1698                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1699                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1700                 [UNIT_BEFORE] = UNIT_AFTER,
1701                 [UNIT_AFTER] = UNIT_BEFORE,
1702                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1703                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1704                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1705                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1706                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1707                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1708                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1709         };
1710         int r, q = 0, v = 0, w = 0;
1711
1712         assert(u);
1713         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1714         assert(other);
1715
1716         u = unit_follow_merge(u);
1717         other = unit_follow_merge(other);
1718
1719         /* We won't allow dependencies on ourselves. We will not
1720          * consider them an error however. */
1721         if (u == other)
1722                 return 0;
1723
1724         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1725                 return r;
1726
1727         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1728                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1729                         return r;
1730
1731         if (add_reference)
1732                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1733                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1734                         return r;
1735
1736         if ((q = set_put(u->dependencies[d], other)) < 0)
1737                 return q;
1738
1739         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1740                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1741                         r = v;
1742                         goto fail;
1743                 }
1744
1745         if (add_reference) {
1746                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1747                         r = w;
1748                         goto fail;
1749                 }
1750
1751                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1752                         goto fail;
1753         }
1754
1755         unit_add_to_dbus_queue(u);
1756         return 0;
1757
1758 fail:
1759         if (q > 0)
1760                 set_remove(u->dependencies[d], other);
1761
1762         if (v > 0)
1763                 set_remove(other->dependencies[inverse_table[d]], u);
1764
1765         if (w > 0)
1766                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1767
1768         return r;
1769 }
1770
1771 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1772         int r;
1773
1774         assert(u);
1775
1776         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1777                 return r;
1778
1779         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1780                 return r;
1781
1782         return 0;
1783 }
1784
1785 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1786         char *s;
1787
1788         assert(u);
1789         assert(name || path);
1790         assert(p);
1791
1792         if (!name)
1793                 name = path_get_file_name(path);
1794
1795         if (!unit_name_is_template(name)) {
1796                 *p = NULL;
1797                 return name;
1798         }
1799
1800         if (u->instance)
1801                 s = unit_name_replace_instance(name, u->instance);
1802         else {
1803                 char *i;
1804
1805                 i = unit_name_to_prefix(u->id);
1806                 if (!i)
1807                         return NULL;
1808
1809                 s = unit_name_replace_instance(name, i);
1810                 free(i);
1811         }
1812
1813         if (!s)
1814                 return NULL;
1815
1816         *p = s;
1817         return s;
1818 }
1819
1820 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1821         Unit *other;
1822         int r;
1823         _cleanup_free_ char *s = NULL;
1824
1825         assert(u);
1826         assert(name || path);
1827
1828         name = resolve_template(u, name, path, &s);
1829         if (!name)
1830                 return -ENOMEM;
1831
1832         r = manager_load_unit(u->manager, name, path, NULL, &other);
1833         if (r < 0)
1834                 return r;
1835
1836         return unit_add_dependency(u, d, other, add_reference);
1837 }
1838
1839 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1840         Unit *other;
1841         int r;
1842         char *s;
1843
1844         assert(u);
1845         assert(name || path);
1846
1847         if (!(name = resolve_template(u, name, path, &s)))
1848                 return -ENOMEM;
1849
1850         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1851                 goto finish;
1852
1853         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1854
1855 finish:
1856         free(s);
1857         return r;
1858 }
1859
1860 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1861         Unit *other;
1862         int r;
1863         char *s;
1864
1865         assert(u);
1866         assert(name || path);
1867
1868         if (!(name = resolve_template(u, name, path, &s)))
1869                 return -ENOMEM;
1870
1871         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1872                 goto finish;
1873
1874         r = unit_add_dependency(other, d, u, add_reference);
1875
1876 finish:
1877         free(s);
1878         return r;
1879 }
1880
1881 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1882         Unit *other;
1883         int r;
1884         char *s;
1885
1886         assert(u);
1887         assert(name || path);
1888
1889         if (!(name = resolve_template(u, name, path, &s)))
1890                 return -ENOMEM;
1891
1892         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1893                 goto finish;
1894
1895         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1896                 goto finish;
1897
1898 finish:
1899         free(s);
1900         return r;
1901 }
1902
1903 int set_unit_path(const char *p) {
1904         _cleanup_free_ char *c = NULL;
1905
1906         /* This is mostly for debug purposes */
1907         c = path_make_absolute_cwd(p);
1908         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1909                 return -errno;
1910
1911         return 0;
1912 }
1913
1914 char *unit_dbus_path(Unit *u) {
1915         assert(u);
1916
1917         if (!u->id)
1918                 return NULL;
1919
1920         return unit_dbus_path_from_name(u->id);
1921 }
1922
1923 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1924         int r;
1925
1926         assert(u);
1927         assert(b);
1928
1929         assert(b->path);
1930
1931         if (!b->controller) {
1932                 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1933                 if (!b->controller)
1934                         return log_oom();
1935
1936                 b->ours = true;
1937         }
1938
1939         /* Ensure this hasn't been added yet */
1940         assert(!b->unit);
1941
1942         if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1943                 CGroupBonding *l;
1944
1945                 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1946                 LIST_PREPEND(CGroupBonding, by_path, l, b);
1947
1948                 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1949                 if (r < 0) {
1950                         LIST_REMOVE(CGroupBonding, by_path, l, b);
1951                         return r;
1952                 }
1953         }
1954
1955         LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1956         b->unit = u;
1957
1958         return 0;
1959 }
1960
1961 char *unit_default_cgroup_path(Unit *u) {
1962         assert(u);
1963
1964         if (u->instance) {
1965                 _cleanup_free_ char *t = NULL;
1966
1967                 t = unit_name_template(u->id);
1968                 if (!t)
1969                         return NULL;
1970
1971                 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1972         } else
1973                 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1974 }
1975
1976 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1977         char *controller = NULL, *path = NULL;
1978         CGroupBonding *b = NULL;
1979         bool ours = false;
1980         int r;
1981
1982         assert(u);
1983         assert(name);
1984
1985         r = cg_split_spec(name, &controller, &path);
1986         if (r < 0)
1987                 return r;
1988
1989         if (!path) {
1990                 path = unit_default_cgroup_path(u);
1991                 ours = true;
1992         }
1993
1994         if (!controller) {
1995                 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1996                 ours = true;
1997         }
1998
1999         if (!path || !controller) {
2000                 free(path);
2001                 free(controller);
2002                 return log_oom();
2003         }
2004
2005         b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2006         if (b) {
2007                 if (streq(path, b->path)) {
2008                         free(path);
2009                         free(controller);
2010
2011                         if (ret)
2012                                 *ret = b;
2013                         return 0;
2014                 }
2015
2016                 if (overwrite && !b->essential) {
2017                         free(controller);
2018
2019                         free(b->path);
2020                         b->path = path;
2021
2022                         b->ours = ours;
2023                         b->realized = false;
2024
2025                         if (ret)
2026                                 *ret = b;
2027
2028                         return 1;
2029                 }
2030
2031                 r = -EEXIST;
2032                 b = NULL;
2033                 goto fail;
2034         }
2035
2036         b = new0(CGroupBonding, 1);
2037         if (!b) {
2038                 r = -ENOMEM;
2039                 goto fail;
2040         }
2041
2042         b->controller = controller;
2043         b->path = path;
2044         b->ours = ours;
2045         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2046
2047         r = unit_add_cgroup(u, b);
2048         if (r < 0)
2049                 goto fail;
2050
2051         if (ret)
2052                 *ret = b;
2053
2054         return 1;
2055
2056 fail:
2057         free(path);
2058         free(controller);
2059         free(b);
2060
2061         return r;
2062 }
2063
2064 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2065         CGroupBonding *b = NULL;
2066         int r = -ENOMEM;
2067
2068         assert(u);
2069
2070         if (!controller)
2071                 controller = SYSTEMD_CGROUP_CONTROLLER;
2072
2073         if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2074                 return 0;
2075
2076         b = new0(CGroupBonding, 1);
2077         if (!b)
2078                 return -ENOMEM;
2079
2080         b->controller = strdup(controller);
2081         if (!b->controller)
2082                 goto fail;
2083
2084         b->path = unit_default_cgroup_path(u);
2085         if (!b->path)
2086                 goto fail;
2087
2088         b->ours = true;
2089         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2090
2091         r = unit_add_cgroup(u, b);
2092         if (r < 0)
2093                 goto fail;
2094
2095         return 1;
2096
2097 fail:
2098         free(b->path);
2099         free(b->controller);
2100         free(b);
2101
2102         return r;
2103 }
2104
2105 int unit_add_default_cgroups(Unit *u) {
2106         CGroupAttribute *a;
2107         char **c;
2108         int r;
2109
2110         assert(u);
2111
2112         /* Adds in the default cgroups, if they weren't specified
2113          * otherwise. */
2114
2115         if (!u->manager->cgroup_hierarchy)
2116                 return 0;
2117
2118         r = unit_add_one_default_cgroup(u, NULL);
2119         if (r < 0)
2120                 return r;
2121
2122         STRV_FOREACH(c, u->manager->default_controllers)
2123                 unit_add_one_default_cgroup(u, *c);
2124
2125         LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2126                 unit_add_one_default_cgroup(u, a->controller);
2127
2128         return 0;
2129 }
2130
2131 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2132         assert(u);
2133
2134         return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2135 }
2136
2137 int unit_add_cgroup_attribute(
2138                 Unit *u,
2139                 const CGroupSemantics *semantics,
2140                 const char *controller,
2141                 const char *name,
2142                 const char *value,
2143                 CGroupAttribute **ret) {
2144
2145         _cleanup_free_ char *c = NULL;
2146         CGroupAttribute *a;
2147         int r;
2148
2149         assert(u);
2150         assert(value);
2151
2152         if (semantics) {
2153                 /* Semantics always take precedence */
2154                 if (semantics->name)
2155                         name = semantics->name;
2156
2157                 if (semantics->controller)
2158                         controller = semantics->controller;
2159         }
2160
2161         if (!name)
2162                 return -EINVAL;
2163
2164         if (!controller) {
2165                 r = cg_controller_from_attr(name, &c);
2166                 if (r < 0)
2167                         return -EINVAL;
2168
2169                 controller = c;
2170         }
2171
2172         if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2173                 return -EINVAL;
2174
2175         if (!filename_is_safe(name))
2176                 return -EINVAL;
2177
2178         if (!filename_is_safe(controller))
2179                 return -EINVAL;
2180
2181         /* Check if this attribute already exists. Note that we will
2182          * explicitly check for the value here too, as there are
2183          * attributes which accept multiple values. */
2184         a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2185         if (a) {
2186                 if (streq(value, a->value)) {
2187                         /* Exactly the same value is always OK, let's ignore this */
2188                         if (ret)
2189                                 *ret = a;
2190
2191                         return 0;
2192                 }
2193
2194                 if (semantics && !semantics->multiple) {
2195                         char *v;
2196
2197                         /* If this is a single-item entry, we can
2198                          * simply patch the existing attribute */
2199
2200                         v = strdup(value);
2201                         if (!v)
2202                                 return -ENOMEM;
2203
2204                         free(a->value);
2205                         a->value = v;
2206
2207                         if (ret)
2208                                 *ret = a;
2209                         return 1;
2210                 }
2211         }
2212
2213         a = new0(CGroupAttribute, 1);
2214         if (!a)
2215                 return -ENOMEM;
2216
2217         if (c) {
2218                 a->controller = c;
2219                 c = NULL;
2220         } else
2221                 a->controller = strdup(controller);
2222
2223         a->name = strdup(name);
2224         a->value = strdup(value);
2225
2226         if (!a->controller || !a->name || !a->value) {
2227                 free(a->controller);
2228                 free(a->name);
2229                 free(a->value);
2230                 free(a);
2231                 return -ENOMEM;
2232         }
2233
2234         a->semantics = semantics;
2235         a->unit = u;
2236
2237         LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2238
2239         if (ret)
2240                 *ret = a;
2241
2242         return 1;
2243 }
2244
2245 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2246         char *t;
2247         int r;
2248
2249         assert(u);
2250         assert(type);
2251         assert(_found);
2252
2253         if (!(t = unit_name_change_suffix(u->id, type)))
2254                 return -ENOMEM;
2255
2256         assert(!unit_has_name(u, t));
2257
2258         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2259         free(t);
2260
2261         assert(r < 0 || *_found != u);
2262
2263         return r;
2264 }
2265
2266 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2267         Unit *found;
2268         char *t;
2269
2270         assert(u);
2271         assert(type);
2272         assert(_found);
2273
2274         if (!(t = unit_name_change_suffix(u->id, type)))
2275                 return -ENOMEM;
2276
2277         assert(!unit_has_name(u, t));
2278
2279         found = manager_get_unit(u->manager, t);
2280         free(t);
2281
2282         if (!found)
2283                 return -ENOENT;
2284
2285         *_found = found;
2286         return 0;
2287 }
2288
2289 int unit_watch_bus_name(Unit *u, const char *name) {
2290         assert(u);
2291         assert(name);
2292
2293         /* Watch a specific name on the bus. We only support one unit
2294          * watching each name for now. */
2295
2296         return hashmap_put(u->manager->watch_bus, name, u);
2297 }
2298
2299 void unit_unwatch_bus_name(Unit *u, const char *name) {
2300         assert(u);
2301         assert(name);
2302
2303         hashmap_remove_value(u->manager->watch_bus, name, u);
2304 }
2305
2306 bool unit_can_serialize(Unit *u) {
2307         assert(u);
2308
2309         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2310 }
2311
2312 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2313         int r;
2314
2315         assert(u);
2316         assert(f);
2317         assert(fds);
2318
2319         if (!unit_can_serialize(u))
2320                 return 0;
2321
2322         if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2323                 return r;
2324
2325
2326         if (serialize_jobs) {
2327                 if (u->job) {
2328                         fprintf(f, "job\n");
2329                         job_serialize(u->job, f, fds);
2330                 }
2331
2332                 if (u->nop_job) {
2333                         fprintf(f, "job\n");
2334                         job_serialize(u->nop_job, f, fds);
2335                 }
2336         }
2337
2338         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2339         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2340         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2341         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2342         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2343
2344         if (dual_timestamp_is_set(&u->condition_timestamp))
2345                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2346
2347         /* End marker */
2348         fputc('\n', f);
2349         return 0;
2350 }
2351
2352 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2353         va_list ap;
2354
2355         assert(u);
2356         assert(f);
2357         assert(key);
2358         assert(format);
2359
2360         fputs(key, f);
2361         fputc('=', f);
2362
2363         va_start(ap, format);
2364         vfprintf(f, format, ap);
2365         va_end(ap);
2366
2367         fputc('\n', f);
2368 }
2369
2370 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2371         assert(u);
2372         assert(f);
2373         assert(key);
2374         assert(value);
2375
2376         fprintf(f, "%s=%s\n", key, value);
2377 }
2378
2379 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2380         int r;
2381
2382         assert(u);
2383         assert(f);
2384         assert(fds);
2385
2386         if (!unit_can_serialize(u))
2387                 return 0;
2388
2389         for (;;) {
2390                 char line[LINE_MAX], *l, *v;
2391                 size_t k;
2392
2393                 if (!fgets(line, sizeof(line), f)) {
2394                         if (feof(f))
2395                                 return 0;
2396                         return -errno;
2397                 }
2398
2399                 char_array_0(line);
2400                 l = strstrip(line);
2401
2402                 /* End marker */
2403                 if (l[0] == 0)
2404                         return 0;
2405
2406                 k = strcspn(l, "=");
2407
2408                 if (l[k] == '=') {
2409                         l[k] = 0;
2410                         v = l+k+1;
2411                 } else
2412                         v = l+k;
2413
2414                 if (streq(l, "job")) {
2415                         if (v[0] == '\0') {
2416                                 /* new-style serialized job */
2417                                 Job *j = job_new_raw(u);
2418                                 if (!j)
2419                                         return -ENOMEM;
2420
2421                                 r = job_deserialize(j, f, fds);
2422                                 if (r < 0) {
2423                                         job_free(j);
2424                                         return r;
2425                                 }
2426
2427                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2428                                 if (r < 0) {
2429                                         job_free(j);
2430                                         return r;
2431                                 }
2432
2433                                 r = job_install_deserialized(j);
2434                                 if (r < 0) {
2435                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2436                                         job_free(j);
2437                                         return r;
2438                                 }
2439                         } else {
2440                                 /* legacy */
2441                                 JobType type = job_type_from_string(v);
2442                                 if (type < 0)
2443                                         log_debug("Failed to parse job type value %s", v);
2444                                 else
2445                                         u->deserialized_job = type;
2446                         }
2447                         continue;
2448                 } else if (streq(l, "inactive-exit-timestamp")) {
2449                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2450                         continue;
2451                 } else if (streq(l, "active-enter-timestamp")) {
2452                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2453                         continue;
2454                 } else if (streq(l, "active-exit-timestamp")) {
2455                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2456                         continue;
2457                 } else if (streq(l, "inactive-enter-timestamp")) {
2458                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2459                         continue;
2460                 } else if (streq(l, "condition-timestamp")) {
2461                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2462                         continue;
2463                 } else if (streq(l, "condition-result")) {
2464                         int b;
2465
2466                         if ((b = parse_boolean(v)) < 0)
2467                                 log_debug("Failed to parse condition result value %s", v);
2468                         else
2469                                 u->condition_result = b;
2470
2471                         continue;
2472                 }
2473
2474                 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2475                         return r;
2476         }
2477 }
2478
2479 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2480         Unit *device;
2481         char *e;
2482         int r;
2483
2484         assert(u);
2485
2486         if (!what)
2487                 return 0;
2488
2489         /* Adds in links to the device node that this unit is based on */
2490
2491         if (!is_device_path(what))
2492                 return 0;
2493
2494         e = unit_name_from_path(what, ".device");
2495         if (!e)
2496                 return -ENOMEM;
2497
2498         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2499         free(e);
2500         if (r < 0)
2501                 return r;
2502
2503         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2504         if (r < 0)
2505                 return r;
2506
2507         if (wants) {
2508                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2509                 if (r < 0)
2510                         return r;
2511         }
2512
2513         return 0;
2514 }
2515
2516 int unit_coldplug(Unit *u) {
2517         int r;
2518
2519         assert(u);
2520
2521         if (UNIT_VTABLE(u)->coldplug)
2522                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2523                         return r;
2524
2525         if (u->job) {
2526                 r = job_coldplug(u->job);
2527                 if (r < 0)
2528                         return r;
2529         } else if (u->deserialized_job >= 0) {
2530                 /* legacy */
2531                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2532                 if (r < 0)
2533                         return r;
2534
2535                 u->deserialized_job = _JOB_TYPE_INVALID;
2536         }
2537
2538         return 0;
2539 }
2540
2541 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2542         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2543 }
2544
2545 bool unit_need_daemon_reload(Unit *u) {
2546         struct stat st;
2547
2548         assert(u);
2549
2550         if (u->fragment_path) {
2551                 zero(st);
2552                 if (stat(u->fragment_path, &st) < 0)
2553                         /* What, cannot access this anymore? */
2554                         return true;
2555
2556                 if (u->fragment_mtime > 0 &&
2557                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2558                         return true;
2559         }
2560
2561         if (u->source_path) {
2562                 zero(st);
2563                 if (stat(u->source_path, &st) < 0)
2564                         return true;
2565
2566                 if (u->source_mtime > 0 &&
2567                     timespec_load(&st.st_mtim) != u->source_mtime)
2568                         return true;
2569         }
2570
2571         return false;
2572 }
2573
2574 void unit_reset_failed(Unit *u) {
2575         assert(u);
2576
2577         if (UNIT_VTABLE(u)->reset_failed)
2578                 UNIT_VTABLE(u)->reset_failed(u);
2579 }
2580
2581 Unit *unit_following(Unit *u) {
2582         assert(u);
2583
2584         if (UNIT_VTABLE(u)->following)
2585                 return UNIT_VTABLE(u)->following(u);
2586
2587         return NULL;
2588 }
2589
2590 bool unit_pending_inactive(Unit *u) {
2591         assert(u);
2592
2593         /* Returns true if the unit is inactive or going down */
2594
2595         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2596                 return true;
2597
2598         if (u->job && u->job->type == JOB_STOP)
2599                 return true;
2600
2601         return false;
2602 }
2603
2604 bool unit_pending_active(Unit *u) {
2605         assert(u);
2606
2607         /* Returns true if the unit is active or going up */
2608
2609         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2610                 return true;
2611
2612         if (u->job &&
2613             (u->job->type == JOB_START ||
2614              u->job->type == JOB_RELOAD_OR_START ||
2615              u->job->type == JOB_RESTART))
2616                 return true;
2617
2618         return false;
2619 }
2620
2621 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2622         assert(u);
2623         assert(w >= 0 && w < _KILL_WHO_MAX);
2624         assert(signo > 0);
2625         assert(signo < _NSIG);
2626
2627         if (!UNIT_VTABLE(u)->kill)
2628                 return -ENOTSUP;
2629
2630         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2631 }
2632
2633 int unit_following_set(Unit *u, Set **s) {
2634         assert(u);
2635         assert(s);
2636
2637         if (UNIT_VTABLE(u)->following_set)
2638                 return UNIT_VTABLE(u)->following_set(u, s);
2639
2640         *s = NULL;
2641         return 0;
2642 }
2643
2644 UnitFileState unit_get_unit_file_state(Unit *u) {
2645         assert(u);
2646
2647         if (u->unit_file_state < 0 && u->fragment_path)
2648                 u->unit_file_state = unit_file_get_state(
2649                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2650                                 NULL, path_get_file_name(u->fragment_path));
2651
2652         return u->unit_file_state;
2653 }
2654
2655 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2656         assert(ref);
2657         assert(u);
2658
2659         if (ref->unit)
2660                 unit_ref_unset(ref);
2661
2662         ref->unit = u;
2663         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2664         return u;
2665 }
2666
2667 void unit_ref_unset(UnitRef *ref) {
2668         assert(ref);
2669
2670         if (!ref->unit)
2671                 return;
2672
2673         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2674         ref->unit = NULL;
2675 }
2676
2677 int unit_add_one_mount_link(Unit *u, Mount *m) {
2678         char **i;
2679
2680         assert(u);
2681         assert(m);
2682
2683         if (u->load_state != UNIT_LOADED ||
2684             UNIT(m)->load_state != UNIT_LOADED)
2685                 return 0;
2686
2687         STRV_FOREACH(i, u->requires_mounts_for) {
2688
2689                 if (UNIT(m) == u)
2690                         continue;
2691
2692                 if (!path_startswith(*i, m->where))
2693                         continue;
2694
2695                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2696         }
2697
2698         return 0;
2699 }
2700
2701 int unit_add_mount_links(Unit *u) {
2702         Unit *other;
2703         int r;
2704
2705         assert(u);
2706
2707         LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2708                 r = unit_add_one_mount_link(u, MOUNT(other));
2709                 if (r < 0)
2710                         return r;
2711         }
2712
2713         return 0;
2714 }
2715
2716 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2717         unsigned i;
2718         int r;
2719
2720         assert(u);
2721         assert(c);
2722
2723         /* This only copies in the ones that need memory */
2724
2725         for (i = 0; i < RLIMIT_NLIMITS; i++)
2726                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2727                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2728                         if (!c->rlimit[i])
2729                                 return -ENOMEM;
2730                 }
2731
2732         if (u->manager->running_as == SYSTEMD_USER &&
2733             !c->working_directory) {
2734
2735                 r = get_home_dir(&c->working_directory);
2736                 if (r < 0)
2737                         return r;
2738         }
2739
2740         return 0;
2741 }
2742
2743 ExecContext *unit_get_exec_context(Unit *u) {
2744         size_t offset;
2745         assert(u);
2746
2747         offset = UNIT_VTABLE(u)->exec_context_offset;
2748         if (offset <= 0)
2749                 return NULL;
2750
2751         return (ExecContext*) ((uint8_t*) u + offset);
2752 }
2753
2754 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2755         char *p, *q;
2756         int r;
2757
2758         assert(u);
2759         assert(name);
2760         assert(_p);
2761         assert(_q);
2762
2763         if (u->manager->running_as == SYSTEMD_USER && runtime)
2764                 return -ENOTSUP;
2765
2766         if (!filename_is_safe(name))
2767                 return -EINVAL;
2768
2769         if (u->manager->running_as == SYSTEMD_USER) {
2770                 _cleanup_free_ char *c = NULL;
2771
2772                 r = user_config_home(&c);
2773                 if (r < 0)
2774                         return r;
2775                 if (r == 0)
2776                         return -ENOENT;
2777
2778                 p = strjoin(c, "/", u->id, ".d", NULL);
2779         } else  if (runtime)
2780                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2781         else
2782                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2783         if (!p)
2784                 return -ENOMEM;
2785
2786         q = strjoin(p, "/50-", name, ".conf", NULL);
2787         if (!q) {
2788                 free(p);
2789                 return -ENOMEM;
2790         }
2791
2792         *_p = p;
2793         *_q = q;
2794         return 0;
2795 }
2796
2797 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2798         _cleanup_free_ char *p = NULL, *q = NULL;
2799         int r;
2800
2801         assert(u);
2802
2803         r = drop_in_file(u, runtime, name, &p, &q);
2804         if (r < 0)
2805                 return r;
2806
2807         mkdir_p(p, 0755);
2808         return write_one_line_file_atomic_label(q, data);
2809 }
2810
2811 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2812         _cleanup_free_ char *p = NULL, *q = NULL;
2813         int r;
2814
2815         assert(u);
2816
2817         r = drop_in_file(u, runtime, name, &p, &q);
2818         if (unlink(q) < 0)
2819                 r = -errno;
2820         else
2821                 r = 0;
2822
2823         rmdir(p);
2824         return r;
2825 }
2826
2827 int unit_kill_context(
2828                 Unit *u,
2829                 KillContext *c,
2830                 bool sigkill,
2831                 pid_t main_pid,
2832                 pid_t control_pid,
2833                 bool main_pid_alien) {
2834
2835         int sig, wait_for_exit = 0, r;
2836
2837         assert(u);
2838         assert(c);
2839
2840         if (c->kill_mode == KILL_NONE)
2841                 return 0;
2842
2843         sig = sigkill ? SIGKILL : c->kill_signal;
2844
2845         if (main_pid > 0) {
2846                 r = kill_and_sigcont(main_pid, sig);
2847
2848                 if (r < 0 && r != -ESRCH) {
2849                         _cleanup_free_ char *comm = NULL;
2850                         get_process_comm(main_pid, &comm);
2851
2852                         log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2853                                          (long) main_pid, strna(comm), strerror(-r));
2854                 } else
2855                         wait_for_exit = !main_pid_alien;
2856         }
2857
2858         if (control_pid > 0) {
2859                 r = kill_and_sigcont(control_pid, sig);
2860
2861                 if (r < 0 && r != -ESRCH) {
2862                         _cleanup_free_ char *comm = NULL;
2863                         get_process_comm(control_pid, &comm);
2864
2865                         log_warning_unit(u->id,
2866                                          "Failed to kill control process %li (%s): %s",
2867                                          (long) control_pid, strna(comm), strerror(-r));
2868                 } else
2869                         wait_for_exit = true;
2870         }
2871
2872         if (c->kill_mode == KILL_CONTROL_GROUP) {
2873                 _cleanup_set_free_ Set *pid_set = NULL;
2874
2875                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2876                 if (!pid_set)
2877                         return -ENOMEM;
2878
2879                 /* Exclude the main/control pids from being killed via the cgroup */
2880                 if (main_pid > 0) {
2881                         r = set_put(pid_set, LONG_TO_PTR(main_pid));
2882                         if (r < 0)
2883                                 return r;
2884                 }
2885
2886                 if (control_pid > 0) {
2887                         r = set_put(pid_set, LONG_TO_PTR(control_pid));
2888                         if (r < 0)
2889                                 return r;
2890                 }
2891
2892                 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2893                 if (r < 0) {
2894                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2895                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2896                 } else if (r > 0)
2897                         wait_for_exit = true;
2898         }
2899
2900         return wait_for_exit;
2901 }
2902
2903 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2904         [UNIT_ACTIVE] = "active",
2905         [UNIT_RELOADING] = "reloading",
2906         [UNIT_INACTIVE] = "inactive",
2907         [UNIT_FAILED] = "failed",
2908         [UNIT_ACTIVATING] = "activating",
2909         [UNIT_DEACTIVATING] = "deactivating"
2910 };
2911
2912 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2913
2914 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2915         [UNIT_REQUIRES] = "Requires",
2916         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2917         [UNIT_REQUISITE] = "Requisite",
2918         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2919         [UNIT_WANTS] = "Wants",
2920         [UNIT_BINDS_TO] = "BindsTo",
2921         [UNIT_PART_OF] = "PartOf",
2922         [UNIT_REQUIRED_BY] = "RequiredBy",
2923         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2924         [UNIT_WANTED_BY] = "WantedBy",
2925         [UNIT_BOUND_BY] = "BoundBy",
2926         [UNIT_CONSISTS_OF] = "ConsistsOf",
2927         [UNIT_CONFLICTS] = "Conflicts",
2928         [UNIT_CONFLICTED_BY] = "ConflictedBy",
2929         [UNIT_BEFORE] = "Before",
2930         [UNIT_AFTER] = "After",
2931         [UNIT_ON_FAILURE] = "OnFailure",
2932         [UNIT_TRIGGERS] = "Triggers",
2933         [UNIT_TRIGGERED_BY] = "TriggeredBy",
2934         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2935         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2936         [UNIT_REFERENCES] = "References",
2937         [UNIT_REFERENCED_BY] = "ReferencedBy",
2938 };
2939
2940 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);