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                 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1584                         return -errno;
1585         } else
1586                 assert_not_reached("Invalid watch type");
1587
1588         zero(its);
1589
1590         if (delay <= 0) {
1591                 /* Set absolute time in the past, but not 0, since we
1592                  * don't want to disarm the timer */
1593                 its.it_value.tv_sec = 0;
1594                 its.it_value.tv_nsec = 1;
1595
1596                 flags = TFD_TIMER_ABSTIME;
1597         } else {
1598                 timespec_store(&its.it_value, delay);
1599                 flags = 0;
1600         }
1601
1602         /* This will also flush the elapse counter */
1603         if (timerfd_settime(fd, flags, &its, NULL) < 0)
1604                 goto fail;
1605
1606         if (w->type == WATCH_INVALID) {
1607                 struct epoll_event ev;
1608
1609                 zero(ev);
1610                 ev.data.ptr = w;
1611                 ev.events = EPOLLIN;
1612
1613                 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1614                         goto fail;
1615         }
1616
1617         w->type = WATCH_UNIT_TIMER;
1618         w->fd = fd;
1619         w->data.unit = u;
1620
1621         return 0;
1622
1623 fail:
1624         if (ours)
1625                 close_nointr_nofail(fd);
1626
1627         return -errno;
1628 }
1629
1630 void unit_unwatch_timer(Unit *u, Watch *w) {
1631         assert(u);
1632         assert(w);
1633
1634         if (w->type == WATCH_INVALID)
1635                 return;
1636
1637         assert(w->type == WATCH_UNIT_TIMER);
1638         assert(w->data.unit == u);
1639         assert(w->fd >= 0);
1640
1641         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1642         close_nointr_nofail(w->fd);
1643
1644         w->fd = -1;
1645         w->type = WATCH_INVALID;
1646         w->data.unit = NULL;
1647 }
1648
1649 bool unit_job_is_applicable(Unit *u, JobType j) {
1650         assert(u);
1651         assert(j >= 0 && j < _JOB_TYPE_MAX);
1652
1653         switch (j) {
1654
1655         case JOB_VERIFY_ACTIVE:
1656         case JOB_START:
1657         case JOB_STOP:
1658         case JOB_NOP:
1659                 return true;
1660
1661         case JOB_RESTART:
1662         case JOB_TRY_RESTART:
1663                 return unit_can_start(u);
1664
1665         case JOB_RELOAD:
1666                 return unit_can_reload(u);
1667
1668         case JOB_RELOAD_OR_START:
1669                 return unit_can_reload(u) && unit_can_start(u);
1670
1671         default:
1672                 assert_not_reached("Invalid job type");
1673         }
1674 }
1675
1676 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1677
1678         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1679                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1680                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1681                 [UNIT_WANTS] = UNIT_WANTED_BY,
1682                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1683                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1684                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1685                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1686                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1687                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1688                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1689                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1690                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1691                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1692                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1693                 [UNIT_BEFORE] = UNIT_AFTER,
1694                 [UNIT_AFTER] = UNIT_BEFORE,
1695                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1696                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1697                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1698                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1699                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1700                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1701                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1702         };
1703         int r, q = 0, v = 0, w = 0;
1704
1705         assert(u);
1706         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1707         assert(other);
1708
1709         u = unit_follow_merge(u);
1710         other = unit_follow_merge(other);
1711
1712         /* We won't allow dependencies on ourselves. We will not
1713          * consider them an error however. */
1714         if (u == other)
1715                 return 0;
1716
1717         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1718                 return r;
1719
1720         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1721                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1722                         return r;
1723
1724         if (add_reference)
1725                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1726                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1727                         return r;
1728
1729         if ((q = set_put(u->dependencies[d], other)) < 0)
1730                 return q;
1731
1732         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1733                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1734                         r = v;
1735                         goto fail;
1736                 }
1737
1738         if (add_reference) {
1739                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1740                         r = w;
1741                         goto fail;
1742                 }
1743
1744                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1745                         goto fail;
1746         }
1747
1748         unit_add_to_dbus_queue(u);
1749         return 0;
1750
1751 fail:
1752         if (q > 0)
1753                 set_remove(u->dependencies[d], other);
1754
1755         if (v > 0)
1756                 set_remove(other->dependencies[inverse_table[d]], u);
1757
1758         if (w > 0)
1759                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1760
1761         return r;
1762 }
1763
1764 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1765         int r;
1766
1767         assert(u);
1768
1769         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1770                 return r;
1771
1772         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1773                 return r;
1774
1775         return 0;
1776 }
1777
1778 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1779         char *s;
1780
1781         assert(u);
1782         assert(name || path);
1783
1784         if (!name)
1785                 name = path_get_file_name(path);
1786
1787         if (!unit_name_is_template(name)) {
1788                 *p = NULL;
1789                 return name;
1790         }
1791
1792         if (u->instance)
1793                 s = unit_name_replace_instance(name, u->instance);
1794         else {
1795                 char *i;
1796
1797                 if (!(i = unit_name_to_prefix(u->id)))
1798                         return NULL;
1799
1800                 s = unit_name_replace_instance(name, i);
1801                 free(i);
1802         }
1803
1804         if (!s)
1805                 return NULL;
1806
1807         *p = s;
1808         return s;
1809 }
1810
1811 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1812         Unit *other;
1813         int r;
1814         char *s;
1815
1816         assert(u);
1817         assert(name || path);
1818
1819         if (!(name = resolve_template(u, name, path, &s)))
1820                 return -ENOMEM;
1821
1822         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1823                 goto finish;
1824
1825         r = unit_add_dependency(u, d, other, add_reference);
1826
1827 finish:
1828         free(s);
1829         return r;
1830 }
1831
1832 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1833         Unit *other;
1834         int r;
1835         char *s;
1836
1837         assert(u);
1838         assert(name || path);
1839
1840         if (!(name = resolve_template(u, name, path, &s)))
1841                 return -ENOMEM;
1842
1843         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1844                 goto finish;
1845
1846         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1847
1848 finish:
1849         free(s);
1850         return r;
1851 }
1852
1853 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1854         Unit *other;
1855         int r;
1856         char *s;
1857
1858         assert(u);
1859         assert(name || path);
1860
1861         if (!(name = resolve_template(u, name, path, &s)))
1862                 return -ENOMEM;
1863
1864         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1865                 goto finish;
1866
1867         r = unit_add_dependency(other, d, u, add_reference);
1868
1869 finish:
1870         free(s);
1871         return r;
1872 }
1873
1874 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1875         Unit *other;
1876         int r;
1877         char *s;
1878
1879         assert(u);
1880         assert(name || path);
1881
1882         if (!(name = resolve_template(u, name, path, &s)))
1883                 return -ENOMEM;
1884
1885         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1886                 goto finish;
1887
1888         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1889                 goto finish;
1890
1891 finish:
1892         free(s);
1893         return r;
1894 }
1895
1896 int set_unit_path(const char *p) {
1897         char *cwd, *c;
1898         int r;
1899
1900         /* This is mostly for debug purposes */
1901
1902         if (path_is_absolute(p)) {
1903                 if (!(c = strdup(p)))
1904                         return -ENOMEM;
1905         } else {
1906                 if (!(cwd = get_current_dir_name()))
1907                         return -errno;
1908
1909                 r = asprintf(&c, "%s/%s", cwd, p);
1910                 free(cwd);
1911
1912                 if (r < 0)
1913                         return -ENOMEM;
1914         }
1915
1916         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1917                 r = -errno;
1918                 free(c);
1919                 return r;
1920         }
1921
1922         return 0;
1923 }
1924
1925 char *unit_dbus_path(Unit *u) {
1926         assert(u);
1927
1928         if (!u->id)
1929                 return NULL;
1930
1931         return unit_dbus_path_from_name(u->id);
1932 }
1933
1934 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1935         int r;
1936
1937         assert(u);
1938         assert(b);
1939
1940         assert(b->path);
1941
1942         if (!b->controller) {
1943                 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1944                         return -ENOMEM;
1945
1946                 b->ours = true;
1947         }
1948
1949         /* Ensure this hasn't been added yet */
1950         assert(!b->unit);
1951
1952         if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1953                 CGroupBonding *l;
1954
1955                 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1956                 LIST_PREPEND(CGroupBonding, by_path, l, b);
1957
1958                 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1959                         LIST_REMOVE(CGroupBonding, by_path, l, b);
1960                         return r;
1961                 }
1962         }
1963
1964         LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1965         b->unit = u;
1966
1967         return 0;
1968 }
1969
1970 char *unit_default_cgroup_path(Unit *u) {
1971         char *p;
1972
1973         assert(u);
1974
1975         if (u->instance) {
1976                 char *t;
1977
1978                 t = unit_name_template(u->id);
1979                 if (!t)
1980                         return NULL;
1981
1982                 p = strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1983                 free(t);
1984         } else
1985                 p = strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1986
1987         return p;
1988 }
1989
1990 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1991         char *controller = NULL, *path = NULL;
1992         CGroupBonding *b = NULL;
1993         bool ours = false;
1994         int r;
1995
1996         assert(u);
1997         assert(name);
1998
1999         if ((r = cg_split_spec(name, &controller, &path)) < 0)
2000                 return r;
2001
2002         if (!path) {
2003                 path = unit_default_cgroup_path(u);
2004                 ours = true;
2005         }
2006
2007         if (!controller) {
2008                 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2009                 ours = true;
2010         }
2011
2012         if (!path || !controller) {
2013                 free(path);
2014                 free(controller);
2015
2016                 return -ENOMEM;
2017         }
2018
2019         if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
2020                 r = -EEXIST;
2021                 goto fail;
2022         }
2023
2024         if (!(b = new0(CGroupBonding, 1))) {
2025                 r = -ENOMEM;
2026                 goto fail;
2027         }
2028
2029         b->controller = controller;
2030         b->path = path;
2031         b->ours = ours;
2032         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2033
2034         if ((r = unit_add_cgroup(u, b)) < 0)
2035                 goto fail;
2036
2037         return 0;
2038
2039 fail:
2040         free(path);
2041         free(controller);
2042         free(b);
2043
2044         return r;
2045 }
2046
2047 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2048         CGroupBonding *b = NULL;
2049         int r = -ENOMEM;
2050
2051         assert(u);
2052
2053         if (!controller)
2054                 controller = SYSTEMD_CGROUP_CONTROLLER;
2055
2056         if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2057                 return 0;
2058
2059         if (!(b = new0(CGroupBonding, 1)))
2060                 return -ENOMEM;
2061
2062         if (!(b->controller = strdup(controller)))
2063                 goto fail;
2064
2065         b->path = unit_default_cgroup_path(u);
2066         if (!b->path)
2067                 goto fail;
2068
2069         b->ours = true;
2070         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2071
2072         if ((r = unit_add_cgroup(u, b)) < 0)
2073                 goto fail;
2074
2075         return 0;
2076
2077 fail:
2078         free(b->path);
2079         free(b->controller);
2080         free(b);
2081
2082         return r;
2083 }
2084
2085 int unit_add_default_cgroups(Unit *u) {
2086         CGroupAttribute *a;
2087         char **c;
2088         int r;
2089
2090         assert(u);
2091
2092         /* Adds in the default cgroups, if they weren't specified
2093          * otherwise. */
2094
2095         if (!u->manager->cgroup_hierarchy)
2096                 return 0;
2097
2098         if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
2099                 return r;
2100
2101         STRV_FOREACH(c, u->manager->default_controllers)
2102                 unit_add_one_default_cgroup(u, *c);
2103
2104         LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2105                 unit_add_one_default_cgroup(u, a->controller);
2106
2107         return 0;
2108 }
2109
2110 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2111         assert(u);
2112
2113         return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
2114 }
2115
2116 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
2117         int r;
2118         char *c = NULL;
2119         CGroupAttribute *a;
2120
2121         assert(u);
2122         assert(name);
2123         assert(value);
2124
2125         if (!controller) {
2126                 const char *dot;
2127
2128                 dot = strchr(name, '.');
2129                 if (!dot)
2130                         return -EINVAL;
2131
2132                 c = strndup(name, dot - name);
2133                 if (!c)
2134                         return -ENOMEM;
2135
2136                 controller = c;
2137         }
2138
2139         if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
2140                 r = -EINVAL;
2141                 goto finish;
2142         }
2143
2144         a = new0(CGroupAttribute, 1);
2145         if (!a) {
2146                 r = -ENOMEM;
2147                 goto finish;
2148         }
2149
2150         if (c) {
2151                 a->controller = c;
2152                 c = NULL;
2153         } else
2154                 a->controller = strdup(controller);
2155
2156         a->name = strdup(name);
2157         a->value = strdup(value);
2158
2159         if (!a->controller || !a->name || !a->value) {
2160                 free(a->controller);
2161                 free(a->name);
2162                 free(a->value);
2163                 free(a);
2164
2165                 return -ENOMEM;
2166         }
2167
2168         a->map_callback = map_callback;
2169
2170         LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2171
2172         r = 0;
2173
2174 finish:
2175         free(c);
2176         return r;
2177 }
2178
2179 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2180         char *t;
2181         int r;
2182
2183         assert(u);
2184         assert(type);
2185         assert(_found);
2186
2187         if (!(t = unit_name_change_suffix(u->id, type)))
2188                 return -ENOMEM;
2189
2190         assert(!unit_has_name(u, t));
2191
2192         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2193         free(t);
2194
2195         assert(r < 0 || *_found != u);
2196
2197         return r;
2198 }
2199
2200 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2201         Unit *found;
2202         char *t;
2203
2204         assert(u);
2205         assert(type);
2206         assert(_found);
2207
2208         if (!(t = unit_name_change_suffix(u->id, type)))
2209                 return -ENOMEM;
2210
2211         assert(!unit_has_name(u, t));
2212
2213         found = manager_get_unit(u->manager, t);
2214         free(t);
2215
2216         if (!found)
2217                 return -ENOENT;
2218
2219         *_found = found;
2220         return 0;
2221 }
2222
2223 int unit_watch_bus_name(Unit *u, const char *name) {
2224         assert(u);
2225         assert(name);
2226
2227         /* Watch a specific name on the bus. We only support one unit
2228          * watching each name for now. */
2229
2230         return hashmap_put(u->manager->watch_bus, name, u);
2231 }
2232
2233 void unit_unwatch_bus_name(Unit *u, const char *name) {
2234         assert(u);
2235         assert(name);
2236
2237         hashmap_remove_value(u->manager->watch_bus, name, u);
2238 }
2239
2240 bool unit_can_serialize(Unit *u) {
2241         assert(u);
2242
2243         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2244 }
2245
2246 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2247         int r;
2248
2249         assert(u);
2250         assert(f);
2251         assert(fds);
2252
2253         if (!unit_can_serialize(u))
2254                 return 0;
2255
2256         if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2257                 return r;
2258
2259
2260         if (serialize_jobs) {
2261                 if (u->job) {
2262                         fprintf(f, "job\n");
2263                         job_serialize(u->job, f, fds);
2264                 }
2265
2266                 if (u->nop_job) {
2267                         fprintf(f, "job\n");
2268                         job_serialize(u->nop_job, f, fds);
2269                 }
2270         }
2271
2272         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2273         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2274         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2275         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2276         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2277
2278         if (dual_timestamp_is_set(&u->condition_timestamp))
2279                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2280
2281         /* End marker */
2282         fputc('\n', f);
2283         return 0;
2284 }
2285
2286 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2287         va_list ap;
2288
2289         assert(u);
2290         assert(f);
2291         assert(key);
2292         assert(format);
2293
2294         fputs(key, f);
2295         fputc('=', f);
2296
2297         va_start(ap, format);
2298         vfprintf(f, format, ap);
2299         va_end(ap);
2300
2301         fputc('\n', f);
2302 }
2303
2304 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2305         assert(u);
2306         assert(f);
2307         assert(key);
2308         assert(value);
2309
2310         fprintf(f, "%s=%s\n", key, value);
2311 }
2312
2313 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2314         int r;
2315
2316         assert(u);
2317         assert(f);
2318         assert(fds);
2319
2320         if (!unit_can_serialize(u))
2321                 return 0;
2322
2323         for (;;) {
2324                 char line[LINE_MAX], *l, *v;
2325                 size_t k;
2326
2327                 if (!fgets(line, sizeof(line), f)) {
2328                         if (feof(f))
2329                                 return 0;
2330                         return -errno;
2331                 }
2332
2333                 char_array_0(line);
2334                 l = strstrip(line);
2335
2336                 /* End marker */
2337                 if (l[0] == 0)
2338                         return 0;
2339
2340                 k = strcspn(l, "=");
2341
2342                 if (l[k] == '=') {
2343                         l[k] = 0;
2344                         v = l+k+1;
2345                 } else
2346                         v = l+k;
2347
2348                 if (streq(l, "job")) {
2349                         if (v[0] == '\0') {
2350                                 /* new-style serialized job */
2351                                 Job *j = job_new_raw(u);
2352                                 if (!j)
2353                                         return -ENOMEM;
2354
2355                                 r = job_deserialize(j, f, fds);
2356                                 if (r < 0) {
2357                                         job_free(j);
2358                                         return r;
2359                                 }
2360
2361                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2362                                 if (r < 0) {
2363                                         job_free(j);
2364                                         return r;
2365                                 }
2366
2367                                 r = job_install_deserialized(j);
2368                                 if (r < 0) {
2369                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2370                                         job_free(j);
2371                                         return r;
2372                                 }
2373                         } else {
2374                                 /* legacy */
2375                                 JobType type = job_type_from_string(v);
2376                                 if (type < 0)
2377                                         log_debug("Failed to parse job type value %s", v);
2378                                 else
2379                                         u->deserialized_job = type;
2380                         }
2381                         continue;
2382                 } else if (streq(l, "inactive-exit-timestamp")) {
2383                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2384                         continue;
2385                 } else if (streq(l, "active-enter-timestamp")) {
2386                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2387                         continue;
2388                 } else if (streq(l, "active-exit-timestamp")) {
2389                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2390                         continue;
2391                 } else if (streq(l, "inactive-enter-timestamp")) {
2392                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2393                         continue;
2394                 } else if (streq(l, "condition-timestamp")) {
2395                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2396                         continue;
2397                 } else if (streq(l, "condition-result")) {
2398                         int b;
2399
2400                         if ((b = parse_boolean(v)) < 0)
2401                                 log_debug("Failed to parse condition result value %s", v);
2402                         else
2403                                 u->condition_result = b;
2404
2405                         continue;
2406                 }
2407
2408                 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2409                         return r;
2410         }
2411 }
2412
2413 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2414         Unit *device;
2415         char *e;
2416         int r;
2417
2418         assert(u);
2419
2420         if (!what)
2421                 return 0;
2422
2423         /* Adds in links to the device node that this unit is based on */
2424
2425         if (!is_device_path(what))
2426                 return 0;
2427
2428         e = unit_name_from_path(what, ".device");
2429         if (!e)
2430                 return -ENOMEM;
2431
2432         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2433         free(e);
2434         if (r < 0)
2435                 return r;
2436
2437         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2438         if (r < 0)
2439                 return r;
2440
2441         if (wants) {
2442                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2443                 if (r < 0)
2444                         return r;
2445         }
2446
2447         return 0;
2448 }
2449
2450 int unit_coldplug(Unit *u) {
2451         int r;
2452
2453         assert(u);
2454
2455         if (UNIT_VTABLE(u)->coldplug)
2456                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2457                         return r;
2458
2459         if (u->job) {
2460                 r = job_coldplug(u->job);
2461                 if (r < 0)
2462                         return r;
2463         } else if (u->deserialized_job >= 0) {
2464                 /* legacy */
2465                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2466                 if (r < 0)
2467                         return r;
2468
2469                 u->deserialized_job = _JOB_TYPE_INVALID;
2470         }
2471
2472         return 0;
2473 }
2474
2475 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2476         va_list ap;
2477
2478         assert(u);
2479         assert(format);
2480
2481         if (!manager_get_show_status(u->manager))
2482                 return;
2483
2484         if (!manager_is_booting_or_shutting_down(u->manager))
2485                 return;
2486
2487         va_start(ap, format);
2488         status_vprintf(status, true, format, ap);
2489         va_end(ap);
2490 }
2491
2492 bool unit_need_daemon_reload(Unit *u) {
2493         struct stat st;
2494
2495         assert(u);
2496
2497         if (u->fragment_path) {
2498                 zero(st);
2499                 if (stat(u->fragment_path, &st) < 0)
2500                         /* What, cannot access this anymore? */
2501                         return true;
2502
2503                 if (u->fragment_mtime > 0 &&
2504                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2505                         return true;
2506         }
2507
2508         if (u->source_path) {
2509                 zero(st);
2510                 if (stat(u->source_path, &st) < 0)
2511                         return true;
2512
2513                 if (u->source_mtime > 0 &&
2514                     timespec_load(&st.st_mtim) != u->source_mtime)
2515                         return true;
2516         }
2517
2518         return false;
2519 }
2520
2521 void unit_reset_failed(Unit *u) {
2522         assert(u);
2523
2524         if (UNIT_VTABLE(u)->reset_failed)
2525                 UNIT_VTABLE(u)->reset_failed(u);
2526 }
2527
2528 Unit *unit_following(Unit *u) {
2529         assert(u);
2530
2531         if (UNIT_VTABLE(u)->following)
2532                 return UNIT_VTABLE(u)->following(u);
2533
2534         return NULL;
2535 }
2536
2537 bool unit_pending_inactive(Unit *u) {
2538         assert(u);
2539
2540         /* Returns true if the unit is inactive or going down */
2541
2542         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2543                 return true;
2544
2545         if (u->job && u->job->type == JOB_STOP)
2546                 return true;
2547
2548         return false;
2549 }
2550
2551 bool unit_pending_active(Unit *u) {
2552         assert(u);
2553
2554         /* Returns true if the unit is active or going up */
2555
2556         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2557                 return true;
2558
2559         if (u->job &&
2560             (u->job->type == JOB_START ||
2561              u->job->type == JOB_RELOAD_OR_START ||
2562              u->job->type == JOB_RESTART))
2563                 return true;
2564
2565         return false;
2566 }
2567
2568 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2569         assert(u);
2570         assert(w >= 0 && w < _KILL_WHO_MAX);
2571         assert(signo > 0);
2572         assert(signo < _NSIG);
2573
2574         if (!UNIT_VTABLE(u)->kill)
2575                 return -ENOTSUP;
2576
2577         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2578 }
2579
2580 int unit_following_set(Unit *u, Set **s) {
2581         assert(u);
2582         assert(s);
2583
2584         if (UNIT_VTABLE(u)->following_set)
2585                 return UNIT_VTABLE(u)->following_set(u, s);
2586
2587         *s = NULL;
2588         return 0;
2589 }
2590
2591 UnitFileState unit_get_unit_file_state(Unit *u) {
2592         assert(u);
2593
2594         if (u->unit_file_state < 0 && u->fragment_path)
2595                 u->unit_file_state = unit_file_get_state(
2596                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2597                                 NULL, path_get_file_name(u->fragment_path));
2598
2599         return u->unit_file_state;
2600 }
2601
2602 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2603         assert(ref);
2604         assert(u);
2605
2606         if (ref->unit)
2607                 unit_ref_unset(ref);
2608
2609         ref->unit = u;
2610         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2611         return u;
2612 }
2613
2614 void unit_ref_unset(UnitRef *ref) {
2615         assert(ref);
2616
2617         if (!ref->unit)
2618                 return;
2619
2620         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2621         ref->unit = NULL;
2622 }
2623
2624 int unit_add_one_mount_link(Unit *u, Mount *m) {
2625         char **i;
2626
2627         assert(u);
2628         assert(m);
2629
2630         if (u->load_state != UNIT_LOADED ||
2631             UNIT(m)->load_state != UNIT_LOADED)
2632                 return 0;
2633
2634         STRV_FOREACH(i, u->requires_mounts_for) {
2635
2636                 if (UNIT(m) == u)
2637                         continue;
2638
2639                 if (!path_startswith(*i, m->where))
2640                         continue;
2641
2642                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2643         }
2644
2645         return 0;
2646 }
2647
2648 int unit_add_mount_links(Unit *u) {
2649         Unit *other;
2650         int r;
2651
2652         assert(u);
2653
2654         LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2655                 r = unit_add_one_mount_link(u, MOUNT(other));
2656                 if (r < 0)
2657                         return r;
2658         }
2659
2660         return 0;
2661 }
2662
2663 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2664         unsigned i;
2665         int r;
2666
2667         assert(u);
2668         assert(c);
2669
2670         /* This only copies in the ones that need memory */
2671
2672         for (i = 0; i < RLIMIT_NLIMITS; i++)
2673                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2674                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2675                         if (!c->rlimit[i])
2676                                 return -ENOMEM;
2677                 }
2678
2679         if (u->manager->running_as == SYSTEMD_USER &&
2680             !c->working_directory) {
2681
2682                 r = get_home_dir(&c->working_directory);
2683                 if (r < 0)
2684                         return r;
2685         }
2686
2687         return 0;
2688 }
2689
2690 ExecContext *unit_get_exec_context(Unit *u) {
2691         size_t offset;
2692         assert(u);
2693
2694         offset = UNIT_VTABLE(u)->exec_context_offset;
2695         if (offset <= 0)
2696                 return NULL;
2697
2698         return (ExecContext*) ((uint8_t*) u + offset);
2699 }
2700
2701 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2702         [UNIT_ACTIVE] = "active",
2703         [UNIT_RELOADING] = "reloading",
2704         [UNIT_INACTIVE] = "inactive",
2705         [UNIT_FAILED] = "failed",
2706         [UNIT_ACTIVATING] = "activating",
2707         [UNIT_DEACTIVATING] = "deactivating"
2708 };
2709
2710 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2711
2712 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2713         [UNIT_REQUIRES] = "Requires",
2714         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2715         [UNIT_REQUISITE] = "Requisite",
2716         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2717         [UNIT_WANTS] = "Wants",
2718         [UNIT_BINDS_TO] = "BindsTo",
2719         [UNIT_PART_OF] = "PartOf",
2720         [UNIT_REQUIRED_BY] = "RequiredBy",
2721         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2722         [UNIT_WANTED_BY] = "WantedBy",
2723         [UNIT_BOUND_BY] = "BoundBy",
2724         [UNIT_CONSISTS_OF] = "ConsistsOf",
2725         [UNIT_CONFLICTS] = "Conflicts",
2726         [UNIT_CONFLICTED_BY] = "ConflictedBy",
2727         [UNIT_BEFORE] = "Before",
2728         [UNIT_AFTER] = "After",
2729         [UNIT_ON_FAILURE] = "OnFailure",
2730         [UNIT_TRIGGERS] = "Triggers",
2731         [UNIT_TRIGGERED_BY] = "TriggeredBy",
2732         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2733         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2734         [UNIT_REFERENCES] = "References",
2735         [UNIT_REFERENCED_BY] = "ReferencedBy",
2736 };
2737
2738 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);