src/core/unit.c

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