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