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         /* We use two hash tables here, since the same PID might be
 149          * watched by two different units: once the unit that forked
 150          * it off, and possibly a different unit to which it was
 151          * joined as cgroup member. Since we know that it is either
 152          * one or two units for each PID we just use to hashmaps
 153          * here. */
 154         Hashmap *watch_pids1;  /* pid => Unit object n:1 */
 155         Hashmap *watch_pids2;  /* pid => Unit object n:1 */
 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         int time_change_fd;
 176         sd_event_source *time_change_event_source;
 177
 178         sd_event_source *jobs_in_progress_event_source;
 179
 180         int user_lookup_fds[2];
 181         sd_event_source *user_lookup_event_source;
 182
 183         UnitFileScope unit_file_scope;
 184         LookupPaths lookup_paths;
 185         Set *unit_path_cache;
 186
 187         char **environment;
 188
 189         usec_t runtime_watchdog;
 190         usec_t shutdown_watchdog;
 191
 192         dual_timestamp timestamps[_MANAGER_TIMESTAMP_MAX];
 193
 194         struct udev* udev;
 195
 196         /* Data specific to the device subsystem */
 197         struct udev_monitor* udev_monitor;
 198         sd_event_source *udev_event_source;
 199         Hashmap *devices_by_sysfs;
 200
 201         /* Data specific to the mount subsystem */
 202         struct libmnt_monitor *mount_monitor;
 203         sd_event_source *mount_event_source;
 204
 205         /* Data specific to the swap filesystem */
 206         FILE *proc_swaps;
 207         sd_event_source *swap_event_source;
 208         Hashmap *swaps_by_devnode;
 209
 210         /* Data specific to the D-Bus subsystem */
 211         sd_bus *api_bus, *system_bus;
 212         Set *private_buses;
 213         int private_listen_fd;
 214         sd_event_source *private_listen_event_source;
 215
 216         /* Contains all the clients that are subscribed to signals via
 217         the API bus. Note that private bus connections are always
 218         considered subscribes, since they last for very short only,
 219         and it is much simpler that way. */
 220         sd_bus_track *subscribed;
 221         char **deserialized_subscribed;
 222
 223         /* This is used during reloading: before the reload we queue
 224          * the reply message here, and afterwards we send it */
 225         sd_bus_message *queued_message;
 226
 227         Hashmap *watch_bus;  /* D-Bus names => Unit object n:1 */
 228
 229         bool send_reloading_done;
 230
 231         uint32_t current_job_id;
 232         uint32_t default_unit_job_id;
 233
 234         /* Data specific to the Automount subsystem */
 235         int dev_autofs_fd;
 236
 237         /* Data specific to the cgroup subsystem */
 238         Hashmap *cgroup_unit;
 239         CGroupMask cgroup_supported;
 240         char *cgroup_root;
 241
 242         /* Notifications from cgroups, when the unified hierarchy is used is done via inotify. */
 243         int cgroup_inotify_fd;
 244         sd_event_source *cgroup_inotify_event_source;
 245         Hashmap *cgroup_inotify_wd_unit;
 246
 247         /* A defer event for handling cgroup empty events and processing them after SIGCHLD in all cases. */
 248         sd_event_source *cgroup_empty_event_source;
 249
 250         /* Make sure the user cannot accidentally unmount our cgroup
 251          * file system */
 252         int pin_cgroupfs_fd;
 253
 254         unsigned gc_marker;
 255
 256         /* Flags */
 257         ManagerExitCode exit_code:5;
 258
 259         bool dispatching_load_queue:1;
 260         bool dispatching_dbus_queue:1;
 261
 262         bool taint_usr:1;
 263
 264         bool ready_sent:1;
 265
 266         unsigned test_run_flags:8;
 267
 268         /* If non-zero, exit with the following value when the systemd
 269          * process terminate. Useful for containers: systemd-nspawn could get
 270          * the return value. */
 271         uint8_t return_value;
 272
 273         ShowStatus show_status;
 274         char *confirm_spawn;
 275         bool no_console_output;
 276
 277         ExecOutput default_std_output, default_std_error;
 278
 279         usec_t default_restart_usec, default_timeout_start_usec, default_timeout_stop_usec;
 280
 281         usec_t default_start_limit_interval;
 282         unsigned default_start_limit_burst;
 283
 284         bool default_cpu_accounting;
 285         bool default_memory_accounting;
 286         bool default_io_accounting;
 287         bool default_blockio_accounting;
 288         bool default_tasks_accounting;
 289         bool default_ip_accounting;
 290
 291         uint64_t default_tasks_max;
 292         usec_t default_timer_accuracy_usec;
 293
 294         struct rlimit *rlimit[_RLIMIT_MAX];
 295
 296         /* non-zero if we are reloading or reexecuting, */
 297         int n_reloading;
 298
 299         unsigned n_installed_jobs;
 300         unsigned n_failed_jobs;
 301
 302         /* Jobs in progress watching */
 303         unsigned n_running_jobs;
 304         unsigned n_on_console;
 305         unsigned jobs_in_progress_iteration;
 306
 307         /* Do we have any outstanding password prompts? */
 308         int have_ask_password;
 309         int ask_password_inotify_fd;
 310         sd_event_source *ask_password_event_source;
 311
 312         /* Type=idle pipes */
 313         int idle_pipe[4];
 314         sd_event_source *idle_pipe_event_source;
 315
 316         char *switch_root;
 317         char *switch_root_init;
 318
 319         /* This maps all possible path prefixes to the units needing
 320          * them. It's a hashmap with a path string as key and a Set as
 321          * value where Unit objects are contained. */
 322         Hashmap *units_requiring_mounts_for;
 323
 324         /* Used for processing polkit authorization responses */
 325         Hashmap *polkit_registry;
 326
 327         /* Dynamic users/groups, indexed by their name */
 328         Hashmap *dynamic_users;
 329
 330         /* Keep track of all UIDs and GIDs any of our services currently use. This is useful for the RemoveIPC= logic. */
 331         Hashmap *uid_refs;
 332         Hashmap *gid_refs;
 333
 334         /* When the user hits C-A-D more than 7 times per 2s, do something immediately... */
 335         RateLimit ctrl_alt_del_ratelimit;
 336         EmergencyAction cad_burst_action;
 337
 338         const char *unit_log_field;
 339         const char *unit_log_format_string;
 340
 341         const char *invocation_log_field;
 342         const char *invocation_log_format_string;
 343
 344         int first_boot; /* tri-state */
 345
 346         /* prefixes of e.g. RuntimeDirectory= */
 347         char *prefix[_EXEC_DIRECTORY_TYPE_MAX];
 348 };
 349
 350 #define MANAGER_IS_SYSTEM(m) ((m)->unit_file_scope == UNIT_FILE_SYSTEM)
 351 #define MANAGER_IS_USER(m) ((m)->unit_file_scope != UNIT_FILE_SYSTEM)
 352
 353 #define MANAGER_IS_RELOADING(m) ((m)->n_reloading > 0)
 354
 355 int manager_new(UnitFileScope scope, unsigned test_run_flags, Manager **m);
 356 Manager* manager_free(Manager *m);
 357
 358 void manager_enumerate(Manager *m);
 359 int manager_startup(Manager *m, FILE *serialization, FDSet *fds);
 360
 361 Job *manager_get_job(Manager *m, uint32_t id);
 362 Unit *manager_get_unit(Manager *m, const char *name);
 363
 364 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j);
 365
 366 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 367 int manager_load_unit(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 368 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u);
 369
 370 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, sd_bus_error *e, Job **_ret);
 371 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, sd_bus_error *e, Job **_ret);
 372 int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Job **ret);
 373 int manager_propagate_reload(Manager *m, Unit *unit, JobMode mode, sd_bus_error *e);
 374
 375 void manager_dump_units(Manager *s, FILE *f, const char *prefix);
 376 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix);
 377 void manager_dump(Manager *s, FILE *f, const char *prefix);
 378
 379 void manager_clear_jobs(Manager *m);
 380
 381 unsigned manager_dispatch_load_queue(Manager *m);
 382
 383 int manager_environment_add(Manager *m, char **minus, char **plus);
 384 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit);
 385
 386 int manager_loop(Manager *m);
 387
 388 int manager_open_serialization(Manager *m, FILE **_f);
 389
 390 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root);
 391 int manager_deserialize(Manager *m, FILE *f, FDSet *fds);
 392
 393 int manager_reload(Manager *m);
 394
 395 void manager_reset_failed(Manager *m);
 396
 397 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);
 398 void manager_send_unit_plymouth(Manager *m, Unit *u);
 399
 400 bool manager_unit_inactive_or_pending(Manager *m, const char *name);
 401
 402 void manager_check_finished(Manager *m);
 403
 404 void manager_recheck_journal(Manager *m);
 405
 406 void manager_set_show_status(Manager *m, ShowStatus mode);
 407 void manager_set_first_boot(Manager *m, bool b);
 408
 409 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) _printf_(4,5);
 410 void manager_flip_auto_status(Manager *m, bool enable);
 411
 412 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path);
 413
 414 void manager_set_exec_params(Manager *m, ExecParameters *p);
 415
 416 ManagerState manager_state(Manager *m);
 417
 418 int manager_update_failed_units(Manager *m, Unit *u, bool failed);
 419
 420 void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now);
 421 int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc);
 422
 423 void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now);
 424 int manager_ref_gid(Manager *m, gid_t gid, bool destroy_now);
 425
 426 void manager_vacuum_uid_refs(Manager *m);
 427 void manager_vacuum_gid_refs(Manager *m);
 428
 429 void manager_serialize_uid_refs(Manager *m, FILE *f);
 430 void manager_deserialize_uid_refs_one(Manager *m, const char *value);
 431
 432 void manager_serialize_gid_refs(Manager *m, FILE *f);
 433 void manager_deserialize_gid_refs_one(Manager *m, const char *value);
 434
 435 const char *manager_state_to_string(ManagerState m) _const_;
 436 ManagerState manager_state_from_string(const char *s) _pure_;
 437
 438 const char *manager_get_confirm_spawn(Manager *m);
 439 bool manager_is_confirm_spawn_disabled(Manager *m);
 440 void manager_disable_confirm_spawn(void);
 441
 442 const char *manager_timestamp_to_string(ManagerTimestamp m) _const_;
 443 ManagerTimestamp manager_timestamp_from_string(const char *s) _pure_;