Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : : #pragma once
3 : :
4 : : #include <stdbool.h>
5 : : #include <stdio.h>
6 : :
7 : : #include "sd-bus.h"
8 : : #include "sd-device.h"
9 : : #include "sd-event.h"
10 : :
11 : : #include "cgroup-util.h"
12 : : #include "fdset.h"
13 : : #include "hashmap.h"
14 : : #include "ip-address-access.h"
15 : : #include "list.h"
16 : : #include "prioq.h"
17 : : #include "ratelimit.h"
18 : :
19 : : struct libmnt_monitor;
20 : : typedef struct Unit Unit;
21 : :
22 : : /* Enforce upper limit how many names we allow */
23 : : #define MANAGER_MAX_NAMES 131072 /* 128K */
24 : :
25 : : typedef struct Manager Manager;
26 : :
27 : : /* An externally visible state. We don't actually maintain this as state variable, but derive it from various fields
28 : : * when requested */
29 : : typedef enum ManagerState {
30 : : MANAGER_INITIALIZING,
31 : : MANAGER_STARTING,
32 : : MANAGER_RUNNING,
33 : : MANAGER_DEGRADED,
34 : : MANAGER_MAINTENANCE,
35 : : MANAGER_STOPPING,
36 : : _MANAGER_STATE_MAX,
37 : : _MANAGER_STATE_INVALID = -1
38 : : } ManagerState;
39 : :
40 : : typedef enum ManagerObjective {
41 : : MANAGER_OK,
42 : : MANAGER_EXIT,
43 : : MANAGER_RELOAD,
44 : : MANAGER_REEXECUTE,
45 : : MANAGER_REBOOT,
46 : : MANAGER_POWEROFF,
47 : : MANAGER_HALT,
48 : : MANAGER_KEXEC,
49 : : MANAGER_SWITCH_ROOT,
50 : : _MANAGER_OBJECTIVE_MAX,
51 : : _MANAGER_OBJECTIVE_INVALID = -1
52 : : } ManagerObjective;
53 : :
54 : : typedef enum StatusType {
55 : : STATUS_TYPE_EPHEMERAL,
56 : : STATUS_TYPE_NORMAL,
57 : : STATUS_TYPE_EMERGENCY,
58 : : } StatusType;
59 : :
60 : : typedef enum OOMPolicy {
61 : : OOM_CONTINUE, /* The kernel kills the process it wants to kill, and that's it */
62 : : OOM_STOP, /* The kernel kills the process it wants to kill, and we stop the unit */
63 : : OOM_KILL, /* The kernel kills the process it wants to kill, and all others in the unit, and we stop the unit */
64 : : _OOM_POLICY_MAX,
65 : : _OOM_POLICY_INVALID = -1
66 : : } OOMPolicy;
67 : :
68 : : /* Notes:
69 : : * 1. TIMESTAMP_FIRMWARE, TIMESTAMP_LOADER, TIMESTAMP_KERNEL, TIMESTAMP_INITRD,
70 : : * TIMESTAMP_SECURITY_START, and TIMESTAMP_SECURITY_FINISH are set only when
71 : : * the manager is system and not running under container environment.
72 : : *
73 : : * 2. The monotonic timestamp of TIMESTAMP_KERNEL is always zero.
74 : : *
75 : : * 3. The realtime timestamp of TIMESTAMP_KERNEL will be unset if the system does not
76 : : * have RTC.
77 : : *
78 : : * 4. TIMESTAMP_FIRMWARE and TIMESTAMP_LOADER will be unset if the system does not
79 : : * have RTC, or systemd is built without EFI support.
80 : : *
81 : : * 5. The monotonic timestamps of TIMESTAMP_FIRMWARE and TIMESTAMP_LOADER are stored as
82 : : * negative of the actual value.
83 : : *
84 : : * 6. TIMESTAMP_USERSPACE is the timestamp of when the manager was started.
85 : : *
86 : : * 7. TIMESTAMP_INITRD_* are set only when the system is booted with an initrd.
87 : : */
88 : :
89 : : typedef enum ManagerTimestamp {
90 : : MANAGER_TIMESTAMP_FIRMWARE,
91 : : MANAGER_TIMESTAMP_LOADER,
92 : : MANAGER_TIMESTAMP_KERNEL,
93 : : MANAGER_TIMESTAMP_INITRD,
94 : : MANAGER_TIMESTAMP_USERSPACE,
95 : : MANAGER_TIMESTAMP_FINISH,
96 : :
97 : : MANAGER_TIMESTAMP_SECURITY_START,
98 : : MANAGER_TIMESTAMP_SECURITY_FINISH,
99 : : MANAGER_TIMESTAMP_GENERATORS_START,
100 : : MANAGER_TIMESTAMP_GENERATORS_FINISH,
101 : : MANAGER_TIMESTAMP_UNITS_LOAD_START,
102 : : MANAGER_TIMESTAMP_UNITS_LOAD_FINISH,
103 : :
104 : : MANAGER_TIMESTAMP_INITRD_SECURITY_START,
105 : : MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH,
106 : : MANAGER_TIMESTAMP_INITRD_GENERATORS_START,
107 : : MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH,
108 : : MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START,
109 : : MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH,
110 : : _MANAGER_TIMESTAMP_MAX,
111 : : _MANAGER_TIMESTAMP_INVALID = -1,
112 : : } ManagerTimestamp;
113 : :
114 : : #include "execute.h"
115 : : #include "job.h"
116 : : #include "path-lookup.h"
117 : : #include "show-status.h"
118 : : #include "unit-name.h"
119 : :
120 : : typedef enum ManagerTestRunFlags {
121 : : MANAGER_TEST_NORMAL = 0, /* run normally */
122 : : MANAGER_TEST_RUN_MINIMAL = 1 << 0, /* create basic data structures */
123 : : MANAGER_TEST_RUN_BASIC = 1 << 1, /* interact with the environment */
124 : : MANAGER_TEST_RUN_ENV_GENERATORS = 1 << 2, /* also run env generators */
125 : : MANAGER_TEST_RUN_GENERATORS = 1 << 3, /* also run unit generators */
126 : : MANAGER_TEST_FULL = MANAGER_TEST_RUN_BASIC | MANAGER_TEST_RUN_ENV_GENERATORS | MANAGER_TEST_RUN_GENERATORS,
127 : : } ManagerTestRunFlags;
128 : :
129 : : assert_cc((MANAGER_TEST_FULL & UINT8_MAX) == MANAGER_TEST_FULL);
130 : :
131 : : struct Manager {
132 : : /* Note that the set of units we know of is allowed to be
133 : : * inconsistent. However the subset of it that is loaded may
134 : : * not, and the list of jobs may neither. */
135 : :
136 : : /* Active jobs and units */
137 : : Hashmap *units; /* name string => Unit object n:1 */
138 : : Hashmap *units_by_invocation_id;
139 : : Hashmap *jobs; /* job id => Job object 1:1 */
140 : :
141 : : /* To make it easy to iterate through the units of a specific
142 : : * type we maintain a per type linked list */
143 : : LIST_HEAD(Unit, units_by_type[_UNIT_TYPE_MAX]);
144 : :
145 : : /* Units that need to be loaded */
146 : : LIST_HEAD(Unit, load_queue); /* this is actually more a stack than a queue, but uh. */
147 : :
148 : : /* Jobs that need to be run */
149 : : struct Prioq *run_queue;
150 : :
151 : : /* Units and jobs that have not yet been announced via
152 : : * D-Bus. When something about a job changes it is added here
153 : : * if it is not in there yet. This allows easy coalescing of
154 : : * D-Bus change signals. */
155 : : LIST_HEAD(Unit, dbus_unit_queue);
156 : : LIST_HEAD(Job, dbus_job_queue);
157 : :
158 : : /* Units to remove */
159 : : LIST_HEAD(Unit, cleanup_queue);
160 : :
161 : : /* Units and jobs to check when doing GC */
162 : : LIST_HEAD(Unit, gc_unit_queue);
163 : : LIST_HEAD(Job, gc_job_queue);
164 : :
165 : : /* Units that should be realized */
166 : : LIST_HEAD(Unit, cgroup_realize_queue);
167 : :
168 : : /* Units whose cgroup ran empty */
169 : : LIST_HEAD(Unit, cgroup_empty_queue);
170 : :
171 : : /* Units whose memory.event fired */
172 : : LIST_HEAD(Unit, cgroup_oom_queue);
173 : :
174 : : /* Target units whose default target dependencies haven't been set yet */
175 : : LIST_HEAD(Unit, target_deps_queue);
176 : :
177 : : /* Units that might be subject to StopWhenUnneeded= clean-up */
178 : : LIST_HEAD(Unit, stop_when_unneeded_queue);
179 : :
180 : : sd_event *event;
181 : :
182 : : /* This maps PIDs we care about to units that are interested in. We allow multiple units to he interested in
183 : : * the same PID and multiple PIDs to be relevant to the same unit. Since in most cases only a single unit will
184 : : * be interested in the same PID we use a somewhat special encoding here: the first unit interested in a PID is
185 : : * stored directly in the hashmap, keyed by the PID unmodified. If there are other units interested too they'll
186 : : * be stored in a NULL-terminated array, and keyed by the negative PID. This is safe as pid_t is signed and
187 : : * negative PIDs are not used for regular processes but process groups, which we don't care about in this
188 : : * context, but this allows us to use the negative range for our own purposes. */
189 : : Hashmap *watch_pids; /* pid => unit as well as -pid => array of units */
190 : :
191 : : /* A set contains all units which cgroup should be refreshed after startup */
192 : : Set *startup_units;
193 : :
194 : : /* A set which contains all currently failed units */
195 : : Set *failed_units;
196 : :
197 : : sd_event_source *run_queue_event_source;
198 : :
199 : : char *notify_socket;
200 : : int notify_fd;
201 : : sd_event_source *notify_event_source;
202 : :
203 : : int cgroups_agent_fd;
204 : : sd_event_source *cgroups_agent_event_source;
205 : :
206 : : int signal_fd;
207 : : sd_event_source *signal_event_source;
208 : :
209 : : sd_event_source *sigchld_event_source;
210 : :
211 : : int time_change_fd;
212 : : sd_event_source *time_change_event_source;
213 : :
214 : : sd_event_source *timezone_change_event_source;
215 : :
216 : : sd_event_source *jobs_in_progress_event_source;
217 : :
218 : : int user_lookup_fds[2];
219 : : sd_event_source *user_lookup_event_source;
220 : :
221 : : sd_event_source *sync_bus_names_event_source;
222 : :
223 : : UnitFileScope unit_file_scope;
224 : : LookupPaths lookup_paths;
225 : : Hashmap *unit_id_map;
226 : : Hashmap *unit_name_map;
227 : : Set *unit_path_cache;
228 : : usec_t unit_cache_mtime;
229 : :
230 : : char **transient_environment; /* The environment, as determined from config files, kernel cmdline and environment generators */
231 : : char **client_environment; /* Environment variables created by clients through the bus API */
232 : :
233 : : usec_t runtime_watchdog;
234 : : usec_t reboot_watchdog;
235 : : usec_t kexec_watchdog;
236 : :
237 : : dual_timestamp timestamps[_MANAGER_TIMESTAMP_MAX];
238 : :
239 : : /* Data specific to the device subsystem */
240 : : sd_device_monitor *device_monitor;
241 : : Hashmap *devices_by_sysfs;
242 : :
243 : : /* Data specific to the mount subsystem */
244 : : struct libmnt_monitor *mount_monitor;
245 : : sd_event_source *mount_event_source;
246 : :
247 : : /* Data specific to the swap filesystem */
248 : : FILE *proc_swaps;
249 : : sd_event_source *swap_event_source;
250 : : Hashmap *swaps_by_devnode;
251 : :
252 : : /* Data specific to the D-Bus subsystem */
253 : : sd_bus *api_bus, *system_bus;
254 : : Set *private_buses;
255 : : int private_listen_fd;
256 : : sd_event_source *private_listen_event_source;
257 : :
258 : : /* Contains all the clients that are subscribed to signals via
259 : : the API bus. Note that private bus connections are always
260 : : considered subscribes, since they last for very short only,
261 : : and it is much simpler that way. */
262 : : sd_bus_track *subscribed;
263 : : char **deserialized_subscribed;
264 : :
265 : : /* This is used during reloading: before the reload we queue
266 : : * the reply message here, and afterwards we send it */
267 : : sd_bus_message *pending_reload_message;
268 : :
269 : : Hashmap *watch_bus; /* D-Bus names => Unit object n:1 */
270 : :
271 : : bool send_reloading_done;
272 : :
273 : : uint32_t current_job_id;
274 : : uint32_t default_unit_job_id;
275 : :
276 : : /* Data specific to the Automount subsystem */
277 : : int dev_autofs_fd;
278 : :
279 : : /* Data specific to the cgroup subsystem */
280 : : Hashmap *cgroup_unit;
281 : : CGroupMask cgroup_supported;
282 : : char *cgroup_root;
283 : :
284 : : /* Notifications from cgroups, when the unified hierarchy is used is done via inotify. */
285 : : int cgroup_inotify_fd;
286 : : sd_event_source *cgroup_inotify_event_source;
287 : :
288 : : /* Maps for finding the unit for each inotify watch descriptor for the cgroup.events and
289 : : * memory.events cgroupv2 attributes. */
290 : : Hashmap *cgroup_control_inotify_wd_unit;
291 : : Hashmap *cgroup_memory_inotify_wd_unit;
292 : :
293 : : /* A defer event for handling cgroup empty events and processing them after SIGCHLD in all cases. */
294 : : sd_event_source *cgroup_empty_event_source;
295 : : sd_event_source *cgroup_oom_event_source;
296 : :
297 : : /* Make sure the user cannot accidentally unmount our cgroup
298 : : * file system */
299 : : int pin_cgroupfs_fd;
300 : :
301 : : unsigned gc_marker;
302 : :
303 : : /* The stat() data the last time we saw /etc/localtime */
304 : : usec_t etc_localtime_mtime;
305 : : bool etc_localtime_accessible:1;
306 : :
307 : : ManagerObjective objective:5;
308 : :
309 : : /* Flags */
310 : : bool dispatching_load_queue:1;
311 : :
312 : : bool taint_usr:1;
313 : :
314 : : /* Have we already sent out the READY=1 notification? */
315 : : bool ready_sent:1;
316 : :
317 : : /* Have we already printed the taint line if necessary? */
318 : : bool taint_logged:1;
319 : :
320 : : /* Have we ever changed the "kernel.pid_max" sysctl? */
321 : : bool sysctl_pid_max_changed:1;
322 : :
323 : : ManagerTestRunFlags test_run_flags:8;
324 : :
325 : : /* If non-zero, exit with the following value when the systemd
326 : : * process terminate. Useful for containers: systemd-nspawn could get
327 : : * the return value. */
328 : : uint8_t return_value;
329 : :
330 : : ShowStatus show_status;
331 : : StatusUnitFormat status_unit_format;
332 : : char *confirm_spawn;
333 : : bool no_console_output;
334 : : bool service_watchdogs;
335 : :
336 : : ExecOutput default_std_output, default_std_error;
337 : :
338 : : usec_t default_restart_usec, default_timeout_start_usec, default_timeout_stop_usec;
339 : : usec_t default_timeout_abort_usec;
340 : : bool default_timeout_abort_set;
341 : :
342 : : usec_t default_start_limit_interval;
343 : : unsigned default_start_limit_burst;
344 : :
345 : : bool default_cpu_accounting;
346 : : bool default_memory_accounting;
347 : : bool default_io_accounting;
348 : : bool default_blockio_accounting;
349 : : bool default_tasks_accounting;
350 : : bool default_ip_accounting;
351 : :
352 : : uint64_t default_tasks_max;
353 : : usec_t default_timer_accuracy_usec;
354 : :
355 : : OOMPolicy default_oom_policy;
356 : :
357 : : int original_log_level;
358 : : LogTarget original_log_target;
359 : : bool log_level_overridden:1;
360 : : bool log_target_overridden:1;
361 : :
362 : : struct rlimit *rlimit[_RLIMIT_MAX];
363 : :
364 : : /* non-zero if we are reloading or reexecuting, */
365 : : int n_reloading;
366 : :
367 : : unsigned n_installed_jobs;
368 : : unsigned n_failed_jobs;
369 : :
370 : : /* Jobs in progress watching */
371 : : unsigned n_running_jobs;
372 : : unsigned n_on_console;
373 : : unsigned jobs_in_progress_iteration;
374 : :
375 : : /* Do we have any outstanding password prompts? */
376 : : int have_ask_password;
377 : : int ask_password_inotify_fd;
378 : : sd_event_source *ask_password_event_source;
379 : :
380 : : /* Type=idle pipes */
381 : : int idle_pipe[4];
382 : : sd_event_source *idle_pipe_event_source;
383 : :
384 : : char *switch_root;
385 : : char *switch_root_init;
386 : :
387 : : /* This maps all possible path prefixes to the units needing
388 : : * them. It's a hashmap with a path string as key and a Set as
389 : : * value where Unit objects are contained. */
390 : : Hashmap *units_requiring_mounts_for;
391 : :
392 : : /* Used for processing polkit authorization responses */
393 : : Hashmap *polkit_registry;
394 : :
395 : : /* Dynamic users/groups, indexed by their name */
396 : : Hashmap *dynamic_users;
397 : :
398 : : /* Keep track of all UIDs and GIDs any of our services currently use. This is useful for the RemoveIPC= logic. */
399 : : Hashmap *uid_refs;
400 : : Hashmap *gid_refs;
401 : :
402 : : /* ExecRuntime, indexed by their owner unit id */
403 : : Hashmap *exec_runtime_by_id;
404 : :
405 : : /* When the user hits C-A-D more than 7 times per 2s, do something immediately... */
406 : : RateLimit ctrl_alt_del_ratelimit;
407 : : EmergencyAction cad_burst_action;
408 : :
409 : : const char *unit_log_field;
410 : : const char *unit_log_format_string;
411 : :
412 : : const char *invocation_log_field;
413 : : const char *invocation_log_format_string;
414 : :
415 : : int first_boot; /* tri-state */
416 : :
417 : : /* Prefixes of e.g. RuntimeDirectory= */
418 : : char *prefix[_EXEC_DIRECTORY_TYPE_MAX];
419 : :
420 : : /* Used in the SIGCHLD and sd_notify() message invocation logic to avoid that we dispatch the same event
421 : : * multiple times on the same unit. */
422 : : unsigned sigchldgen;
423 : : unsigned notifygen;
424 : :
425 : : bool honor_device_enumeration;
426 : : };
427 : :
428 : 0 : static inline usec_t manager_default_timeout_abort_usec(Manager *m) {
429 [ # # ]: 0 : assert(m);
430 [ # # ]: 0 : return m->default_timeout_abort_set ? m->default_timeout_abort_usec : m->default_timeout_stop_usec;
431 : : }
432 : :
433 : : #define MANAGER_IS_SYSTEM(m) ((m)->unit_file_scope == UNIT_FILE_SYSTEM)
434 : : #define MANAGER_IS_USER(m) ((m)->unit_file_scope != UNIT_FILE_SYSTEM)
435 : :
436 : : #define MANAGER_IS_RELOADING(m) ((m)->n_reloading > 0)
437 : :
438 : : #define MANAGER_IS_FINISHED(m) (dual_timestamp_is_set((m)->timestamps + MANAGER_TIMESTAMP_FINISH))
439 : :
440 : : /* The objective is set to OK as soon as we enter the main loop, and set otherwise as soon as we are done with it */
441 : : #define MANAGER_IS_RUNNING(m) ((m)->objective == MANAGER_OK)
442 : :
443 : : #define MANAGER_IS_TEST_RUN(m) ((m)->test_run_flags != 0)
444 : :
445 : : int manager_new(UnitFileScope scope, ManagerTestRunFlags test_run_flags, Manager **m);
446 : : Manager* manager_free(Manager *m);
447 [ + + ]: 92 : DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
448 : :
449 : : int manager_startup(Manager *m, FILE *serialization, FDSet *fds);
450 : :
451 : : Job *manager_get_job(Manager *m, uint32_t id);
452 : : Unit *manager_get_unit(Manager *m, const char *name);
453 : :
454 : : int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j);
455 : :
456 : : int manager_load_unit_prepare(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
457 : : int manager_load_unit(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
458 : : int manager_load_startable_unit_or_warn(Manager *m, const char *name, const char *path, Unit **ret);
459 : : int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u);
460 : :
461 : : int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, Set *affected_jobs, sd_bus_error *e, Job **_ret);
462 : : int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs, sd_bus_error *e, Job **_ret);
463 : : int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs, Job **ret);
464 : : int manager_propagate_reload(Manager *m, Unit *unit, JobMode mode, sd_bus_error *e);
465 : :
466 : : void manager_dump_units(Manager *s, FILE *f, const char *prefix);
467 : : void manager_dump_jobs(Manager *s, FILE *f, const char *prefix);
468 : : void manager_dump(Manager *s, FILE *f, const char *prefix);
469 : : int manager_get_dump_string(Manager *m, char **ret);
470 : :
471 : : void manager_clear_jobs(Manager *m);
472 : :
473 : : void manager_unwatch_pid(Manager *m, pid_t pid);
474 : :
475 : : unsigned manager_dispatch_load_queue(Manager *m);
476 : :
477 : : int manager_default_environment(Manager *m);
478 : : int manager_transient_environment_add(Manager *m, char **plus);
479 : : int manager_client_environment_modify(Manager *m, char **minus, char **plus);
480 : : int manager_get_effective_environment(Manager *m, char ***ret);
481 : :
482 : : int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit);
483 : :
484 : : int manager_loop(Manager *m);
485 : :
486 : : int manager_open_serialization(Manager *m, FILE **_f);
487 : :
488 : : int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root);
489 : : int manager_deserialize(Manager *m, FILE *f, FDSet *fds);
490 : :
491 : : int manager_reload(Manager *m);
492 : :
493 : : void manager_reset_failed(Manager *m);
494 : :
495 : : void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);
496 : : void manager_send_unit_plymouth(Manager *m, Unit *u);
497 : :
498 : : bool manager_unit_inactive_or_pending(Manager *m, const char *name);
499 : :
500 : : void manager_check_finished(Manager *m);
501 : :
502 : : void manager_recheck_dbus(Manager *m);
503 : : void manager_recheck_journal(Manager *m);
504 : :
505 : : void manager_set_show_status(Manager *m, ShowStatus mode);
506 : : void manager_set_first_boot(Manager *m, bool b);
507 : :
508 : : void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) _printf_(4,5);
509 : : void manager_flip_auto_status(Manager *m, bool enable);
510 : :
511 : : Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path);
512 : :
513 : : ManagerState manager_state(Manager *m);
514 : :
515 : : int manager_update_failed_units(Manager *m, Unit *u, bool failed);
516 : :
517 : : void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now);
518 : : int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc);
519 : :
520 : : void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now);
521 : : int manager_ref_gid(Manager *m, gid_t gid, bool destroy_now);
522 : :
523 : : void manager_vacuum_uid_refs(Manager *m);
524 : : void manager_vacuum_gid_refs(Manager *m);
525 : :
526 : : void manager_serialize_uid_refs(Manager *m, FILE *f);
527 : : void manager_deserialize_uid_refs_one(Manager *m, const char *value);
528 : :
529 : : void manager_serialize_gid_refs(Manager *m, FILE *f);
530 : : void manager_deserialize_gid_refs_one(Manager *m, const char *value);
531 : :
532 : : char *manager_taint_string(Manager *m);
533 : :
534 : : void manager_ref_console(Manager *m);
535 : : void manager_unref_console(Manager *m);
536 : :
537 : : void manager_override_log_level(Manager *m, int level);
538 : : void manager_restore_original_log_level(Manager *m);
539 : :
540 : : void manager_override_log_target(Manager *m, LogTarget target);
541 : : void manager_restore_original_log_target(Manager *m);
542 : :
543 : : const char *manager_state_to_string(ManagerState m) _const_;
544 : : ManagerState manager_state_from_string(const char *s) _pure_;
545 : :
546 : : const char *manager_get_confirm_spawn(Manager *m);
547 : : bool manager_is_confirm_spawn_disabled(Manager *m);
548 : : void manager_disable_confirm_spawn(void);
549 : :
550 : : const char *manager_timestamp_to_string(ManagerTimestamp m) _const_;
551 : : ManagerTimestamp manager_timestamp_from_string(const char *s) _pure_;
552 : : ManagerTimestamp manager_timestamp_initrd_mangle(ManagerTimestamp s);
553 : :
554 : : const char* oom_policy_to_string(OOMPolicy i) _const_;
555 : : OOMPolicy oom_policy_from_string(const char *s) _pure_;
|
