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
2160         assert(u);
2161         assert(name);
2162         assert(value);
2163
2164         if (!controller) {
2165                 const char *dot;
2166
2167                 dot = strchr(name, '.');
2168                 if (!dot)
2169                         return -EINVAL;
2170
2171                 c = strndup(name, dot - name);
2172                 if (!c)
2173                         return -ENOMEM;
2174
2175                 controller = c;
2176         }
2177
2178         if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2179                 return -EINVAL;
2180
2181         a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2182         if (a) {
2183                 char *v;
2184
2185                 if (streq(value, a->value)) {
2186                         if (ret)
2187                                 *ret = a;
2188
2189                         return 0;
2190                 }
2191
2192                 v = strdup(value);
2193                 if (!v)
2194                         return -ENOMEM;
2195
2196                 free(a->value);
2197                 a->value = v;
2198
2199                 if (ret)
2200                         *ret = a;
2201
2202                 return 1;
2203         }
2204
2205         a = new0(CGroupAttribute, 1);
2206         if (!a)
2207                 return -ENOMEM;
2208
2209         if (c) {
2210                 a->controller = c;
2211                 c = NULL;
2212         } else
2213                 a->controller = strdup(controller);
2214
2215         a->name = strdup(name);
2216         a->value = strdup(value);
2217
2218         if (!a->controller || !a->name || !a->value) {
2219                 free(a->controller);
2220                 free(a->name);
2221                 free(a->value);
2222                 free(a);
2223
2224                 return -ENOMEM;
2225         }
2226
2227         a->map_callback = map_callback;
2228         a->unit = u;
2229
2230         LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2231
2232         if (ret)
2233                 *ret = a;
2234
2235         return 1;
2236 }
2237
2238 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2239         char *t;
2240         int r;
2241
2242         assert(u);
2243         assert(type);
2244         assert(_found);
2245
2246         if (!(t = unit_name_change_suffix(u->id, type)))
2247                 return -ENOMEM;
2248
2249         assert(!unit_has_name(u, t));
2250
2251         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2252         free(t);
2253
2254         assert(r < 0 || *_found != u);
2255
2256         return r;
2257 }
2258
2259 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2260         Unit *found;
2261         char *t;
2262
2263         assert(u);
2264         assert(type);
2265         assert(_found);
2266
2267         if (!(t = unit_name_change_suffix(u->id, type)))
2268                 return -ENOMEM;
2269
2270         assert(!unit_has_name(u, t));
2271
2272         found = manager_get_unit(u->manager, t);
2273         free(t);
2274
2275         if (!found)
2276                 return -ENOENT;
2277
2278         *_found = found;
2279         return 0;
2280 }
2281
2282 int unit_watch_bus_name(Unit *u, const char *name) {
2283         assert(u);
2284         assert(name);
2285
2286         /* Watch a specific name on the bus. We only support one unit
2287          * watching each name for now. */
2288
2289         return hashmap_put(u->manager->watch_bus, name, u);
2290 }
2291
2292 void unit_unwatch_bus_name(Unit *u, const char *name) {
2293         assert(u);
2294         assert(name);
2295
2296         hashmap_remove_value(u->manager->watch_bus, name, u);
2297 }
2298
2299 bool unit_can_serialize(Unit *u) {
2300         assert(u);
2301
2302         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2303 }
2304
2305 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2306         int r;
2307
2308         assert(u);
2309         assert(f);
2310         assert(fds);
2311
2312         if (!unit_can_serialize(u))
2313                 return 0;
2314
2315         if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2316                 return r;
2317
2318
2319         if (serialize_jobs) {
2320                 if (u->job) {
2321                         fprintf(f, "job\n");
2322                         job_serialize(u->job, f, fds);
2323                 }
2324
2325                 if (u->nop_job) {
2326                         fprintf(f, "job\n");
2327                         job_serialize(u->nop_job, f, fds);
2328                 }
2329         }
2330
2331         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2332         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2333         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2334         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2335         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2336
2337         if (dual_timestamp_is_set(&u->condition_timestamp))
2338                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2339
2340         /* End marker */
2341         fputc('\n', f);
2342         return 0;
2343 }
2344
2345 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2346         va_list ap;
2347
2348         assert(u);
2349         assert(f);
2350         assert(key);
2351         assert(format);
2352
2353         fputs(key, f);
2354         fputc('=', f);
2355
2356         va_start(ap, format);
2357         vfprintf(f, format, ap);
2358         va_end(ap);
2359
2360         fputc('\n', f);
2361 }
2362
2363 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2364         assert(u);
2365         assert(f);
2366         assert(key);
2367         assert(value);
2368
2369         fprintf(f, "%s=%s\n", key, value);
2370 }
2371
2372 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2373         int r;
2374
2375         assert(u);
2376         assert(f);
2377         assert(fds);
2378
2379         if (!unit_can_serialize(u))
2380                 return 0;
2381
2382         for (;;) {
2383                 char line[LINE_MAX], *l, *v;
2384                 size_t k;
2385
2386                 if (!fgets(line, sizeof(line), f)) {
2387                         if (feof(f))
2388                                 return 0;
2389                         return -errno;
2390                 }
2391
2392                 char_array_0(line);
2393                 l = strstrip(line);
2394
2395                 /* End marker */
2396                 if (l[0] == 0)
2397                         return 0;
2398
2399                 k = strcspn(l, "=");
2400
2401                 if (l[k] == '=') {
2402                         l[k] = 0;
2403                         v = l+k+1;
2404                 } else
2405                         v = l+k;
2406
2407                 if (streq(l, "job")) {
2408                         if (v[0] == '\0') {
2409                                 /* new-style serialized job */
2410                                 Job *j = job_new_raw(u);
2411                                 if (!j)
2412                                         return -ENOMEM;
2413
2414                                 r = job_deserialize(j, f, fds);
2415                                 if (r < 0) {
2416                                         job_free(j);
2417                                         return r;
2418                                 }
2419
2420                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2421                                 if (r < 0) {
2422                                         job_free(j);
2423                                         return r;
2424                                 }
2425
2426                                 r = job_install_deserialized(j);
2427                                 if (r < 0) {
2428                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2429                                         job_free(j);
2430                                         return r;
2431                                 }
2432                         } else {
2433                                 /* legacy */
2434                                 JobType type = job_type_from_string(v);
2435                                 if (type < 0)
2436                                         log_debug("Failed to parse job type value %s", v);
2437                                 else
2438                                         u->deserialized_job = type;
2439                         }
2440                         continue;
2441                 } else if (streq(l, "inactive-exit-timestamp")) {
2442                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2443                         continue;
2444                 } else if (streq(l, "active-enter-timestamp")) {
2445                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2446                         continue;
2447                 } else if (streq(l, "active-exit-timestamp")) {
2448                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2449                         continue;
2450                 } else if (streq(l, "inactive-enter-timestamp")) {
2451                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2452                         continue;
2453                 } else if (streq(l, "condition-timestamp")) {
2454                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2455                         continue;
2456                 } else if (streq(l, "condition-result")) {
2457                         int b;
2458
2459                         if ((b = parse_boolean(v)) < 0)
2460                                 log_debug("Failed to parse condition result value %s", v);
2461                         else
2462                                 u->condition_result = b;
2463
2464                         continue;
2465                 }
2466
2467                 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2468                         return r;
2469         }
2470 }
2471
2472 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2473         Unit *device;
2474         char *e;
2475         int r;
2476
2477         assert(u);
2478
2479         if (!what)
2480                 return 0;
2481
2482         /* Adds in links to the device node that this unit is based on */
2483
2484         if (!is_device_path(what))
2485                 return 0;
2486
2487         e = unit_name_from_path(what, ".device");
2488         if (!e)
2489                 return -ENOMEM;
2490
2491         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2492         free(e);
2493         if (r < 0)
2494                 return r;
2495
2496         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2497         if (r < 0)
2498                 return r;
2499
2500         if (wants) {
2501                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2502                 if (r < 0)
2503                         return r;
2504         }
2505
2506         return 0;
2507 }
2508
2509 int unit_coldplug(Unit *u) {
2510         int r;
2511
2512         assert(u);
2513
2514         if (UNIT_VTABLE(u)->coldplug)
2515                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2516                         return r;
2517
2518         if (u->job) {
2519                 r = job_coldplug(u->job);
2520                 if (r < 0)
2521                         return r;
2522         } else if (u->deserialized_job >= 0) {
2523                 /* legacy */
2524                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2525                 if (r < 0)
2526                         return r;
2527
2528                 u->deserialized_job = _JOB_TYPE_INVALID;
2529         }
2530
2531         return 0;
2532 }
2533
2534 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2535         va_list ap;
2536
2537         assert(u);
2538         assert(format);
2539
2540         if (!manager_get_show_status(u->manager))
2541                 return;
2542
2543         if (!manager_is_booting_or_shutting_down(u->manager))
2544                 return;
2545
2546         va_start(ap, format);
2547         status_vprintf(status, true, format, ap);
2548         va_end(ap);
2549 }
2550
2551 bool unit_need_daemon_reload(Unit *u) {
2552         struct stat st;
2553
2554         assert(u);
2555
2556         if (u->fragment_path) {
2557                 zero(st);
2558                 if (stat(u->fragment_path, &st) < 0)
2559                         /* What, cannot access this anymore? */
2560                         return true;
2561
2562                 if (u->fragment_mtime > 0 &&
2563                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2564                         return true;
2565         }
2566
2567         if (u->source_path) {
2568                 zero(st);
2569                 if (stat(u->source_path, &st) < 0)
2570                         return true;
2571
2572                 if (u->source_mtime > 0 &&
2573                     timespec_load(&st.st_mtim) != u->source_mtime)
2574                         return true;
2575         }
2576
2577         return false;
2578 }
2579
2580 void unit_reset_failed(Unit *u) {
2581         assert(u);
2582
2583         if (UNIT_VTABLE(u)->reset_failed)
2584                 UNIT_VTABLE(u)->reset_failed(u);
2585 }
2586
2587 Unit *unit_following(Unit *u) {
2588         assert(u);
2589
2590         if (UNIT_VTABLE(u)->following)
2591                 return UNIT_VTABLE(u)->following(u);
2592
2593         return NULL;
2594 }
2595
2596 bool unit_pending_inactive(Unit *u) {
2597         assert(u);
2598
2599         /* Returns true if the unit is inactive or going down */
2600
2601         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2602                 return true;
2603
2604         if (u->job && u->job->type == JOB_STOP)
2605                 return true;
2606
2607         return false;
2608 }
2609
2610 bool unit_pending_active(Unit *u) {
2611         assert(u);
2612
2613         /* Returns true if the unit is active or going up */
2614
2615         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2616                 return true;
2617
2618         if (u->job &&
2619             (u->job->type == JOB_START ||
2620              u->job->type == JOB_RELOAD_OR_START ||
2621              u->job->type == JOB_RESTART))
2622                 return true;
2623
2624         return false;
2625 }
2626
2627 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2628         assert(u);
2629         assert(w >= 0 && w < _KILL_WHO_MAX);
2630         assert(signo > 0);
2631         assert(signo < _NSIG);
2632
2633         if (!UNIT_VTABLE(u)->kill)
2634                 return -ENOTSUP;
2635
2636         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2637 }
2638
2639 int unit_following_set(Unit *u, Set **s) {
2640         assert(u);
2641         assert(s);
2642
2643         if (UNIT_VTABLE(u)->following_set)
2644                 return UNIT_VTABLE(u)->following_set(u, s);
2645
2646         *s = NULL;
2647         return 0;
2648 }
2649
2650 UnitFileState unit_get_unit_file_state(Unit *u) {
2651         assert(u);
2652
2653         if (u->unit_file_state < 0 && u->fragment_path)
2654                 u->unit_file_state = unit_file_get_state(
2655                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2656                                 NULL, path_get_file_name(u->fragment_path));
2657
2658         return u->unit_file_state;
2659 }
2660
2661 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2662         assert(ref);
2663         assert(u);
2664
2665         if (ref->unit)
2666                 unit_ref_unset(ref);
2667
2668         ref->unit = u;
2669         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2670         return u;
2671 }
2672
2673 void unit_ref_unset(UnitRef *ref) {
2674         assert(ref);
2675
2676         if (!ref->unit)
2677                 return;
2678
2679         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2680         ref->unit = NULL;
2681 }
2682
2683 int unit_add_one_mount_link(Unit *u, Mount *m) {
2684         char **i;
2685
2686         assert(u);
2687         assert(m);
2688
2689         if (u->load_state != UNIT_LOADED ||
2690             UNIT(m)->load_state != UNIT_LOADED)
2691                 return 0;
2692
2693         STRV_FOREACH(i, u->requires_mounts_for) {
2694
2695                 if (UNIT(m) == u)
2696                         continue;
2697
2698                 if (!path_startswith(*i, m->where))
2699                         continue;
2700
2701                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2702         }
2703
2704         return 0;
2705 }
2706
2707 int unit_add_mount_links(Unit *u) {
2708         Unit *other;
2709         int r;
2710
2711         assert(u);
2712
2713         LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2714                 r = unit_add_one_mount_link(u, MOUNT(other));
2715                 if (r < 0)
2716                         return r;
2717         }
2718
2719         return 0;
2720 }
2721
2722 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2723         unsigned i;
2724         int r;
2725
2726         assert(u);
2727         assert(c);
2728
2729         /* This only copies in the ones that need memory */
2730
2731         for (i = 0; i < RLIMIT_NLIMITS; i++)
2732                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2733                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2734                         if (!c->rlimit[i])
2735                                 return -ENOMEM;
2736                 }
2737
2738         if (u->manager->running_as == SYSTEMD_USER &&
2739             !c->working_directory) {
2740
2741                 r = get_home_dir(&c->working_directory);
2742                 if (r < 0)
2743                         return r;
2744         }
2745
2746         return 0;
2747 }
2748
2749 ExecContext *unit_get_exec_context(Unit *u) {
2750         size_t offset;
2751         assert(u);
2752
2753         offset = UNIT_VTABLE(u)->exec_context_offset;
2754         if (offset <= 0)
2755                 return NULL;
2756
2757         return (ExecContext*) ((uint8_t*) u + offset);
2758 }
2759
2760 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2761         [UNIT_ACTIVE] = "active",
2762         [UNIT_RELOADING] = "reloading",
2763         [UNIT_INACTIVE] = "inactive",
2764         [UNIT_FAILED] = "failed",
2765         [UNIT_ACTIVATING] = "activating",
2766         [UNIT_DEACTIVATING] = "deactivating"
2767 };
2768
2769 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2770
2771 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2772         [UNIT_REQUIRES] = "Requires",
2773         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2774         [UNIT_REQUISITE] = "Requisite",
2775         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2776         [UNIT_WANTS] = "Wants",
2777         [UNIT_BINDS_TO] = "BindsTo",
2778         [UNIT_PART_OF] = "PartOf",
2779         [UNIT_REQUIRED_BY] = "RequiredBy",
2780         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2781         [UNIT_WANTED_BY] = "WantedBy",
2782         [UNIT_BOUND_BY] = "BoundBy",
2783         [UNIT_CONSISTS_OF] = "ConsistsOf",
2784         [UNIT_CONFLICTS] = "Conflicts",
2785         [UNIT_CONFLICTED_BY] = "ConflictedBy",
2786         [UNIT_BEFORE] = "Before",
2787         [UNIT_AFTER] = "After",
2788         [UNIT_ON_FAILURE] = "OnFailure",
2789         [UNIT_TRIGGERS] = "Triggers",
2790         [UNIT_TRIGGERED_BY] = "TriggeredBy",
2791         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2792         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2793         [UNIT_REFERENCES] = "References",
2794         [UNIT_REFERENCED_BY] = "ReferencedBy",
2795 };
2796
2797 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);