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