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