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