src/core/unit.c

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