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