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_REQUISITE], 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_REPLACE, true, NULL, NULL);
1248
1249         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1250                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1251                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1252                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1253
1254         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1255                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1256                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1257
1258         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1259                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1260                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1261 }
1262
1263 static void retroactively_stop_dependencies(Unit *u) {
1264         Iterator i;
1265         Unit *other;
1266
1267         assert(u);
1268         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1269
1270         /* Pull down units which are bound to us recursively if enabled */
1271         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1272                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1273                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1274 }
1275
1276 static void check_unneeded_dependencies(Unit *u) {
1277         Iterator i;
1278         Unit *other;
1279
1280         assert(u);
1281         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1282
1283         /* Garbage collect services that might not be needed anymore, if enabled */
1284         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1285                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1286                         unit_check_unneeded(other);
1287         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1288                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1289                         unit_check_unneeded(other);
1290         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1291                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1292                         unit_check_unneeded(other);
1293         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1294                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1295                         unit_check_unneeded(other);
1296         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1297                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1298                         unit_check_unneeded(other);
1299         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1300                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1301                         unit_check_unneeded(other);
1302 }
1303
1304 void unit_trigger_on_failure(Unit *u) {
1305         Unit *other;
1306         Iterator i;
1307
1308         assert(u);
1309
1310         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1311                 return;
1312
1313         log_info("Triggering OnFailure= dependencies of %s.", u->id);
1314
1315         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1316                 int r;
1317
1318                 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1319                         log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1320         }
1321 }
1322
1323 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1324         Manager *m;
1325         bool unexpected;
1326
1327         assert(u);
1328         assert(os < _UNIT_ACTIVE_STATE_MAX);
1329         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1330
1331         /* Note that this is called for all low-level state changes,
1332          * even if they might map to the same high-level
1333          * UnitActiveState! That means that ns == os is OK an expected
1334          * behavior here. For example: if a mount point is remounted
1335          * this function will be called too! */
1336
1337         m = u->manager;
1338
1339         if (m->n_reloading <= 0) {
1340                 dual_timestamp ts;
1341
1342                 dual_timestamp_get(&ts);
1343
1344                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1345                         u->inactive_exit_timestamp = ts;
1346                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1347                         u->inactive_enter_timestamp = ts;
1348
1349                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1350                         u->active_enter_timestamp = ts;
1351                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1352                         u->active_exit_timestamp = ts;
1353
1354                 timer_unit_notify(u, ns);
1355                 path_unit_notify(u, ns);
1356         }
1357
1358         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1359                 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1360
1361         if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1362                 ExecContext *ec = unit_get_exec_context(u);
1363                 if (ec && exec_context_may_touch_console(ec)) {
1364                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1365                                 m->n_on_console--;
1366                         else
1367                                 m->n_on_console++;
1368                 }
1369         }
1370
1371         if (u->job) {
1372                 unexpected = false;
1373
1374                 if (u->job->state == JOB_WAITING)
1375
1376                         /* So we reached a different state for this
1377                          * job. Let's see if we can run it now if it
1378                          * failed previously due to EAGAIN. */
1379                         job_add_to_run_queue(u->job);
1380
1381                 /* Let's check whether this state change constitutes a
1382                  * finished job, or maybe contradicts a running job and
1383                  * hence needs to invalidate jobs. */
1384
1385                 switch (u->job->type) {
1386
1387                 case JOB_START:
1388                 case JOB_VERIFY_ACTIVE:
1389
1390                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1391                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1392                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1393                                 unexpected = true;
1394
1395                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1396                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1397                         }
1398
1399                         break;
1400
1401                 case JOB_RELOAD:
1402                 case JOB_RELOAD_OR_START:
1403
1404                         if (u->job->state == JOB_RUNNING) {
1405                                 if (ns == UNIT_ACTIVE)
1406                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1407                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1408                                         unexpected = true;
1409
1410                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1411                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1412                                 }
1413                         }
1414
1415                         break;
1416
1417                 case JOB_STOP:
1418                 case JOB_RESTART:
1419                 case JOB_TRY_RESTART:
1420
1421                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1422                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1423                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1424                                 unexpected = true;
1425                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1426                         }
1427
1428                         break;
1429
1430                 default:
1431                         assert_not_reached("Job type unknown");
1432                 }
1433
1434         } else
1435                 unexpected = true;
1436
1437         if (m->n_reloading <= 0) {
1438
1439                 /* If this state change happened without being
1440                  * requested by a job, then let's retroactively start
1441                  * or stop dependencies. We skip that step when
1442                  * deserializing, since we don't want to create any
1443                  * additional jobs just because something is already
1444                  * activated. */
1445
1446                 if (unexpected) {
1447                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1448                                 retroactively_start_dependencies(u);
1449                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1450                                 retroactively_stop_dependencies(u);
1451                 }
1452
1453                 /* stop unneeded units regardless if going down was expected or not */
1454                 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1455                         check_unneeded_dependencies(u);
1456
1457                 if (ns != os && ns == UNIT_FAILED) {
1458                         log_struct_unit(LOG_NOTICE,
1459                                    u->id,
1460                                    "MESSAGE=Unit %s entered failed state", u->id,
1461                                    NULL);
1462                         unit_trigger_on_failure(u);
1463                 }
1464         }
1465
1466         /* Some names are special */
1467         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1468
1469                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1470                         /* The bus just might have become available,
1471                          * hence try to connect to it, if we aren't
1472                          * yet connected. */
1473                         bus_init(m, true);
1474
1475                 if (u->type == UNIT_SERVICE &&
1476                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1477                     m->n_reloading <= 0) {
1478                         /* Write audit record if we have just finished starting up */
1479                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1480                         u->in_audit = true;
1481                 }
1482
1483                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1484                         manager_send_unit_plymouth(m, u);
1485
1486         } else {
1487
1488                 /* We don't care about D-Bus here, since we'll get an
1489                  * asynchronous notification for it anyway. */
1490
1491                 if (u->type == UNIT_SERVICE &&
1492                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1493                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1494                     m->n_reloading <= 0) {
1495
1496                         /* Hmm, if there was no start record written
1497                          * write it now, so that we always have a nice
1498                          * pair */
1499                         if (!u->in_audit) {
1500                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1501
1502                                 if (ns == UNIT_INACTIVE)
1503                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1504                         } else
1505                                 /* Write audit record if we have just finished shutting down */
1506                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1507
1508                         u->in_audit = false;
1509                 }
1510         }
1511
1512         manager_recheck_journal(m);
1513
1514         /* Maybe we finished startup and are now ready for being
1515          * stopped because unneeded? */
1516         if (u->manager->n_reloading <= 0)
1517                 unit_check_unneeded(u);
1518
1519         unit_add_to_dbus_queue(u);
1520         unit_add_to_gc_queue(u);
1521 }
1522
1523 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1524         struct epoll_event ev;
1525
1526         assert(u);
1527         assert(fd >= 0);
1528         assert(w);
1529         assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1530
1531         zero(ev);
1532         ev.data.ptr = w;
1533         ev.events = events;
1534
1535         if (epoll_ctl(u->manager->epoll_fd,
1536                       w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1537                       fd,
1538                       &ev) < 0)
1539                 return -errno;
1540
1541         w->fd = fd;
1542         w->type = WATCH_FD;
1543         w->data.unit = u;
1544
1545         return 0;
1546 }
1547
1548 void unit_unwatch_fd(Unit *u, Watch *w) {
1549         assert(u);
1550         assert(w);
1551
1552         if (w->type == WATCH_INVALID)
1553                 return;
1554
1555         assert(w->type == WATCH_FD);
1556         assert(w->data.unit == u);
1557         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1558
1559         w->fd = -1;
1560         w->type = WATCH_INVALID;
1561         w->data.unit = NULL;
1562 }
1563
1564 int unit_watch_pid(Unit *u, pid_t pid) {
1565         assert(u);
1566         assert(pid >= 1);
1567
1568         /* Watch a specific PID. We only support one unit watching
1569          * each PID for now. */
1570
1571         return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1572 }
1573
1574 void unit_unwatch_pid(Unit *u, pid_t pid) {
1575         assert(u);
1576         assert(pid >= 1);
1577
1578         hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1579 }
1580
1581 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1582         struct itimerspec its;
1583         int flags, fd;
1584         bool ours;
1585
1586         assert(u);
1587         assert(w);
1588         assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1589
1590         /* This will try to reuse the old timer if there is one */
1591
1592         if (w->type == WATCH_UNIT_TIMER) {
1593                 assert(w->data.unit == u);
1594                 assert(w->fd >= 0);
1595
1596                 ours = false;
1597                 fd = w->fd;
1598         } else if (w->type == WATCH_INVALID) {
1599
1600                 ours = true;
1601                 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1602                 if (fd < 0)
1603                         return -errno;
1604         } else
1605                 assert_not_reached("Invalid watch type");
1606
1607         zero(its);
1608
1609         if (usec <= 0) {
1610                 /* Set absolute time in the past, but not 0, since we
1611                  * don't want to disarm the timer */
1612                 its.it_value.tv_sec = 0;
1613                 its.it_value.tv_nsec = 1;
1614
1615                 flags = TFD_TIMER_ABSTIME;
1616         } else {
1617                 timespec_store(&its.it_value, usec);
1618                 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1619         }
1620
1621         /* This will also flush the elapse counter */
1622         if (timerfd_settime(fd, flags, &its, NULL) < 0)
1623                 goto fail;
1624
1625         if (w->type == WATCH_INVALID) {
1626                 struct epoll_event ev;
1627
1628                 zero(ev);
1629                 ev.data.ptr = w;
1630                 ev.events = EPOLLIN;
1631
1632                 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1633                         goto fail;
1634         }
1635
1636         w->type = WATCH_UNIT_TIMER;
1637         w->fd = fd;
1638         w->data.unit = u;
1639
1640         return 0;
1641
1642 fail:
1643         if (ours)
1644                 close_nointr_nofail(fd);
1645
1646         return -errno;
1647 }
1648
1649 void unit_unwatch_timer(Unit *u, Watch *w) {
1650         assert(u);
1651         assert(w);
1652
1653         if (w->type == WATCH_INVALID)
1654                 return;
1655
1656         assert(w->type == WATCH_UNIT_TIMER);
1657         assert(w->data.unit == u);
1658         assert(w->fd >= 0);
1659
1660         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1661         close_nointr_nofail(w->fd);
1662
1663         w->fd = -1;
1664         w->type = WATCH_INVALID;
1665         w->data.unit = NULL;
1666 }
1667
1668 bool unit_job_is_applicable(Unit *u, JobType j) {
1669         assert(u);
1670         assert(j >= 0 && j < _JOB_TYPE_MAX);
1671
1672         switch (j) {
1673
1674         case JOB_VERIFY_ACTIVE:
1675         case JOB_START:
1676         case JOB_STOP:
1677         case JOB_NOP:
1678                 return true;
1679
1680         case JOB_RESTART:
1681         case JOB_TRY_RESTART:
1682                 return unit_can_start(u);
1683
1684         case JOB_RELOAD:
1685                 return unit_can_reload(u);
1686
1687         case JOB_RELOAD_OR_START:
1688                 return unit_can_reload(u) && unit_can_start(u);
1689
1690         default:
1691                 assert_not_reached("Invalid job type");
1692         }
1693 }
1694
1695 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1696
1697         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1698                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1699                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1700                 [UNIT_WANTS] = UNIT_WANTED_BY,
1701                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1702                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1703                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1704                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1705                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1706                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1707                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1708                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1709                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1710                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1711                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1712                 [UNIT_BEFORE] = UNIT_AFTER,
1713                 [UNIT_AFTER] = UNIT_BEFORE,
1714                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1715                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1716                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1717                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1718                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1719                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1720                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1721         };
1722         int r, q = 0, v = 0, w = 0;
1723
1724         assert(u);
1725         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1726         assert(other);
1727
1728         u = unit_follow_merge(u);
1729         other = unit_follow_merge(other);
1730
1731         /* We won't allow dependencies on ourselves. We will not
1732          * consider them an error however. */
1733         if (u == other)
1734                 return 0;
1735
1736         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1737                 return r;
1738
1739         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1740                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1741                         return r;
1742
1743         if (add_reference)
1744                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1745                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1746                         return r;
1747
1748         if ((q = set_put(u->dependencies[d], other)) < 0)
1749                 return q;
1750
1751         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1752                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1753                         r = v;
1754                         goto fail;
1755                 }
1756
1757         if (add_reference) {
1758                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1759                         r = w;
1760                         goto fail;
1761                 }
1762
1763                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1764                         goto fail;
1765         }
1766
1767         unit_add_to_dbus_queue(u);
1768         return 0;
1769
1770 fail:
1771         if (q > 0)
1772                 set_remove(u->dependencies[d], other);
1773
1774         if (v > 0)
1775                 set_remove(other->dependencies[inverse_table[d]], u);
1776
1777         if (w > 0)
1778                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1779
1780         return r;
1781 }
1782
1783 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1784         int r;
1785
1786         assert(u);
1787
1788         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1789                 return r;
1790
1791         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1792                 return r;
1793
1794         return 0;
1795 }
1796
1797 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1798         char *s;
1799
1800         assert(u);
1801         assert(name || path);
1802         assert(p);
1803
1804         if (!name)
1805                 name = path_get_file_name(path);
1806
1807         if (!unit_name_is_template(name)) {
1808                 *p = NULL;
1809                 return name;
1810         }
1811
1812         if (u->instance)
1813                 s = unit_name_replace_instance(name, u->instance);
1814         else {
1815                 char *i;
1816
1817                 i = unit_name_to_prefix(u->id);
1818                 if (!i)
1819                         return NULL;
1820
1821                 s = unit_name_replace_instance(name, i);
1822                 free(i);
1823         }
1824
1825         if (!s)
1826                 return NULL;
1827
1828         *p = s;
1829         return s;
1830 }
1831
1832 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1833         Unit *other;
1834         int r;
1835         _cleanup_free_ char *s = NULL;
1836
1837         assert(u);
1838         assert(name || path);
1839
1840         name = resolve_template(u, name, path, &s);
1841         if (!name)
1842                 return -ENOMEM;
1843
1844         r = manager_load_unit(u->manager, name, path, NULL, &other);
1845         if (r < 0)
1846                 return r;
1847
1848         return unit_add_dependency(u, d, other, add_reference);
1849 }
1850
1851 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1852         Unit *other;
1853         int r;
1854         char *s;
1855
1856         assert(u);
1857         assert(name || path);
1858
1859         if (!(name = resolve_template(u, name, path, &s)))
1860                 return -ENOMEM;
1861
1862         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1863                 goto finish;
1864
1865         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1866
1867 finish:
1868         free(s);
1869         return r;
1870 }
1871
1872 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1873         Unit *other;
1874         int r;
1875         char *s;
1876
1877         assert(u);
1878         assert(name || path);
1879
1880         if (!(name = resolve_template(u, name, path, &s)))
1881                 return -ENOMEM;
1882
1883         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1884                 goto finish;
1885
1886         r = unit_add_dependency(other, d, u, add_reference);
1887
1888 finish:
1889         free(s);
1890         return r;
1891 }
1892
1893 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1894         Unit *other;
1895         int r;
1896         char *s;
1897
1898         assert(u);
1899         assert(name || path);
1900
1901         if (!(name = resolve_template(u, name, path, &s)))
1902                 return -ENOMEM;
1903
1904         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1905                 goto finish;
1906
1907         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1908                 goto finish;
1909
1910 finish:
1911         free(s);
1912         return r;
1913 }
1914
1915 int set_unit_path(const char *p) {
1916         _cleanup_free_ char *c = NULL;
1917
1918         /* This is mostly for debug purposes */
1919         c = path_make_absolute_cwd(p);
1920         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1921                 return -errno;
1922
1923         return 0;
1924 }
1925
1926 char *unit_dbus_path(Unit *u) {
1927         assert(u);
1928
1929         if (!u->id)
1930                 return NULL;
1931
1932         return unit_dbus_path_from_name(u->id);
1933 }
1934
1935 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1936         int r;
1937
1938         assert(u);
1939         assert(b);
1940
1941         assert(b->path);
1942
1943         if (!b->controller) {
1944                 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1945                 if (!b->controller)
1946                         return log_oom();
1947
1948                 b->ours = true;
1949         }
1950
1951         /* Ensure this hasn't been added yet */
1952         assert(!b->unit);
1953
1954         if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1955                 CGroupBonding *l;
1956
1957                 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1958                 LIST_PREPEND(CGroupBonding, by_path, l, b);
1959
1960                 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1961                 if (r < 0) {
1962                         LIST_REMOVE(CGroupBonding, by_path, l, b);
1963                         return r;
1964                 }
1965         }
1966
1967         LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1968         b->unit = u;
1969
1970         return 0;
1971 }
1972
1973 char *unit_default_cgroup_path(Unit *u) {
1974         assert(u);
1975
1976         if (u->instance) {
1977                 _cleanup_free_ char *t = NULL;
1978
1979                 t = unit_name_template(u->id);
1980                 if (!t)
1981                         return NULL;
1982
1983                 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1984         } else
1985                 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1986 }
1987
1988 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1989         char *controller = NULL, *path = NULL;
1990         CGroupBonding *b = NULL;
1991         bool ours = false;
1992         int r;
1993
1994         assert(u);
1995         assert(name);
1996
1997         r = cg_split_spec(name, &controller, &path);
1998         if (r < 0)
1999                 return r;
2000
2001         if (!path) {
2002                 path = unit_default_cgroup_path(u);
2003                 ours = true;
2004         }
2005
2006         if (!controller) {
2007                 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2008                 ours = true;
2009         }
2010
2011         if (!path || !controller) {
2012                 free(path);
2013                 free(controller);
2014                 return log_oom();
2015         }
2016
2017         b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2018         if (b) {
2019                 if (streq(path, b->path)) {
2020                         free(path);
2021                         free(controller);
2022
2023                         if (ret)
2024                                 *ret = b;
2025                         return 0;
2026                 }
2027
2028                 if (overwrite && !b->essential) {
2029                         free(controller);
2030
2031                         free(b->path);
2032                         b->path = path;
2033
2034                         b->ours = ours;
2035                         b->realized = false;
2036
2037                         if (ret)
2038                                 *ret = b;
2039
2040                         return 1;
2041                 }
2042
2043                 r = -EEXIST;
2044                 b = NULL;
2045                 goto fail;
2046         }
2047
2048         b = new0(CGroupBonding, 1);
2049         if (!b) {
2050                 r = -ENOMEM;
2051                 goto fail;
2052         }
2053
2054         b->controller = controller;
2055         b->path = path;
2056         b->ours = ours;
2057         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2058
2059         r = unit_add_cgroup(u, b);
2060         if (r < 0)
2061                 goto fail;
2062
2063         if (ret)
2064                 *ret = b;
2065
2066         return 1;
2067
2068 fail:
2069         free(path);
2070         free(controller);
2071         free(b);
2072
2073         return r;
2074 }
2075
2076 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2077         CGroupBonding *b = NULL;
2078         int r = -ENOMEM;
2079
2080         assert(u);
2081
2082         if (!controller)
2083                 controller = SYSTEMD_CGROUP_CONTROLLER;
2084
2085         if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2086                 return 0;
2087
2088         b = new0(CGroupBonding, 1);
2089         if (!b)
2090                 return -ENOMEM;
2091
2092         b->controller = strdup(controller);
2093         if (!b->controller)
2094                 goto fail;
2095
2096         b->path = unit_default_cgroup_path(u);
2097         if (!b->path)
2098                 goto fail;
2099
2100         b->ours = true;
2101         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2102
2103         r = unit_add_cgroup(u, b);
2104         if (r < 0)
2105                 goto fail;
2106
2107         return 1;
2108
2109 fail:
2110         free(b->path);
2111         free(b->controller);
2112         free(b);
2113
2114         return r;
2115 }
2116
2117 int unit_add_default_cgroups(Unit *u) {
2118         CGroupAttribute *a;
2119         char **c;
2120         int r;
2121
2122         assert(u);
2123
2124         /* Adds in the default cgroups, if they weren't specified
2125          * otherwise. */
2126
2127         if (!u->manager->cgroup_hierarchy)
2128                 return 0;
2129
2130         r = unit_add_one_default_cgroup(u, NULL);
2131         if (r < 0)
2132                 return r;
2133
2134         STRV_FOREACH(c, u->manager->default_controllers)
2135                 unit_add_one_default_cgroup(u, *c);
2136
2137         LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2138                 unit_add_one_default_cgroup(u, a->controller);
2139
2140         return 0;
2141 }
2142
2143 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2144         assert(u);
2145
2146         return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2147 }
2148
2149 int unit_add_cgroup_attribute(
2150                 Unit *u,
2151                 const CGroupSemantics *semantics,
2152                 const char *controller,
2153                 const char *name,
2154                 const char *value,
2155                 CGroupAttribute **ret) {
2156
2157         _cleanup_free_ char *c = NULL;
2158         CGroupAttribute *a;
2159         int r;
2160
2161         assert(u);
2162         assert(value);
2163
2164         if (semantics) {
2165                 /* Semantics always take precedence */
2166                 if (semantics->name)
2167                         name = semantics->name;
2168
2169                 if (semantics->controller)
2170                         controller = semantics->controller;
2171         }
2172
2173         if (!name)
2174                 return -EINVAL;
2175
2176         if (!controller) {
2177                 r = cg_controller_from_attr(name, &c);
2178                 if (r < 0)
2179                         return -EINVAL;
2180
2181                 controller = c;
2182         }
2183
2184         if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2185                 return -EINVAL;
2186
2187         if (!filename_is_safe(name))
2188                 return -EINVAL;
2189
2190         if (!filename_is_safe(controller))
2191                 return -EINVAL;
2192
2193         /* Check if this attribute already exists. Note that we will
2194          * explicitly check for the value here too, as there are
2195          * attributes which accept multiple values. */
2196         a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2197         if (a) {
2198                 if (streq(value, a->value)) {
2199                         /* Exactly the same value is always OK, let's ignore this */
2200                         if (ret)
2201                                 *ret = a;
2202
2203                         return 0;
2204                 }
2205
2206                 if (semantics && !semantics->multiple) {
2207                         char *v;
2208
2209                         /* If this is a single-item entry, we can
2210                          * simply patch the existing attribute */
2211
2212                         v = strdup(value);
2213                         if (!v)
2214                                 return -ENOMEM;
2215
2216                         free(a->value);
2217                         a->value = v;
2218
2219                         if (ret)
2220                                 *ret = a;
2221                         return 1;
2222                 }
2223         }
2224
2225         a = new0(CGroupAttribute, 1);
2226         if (!a)
2227                 return -ENOMEM;
2228
2229         if (c) {
2230                 a->controller = c;
2231                 c = NULL;
2232         } else
2233                 a->controller = strdup(controller);
2234
2235         a->name = strdup(name);
2236         a->value = strdup(value);
2237
2238         if (!a->controller || !a->name || !a->value) {
2239                 free(a->controller);
2240                 free(a->name);
2241                 free(a->value);
2242                 free(a);
2243                 return -ENOMEM;
2244         }
2245
2246         a->semantics = semantics;
2247         a->unit = u;
2248
2249         LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2250
2251         if (ret)
2252                 *ret = a;
2253
2254         return 1;
2255 }
2256
2257 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2258         char *t;
2259         int r;
2260
2261         assert(u);
2262         assert(type);
2263         assert(_found);
2264
2265         if (!(t = unit_name_change_suffix(u->id, type)))
2266                 return -ENOMEM;
2267
2268         assert(!unit_has_name(u, t));
2269
2270         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2271         free(t);
2272
2273         assert(r < 0 || *_found != u);
2274
2275         return r;
2276 }
2277
2278 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2279         Unit *found;
2280         char *t;
2281
2282         assert(u);
2283         assert(type);
2284         assert(_found);
2285
2286         if (!(t = unit_name_change_suffix(u->id, type)))
2287                 return -ENOMEM;
2288
2289         assert(!unit_has_name(u, t));
2290
2291         found = manager_get_unit(u->manager, t);
2292         free(t);
2293
2294         if (!found)
2295                 return -ENOENT;
2296
2297         *_found = found;
2298         return 0;
2299 }
2300
2301 int unit_watch_bus_name(Unit *u, const char *name) {
2302         assert(u);
2303         assert(name);
2304
2305         /* Watch a specific name on the bus. We only support one unit
2306          * watching each name for now. */
2307
2308         return hashmap_put(u->manager->watch_bus, name, u);
2309 }
2310
2311 void unit_unwatch_bus_name(Unit *u, const char *name) {
2312         assert(u);
2313         assert(name);
2314
2315         hashmap_remove_value(u->manager->watch_bus, name, u);
2316 }
2317
2318 bool unit_can_serialize(Unit *u) {
2319         assert(u);
2320
2321         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2322 }
2323
2324 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2325         int r;
2326
2327         assert(u);
2328         assert(f);
2329         assert(fds);
2330
2331         if (!unit_can_serialize(u))
2332                 return 0;
2333
2334         if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2335                 return r;
2336
2337
2338         if (serialize_jobs) {
2339                 if (u->job) {
2340                         fprintf(f, "job\n");
2341                         job_serialize(u->job, f, fds);
2342                 }
2343
2344                 if (u->nop_job) {
2345                         fprintf(f, "job\n");
2346                         job_serialize(u->nop_job, f, fds);
2347                 }
2348         }
2349
2350         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2351         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2352         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2353         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2354         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2355
2356         if (dual_timestamp_is_set(&u->condition_timestamp))
2357                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2358
2359         /* End marker */
2360         fputc('\n', f);
2361         return 0;
2362 }
2363
2364 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2365         va_list ap;
2366
2367         assert(u);
2368         assert(f);
2369         assert(key);
2370         assert(format);
2371
2372         fputs(key, f);
2373         fputc('=', f);
2374
2375         va_start(ap, format);
2376         vfprintf(f, format, ap);
2377         va_end(ap);
2378
2379         fputc('\n', f);
2380 }
2381
2382 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2383         assert(u);
2384         assert(f);
2385         assert(key);
2386         assert(value);
2387
2388         fprintf(f, "%s=%s\n", key, value);
2389 }
2390
2391 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2392         int r;
2393
2394         assert(u);
2395         assert(f);
2396         assert(fds);
2397
2398         if (!unit_can_serialize(u))
2399                 return 0;
2400
2401         for (;;) {
2402                 char line[LINE_MAX], *l, *v;
2403                 size_t k;
2404
2405                 if (!fgets(line, sizeof(line), f)) {
2406                         if (feof(f))
2407                                 return 0;
2408                         return -errno;
2409                 }
2410
2411                 char_array_0(line);
2412                 l = strstrip(line);
2413
2414                 /* End marker */
2415                 if (l[0] == 0)
2416                         return 0;
2417
2418                 k = strcspn(l, "=");
2419
2420                 if (l[k] == '=') {
2421                         l[k] = 0;
2422                         v = l+k+1;
2423                 } else
2424                         v = l+k;
2425
2426                 if (streq(l, "job")) {
2427                         if (v[0] == '\0') {
2428                                 /* new-style serialized job */
2429                                 Job *j = job_new_raw(u);
2430                                 if (!j)
2431                                         return -ENOMEM;
2432
2433                                 r = job_deserialize(j, f, fds);
2434                                 if (r < 0) {
2435                                         job_free(j);
2436                                         return r;
2437                                 }
2438
2439                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2440                                 if (r < 0) {
2441                                         job_free(j);
2442                                         return r;
2443                                 }
2444
2445                                 r = job_install_deserialized(j);
2446                                 if (r < 0) {
2447                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2448                                         job_free(j);
2449                                         return r;
2450                                 }
2451
2452                                 if (j->state == JOB_RUNNING)
2453                                         u->manager->n_running_jobs++;
2454                         } else {
2455                                 /* legacy */
2456                                 JobType type = job_type_from_string(v);
2457                                 if (type < 0)
2458                                         log_debug("Failed to parse job type value %s", v);
2459                                 else
2460                                         u->deserialized_job = type;
2461                         }
2462                         continue;
2463                 } else if (streq(l, "inactive-exit-timestamp")) {
2464                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2465                         continue;
2466                 } else if (streq(l, "active-enter-timestamp")) {
2467                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2468                         continue;
2469                 } else if (streq(l, "active-exit-timestamp")) {
2470                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2471                         continue;
2472                 } else if (streq(l, "inactive-enter-timestamp")) {
2473                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2474                         continue;
2475                 } else if (streq(l, "condition-timestamp")) {
2476                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2477                         continue;
2478                 } else if (streq(l, "condition-result")) {
2479                         int b;
2480
2481                         if ((b = parse_boolean(v)) < 0)
2482                                 log_debug("Failed to parse condition result value %s", v);
2483                         else
2484                                 u->condition_result = b;
2485
2486                         continue;
2487                 }
2488
2489                 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2490                         return r;
2491         }
2492 }
2493
2494 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2495         Unit *device;
2496         char *e;
2497         int r;
2498
2499         assert(u);
2500
2501         if (!what)
2502                 return 0;
2503
2504         /* Adds in links to the device node that this unit is based on */
2505
2506         if (!is_device_path(what))
2507                 return 0;
2508
2509         e = unit_name_from_path(what, ".device");
2510         if (!e)
2511                 return -ENOMEM;
2512
2513         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2514         free(e);
2515         if (r < 0)
2516                 return r;
2517
2518         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2519         if (r < 0)
2520                 return r;
2521
2522         if (wants) {
2523                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2524                 if (r < 0)
2525                         return r;
2526         }
2527
2528         return 0;
2529 }
2530
2531 int unit_coldplug(Unit *u) {
2532         int r;
2533
2534         assert(u);
2535
2536         if (UNIT_VTABLE(u)->coldplug)
2537                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2538                         return r;
2539
2540         if (u->job) {
2541                 r = job_coldplug(u->job);
2542                 if (r < 0)
2543                         return r;
2544         } else if (u->deserialized_job >= 0) {
2545                 /* legacy */
2546                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2547                 if (r < 0)
2548                         return r;
2549
2550                 u->deserialized_job = _JOB_TYPE_INVALID;
2551         }
2552
2553         return 0;
2554 }
2555
2556 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2557         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2558 }
2559
2560 bool unit_need_daemon_reload(Unit *u) {
2561         struct stat st;
2562
2563         assert(u);
2564
2565         if (u->fragment_path) {
2566                 zero(st);
2567                 if (stat(u->fragment_path, &st) < 0)
2568                         /* What, cannot access this anymore? */
2569                         return true;
2570
2571                 if (u->fragment_mtime > 0 &&
2572                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2573                         return true;
2574         }
2575
2576         if (u->source_path) {
2577                 zero(st);
2578                 if (stat(u->source_path, &st) < 0)
2579                         return true;
2580
2581                 if (u->source_mtime > 0 &&
2582                     timespec_load(&st.st_mtim) != u->source_mtime)
2583                         return true;
2584         }
2585
2586         return false;
2587 }
2588
2589 void unit_reset_failed(Unit *u) {
2590         assert(u);
2591
2592         if (UNIT_VTABLE(u)->reset_failed)
2593                 UNIT_VTABLE(u)->reset_failed(u);
2594 }
2595
2596 Unit *unit_following(Unit *u) {
2597         assert(u);
2598
2599         if (UNIT_VTABLE(u)->following)
2600                 return UNIT_VTABLE(u)->following(u);
2601
2602         return NULL;
2603 }
2604
2605 bool unit_pending_inactive(Unit *u) {
2606         assert(u);
2607
2608         /* Returns true if the unit is inactive or going down */
2609
2610         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2611                 return true;
2612
2613         if (u->job && u->job->type == JOB_STOP)
2614                 return true;
2615
2616         return false;
2617 }
2618
2619 bool unit_pending_active(Unit *u) {
2620         assert(u);
2621
2622         /* Returns true if the unit is active or going up */
2623
2624         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2625                 return true;
2626
2627         if (u->job &&
2628             (u->job->type == JOB_START ||
2629              u->job->type == JOB_RELOAD_OR_START ||
2630              u->job->type == JOB_RESTART))
2631                 return true;
2632
2633         return false;
2634 }
2635
2636 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2637         assert(u);
2638         assert(w >= 0 && w < _KILL_WHO_MAX);
2639         assert(signo > 0);
2640         assert(signo < _NSIG);
2641
2642         if (!UNIT_VTABLE(u)->kill)
2643                 return -ENOTSUP;
2644
2645         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2646 }
2647
2648 int unit_kill_common(
2649                 Unit *u,
2650                 KillWho who,
2651                 int signo,
2652                 pid_t main_pid,
2653                 pid_t control_pid,
2654                 DBusError *error) {
2655
2656         int r = 0;
2657
2658         if (who == KILL_MAIN && main_pid <= 0) {
2659                 if (main_pid < 0)
2660                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2661                 else
2662                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2663                 return -ESRCH;
2664         }
2665
2666         if (who == KILL_CONTROL && control_pid <= 0) {
2667                 if (control_pid < 0)
2668                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2669                 else
2670                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2671                 return -ESRCH;
2672         }
2673
2674         if (who == KILL_CONTROL || who == KILL_ALL)
2675                 if (control_pid > 0)
2676                         if (kill(control_pid, signo) < 0)
2677                                 r = -errno;
2678
2679         if (who == KILL_MAIN || who == KILL_ALL)
2680                 if (main_pid > 0)
2681                         if (kill(main_pid, signo) < 0)
2682                                 r = -errno;
2683
2684         if (who == KILL_ALL) {
2685                 _cleanup_set_free_ Set *pid_set = NULL;
2686                 int q;
2687
2688                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2689                 if (!pid_set)
2690                         return -ENOMEM;
2691
2692                 /* Exclude the control/main pid from being killed via the cgroup */
2693                 if (control_pid > 0) {
2694                         q = set_put(pid_set, LONG_TO_PTR(control_pid));
2695                         if (q < 0)
2696                                 return q;
2697                 }
2698
2699                 if (main_pid > 0) {
2700                         q = set_put(pid_set, LONG_TO_PTR(main_pid));
2701                         if (q < 0)
2702                                 return q;
2703                 }
2704
2705                 q = cgroup_bonding_kill_list(u->cgroup_bondings, signo, false, false, pid_set, NULL);
2706                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2707                         r = q;
2708         }
2709
2710         return r;
2711 }
2712
2713 int unit_following_set(Unit *u, Set **s) {
2714         assert(u);
2715         assert(s);
2716
2717         if (UNIT_VTABLE(u)->following_set)
2718                 return UNIT_VTABLE(u)->following_set(u, s);
2719
2720         *s = NULL;
2721         return 0;
2722 }
2723
2724 UnitFileState unit_get_unit_file_state(Unit *u) {
2725         assert(u);
2726
2727         if (u->unit_file_state < 0 && u->fragment_path)
2728                 u->unit_file_state = unit_file_get_state(
2729                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2730                                 NULL, path_get_file_name(u->fragment_path));
2731
2732         return u->unit_file_state;
2733 }
2734
2735 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2736         assert(ref);
2737         assert(u);
2738
2739         if (ref->unit)
2740                 unit_ref_unset(ref);
2741
2742         ref->unit = u;
2743         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2744         return u;
2745 }
2746
2747 void unit_ref_unset(UnitRef *ref) {
2748         assert(ref);
2749
2750         if (!ref->unit)
2751                 return;
2752
2753         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2754         ref->unit = NULL;
2755 }
2756
2757 int unit_add_one_mount_link(Unit *u, Mount *m) {
2758         char **i;
2759
2760         assert(u);
2761         assert(m);
2762
2763         if (u->load_state != UNIT_LOADED ||
2764             UNIT(m)->load_state != UNIT_LOADED)
2765                 return 0;
2766
2767         STRV_FOREACH(i, u->requires_mounts_for) {
2768
2769                 if (UNIT(m) == u)
2770                         continue;
2771
2772                 if (!path_startswith(*i, m->where))
2773                         continue;
2774
2775                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2776         }
2777
2778         return 0;
2779 }
2780
2781 int unit_add_mount_links(Unit *u) {
2782         Unit *other;
2783         int r;
2784
2785         assert(u);
2786
2787         LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2788                 r = unit_add_one_mount_link(u, MOUNT(other));
2789                 if (r < 0)
2790                         return r;
2791         }
2792
2793         return 0;
2794 }
2795
2796 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2797         unsigned i;
2798         int r;
2799
2800         assert(u);
2801         assert(c);
2802
2803         /* This only copies in the ones that need memory */
2804
2805         for (i = 0; i < RLIMIT_NLIMITS; i++)
2806                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2807                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2808                         if (!c->rlimit[i])
2809                                 return -ENOMEM;
2810                 }
2811
2812         if (u->manager->running_as == SYSTEMD_USER &&
2813             !c->working_directory) {
2814
2815                 r = get_home_dir(&c->working_directory);
2816                 if (r < 0)
2817                         return r;
2818         }
2819
2820         return 0;
2821 }
2822
2823 ExecContext *unit_get_exec_context(Unit *u) {
2824         size_t offset;
2825         assert(u);
2826
2827         offset = UNIT_VTABLE(u)->exec_context_offset;
2828         if (offset <= 0)
2829                 return NULL;
2830
2831         return (ExecContext*) ((uint8_t*) u + offset);
2832 }
2833
2834 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2835         char *p, *q;
2836         int r;
2837
2838         assert(u);
2839         assert(name);
2840         assert(_p);
2841         assert(_q);
2842
2843         if (u->manager->running_as == SYSTEMD_USER && runtime)
2844                 return -ENOTSUP;
2845
2846         if (!filename_is_safe(name))
2847                 return -EINVAL;
2848
2849         if (u->manager->running_as == SYSTEMD_USER) {
2850                 _cleanup_free_ char *c = NULL;
2851
2852                 r = user_config_home(&c);
2853                 if (r < 0)
2854                         return r;
2855                 if (r == 0)
2856                         return -ENOENT;
2857
2858                 p = strjoin(c, "/", u->id, ".d", NULL);
2859         } else  if (runtime)
2860                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2861         else
2862                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2863         if (!p)
2864                 return -ENOMEM;
2865
2866         q = strjoin(p, "/50-", name, ".conf", NULL);
2867         if (!q) {
2868                 free(p);
2869                 return -ENOMEM;
2870         }
2871
2872         *_p = p;
2873         *_q = q;
2874         return 0;
2875 }
2876
2877 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2878         _cleanup_free_ char *p = NULL, *q = NULL;
2879         int r;
2880
2881         assert(u);
2882
2883         r = drop_in_file(u, runtime, name, &p, &q);
2884         if (r < 0)
2885                 return r;
2886
2887         mkdir_p(p, 0755);
2888         return write_one_line_file_atomic_label(q, data);
2889 }
2890
2891 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2892         _cleanup_free_ char *p = NULL, *q = NULL;
2893         int r;
2894
2895         assert(u);
2896
2897         r = drop_in_file(u, runtime, name, &p, &q);
2898         if (unlink(q) < 0)
2899                 r = -errno;
2900         else
2901                 r = 0;
2902
2903         rmdir(p);
2904         return r;
2905 }
2906
2907 int unit_kill_context(
2908                 Unit *u,
2909                 KillContext *c,
2910                 bool sigkill,
2911                 pid_t main_pid,
2912                 pid_t control_pid,
2913                 bool main_pid_alien) {
2914
2915         int sig, wait_for_exit = 0, r;
2916
2917         assert(u);
2918         assert(c);
2919
2920         if (c->kill_mode == KILL_NONE)
2921                 return 0;
2922
2923         sig = sigkill ? SIGKILL : c->kill_signal;
2924
2925         if (main_pid > 0) {
2926                 r = kill_and_sigcont(main_pid, sig);
2927
2928                 if (r < 0 && r != -ESRCH) {
2929                         _cleanup_free_ char *comm = NULL;
2930                         get_process_comm(main_pid, &comm);
2931
2932                         log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2933                                          (long) main_pid, strna(comm), strerror(-r));
2934                 } else
2935                         wait_for_exit = !main_pid_alien;
2936         }
2937
2938         if (control_pid > 0) {
2939                 r = kill_and_sigcont(control_pid, sig);
2940
2941                 if (r < 0 && r != -ESRCH) {
2942                         _cleanup_free_ char *comm = NULL;
2943                         get_process_comm(control_pid, &comm);
2944
2945                         log_warning_unit(u->id,
2946                                          "Failed to kill control process %li (%s): %s",
2947                                          (long) control_pid, strna(comm), strerror(-r));
2948                 } else
2949                         wait_for_exit = true;
2950         }
2951
2952         if (c->kill_mode == KILL_CONTROL_GROUP) {
2953                 _cleanup_set_free_ Set *pid_set = NULL;
2954
2955                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2956                 if (!pid_set)
2957                         return -ENOMEM;
2958
2959                 /* Exclude the main/control pids from being killed via the cgroup */
2960                 if (main_pid > 0) {
2961                         r = set_put(pid_set, LONG_TO_PTR(main_pid));
2962                         if (r < 0)
2963                                 return r;
2964                 }
2965
2966                 if (control_pid > 0) {
2967                         r = set_put(pid_set, LONG_TO_PTR(control_pid));
2968                         if (r < 0)
2969                                 return r;
2970                 }
2971
2972                 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2973                 if (r < 0) {
2974                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2975                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2976                 } else if (r > 0)
2977                         wait_for_exit = true;
2978         }
2979
2980         return wait_for_exit;
2981 }
2982
2983 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2984         [UNIT_ACTIVE] = "active",
2985         [UNIT_RELOADING] = "reloading",
2986         [UNIT_INACTIVE] = "inactive",
2987         [UNIT_FAILED] = "failed",
2988         [UNIT_ACTIVATING] = "activating",
2989         [UNIT_DEACTIVATING] = "deactivating"
2990 };
2991
2992 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2993
2994 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2995         [UNIT_REQUIRES] = "Requires",
2996         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2997         [UNIT_REQUISITE] = "Requisite",
2998         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2999         [UNIT_WANTS] = "Wants",
3000         [UNIT_BINDS_TO] = "BindsTo",
3001         [UNIT_PART_OF] = "PartOf",
3002         [UNIT_REQUIRED_BY] = "RequiredBy",
3003         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3004         [UNIT_WANTED_BY] = "WantedBy",
3005         [UNIT_BOUND_BY] = "BoundBy",
3006         [UNIT_CONSISTS_OF] = "ConsistsOf",
3007         [UNIT_CONFLICTS] = "Conflicts",
3008         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3009         [UNIT_BEFORE] = "Before",
3010         [UNIT_AFTER] = "After",
3011         [UNIT_ON_FAILURE] = "OnFailure",
3012         [UNIT_TRIGGERS] = "Triggers",
3013         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3014         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3015         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3016         [UNIT_REFERENCES] = "References",
3017         [UNIT_REFERENCED_BY] = "ReferencedBy",
3018 };
3019
3020 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);