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