src/core/manager.h

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