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