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