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         _cleanup_set_free_ Set *following_set = NULL;
 720         int r;
 721
 722         assert(u);
 723         assert(u->type >= 0);
 724
 725         if (!prefix)
 726                 prefix = "";
 727         p2 = strappend(prefix, "\t");
 728         prefix2 = p2 ? p2 : prefix;
 729
 730         fprintf(f,
 731                 "%s-> Unit %s:\n"
 732                 "%s\tDescription: %s\n"
 733                 "%s\tInstance: %s\n"
 734                 "%s\tUnit Load State: %s\n"
 735                 "%s\tUnit Active State: %s\n"
 736                 "%s\tInactive Exit Timestamp: %s\n"
 737                 "%s\tActive Enter Timestamp: %s\n"
 738                 "%s\tActive Exit Timestamp: %s\n"
 739                 "%s\tInactive Enter Timestamp: %s\n"
 740                 "%s\tGC Check Good: %s\n"
 741                 "%s\tNeed Daemon Reload: %s\n"
 742                 "%s\tTransient: %s\n"
 743                 "%s\tSlice: %s\n"
 744                 "%s\tCGroup: %s\n"
 745                 "%s\tCGroup realized: %s\n"
 746                 "%s\tCGroup mask: 0x%x\n"
 747                 "%s\tCGroup members mask: 0x%x\n",
 748                 prefix, u->id,
 749                 prefix, unit_description(u),
 750                 prefix, strna(u->instance),
 751                 prefix, unit_load_state_to_string(u->load_state),
 752                 prefix, unit_active_state_to_string(unit_active_state(u)),
 753                 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
 754                 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
 755                 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
 756                 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
 757                 prefix, yes_no(unit_check_gc(u)),
 758                 prefix, yes_no(unit_need_daemon_reload(u)),
 759                 prefix, yes_no(u->transient),
 760                 prefix, strna(unit_slice_name(u)),
 761                 prefix, strna(u->cgroup_path),
 762                 prefix, yes_no(u->cgroup_realized),
 763                 prefix, u->cgroup_mask,
 764                 prefix, u->cgroup_members_mask);
 765
 766         SET_FOREACH(t, u->names, i)
 767                 fprintf(f, "%s\tName: %s\n", prefix, t);
 768
 769         STRV_FOREACH(j, u->documentation)
 770                 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
 771
 772         following = unit_following(u);
 773         if (following)
 774                 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
 775
 776         r = unit_following_set(u, &following_set);
 777         if (r >= 0) {
 778                 Unit *other;
 779
 780                 SET_FOREACH(other, following_set, i)
 781                         fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
 782         }
 783
 784         if (u->fragment_path)
 785                 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
 786
 787         if (u->source_path)
 788                 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
 789
 790         STRV_FOREACH(j, u->dropin_paths)
 791                 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
 792
 793         if (u->job_timeout > 0)
 794                 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
 795
 796         condition_dump_list(u->conditions, f, prefix);
 797
 798         if (dual_timestamp_is_set(&u->condition_timestamp))
 799                 fprintf(f,
 800                         "%s\tCondition Timestamp: %s\n"
 801                         "%s\tCondition Result: %s\n",
 802                         prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
 803                         prefix, yes_no(u->condition_result));
 804
 805         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
 806                 Unit *other;
 807
 808                 SET_FOREACH(other, u->dependencies[d], i)
 809                         fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
 810         }
 811
 812         if (!strv_isempty(u->requires_mounts_for)) {
 813                 fprintf(f,
 814                         "%s\tRequiresMountsFor:", prefix);
 815
 816                 STRV_FOREACH(j, u->requires_mounts_for)
 817                         fprintf(f, " %s", *j);
 818
 819                 fputs("\n", f);
 820         }
 821
 822         if (u->load_state == UNIT_LOADED) {
 823
 824                 fprintf(f,
 825                         "%s\tStopWhenUnneeded: %s\n"
 826                         "%s\tRefuseManualStart: %s\n"
 827                         "%s\tRefuseManualStop: %s\n"
 828                         "%s\tDefaultDependencies: %s\n"
 829                         "%s\tOnFailureIsolate: %s\n"
 830                         "%s\tIgnoreOnIsolate: %s\n"
 831                         "%s\tIgnoreOnSnapshot: %s\n",
 832                         prefix, yes_no(u->stop_when_unneeded),
 833                         prefix, yes_no(u->refuse_manual_start),
 834                         prefix, yes_no(u->refuse_manual_stop),
 835                         prefix, yes_no(u->default_dependencies),
 836                         prefix, yes_no(u->on_failure_isolate),
 837                         prefix, yes_no(u->ignore_on_isolate),
 838                         prefix, yes_no(u->ignore_on_snapshot));
 839
 840                 if (UNIT_VTABLE(u)->dump)
 841                         UNIT_VTABLE(u)->dump(u, f, prefix2);
 842
 843         } else if (u->load_state == UNIT_MERGED)
 844                 fprintf(f,
 845                         "%s\tMerged into: %s\n",
 846                         prefix, u->merged_into->id);
 847         else if (u->load_state == UNIT_ERROR)
 848                 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
 849
 850
 851         if (u->job)
 852                 job_dump(u->job, f, prefix2);
 853
 854         if (u->nop_job)
 855                 job_dump(u->nop_job, f, prefix2);
 856
 857 }
 858
 859 /* Common implementation for multiple backends */
 860 int unit_load_fragment_and_dropin(Unit *u) {
 861         int r;
 862
 863         assert(u);
 864
 865         /* Load a .{service,socket,...} file */
 866         r = unit_load_fragment(u);
 867         if (r < 0)
 868                 return r;
 869
 870         if (u->load_state == UNIT_STUB)
 871                 return -ENOENT;
 872
 873         /* Load drop-in directory data */
 874         r = unit_load_dropin(unit_follow_merge(u));
 875         if (r < 0)
 876                 return r;
 877
 878         return 0;
 879 }
 880
 881 /* Common implementation for multiple backends */
 882 int unit_load_fragment_and_dropin_optional(Unit *u) {
 883         int r;
 884
 885         assert(u);
 886
 887         /* Same as unit_load_fragment_and_dropin(), but whether
 888          * something can be loaded or not doesn't matter. */
 889
 890         /* Load a .service file */
 891         r = unit_load_fragment(u);
 892         if (r < 0)
 893                 return r;
 894
 895         if (u->load_state == UNIT_STUB)
 896                 u->load_state = UNIT_LOADED;
 897
 898         /* Load drop-in directory data */
 899         r = unit_load_dropin(unit_follow_merge(u));
 900         if (r < 0)
 901                 return r;
 902
 903         return 0;
 904 }
 905
 906 int unit_add_default_target_dependency(Unit *u, Unit *target) {
 907         assert(u);
 908         assert(target);
 909
 910         if (target->type != UNIT_TARGET)
 911                 return 0;
 912
 913         /* Only add the dependency if both units are loaded, so that
 914          * that loop check below is reliable */
 915         if (u->load_state != UNIT_LOADED ||
 916             target->load_state != UNIT_LOADED)
 917                 return 0;
 918
 919         /* If either side wants no automatic dependencies, then let's
 920          * skip this */
 921         if (!u->default_dependencies ||
 922             !target->default_dependencies)
 923                 return 0;
 924
 925         /* Don't create loops */
 926         if (set_get(target->dependencies[UNIT_BEFORE], u))
 927                 return 0;
 928
 929         return unit_add_dependency(target, UNIT_AFTER, u, true);
 930 }
 931
 932 static int unit_add_default_dependencies(Unit *u) {
 933
 934         static const UnitDependency deps[] = {
 935                 UNIT_REQUIRED_BY,
 936                 UNIT_REQUIRED_BY_OVERRIDABLE,
 937                 UNIT_WANTED_BY,
 938                 UNIT_BOUND_BY
 939         };
 940
 941         Unit *target;
 942         Iterator i;
 943         int r;
 944         unsigned k;
 945
 946         assert(u);
 947
 948         for (k = 0; k < ELEMENTSOF(deps); k++)
 949                 SET_FOREACH(target, u->dependencies[deps[k]], i) {
 950                         r = unit_add_default_target_dependency(u, target);
 951                         if (r < 0)
 952                                 return r;
 953                 }
 954
 955         if (u->default_dependencies && unit_get_cgroup_context(u)) {
 956                 if (UNIT_ISSET(u->slice))
 957                         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
 958                 else
 959                         r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
 960
 961                 if (r < 0)
 962                         return r;
 963         }
 964
 965         return 0;
 966 }
 967
 968 static int unit_add_mount_links(Unit *u) {
 969         char **i;
 970         int r;
 971
 972         assert(u);
 973
 974         STRV_FOREACH(i, u->requires_mounts_for) {
 975                 char prefix[strlen(*i) + 1];
 976
 977                 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
 978                         Unit *m;
 979
 980                         r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
 981                         if (r < 0)
 982                                 return r;
 983                         if (r == 0)
 984                                 continue;
 985                         if (m == u)
 986                                 continue;
 987
 988                         if (m->load_state != UNIT_LOADED)
 989                                 continue;
 990
 991                         r = unit_add_dependency(u, UNIT_AFTER, m, true);
 992                         if (r < 0)
 993                                 return r;
 994
 995                         if (m->fragment_path) {
 996                                 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
 997                                 if (r < 0)
 998                                         return r;
 999                         }
1000                 }
1001         }
1002
1003         return 0;
1004 }
1005
1006 int unit_load(Unit *u) {
1007         int r;
1008
1009         assert(u);
1010
1011         if (u->in_load_queue) {
1012                 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1013                 u->in_load_queue = false;
1014         }
1015
1016         if (u->type == _UNIT_TYPE_INVALID)
1017                 return -EINVAL;
1018
1019         if (u->load_state != UNIT_STUB)
1020                 return 0;
1021
1022         if (UNIT_VTABLE(u)->load) {
1023                 r = UNIT_VTABLE(u)->load(u);
1024                 if (r < 0)
1025                         goto fail;
1026         }
1027
1028         if (u->load_state == UNIT_STUB) {
1029                 r = -ENOENT;
1030                 goto fail;
1031         }
1032
1033         if (u->load_state == UNIT_LOADED) {
1034
1035                 if (u->default_dependencies) {
1036                         r = unit_add_default_dependencies(u);
1037                         if (r < 0)
1038                                 goto fail;
1039                 }
1040
1041                 unit_update_member_masks(u);
1042
1043                 r = unit_add_mount_links(u);
1044                 if (r < 0)
1045                         goto fail;
1046
1047                 if (u->on_failure_isolate &&
1048                     set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1049
1050                         log_error_unit(u->id,
1051                                        "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
1052
1053                         r = -EINVAL;
1054                         goto fail;
1055                 }
1056         }
1057
1058         assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1059
1060         unit_add_to_dbus_queue(unit_follow_merge(u));
1061         unit_add_to_gc_queue(u);
1062
1063         return 0;
1064
1065 fail:
1066         u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1067         u->load_error = r;
1068         unit_add_to_dbus_queue(u);
1069         unit_add_to_gc_queue(u);
1070
1071         log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1072                        u->id, strerror(-r));
1073
1074         return r;
1075 }
1076
1077 static bool unit_condition_test(Unit *u) {
1078         assert(u);
1079
1080         dual_timestamp_get(&u->condition_timestamp);
1081         u->condition_result = condition_test_list(u->id, u->conditions);
1082
1083         return u->condition_result;
1084 }
1085
1086 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1087         const UnitStatusMessageFormats *format_table;
1088
1089         assert(u);
1090         assert(t >= 0);
1091         assert(t < _JOB_TYPE_MAX);
1092
1093         if (t != JOB_START && t != JOB_STOP)
1094                 return NULL;
1095
1096         format_table = &UNIT_VTABLE(u)->status_message_formats;
1097         if (!format_table)
1098                 return NULL;
1099
1100         return format_table->starting_stopping[t == JOB_STOP];
1101 }
1102
1103 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1104         const char *format;
1105
1106         assert(u);
1107         assert(t >= 0);
1108         assert(t < _JOB_TYPE_MAX);
1109
1110         format = unit_get_status_message_format(u, t);
1111         if (format)
1112                 return format;
1113
1114         /* Return generic strings */
1115         if (t == JOB_START)
1116                 return "Starting %s.";
1117         else if (t == JOB_STOP)
1118                 return "Stopping %s.";
1119         else if (t == JOB_RELOAD)
1120                 return "Reloading %s.";
1121
1122         return NULL;
1123 }
1124
1125 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1126         const char *format;
1127
1128         assert(u);
1129
1130         /* We only print status messages for selected units on
1131          * selected operations. */
1132
1133         format = unit_get_status_message_format(u, t);
1134         if (!format)
1135                 return;
1136
1137         unit_status_printf(u, "", format);
1138 }
1139
1140 #pragma GCC diagnostic push
1141 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1142 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1143         const char *format;
1144         char buf[LINE_MAX];
1145         sd_id128_t mid;
1146
1147         assert(u);
1148
1149         if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1150                 return;
1151
1152         if (log_on_console())
1153                 return;
1154
1155         /* We log status messages for all units and all operations. */
1156
1157         format = unit_get_status_message_format_try_harder(u, t);
1158         if (!format)
1159                 return;
1160
1161         snprintf(buf, sizeof(buf), format, unit_description(u));
1162         char_array_0(buf);
1163
1164         mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1165               t == JOB_STOP  ? SD_MESSAGE_UNIT_STOPPING :
1166                                SD_MESSAGE_UNIT_RELOADING;
1167
1168         log_struct_unit(LOG_INFO,
1169                         u->id,
1170                         MESSAGE_ID(mid),
1171                         "MESSAGE=%s", buf,
1172                         NULL);
1173 }
1174 #pragma GCC diagnostic pop
1175
1176 /* Errors:
1177  *         -EBADR:     This unit type does not support starting.
1178  *         -EALREADY:  Unit is already started.
1179  *         -EAGAIN:    An operation is already in progress. Retry later.
1180  *         -ECANCELED: Too many requests for now.
1181  */
1182 int unit_start(Unit *u) {
1183         UnitActiveState state;
1184         Unit *following;
1185
1186         assert(u);
1187
1188         if (u->load_state != UNIT_LOADED)
1189                 return -EINVAL;
1190
1191         /* If this is already started, then this will succeed. Note
1192          * that this will even succeed if this unit is not startable
1193          * by the user. This is relied on to detect when we need to
1194          * wait for units and when waiting is finished. */
1195         state = unit_active_state(u);
1196         if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1197                 return -EALREADY;
1198
1199         /* If the conditions failed, don't do anything at all. If we
1200          * already are activating this call might still be useful to
1201          * speed up activation in case there is some hold-off time,
1202          * but we don't want to recheck the condition in that case. */
1203         if (state != UNIT_ACTIVATING &&
1204             !unit_condition_test(u)) {
1205                 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1206                 return -EALREADY;
1207         }
1208
1209         /* Forward to the main object, if we aren't it. */
1210         following = unit_following(u);
1211         if (following) {
1212                 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1213                                u->id, following->id);
1214                 return unit_start(following);
1215         }
1216
1217         unit_status_log_starting_stopping_reloading(u, JOB_START);
1218         unit_status_print_starting_stopping(u, JOB_START);
1219
1220         /* If it is stopped, but we cannot start it, then fail */
1221         if (!UNIT_VTABLE(u)->start)
1222                 return -EBADR;
1223
1224         /* We don't suppress calls to ->start() here when we are
1225          * already starting, to allow this request to be used as a
1226          * "hurry up" call, for example when the unit is in some "auto
1227          * restart" state where it waits for a holdoff timer to elapse
1228          * before it will start again. */
1229
1230         unit_add_to_dbus_queue(u);
1231
1232         return UNIT_VTABLE(u)->start(u);
1233 }
1234
1235 bool unit_can_start(Unit *u) {
1236         assert(u);
1237
1238         return !!UNIT_VTABLE(u)->start;
1239 }
1240
1241 bool unit_can_isolate(Unit *u) {
1242         assert(u);
1243
1244         return unit_can_start(u) &&
1245                 u->allow_isolate;
1246 }
1247
1248 /* Errors:
1249  *         -EBADR:    This unit type does not support stopping.
1250  *         -EALREADY: Unit is already stopped.
1251  *         -EAGAIN:   An operation is already in progress. Retry later.
1252  */
1253 int unit_stop(Unit *u) {
1254         UnitActiveState state;
1255         Unit *following;
1256
1257         assert(u);
1258
1259         state = unit_active_state(u);
1260         if (UNIT_IS_INACTIVE_OR_FAILED(state))
1261                 return -EALREADY;
1262
1263         if ((following = unit_following(u))) {
1264                 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1265                                u->id, following->id);
1266                 return unit_stop(following);
1267         }
1268
1269         unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1270         unit_status_print_starting_stopping(u, JOB_STOP);
1271
1272         if (!UNIT_VTABLE(u)->stop)
1273                 return -EBADR;
1274
1275         unit_add_to_dbus_queue(u);
1276
1277         return UNIT_VTABLE(u)->stop(u);
1278 }
1279
1280 /* Errors:
1281  *         -EBADR:    This unit type does not support reloading.
1282  *         -ENOEXEC:  Unit is not started.
1283  *         -EAGAIN:   An operation is already in progress. Retry later.
1284  */
1285 int unit_reload(Unit *u) {
1286         UnitActiveState state;
1287         Unit *following;
1288
1289         assert(u);
1290
1291         if (u->load_state != UNIT_LOADED)
1292                 return -EINVAL;
1293
1294         if (!unit_can_reload(u))
1295                 return -EBADR;
1296
1297         state = unit_active_state(u);
1298         if (state == UNIT_RELOADING)
1299                 return -EALREADY;
1300
1301         if (state != UNIT_ACTIVE)
1302                 return -ENOEXEC;
1303
1304         following = unit_following(u);
1305         if (following) {
1306                 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1307                                u->id, following->id);
1308                 return unit_reload(following);
1309         }
1310
1311         unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1312
1313         unit_add_to_dbus_queue(u);
1314         return UNIT_VTABLE(u)->reload(u);
1315 }
1316
1317 bool unit_can_reload(Unit *u) {
1318         assert(u);
1319
1320         if (!UNIT_VTABLE(u)->reload)
1321                 return false;
1322
1323         if (!UNIT_VTABLE(u)->can_reload)
1324                 return true;
1325
1326         return UNIT_VTABLE(u)->can_reload(u);
1327 }
1328
1329 static void unit_check_unneeded(Unit *u) {
1330         Iterator i;
1331         Unit *other;
1332
1333         assert(u);
1334
1335         /* If this service shall be shut down when unneeded then do
1336          * so. */
1337
1338         if (!u->stop_when_unneeded)
1339                 return;
1340
1341         if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1342                 return;
1343
1344         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1345                 if (unit_active_or_pending(other))
1346                         return;
1347
1348         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1349                 if (unit_active_or_pending(other))
1350                         return;
1351
1352         SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1353                 if (unit_active_or_pending(other))
1354                         return;
1355
1356         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1357                 if (unit_active_or_pending(other))
1358                         return;
1359
1360         log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1361
1362         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1363         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1364 }
1365
1366 static void retroactively_start_dependencies(Unit *u) {
1367         Iterator i;
1368         Unit *other;
1369
1370         assert(u);
1371         assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1372
1373         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], 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_REPLACE, true, NULL, NULL);
1377
1378         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1379                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1380                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1381                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1382
1383         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1384                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1385                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1386                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1387
1388         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1389                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1390                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1391                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1392
1393         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1394                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1395                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1396
1397         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1398                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1399                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1400 }
1401
1402 static void retroactively_stop_dependencies(Unit *u) {
1403         Iterator i;
1404         Unit *other;
1405
1406         assert(u);
1407         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1408
1409         /* Pull down units which are bound to us recursively if enabled */
1410         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1411                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1412                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1413 }
1414
1415 static void check_unneeded_dependencies(Unit *u) {
1416         Iterator i;
1417         Unit *other;
1418
1419         assert(u);
1420         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1421
1422         /* Garbage collect services that might not be needed anymore, if enabled */
1423         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1424                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1425                         unit_check_unneeded(other);
1426         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1427                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1428                         unit_check_unneeded(other);
1429         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1430                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1431                         unit_check_unneeded(other);
1432         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1433                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1434                         unit_check_unneeded(other);
1435         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1436                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1437                         unit_check_unneeded(other);
1438         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1439                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1440                         unit_check_unneeded(other);
1441 }
1442
1443 void unit_start_on_failure(Unit *u) {
1444         Unit *other;
1445         Iterator i;
1446
1447         assert(u);
1448
1449         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1450                 return;
1451
1452         log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1453
1454         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1455                 int r;
1456
1457                 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1458                 if (r < 0)
1459                         log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1460         }
1461 }
1462
1463 void unit_trigger_notify(Unit *u) {
1464         Unit *other;
1465         Iterator i;
1466
1467         assert(u);
1468
1469         SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1470                 if (UNIT_VTABLE(other)->trigger_notify)
1471                         UNIT_VTABLE(other)->trigger_notify(other, u);
1472 }
1473
1474 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1475         Manager *m;
1476         bool unexpected;
1477
1478         assert(u);
1479         assert(os < _UNIT_ACTIVE_STATE_MAX);
1480         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1481
1482         /* Note that this is called for all low-level state changes,
1483          * even if they might map to the same high-level
1484          * UnitActiveState! That means that ns == os is OK an expected
1485          * behavior here. For example: if a mount point is remounted
1486          * this function will be called too! */
1487
1488         m = u->manager;
1489
1490         if (m->n_reloading <= 0) {
1491                 dual_timestamp ts;
1492
1493                 dual_timestamp_get(&ts);
1494
1495                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1496                         u->inactive_exit_timestamp = ts;
1497                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1498                         u->inactive_enter_timestamp = ts;
1499
1500                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1501                         u->active_enter_timestamp = ts;
1502                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1503                         u->active_exit_timestamp = ts;
1504         }
1505
1506         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1507                 unit_destroy_cgroup(u);
1508
1509         /* Note that this doesn't apply to RemainAfterExit services exiting
1510          * sucessfully, since there's no change of state in that case. Which is
1511          * why it is handled in service_set_state() */
1512         if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1513                 ExecContext *ec = unit_get_exec_context(u);
1514                 if (ec && exec_context_may_touch_console(ec)) {
1515                         if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1516                                 m->n_on_console --;
1517
1518                                 if (m->n_on_console == 0)
1519                                         /* unset no_console_output flag, since the console is free */
1520                                         m->no_console_output = false;
1521                         } else
1522                                 m->n_on_console ++;
1523                 }
1524         }
1525
1526         if (u->job) {
1527                 unexpected = false;
1528
1529                 if (u->job->state == JOB_WAITING)
1530
1531                         /* So we reached a different state for this
1532                          * job. Let's see if we can run it now if it
1533                          * failed previously due to EAGAIN. */
1534                         job_add_to_run_queue(u->job);
1535
1536                 /* Let's check whether this state change constitutes a
1537                  * finished job, or maybe contradicts a running job and
1538                  * hence needs to invalidate jobs. */
1539
1540                 switch (u->job->type) {
1541
1542                 case JOB_START:
1543                 case JOB_VERIFY_ACTIVE:
1544
1545                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1546                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1547                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
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                         break;
1555
1556                 case JOB_RELOAD:
1557                 case JOB_RELOAD_OR_START:
1558
1559                         if (u->job->state == JOB_RUNNING) {
1560                                 if (ns == UNIT_ACTIVE)
1561                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1562                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1563                                         unexpected = true;
1564
1565                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1566                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1567                                 }
1568                         }
1569
1570                         break;
1571
1572                 case JOB_STOP:
1573                 case JOB_RESTART:
1574                 case JOB_TRY_RESTART:
1575
1576                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1577                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1578                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1579                                 unexpected = true;
1580                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1581                         }
1582
1583                         break;
1584
1585                 default:
1586                         assert_not_reached("Job type unknown");
1587                 }
1588
1589         } else
1590                 unexpected = true;
1591
1592         if (m->n_reloading <= 0) {
1593
1594                 /* If this state change happened without being
1595                  * requested by a job, then let's retroactively start
1596                  * or stop dependencies. We skip that step when
1597                  * deserializing, since we don't want to create any
1598                  * additional jobs just because something is already
1599                  * activated. */
1600
1601                 if (unexpected) {
1602                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1603                                 retroactively_start_dependencies(u);
1604                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1605                                 retroactively_stop_dependencies(u);
1606                 }
1607
1608                 /* stop unneeded units regardless if going down was expected or not */
1609                 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1610                         check_unneeded_dependencies(u);
1611
1612                 if (ns != os && ns == UNIT_FAILED) {
1613                         log_notice_unit(u->id,
1614                                         "Unit %s entered failed state.", u->id);
1615                         unit_start_on_failure(u);
1616                 }
1617         }
1618
1619         /* Some names are special */
1620         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1621
1622                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1623                         /* The bus just might have become available,
1624                          * hence try to connect to it, if we aren't
1625                          * yet connected. */
1626                         bus_init(m, true);
1627
1628                 if (u->type == UNIT_SERVICE &&
1629                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1630                     m->n_reloading <= 0) {
1631                         /* Write audit record if we have just finished starting up */
1632                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1633                         u->in_audit = true;
1634                 }
1635
1636                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1637                         manager_send_unit_plymouth(m, u);
1638
1639         } else {
1640
1641                 /* We don't care about D-Bus here, since we'll get an
1642                  * asynchronous notification for it anyway. */
1643
1644                 if (u->type == UNIT_SERVICE &&
1645                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1646                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1647                     m->n_reloading <= 0) {
1648
1649                         /* Hmm, if there was no start record written
1650                          * write it now, so that we always have a nice
1651                          * pair */
1652                         if (!u->in_audit) {
1653                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1654
1655                                 if (ns == UNIT_INACTIVE)
1656                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1657                         } else
1658                                 /* Write audit record if we have just finished shutting down */
1659                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1660
1661                         u->in_audit = false;
1662                 }
1663         }
1664
1665         manager_recheck_journal(m);
1666         unit_trigger_notify(u);
1667
1668         /* Maybe we finished startup and are now ready for being
1669          * stopped because unneeded? */
1670         if (u->manager->n_reloading <= 0)
1671                 unit_check_unneeded(u);
1672
1673         unit_add_to_dbus_queue(u);
1674         unit_add_to_gc_queue(u);
1675 }
1676
1677 int unit_watch_pid(Unit *u, pid_t pid) {
1678         assert(u);
1679         assert(pid >= 1);
1680
1681         /* Watch a specific PID. We only support one unit watching
1682          * each PID for now. */
1683
1684         return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1685 }
1686
1687 void unit_unwatch_pid(Unit *u, pid_t pid) {
1688         assert(u);
1689         assert(pid >= 1);
1690
1691         hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1692 }
1693
1694 bool unit_job_is_applicable(Unit *u, JobType j) {
1695         assert(u);
1696         assert(j >= 0 && j < _JOB_TYPE_MAX);
1697
1698         switch (j) {
1699
1700         case JOB_VERIFY_ACTIVE:
1701         case JOB_START:
1702         case JOB_STOP:
1703         case JOB_NOP:
1704                 return true;
1705
1706         case JOB_RESTART:
1707         case JOB_TRY_RESTART:
1708                 return unit_can_start(u);
1709
1710         case JOB_RELOAD:
1711                 return unit_can_reload(u);
1712
1713         case JOB_RELOAD_OR_START:
1714                 return unit_can_reload(u) && unit_can_start(u);
1715
1716         default:
1717                 assert_not_reached("Invalid job type");
1718         }
1719 }
1720
1721 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1722
1723         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1724                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1725                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1726                 [UNIT_WANTS] = UNIT_WANTED_BY,
1727                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1728                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1729                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1730                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1731                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1732                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1733                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1734                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1735                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1736                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1737                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1738                 [UNIT_BEFORE] = UNIT_AFTER,
1739                 [UNIT_AFTER] = UNIT_BEFORE,
1740                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1741                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1742                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1743                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1744                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1745                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1746                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1747         };
1748         int r, q = 0, v = 0, w = 0;
1749
1750         assert(u);
1751         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1752         assert(other);
1753
1754         u = unit_follow_merge(u);
1755         other = unit_follow_merge(other);
1756
1757         /* We won't allow dependencies on ourselves. We will not
1758          * consider them an error however. */
1759         if (u == other)
1760                 return 0;
1761
1762         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1763                 return r;
1764
1765         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1766                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1767                         return r;
1768
1769         if (add_reference)
1770                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1771                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1772                         return r;
1773
1774         if ((q = set_put(u->dependencies[d], other)) < 0)
1775                 return q;
1776
1777         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1778                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1779                         r = v;
1780                         goto fail;
1781                 }
1782
1783         if (add_reference) {
1784                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1785                         r = w;
1786                         goto fail;
1787                 }
1788
1789                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1790                         goto fail;
1791         }
1792
1793         unit_add_to_dbus_queue(u);
1794         return 0;
1795
1796 fail:
1797         if (q > 0)
1798                 set_remove(u->dependencies[d], other);
1799
1800         if (v > 0)
1801                 set_remove(other->dependencies[inverse_table[d]], u);
1802
1803         if (w > 0)
1804                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1805
1806         return r;
1807 }
1808
1809 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1810         int r;
1811
1812         assert(u);
1813
1814         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1815                 return r;
1816
1817         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1818                 return r;
1819
1820         return 0;
1821 }
1822
1823 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1824         char *s;
1825
1826         assert(u);
1827         assert(name || path);
1828         assert(p);
1829
1830         if (!name)
1831                 name = path_get_file_name(path);
1832
1833         if (!unit_name_is_template(name)) {
1834                 *p = NULL;
1835                 return name;
1836         }
1837
1838         if (u->instance)
1839                 s = unit_name_replace_instance(name, u->instance);
1840         else {
1841                 _cleanup_free_ char *i = NULL;
1842
1843                 i = unit_name_to_prefix(u->id);
1844                 if (!i)
1845                         return NULL;
1846
1847                 s = unit_name_replace_instance(name, i);
1848         }
1849
1850         if (!s)
1851                 return NULL;
1852
1853         *p = s;
1854         return s;
1855 }
1856
1857 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1858         Unit *other;
1859         int r;
1860         _cleanup_free_ char *s = NULL;
1861
1862         assert(u);
1863         assert(name || path);
1864
1865         name = resolve_template(u, name, path, &s);
1866         if (!name)
1867                 return -ENOMEM;
1868
1869         r = manager_load_unit(u->manager, name, path, NULL, &other);
1870         if (r < 0)
1871                 return r;
1872
1873         return unit_add_dependency(u, d, other, add_reference);
1874 }
1875
1876 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1877         Unit *other;
1878         int r;
1879         _cleanup_free_ char *s = NULL;
1880
1881         assert(u);
1882         assert(name || path);
1883
1884         if (!(name = resolve_template(u, name, path, &s)))
1885                 return -ENOMEM;
1886
1887         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1888                 return r;
1889
1890         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1891
1892         return r;
1893 }
1894
1895 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1896         Unit *other;
1897         int r;
1898         _cleanup_free_ char *s = NULL;
1899
1900         assert(u);
1901         assert(name || path);
1902
1903         if (!(name = resolve_template(u, name, path, &s)))
1904                 return -ENOMEM;
1905
1906         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1907                 return r;
1908
1909         r = unit_add_dependency(other, d, u, add_reference);
1910
1911         return r;
1912 }
1913
1914 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1915         Unit *other;
1916         int r;
1917         _cleanup_free_ char *s = NULL;
1918
1919         assert(u);
1920         assert(name || path);
1921
1922         if (!(name = resolve_template(u, name, path, &s)))
1923                 return -ENOMEM;
1924
1925         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1926                 return r;
1927
1928         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1929                 return r;
1930
1931         return r;
1932 }
1933
1934 int set_unit_path(const char *p) {
1935         _cleanup_free_ char *c = NULL;
1936
1937         /* This is mostly for debug purposes */
1938         c = path_make_absolute_cwd(p);
1939         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1940                 return -errno;
1941
1942         return 0;
1943 }
1944
1945 char *unit_dbus_path(Unit *u) {
1946         assert(u);
1947
1948         if (!u->id)
1949                 return NULL;
1950
1951         return unit_dbus_path_from_name(u->id);
1952 }
1953
1954 char *unit_default_cgroup_path(Unit *u) {
1955         _cleanup_free_ char *escaped = NULL, *slice = NULL;
1956         int r;
1957
1958         assert(u);
1959
1960         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1961                 return strdup(u->manager->cgroup_root);
1962
1963         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1964                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
1965                 if (r < 0)
1966                         return NULL;
1967         }
1968
1969         escaped = cg_escape(u->id);
1970         if (!escaped)
1971                 return NULL;
1972
1973         if (slice)
1974                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
1975         else
1976                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
1977 }
1978
1979 int unit_add_default_slice(Unit *u) {
1980         _cleanup_free_ char *b = NULL;
1981         const char *slice_name;
1982         Unit *slice;
1983         int r;
1984
1985         assert(u);
1986
1987         if (UNIT_ISSET(u->slice))
1988                 return 0;
1989
1990         if (!unit_get_cgroup_context(u))
1991                 return 0;
1992
1993         if (u->instance) {
1994                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
1995
1996                 /* Implicitly place all instantiated units in their
1997                  * own per-template slice */
1998
1999                 prefix = unit_name_to_prefix(u->id);
2000                 if (!prefix)
2001                         return -ENOMEM;
2002
2003                 /* The prefix is already escaped, but it might include
2004                  * "-" which has a special meaning for slice units,
2005                  * hence escape it here extra. */
2006                 escaped = strreplace(prefix, "-", "\\x2d");
2007                 if (!escaped)
2008                         return -ENOMEM;
2009
2010                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2011                         b = strjoin("system-", escaped, ".slice", NULL);
2012                 else
2013                         b = strappend(escaped, ".slice");
2014                 if (!b)
2015                         return -ENOMEM;
2016
2017                 slice_name = b;
2018         } else
2019                 slice_name =
2020                         u->manager->running_as == SYSTEMD_SYSTEM
2021                         ? SPECIAL_SYSTEM_SLICE
2022                         : SPECIAL_ROOT_SLICE;
2023
2024         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2025         if (r < 0)
2026                 return r;
2027
2028         unit_ref_set(&u->slice, slice);
2029         return 0;
2030 }
2031
2032 const char *unit_slice_name(Unit *u) {
2033         assert(u);
2034
2035         if (!UNIT_ISSET(u->slice))
2036                 return NULL;
2037
2038         return UNIT_DEREF(u->slice)->id;
2039 }
2040
2041 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2042         _cleanup_free_ char *t = NULL;
2043         int r;
2044
2045         assert(u);
2046         assert(type);
2047         assert(_found);
2048
2049         t = unit_name_change_suffix(u->id, type);
2050         if (!t)
2051                 return -ENOMEM;
2052
2053         assert(!unit_has_name(u, t));
2054
2055         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2056         assert(r < 0 || *_found != u);
2057         return r;
2058 }
2059
2060 int unit_watch_bus_name(Unit *u, const char *name) {
2061         assert(u);
2062         assert(name);
2063
2064         /* Watch a specific name on the bus. We only support one unit
2065          * watching each name for now. */
2066
2067         return hashmap_put(u->manager->watch_bus, name, u);
2068 }
2069
2070 void unit_unwatch_bus_name(Unit *u, const char *name) {
2071         assert(u);
2072         assert(name);
2073
2074         hashmap_remove_value(u->manager->watch_bus, name, u);
2075 }
2076
2077 bool unit_can_serialize(Unit *u) {
2078         assert(u);
2079
2080         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2081 }
2082
2083 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2084         int r;
2085
2086         assert(u);
2087         assert(f);
2088         assert(fds);
2089
2090         if (!unit_can_serialize(u))
2091                 return 0;
2092
2093         r = UNIT_VTABLE(u)->serialize(u, f, fds);
2094         if (r < 0)
2095                 return r;
2096
2097
2098         if (serialize_jobs) {
2099                 if (u->job) {
2100                         fprintf(f, "job\n");
2101                         job_serialize(u->job, f, fds);
2102                 }
2103
2104                 if (u->nop_job) {
2105                         fprintf(f, "job\n");
2106                         job_serialize(u->nop_job, f, fds);
2107                 }
2108         }
2109
2110         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2111         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2112         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2113         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2114         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2115
2116         if (dual_timestamp_is_set(&u->condition_timestamp))
2117                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2118
2119         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2120
2121         if (u->cgroup_path)
2122                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2123
2124         /* End marker */
2125         fputc('\n', f);
2126         return 0;
2127 }
2128
2129 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2130         va_list ap;
2131
2132         assert(u);
2133         assert(f);
2134         assert(key);
2135         assert(format);
2136
2137         fputs(key, f);
2138         fputc('=', f);
2139
2140         va_start(ap, format);
2141         vfprintf(f, format, ap);
2142         va_end(ap);
2143
2144         fputc('\n', f);
2145 }
2146
2147 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2148         assert(u);
2149         assert(f);
2150         assert(key);
2151         assert(value);
2152
2153         fprintf(f, "%s=%s\n", key, value);
2154 }
2155
2156 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2157         int r;
2158
2159         assert(u);
2160         assert(f);
2161         assert(fds);
2162
2163         if (!unit_can_serialize(u))
2164                 return 0;
2165
2166         for (;;) {
2167                 char line[LINE_MAX], *l, *v;
2168                 size_t k;
2169
2170                 if (!fgets(line, sizeof(line), f)) {
2171                         if (feof(f))
2172                                 return 0;
2173                         return -errno;
2174                 }
2175
2176                 char_array_0(line);
2177                 l = strstrip(line);
2178
2179                 /* End marker */
2180                 if (l[0] == 0)
2181                         return 0;
2182
2183                 k = strcspn(l, "=");
2184
2185                 if (l[k] == '=') {
2186                         l[k] = 0;
2187                         v = l+k+1;
2188                 } else
2189                         v = l+k;
2190
2191                 if (streq(l, "job")) {
2192                         if (v[0] == '\0') {
2193                                 /* new-style serialized job */
2194                                 Job *j = job_new_raw(u);
2195                                 if (!j)
2196                                         return -ENOMEM;
2197
2198                                 r = job_deserialize(j, f, fds);
2199                                 if (r < 0) {
2200                                         job_free(j);
2201                                         return r;
2202                                 }
2203
2204                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2205                                 if (r < 0) {
2206                                         job_free(j);
2207                                         return r;
2208                                 }
2209
2210                                 r = job_install_deserialized(j);
2211                                 if (r < 0) {
2212                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2213                                         job_free(j);
2214                                         return r;
2215                                 }
2216
2217                                 if (j->state == JOB_RUNNING)
2218                                         u->manager->n_running_jobs++;
2219                         } else {
2220                                 /* legacy */
2221                                 JobType type = job_type_from_string(v);
2222                                 if (type < 0)
2223                                         log_debug("Failed to parse job type value %s", v);
2224                                 else
2225                                         u->deserialized_job = type;
2226                         }
2227                         continue;
2228                 } else if (streq(l, "inactive-exit-timestamp")) {
2229                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2230                         continue;
2231                 } else if (streq(l, "active-enter-timestamp")) {
2232                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2233                         continue;
2234                 } else if (streq(l, "active-exit-timestamp")) {
2235                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2236                         continue;
2237                 } else if (streq(l, "inactive-enter-timestamp")) {
2238                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2239                         continue;
2240                 } else if (streq(l, "condition-timestamp")) {
2241                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2242                         continue;
2243                 } else if (streq(l, "condition-result")) {
2244                         int b;
2245
2246                         b = parse_boolean(v);
2247                         if (b < 0)
2248                                 log_debug("Failed to parse condition result value %s", v);
2249                         else
2250                                 u->condition_result = b;
2251
2252                         continue;
2253
2254                 } else if (streq(l, "transient")) {
2255                         int b;
2256
2257                         b = parse_boolean(v);
2258                         if (b < 0)
2259                                 log_debug("Failed to parse transient bool %s", v);
2260                         else
2261                                 u->transient = b;
2262
2263                         continue;
2264                 } else if (streq(l, "cgroup")) {
2265                         char *s;
2266
2267                         s = strdup(v);
2268                         if (!s)
2269                                 return -ENOMEM;
2270
2271                         free(u->cgroup_path);
2272                         u->cgroup_path = s;
2273
2274                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2275                         continue;
2276                 }
2277
2278                 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2279                 if (r < 0)
2280                         return r;
2281         }
2282 }
2283
2284 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2285         Unit *device;
2286         _cleanup_free_ char *e = NULL;
2287         int r;
2288
2289         assert(u);
2290
2291         if (!what)
2292                 return 0;
2293
2294         /* Adds in links to the device node that this unit is based on */
2295
2296         if (!is_device_path(what))
2297                 return 0;
2298
2299         e = unit_name_from_path(what, ".device");
2300         if (!e)
2301                 return -ENOMEM;
2302
2303         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2304
2305         if (r < 0)
2306                 return r;
2307
2308         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2309         if (r < 0)
2310                 return r;
2311
2312         if (wants) {
2313                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2314                 if (r < 0)
2315                         return r;
2316         }
2317
2318         return 0;
2319 }
2320
2321 int unit_coldplug(Unit *u) {
2322         int r;
2323
2324         assert(u);
2325
2326         if (UNIT_VTABLE(u)->coldplug)
2327                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2328                         return r;
2329
2330         if (u->job) {
2331                 r = job_coldplug(u->job);
2332                 if (r < 0)
2333                         return r;
2334         } else if (u->deserialized_job >= 0) {
2335                 /* legacy */
2336                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2337                 if (r < 0)
2338                         return r;
2339
2340                 u->deserialized_job = _JOB_TYPE_INVALID;
2341         }
2342
2343         return 0;
2344 }
2345
2346 #pragma GCC diagnostic push
2347 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2348 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2349         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2350 }
2351 #pragma GCC diagnostic pop
2352
2353 bool unit_need_daemon_reload(Unit *u) {
2354         _cleanup_strv_free_ char **t = NULL;
2355         char **path;
2356         struct stat st;
2357         unsigned loaded_cnt, current_cnt;
2358
2359         assert(u);
2360
2361         if (u->fragment_path) {
2362                 zero(st);
2363                 if (stat(u->fragment_path, &st) < 0)
2364                         /* What, cannot access this anymore? */
2365                         return true;
2366
2367                 if (u->fragment_mtime > 0 &&
2368                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2369                         return true;
2370         }
2371
2372         if (u->source_path) {
2373                 zero(st);
2374                 if (stat(u->source_path, &st) < 0)
2375                         return true;
2376
2377                 if (u->source_mtime > 0 &&
2378                     timespec_load(&st.st_mtim) != u->source_mtime)
2379                         return true;
2380         }
2381
2382         t = unit_find_dropin_paths(u);
2383         loaded_cnt = strv_length(t);
2384         current_cnt = strv_length(u->dropin_paths);
2385
2386         if (loaded_cnt == current_cnt) {
2387                 if (loaded_cnt == 0)
2388                         return false;
2389
2390                 if (strv_overlap(u->dropin_paths, t)) {
2391                         STRV_FOREACH(path, u->dropin_paths) {
2392                                 zero(st);
2393                                 if (stat(*path, &st) < 0)
2394                                         return true;
2395
2396                                 if (u->dropin_mtime > 0 &&
2397                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2398                                         return true;
2399                         }
2400
2401                         return false;
2402                 } else
2403                         return true;
2404         } else
2405                 return true;
2406 }
2407
2408 void unit_reset_failed(Unit *u) {
2409         assert(u);
2410
2411         if (UNIT_VTABLE(u)->reset_failed)
2412                 UNIT_VTABLE(u)->reset_failed(u);
2413 }
2414
2415 Unit *unit_following(Unit *u) {
2416         assert(u);
2417
2418         if (UNIT_VTABLE(u)->following)
2419                 return UNIT_VTABLE(u)->following(u);
2420
2421         return NULL;
2422 }
2423
2424 bool unit_stop_pending(Unit *u) {
2425         assert(u);
2426
2427         /* This call does check the current state of the unit. It's
2428          * hence useful to be called from state change calls of the
2429          * unit itself, where the state isn't updated yet. This is
2430          * different from unit_inactive_or_pending() which checks both
2431          * the current state and for a queued job. */
2432
2433         return u->job && u->job->type == JOB_STOP;
2434 }
2435
2436 bool unit_inactive_or_pending(Unit *u) {
2437         assert(u);
2438
2439         /* Returns true if the unit is inactive or going down */
2440
2441         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2442                 return true;
2443
2444         if (unit_stop_pending(u))
2445                 return true;
2446
2447         return false;
2448 }
2449
2450 bool unit_active_or_pending(Unit *u) {
2451         assert(u);
2452
2453         /* Returns true if the unit is active or going up */
2454
2455         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2456                 return true;
2457
2458         if (u->job &&
2459             (u->job->type == JOB_START ||
2460              u->job->type == JOB_RELOAD_OR_START ||
2461              u->job->type == JOB_RESTART))
2462                 return true;
2463
2464         return false;
2465 }
2466
2467 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2468         assert(u);
2469         assert(w >= 0 && w < _KILL_WHO_MAX);
2470         assert(signo > 0);
2471         assert(signo < _NSIG);
2472
2473         if (!UNIT_VTABLE(u)->kill)
2474                 return -ENOTSUP;
2475
2476         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2477 }
2478
2479 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2480         Set *pid_set;
2481         int r;
2482
2483         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2484         if (!pid_set)
2485                 return NULL;
2486
2487         /* Exclude the main/control pids from being killed via the cgroup */
2488         if (main_pid > 0) {
2489                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2490                 if (r < 0)
2491                         goto fail;
2492         }
2493
2494         if (control_pid > 0) {
2495                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2496                 if (r < 0)
2497                         goto fail;
2498         }
2499
2500         return pid_set;
2501
2502 fail:
2503         set_free(pid_set);
2504         return NULL;
2505 }
2506
2507 int unit_kill_common(
2508                 Unit *u,
2509                 KillWho who,
2510                 int signo,
2511                 pid_t main_pid,
2512                 pid_t control_pid,
2513                 sd_bus_error *error) {
2514
2515         int r = 0;
2516
2517         if (who == KILL_MAIN && main_pid <= 0) {
2518                 if (main_pid < 0)
2519                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2520                 else
2521                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2522                 return -ESRCH;
2523         }
2524
2525         if (who == KILL_CONTROL && control_pid <= 0) {
2526                 if (control_pid < 0)
2527                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2528                 else
2529                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2530                 return -ESRCH;
2531         }
2532
2533         if (who == KILL_CONTROL || who == KILL_ALL)
2534                 if (control_pid > 0)
2535                         if (kill(control_pid, signo) < 0)
2536                                 r = -errno;
2537
2538         if (who == KILL_MAIN || who == KILL_ALL)
2539                 if (main_pid > 0)
2540                         if (kill(main_pid, signo) < 0)
2541                                 r = -errno;
2542
2543         if (who == KILL_ALL && u->cgroup_path) {
2544                 _cleanup_set_free_ Set *pid_set = NULL;
2545                 int q;
2546
2547                 /* Exclude the main/control pids from being killed via the cgroup */
2548                 pid_set = unit_pid_set(main_pid, control_pid);
2549                 if (!pid_set)
2550                         return -ENOMEM;
2551
2552                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2553                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2554                         r = q;
2555         }
2556
2557         return r;
2558 }
2559
2560 int unit_following_set(Unit *u, Set **s) {
2561         assert(u);
2562         assert(s);
2563
2564         if (UNIT_VTABLE(u)->following_set)
2565                 return UNIT_VTABLE(u)->following_set(u, s);
2566
2567         *s = NULL;
2568         return 0;
2569 }
2570
2571 UnitFileState unit_get_unit_file_state(Unit *u) {
2572         assert(u);
2573
2574         if (u->unit_file_state < 0 && u->fragment_path)
2575                 u->unit_file_state = unit_file_get_state(
2576                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2577                                 NULL, path_get_file_name(u->fragment_path));
2578
2579         return u->unit_file_state;
2580 }
2581
2582 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2583         assert(ref);
2584         assert(u);
2585
2586         if (ref->unit)
2587                 unit_ref_unset(ref);
2588
2589         ref->unit = u;
2590         LIST_PREPEND(refs, u->refs, ref);
2591         return u;
2592 }
2593
2594 void unit_ref_unset(UnitRef *ref) {
2595         assert(ref);
2596
2597         if (!ref->unit)
2598                 return;
2599
2600         LIST_REMOVE(refs, ref->unit->refs, ref);
2601         ref->unit = NULL;
2602 }
2603
2604 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2605         unsigned i;
2606         int r;
2607
2608         assert(u);
2609         assert(c);
2610
2611         /* This only copies in the ones that need memory */
2612         for (i = 0; i < RLIMIT_NLIMITS; i++)
2613                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2614                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2615                         if (!c->rlimit[i])
2616                                 return -ENOMEM;
2617                 }
2618
2619         if (u->manager->running_as == SYSTEMD_USER &&
2620             !c->working_directory) {
2621
2622                 r = get_home_dir(&c->working_directory);
2623                 if (r < 0)
2624                         return r;
2625         }
2626
2627         return 0;
2628 }
2629
2630 ExecContext *unit_get_exec_context(Unit *u) {
2631         size_t offset;
2632         assert(u);
2633
2634         offset = UNIT_VTABLE(u)->exec_context_offset;
2635         if (offset <= 0)
2636                 return NULL;
2637
2638         return (ExecContext*) ((uint8_t*) u + offset);
2639 }
2640
2641 KillContext *unit_get_kill_context(Unit *u) {
2642         size_t offset;
2643         assert(u);
2644
2645         offset = UNIT_VTABLE(u)->kill_context_offset;
2646         if (offset <= 0)
2647                 return NULL;
2648
2649         return (KillContext*) ((uint8_t*) u + offset);
2650 }
2651
2652 CGroupContext *unit_get_cgroup_context(Unit *u) {
2653         size_t offset;
2654
2655         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2656         if (offset <= 0)
2657                 return NULL;
2658
2659         return (CGroupContext*) ((uint8_t*) u + offset);
2660 }
2661
2662 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2663         _cleanup_free_ char *b = NULL;
2664         char *p, *q;
2665         int r;
2666
2667         assert(u);
2668         assert(name);
2669         assert(_p);
2670         assert(_q);
2671         assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2672
2673         b = xescape(name, "/.");
2674         if (!b)
2675                 return -ENOMEM;
2676
2677         if (!filename_is_safe(b))
2678                 return -EINVAL;
2679
2680         if (u->manager->running_as == SYSTEMD_USER) {
2681                 _cleanup_free_ char *c = NULL;
2682
2683                 r = user_config_home(&c);
2684                 if (r < 0)
2685                         return r;
2686                 if (r == 0)
2687                         return -ENOENT;
2688
2689                 p = strjoin(c, "/", u->id, ".d", NULL);
2690         } else if (mode & UNIT_PERSISTENT)
2691                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2692         else
2693                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2694         if (!p)
2695                 return -ENOMEM;
2696
2697         q = strjoin(p, "/90-", b, ".conf", NULL);
2698         if (!q) {
2699                 free(p);
2700                 return -ENOMEM;
2701         }
2702
2703         *_p = p;
2704         *_q = q;
2705         return 0;
2706 }
2707
2708 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2709         _cleanup_free_ char *p = NULL, *q = NULL;
2710         int r;
2711
2712         assert(u);
2713         assert(name);
2714         assert(data);
2715
2716         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2717                 return 0;
2718
2719         r = drop_in_file(u, mode, name, &p, &q);
2720         if (r < 0)
2721                 return r;
2722
2723         mkdir_p(p, 0755);
2724         return write_string_file_atomic_label(q, data);
2725 }
2726
2727 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2728         _cleanup_free_ char *p = NULL;
2729         va_list ap;
2730         int r;
2731
2732         assert(u);
2733         assert(name);
2734         assert(format);
2735
2736         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2737                 return 0;
2738
2739         va_start(ap, format);
2740         r = vasprintf(&p, format, ap);
2741         va_end(ap);
2742
2743         if (r < 0)
2744                 return -ENOMEM;
2745
2746         return unit_write_drop_in(u, mode, name, p);
2747 }
2748
2749 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2750         _cleanup_free_ char *ndata = NULL;
2751
2752         assert(u);
2753         assert(name);
2754         assert(data);
2755
2756         if (!UNIT_VTABLE(u)->private_section)
2757                 return -EINVAL;
2758
2759         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2760                 return 0;
2761
2762         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2763         if (!ndata)
2764                 return -ENOMEM;
2765
2766         return unit_write_drop_in(u, mode, name, ndata);
2767 }
2768
2769 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2770         _cleanup_free_ char *p = NULL;
2771         va_list ap;
2772         int r;
2773
2774         assert(u);
2775         assert(name);
2776         assert(format);
2777
2778         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2779                 return 0;
2780
2781         va_start(ap, format);
2782         r = vasprintf(&p, format, ap);
2783         va_end(ap);
2784
2785         if (r < 0)
2786                 return -ENOMEM;
2787
2788         return unit_write_drop_in_private(u, mode, name, p);
2789 }
2790
2791 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2792         _cleanup_free_ char *p = NULL, *q = NULL;
2793         int r;
2794
2795         assert(u);
2796
2797         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2798                 return 0;
2799
2800         r = drop_in_file(u, mode, name, &p, &q);
2801         if (r < 0)
2802                 return r;
2803
2804         if (unlink(q) < 0)
2805                 r = errno == ENOENT ? 0 : -errno;
2806         else
2807                 r = 1;
2808
2809         rmdir(p);
2810         return r;
2811 }
2812
2813 int unit_make_transient(Unit *u) {
2814         int r;
2815
2816         assert(u);
2817
2818         u->load_state = UNIT_STUB;
2819         u->load_error = 0;
2820         u->transient = true;
2821
2822         free(u->fragment_path);
2823         u->fragment_path = NULL;
2824
2825         if (u->manager->running_as == SYSTEMD_USER) {
2826                 _cleanup_free_ char *c = NULL;
2827
2828                 r = user_config_home(&c);
2829                 if (r < 0)
2830                         return r;
2831                 if (r == 0)
2832                         return -ENOENT;
2833
2834                 u->fragment_path = strjoin(c, "/", u->id, NULL);
2835                 if (!u->fragment_path)
2836                         return -ENOMEM;
2837
2838                 mkdir_p(c, 0755);
2839         } else {
2840                 u->fragment_path = strappend("/run/systemd/system/", u->id);
2841                 if (!u->fragment_path)
2842                         return -ENOMEM;
2843
2844                 mkdir_p("/run/systemd/system", 0755);
2845         }
2846
2847         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2848 }
2849
2850 int unit_kill_context(
2851                 Unit *u,
2852                 KillContext *c,
2853                 bool sigkill,
2854                 pid_t main_pid,
2855                 pid_t control_pid,
2856                 bool main_pid_alien) {
2857
2858         int sig, wait_for_exit = 0, r;
2859
2860         assert(u);
2861         assert(c);
2862
2863         if (c->kill_mode == KILL_NONE)
2864                 return 0;
2865
2866         sig = sigkill ? SIGKILL : c->kill_signal;
2867
2868         if (main_pid > 0) {
2869                 r = kill_and_sigcont(main_pid, sig);
2870
2871                 if (r < 0 && r != -ESRCH) {
2872                         _cleanup_free_ char *comm = NULL;
2873                         get_process_comm(main_pid, &comm);
2874
2875                         log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2876                                          (long) main_pid, strna(comm), strerror(-r));
2877                 } else {
2878                         wait_for_exit = !main_pid_alien;
2879
2880                         if (c->send_sighup)
2881                                 kill(main_pid, SIGHUP);
2882                 }
2883         }
2884
2885         if (control_pid > 0) {
2886                 r = kill_and_sigcont(control_pid, sig);
2887
2888                 if (r < 0 && r != -ESRCH) {
2889                         _cleanup_free_ char *comm = NULL;
2890                         get_process_comm(control_pid, &comm);
2891
2892                         log_warning_unit(u->id,
2893                                          "Failed to kill control process %li (%s): %s",
2894                                          (long) control_pid, strna(comm), strerror(-r));
2895                 } else {
2896                         wait_for_exit = true;
2897
2898                         if (c->send_sighup)
2899                                 kill(control_pid, SIGHUP);
2900                 }
2901         }
2902
2903         if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2904                 _cleanup_set_free_ Set *pid_set = NULL;
2905
2906                 /* Exclude the main/control pids from being killed via the cgroup */
2907                 pid_set = unit_pid_set(main_pid, control_pid);
2908                 if (!pid_set)
2909                         return -ENOMEM;
2910
2911                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2912                 if (r < 0) {
2913                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2914                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2915                 } else if (r > 0) {
2916                         wait_for_exit = true;
2917                         if (c->send_sighup) {
2918                                 set_free(pid_set);
2919
2920                                 pid_set = unit_pid_set(main_pid, control_pid);
2921                                 if (!pid_set)
2922                                         return -ENOMEM;
2923
2924                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
2925                         }
2926                 }
2927         }
2928
2929         return wait_for_exit;
2930 }
2931
2932 int unit_require_mounts_for(Unit *u, const char *path) {
2933         char prefix[strlen(path) + 1], *p;
2934         int r;
2935
2936         assert(u);
2937         assert(path);
2938
2939         /* Registers a unit for requiring a certain path and all its
2940          * prefixes. We keep a simple array of these paths in the
2941          * unit, since its usually short. However, we build a prefix
2942          * table for all possible prefixes so that new appearing mount
2943          * units can easily determine which units to make themselves a
2944          * dependency of. */
2945
2946         p = strdup(path);
2947         if (!p)
2948                 return -ENOMEM;
2949
2950         path_kill_slashes(p);
2951
2952         if (!path_is_absolute(p)) {
2953                 free(p);
2954                 return -EINVAL;
2955         }
2956
2957         if (!path_is_safe(p)) {
2958                 free(p);
2959                 return -EPERM;
2960         }
2961
2962         if (strv_contains(u->requires_mounts_for, p)) {
2963                 free(p);
2964                 return 0;
2965         }
2966
2967         r = strv_push(&u->requires_mounts_for, p);
2968         if (r < 0) {
2969                 free(p);
2970                 return r;
2971         }
2972
2973         PATH_FOREACH_PREFIX_MORE(prefix, p) {
2974                 Set *x;
2975
2976                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
2977                 if (!x) {
2978                         char *q;
2979
2980                         if (!u->manager->units_requiring_mounts_for) {
2981                                 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
2982                                 if (!u->manager->units_requiring_mounts_for)
2983                                         return -ENOMEM;
2984                         }
2985
2986                         q = strdup(prefix);
2987                         if (!q)
2988                                 return -ENOMEM;
2989
2990                         x = set_new(NULL, NULL);
2991                         if (!x) {
2992                                 free(q);
2993                                 return -ENOMEM;
2994                         }
2995
2996                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
2997                         if (r < 0) {
2998                                 free(q);
2999                                 set_free(x);
3000                                 return r;
3001                         }
3002                 }
3003
3004                 r = set_put(x, u);
3005                 if (r < 0)
3006                         return r;
3007         }
3008
3009         return 0;
3010 }
3011
3012 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3013         [UNIT_ACTIVE] = "active",
3014         [UNIT_RELOADING] = "reloading",
3015         [UNIT_INACTIVE] = "inactive",
3016         [UNIT_FAILED] = "failed",
3017         [UNIT_ACTIVATING] = "activating",
3018         [UNIT_DEACTIVATING] = "deactivating"
3019 };
3020
3021 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3022
3023 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3024         [UNIT_REQUIRES] = "Requires",
3025         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3026         [UNIT_REQUISITE] = "Requisite",
3027         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3028         [UNIT_WANTS] = "Wants",
3029         [UNIT_BINDS_TO] = "BindsTo",
3030         [UNIT_PART_OF] = "PartOf",
3031         [UNIT_REQUIRED_BY] = "RequiredBy",
3032         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3033         [UNIT_WANTED_BY] = "WantedBy",
3034         [UNIT_BOUND_BY] = "BoundBy",
3035         [UNIT_CONSISTS_OF] = "ConsistsOf",
3036         [UNIT_CONFLICTS] = "Conflicts",
3037         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3038         [UNIT_BEFORE] = "Before",
3039         [UNIT_AFTER] = "After",
3040         [UNIT_ON_FAILURE] = "OnFailure",
3041         [UNIT_TRIGGERS] = "Triggers",
3042         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3043         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3044         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3045         [UNIT_REFERENCES] = "References",
3046         [UNIT_REFERENCED_BY] = "ReferencedBy",
3047 };
3048
3049 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);