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