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 = 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 = cg_escape(u->id);
2009         if (!escaped)
2010                 return NULL;
2011
2012         if (slice)
2013                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2014         else
2015                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2016 }
2017
2018 int unit_add_default_slice(Unit *u) {
2019         _cleanup_free_ char *b = NULL;
2020         const char *slice_name;
2021         Unit *slice;
2022         int r;
2023
2024         assert(u);
2025
2026         if (UNIT_ISSET(u->slice))
2027                 return 0;
2028
2029         if (!unit_get_cgroup_context(u))
2030                 return 0;
2031
2032         if (u->instance) {
2033                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2034                         ;
2035                 /* Implicitly place all instantiated units in their
2036                  * own per-template slice */
2037
2038                 prefix = unit_name_to_prefix(u->id);
2039                 if (!prefix)
2040                         return -ENOMEM;
2041
2042                 /* The prefix is already escaped, but it might include
2043                  * "-" which has a special meaning for slice units,
2044                  * hence escape it here extra. */
2045                 escaped = strreplace(prefix, "-", "\\x2d");
2046                 if (!escaped)
2047                         return -ENOMEM;
2048
2049                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2050                         b = strjoin("system-", escaped, ".slice", NULL);
2051                 else
2052                         b = strappend(escaped, ".slice");
2053                 if (!b)
2054                         return -ENOMEM;
2055
2056                 slice_name = b;
2057         } else
2058                 slice_name =
2059                         u->manager->running_as == SYSTEMD_SYSTEM
2060                         ? SPECIAL_SYSTEM_SLICE
2061                         : SPECIAL_ROOT_SLICE;
2062
2063         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2064         if (r < 0)
2065                 return r;
2066
2067         unit_ref_set(&u->slice, slice);
2068         return 0;
2069 }
2070
2071 const char *unit_slice_name(Unit *u) {
2072         assert(u);
2073
2074         if (!UNIT_ISSET(u->slice))
2075                 return NULL;
2076
2077         return UNIT_DEREF(u->slice)->id;
2078 }
2079
2080 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2081         _cleanup_free_ char *t = NULL;
2082         int r;
2083
2084         assert(u);
2085         assert(type);
2086         assert(_found);
2087
2088         t = unit_name_change_suffix(u->id, type);
2089         if (!t)
2090                 return -ENOMEM;
2091
2092         assert(!unit_has_name(u, t));
2093
2094         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2095         assert(r < 0 || *_found != u);
2096         return r;
2097 }
2098
2099 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2100         _cleanup_free_ char *t = NULL;
2101         Unit *found;
2102
2103         assert(u);
2104         assert(type);
2105         assert(_found);
2106
2107         t = unit_name_change_suffix(u->id, type);
2108         if (!t)
2109                 return -ENOMEM;
2110
2111         assert(!unit_has_name(u, t));
2112
2113         found = manager_get_unit(u->manager, t);
2114         if (!found)
2115                 return -ENOENT;
2116
2117         *_found = found;
2118         return 0;
2119 }
2120
2121 int unit_watch_bus_name(Unit *u, const char *name) {
2122         assert(u);
2123         assert(name);
2124
2125         /* Watch a specific name on the bus. We only support one unit
2126          * watching each name for now. */
2127
2128         return hashmap_put(u->manager->watch_bus, name, u);
2129 }
2130
2131 void unit_unwatch_bus_name(Unit *u, const char *name) {
2132         assert(u);
2133         assert(name);
2134
2135         hashmap_remove_value(u->manager->watch_bus, name, u);
2136 }
2137
2138 bool unit_can_serialize(Unit *u) {
2139         assert(u);
2140
2141         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2142 }
2143
2144 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2145         int r;
2146
2147         assert(u);
2148         assert(f);
2149         assert(fds);
2150
2151         if (!unit_can_serialize(u))
2152                 return 0;
2153
2154         r = UNIT_VTABLE(u)->serialize(u, f, fds);
2155         if (r < 0)
2156                 return r;
2157
2158
2159         if (serialize_jobs) {
2160                 if (u->job) {
2161                         fprintf(f, "job\n");
2162                         job_serialize(u->job, f, fds);
2163                 }
2164
2165                 if (u->nop_job) {
2166                         fprintf(f, "job\n");
2167                         job_serialize(u->nop_job, f, fds);
2168                 }
2169         }
2170
2171         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2172         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2173         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2174         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2175         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2176
2177         if (dual_timestamp_is_set(&u->condition_timestamp))
2178                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2179
2180         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2181
2182         if (u->cgroup_path)
2183                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2184
2185         /* End marker */
2186         fputc('\n', f);
2187         return 0;
2188 }
2189
2190 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2191         va_list ap;
2192
2193         assert(u);
2194         assert(f);
2195         assert(key);
2196         assert(format);
2197
2198         fputs(key, f);
2199         fputc('=', f);
2200
2201         va_start(ap, format);
2202         vfprintf(f, format, ap);
2203         va_end(ap);
2204
2205         fputc('\n', f);
2206 }
2207
2208 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2209         assert(u);
2210         assert(f);
2211         assert(key);
2212         assert(value);
2213
2214         fprintf(f, "%s=%s\n", key, value);
2215 }
2216
2217 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2218         int r;
2219
2220         assert(u);
2221         assert(f);
2222         assert(fds);
2223
2224         if (!unit_can_serialize(u))
2225                 return 0;
2226
2227         for (;;) {
2228                 char line[LINE_MAX], *l, *v;
2229                 size_t k;
2230
2231                 if (!fgets(line, sizeof(line), f)) {
2232                         if (feof(f))
2233                                 return 0;
2234                         return -errno;
2235                 }
2236
2237                 char_array_0(line);
2238                 l = strstrip(line);
2239
2240                 /* End marker */
2241                 if (l[0] == 0)
2242                         return 0;
2243
2244                 k = strcspn(l, "=");
2245
2246                 if (l[k] == '=') {
2247                         l[k] = 0;
2248                         v = l+k+1;
2249                 } else
2250                         v = l+k;
2251
2252                 if (streq(l, "job")) {
2253                         if (v[0] == '\0') {
2254                                 /* new-style serialized job */
2255                                 Job *j = job_new_raw(u);
2256                                 if (!j)
2257                                         return -ENOMEM;
2258
2259                                 r = job_deserialize(j, f, fds);
2260                                 if (r < 0) {
2261                                         job_free(j);
2262                                         return r;
2263                                 }
2264
2265                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2266                                 if (r < 0) {
2267                                         job_free(j);
2268                                         return r;
2269                                 }
2270
2271                                 r = job_install_deserialized(j);
2272                                 if (r < 0) {
2273                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2274                                         job_free(j);
2275                                         return r;
2276                                 }
2277
2278                                 if (j->state == JOB_RUNNING)
2279                                         u->manager->n_running_jobs++;
2280                         } else {
2281                                 /* legacy */
2282                                 JobType type = job_type_from_string(v);
2283                                 if (type < 0)
2284                                         log_debug("Failed to parse job type value %s", v);
2285                                 else
2286                                         u->deserialized_job = type;
2287                         }
2288                         continue;
2289                 } else if (streq(l, "inactive-exit-timestamp")) {
2290                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2291                         continue;
2292                 } else if (streq(l, "active-enter-timestamp")) {
2293                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2294                         continue;
2295                 } else if (streq(l, "active-exit-timestamp")) {
2296                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2297                         continue;
2298                 } else if (streq(l, "inactive-enter-timestamp")) {
2299                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2300                         continue;
2301                 } else if (streq(l, "condition-timestamp")) {
2302                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2303                         continue;
2304                 } else if (streq(l, "condition-result")) {
2305                         int b;
2306
2307                         b = parse_boolean(v);
2308                         if (b < 0)
2309                                 log_debug("Failed to parse condition result value %s", v);
2310                         else
2311                                 u->condition_result = b;
2312
2313                         continue;
2314
2315                 } else if (streq(l, "transient")) {
2316                         int b;
2317
2318                         b = parse_boolean(v);
2319                         if (b < 0)
2320                                 log_debug("Failed to parse transient bool %s", v);
2321                         else
2322                                 u->transient = b;
2323
2324                         continue;
2325                 } else if (streq(l, "cgroup")) {
2326                         char *s;
2327
2328                         s = strdup(v);
2329                         if (!s)
2330                                 return -ENOMEM;
2331
2332                         free(u->cgroup_path);
2333                         u->cgroup_path = s;
2334
2335                         hashmap_put(u->manager->cgroup_unit, s, u);
2336                         continue;
2337                 }
2338
2339                 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2340                 if (r < 0)
2341                         return r;
2342         }
2343 }
2344
2345 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2346         Unit *device;
2347         char *e;
2348         int r;
2349
2350         assert(u);
2351
2352         if (!what)
2353                 return 0;
2354
2355         /* Adds in links to the device node that this unit is based on */
2356
2357         if (!is_device_path(what))
2358                 return 0;
2359
2360         e = unit_name_from_path(what, ".device");
2361         if (!e)
2362                 return -ENOMEM;
2363
2364         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2365         free(e);
2366         if (r < 0)
2367                 return r;
2368
2369         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2370         if (r < 0)
2371                 return r;
2372
2373         if (wants) {
2374                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2375                 if (r < 0)
2376                         return r;
2377         }
2378
2379         return 0;
2380 }
2381
2382 int unit_coldplug(Unit *u) {
2383         int r;
2384
2385         assert(u);
2386
2387         if (UNIT_VTABLE(u)->coldplug)
2388                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2389                         return r;
2390
2391         if (u->job) {
2392                 r = job_coldplug(u->job);
2393                 if (r < 0)
2394                         return r;
2395         } else if (u->deserialized_job >= 0) {
2396                 /* legacy */
2397                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2398                 if (r < 0)
2399                         return r;
2400
2401                 u->deserialized_job = _JOB_TYPE_INVALID;
2402         }
2403
2404         return 0;
2405 }
2406
2407 #pragma GCC diagnostic push
2408 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2409 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2410         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2411 }
2412 #pragma GCC diagnostic pop
2413
2414 bool unit_need_daemon_reload(Unit *u) {
2415         _cleanup_strv_free_ char **t = NULL;
2416         char **path;
2417         struct stat st;
2418         unsigned loaded_cnt, current_cnt;
2419
2420         assert(u);
2421
2422         if (u->fragment_path) {
2423                 zero(st);
2424                 if (stat(u->fragment_path, &st) < 0)
2425                         /* What, cannot access this anymore? */
2426                         return true;
2427
2428                 if (u->fragment_mtime > 0 &&
2429                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2430                         return true;
2431         }
2432
2433         if (u->source_path) {
2434                 zero(st);
2435                 if (stat(u->source_path, &st) < 0)
2436                         return true;
2437
2438                 if (u->source_mtime > 0 &&
2439                     timespec_load(&st.st_mtim) != u->source_mtime)
2440                         return true;
2441         }
2442
2443         t = unit_find_dropin_paths(u);
2444         loaded_cnt = strv_length(t);
2445         current_cnt = strv_length(u->dropin_paths);
2446
2447         if (loaded_cnt == current_cnt) {
2448                 if (loaded_cnt == 0)
2449                         return false;
2450
2451                 if (strv_overlap(u->dropin_paths, t)) {
2452                         STRV_FOREACH(path, u->dropin_paths) {
2453                                 zero(st);
2454                                 if (stat(*path, &st) < 0)
2455                                         return true;
2456
2457                                 if (u->dropin_mtime > 0 &&
2458                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2459                                         return true;
2460                         }
2461
2462                         return false;
2463                 } else
2464                         return true;
2465         } else
2466                 return true;
2467 }
2468
2469 void unit_reset_failed(Unit *u) {
2470         assert(u);
2471
2472         if (UNIT_VTABLE(u)->reset_failed)
2473                 UNIT_VTABLE(u)->reset_failed(u);
2474 }
2475
2476 Unit *unit_following(Unit *u) {
2477         assert(u);
2478
2479         if (UNIT_VTABLE(u)->following)
2480                 return UNIT_VTABLE(u)->following(u);
2481
2482         return NULL;
2483 }
2484
2485 bool unit_stop_pending(Unit *u) {
2486         assert(u);
2487
2488         /* This call does check the current state of the unit. It's
2489          * hence useful to be called from state change calls of the
2490          * unit itself, where the state isn't updated yet. This is
2491          * different from unit_inactive_or_pending() which checks both
2492          * the current state and for a queued job. */
2493
2494         return u->job && u->job->type == JOB_STOP;
2495 }
2496
2497 bool unit_inactive_or_pending(Unit *u) {
2498         assert(u);
2499
2500         /* Returns true if the unit is inactive or going down */
2501
2502         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2503                 return true;
2504
2505         if (unit_stop_pending(u))
2506                 return true;
2507
2508         return false;
2509 }
2510
2511 bool unit_active_or_pending(Unit *u) {
2512         assert(u);
2513
2514         /* Returns true if the unit is active or going up */
2515
2516         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2517                 return true;
2518
2519         if (u->job &&
2520             (u->job->type == JOB_START ||
2521              u->job->type == JOB_RELOAD_OR_START ||
2522              u->job->type == JOB_RESTART))
2523                 return true;
2524
2525         return false;
2526 }
2527
2528 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2529         assert(u);
2530         assert(w >= 0 && w < _KILL_WHO_MAX);
2531         assert(signo > 0);
2532         assert(signo < _NSIG);
2533
2534         if (!UNIT_VTABLE(u)->kill)
2535                 return -ENOTSUP;
2536
2537         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2538 }
2539
2540 int unit_kill_common(
2541                 Unit *u,
2542                 KillWho who,
2543                 int signo,
2544                 pid_t main_pid,
2545                 pid_t control_pid,
2546                 DBusError *error) {
2547
2548         int r = 0;
2549
2550         if (who == KILL_MAIN && main_pid <= 0) {
2551                 if (main_pid < 0)
2552                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2553                 else
2554                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2555                 return -ESRCH;
2556         }
2557
2558         if (who == KILL_CONTROL && control_pid <= 0) {
2559                 if (control_pid < 0)
2560                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2561                 else
2562                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2563                 return -ESRCH;
2564         }
2565
2566         if (who == KILL_CONTROL || who == KILL_ALL)
2567                 if (control_pid > 0)
2568                         if (kill(control_pid, signo) < 0)
2569                                 r = -errno;
2570
2571         if (who == KILL_MAIN || who == KILL_ALL)
2572                 if (main_pid > 0)
2573                         if (kill(main_pid, signo) < 0)
2574                                 r = -errno;
2575
2576         if (who == KILL_ALL && u->cgroup_path) {
2577                 _cleanup_set_free_ Set *pid_set = NULL;
2578                 int q;
2579
2580                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2581                 if (!pid_set)
2582                         return -ENOMEM;
2583
2584                 /* Exclude the control/main pid from being killed via the cgroup */
2585                 if (control_pid > 0) {
2586                         q = set_put(pid_set, LONG_TO_PTR(control_pid));
2587                         if (q < 0)
2588                                 return q;
2589                 }
2590
2591                 if (main_pid > 0) {
2592                         q = set_put(pid_set, LONG_TO_PTR(main_pid));
2593                         if (q < 0)
2594                                 return q;
2595                 }
2596
2597                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2598                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2599                         r = q;
2600         }
2601
2602         return r;
2603 }
2604
2605 int unit_following_set(Unit *u, Set **s) {
2606         assert(u);
2607         assert(s);
2608
2609         if (UNIT_VTABLE(u)->following_set)
2610                 return UNIT_VTABLE(u)->following_set(u, s);
2611
2612         *s = NULL;
2613         return 0;
2614 }
2615
2616 UnitFileState unit_get_unit_file_state(Unit *u) {
2617         assert(u);
2618
2619         if (u->unit_file_state < 0 && u->fragment_path)
2620                 u->unit_file_state = unit_file_get_state(
2621                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2622                                 NULL, path_get_file_name(u->fragment_path));
2623
2624         return u->unit_file_state;
2625 }
2626
2627 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2628         assert(ref);
2629         assert(u);
2630
2631         if (ref->unit)
2632                 unit_ref_unset(ref);
2633
2634         ref->unit = u;
2635         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2636         return u;
2637 }
2638
2639 void unit_ref_unset(UnitRef *ref) {
2640         assert(ref);
2641
2642         if (!ref->unit)
2643                 return;
2644
2645         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2646         ref->unit = NULL;
2647 }
2648
2649 int unit_add_one_mount_link(Unit *u, Mount *m) {
2650         char **i;
2651
2652         assert(u);
2653         assert(m);
2654
2655         if (u->load_state != UNIT_LOADED ||
2656             UNIT(m)->load_state != UNIT_LOADED)
2657                 return 0;
2658
2659         STRV_FOREACH(i, u->requires_mounts_for) {
2660
2661                 if (UNIT(m) == u)
2662                         continue;
2663
2664                 if (!path_startswith(*i, m->where))
2665                         continue;
2666
2667                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2668         }
2669
2670         return 0;
2671 }
2672
2673 int unit_add_mount_links(Unit *u) {
2674         Unit *other;
2675         int r;
2676
2677         assert(u);
2678
2679         LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2680                 r = unit_add_one_mount_link(u, MOUNT(other));
2681                 if (r < 0)
2682                         return r;
2683         }
2684
2685         return 0;
2686 }
2687
2688 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2689         unsigned i;
2690         int r;
2691
2692         assert(u);
2693         assert(c);
2694
2695         /* This only copies in the ones that need memory */
2696         for (i = 0; i < RLIMIT_NLIMITS; i++)
2697                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2698                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2699                         if (!c->rlimit[i])
2700                                 return -ENOMEM;
2701                 }
2702
2703         if (u->manager->running_as == SYSTEMD_USER &&
2704             !c->working_directory) {
2705
2706                 r = get_home_dir(&c->working_directory);
2707                 if (r < 0)
2708                         return r;
2709         }
2710
2711         return 0;
2712 }
2713
2714 ExecContext *unit_get_exec_context(Unit *u) {
2715         size_t offset;
2716         assert(u);
2717
2718         offset = UNIT_VTABLE(u)->exec_context_offset;
2719         if (offset <= 0)
2720                 return NULL;
2721
2722         return (ExecContext*) ((uint8_t*) u + offset);
2723 }
2724
2725 CGroupContext *unit_get_cgroup_context(Unit *u) {
2726         size_t offset;
2727
2728         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2729         if (offset <= 0)
2730                 return NULL;
2731
2732         return (CGroupContext*) ((uint8_t*) u + offset);
2733 }
2734
2735 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2736         _cleanup_free_ char *b = NULL;
2737         char *p, *q;
2738         int r;
2739
2740         assert(u);
2741         assert(name);
2742         assert(_p);
2743         assert(_q);
2744         assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2745
2746         b = xescape(name, "/.");
2747         if (!b)
2748                 return -ENOMEM;
2749
2750         if (!filename_is_safe(b))
2751                 return -EINVAL;
2752
2753         if (u->manager->running_as == SYSTEMD_USER) {
2754                 _cleanup_free_ char *c = NULL;
2755
2756                 r = user_config_home(&c);
2757                 if (r < 0)
2758                         return r;
2759                 if (r == 0)
2760                         return -ENOENT;
2761
2762                 p = strjoin(c, "/", u->id, ".d", NULL);
2763         } else if (mode & UNIT_PERSISTENT)
2764                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2765         else
2766                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2767         if (!p)
2768                 return -ENOMEM;
2769
2770         q = strjoin(p, "/90-", b, ".conf", NULL);
2771         if (!q) {
2772                 free(p);
2773                 return -ENOMEM;
2774         }
2775
2776         *_p = p;
2777         *_q = q;
2778         return 0;
2779 }
2780
2781 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2782         _cleanup_free_ char *p = NULL, *q = NULL;
2783         int r;
2784
2785         assert(u);
2786         assert(name);
2787         assert(data);
2788
2789         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2790                 return 0;
2791
2792         r = drop_in_file(u, mode, name, &p, &q);
2793         if (r < 0)
2794                 return r;
2795
2796         mkdir_p(p, 0755);
2797         return write_string_file_atomic_label(q, data);
2798 }
2799
2800 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2801         _cleanup_free_ char *p = NULL;
2802         va_list ap;
2803         int r;
2804
2805         assert(u);
2806         assert(name);
2807         assert(format);
2808
2809         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2810                 return 0;
2811
2812         va_start(ap, format);
2813         r = vasprintf(&p, format, ap);
2814         va_end(ap);
2815
2816         if (r < 0)
2817                 return -ENOMEM;
2818
2819         return unit_write_drop_in(u, mode, name, p);
2820 }
2821
2822 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2823         _cleanup_free_ char *ndata = NULL;
2824
2825         assert(u);
2826         assert(name);
2827         assert(data);
2828
2829         if (!UNIT_VTABLE(u)->private_section)
2830                 return -EINVAL;
2831
2832         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2833                 return 0;
2834
2835         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2836         if (!ndata)
2837                 return -ENOMEM;
2838
2839         return unit_write_drop_in(u, mode, name, ndata);
2840 }
2841
2842 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2843         _cleanup_free_ char *p = NULL;
2844         va_list ap;
2845         int r;
2846
2847         assert(u);
2848         assert(name);
2849         assert(format);
2850
2851         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2852                 return 0;
2853
2854         va_start(ap, format);
2855         r = vasprintf(&p, format, ap);
2856         va_end(ap);
2857
2858         if (r < 0)
2859                 return -ENOMEM;
2860
2861         return unit_write_drop_in_private(u, mode, name, p);
2862 }
2863
2864 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2865         _cleanup_free_ char *p = NULL, *q = NULL;
2866         int r;
2867
2868         assert(u);
2869
2870         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2871                 return 0;
2872
2873         r = drop_in_file(u, mode, name, &p, &q);
2874         if (unlink(q) < 0)
2875                 r = errno == ENOENT ? 0 : -errno;
2876         else
2877                 r = 1;
2878
2879         rmdir(p);
2880         return r;
2881 }
2882
2883 int unit_make_transient(Unit *u) {
2884         int r;
2885
2886         assert(u);
2887
2888         u->load_state = UNIT_STUB;
2889         u->load_error = 0;
2890         u->transient = true;
2891
2892         free(u->fragment_path);
2893         u->fragment_path = NULL;
2894
2895         if (u->manager->running_as == SYSTEMD_USER) {
2896                 _cleanup_free_ char *c = NULL;
2897
2898                 r = user_config_home(&c);
2899                 if (r < 0)
2900                         return r;
2901                 if (r == 0)
2902                         return -ENOENT;
2903
2904                 u->fragment_path = strjoin(c, "/", u->id, NULL);
2905                 if (!u->fragment_path)
2906                         return -ENOMEM;
2907
2908                 mkdir_p(c, 0755);
2909         } else {
2910                 u->fragment_path = strappend("/run/systemd/system/", u->id);
2911                 if (!u->fragment_path)
2912                         return -ENOMEM;
2913
2914                 mkdir_p("/run/systemd/system", 0755);
2915         }
2916
2917         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2918 }
2919
2920 int unit_kill_context(
2921                 Unit *u,
2922                 KillContext *c,
2923                 bool sigkill,
2924                 pid_t main_pid,
2925                 pid_t control_pid,
2926                 bool main_pid_alien) {
2927
2928         int sig, wait_for_exit = 0, r;
2929
2930         assert(u);
2931         assert(c);
2932
2933         if (c->kill_mode == KILL_NONE)
2934                 return 0;
2935
2936         sig = sigkill ? SIGKILL : c->kill_signal;
2937
2938         if (main_pid > 0) {
2939                 r = kill_and_sigcont(main_pid, sig);
2940
2941                 if (r < 0 && r != -ESRCH) {
2942                         _cleanup_free_ char *comm = NULL;
2943                         get_process_comm(main_pid, &comm);
2944
2945                         log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2946                                          (long) main_pid, strna(comm), strerror(-r));
2947                 } else
2948                         wait_for_exit = !main_pid_alien;
2949         }
2950
2951         if (control_pid > 0) {
2952                 r = kill_and_sigcont(control_pid, sig);
2953
2954                 if (r < 0 && r != -ESRCH) {
2955                         _cleanup_free_ char *comm = NULL;
2956                         get_process_comm(control_pid, &comm);
2957
2958                         log_warning_unit(u->id,
2959                                          "Failed to kill control process %li (%s): %s",
2960                                          (long) control_pid, strna(comm), strerror(-r));
2961                 } else
2962                         wait_for_exit = true;
2963         }
2964
2965         if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2966                 _cleanup_set_free_ Set *pid_set = NULL;
2967
2968                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2969                 if (!pid_set)
2970                         return -ENOMEM;
2971
2972                 /* Exclude the main/control pids from being killed via the cgroup */
2973                 if (main_pid > 0) {
2974                         r = set_put(pid_set, LONG_TO_PTR(main_pid));
2975                         if (r < 0)
2976                                 return r;
2977                 }
2978
2979                 if (control_pid > 0) {
2980                         r = set_put(pid_set, LONG_TO_PTR(control_pid));
2981                         if (r < 0)
2982                                 return r;
2983                 }
2984
2985                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2986                 if (r < 0) {
2987                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2988                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2989                 } else if (r > 0)
2990                         wait_for_exit = true;
2991         }
2992
2993         return wait_for_exit;
2994 }
2995
2996 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2997         [UNIT_ACTIVE] = "active",
2998         [UNIT_RELOADING] = "reloading",
2999         [UNIT_INACTIVE] = "inactive",
3000         [UNIT_FAILED] = "failed",
3001         [UNIT_ACTIVATING] = "activating",
3002         [UNIT_DEACTIVATING] = "deactivating"
3003 };
3004
3005 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3006
3007 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3008         [UNIT_REQUIRES] = "Requires",
3009         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3010         [UNIT_REQUISITE] = "Requisite",
3011         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3012         [UNIT_WANTS] = "Wants",
3013         [UNIT_BINDS_TO] = "BindsTo",
3014         [UNIT_PART_OF] = "PartOf",
3015         [UNIT_REQUIRED_BY] = "RequiredBy",
3016         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3017         [UNIT_WANTED_BY] = "WantedBy",
3018         [UNIT_BOUND_BY] = "BoundBy",
3019         [UNIT_CONSISTS_OF] = "ConsistsOf",
3020         [UNIT_CONFLICTS] = "Conflicts",
3021         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3022         [UNIT_BEFORE] = "Before",
3023         [UNIT_AFTER] = "After",
3024         [UNIT_ON_FAILURE] = "OnFailure",
3025         [UNIT_TRIGGERS] = "Triggers",
3026         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3027         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3028         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3029         [UNIT_REFERENCES] = "References",
3030         [UNIT_REFERENCED_BY] = "ReferencedBy",
3031 };
3032
3033 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);