src/core/unit.c

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