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