src/core/unit.c

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