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