src/core/manager.h

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   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 "common-signal.h"
  12 #include "cgroup-util.h"
  13 #include "cgroup.h"
  14 #include "fdset.h"
  15 #include "hashmap.h"
  16 #include "list.h"
  17 #include "prioq.h"
  18 #include "ratelimit.h"
  19 #include "varlink.h"
  20
  21 struct libmnt_monitor;
  22 typedef struct Unit Unit;
  23
  24 /* Enforce upper limit how many names we allow */
  25 #define MANAGER_MAX_NAMES 131072 /* 128K */
  26
  27 /* On sigrtmin+18, private commands */
  28 enum {
  29         MANAGER_SIGNAL_COMMAND_DUMP_JOBS = _COMMON_SIGNAL_COMMAND_PRIVATE_BASE + 0,
  30         _MANAGER_SIGNAL_COMMAND_MAX,
  31 };
  32
  33 assert_cc((int) _MANAGER_SIGNAL_COMMAND_MAX <= (int) _COMMON_SIGNAL_COMMAND_PRIVATE_END);
  34
  35 typedef struct Manager Manager;
  36
  37 /* An externally visible state. We don't actually maintain this as state variable, but derive it from various fields
  38  * when requested */
  39 typedef enum ManagerState {
  40         MANAGER_INITIALIZING,
  41         MANAGER_STARTING,
  42         MANAGER_RUNNING,
  43         MANAGER_DEGRADED,
  44         MANAGER_MAINTENANCE,
  45         MANAGER_STOPPING,
  46         _MANAGER_STATE_MAX,
  47         _MANAGER_STATE_INVALID = -EINVAL,
  48 } ManagerState;
  49
  50 typedef enum ManagerObjective {
  51         MANAGER_OK,
  52         MANAGER_EXIT,
  53         MANAGER_RELOAD,
  54         MANAGER_REEXECUTE,
  55         MANAGER_REBOOT,
  56         MANAGER_SOFT_REBOOT,
  57         MANAGER_POWEROFF,
  58         MANAGER_HALT,
  59         MANAGER_KEXEC,
  60         MANAGER_SWITCH_ROOT,
  61         _MANAGER_OBJECTIVE_MAX,
  62         _MANAGER_OBJECTIVE_INVALID = -EINVAL,
  63 } ManagerObjective;
  64
  65 typedef enum StatusType {
  66         STATUS_TYPE_EPHEMERAL,
  67         STATUS_TYPE_NORMAL,
  68         STATUS_TYPE_NOTICE,
  69         STATUS_TYPE_EMERGENCY,
  70 } StatusType;
  71
  72 typedef enum OOMPolicy {
  73         OOM_CONTINUE,          /* The kernel or systemd-oomd kills the process it wants to kill, and that's it */
  74         OOM_STOP,              /* The kernel or systemd-oomd kills the process it wants to kill, and we stop the unit */
  75         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 */
  76         _OOM_POLICY_MAX,
  77         _OOM_POLICY_INVALID = -EINVAL,
  78 } OOMPolicy;
  79
  80 /* Notes:
  81  * 1. TIMESTAMP_FIRMWARE, TIMESTAMP_LOADER, TIMESTAMP_KERNEL, TIMESTAMP_INITRD,
  82  *    TIMESTAMP_SECURITY_START, and TIMESTAMP_SECURITY_FINISH are set only when
  83  *    the manager is system and not running under container environment.
  84  *
  85  * 2. The monotonic timestamp of TIMESTAMP_KERNEL is always zero.
  86  *
  87  * 3. The realtime timestamp of TIMESTAMP_KERNEL will be unset if the system does not
  88  *    have RTC.
  89  *
  90  * 4. TIMESTAMP_FIRMWARE and TIMESTAMP_LOADER will be unset if the system does not
  91  *    have RTC, or systemd is built without EFI support.
  92  *
  93  * 5. The monotonic timestamps of TIMESTAMP_FIRMWARE and TIMESTAMP_LOADER are stored as
  94  *    negative of the actual value.
  95  *
  96  * 6. TIMESTAMP_USERSPACE is the timestamp of when the manager was started.
  97  *
  98  * 7. TIMESTAMP_INITRD_* are set only when the system is booted with an initrd.
  99  */
 100
 101 typedef enum ManagerTimestamp {
 102         MANAGER_TIMESTAMP_FIRMWARE,
 103         MANAGER_TIMESTAMP_LOADER,
 104         MANAGER_TIMESTAMP_KERNEL,
 105         MANAGER_TIMESTAMP_INITRD,
 106         MANAGER_TIMESTAMP_USERSPACE,
 107         MANAGER_TIMESTAMP_FINISH,
 108
 109         MANAGER_TIMESTAMP_SECURITY_START,
 110         MANAGER_TIMESTAMP_SECURITY_FINISH,
 111         MANAGER_TIMESTAMP_GENERATORS_START,
 112         MANAGER_TIMESTAMP_GENERATORS_FINISH,
 113         MANAGER_TIMESTAMP_UNITS_LOAD_START,
 114         MANAGER_TIMESTAMP_UNITS_LOAD_FINISH,
 115         MANAGER_TIMESTAMP_UNITS_LOAD,
 116
 117         MANAGER_TIMESTAMP_INITRD_SECURITY_START,
 118         MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH,
 119         MANAGER_TIMESTAMP_INITRD_GENERATORS_START,
 120         MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH,
 121         MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START,
 122         MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH,
 123
 124         MANAGER_TIMESTAMP_SOFTREBOOT_START,
 125
 126         _MANAGER_TIMESTAMP_MAX,
 127         _MANAGER_TIMESTAMP_INVALID = -EINVAL,
 128 } ManagerTimestamp;
 129
 130 typedef enum WatchdogType {
 131         WATCHDOG_RUNTIME,
 132         WATCHDOG_REBOOT,
 133         WATCHDOG_KEXEC,
 134         WATCHDOG_PRETIMEOUT,
 135         _WATCHDOG_TYPE_MAX,
 136 } WatchdogType;
 137
 138 #include "execute.h"
 139 #include "job.h"
 140 #include "path-lookup.h"
 141 #include "show-status.h"
 142 #include "unit-name.h"
 143 #include "unit.h"
 144
 145 typedef enum ManagerTestRunFlags {
 146         MANAGER_TEST_NORMAL                  = 0,       /* run normally */
 147         MANAGER_TEST_RUN_MINIMAL             = 1 << 0,  /* create basic data structures */
 148         MANAGER_TEST_RUN_BASIC               = 1 << 1,  /* interact with the environment */
 149         MANAGER_TEST_RUN_ENV_GENERATORS      = 1 << 2,  /* also run env generators  */
 150         MANAGER_TEST_RUN_GENERATORS          = 1 << 3,  /* also run unit generators */
 151         MANAGER_TEST_RUN_IGNORE_DEPENDENCIES = 1 << 4,  /* run while ignoring dependencies */
 152         MANAGER_TEST_DONT_OPEN_EXECUTOR      = 1 << 5,  /* avoid trying to load sd-executor */
 153         MANAGER_TEST_FULL = MANAGER_TEST_RUN_BASIC | MANAGER_TEST_RUN_ENV_GENERATORS | MANAGER_TEST_RUN_GENERATORS,
 154 } ManagerTestRunFlags;
 155
 156 assert_cc((MANAGER_TEST_FULL & UINT8_MAX) == MANAGER_TEST_FULL);
 157
 158 /* Various defaults for unit file settings. */
 159 typedef struct UnitDefaults {
 160         ExecOutput std_output, std_error;
 161
 162         usec_t restart_usec, timeout_start_usec, timeout_stop_usec, timeout_abort_usec, device_timeout_usec;
 163         bool timeout_abort_set;
 164
 165         usec_t start_limit_interval;
 166         unsigned start_limit_burst;
 167
 168         bool cpu_accounting;
 169         bool memory_accounting;
 170         bool io_accounting;
 171         bool blockio_accounting;
 172         bool tasks_accounting;
 173         bool ip_accounting;
 174
 175         CGroupTasksMax tasks_max;
 176         usec_t timer_accuracy_usec;
 177
 178         OOMPolicy oom_policy;
 179         int oom_score_adjust;
 180         bool oom_score_adjust_set;
 181
 182         CGroupPressureWatch memory_pressure_watch;
 183         usec_t memory_pressure_threshold_usec;
 184
 185         char *smack_process_label;
 186
 187         struct rlimit *rlimit[_RLIMIT_MAX];
 188 } UnitDefaults;
 189
 190 struct Manager {
 191         /* Note that the set of units we know of is allowed to be
 192          * inconsistent. However the subset of it that is loaded may
 193          * not, and the list of jobs may neither. */
 194
 195         /* Active jobs and units */
 196         Hashmap *units;  /* name string => Unit object n:1 */
 197         Hashmap *units_by_invocation_id;
 198         Hashmap *jobs;   /* job id => Job object 1:1 */
 199
 200         /* To make it easy to iterate through the units of a specific
 201          * type we maintain a per type linked list */
 202         LIST_HEAD(Unit, units_by_type[_UNIT_TYPE_MAX]);
 203
 204         /* Units that need to be loaded */
 205         LIST_HEAD(Unit, load_queue); /* this is actually more a stack than a queue, but uh. */
 206
 207         /* Jobs that need to be run */
 208         struct Prioq *run_queue;
 209
 210         /* Units and jobs that have not yet been announced via
 211          * D-Bus. When something about a job changes it is added here
 212          * if it is not in there yet. This allows easy coalescing of
 213          * D-Bus change signals. */
 214         LIST_HEAD(Unit, dbus_unit_queue);
 215         LIST_HEAD(Job, dbus_job_queue);
 216
 217         /* Units to remove */
 218         LIST_HEAD(Unit, cleanup_queue);
 219
 220         /* Units and jobs to check when doing GC */
 221         LIST_HEAD(Unit, gc_unit_queue);
 222         LIST_HEAD(Job, gc_job_queue);
 223
 224         /* Units that should be realized */
 225         LIST_HEAD(Unit, cgroup_realize_queue);
 226
 227         /* Units whose cgroup ran empty */
 228         LIST_HEAD(Unit, cgroup_empty_queue);
 229
 230         /* Units whose memory.event fired */
 231         LIST_HEAD(Unit, cgroup_oom_queue);
 232
 233         /* Target units whose default target dependencies haven't been set yet */
 234         LIST_HEAD(Unit, target_deps_queue);
 235
 236         /* Units that might be subject to StopWhenUnneeded= clean-up */
 237         LIST_HEAD(Unit, stop_when_unneeded_queue);
 238
 239         /* Units which are upheld by another other which we might need to act on */
 240         LIST_HEAD(Unit, start_when_upheld_queue);
 241
 242         /* Units that have BindsTo= another unit, and might need to be shutdown because the bound unit is not active. */
 243         LIST_HEAD(Unit, stop_when_bound_queue);
 244
 245         /* Units that have resources open, and where it might be good to check if they can be released now */
 246         LIST_HEAD(Unit, release_resources_queue);
 247
 248         sd_event *event;
 249
 250         /* This maps PIDs we care about to units that are interested in them. We allow multiple units to be
 251          * interested in the same PID and multiple PIDs to be relevant to the same unit. Since in most cases
 252          * only a single unit will be interested in the same PID though, we use a somewhat special structure
 253          * here: the first unit interested in a PID is stored in the hashmap 'watch_pids', keyed by the
 254          * PID. If there are other units interested too they'll be stored in a NULL-terminated array, stored
 255          * in the hashmap 'watch_pids_more', keyed by the PID. Thus to go through the full list of units
 256          * interested in a PID we must look into both hashmaps. */
 257         Hashmap *watch_pids;            /* PidRef* → Unit* */
 258         Hashmap *watch_pids_more;       /* PidRef* → NUL terminated array of Unit* */
 259
 260         /* A set contains all units which cgroup should be refreshed after startup */
 261         Set *startup_units;
 262
 263         /* A set which contains all currently failed units */
 264         Set *failed_units;
 265
 266         sd_event_source *run_queue_event_source;
 267
 268         char *notify_socket;
 269         int notify_fd;
 270         sd_event_source *notify_event_source;
 271
 272         int cgroups_agent_fd;
 273         sd_event_source *cgroups_agent_event_source;
 274
 275         int signal_fd;
 276         sd_event_source *signal_event_source;
 277
 278         sd_event_source *sigchld_event_source;
 279
 280         sd_event_source *time_change_event_source;
 281
 282         sd_event_source *timezone_change_event_source;
 283
 284         sd_event_source *jobs_in_progress_event_source;
 285
 286         int user_lookup_fds[2];
 287         sd_event_source *user_lookup_event_source;
 288
 289         RuntimeScope runtime_scope;
 290
 291         LookupPaths lookup_paths;
 292         Hashmap *unit_id_map;
 293         Hashmap *unit_name_map;
 294         Set *unit_path_cache;
 295         uint64_t unit_cache_timestamp_hash;
 296
 297         /* We don't have support for atomically enabling/disabling units, and unit_file_state might become
 298          * outdated if such operations failed half-way. Therefore, we set this flag if changes to unit files
 299          * are made, and reset it after daemon-reload. If set, we report that daemon-reload is needed through
 300          * unit's NeedDaemonReload property. */
 301         bool unit_file_state_outdated;
 302
 303         char **transient_environment;  /* The environment, as determined from config files, kernel cmdline and environment generators */
 304         char **client_environment;     /* Environment variables created by clients through the bus API */
 305
 306         usec_t watchdog[_WATCHDOG_TYPE_MAX];
 307         usec_t watchdog_overridden[_WATCHDOG_TYPE_MAX];
 308         char *watchdog_pretimeout_governor;
 309         char *watchdog_pretimeout_governor_overridden;
 310
 311         dual_timestamp timestamps[_MANAGER_TIMESTAMP_MAX];
 312
 313         /* Data specific to the device subsystem */
 314         sd_device_monitor *device_monitor;
 315         Hashmap *devices_by_sysfs;
 316
 317         /* Data specific to the mount subsystem */
 318         struct libmnt_monitor *mount_monitor;
 319         sd_event_source *mount_event_source;
 320
 321         /* Data specific to the swap filesystem */
 322         FILE *proc_swaps;
 323         sd_event_source *swap_event_source;
 324         Hashmap *swaps_by_devnode;
 325
 326         /* Data specific to the D-Bus subsystem */
 327         sd_bus *api_bus, *system_bus;
 328         Set *private_buses;
 329         int private_listen_fd;
 330         sd_event_source *private_listen_event_source;
 331
 332         /* Contains all the clients that are subscribed to signals via
 333         the API bus. Note that private bus connections are always
 334         considered subscribes, since they last for very short only,
 335         and it is much simpler that way. */
 336         sd_bus_track *subscribed;
 337         char **deserialized_subscribed;
 338
 339         /* This is used during reloading: before the reload we queue
 340          * the reply message here, and afterwards we send it */
 341         sd_bus_message *pending_reload_message;
 342
 343         Hashmap *watch_bus;  /* D-Bus names => Unit object n:1 */
 344
 345         bool send_reloading_done;
 346
 347         uint32_t current_job_id;
 348         uint32_t default_unit_job_id;
 349
 350         /* Data specific to the Automount subsystem */
 351         int dev_autofs_fd;
 352
 353         /* Data specific to the cgroup subsystem */
 354         Hashmap *cgroup_unit;
 355         CGroupMask cgroup_supported;
 356         char *cgroup_root;
 357
 358         /* Notifications from cgroups, when the unified hierarchy is used is done via inotify. */
 359         int cgroup_inotify_fd;
 360         sd_event_source *cgroup_inotify_event_source;
 361
 362         /* Maps for finding the unit for each inotify watch descriptor for the cgroup.events and
 363          * memory.events cgroupv2 attributes. */
 364         Hashmap *cgroup_control_inotify_wd_unit;
 365         Hashmap *cgroup_memory_inotify_wd_unit;
 366
 367         /* A defer event for handling cgroup empty events and processing them after SIGCHLD in all cases. */
 368         sd_event_source *cgroup_empty_event_source;
 369         sd_event_source *cgroup_oom_event_source;
 370
 371         /* Make sure the user cannot accidentally unmount our cgroup
 372          * file system */
 373         int pin_cgroupfs_fd;
 374
 375         unsigned gc_marker;
 376
 377         /* The stat() data the last time we saw /etc/localtime */
 378         usec_t etc_localtime_mtime;
 379         bool etc_localtime_accessible;
 380
 381         ManagerObjective objective;
 382
 383         /* Flags */
 384         bool dispatching_load_queue;
 385
 386         /* Have we already sent out the READY=1 notification? */
 387         bool ready_sent;
 388
 389         /* Was the last status sent "STATUS=Ready."? */
 390         bool status_ready;
 391
 392         /* Have we already printed the taint line if necessary? */
 393         bool taint_logged;
 394
 395         /* Have we ever changed the "kernel.pid_max" sysctl? */
 396         bool sysctl_pid_max_changed;
 397
 398         ManagerTestRunFlags test_run_flags;
 399
 400         /* If non-zero, exit with the following value when the systemd
 401          * process terminate. Useful for containers: systemd-nspawn could get
 402          * the return value. */
 403         uint8_t return_value;
 404
 405         ShowStatus show_status;
 406         ShowStatus show_status_overridden;
 407         StatusUnitFormat status_unit_format;
 408         char *confirm_spawn;
 409         bool no_console_output;
 410         bool service_watchdogs;
 411
 412         UnitDefaults defaults;
 413
 414         int original_log_level;
 415         LogTarget original_log_target;
 416         bool log_level_overridden;
 417         bool log_target_overridden;
 418
 419         /* non-zero if we are reloading or reexecuting, */
 420         int n_reloading;
 421
 422         unsigned n_installed_jobs;
 423         unsigned n_failed_jobs;
 424
 425         /* Jobs in progress watching */
 426         unsigned n_running_jobs;
 427         unsigned n_on_console;
 428         unsigned jobs_in_progress_iteration;
 429
 430         /* Do we have any outstanding password prompts? */
 431         int have_ask_password;
 432         int ask_password_inotify_fd;
 433         sd_event_source *ask_password_event_source;
 434
 435         /* Type=idle pipes */
 436         int idle_pipe[4];
 437         sd_event_source *idle_pipe_event_source;
 438
 439         char *switch_root;
 440         char *switch_root_init;
 441
 442         /* This is true before and after switching root. */
 443         bool switching_root;
 444
 445         /* These map all possible path prefixes to the units needing them. They are hashmaps with a path
 446          * string as key, and a Set as value where Unit objects are contained. */
 447         Hashmap *units_needing_mounts_for[_UNIT_MOUNT_DEPENDENCY_TYPE_MAX];
 448
 449         /* Used for processing polkit authorization responses */
 450         Hashmap *polkit_registry;
 451
 452         /* Dynamic users/groups, indexed by their name */
 453         Hashmap *dynamic_users;
 454
 455         /* Keep track of all UIDs and GIDs any of our services currently use. This is useful for the RemoveIPC= logic. */
 456         Hashmap *uid_refs;
 457         Hashmap *gid_refs;
 458
 459         /* ExecSharedRuntime, indexed by their owner unit id */
 460         Hashmap *exec_shared_runtime_by_id;
 461
 462         /* When the user hits C-A-D more than 7 times per 2s, do something immediately... */
 463         RateLimit ctrl_alt_del_ratelimit;
 464         EmergencyAction cad_burst_action;
 465
 466         const char *unit_log_field;
 467         const char *unit_log_format_string;
 468
 469         const char *invocation_log_field;
 470         const char *invocation_log_format_string;
 471
 472         int first_boot; /* tri-state */
 473
 474         /* Prefixes of e.g. RuntimeDirectory= */
 475         char *prefix[_EXEC_DIRECTORY_TYPE_MAX];
 476         char *received_credentials_directory;
 477         char *received_encrypted_credentials_directory;
 478
 479         /* Used in the SIGCHLD and sd_notify() message invocation logic to avoid that we dispatch the same event
 480          * multiple times on the same unit. */
 481         unsigned sigchldgen;
 482         unsigned notifygen;
 483
 484         VarlinkServer *varlink_server;
 485         /* When we're a system manager, this object manages the subscription from systemd-oomd to PID1 that's
 486          * used to report changes in ManagedOOM settings (systemd server - oomd client). When
 487          * we're a user manager, this object manages the client connection from the user manager to
 488          * systemd-oomd to report changes in ManagedOOM settings (systemd client - oomd server). */
 489         Varlink *managed_oom_varlink;
 490
 491         /* Reference to RestrictFileSystems= BPF program */
 492         struct restrict_fs_bpf *restrict_fs;
 493
 494         /* Allow users to configure a rate limit for Reload()/Reexecute() operations */
 495         RateLimit reload_reexec_ratelimit;
 496         /* Dump*() are slow, so always rate limit them to 10 per 10 minutes */
 497         RateLimit dump_ratelimit;
 498
 499         sd_event_source *memory_pressure_event_source;
 500
 501         /* For NFTSet= */
 502         FirewallContext *fw_ctx;
 503
 504         /* Pin the systemd-executor binary, so that it never changes until re-exec, ensuring we don't have
 505          * serialization/deserialization compatibility issues during upgrades. */
 506         int executor_fd;
 507
 508         unsigned soft_reboots_count;
 509 };
 510
 511 static inline usec_t manager_default_timeout_abort_usec(Manager *m) {
 512         assert(m);
 513         return m->defaults.timeout_abort_set ? m->defaults.timeout_abort_usec : m->defaults.timeout_stop_usec;
 514 }
 515
 516 #define MANAGER_IS_SYSTEM(m) ((m)->runtime_scope == RUNTIME_SCOPE_SYSTEM)
 517 #define MANAGER_IS_USER(m) ((m)->runtime_scope == RUNTIME_SCOPE_USER)
 518
 519 #define MANAGER_IS_RELOADING(m) ((m)->n_reloading > 0)
 520
 521 #define MANAGER_IS_FINISHED(m) (dual_timestamp_is_set((m)->timestamps + MANAGER_TIMESTAMP_FINISH))
 522
 523 /* 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 */
 524 #define MANAGER_IS_RUNNING(m) ((m)->objective == MANAGER_OK)
 525
 526 #define MANAGER_IS_SWITCHING_ROOT(m) ((m)->switching_root)
 527
 528 #define MANAGER_IS_TEST_RUN(m) ((m)->test_run_flags != 0)
 529
 530 static inline usec_t manager_default_timeout(RuntimeScope scope) {
 531         return scope == RUNTIME_SCOPE_SYSTEM ? DEFAULT_TIMEOUT_USEC : DEFAULT_USER_TIMEOUT_USEC;
 532 }
 533
 534 int manager_new(RuntimeScope scope, ManagerTestRunFlags test_run_flags, Manager **m);
 535 Manager* manager_free(Manager *m);
 536 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
 537
 538 int manager_startup(Manager *m, FILE *serialization, FDSet *fds, const char *root);
 539
 540 Job *manager_get_job(Manager *m, uint32_t id);
 541 Unit *manager_get_unit(Manager *m, const char *name);
 542
 543 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j);
 544
 545 bool manager_unit_cache_should_retry_load(Unit *u);
 546 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **ret);
 547 int manager_load_unit(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **ret);
 548 int manager_load_startable_unit_or_warn(Manager *m, const char *name, const char *path, Unit **ret);
 549 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u);
 550
 551 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, Set *affected_jobs, sd_bus_error *e, Job **_ret);
 552 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs, sd_bus_error *e, Job **_ret);
 553 int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs,  Job **ret);
 554 int manager_propagate_reload(Manager *m, Unit *unit, JobMode mode, sd_bus_error *e);
 555
 556 void manager_clear_jobs(Manager *m);
 557
 558 void manager_unwatch_pidref(Manager *m, const PidRef *pid);
 559
 560 unsigned manager_dispatch_load_queue(Manager *m);
 561
 562 int manager_setup_memory_pressure_event_source(Manager *m);
 563
 564 int manager_default_environment(Manager *m);
 565 int manager_transient_environment_add(Manager *m, char **plus);
 566 int manager_client_environment_modify(Manager *m, char **minus, char **plus);
 567 int manager_get_effective_environment(Manager *m, char ***ret);
 568
 569 int manager_set_unit_defaults(Manager *m, const UnitDefaults *defaults);
 570
 571 void manager_trigger_run_queue(Manager *m);
 572
 573 int manager_loop(Manager *m);
 574
 575 int manager_reload(Manager *m);
 576 Manager* manager_reloading_start(Manager *m);
 577 void manager_reloading_stopp(Manager **m);
 578
 579 void manager_reset_failed(Manager *m);
 580
 581 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);
 582 void manager_send_unit_plymouth(Manager *m, Unit *u);
 583 void manager_send_unit_supervisor(Manager *m, Unit *u, bool active);
 584
 585 bool manager_unit_inactive_or_pending(Manager *m, const char *name);
 586
 587 void manager_check_finished(Manager *m);
 588 void manager_send_reloading(Manager *m);
 589
 590 void disable_printk_ratelimit(void);
 591 void manager_recheck_dbus(Manager *m);
 592 void manager_recheck_journal(Manager *m);
 593
 594 bool manager_get_show_status_on(Manager *m);
 595 void manager_set_show_status(Manager *m, ShowStatus mode, const char *reason);
 596 void manager_override_show_status(Manager *m, ShowStatus mode, const char *reason);
 597
 598 void manager_set_first_boot(Manager *m, bool b);
 599 void manager_set_switching_root(Manager *m, bool switching_root);
 600
 601 double manager_get_progress(Manager *m);
 602
 603 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) _printf_(4,5);
 604
 605 Set* manager_get_units_needing_mounts_for(Manager *m, const char *path, UnitMountDependencyType t);
 606
 607 ManagerState manager_state(Manager *m);
 608
 609 int manager_update_failed_units(Manager *m, Unit *u, bool failed);
 610
 611 void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now);
 612 int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc);
 613
 614 void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now);
 615 int manager_ref_gid(Manager *m, gid_t gid, bool clean_ipc);
 616
 617 char* manager_taint_string(const Manager *m);
 618
 619 void manager_ref_console(Manager *m);
 620 void manager_unref_console(Manager *m);
 621
 622 void manager_override_log_level(Manager *m, int level);
 623 void manager_restore_original_log_level(Manager *m);
 624
 625 void manager_override_log_target(Manager *m, LogTarget target);
 626 void manager_restore_original_log_target(Manager *m);
 627
 628 const char *manager_state_to_string(ManagerState m) _const_;
 629 ManagerState manager_state_from_string(const char *s) _pure_;
 630
 631 const char *manager_get_confirm_spawn(Manager *m);
 632 void manager_disable_confirm_spawn(void);
 633
 634 const char *manager_timestamp_to_string(ManagerTimestamp m) _const_;
 635 ManagerTimestamp manager_timestamp_from_string(const char *s) _pure_;
 636 ManagerTimestamp manager_timestamp_initrd_mangle(ManagerTimestamp s);
 637
 638 usec_t manager_get_watchdog(Manager *m, WatchdogType t);
 639 void manager_set_watchdog(Manager *m, WatchdogType t, usec_t timeout);
 640 void manager_override_watchdog(Manager *m, WatchdogType t, usec_t timeout);
 641 int manager_set_watchdog_pretimeout_governor(Manager *m, const char *governor);
 642 int manager_override_watchdog_pretimeout_governor(Manager *m, const char *governor);
 643
 644 LogTarget manager_get_executor_log_target(Manager *m);
 645
 646 int manager_allocate_idle_pipe(Manager *m);
 647
 648 const char* oom_policy_to_string(OOMPolicy i) _const_;
 649 OOMPolicy oom_policy_from_string(const char *s) _pure_;
 650
 651 void unit_defaults_init(UnitDefaults *defaults, RuntimeScope scope);
 652 void unit_defaults_done(UnitDefaults *defaults);
 653
 654 enum {
 655         /* most important … */
 656         EVENT_PRIORITY_USER_LOOKUP      = SD_EVENT_PRIORITY_NORMAL-10,
 657         EVENT_PRIORITY_MOUNT_TABLE      = SD_EVENT_PRIORITY_NORMAL-9,
 658         EVENT_PRIORITY_SWAP_TABLE       = SD_EVENT_PRIORITY_NORMAL-9,
 659         EVENT_PRIORITY_CGROUP_AGENT     = SD_EVENT_PRIORITY_NORMAL-8, /* cgroupv1 */
 660         EVENT_PRIORITY_CGROUP_INOTIFY   = SD_EVENT_PRIORITY_NORMAL-8, /* cgroupv2 */
 661         EVENT_PRIORITY_CGROUP_OOM       = SD_EVENT_PRIORITY_NORMAL-7,
 662         EVENT_PRIORITY_EXEC_FD          = SD_EVENT_PRIORITY_NORMAL-6,
 663         EVENT_PRIORITY_NOTIFY           = SD_EVENT_PRIORITY_NORMAL-5,
 664         EVENT_PRIORITY_SIGCHLD          = SD_EVENT_PRIORITY_NORMAL-4,
 665         EVENT_PRIORITY_SIGNALS          = SD_EVENT_PRIORITY_NORMAL-3,
 666         EVENT_PRIORITY_CGROUP_EMPTY     = SD_EVENT_PRIORITY_NORMAL-2,
 667         EVENT_PRIORITY_TIME_CHANGE      = SD_EVENT_PRIORITY_NORMAL-1,
 668         EVENT_PRIORITY_TIME_ZONE        = SD_EVENT_PRIORITY_NORMAL-1,
 669         EVENT_PRIORITY_IPC              = SD_EVENT_PRIORITY_NORMAL,
 670         EVENT_PRIORITY_REWATCH_PIDS     = SD_EVENT_PRIORITY_IDLE,
 671         EVENT_PRIORITY_SERVICE_WATCHDOG = SD_EVENT_PRIORITY_IDLE+1,
 672         EVENT_PRIORITY_RUN_QUEUE        = SD_EVENT_PRIORITY_IDLE+2,
 673         /* … to least important */
 674 };