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