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