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