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