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