src/core/manager.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 #pragma once
   4
   5 /***
   6   This file is part of systemd.
   7
   8   Copyright 2010 Lennart Poettering
   9
  10   systemd is free software; you can redistribute it and/or modify it
  11   under the terms of the GNU Lesser General Public License as published by
  12   the Free Software Foundation; either version 2.1 of the License, or
  13   (at your option) any later version.
  14
  15   systemd is distributed in the hope that it will be useful, but
  16   WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18   Lesser General Public License for more details.
  19
  20   You should have received a copy of the GNU Lesser General Public License
  21   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  22 ***/
  23
  24 #include <stdbool.h>
  25 #include <inttypes.h>
  26 #include <stdio.h>
  27
  28 #include "sd-bus.h"
  29 #include "sd-event.h"
  30 #include "fdset.h"
  31 #include "cgroup-util.h"
  32 #include "hashmap.h"
  33 #include "list.h"
  34 #include "set.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 #include "unit.h"
  74 #include "job.h"
  75 #include "path-lookup.h"
  76 #include "execute.h"
  77 #include "unit-name.h"
  78 #include "exit-status.h"
  79 #include "show-status.h"
  80 #include "failure-action.h"
  81
  82 struct Manager {
  83         /* Note that the set of units we know of is allowed to be
  84          * inconsistent. However the subset of it that is loaded may
  85          * not, and the list of jobs may neither. */
  86
  87         /* Active jobs and units */
  88         Hashmap *units;  /* name string => Unit object n:1 */
  89         Hashmap *jobs;   /* job id => Job object 1:1 */
  90
  91         /* To make it easy to iterate through the units of a specific
  92          * type we maintain a per type linked list */
  93         LIST_HEAD(Unit, units_by_type[_UNIT_TYPE_MAX]);
  94
  95         /* Units that need to be loaded */
  96         LIST_HEAD(Unit, load_queue); /* this is actually more a stack than a queue, but uh. */
  97
  98         /* Jobs that need to be run */
  99         LIST_HEAD(Job, run_queue);   /* more a stack than a queue, too */
 100
 101         /* Units and jobs that have not yet been announced via
 102          * D-Bus. When something about a job changes it is added here
 103          * if it is not in there yet. This allows easy coalescing of
 104          * D-Bus change signals. */
 105         LIST_HEAD(Unit, dbus_unit_queue);
 106         LIST_HEAD(Job, dbus_job_queue);
 107
 108         /* Units to remove */
 109         LIST_HEAD(Unit, cleanup_queue);
 110
 111         /* Units to check when doing GC */
 112         LIST_HEAD(Unit, gc_queue);
 113
 114         /* Units that should be realized */
 115         LIST_HEAD(Unit, cgroup_queue);
 116
 117         sd_event *event;
 118
 119         /* We use two hash tables here, since the same PID might be
 120          * watched by two different units: once the unit that forked
 121          * it off, and possibly a different unit to which it was
 122          * joined as cgroup member. Since we know that it is either
 123          * one or two units for each PID we just use to hashmaps
 124          * here. */
 125         Hashmap *watch_pids1;  /* pid => Unit object n:1 */
 126         Hashmap *watch_pids2;  /* pid => Unit object n:1 */
 127
 128         /* A set contains all units which cgroup should be refreshed after startup */
 129         Set *startup_units;
 130
 131         /* A set which contains all currently failed units */
 132         Set *failed_units;
 133
 134         sd_event_source *run_queue_event_source;
 135
 136         char *notify_socket;
 137         int notify_fd;
 138         sd_event_source *notify_event_source;
 139
 140         int signal_fd;
 141         sd_event_source *signal_event_source;
 142
 143         int time_change_fd;
 144         sd_event_source *time_change_event_source;
 145
 146         sd_event_source *jobs_in_progress_event_source;
 147
 148         unsigned n_snapshots;
 149
 150         LookupPaths lookup_paths;
 151         Set *unit_path_cache;
 152
 153         char **environment;
 154
 155         usec_t runtime_watchdog;
 156         usec_t shutdown_watchdog;
 157
 158         dual_timestamp firmware_timestamp;
 159         dual_timestamp loader_timestamp;
 160         dual_timestamp kernel_timestamp;
 161         dual_timestamp initrd_timestamp;
 162         dual_timestamp userspace_timestamp;
 163         dual_timestamp finish_timestamp;
 164
 165         dual_timestamp security_start_timestamp;
 166         dual_timestamp security_finish_timestamp;
 167         dual_timestamp generators_start_timestamp;
 168         dual_timestamp generators_finish_timestamp;
 169         dual_timestamp units_load_start_timestamp;
 170         dual_timestamp units_load_finish_timestamp;
 171
 172         char *generator_unit_path;
 173         char *generator_unit_path_early;
 174         char *generator_unit_path_late;
 175
 176         struct udev* udev;
 177
 178         /* Data specific to the device subsystem */
 179         struct udev_monitor* udev_monitor;
 180         sd_event_source *udev_event_source;
 181         Hashmap *devices_by_sysfs;
 182
 183         /* Data specific to the mount subsystem */
 184         FILE *proc_self_mountinfo;
 185         sd_event_source *mount_event_source;
 186         int utab_inotify_fd;
 187         sd_event_source *mount_utab_event_source;
 188
 189         /* Data specific to the swap filesystem */
 190         FILE *proc_swaps;
 191         sd_event_source *swap_event_source;
 192         Hashmap *swaps_by_devnode;
 193
 194         /* Data specific to the D-Bus subsystem */
 195         sd_bus *api_bus, *system_bus;
 196         Set *private_buses;
 197         int private_listen_fd;
 198         sd_event_source *private_listen_event_source;
 199
 200         /* Contains all the clients that are subscribed to signals via
 201         the API bus. Note that private bus connections are always
 202         considered subscribes, since they last for very short only,
 203         and it is much simpler that way. */
 204         sd_bus_track *subscribed;
 205         char **deserialized_subscribed;
 206
 207         sd_bus_message *queued_message; /* This is used during reloading:
 208                                       * before the reload we queue the
 209                                       * reply message here, and
 210                                       * afterwards we send it */
 211         sd_bus *queued_message_bus; /* The connection to send the queued message on */
 212
 213         Hashmap *watch_bus;  /* D-Bus names => Unit object n:1 */
 214
 215         bool send_reloading_done;
 216
 217         uint32_t current_job_id;
 218         uint32_t default_unit_job_id;
 219
 220         /* Data specific to the Automount subsystem */
 221         int dev_autofs_fd;
 222
 223         /* Data specific to the cgroup subsystem */
 224         Hashmap *cgroup_unit;
 225         CGroupControllerMask cgroup_supported;
 226         char *cgroup_root;
 227
 228         int gc_marker;
 229         unsigned n_in_gc_queue;
 230
 231         /* Make sure the user cannot accidentally unmount our cgroup
 232          * file system */
 233         int pin_cgroupfs_fd;
 234
 235         /* Flags */
 236         SystemdRunningAs running_as;
 237         ManagerExitCode exit_code:5;
 238
 239         bool dispatching_load_queue:1;
 240         bool dispatching_dbus_queue:1;
 241
 242         bool taint_usr:1;
 243         bool first_boot:1;
 244
 245         bool test_run:1;
 246
 247         ShowStatus show_status;
 248         bool confirm_spawn;
 249         bool no_console_output;
 250
 251         ExecOutput default_std_output, default_std_error;
 252
 253         usec_t default_restart_usec, default_timeout_start_usec, default_timeout_stop_usec;
 254
 255         usec_t default_start_limit_interval;
 256         unsigned default_start_limit_burst;
 257
 258         bool default_cpu_accounting;
 259         bool default_memory_accounting;
 260         bool default_blockio_accounting;
 261
 262         usec_t default_timer_accuracy_usec;
 263
 264         struct rlimit *rlimit[_RLIMIT_MAX];
 265
 266         /* non-zero if we are reloading or reexecuting, */
 267         int n_reloading;
 268
 269         unsigned n_installed_jobs;
 270         unsigned n_failed_jobs;
 271
 272         /* Jobs in progress watching */
 273         unsigned n_running_jobs;
 274         unsigned n_on_console;
 275         unsigned jobs_in_progress_iteration;
 276
 277         /* Do we have any outstanding password prompts? */
 278         int have_ask_password;
 279         int ask_password_inotify_fd;
 280         sd_event_source *ask_password_event_source;
 281
 282         /* Type=idle pipes */
 283         int idle_pipe[4];
 284         sd_event_source *idle_pipe_event_source;
 285
 286         char *switch_root;
 287         char *switch_root_init;
 288
 289         /* This maps all possible path prefixes to the units needing
 290          * them. It's a hashmap with a path string as key and a Set as
 291          * value where Unit objects are contained. */
 292         Hashmap *units_requiring_mounts_for;
 293
 294         /* Reference to the kdbus bus control fd */
 295         int kdbus_fd;
 296
 297         /* Used for processing polkit authorization responses */
 298         Hashmap *polkit_registry;
 299
 300         /* When the user hits C-A-D more than 7 times per 2s, reboot immediately... */
 301         RateLimit ctrl_alt_del_ratelimit;
 302 };
 303
 304 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **m);
 305 Manager* manager_free(Manager *m);
 306
 307 int manager_enumerate(Manager *m);
 308 int manager_startup(Manager *m, FILE *serialization, FDSet *fds);
 309
 310 Job *manager_get_job(Manager *m, uint32_t id);
 311 Unit *manager_get_unit(Manager *m, const char *name);
 312
 313 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found);
 314
 315 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j);
 316
 317 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 318 int manager_load_unit(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 319 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u);
 320
 321 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool force, sd_bus_error *e, Job **_ret);
 322 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool force, sd_bus_error *e, Job **_ret);
 323
 324 void manager_dump_units(Manager *s, FILE *f, const char *prefix);
 325 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix);
 326
 327 void manager_clear_jobs(Manager *m);
 328
 329 unsigned manager_dispatch_load_queue(Manager *m);
 330
 331 int manager_environment_add(Manager *m, char **minus, char **plus);
 332 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit);
 333
 334 int manager_loop(Manager *m);
 335
 336 void manager_dispatch_bus_name_owner_changed(Manager *m, const char *name, const char* old_owner, const char *new_owner);
 337
 338 int manager_open_serialization(Manager *m, FILE **_f);
 339
 340 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root);
 341 int manager_deserialize(Manager *m, FILE *f, FDSet *fds);
 342
 343 int manager_reload(Manager *m);
 344
 345 bool manager_is_reloading_or_reexecuting(Manager *m) _pure_;
 346
 347 void manager_reset_failed(Manager *m);
 348
 349 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);
 350 void manager_send_unit_plymouth(Manager *m, Unit *u);
 351
 352 bool manager_unit_inactive_or_pending(Manager *m, const char *name);
 353
 354 void manager_check_finished(Manager *m);
 355
 356 void manager_recheck_journal(Manager *m);
 357
 358 void manager_set_show_status(Manager *m, ShowStatus mode);
 359 void manager_set_first_boot(Manager *m, bool b);
 360
 361 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) _printf_(4,5);
 362 void manager_flip_auto_status(Manager *m, bool enable);
 363
 364 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path);
 365
 366 const char *manager_get_runtime_prefix(Manager *m);
 367
 368 ManagerState manager_state(Manager *m);
 369
 370 const char *manager_state_to_string(ManagerState m) _const_;
 371 ManagerState manager_state_from_string(const char *s) _pure_;