]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/unit.h
Add build/unit-tests CI jobs for s390x (#38232)
[thirdparty/systemd.git] / src / core / unit.h
CommitLineData
db9ecf05 1/* SPDX-License-Identifier: LGPL-2.1-or-later */
c2f1db8f 2#pragma once
87f0e418 3
2d3b784d
ZJS
4#include "sd-id128.h"
5
836e4e7e 6#include "core-forward.h"
87a47f99 7#include "emergency-action.h"
4ea4abb6 8#include "execute.h"
836e4e7e 9#include "hashmap.h"
e77e07f6 10#include "install.h"
836e4e7e 11#include "iterator.h"
4ea4abb6 12#include "job.h"
71d35b6b 13#include "list.h"
836e4e7e 14#include "log.h"
a4bff6ef 15#include "log-context.h"
4ea4abb6 16#include "ratelimit.h"
836e4e7e
DDM
17#include "time-util.h"
18#include "unit-def.h"
19#include "unit-dependency-atom.h"
5cfa33e0 20#include "unit-file.h"
87f0e418 21
4ea4abb6
DDM
22typedef enum UnitMountDependencyType {
23 UNIT_MOUNT_WANTS,
24 UNIT_MOUNT_REQUIRES,
25 _UNIT_MOUNT_DEPENDENCY_TYPE_MAX,
26 _UNIT_MOUNT_DEPENDENCY_TYPE_INVALID = -EINVAL,
27} UnitMountDependencyType;
28
db2cb23b
UTL
29typedef enum KillOperation {
30 KILL_TERMINATE,
1d98fef1 31 KILL_TERMINATE_AND_LOG,
a232ebcc 32 KILL_RESTART,
db2cb23b 33 KILL_KILL,
c87700a1 34 KILL_WATCHDOG,
4940c0b0 35 _KILL_OPERATION_MAX,
2d93c20e 36 _KILL_OPERATION_INVALID = -EINVAL,
db2cb23b
UTL
37} KillOperation;
38
5afe510c
LP
39typedef enum CollectMode {
40 COLLECT_INACTIVE,
41 COLLECT_INACTIVE_OR_FAILED,
42 _COLLECT_MODE_MAX,
2d93c20e 43 _COLLECT_MODE_INVALID = -EINVAL,
5afe510c
LP
44} CollectMode;
45
4ea4abb6
DDM
46typedef enum OOMPolicy {
47 OOM_CONTINUE, /* The kernel or systemd-oomd kills the process it wants to kill, and that's it */
48 OOM_STOP, /* The kernel or systemd-oomd kills the process it wants to kill, and we stop the unit */
49 OOM_KILL, /* The kernel or systemd-oomd kills the process it wants to kill, and all others in the unit, and we stop the unit */
50 _OOM_POLICY_MAX,
51 _OOM_POLICY_INVALID = -EINVAL,
52} OOMPolicy;
53
54typedef enum StatusType {
55 STATUS_TYPE_EPHEMERAL,
56 STATUS_TYPE_NORMAL,
57 STATUS_TYPE_NOTICE,
58 STATUS_TYPE_EMERGENCY,
59} StatusType;
60
87f0e418 61static inline bool UNIT_IS_ACTIVE_OR_RELOADING(UnitActiveState t) {
5162829e 62 return IN_SET(t, UNIT_ACTIVE, UNIT_RELOADING, UNIT_REFRESHING);
87f0e418
LP
63}
64
65static inline bool UNIT_IS_ACTIVE_OR_ACTIVATING(UnitActiveState t) {
5162829e 66 return IN_SET(t, UNIT_ACTIVE, UNIT_ACTIVATING, UNIT_RELOADING, UNIT_REFRESHING);
87f0e418
LP
67}
68
69static inline bool UNIT_IS_INACTIVE_OR_DEACTIVATING(UnitActiveState t) {
3742095b 70 return IN_SET(t, UNIT_INACTIVE, UNIT_FAILED, UNIT_DEACTIVATING);
6124958c
LP
71}
72
fdf20a31 73static inline bool UNIT_IS_INACTIVE_OR_FAILED(UnitActiveState t) {
3742095b 74 return IN_SET(t, UNIT_INACTIVE, UNIT_FAILED);
87f0e418
LP
75}
76
0377cd29 77static inline bool UNIT_IS_LOAD_COMPLETE(UnitLoadState t) {
2d51ea22 78 return t >= 0 && t < _UNIT_LOAD_STATE_MAX && !IN_SET(t, UNIT_STUB, UNIT_MERGED);
0377cd29
LP
79}
80
dc4c5871
MY
81static inline bool UNIT_IS_LOAD_ERROR(UnitLoadState t) {
82 return IN_SET(t, UNIT_NOT_FOUND, UNIT_BAD_SETTING, UNIT_ERROR);
83}
84
eef85c4a
LP
85/* Stores the 'reason' a dependency was created as a bit mask, i.e. due to which configuration source it came to be. We
86 * use this so that we can selectively flush out parts of dependencies again. Note that the same dependency might be
87 * created as a result of multiple "reasons", hence the bitmask. */
88typedef enum UnitDependencyMask {
5238e957 89 /* Configured directly by the unit file, .wants/.requires symlink or drop-in, or as an immediate result of a
eef85c4a
LP
90 * non-dependency option configured that way. */
91 UNIT_DEPENDENCY_FILE = 1 << 0,
92
93 /* As unconditional implicit dependency (not affected by unit configuration — except by the unit name and
94 * type) */
95 UNIT_DEPENDENCY_IMPLICIT = 1 << 1,
96
4db8663b 97 /* A dependency affected by DefaultDependencies=yes. Note that dependencies marked this way are conceptually
eef85c4a
LP
98 * just a subset of UNIT_DEPENDENCY_FILE, as DefaultDependencies= is itself a unit file setting that can only
99 * be set in unit files. We make this two separate bits only to help debugging how dependencies came to be. */
100 UNIT_DEPENDENCY_DEFAULT = 1 << 2,
101
102 /* A dependency created from udev rules */
103 UNIT_DEPENDENCY_UDEV = 1 << 3,
104
105 /* A dependency created because of some unit's RequiresMountsFor= setting */
106 UNIT_DEPENDENCY_PATH = 1 << 4,
107
87c734ee
FB
108 /* A dependency initially configured from the mount unit file however the dependency will be updated
109 * from /proc/self/mountinfo as soon as the kernel will make the entry for that mount available in
110 * the /proc file */
111 UNIT_DEPENDENCY_MOUNT_FILE = 1 << 5,
112
113 /* A dependency created or updated because of data read from /proc/self/mountinfo */
114 UNIT_DEPENDENCY_MOUNTINFO = 1 << 6,
49267b1b 115
eef85c4a 116 /* A dependency created because of data read from /proc/swaps and no other configuration source */
87c734ee 117 UNIT_DEPENDENCY_PROC_SWAP = 1 << 7,
eef85c4a 118
899acf5c 119 /* A dependency for units in slices assigned by directly setting Slice= */
87c734ee 120 UNIT_DEPENDENCY_SLICE_PROPERTY = 1 << 8,
899acf5c 121
87c734ee 122 _UNIT_DEPENDENCY_MASK_FULL = (1 << 9) - 1,
eef85c4a
LP
123} UnitDependencyMask;
124
125/* The Unit's dependencies[] hashmaps use this structure as value. It has the same size as a void pointer, and thus can
126 * be stored directly as hashmap value, without any indirection. Note that this stores two masks, as both the origin
127 * and the destination of a dependency might have created it. */
128typedef union UnitDependencyInfo {
129 void *data;
130 struct {
131 UnitDependencyMask origin_mask:16;
132 UnitDependencyMask destination_mask:16;
133 } _packed_;
134} UnitDependencyInfo;
135
48b92b37
LB
136/* Store information about why a unit was activated.
137 * We start with trigger units (.path/.timer), eventually it will be expanded to include more metadata. */
138typedef struct ActivationDetails {
139 unsigned n_ref;
140 UnitType trigger_unit_type;
141 char *trigger_unit_name;
142} ActivationDetails;
143
144/* For casting an activation event into the various unit-specific types */
145#define DEFINE_ACTIVATION_DETAILS_CAST(UPPERCASE, MixedCase, UNIT_TYPE) \
acca52ab 146 static inline MixedCase* UPPERCASE(const ActivationDetails *a) { \
48b92b37
LB
147 if (_unlikely_(!a || a->trigger_unit_type != UNIT_##UNIT_TYPE)) \
148 return NULL; \
149 \
150 return (MixedCase*) a; \
151 }
152
153/* For casting the various unit types into a unit */
154#define ACTIVATION_DETAILS(u) \
155 ({ \
156 typeof(u) _u_ = (u); \
157 ActivationDetails *_w_ = _u_ ? &(_u_)->meta : NULL; \
158 _w_; \
159 })
160
161ActivationDetails *activation_details_new(Unit *trigger_unit);
162ActivationDetails *activation_details_ref(ActivationDetails *p);
163ActivationDetails *activation_details_unref(ActivationDetails *p);
acca52ab 164void activation_details_serialize(const ActivationDetails *p, FILE *f);
48b92b37 165int activation_details_deserialize(const char *key, const char *value, ActivationDetails **info);
acca52ab
DDM
166int activation_details_append_env(const ActivationDetails *info, char ***strv);
167int activation_details_append_pair(const ActivationDetails *info, char ***strv);
48b92b37
LB
168DEFINE_TRIVIAL_CLEANUP_FUNC(ActivationDetails*, activation_details_unref);
169
170typedef struct ActivationDetailsVTable {
171 /* How much memory does an object of this activation type need */
172 size_t object_size;
173
174 /* This should reset all type-specific variables. This should not allocate memory, and is called
175 * with zero-initialized data. It should hence only initialize variables that need to be set != 0. */
176 void (*init)(ActivationDetails *info, Unit *trigger_unit);
177
178 /* This should free all type-specific variables. It should be idempotent. */
179 void (*done)(ActivationDetails *info);
180
181 /* This should serialize all type-specific variables. */
acca52ab 182 void (*serialize)(const ActivationDetails *info, FILE *f);
48b92b37
LB
183
184 /* This should deserialize all type-specific variables, one at a time. */
185 int (*deserialize)(const char *key, const char *value, ActivationDetails **info);
186
187 /* This should format the type-specific variables for the env block of the spawned service,
188 * and return the number of added items. */
acca52ab 189 int (*append_env)(const ActivationDetails *info, char ***strv);
48b92b37
LB
190
191 /* This should append type-specific variables as key/value pairs for the D-Bus property of the job,
192 * and return the number of added pairs. */
acca52ab 193 int (*append_pair)(const ActivationDetails *info, char ***strv);
48b92b37
LB
194} ActivationDetailsVTable;
195
196extern const ActivationDetailsVTable * const activation_details_vtable[_UNIT_TYPE_MAX];
197
198static inline const ActivationDetailsVTable* ACTIVATION_DETAILS_VTABLE(const ActivationDetails *a) {
199 assert(a);
200 assert(a->trigger_unit_type < _UNIT_TYPE_MAX);
201
202 return activation_details_vtable[a->trigger_unit_type];
203}
204
15ed3c3a
LP
205/* Newer LLVM versions don't like implicit casts from large pointer types to smaller enums, hence let's add
206 * explicit type-safe helpers for that. */
207static inline UnitDependency UNIT_DEPENDENCY_FROM_PTR(const void *p) {
208 return PTR_TO_INT(p);
209}
210
211static inline void* UNIT_DEPENDENCY_TO_PTR(UnitDependency d) {
212 return INT_TO_PTR(d);
213}
214
836e4e7e 215typedef struct UnitRef {
a016b922
LP
216 /* Keeps tracks of references to a unit. This is useful so
217 * that we can merge two units if necessary and correct all
218 * references to them */
219
7f7d01ed
ZJS
220 Unit *source, *target;
221 LIST_FIELDS(UnitRef, refs_by_target);
836e4e7e 222} UnitRef;
a016b922 223
9cc54544 224/* The generic, dynamic definition of the unit */
57b7a260 225typedef struct Unit {
87f0e418 226 Manager *manager;
23a177ef 227
87f0e418
LP
228 UnitType type;
229 UnitLoadState load_state;
23a177ef 230 Unit *merged_into;
87f0e418 231
4562c355 232 char *id; /* The one special name that we use for identification */
9e2f7c11 233 char *instance;
87f0e418 234
4562c355 235 Set *aliases; /* All the other names. */
87f0e418 236
15ed3c3a
LP
237 /* For each dependency type we can look up another Hashmap with this, whose key is a Unit* object,
238 * and whose value encodes why the dependency exists, using the UnitDependencyInfo type. i.e. a
239 * Hashmap(UnitDependency → Hashmap(Unit* → UnitDependencyInfo)) */
240 Hashmap *dependencies;
b7777d08 241 uint64_t dependency_generation;
eef85c4a 242
9e615fa3
LB
243 /* Similar, for RequiresMountsFor= and WantsMountsFor= path dependencies. The key is the path, the
244 * value the UnitDependencyInfo type */
245 Hashmap *mounts_for[_UNIT_MOUNT_DEPENDENCY_TYPE_MAX];
7c8fa05c 246
87f0e418 247 char *description;
49dbfa7b 248 char **documentation;
faf919f1 249
23e9a7dd
LP
250 /* The SELinux context used for checking access to this unit read off the unit file at load time (do
251 * not confuse with the selinux_context field in ExecContext which is the SELinux context we'll set
252 * for processes) */
253 char *access_selinux_context;
254
6be1e7d5 255 char *fragment_path; /* if loaded from a config file this is the primary path to it */
1b64d026 256 char *source_path; /* if converted, the source file */
ae7a7182 257 char **dropin_paths;
f78f265f 258
c2911d48 259 usec_t fragment_not_found_timestamp_hash;
45fb0699 260 usec_t fragment_mtime;
1b64d026 261 usec_t source_mtime;
ae7a7182 262 usec_t dropin_mtime;
87f0e418 263
4f4afc88
LP
264 /* If this is a transient unit we are currently writing, this is where we are writing it to */
265 FILE *transient_file;
266
8c2524c7 267 /* Freezer state */
af1e3365 268 sd_bus_message *pending_freezer_invocation;
8c2524c7
ZJS
269 FreezerState freezer_state;
270
271 /* Job timeout and action to take */
272 EmergencyAction job_timeout_action;
273 usec_t job_timeout;
274 usec_t job_running_timeout;
275 char *job_timeout_reboot_arg;
276
e0209d83 277 /* If there is something to do with this unit, then this is the installed job for it */
87f0e418
LP
278 Job *job;
279
e0209d83
MS
280 /* JOB_NOP jobs are special and can be installed without disturbing the real job. */
281 Job *nop_job;
282
bbc29086
DM
283 /* The slot used for watching NameOwnerChanged signals */
284 sd_bus_slot *match_bus_slot;
a5a8776a 285 sd_bus_slot *get_name_owner_slot;
bbc29086 286
05a98afd
LP
287 /* References to this unit from clients */
288 sd_bus_track *bus_track;
289 char **deserialized_refs;
290
57020a3a 291 /* References to this */
7f7d01ed 292 LIST_HEAD(UnitRef, refs_by_target);
57020a3a 293
52661efd
LP
294 /* Conditions to check */
295 LIST_HEAD(Condition, conditions);
59fccdc5 296 LIST_HEAD(Condition, asserts);
52661efd 297
90bbc946 298 dual_timestamp condition_timestamp;
59fccdc5 299 dual_timestamp assert_timestamp;
90bbc946 300
a483fb59
LP
301 /* Updated whenever the low-level state changes */
302 dual_timestamp state_change_timestamp;
303
304 /* Updated whenever the (high-level) active state enters or leaves the active or inactive states */
63983207
LP
305 dual_timestamp inactive_exit_timestamp;
306 dual_timestamp active_enter_timestamp;
307 dual_timestamp active_exit_timestamp;
308 dual_timestamp inactive_enter_timestamp;
87f0e418 309
ef734fd6 310 /* Per type list */
ac155bb8 311 LIST_FIELDS(Unit, units_by_type);
c1e1601e 312
701cc384 313 /* Load queue */
ac155bb8 314 LIST_FIELDS(Unit, load_queue);
701cc384 315
c1e1601e 316 /* D-Bus queue */
ac155bb8 317 LIST_FIELDS(Unit, dbus_queue);
23a177ef
LP
318
319 /* Cleanup queue */
ac155bb8 320 LIST_FIELDS(Unit, cleanup_queue);
9d58f1db 321
701cc384 322 /* GC queue */
ac155bb8 323 LIST_FIELDS(Unit, gc_queue);
701cc384 324
4ad49000 325 /* CGroup realize members queue */
91a6073e 326 LIST_FIELDS(Unit, cgroup_realize_queue);
4ad49000 327
09e24654
LP
328 /* cgroup empty queue */
329 LIST_FIELDS(Unit, cgroup_empty_queue);
330
afcfaa69
LP
331 /* cgroup OOM queue */
332 LIST_FIELDS(Unit, cgroup_oom_queue);
333
19496554
MS
334 /* Target dependencies queue */
335 LIST_FIELDS(Unit, target_deps_queue);
336
0bc488c9 337 /* Queue of units with StopWhenUnneeded= set that shall be checked for clean-up. */
a3c1168a
LP
338 LIST_FIELDS(Unit, stop_when_unneeded_queue);
339
0bc488c9
LP
340 /* Queue of units that have an Uphold= dependency from some other unit, and should be checked for starting */
341 LIST_FIELDS(Unit, start_when_upheld_queue);
342
56c59592
LP
343 /* Queue of units that have a BindTo= dependency on some other unit, and should possibly be shut down */
344 LIST_FIELDS(Unit, stop_when_bound_queue);
345
6ac62d61
LP
346 /* Queue of units that should be checked if they can release resources now */
347 LIST_FIELDS(Unit, release_resources_queue);
348
1b4ab5a2
MY
349 /* Queue of units that should be informed when other units stop */
350 LIST_FIELDS(Unit, stop_notify_queue);
351
495e75ed
LP
352 /* PIDs we keep an eye on. Note that a unit might have many more, but these are the ones we care
353 * enough about to process SIGCHLD for */
354 Set *pids; /* → PidRef* */
a911bb9a 355
62a76913
LP
356 /* Used in SIGCHLD and sd_notify() message event invocation logic to avoid that we dispatch the same event
357 * multiple times on the same unit. */
358 unsigned sigchldgen;
359 unsigned notifygen;
36f20ae3 360
701cc384 361 /* Used during GC sweeps */
eced69b3 362 unsigned gc_marker;
701cc384 363
8821a00f
LP
364 /* Error code when we didn't manage to load the unit (negative) */
365 int load_error;
366
6bf0f408 367 /* Put a ratelimit on unit starting */
7bf081a1 368 RateLimit start_ratelimit;
87a47f99 369 EmergencyAction start_limit_action;
53c35a76 370
ff68472a
ZJS
371 /* The unit has been marked for reload, restart, etc. Stored as 1u << marker1 | 1u << marker2. */
372 unsigned markers;
373
7af67e9a
LP
374 /* What to do on failure or success */
375 EmergencyAction success_action, failure_action;
376 int success_action_exit_status, failure_action_exit_status;
6bf0f408
LP
377 char *reboot_arg;
378
0bc488c9
LP
379 /* Make sure we never enter endless loops with the StopWhenUnneeded=, BindsTo=, Uphold= logic */
380 RateLimit auto_start_stop_ratelimit;
7223d500 381 sd_event_source *auto_start_stop_event_source;
bea355da 382
00d9ef85
LP
383 /* Reference to a specific UID/GID */
384 uid_t ref_uid;
385 gid_t ref_gid;
386
d2dc52db 387 /* Cached unit file state and preset */
a4375746 388 UnitFileState unit_file_state;
e77e07f6 389 PresetAction unit_file_preset;
a4375746 390
294446dc
LP
391 /* How to start OnSuccess=/OnFailure= units */
392 JobMode on_success_job_mode;
7c52a17b
ZJS
393 JobMode on_failure_job_mode;
394
48b92b37
LB
395 /* If the job had a specific trigger that needs to be advertised (eg: a path unit), store it. */
396 ActivationDetails *activation_details;
397
5afe510c
LP
398 /* Tweaking the GC logic */
399 CollectMode collect_mode;
400
4b58153d
LP
401 /* The current invocation ID */
402 sd_id128_t invocation_id;
403 char invocation_id_string[SD_ID128_STRING_MAX]; /* useful when logging */
404
9d58f1db
LP
405 /* Garbage collect us we nobody wants or requires us anymore */
406 bool stop_when_unneeded;
407
35b8ca3a 408 /* Create default dependencies */
a40eb732
LP
409 bool default_dependencies;
410
559214cb
LB
411 /* Configure so that the unit survives a system transition without stopping/starting. */
412 bool survive_final_kill_signal;
413
b5e9dba8
LP
414 /* Refuse manual starting, allow starting only indirectly via dependency. */
415 bool refuse_manual_start;
416
417 /* Don't allow the user to stop this unit manually, allow stopping only indirectly via dependency. */
418 bool refuse_manual_stop;
419
2528a7a6
LP
420 /* Allow isolation requests */
421 bool allow_isolate;
422
c8f4d764
LP
423 /* Ignore this unit when isolating */
424 bool ignore_on_isolate;
425
49f43d5f 426 /* Did the last condition check succeed? */
90bbc946 427 bool condition_result;
59fccdc5 428 bool assert_result;
90bbc946 429
c2756a68
LP
430 /* Is this a transient unit? */
431 bool transient;
432
f5869324
LP
433 /* Is this a unit that is always running and cannot be stopped? */
434 bool perpetual;
435
7d8bbfbe
LB
436 /* When true logs about this unit will be at debug level regardless of other log level settings */
437 bool debug_invocation;
438
66fa4bdd 439 /* Booleans indicating membership of this unit in the various queues */
9d58f1db
LP
440 bool in_load_queue:1;
441 bool in_dbus_queue:1;
442 bool in_cleanup_queue:1;
701cc384 443 bool in_gc_queue:1;
91a6073e 444 bool in_cgroup_realize_queue:1;
09e24654 445 bool in_cgroup_empty_queue:1;
afcfaa69 446 bool in_cgroup_oom_queue:1;
19496554 447 bool in_target_deps_queue:1;
a3c1168a 448 bool in_stop_when_unneeded_queue:1;
0bc488c9 449 bool in_start_when_upheld_queue:1;
56c59592 450 bool in_stop_when_bound_queue:1;
6ac62d61 451 bool in_release_resources_queue:1;
1b4ab5a2 452 bool in_stop_notify_queue:1;
701cc384 453
9d58f1db 454 bool sent_dbus_new_signal:1;
6c073082 455
8c2524c7
ZJS
456 bool job_running_timeout_set:1;
457
cd6d0a45 458 bool in_audit:1;
adefcf28 459 bool on_console:1;
a57f7e2c 460
6bf0f408
LP
461 bool start_limit_hit:1;
462
f78f265f 463 /* Did we already invoke unit_coldplug() for this unit? */
f8a30ce5 464 bool coldplugged:1;
05a98afd
LP
465
466 /* For transient units: whether to add a bus track reference after creating the unit */
467 bool bus_track_add:1;
d3070fbd
LP
468
469 /* Remember which unit state files we created */
470 bool exported_invocation_id:1;
471 bool exported_log_level_max:1;
472 bool exported_log_extra_fields:1;
5ac1530e
ZJS
473 bool exported_log_ratelimit_interval:1;
474 bool exported_log_ratelimit_burst:1;
2e59b241
LP
475
476 /* When writing transient unit files, stores which section we stored last. If < 0, we didn't write any yet. If
477 * == 0 we are in the [Unit] section, if > 0 we are in the unit type-specific section. */
845d247a 478 signed int last_section_private:2;
57b7a260 479} Unit;
87f0e418 480
57b7a260 481typedef struct UnitStatusMessageFormats {
c6918296
MS
482 const char *starting_stopping[2];
483 const char *finished_start_job[_JOB_RESULT_MAX];
484 const char *finished_stop_job[_JOB_RESULT_MAX];
eda0cbf0
ZJS
485 /* If this entry is present, it'll be called to provide a context-dependent format string,
486 * or NULL to fall back to finished_{start,stop}_job; if those are NULL too, fall back to generic. */
487 const char *(*finished_job)(Unit *u, JobType t, JobResult result);
57b7a260 488} UnitStatusMessageFormats;
c6918296 489
2e59b241
LP
490/* Flags used when writing drop-in files or transient unit files */
491typedef enum UnitWriteFlags {
492 /* Write a runtime unit file or drop-in (i.e. one below /run) */
f3af6290 493 UNIT_RUNTIME = 1 << 0,
2e59b241
LP
494
495 /* Write a persistent drop-in (i.e. one below /etc) */
f3af6290 496 UNIT_PERSISTENT = 1 << 1,
2e59b241
LP
497
498 /* Place this item in the per-unit-type private section, instead of [Unit] */
f3af6290 499 UNIT_PRIVATE = 1 << 2,
2e59b241 500
f3af6290
ZJS
501 /* Apply specifier escaping */
502 UNIT_ESCAPE_SPECIFIERS = 1 << 3,
24536beb 503
f3af6290
ZJS
504 /* Escape elements of ExecStart= syntax, incl. prevention of variable expansion */
505 UNIT_ESCAPE_EXEC_SYNTAX_ENV = 1 << 4,
2e59b241 506
8c41640a
ZJS
507 /* Escape elements of ExecStart=: syntax (no variable expansion) */
508 UNIT_ESCAPE_EXEC_SYNTAX = 1 << 5,
2e59b241
LP
509
510 /* Apply C escaping before writing */
8c41640a 511 UNIT_ESCAPE_C = 1 << 6,
2e59b241
LP
512} UnitWriteFlags;
513
514/* Returns true if neither persistent, nor runtime storage is requested, i.e. this is a check invocation only */
6529ccfa
LP
515static inline bool UNIT_WRITE_FLAGS_NOOP(UnitWriteFlags flags) {
516 return (flags & (UNIT_RUNTIME|UNIT_PERSISTENT)) == 0;
517}
8e2af478 518
57b7a260
FS
519#include "kill.h"
520
9cc54544 521/* The static const, immutable data about a specific unit type */
57b7a260 522typedef struct UnitVTable {
7d17cfbc
MS
523 /* How much memory does an object of this unit type need */
524 size_t object_size;
525
3ef63c31
LP
526 /* If greater than 0, the offset into the object where
527 * ExecContext is found, if the unit type has that */
528 size_t exec_context_offset;
529
4ad49000
LP
530 /* If greater than 0, the offset into the object where
531 * CGroupContext is found, if the unit type has that */
532 size_t cgroup_context_offset;
533
718db961
LP
534 /* If greater than 0, the offset into the object where
535 * KillContext is found, if the unit type has that */
536 size_t kill_context_offset;
537
9cc54544
LP
538 /* If greater than 0, the offset into the object where the pointer to ExecRuntime is found, if
539 * the unit type has that */
613b411c
LP
540 size_t exec_runtime_offset;
541
9cc54544
LP
542 /* If greater than 0, the offset into the object where the pointer to CGroupRuntime is found, if the
543 * unit type has that */
544 size_t cgroup_runtime_offset;
545
ee33e53a 546 /* The name of the configuration file section with the private settings of this unit */
4ad49000 547 const char *private_section;
71645aca 548
f975e971
LP
549 /* Config file sections this unit type understands, separated
550 * by NUL chars */
551 const char *sections;
552
e537352b 553 /* This should reset all type-specific variables. This should
a16e1123
LP
554 * not allocate memory, and is called with zero-initialized
555 * data. It should hence only initialize variables that need
556 * to be set != 0. */
e537352b
LP
557 void (*init)(Unit *u);
558
a16e1123
LP
559 /* This should free all type-specific variables. It should be
560 * idempotent. */
561 void (*done)(Unit *u);
562
e537352b
LP
563 /* Actually load data from disk. This may fail, and should set
564 * load_state to UNIT_LOADED, UNIT_MERGED or leave it at
565 * UNIT_STUB if no configuration could be found. */
566 int (*load)(Unit *u);
567
f0831ed2 568 /* During deserialization we only record the intended state to return to. With coldplug() we actually put the
a95c0505
LP
569 * deserialized state in effect. This is where unit_notify() should be called to start things up. Note that
570 * this callback is invoked *before* we leave the reloading state of the manager, i.e. *before* we consider the
571 * reloading to be complete. Thus, this callback should just restore the exact same state for any unit that was
572 * in effect before the reload, i.e. units should not catch up with changes happened during the reload. That's
573 * what catchup() below is for. */
be847e82 574 int (*coldplug)(Unit *u);
87f0e418 575
a95c0505
LP
576 /* This is called shortly after all units' coldplug() call was invoked, and *after* the manager left the
577 * reloading state. It's supposed to catch up with state changes due to external events we missed so far (for
578 * example because they took place while we were reloading/reexecing) */
f0831ed2
LP
579 void (*catchup)(Unit *u);
580
87f0e418
LP
581 void (*dump)(Unit *u, FILE *f, const char *prefix);
582
583 int (*start)(Unit *u);
584 int (*stop)(Unit *u);
585 int (*reload)(Unit *u);
586
380dc8b0
LP
587 /* Clear out the various runtime/state/cache/logs/configuration data */
588 int (*clean)(Unit *u, ExecCleanMask m);
589
16b6af6a
AV
590 /* Freeze or thaw the unit. Returns > 0 to indicate that the request will be handled asynchronously; unit_frozen
591 * or unit_thawed should be called once the operation is done. Returns 0 if done successfully, or < 0 on error. */
592 int (*freezer_action)(Unit *u, FreezerAction a);
b21bebbe 593 bool (*can_freeze)(const Unit *u);
d9e45bc3 594
380dc8b0
LP
595 /* Return which kind of data can be cleaned */
596 int (*can_clean)(Unit *u, ExecCleanMask *ret);
597
87f0e418
LP
598 bool (*can_reload)(Unit *u);
599
5162829e
LB
600 /* Add a bind/image mount into the unit namespace while it is running. */
601 int (*live_mount)(Unit *u, const char *src, const char *dst, sd_bus_message *message, MountInNamespaceFlags flags, const MountOptions *options, sd_bus_error *error);
f19afb21 602 int (*can_live_mount)(Unit *u, sd_bus_error *error);
5162829e 603
1ece068e
ZJS
604 /* Serialize state and file descriptors that should be carried over into the new
605 * instance after reexecution. */
a16e1123
LP
606 int (*serialize)(Unit *u, FILE *f, FDSet *fds);
607
608 /* Restore one item from the serialization */
609 int (*deserialize_item)(Unit *u, const char *key, const char *data, FDSet *fds);
610
01e10de3 611 /* Try to match up fds with what we need for this unit */
9ff1a6f1 612 void (*distribute_fds)(Unit *u, FDSet *fds);
01e10de3 613
87f0e418
LP
614 /* Boils down the more complex internal state of this unit to
615 * a simpler one that the engine can understand */
616 UnitActiveState (*active_state)(Unit *u);
617
10a94420
LP
618 /* Returns the substate specific to this unit type as
619 * string. This is purely information so that we can give the
35b8ca3a 620 * user a more fine grained explanation in which actual state a
10a94420
LP
621 * unit is in. */
622 const char* (*sub_state_to_string)(Unit *u);
623
deb4e708
MK
624 /* Additionally to UnitActiveState determine whether unit is to be restarted. */
625 bool (*will_restart)(Unit *u);
626
f2f725e5
ZJS
627 /* Return false when there is a reason to prevent this unit from being gc'ed
628 * even though nothing references it and it isn't active in any way. */
629 bool (*may_gc)(Unit *u);
701cc384 630
39c79477
ZJS
631 /* Return true when the unit is not controlled by the manager (e.g. extrinsic mounts). */
632 bool (*is_extrinsic)(Unit *u);
633
7eb2a8a1
LP
634 /* When the unit is not running and no job for it queued we shall release its runtime resources */
635 void (*release_resources)(Unit *u);
a354329f 636
718db961 637 /* Invoked on every child that died */
87f0e418 638 void (*sigchld_event)(Unit *u, pid_t pid, int code, int status);
7824bbeb 639
fdf20a31
MM
640 /* Reset failed state if we are in failed state */
641 void (*reset_failed)(Unit *u);
5632e374 642
afcfaa69 643 /* Called whenever any of the cgroups this unit watches for ran empty */
4ad49000 644 void (*notify_cgroup_empty)(Unit *u);
8e274523 645
afcfaa69 646 /* Called whenever an OOM kill event on this unit was seen */
38c41427 647 void (*notify_cgroup_oom)(Unit *u, bool managed_oom);
afcfaa69 648
8c47c732 649 /* Called whenever a process of this unit sends us a message */
19eccb76 650 void (*notify_message)(Unit *u, PidRef *pidref, const struct ucred *ucred, char * const *tags, FDSet *fds);
8c47c732 651
817062e6
LP
652 /* Called whenever we learn a handoff timestamp */
653 void (*notify_handoff_timestamp)(Unit *u, const struct ucred *ucred, const dual_timestamp *ts);
654
406f1775
DDM
655 /* Called whenever we learn about a child process */
656 void (*notify_pidref)(Unit *u, PidRef *parent_pidref, PidRef *child_pidref);
657
00d9ef85 658 /* Called whenever a name this Unit registered for comes or goes away. */
fc67a943 659 void (*bus_name_owner_change)(Unit *u, const char *new_owner);
05e343b7 660
8e2af478 661 /* Called for each property that is being set */
2e59b241 662 int (*bus_set_property)(Unit *u, const char *name, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
8e2af478
LP
663
664 /* Called after at least one property got changed to apply the necessary change */
665 int (*bus_commit_properties)(Unit *u);
666
a7f241db 667 /* Return the unit this unit is following */
f19afb21 668 Unit* (*following)(Unit *u);
a7f241db 669
6210e7fc
LP
670 /* Return the set of units that are following each other */
671 int (*following_set)(Unit *u, Set **s);
672
3ecaa09b
LP
673 /* Invoked each time a unit this unit is triggering changes
674 * state or gains/loses a job */
675 void (*trigger_notify)(Unit *u, Unit *trigger);
676
1b4ab5a2
MY
677 /* Invoked when some other units stop */
678 bool (*stop_notify)(Unit *u);
679
8742514c
LP
680 /* Called whenever CLOCK_REALTIME made a jump */
681 void (*time_change)(Unit *u);
682
bbf5fd8e
LP
683 /* Called whenever /etc/localtime was modified */
684 void (*timezone_change)(Unit *u);
685
7a7821c8
LP
686 /* Returns the next timeout of a unit */
687 int (*get_timeout)(Unit *u, usec_t *timeout);
68db7a3b 688
f5a9d2ee 689 /* Returns the start timeout of a unit */
690 usec_t (*get_timeout_start_usec)(Unit *u);
691
28364bc3 692 /* Returns the main PID if there is any defined, or NULL. */
3e22239d 693 PidRef* (*main_pid)(Unit *u, bool *ret_is_alien);
291d565a 694
28364bc3 695 /* Returns the control PID if there is any defined, or NULL. */
37eb258e 696 PidRef* (*control_pid)(Unit *u);
291d565a 697
bb2c7685
LP
698 /* Returns true if the unit currently needs access to the console */
699 bool (*needs_console)(Unit *u);
700
7af67e9a
LP
701 /* Returns the exit status to propagate in case of FailureAction=exit/SuccessAction=exit; usually returns the
702 * exit code of the "main" process of the service or similar. */
703 int (*exit_status)(Unit *u);
704
5e1669ff
ZJS
705 /* Return a copy of the status string pointer. */
706 const char* (*status_text)(Unit *u);
707
04eb582a
LP
708 /* Like the enumerate() callback further down, but only enumerates the perpetual units, i.e. all units that
709 * unconditionally exist and are always active. The main reason to keep both enumeration functions separate is
710 * philosophical: the state of perpetual units should be put in place by coldplug(), while the state of those
711 * discovered through regular enumeration should be put in place by catchup(), see below. */
712 void (*enumerate_perpetual)(Manager *m);
713
f0831ed2
LP
714 /* This is called for each unit type and should be used to enumerate units already existing in the system
715 * internally and load them. However, everything that is loaded here should still stay in inactive state. It is
04eb582a 716 * the job of the catchup() call above to put the units into the discovered state. */
ba64af90 717 void (*enumerate)(Manager *m);
f50e0a01
LP
718
719 /* Type specific cleanups. */
7824bbeb 720 void (*shutdown)(Manager *m);
9d58f1db 721
cbd4a8df 722 /* If this function is set and returns false all jobs for units
0faacd47 723 * of this type will immediately fail. */
1c2e9646 724 bool (*supported)(void);
0faacd47 725
9727f242
DDM
726 /* If this function is set, it's invoked first as part of starting a unit to allow start rate
727 * limiting checks to occur before we do anything else. */
705578c3 728 int (*can_start)(Unit *u);
9727f242 729
47261967
LP
730 /* Returns > 0 if the whole subsystem is ratelimited, and new start operations should not be started
731 * for this unit type right now. */
732 int (*subsystem_ratelimited)(Manager *m);
733
718db961 734 /* The strings to print in status messages */
c6918296
MS
735 UnitStatusMessageFormats status_message_formats;
736
c2756a68 737 /* True if transient units of this type are OK */
cbd4a8df 738 bool can_transient;
c5a97ed1 739
1d9cc876 740 /* True if cgroup delegation is permissible */
cbd4a8df 741 bool can_delegate;
1d9cc876 742
c80a9a33 743 /* True if the unit type triggers other units, i.e. can have a UNIT_TRIGGERS dependency */
cbd4a8df 744 bool can_trigger;
c80a9a33
LP
745
746 /* True if the unit type knows a failure state, and thus can be source of an OnFailure= dependency */
cbd4a8df 747 bool can_fail;
c80a9a33 748
d4fd1cf2 749 /* True if units of this type shall be startable only once and then never again */
cbd4a8df 750 bool once_only;
d4fd1cf2 751
755021d4
ZJS
752 /* Do not serialize this unit when preparing for root switch */
753 bool exclude_from_switch_root_serialization;
754
c5a97ed1 755 /* True if queued jobs of this type should be GC'ed if no other job needs them anymore */
cbd4a8df 756 bool gc_jobs;
4d824a4e 757
0923b425 758 /* True if systemd-oomd can monitor and act on this unit's recursive children's cgroups */
cbd4a8df 759 bool can_set_managed_oom;
d52b8493 760
b2bfd121
LP
761 /* If true, we'll notify plymouth about this unit */
762 bool notify_plymouth;
763
b2d6bb5b
LP
764 /* If true, we'll notify a surrounding VMM/container manager about this unit becoming available */
765 bool notify_supervisor;
766
d52b8493
LP
767 /* The audit events to generate on start + stop (or 0 if none shall be generated) */
768 int audit_start_message_type;
769 int audit_stop_message_type;
57b7a260 770} UnitVTable;
87f0e418
LP
771
772extern const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX];
773
c2503e35 774static inline const UnitVTable* UNIT_VTABLE(const Unit *u) {
6529ccfa
LP
775 return unit_vtable[u->type];
776}
87f0e418
LP
777
778/* For casting a unit into the various unit types */
779#define DEFINE_CAST(UPPERCASE, MixedCase) \
780 static inline MixedCase* UPPERCASE(Unit *u) { \
ac155bb8 781 if (_unlikely_(!u || u->type != UNIT_##UPPERCASE)) \
87f0e418
LP
782 return NULL; \
783 \
784 return (MixedCase*) u; \
785 }
786
787/* For casting the various unit types into a unit */
bbf11206
LP
788#define UNIT(u) \
789 ({ \
790 typeof(u) _u_ = (u); \
791 Unit *_w_ = _u_ ? &(_u_)->meta : NULL; \
792 _w_; \
793 })
87f0e418 794
35b7ff80
LP
795#define UNIT_HAS_EXEC_CONTEXT(u) (UNIT_VTABLE(u)->exec_context_offset > 0)
796#define UNIT_HAS_CGROUP_CONTEXT(u) (UNIT_VTABLE(u)->cgroup_context_offset > 0)
797#define UNIT_HAS_KILL_CONTEXT(u) (UNIT_VTABLE(u)->kill_context_offset > 0)
798
15ed3c3a
LP
799Unit* unit_has_dependency(const Unit *u, UnitDependencyAtom atom, Unit *other);
800int unit_get_dependency_array(const Unit *u, UnitDependencyAtom atom, Unit ***ret_array);
83123a44 801int unit_get_transitive_dependency_set(Unit *u, UnitDependencyAtom atom, Set **ret);
15ed3c3a
LP
802
803static inline Hashmap* unit_get_dependencies(Unit *u, UnitDependency d) {
804 return hashmap_get(u->dependencies, UNIT_DEPENDENCY_TO_PTR(d));
805}
806
6529ccfa 807static inline Unit* UNIT_TRIGGER(Unit *u) {
15ed3c3a 808 return unit_has_dependency(u, UNIT_ATOM_TRIGGERS, NULL);
6529ccfa 809}
3ecaa09b 810
12f64221 811static inline Unit* UNIT_GET_SLICE(const Unit *u) {
d219a2b0 812 return unit_has_dependency(u, UNIT_ATOM_IN_SLICE, NULL);
12f64221
LP
813}
814
75db809a
ZJS
815Unit* unit_new(Manager *m, size_t size);
816Unit* unit_free(Unit *u);
dc409696 817DEFINE_TRIVIAL_CLEANUP_FUNC(Unit *, unit_free);
87f0e418 818
a581e45a 819int unit_new_for_name(Manager *m, size_t size, const char *name, Unit **ret);
87f0e418 820int unit_add_name(Unit *u, const char *name);
9e2f7c11 821
eef85c4a
LP
822int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference, UnitDependencyMask mask);
823int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference, UnitDependencyMask mask);
2c966c03 824
35d8c19a 825int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, bool add_reference, UnitDependencyMask mask);
5a724170 826int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, bool add_reference, UnitDependencyMask mask);
2c966c03 827
23a177ef
LP
828int unit_add_exec_dependencies(Unit *u, ExecContext *c);
829
0ae97ec1 830int unit_choose_id(Unit *u, const char *name);
f50e0a01 831int unit_set_description(Unit *u, const char *description);
87f0e418 832
6ac62d61
LP
833void unit_release_resources(Unit *u);
834
f2f725e5 835bool unit_may_gc(Unit *u);
701cc384 836
39c79477
ZJS
837static inline bool unit_is_extrinsic(Unit *u) {
838 return u->perpetual ||
839 (UNIT_VTABLE(u)->is_extrinsic && UNIT_VTABLE(u)->is_extrinsic(u));
840}
841
5e1669ff
ZJS
842static inline const char* unit_status_text(Unit *u) {
843 if (u && UNIT_VTABLE(u)->status_text)
844 return UNIT_VTABLE(u)->status_text(u);
845 return NULL;
846}
847
87f0e418 848void unit_add_to_load_queue(Unit *u);
c1e1601e 849void unit_add_to_dbus_queue(Unit *u);
23a177ef 850void unit_add_to_cleanup_queue(Unit *u);
701cc384 851void unit_add_to_gc_queue(Unit *u);
19496554 852void unit_add_to_target_deps_queue(Unit *u);
fda09318 853void unit_submit_to_stop_when_unneeded_queue(Unit *u);
0bc488c9 854void unit_submit_to_start_when_upheld_queue(Unit *u);
56c59592 855void unit_submit_to_stop_when_bound_queue(Unit *u);
6ac62d61 856void unit_submit_to_release_resources_queue(Unit *u);
1b4ab5a2
MY
857void unit_add_to_stop_notify_queue(Unit *u);
858void unit_remove_from_stop_notify_queue(Unit *u);
87f0e418
LP
859
860int unit_merge(Unit *u, Unit *other);
23a177ef
LP
861int unit_merge_by_name(Unit *u, const char *other);
862
44a6b1b6 863Unit *unit_follow_merge(Unit *u) _pure_;
87f0e418 864
c3620770 865int unit_load_fragment_and_dropin(Unit *u, bool fragment_required);
87f0e418
LP
866int unit_load(Unit *unit);
867
899acf5c 868int unit_set_slice(Unit *u, Unit *slice);
d79200e2 869int unit_set_default_slice(Unit *u);
a016b922 870
bfd5a068
ZJS
871const char* unit_description(Unit *u) _pure_;
872const char* unit_status_string(Unit *u, char **combined);
87f0e418 873
303ee601 874bool unit_has_name(const Unit *u, const char *name);
f278026d 875
87f0e418
LP
876UnitActiveState unit_active_state(Unit *u);
877
10a94420
LP
878const char* unit_sub_state_to_string(Unit *u);
879
44a6b1b6
ZJS
880bool unit_can_reload(Unit *u) _pure_;
881bool unit_can_start(Unit *u) _pure_;
f5869324 882bool unit_can_stop(Unit *u) _pure_;
44a6b1b6 883bool unit_can_isolate(Unit *u) _pure_;
87f0e418 884
48b92b37 885int unit_start(Unit *u, ActivationDetails *details);
87f0e418
LP
886int unit_stop(Unit *u);
887int unit_reload(Unit *u);
888
0f23564a 889int unit_kill(Unit *u, KillWhom w, const char *subgroup, int signo, int code, int value, sd_bus_error *ret_error);
8a0867d6 890
38c41427
NK
891void unit_notify_cgroup_oom(Unit *u, bool managed_oom);
892
96b09de5 893void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success);
87f0e418 894
d70dfe1b 895int unit_watch_pidref(Unit *u, const PidRef *pid, bool exclusive);
d70dfe1b 896void unit_unwatch_pidref(Unit *u, const PidRef *pid);
a911bb9a 897void unit_unwatch_all_pids(Unit *u);
ea1e0bf1 898void unit_unwatch_pidref_done(Unit *u, PidRef *pidref);
a911bb9a 899
9806e87d 900int unit_install_bus_match(Unit *u, sd_bus *bus, const char *name);
05e343b7
LP
901int unit_watch_bus_name(Unit *u, const char *name);
902void unit_unwatch_bus_name(Unit *u, const char *name);
903
87f0e418
LP
904bool unit_job_is_applicable(Unit *u, JobType j);
905
6c8ade30 906int setenv_unit_path(const char *p);
0301abf4 907
ff3f2953
ZJS
908char* unit_dbus_path(Unit *u);
909char* unit_dbus_path_invocation_id(Unit *u);
50159e6a 910
f6ff8c29
LP
911int unit_load_related_unit(Unit *u, const char *type, Unit **_found);
912
d336ba9f 913int unit_add_node_dependency(Unit *u, const char *what, UnitDependency d, UnitDependencyMask mask);
44b0d1fd 914int unit_add_blockdev_dependency(Unit *u, const char *what, UnitDependencyMask mask);
6e2ef85b 915
be847e82 916int unit_coldplug(Unit *u);
f0831ed2 917void unit_catchup(Unit *u);
cca098b0 918
04d232d8 919void unit_status_printf(Unit *u, StatusType status_type, const char *status, const char *format, const char *ident) _printf_(4, 0);
9e58ff9c 920
45fb0699
LP
921bool unit_need_daemon_reload(Unit *u);
922
fdf20a31 923void unit_reset_failed(Unit *u);
5632e374 924
a7f241db 925Unit *unit_following(Unit *u);
eeaedb7c 926int unit_following_set(Unit *u, Set **s);
a7f241db 927
bfd5a068 928const char* unit_slice_name(Unit *u);
9444b1f2 929
44a6b1b6
ZJS
930bool unit_stop_pending(Unit *u) _pure_;
931bool unit_inactive_or_pending(Unit *u) _pure_;
31afa0a4 932bool unit_active_or_pending(Unit *u);
52a12341 933bool unit_will_restart_default(Unit *u);
deb4e708 934bool unit_will_restart(Unit *u);
18ffdfda 935
bba34eed
LP
936int unit_add_default_target_dependency(Unit *u, Unit *target);
937
9faeb2d0 938void unit_start_on_termination_deps(Unit *u, UnitDependencyAtom atom);
3ecaa09b 939void unit_trigger_notify(Unit *u);
c0daa706 940
a89afe19
AB
941int unit_get_exec_quota_stats(Unit *u, ExecContext *c, ExecDirectoryType dt, uint64_t *ret_usage, uint64_t *ret_limit);
942
a4375746 943UnitFileState unit_get_unit_file_state(Unit *u);
e77e07f6 944PresetAction unit_get_unit_file_preset(Unit *u);
a4375746 945
7f7d01ed 946Unit* unit_ref_set(UnitRef *ref, Unit *source, Unit *target);
57020a3a
LP
947void unit_ref_unset(UnitRef *ref);
948
7f7d01ed
ZJS
949#define UNIT_DEREF(ref) ((ref).target)
950#define UNIT_ISSET(ref) (!!(ref).target)
57020a3a 951
598459ce 952int unit_patch_contexts(Unit *u);
e06c73cc 953
2234032c
MY
954ExecContext* unit_get_exec_context(const Unit *u) _pure_;
955KillContext* unit_get_kill_context(const Unit *u) _pure_;
956CGroupContext* unit_get_cgroup_context(const Unit *u) _pure_;
598459ce 957
2234032c
MY
958ExecRuntime* unit_get_exec_runtime(const Unit *u) _pure_;
959CGroupRuntime* unit_get_cgroup_runtime(const Unit *u) _pure_;
613b411c
LP
960
961int unit_setup_exec_runtime(Unit *u);
2234032c 962CGroupRuntime* unit_setup_cgroup_runtime(Unit *u);
3ef63c31 963
68ecb48b 964const char* unit_escape_setting(const char *s, UnitWriteFlags flags, char **buf);
2e59b241 965char* unit_concat_strv(char **l, UnitWriteFlags flags);
b9ec9359 966
2e59b241
LP
967int unit_write_setting(Unit *u, UnitWriteFlags flags, const char *name, const char *data);
968int unit_write_settingf(Unit *u, UnitWriteFlags mode, const char *name, const char *format, ...) _printf_(4,5);
b9ec9359 969
b826e317 970int unit_kill_context(Unit *u, KillOperation k);
cd2086fe 971
c2756a68
LP
972int unit_make_transient(Unit *u);
973
9e615fa3 974int unit_add_mounts_for(Unit *u, const char *path, UnitDependencyMask mask, UnitMountDependencyType type);
a57f7e2c 975
1c2e9646
LP
976bool unit_type_supported(UnitType t);
977
0f13f3bd
LP
978bool unit_is_pristine(Unit *u);
979
a3c1168a 980bool unit_is_unneeded(Unit *u);
0bc488c9 981bool unit_is_upheld_by_active(Unit *u, Unit **ret_culprit);
56c59592 982bool unit_is_bound_by_inactive(Unit *u, Unit **ret_culprit);
a3c1168a 983
37eb258e 984PidRef* unit_control_pid(Unit *u);
3e22239d
YW
985PidRef* unit_main_pid_full(Unit *u, bool *ret_is_alien);
986static inline PidRef* unit_main_pid(Unit *u) {
987 return unit_main_pid_full(u, NULL);
988}
291d565a 989
8b4305c7 990void unit_warn_if_dir_nonempty(Unit *u, const char* where);
38c35970
LP
991int unit_log_noncanonical_mount_path(Unit *u, const char *where);
992int unit_fail_if_noncanonical_mount_path(Unit *u, const char* where);
8b4305c7 993
97a3f4ee 994int unit_test_start_limit(Unit *u);
07299350 995
00d9ef85
LP
996int unit_ref_uid_gid(Unit *u, uid_t uid, gid_t gid);
997void unit_unref_uid_gid(Unit *u, bool destroy_now);
998
999void unit_notify_user_lookup(Unit *u, uid_t uid, gid_t gid);
1000
2d3b784d 1001int unit_set_invocation_id(Unit *u, sd_id128_t id);
4b58153d
LP
1002int unit_acquire_invocation_id(Unit *u);
1003
1ad6e8b3 1004int unit_set_exec_params(Unit *s, ExecParameters *p);
f0d47797 1005
5162829e 1006int unit_fork_helper_process(Unit *u, const char *name, bool into_cgroup, PidRef *ret);
4775b55d 1007int unit_fork_and_watch_rm_rf(Unit *u, char **paths, PidRef *ret);
a79279c7 1008
c999cf38
LP
1009void unit_remove_dependencies(Unit *u, UnitDependencyMask mask);
1010
d3070fbd
LP
1011void unit_export_state_files(Unit *u);
1012void unit_unlink_state_files(Unit *u);
7f2a7ccf
MY
1013
1014int unit_set_debug_invocation(Unit *u, bool enable);
d3070fbd 1015
3c7416b6
LP
1016int unit_prepare_exec(Unit *u);
1017
95e631da 1018int unit_warn_leftover_processes(Unit *u, bool start);
a4634b21 1019
bb2c7685
LP
1020bool unit_needs_console(Unit *u);
1021
4ace93da 1022int unit_pid_attachable(Unit *unit, PidRef *pid, sd_bus_error *error);
6592b975 1023
28a2dfe8
ZJS
1024static inline bool unit_has_job_type(Unit *u, JobType type) {
1025 return u && u->job && u->job->type == type;
1026}
1027
836e4e7e 1028int unit_get_log_level_max(const Unit *u);
ba77798b 1029
836e4e7e 1030bool unit_log_level_test(const Unit *u, int level);
c2503e35 1031
31cd5f63
AZ
1032/* unit_log_skip is for cases like ExecCondition= where a unit is considered "done"
1033 * after some execution, rather than succeeded or failed. */
1034void unit_log_skip(Unit *u, const char *result);
523ee2d4 1035void unit_log_success(Unit *u);
7c047d74 1036void unit_log_failure(Unit *u, const char *result);
aac99f30
ZJS
1037static inline void unit_log_result(Unit *u, bool success, const char *result) {
1038 if (success)
1039 unit_log_success(u);
1040 else
1041 unit_log_failure(u, result);
1042}
1043
5cc2cd1c 1044void unit_log_process_exit(Unit *u, const char *kind, const char *command, bool success, int code, int status);
7c047d74 1045
7af67e9a
LP
1046int unit_exit_status(Unit *u);
1047int unit_success_action_exit_status(Unit *u);
1048int unit_failure_action_exit_status(Unit *u);
1049
a4191c9f
LP
1050int unit_test_trigger_loaded(Unit *u);
1051
703b1b7f 1052void unit_destroy_runtime_data(Unit *u, const ExecContext *context, bool destroy_runtime_dir);
380dc8b0
LP
1053int unit_clean(Unit *u, ExecCleanMask mask);
1054int unit_can_clean(Unit *u, ExecCleanMask *ret_mask);
1055
f882c102
DDM
1056bool unit_can_start_refuse_manual(Unit *u);
1057bool unit_can_stop_refuse_manual(Unit *u);
1058bool unit_can_isolate_refuse_manual(Unit *u);
1059
b21bebbe 1060bool unit_can_freeze(const Unit *u);
16b6af6a 1061int unit_freezer_action(Unit *u, FreezerAction action);
54e1f676 1062void unit_next_freezer_state(Unit *u, FreezerAction action, FreezerState *ret_next, FreezerState *ret_objective);
0064290a 1063void unit_set_freezer_state(Unit *u, FreezerState state);
e1ac5259 1064void unit_freezer_complete(Unit *u, FreezerState kernel_state);
d9e45bc3 1065
f19afb21 1066int unit_can_live_mount(Unit *u, sd_bus_error *error);
5162829e
LB
1067int unit_live_mount(Unit *u, const char *src, const char *dst, sd_bus_message *message, MountInNamespaceFlags flags, const MountOptions *options, sd_bus_error *error);
1068
6e548561
DDM
1069Condition *unit_find_failed_condition(Unit *u);
1070
e9276800
LP
1071int unit_arm_timer(Unit *u, sd_event_source **source, bool relative, usec_t usec, sd_event_time_handler_t handler);
1072
6e0f9593 1073bool unit_passes_filter(Unit *u, char * const *states, char * const *patterns);
6d2984d2 1074
a8157796
LP
1075int unit_compare_priority(Unit *a, Unit *b);
1076
64fd6ba9
DDM
1077const char* unit_log_field(const Unit *u);
1078const char* unit_invocation_log_field(const Unit *u);
1079
9e615fa3
LB
1080UnitMountDependencyType unit_mount_dependency_type_from_string(const char *s) _const_;
1081const char* unit_mount_dependency_type_to_string(UnitMountDependencyType t) _const_;
1082UnitDependency unit_mount_dependency_type_to_dependency_type(UnitMountDependencyType t) _pure_;
1083
4ea4abb6
DDM
1084const char* oom_policy_to_string(OOMPolicy i) _const_;
1085OOMPolicy oom_policy_from_string(const char *s) _pure_;
1086
e8e581bf
ZJS
1087/* Macros which append UNIT= or USER_UNIT= to the message */
1088
ac513634 1089#define log_unit_full_errno_zerook(unit, level, error, ...) \
f2341e0a 1090 ({ \
8dec4a9d 1091 const Unit *_u = (unit); \
c2503e35 1092 const int _l = (level); \
ba77798b
DDM
1093 LOG_CONTEXT_SET_LOG_LEVEL(unit_get_log_level_max(_u)); \
1094 const ExecContext *_c = _u ? unit_get_exec_context(_u) : NULL; \
1092e82b
LB
1095 LOG_CONTEXT_PUSH_IOV(_c ? _c->log_extra_fields : NULL, \
1096 _c ? _c->n_log_extra_fields : 0); \
ba77798b
DDM
1097 _u ? log_object_internal(_l, error, PROJECT_FILE, __LINE__, __func__, unit_log_field(_u), _u->id, unit_invocation_log_field(_u), _u->invocation_id_string, ##__VA_ARGS__) : \
1098 log_internal(_l, error, PROJECT_FILE, __LINE__, __func__, ##__VA_ARGS__); \
f2341e0a
LP
1099 })
1100
ac513634
YW
1101#define log_unit_full_errno(unit, level, error, ...) \
1102 ({ \
1103 int _error = (error); \
1104 ASSERT_NON_ZERO(_error); \
1105 log_unit_full_errno_zerook(unit, level, _error, ##__VA_ARGS__); \
1106 })
1107
1108#define log_unit_full(unit, level, ...) (void) log_unit_full_errno_zerook(unit, level, 0, __VA_ARGS__)
8ed6f81b 1109
ac513634 1110#define log_unit_debug(unit, ...) log_unit_full(unit, LOG_DEBUG, __VA_ARGS__)
8ed6f81b
YW
1111#define log_unit_info(unit, ...) log_unit_full(unit, LOG_INFO, __VA_ARGS__)
1112#define log_unit_notice(unit, ...) log_unit_full(unit, LOG_NOTICE, __VA_ARGS__)
1113#define log_unit_warning(unit, ...) log_unit_full(unit, LOG_WARNING, __VA_ARGS__)
1114#define log_unit_error(unit, ...) log_unit_full(unit, LOG_ERR, __VA_ARGS__)
1115
1116#define log_unit_debug_errno(unit, error, ...) log_unit_full_errno(unit, LOG_DEBUG, error, __VA_ARGS__)
1117#define log_unit_info_errno(unit, error, ...) log_unit_full_errno(unit, LOG_INFO, error, __VA_ARGS__)
1118#define log_unit_notice_errno(unit, error, ...) log_unit_full_errno(unit, LOG_NOTICE, error, __VA_ARGS__)
1119#define log_unit_warning_errno(unit, error, ...) log_unit_full_errno(unit, LOG_WARNING, error, __VA_ARGS__)
1120#define log_unit_error_errno(unit, error, ...) log_unit_full_errno(unit, LOG_ERR, error, __VA_ARGS__)
f2341e0a 1121
556b6f4e
DDM
1122#if LOG_TRACE
1123# define log_unit_trace(...) log_unit_debug(__VA_ARGS__)
1124# define log_unit_trace_errno(...) log_unit_debug_errno(__VA_ARGS__)
1125#else
1126# define log_unit_trace(...) do {} while (0)
1127# define log_unit_trace_errno(e, ...) (-ERRNO_VALUE(e))
1128#endif
1129
c2503e35
RH
1130#define log_unit_struct_errno(unit, level, error, ...) \
1131 ({ \
1132 const Unit *_u = (unit); \
1133 const int _l = (level); \
ba77798b
DDM
1134 LOG_CONTEXT_SET_LOG_LEVEL(unit_get_log_level_max(_u)); \
1135 const ExecContext *_c = _u ? unit_get_exec_context(_u) : NULL; \
1092e82b
LB
1136 LOG_CONTEXT_PUSH_IOV(_c ? _c->log_extra_fields : NULL, \
1137 _c ? _c->n_log_extra_fields : 0); \
ba77798b 1138 log_struct_errno(_l, error, __VA_ARGS__, LOG_UNIT_ID(_u)); \
c2503e35
RH
1139 })
1140
1141#define log_unit_struct(unit, level, ...) log_unit_struct_errno(unit, level, 0, __VA_ARGS__)
1142
1143#define log_unit_struct_iovec_errno(unit, level, error, iovec, n_iovec) \
1144 ({ \
1092e82b 1145 const Unit *_u = (unit); \
c2503e35 1146 const int _l = (level); \
ba77798b
DDM
1147 LOG_CONTEXT_SET_LOG_LEVEL(unit_get_log_level_max(_u)); \
1148 const ExecContext *_c = _u ? unit_get_exec_context(_u) : NULL; \
1092e82b
LB
1149 LOG_CONTEXT_PUSH_IOV(_c ? _c->log_extra_fields : NULL, \
1150 _c ? _c->n_log_extra_fields : 0); \
ba77798b 1151 log_struct_iovec_errno(_l, error, iovec, n_iovec); \
c2503e35
RH
1152 })
1153
1154#define log_unit_struct_iovec(unit, level, iovec, n_iovec) log_unit_struct_iovec_errno(unit, level, 0, iovec, n_iovec)
1155
b9ce5cf9
ZJS
1156/* Like LOG_MESSAGE(), but with the unit name prefixed. */
1157#define LOG_UNIT_MESSAGE(unit, fmt, ...) LOG_MESSAGE("%s: " fmt, (unit)->id, ##__VA_ARGS__)
64fd6ba9
DDM
1158#define LOG_UNIT_ID(unit) LOG_ITEM("%s%s", unit_log_field((unit)), (unit)->id)
1159#define LOG_UNIT_INVOCATION_ID(unit) LOG_ITEM("%s%s", unit_invocation_log_field((unit)), (unit)->invocation_id_string)
5afe510c
LP
1160
1161const char* collect_mode_to_string(CollectMode m) _const_;
1162CollectMode collect_mode_from_string(const char *s) _pure_;
15ed3c3a
LP
1163
1164typedef struct UnitForEachDependencyData {
1165 /* Stores state for the FOREACH macro below for iterating through all deps that have any of the
1166 * specified dependency atom bits set */
b7777d08 1167 const Unit *unit;
15ed3c3a
LP
1168 UnitDependencyAtom match_atom;
1169 Hashmap *by_type, *by_unit;
1170 void *current_type;
1171 Iterator by_type_iterator, by_unit_iterator;
1172 Unit **current_unit;
b7777d08
YW
1173 uint64_t generation;
1174 unsigned n_restart;
1175 bool restart_on_generation_change;
15ed3c3a
LP
1176} UnitForEachDependencyData;
1177
b7777d08
YW
1178/* Let's not restart the loop infinitely. */
1179#define MAX_FOREACH_DEPENDENCY_RESTART 100000
1180
15ed3c3a
LP
1181/* Iterates through all dependencies that have a specific atom in the dependency type set. This tries to be
1182 * smart: if the atom is unique, we'll directly go to right entry. Otherwise we'll iterate through the
1183 * per-dependency type hashmap and match all dep that have the right atom set. */
b7777d08 1184#define _UNIT_FOREACH_DEPENDENCY(other, u, ma, restart, data) \
15ed3c3a 1185 for (UnitForEachDependencyData data = { \
b7777d08 1186 .unit = (u), \
15ed3c3a 1187 .match_atom = (ma), \
15ed3c3a 1188 .current_unit = &(other), \
b7777d08 1189 .restart_on_generation_change = (restart), \
15ed3c3a
LP
1190 }; \
1191 ({ \
1192 UnitDependency _dt = _UNIT_DEPENDENCY_INVALID; \
1193 bool _found; \
1194 \
b7777d08
YW
1195 if (data.generation == 0 || \
1196 (data.restart_on_generation_change && \
1197 data.generation != data.unit->dependency_generation)) { \
1198 data.generation = data.unit->dependency_generation; \
1199 data.by_type = data.unit->dependencies; \
1200 data.by_type_iterator = ITERATOR_FIRST; \
1201 assert_se(data.n_restart++ < MAX_FOREACH_DEPENDENCY_RESTART); \
1202 } else \
1203 assert(data.generation == data.unit->dependency_generation); \
1204 \
15ed3c3a
LP
1205 if (data.by_type && ITERATOR_IS_FIRST(data.by_type_iterator)) { \
1206 _dt = unit_dependency_from_unique_atom(data.match_atom); \
1207 if (_dt >= 0) { \
1208 data.by_unit = hashmap_get(data.by_type, UNIT_DEPENDENCY_TO_PTR(_dt)); \
1209 data.current_type = UNIT_DEPENDENCY_TO_PTR(_dt); \
1210 data.by_type = NULL; \
1211 _found = !!data.by_unit; \
1212 } \
1213 } \
1214 if (_dt < 0) \
1215 _found = hashmap_iterate(data.by_type, \
1216 &data.by_type_iterator, \
b7777d08 1217 (void**) &(data.by_unit), \
15ed3c3a
LP
1218 (const void**) &(data.current_type)); \
1219 _found; \
1220 }); ) \
1221 if ((unit_dependency_to_atom(UNIT_DEPENDENCY_FROM_PTR(data.current_type)) & data.match_atom) != 0) \
1222 for (data.by_unit_iterator = ITERATOR_FIRST; \
b7777d08 1223 data.generation == data.unit->dependency_generation && \
15ed3c3a
LP
1224 hashmap_iterate(data.by_unit, \
1225 &data.by_unit_iterator, \
1226 NULL, \
1227 (const void**) data.current_unit); )
1228
1229/* Note: this matches deps that have *any* of the atoms specified in match_atom set */
1230#define UNIT_FOREACH_DEPENDENCY(other, u, match_atom) \
b7777d08
YW
1231 _UNIT_FOREACH_DEPENDENCY(other, u, match_atom, false, UNIQ_T(data, UNIQ))
1232#define UNIT_FOREACH_DEPENDENCY_SAFE(other, u, match_atom) \
1233 _UNIT_FOREACH_DEPENDENCY(other, u, match_atom, true, UNIQ_T(data, UNIQ))
4b2af439 1234
8574b794
MY
1235#define _LOG_CONTEXT_PUSH_UNIT(unit, u, c) \
1236 const Unit *u = (unit); \
1237 const ExecContext *c = unit_get_exec_context(u); \
64fd6ba9
DDM
1238 LOG_CONTEXT_PUSH_KEY_VALUE(unit_log_field(u), u->id); \
1239 LOG_CONTEXT_PUSH_KEY_VALUE(unit_invocation_log_field(u), u->invocation_id_string); \
8574b794 1240 LOG_CONTEXT_PUSH_IOV(c ? c->log_extra_fields : NULL, c ? c->n_log_extra_fields : 0); \
ba77798b 1241 LOG_CONTEXT_SET_LOG_LEVEL(unit_get_log_level_max(u))
4b2af439
DDM
1242
1243#define LOG_CONTEXT_PUSH_UNIT(unit) \
1244 _LOG_CONTEXT_PUSH_UNIT(unit, UNIQ_T(u, UNIQ), UNIQ_T(c, UNIQ))