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