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