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