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_SHUTDOWN_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         /* Objective as it was before serialization, mostly to detect soft-reboots */
 383         ManagerObjective previous_objective;
 384
 385         /* Flags */
 386         bool dispatching_load_queue;
 387
 388         /* Have we already sent out the READY=1 notification? */
 389         bool ready_sent;
 390
 391         /* Was the last status sent "STATUS=Ready."? */
 392         bool status_ready;
 393
 394         /* Have we already printed the taint line if necessary? */
 395         bool taint_logged;
 396
 397         /* Have we ever changed the "kernel.pid_max" sysctl? */
 398         bool sysctl_pid_max_changed;
 399
 400         ManagerTestRunFlags test_run_flags;
 401
 402         /* If non-zero, exit with the following value when the systemd
 403          * process terminate. Useful for containers: systemd-nspawn could get
 404          * the return value. */
 405         uint8_t return_value;
 406
 407         ShowStatus show_status;
 408         ShowStatus show_status_overridden;
 409         StatusUnitFormat status_unit_format;
 410         char *confirm_spawn;
 411         bool no_console_output;
 412         bool service_watchdogs;
 413
 414         UnitDefaults defaults;
 415
 416         int original_log_level;
 417         LogTarget original_log_target;
 418         bool log_level_overridden;
 419         bool log_target_overridden;
 420
 421         /* non-zero if we are reloading or reexecuting, */
 422         int n_reloading;
 423
 424         unsigned n_installed_jobs;
 425         unsigned n_failed_jobs;
 426
 427         /* Jobs in progress watching */
 428         unsigned n_running_jobs;
 429         unsigned n_on_console;
 430         unsigned jobs_in_progress_iteration;
 431
 432         /* Do we have any outstanding password prompts? */
 433         int have_ask_password;
 434         int ask_password_inotify_fd;
 435         sd_event_source *ask_password_event_source;
 436
 437         /* Type=idle pipes */
 438         int idle_pipe[4];
 439         sd_event_source *idle_pipe_event_source;
 440
 441         char *switch_root;
 442         char *switch_root_init;
 443
 444         /* This is true before and after switching root. */
 445         bool switching_root;
 446
 447         /* These map all possible path prefixes to the units needing them. They are hashmaps with a path
 448          * string as key, and a Set as value where Unit objects are contained. */
 449         Hashmap *units_needing_mounts_for[_UNIT_MOUNT_DEPENDENCY_TYPE_MAX];
 450
 451         /* Used for processing polkit authorization responses */
 452         Hashmap *polkit_registry;
 453
 454         /* Dynamic users/groups, indexed by their name */
 455         Hashmap *dynamic_users;
 456
 457         /* Keep track of all UIDs and GIDs any of our services currently use. This is useful for the RemoveIPC= logic. */
 458         Hashmap *uid_refs;
 459         Hashmap *gid_refs;
 460
 461         /* ExecSharedRuntime, indexed by their owner unit id */
 462         Hashmap *exec_shared_runtime_by_id;
 463
 464         /* When the user hits C-A-D more than 7 times per 2s, do something immediately... */
 465         RateLimit ctrl_alt_del_ratelimit;
 466         EmergencyAction cad_burst_action;
 467
 468         const char *unit_log_field;
 469         const char *unit_log_format_string;
 470
 471         const char *invocation_log_field;
 472         const char *invocation_log_format_string;
 473
 474         int first_boot; /* tri-state */
 475
 476         /* Prefixes of e.g. RuntimeDirectory= */
 477         char *prefix[_EXEC_DIRECTORY_TYPE_MAX];
 478         char *received_credentials_directory;
 479         char *received_encrypted_credentials_directory;
 480
 481         /* Used in the SIGCHLD and sd_notify() message invocation logic to avoid that we dispatch the same event
 482          * multiple times on the same unit. */
 483         unsigned sigchldgen;
 484         unsigned notifygen;
 485
 486         VarlinkServer *varlink_server;
 487         /* When we're a system manager, this object manages the subscription from systemd-oomd to PID1 that's
 488          * used to report changes in ManagedOOM settings (systemd server - oomd client). When
 489          * we're a user manager, this object manages the client connection from the user manager to
 490          * systemd-oomd to report changes in ManagedOOM settings (systemd client - oomd server). */
 491         Varlink *managed_oom_varlink;
 492
 493         /* Reference to RestrictFileSystems= BPF program */
 494         struct restrict_fs_bpf *restrict_fs;
 495
 496         /* Allow users to configure a rate limit for Reload()/Reexecute() operations */
 497         RateLimit reload_reexec_ratelimit;
 498         /* Dump*() are slow, so always rate limit them to 10 per 10 minutes */
 499         RateLimit dump_ratelimit;
 500
 501         sd_event_source *memory_pressure_event_source;
 502
 503         /* For NFTSet= */
 504         FirewallContext *fw_ctx;
 505
 506         /* Pin the systemd-executor binary, so that it never changes until re-exec, ensuring we don't have
 507          * serialization/deserialization compatibility issues during upgrades. */
 508         int executor_fd;
 509
 510         unsigned soft_reboots_count;
 511 };
 512
 513 static inline usec_t manager_default_timeout_abort_usec(Manager *m) {
 514         assert(m);
 515         return m->defaults.timeout_abort_set ? m->defaults.timeout_abort_usec : m->defaults.timeout_stop_usec;
 516 }
 517
 518 #define MANAGER_IS_SYSTEM(m) ((m)->runtime_scope == RUNTIME_SCOPE_SYSTEM)
 519 #define MANAGER_IS_USER(m) ((m)->runtime_scope == RUNTIME_SCOPE_USER)
 520
 521 #define MANAGER_IS_RELOADING(m) ((m)->n_reloading > 0)
 522
 523 #define MANAGER_IS_FINISHED(m) (dual_timestamp_is_set((m)->timestamps + MANAGER_TIMESTAMP_FINISH))
 524
 525 /* 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 */
 526 #define MANAGER_IS_RUNNING(m) ((m)->objective == MANAGER_OK)
 527
 528 #define MANAGER_IS_SWITCHING_ROOT(m) ((m)->switching_root)
 529
 530 #define MANAGER_IS_TEST_RUN(m) ((m)->test_run_flags != 0)
 531
 532 static inline usec_t manager_default_timeout(RuntimeScope scope) {
 533         return scope == RUNTIME_SCOPE_SYSTEM ? DEFAULT_TIMEOUT_USEC : DEFAULT_USER_TIMEOUT_USEC;
 534 }
 535
 536 int manager_new(RuntimeScope scope, ManagerTestRunFlags test_run_flags, Manager **m);
 537 Manager* manager_free(Manager *m);
 538 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
 539
 540 int manager_startup(Manager *m, FILE *serialization, FDSet *fds, const char *root);
 541
 542 Job *manager_get_job(Manager *m, uint32_t id);
 543 Unit *manager_get_unit(Manager *m, const char *name);
 544
 545 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j);
 546
 547 bool manager_unit_cache_should_retry_load(Unit *u);
 548 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **ret);
 549 int manager_load_unit(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **ret);
 550 int manager_load_startable_unit_or_warn(Manager *m, const char *name, const char *path, Unit **ret);
 551 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u);
 552
 553 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, Set *affected_jobs, sd_bus_error *e, Job **_ret);
 554 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs, sd_bus_error *e, Job **_ret);
 555 int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Set *affected_jobs,  Job **ret);
 556 int manager_propagate_reload(Manager *m, Unit *unit, JobMode mode, sd_bus_error *e);
 557
 558 void manager_clear_jobs(Manager *m);
 559
 560 void manager_unwatch_pidref(Manager *m, const PidRef *pid);
 561
 562 unsigned manager_dispatch_load_queue(Manager *m);
 563
 564 int manager_setup_memory_pressure_event_source(Manager *m);
 565
 566 int manager_default_environment(Manager *m);
 567 int manager_transient_environment_add(Manager *m, char **plus);
 568 int manager_client_environment_modify(Manager *m, char **minus, char **plus);
 569 int manager_get_effective_environment(Manager *m, char ***ret);
 570
 571 int manager_set_unit_defaults(Manager *m, const UnitDefaults *defaults);
 572
 573 void manager_trigger_run_queue(Manager *m);
 574
 575 int manager_loop(Manager *m);
 576
 577 int manager_reload(Manager *m);
 578 Manager* manager_reloading_start(Manager *m);
 579 void manager_reloading_stopp(Manager **m);
 580
 581 void manager_reset_failed(Manager *m);
 582
 583 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);
 584 void manager_send_unit_plymouth(Manager *m, Unit *u);
 585 void manager_send_unit_supervisor(Manager *m, Unit *u, bool active);
 586
 587 bool manager_unit_inactive_or_pending(Manager *m, const char *name);
 588
 589 void manager_check_finished(Manager *m);
 590 void manager_send_reloading(Manager *m);
 591
 592 void disable_printk_ratelimit(void);
 593 void manager_recheck_dbus(Manager *m);
 594 void manager_recheck_journal(Manager *m);
 595
 596 bool manager_get_show_status_on(Manager *m);
 597 void manager_set_show_status(Manager *m, ShowStatus mode, const char *reason);
 598 void manager_override_show_status(Manager *m, ShowStatus mode, const char *reason);
 599
 600 void manager_set_first_boot(Manager *m, bool b);
 601 void manager_set_switching_root(Manager *m, bool switching_root);
 602
 603 double manager_get_progress(Manager *m);
 604
 605 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) _printf_(4,5);
 606
 607 Set* manager_get_units_needing_mounts_for(Manager *m, const char *path, UnitMountDependencyType t);
 608
 609 ManagerState manager_state(Manager *m);
 610
 611 int manager_update_failed_units(Manager *m, Unit *u, bool failed);
 612
 613 void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now);
 614 int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc);
 615
 616 void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now);
 617 int manager_ref_gid(Manager *m, gid_t gid, bool clean_ipc);
 618
 619 char* manager_taint_string(const Manager *m);
 620
 621 void manager_ref_console(Manager *m);
 622 void manager_unref_console(Manager *m);
 623
 624 void manager_override_log_level(Manager *m, int level);
 625 void manager_restore_original_log_level(Manager *m);
 626
 627 void manager_override_log_target(Manager *m, LogTarget target);
 628 void manager_restore_original_log_target(Manager *m);
 629
 630 const char *manager_state_to_string(ManagerState m) _const_;
 631 ManagerState manager_state_from_string(const char *s) _pure_;
 632
 633 const char *manager_get_confirm_spawn(Manager *m);
 634 void manager_disable_confirm_spawn(void);
 635
 636 const char *manager_timestamp_to_string(ManagerTimestamp m) _const_;
 637 ManagerTimestamp manager_timestamp_from_string(const char *s) _pure_;
 638 ManagerTimestamp manager_timestamp_initrd_mangle(ManagerTimestamp s);
 639
 640 usec_t manager_get_watchdog(Manager *m, WatchdogType t);
 641 void manager_set_watchdog(Manager *m, WatchdogType t, usec_t timeout);
 642 void manager_override_watchdog(Manager *m, WatchdogType t, usec_t timeout);
 643 int manager_set_watchdog_pretimeout_governor(Manager *m, const char *governor);
 644 int manager_override_watchdog_pretimeout_governor(Manager *m, const char *governor);
 645
 646 LogTarget manager_get_executor_log_target(Manager *m);
 647
 648 int manager_allocate_idle_pipe(Manager *m);
 649
 650 const char* oom_policy_to_string(OOMPolicy i) _const_;
 651 OOMPolicy oom_policy_from_string(const char *s) _pure_;
 652
 653 void unit_defaults_init(UnitDefaults *defaults, RuntimeScope scope);
 654 void unit_defaults_done(UnitDefaults *defaults);
 655
 656 enum {
 657         /* most important … */
 658         EVENT_PRIORITY_USER_LOOKUP      = SD_EVENT_PRIORITY_NORMAL-10,
 659         EVENT_PRIORITY_MOUNT_TABLE      = SD_EVENT_PRIORITY_NORMAL-9,
 660         EVENT_PRIORITY_SWAP_TABLE       = SD_EVENT_PRIORITY_NORMAL-9,
 661         EVENT_PRIORITY_CGROUP_AGENT     = SD_EVENT_PRIORITY_NORMAL-8, /* cgroupv1 */
 662         EVENT_PRIORITY_CGROUP_INOTIFY   = SD_EVENT_PRIORITY_NORMAL-8, /* cgroupv2 */
 663         EVENT_PRIORITY_CGROUP_OOM       = SD_EVENT_PRIORITY_NORMAL-7,
 664         EVENT_PRIORITY_EXEC_FD          = SD_EVENT_PRIORITY_NORMAL-6,
 665         EVENT_PRIORITY_NOTIFY           = SD_EVENT_PRIORITY_NORMAL-5,
 666         EVENT_PRIORITY_SIGCHLD          = SD_EVENT_PRIORITY_NORMAL-4,
 667         EVENT_PRIORITY_SIGNALS          = SD_EVENT_PRIORITY_NORMAL-3,
 668         EVENT_PRIORITY_CGROUP_EMPTY     = SD_EVENT_PRIORITY_NORMAL-2,
 669         EVENT_PRIORITY_TIME_CHANGE      = SD_EVENT_PRIORITY_NORMAL-1,
 670         EVENT_PRIORITY_TIME_ZONE        = SD_EVENT_PRIORITY_NORMAL-1,
 671         EVENT_PRIORITY_IPC              = SD_EVENT_PRIORITY_NORMAL,
 672         EVENT_PRIORITY_REWATCH_PIDS     = SD_EVENT_PRIORITY_IDLE,
 673         EVENT_PRIORITY_SERVICE_WATCHDOG = SD_EVENT_PRIORITY_IDLE+1,
 674         EVENT_PRIORITY_RUN_QUEUE        = SD_EVENT_PRIORITY_IDLE+2,
 675         /* … to least important */
 676 };