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