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