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