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