src/core/unit.h

   1 #pragma once
   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 <stdbool.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25
  26 typedef struct Unit Unit;
  27 typedef struct UnitVTable UnitVTable;
  28 typedef struct UnitRef UnitRef;
  29 typedef struct UnitStatusMessageFormats UnitStatusMessageFormats;
  30
  31 #include "condition.h"
  32 #include "failure-action.h"
  33 #include "install.h"
  34 #include "list.h"
  35 #include "unit-name.h"
  36
  37 typedef enum KillOperation {
  38         KILL_TERMINATE,
  39         KILL_TERMINATE_AND_LOG,
  40         KILL_KILL,
  41         KILL_ABORT,
  42         _KILL_OPERATION_MAX,
  43         _KILL_OPERATION_INVALID = -1
  44 } KillOperation;
  45
  46 static inline bool UNIT_IS_ACTIVE_OR_RELOADING(UnitActiveState t) {
  47         return t == UNIT_ACTIVE || t == UNIT_RELOADING;
  48 }
  49
  50 static inline bool UNIT_IS_ACTIVE_OR_ACTIVATING(UnitActiveState t) {
  51         return t == UNIT_ACTIVE || t == UNIT_ACTIVATING || t == UNIT_RELOADING;
  52 }
  53
  54 static inline bool UNIT_IS_INACTIVE_OR_DEACTIVATING(UnitActiveState t) {
  55         return t == UNIT_INACTIVE || t == UNIT_FAILED || t == UNIT_DEACTIVATING;
  56 }
  57
  58 static inline bool UNIT_IS_INACTIVE_OR_FAILED(UnitActiveState t) {
  59         return t == UNIT_INACTIVE || t == UNIT_FAILED;
  60 }
  61
  62 #include "job.h"
  63
  64 struct UnitRef {
  65         /* Keeps tracks of references to a unit. This is useful so
  66          * that we can merge two units if necessary and correct all
  67          * references to them */
  68
  69         Unit* unit;
  70         LIST_FIELDS(UnitRef, refs);
  71 };
  72
  73 struct Unit {
  74         Manager *manager;
  75
  76         UnitType type;
  77         UnitLoadState load_state;
  78         Unit *merged_into;
  79
  80         char *id; /* One name is special because we use it for identification. Points to an entry in the names set */
  81         char *instance;
  82
  83         Set *names;
  84         Set *dependencies[_UNIT_DEPENDENCY_MAX];
  85
  86         char **requires_mounts_for;
  87
  88         char *description;
  89         char **documentation;
  90
  91         char *fragment_path; /* if loaded from a config file this is the primary path to it */
  92         char *source_path; /* if converted, the source file */
  93         char **dropin_paths;
  94
  95         usec_t fragment_mtime;
  96         usec_t source_mtime;
  97         usec_t dropin_mtime;
  98
  99         /* If this is a transient unit we are currently writing, this is where we are writing it to */
 100         FILE *transient_file;
 101
 102         /* If there is something to do with this unit, then this is the installed job for it */
 103         Job *job;
 104
 105         /* JOB_NOP jobs are special and can be installed without disturbing the real job. */
 106         Job *nop_job;
 107
 108         /* The slot used for watching NameOwnerChanged signals */
 109         sd_bus_slot *match_bus_slot;
 110
 111         /* References to this unit from clients */
 112         sd_bus_track *bus_track;
 113         char **deserialized_refs;
 114
 115         /* Job timeout and action to take */
 116         usec_t job_timeout;
 117         FailureAction job_timeout_action;
 118         char *job_timeout_reboot_arg;
 119
 120         /* References to this */
 121         LIST_HEAD(UnitRef, refs);
 122
 123         /* Conditions to check */
 124         LIST_HEAD(Condition, conditions);
 125         LIST_HEAD(Condition, asserts);
 126
 127         dual_timestamp condition_timestamp;
 128         dual_timestamp assert_timestamp;
 129
 130         /* Updated whenever the low-level state changes */
 131         dual_timestamp state_change_timestamp;
 132
 133         /* Updated whenever the (high-level) active state enters or leaves the active or inactive states */
 134         dual_timestamp inactive_exit_timestamp;
 135         dual_timestamp active_enter_timestamp;
 136         dual_timestamp active_exit_timestamp;
 137         dual_timestamp inactive_enter_timestamp;
 138
 139         UnitRef slice;
 140
 141         /* Per type list */
 142         LIST_FIELDS(Unit, units_by_type);
 143
 144         /* All units which have requires_mounts_for set */
 145         LIST_FIELDS(Unit, has_requires_mounts_for);
 146
 147         /* Load queue */
 148         LIST_FIELDS(Unit, load_queue);
 149
 150         /* D-Bus queue */
 151         LIST_FIELDS(Unit, dbus_queue);
 152
 153         /* Cleanup queue */
 154         LIST_FIELDS(Unit, cleanup_queue);
 155
 156         /* GC queue */
 157         LIST_FIELDS(Unit, gc_queue);
 158
 159         /* CGroup realize members queue */
 160         LIST_FIELDS(Unit, cgroup_queue);
 161
 162         /* Units with the same CGroup netclass */
 163         LIST_FIELDS(Unit, cgroup_netclass);
 164
 165         /* PIDs we keep an eye on. Note that a unit might have many
 166          * more, but these are the ones we care enough about to
 167          * process SIGCHLD for */
 168         Set *pids;
 169
 170         /* Used in sigchld event invocation to avoid repeat events being invoked */
 171         uint64_t sigchldgen;
 172
 173         /* Used during GC sweeps */
 174         unsigned gc_marker;
 175
 176         /* Error code when we didn't manage to load the unit (negative) */
 177         int load_error;
 178
 179         /* Put a ratelimit on unit starting */
 180         RateLimit start_limit;
 181         FailureAction start_limit_action;
 182         char *reboot_arg;
 183
 184         /* Make sure we never enter endless loops with the check unneeded logic, or the BindsTo= logic */
 185         RateLimit auto_stop_ratelimit;
 186
 187         /* Reference to a specific UID/GID */
 188         uid_t ref_uid;
 189         gid_t ref_gid;
 190
 191         /* Cached unit file state and preset */
 192         UnitFileState unit_file_state;
 193         int unit_file_preset;
 194
 195         /* Where the cpu.stat or cpuacct.usage was at the time the unit was started */
 196         nsec_t cpu_usage_base;
 197         nsec_t cpu_usage_last; /* the most recently read value */
 198
 199         /* Counterparts in the cgroup filesystem */
 200         char *cgroup_path;
 201         CGroupMask cgroup_realized_mask;
 202         CGroupMask cgroup_enabled_mask;
 203         CGroupMask cgroup_subtree_mask;
 204         CGroupMask cgroup_members_mask;
 205         int cgroup_inotify_wd;
 206
 207         /* How to start OnFailure units */
 208         JobMode on_failure_job_mode;
 209
 210         /* The current invocation ID */
 211         sd_id128_t invocation_id;
 212         char invocation_id_string[SD_ID128_STRING_MAX]; /* useful when logging */
 213
 214         /* Garbage collect us we nobody wants or requires us anymore */
 215         bool stop_when_unneeded;
 216
 217         /* Create default dependencies */
 218         bool default_dependencies;
 219
 220         /* Refuse manual starting, allow starting only indirectly via dependency. */
 221         bool refuse_manual_start;
 222
 223         /* Don't allow the user to stop this unit manually, allow stopping only indirectly via dependency. */
 224         bool refuse_manual_stop;
 225
 226         /* Allow isolation requests */
 227         bool allow_isolate;
 228
 229         /* Ignore this unit when isolating */
 230         bool ignore_on_isolate;
 231
 232         /* Did the last condition check succeed? */
 233         bool condition_result;
 234         bool assert_result;
 235
 236         /* Is this a transient unit? */
 237         bool transient;
 238
 239         bool in_load_queue:1;
 240         bool in_dbus_queue:1;
 241         bool in_cleanup_queue:1;
 242         bool in_gc_queue:1;
 243         bool in_cgroup_queue:1;
 244
 245         bool sent_dbus_new_signal:1;
 246
 247         bool no_gc:1;
 248
 249         bool in_audit:1;
 250
 251         bool cgroup_realized:1;
 252         bool cgroup_members_mask_valid:1;
 253         bool cgroup_subtree_mask_valid:1;
 254
 255         bool start_limit_hit:1;
 256
 257         /* Did we already invoke unit_coldplug() for this unit? */
 258         bool coldplugged:1;
 259
 260         /* For transient units: whether to add a bus track reference after creating the unit */
 261         bool bus_track_add:1;
 262 };
 263
 264 struct UnitStatusMessageFormats {
 265         const char *starting_stopping[2];
 266         const char *finished_start_job[_JOB_RESULT_MAX];
 267         const char *finished_stop_job[_JOB_RESULT_MAX];
 268 };
 269
 270 typedef enum UnitSetPropertiesMode {
 271         UNIT_CHECK = 0,
 272         UNIT_RUNTIME = 1,
 273         UNIT_PERSISTENT = 2,
 274 } UnitSetPropertiesMode;
 275
 276 #include "automount.h"
 277 #include "busname.h"
 278 #include "device.h"
 279 #include "path.h"
 280 #include "scope.h"
 281 #include "slice.h"
 282 #include "socket.h"
 283 #include "swap.h"
 284 #include "target.h"
 285 #include "timer.h"
 286
 287 struct UnitVTable {
 288         /* How much memory does an object of this unit type need */
 289         size_t object_size;
 290
 291         /* If greater than 0, the offset into the object where
 292          * ExecContext is found, if the unit type has that */
 293         size_t exec_context_offset;
 294
 295         /* If greater than 0, the offset into the object where
 296          * CGroupContext is found, if the unit type has that */
 297         size_t cgroup_context_offset;
 298
 299         /* If greater than 0, the offset into the object where
 300          * KillContext is found, if the unit type has that */
 301         size_t kill_context_offset;
 302
 303         /* If greater than 0, the offset into the object where the
 304          * pointer to ExecRuntime is found, if the unit type has
 305          * that */
 306         size_t exec_runtime_offset;
 307
 308         /* If greater than 0, the offset into the object where the pointer to DynamicCreds is found, if the unit type
 309          * has that. */
 310         size_t dynamic_creds_offset;
 311
 312         /* The name of the configuration file section with the private settings of this unit */
 313         const char *private_section;
 314
 315         /* Config file sections this unit type understands, separated
 316          * by NUL chars */
 317         const char *sections;
 318
 319         /* This should reset all type-specific variables. This should
 320          * not allocate memory, and is called with zero-initialized
 321          * data. It should hence only initialize variables that need
 322          * to be set != 0. */
 323         void (*init)(Unit *u);
 324
 325         /* This should free all type-specific variables. It should be
 326          * idempotent. */
 327         void (*done)(Unit *u);
 328
 329         /* Actually load data from disk. This may fail, and should set
 330          * load_state to UNIT_LOADED, UNIT_MERGED or leave it at
 331          * UNIT_STUB if no configuration could be found. */
 332         int (*load)(Unit *u);
 333
 334         /* If a lot of units got created via enumerate(), this is
 335          * where to actually set the state and call unit_notify(). */
 336         int (*coldplug)(Unit *u);
 337
 338         void (*dump)(Unit *u, FILE *f, const char *prefix);
 339
 340         int (*start)(Unit *u);
 341         int (*stop)(Unit *u);
 342         int (*reload)(Unit *u);
 343
 344         int (*kill)(Unit *u, KillWho w, int signo, sd_bus_error *error);
 345
 346         bool (*can_reload)(Unit *u);
 347
 348         /* Write all data that cannot be restored from other sources
 349          * away using unit_serialize_item() */
 350         int (*serialize)(Unit *u, FILE *f, FDSet *fds);
 351
 352         /* Restore one item from the serialization */
 353         int (*deserialize_item)(Unit *u, const char *key, const char *data, FDSet *fds);
 354
 355         /* Try to match up fds with what we need for this unit */
 356         void (*distribute_fds)(Unit *u, FDSet *fds);
 357
 358         /* Boils down the more complex internal state of this unit to
 359          * a simpler one that the engine can understand */
 360         UnitActiveState (*active_state)(Unit *u);
 361
 362         /* Returns the substate specific to this unit type as
 363          * string. This is purely information so that we can give the
 364          * user a more fine grained explanation in which actual state a
 365          * unit is in. */
 366         const char* (*sub_state_to_string)(Unit *u);
 367
 368         /* Return true when there is reason to keep this entry around
 369          * even nothing references it and it isn't active in any
 370          * way */
 371         bool (*check_gc)(Unit *u);
 372
 373         /* When the unit is not running and no job for it queued we
 374          * shall release its runtime resources */
 375         void (*release_resources)(Unit *u);
 376
 377         /* Invoked on every child that died */
 378         void (*sigchld_event)(Unit *u, pid_t pid, int code, int status);
 379
 380         /* Reset failed state if we are in failed state */
 381         void (*reset_failed)(Unit *u);
 382
 383         /* Called whenever any of the cgroups this unit watches for
 384          * ran empty */
 385         void (*notify_cgroup_empty)(Unit *u);
 386
 387         /* Called whenever a process of this unit sends us a message */
 388         void (*notify_message)(Unit *u, pid_t pid, char **tags, FDSet *fds);
 389
 390         /* Called whenever a name this Unit registered for comes or goes away. */
 391         void (*bus_name_owner_change)(Unit *u, const char *name, const char *old_owner, const char *new_owner);
 392
 393         /* Called for each property that is being set */
 394         int (*bus_set_property)(Unit *u, const char *name, sd_bus_message *message, UnitSetPropertiesMode mode, sd_bus_error *error);
 395
 396         /* Called after at least one property got changed to apply the necessary change */
 397         int (*bus_commit_properties)(Unit *u);
 398
 399         /* Return the unit this unit is following */
 400         Unit *(*following)(Unit *u);
 401
 402         /* Return the set of units that are following each other */
 403         int (*following_set)(Unit *u, Set **s);
 404
 405         /* Invoked each time a unit this unit is triggering changes
 406          * state or gains/loses a job */
 407         void (*trigger_notify)(Unit *u, Unit *trigger);
 408
 409         /* Called whenever CLOCK_REALTIME made a jump */
 410         void (*time_change)(Unit *u);
 411
 412         /* Returns the next timeout of a unit */
 413         int (*get_timeout)(Unit *u, usec_t *timeout);
 414
 415         /* Returns the main PID if there is any defined, or 0. */
 416         pid_t (*main_pid)(Unit *u);
 417
 418         /* Returns the main PID if there is any defined, or 0. */
 419         pid_t (*control_pid)(Unit *u);
 420
 421         /* This is called for each unit type and should be used to
 422          * enumerate existing devices and load them. However,
 423          * everything that is loaded here should still stay in
 424          * inactive state. It is the job of the coldplug() call above
 425          * to put the units into the initial state.  */
 426         void (*enumerate)(Manager *m);
 427
 428         /* Type specific cleanups. */
 429         void (*shutdown)(Manager *m);
 430
 431         /* If this function is set and return false all jobs for units
 432          * of this type will immediately fail. */
 433         bool (*supported)(void);
 434
 435         /* The bus vtable */
 436         const sd_bus_vtable *bus_vtable;
 437
 438         /* The strings to print in status messages */
 439         UnitStatusMessageFormats status_message_formats;
 440
 441         /* True if transient units of this type are OK */
 442         bool can_transient:1;
 443 };
 444
 445 extern const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX];
 446
 447 #define UNIT_VTABLE(u) unit_vtable[(u)->type]
 448
 449 /* For casting a unit into the various unit types */
 450 #define DEFINE_CAST(UPPERCASE, MixedCase)                               \
 451         static inline MixedCase* UPPERCASE(Unit *u) {                   \
 452                 if (_unlikely_(!u || u->type != UNIT_##UPPERCASE))      \
 453                         return NULL;                                    \
 454                                                                         \
 455                 return (MixedCase*) u;                                  \
 456         }
 457
 458 /* For casting the various unit types into a unit */
 459 #define UNIT(u) (&(u)->meta)
 460
 461 #define UNIT_HAS_EXEC_CONTEXT(u) (UNIT_VTABLE(u)->exec_context_offset > 0)
 462 #define UNIT_HAS_CGROUP_CONTEXT(u) (UNIT_VTABLE(u)->cgroup_context_offset > 0)
 463 #define UNIT_HAS_KILL_CONTEXT(u) (UNIT_VTABLE(u)->kill_context_offset > 0)
 464
 465 #define UNIT_TRIGGER(u) ((Unit*) set_first((u)->dependencies[UNIT_TRIGGERS]))
 466
 467 DEFINE_CAST(SERVICE, Service);
 468 DEFINE_CAST(SOCKET, Socket);
 469 DEFINE_CAST(BUSNAME, BusName);
 470 DEFINE_CAST(TARGET, Target);
 471 DEFINE_CAST(DEVICE, Device);
 472 DEFINE_CAST(MOUNT, Mount);
 473 DEFINE_CAST(AUTOMOUNT, Automount);
 474 DEFINE_CAST(SWAP, Swap);
 475 DEFINE_CAST(TIMER, Timer);
 476 DEFINE_CAST(PATH, Path);
 477 DEFINE_CAST(SLICE, Slice);
 478 DEFINE_CAST(SCOPE, Scope);
 479
 480 Unit *unit_new(Manager *m, size_t size);
 481 void unit_free(Unit *u);
 482
 483 int unit_add_name(Unit *u, const char *name);
 484
 485 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference);
 486 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference);
 487
 488 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *filename, bool add_reference);
 489 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference);
 490
 491 int unit_add_exec_dependencies(Unit *u, ExecContext *c);
 492
 493 int unit_choose_id(Unit *u, const char *name);
 494 int unit_set_description(Unit *u, const char *description);
 495
 496 bool unit_check_gc(Unit *u);
 497
 498 void unit_add_to_load_queue(Unit *u);
 499 void unit_add_to_dbus_queue(Unit *u);
 500 void unit_add_to_cleanup_queue(Unit *u);
 501 void unit_add_to_gc_queue(Unit *u);
 502
 503 int unit_merge(Unit *u, Unit *other);
 504 int unit_merge_by_name(Unit *u, const char *other);
 505
 506 Unit *unit_follow_merge(Unit *u) _pure_;
 507
 508 int unit_load_fragment_and_dropin(Unit *u);
 509 int unit_load_fragment_and_dropin_optional(Unit *u);
 510 int unit_load(Unit *unit);
 511
 512 int unit_set_slice(Unit *u, Unit *slice);
 513 int unit_set_default_slice(Unit *u);
 514
 515 const char *unit_description(Unit *u) _pure_;
 516
 517 bool unit_has_name(Unit *u, const char *name);
 518
 519 UnitActiveState unit_active_state(Unit *u);
 520
 521 const char* unit_sub_state_to_string(Unit *u);
 522
 523 void unit_dump(Unit *u, FILE *f, const char *prefix);
 524
 525 bool unit_can_reload(Unit *u) _pure_;
 526 bool unit_can_start(Unit *u) _pure_;
 527 bool unit_can_isolate(Unit *u) _pure_;
 528
 529 int unit_start(Unit *u);
 530 int unit_stop(Unit *u);
 531 int unit_reload(Unit *u);
 532
 533 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error);
 534 int unit_kill_common(Unit *u, KillWho who, int signo, pid_t main_pid, pid_t control_pid, sd_bus_error *error);
 535
 536 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success);
 537
 538 int unit_watch_pid(Unit *u, pid_t pid);
 539 void unit_unwatch_pid(Unit *u, pid_t pid);
 540 void unit_unwatch_all_pids(Unit *u);
 541
 542 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2);
 543
 544 int unit_install_bus_match(Unit *u, sd_bus *bus, const char *name);
 545 int unit_watch_bus_name(Unit *u, const char *name);
 546 void unit_unwatch_bus_name(Unit *u, const char *name);
 547
 548 bool unit_job_is_applicable(Unit *u, JobType j);
 549
 550 int set_unit_path(const char *p);
 551
 552 char *unit_dbus_path(Unit *u);
 553 char *unit_dbus_path_invocation_id(Unit *u);
 554
 555 int unit_load_related_unit(Unit *u, const char *type, Unit **_found);
 556
 557 bool unit_can_serialize(Unit *u) _pure_;
 558
 559 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs);
 560 int unit_deserialize(Unit *u, FILE *f, FDSet *fds);
 561
 562 int unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value);
 563 int unit_serialize_item_escaped(Unit *u, FILE *f, const char *key, const char *value);
 564 int unit_serialize_item_fd(Unit *u, FILE *f, FDSet *fds, const char *key, int fd);
 565 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *value, ...) _printf_(4,5);
 566
 567 int unit_add_node_link(Unit *u, const char *what, bool wants, UnitDependency d);
 568
 569 int unit_coldplug(Unit *u);
 570
 571 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) _printf_(3, 0);
 572 void unit_status_emit_starting_stopping_reloading(Unit *u, JobType t);
 573
 574 bool unit_need_daemon_reload(Unit *u);
 575
 576 void unit_reset_failed(Unit *u);
 577
 578 Unit *unit_following(Unit *u);
 579 int unit_following_set(Unit *u, Set **s);
 580
 581 const char *unit_slice_name(Unit *u);
 582
 583 bool unit_stop_pending(Unit *u) _pure_;
 584 bool unit_inactive_or_pending(Unit *u) _pure_;
 585 bool unit_active_or_pending(Unit *u);
 586
 587 int unit_add_default_target_dependency(Unit *u, Unit *target);
 588
 589 void unit_start_on_failure(Unit *u);
 590 void unit_trigger_notify(Unit *u);
 591
 592 UnitFileState unit_get_unit_file_state(Unit *u);
 593 int unit_get_unit_file_preset(Unit *u);
 594
 595 Unit* unit_ref_set(UnitRef *ref, Unit *u);
 596 void unit_ref_unset(UnitRef *ref);
 597
 598 #define UNIT_DEREF(ref) ((ref).unit)
 599 #define UNIT_ISSET(ref) (!!(ref).unit)
 600
 601 int unit_patch_contexts(Unit *u);
 602
 603 ExecContext *unit_get_exec_context(Unit *u) _pure_;
 604 KillContext *unit_get_kill_context(Unit *u) _pure_;
 605 CGroupContext *unit_get_cgroup_context(Unit *u) _pure_;
 606
 607 ExecRuntime *unit_get_exec_runtime(Unit *u) _pure_;
 608
 609 int unit_setup_exec_runtime(Unit *u);
 610 int unit_setup_dynamic_creds(Unit *u);
 611
 612 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data);
 613 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) _printf_(4,5);
 614
 615 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data);
 616 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) _printf_(4,5);
 617
 618 int unit_kill_context(Unit *u, KillContext *c, KillOperation k, pid_t main_pid, pid_t control_pid, bool main_pid_alien);
 619
 620 int unit_make_transient(Unit *u);
 621
 622 int unit_require_mounts_for(Unit *u, const char *path);
 623
 624 bool unit_type_supported(UnitType t);
 625
 626 bool unit_is_pristine(Unit *u);
 627
 628 pid_t unit_control_pid(Unit *u);
 629 pid_t unit_main_pid(Unit *u);
 630
 631 static inline bool unit_supported(Unit *u) {
 632         return unit_type_supported(u->type);
 633 }
 634
 635 void unit_warn_if_dir_nonempty(Unit *u, const char* where);
 636 int unit_fail_if_symlink(Unit *u, const char* where);
 637
 638 int unit_start_limit_test(Unit *u);
 639
 640 void unit_unref_uid(Unit *u, bool destroy_now);
 641 int unit_ref_uid(Unit *u, uid_t uid, bool clean_ipc);
 642
 643 void unit_unref_gid(Unit *u, bool destroy_now);
 644 int unit_ref_gid(Unit *u, gid_t gid, bool clean_ipc);
 645
 646 int unit_ref_uid_gid(Unit *u, uid_t uid, gid_t gid);
 647 void unit_unref_uid_gid(Unit *u, bool destroy_now);
 648
 649 void unit_notify_user_lookup(Unit *u, uid_t uid, gid_t gid);
 650
 651 int unit_set_invocation_id(Unit *u, sd_id128_t id);
 652 int unit_acquire_invocation_id(Unit *u);
 653
 654 /* Macros which append UNIT= or USER_UNIT= to the message */
 655
 656 #define log_unit_full(unit, level, error, ...)                          \
 657         ({                                                              \
 658                 const Unit *_u = (unit);                                \
 659                 _u ? log_object_internal(level, error, __FILE__, __LINE__, __func__, _u->manager->unit_log_field, _u->id, _u->manager->invocation_log_field, _u->invocation_id_string, ##__VA_ARGS__) : \
 660                         log_internal(level, error, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
 661         })
 662
 663 #define log_unit_debug(unit, ...)   log_unit_full(unit, LOG_DEBUG, 0, ##__VA_ARGS__)
 664 #define log_unit_info(unit, ...)    log_unit_full(unit, LOG_INFO, 0, ##__VA_ARGS__)
 665 #define log_unit_notice(unit, ...)  log_unit_full(unit, LOG_NOTICE, 0, ##__VA_ARGS__)
 666 #define log_unit_warning(unit, ...) log_unit_full(unit, LOG_WARNING, 0, ##__VA_ARGS__)
 667 #define log_unit_error(unit, ...)   log_unit_full(unit, LOG_ERR, 0, ##__VA_ARGS__)
 668
 669 #define log_unit_debug_errno(unit, error, ...)   log_unit_full(unit, LOG_DEBUG, error, ##__VA_ARGS__)
 670 #define log_unit_info_errno(unit, error, ...)    log_unit_full(unit, LOG_INFO, error, ##__VA_ARGS__)
 671 #define log_unit_notice_errno(unit, error, ...)  log_unit_full(unit, LOG_NOTICE, error, ##__VA_ARGS__)
 672 #define log_unit_warning_errno(unit, error, ...) log_unit_full(unit, LOG_WARNING, error, ##__VA_ARGS__)
 673 #define log_unit_error_errno(unit, error, ...)   log_unit_full(unit, LOG_ERR, error, ##__VA_ARGS__)
 674
 675 #define LOG_UNIT_MESSAGE(unit, fmt, ...) "MESSAGE=%s: " fmt, (unit)->id, ##__VA_ARGS__
 676 #define LOG_UNIT_ID(unit) (unit)->manager->unit_log_format_string, (unit)->id