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