src/core/unit.c

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