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
  33 /* Enforce upper limit how many names we allow */
  34 #define MANAGER_MAX_NAMES 131072 /* 128K */
  35
  36 typedef struct Manager Manager;
  37
  38 typedef enum ManagerState {
  39         MANAGER_INITIALIZING,
  40         MANAGER_STARTING,
  41         MANAGER_RUNNING,
  42         MANAGER_DEGRADED,
  43         MANAGER_MAINTENANCE,
  44         MANAGER_STOPPING,
  45         _MANAGER_STATE_MAX,
  46         _MANAGER_STATE_INVALID = -1
  47 } ManagerState;
  48
  49 typedef enum ManagerExitCode {
  50         MANAGER_OK,
  51         MANAGER_EXIT,
  52         MANAGER_RELOAD,
  53         MANAGER_REEXECUTE,
  54         MANAGER_REBOOT,
  55         MANAGER_POWEROFF,
  56         MANAGER_HALT,
  57         MANAGER_KEXEC,
  58         MANAGER_SWITCH_ROOT,
  59         _MANAGER_EXIT_CODE_MAX,
  60         _MANAGER_EXIT_CODE_INVALID = -1
  61 } ManagerExitCode;
  62
  63 #include "unit.h"
  64 #include "job.h"
  65 #include "hashmap.h"
  66 #include "list.h"
  67 #include "set.h"
  68 #include "path-lookup.h"
  69 #include "execute.h"
  70 #include "unit-name.h"
  71 #include "exit-status.h"
  72 #include "show-status.h"
  73 #include "failure-action.h"
  74
  75 struct Manager {
  76         /* Note that the set of units we know of is allowed to be
  77          * inconsistent. However the subset of it that is loaded may
  78          * not, and the list of jobs may neither. */
  79
  80         /* Active jobs and units */
  81         Hashmap *units;  /* name string => Unit object n:1 */
  82         Hashmap *jobs;   /* job id => Job object 1:1 */
  83
  84         /* To make it easy to iterate through the units of a specific
  85          * type we maintain a per type linked list */
  86         LIST_HEAD(Unit, units_by_type[_UNIT_TYPE_MAX]);
  87
  88         /* Units that need to be loaded */
  89         LIST_HEAD(Unit, load_queue); /* this is actually more a stack than a queue, but uh. */
  90
  91         /* Jobs that need to be run */
  92         LIST_HEAD(Job, run_queue);   /* more a stack than a queue, too */
  93
  94         /* Units and jobs that have not yet been announced via
  95          * D-Bus. When something about a job changes it is added here
  96          * if it is not in there yet. This allows easy coalescing of
  97          * D-Bus change signals. */
  98         LIST_HEAD(Unit, dbus_unit_queue);
  99         LIST_HEAD(Job, dbus_job_queue);
 100
 101         /* Units to remove */
 102         LIST_HEAD(Unit, cleanup_queue);
 103
 104         /* Units to check when doing GC */
 105         LIST_HEAD(Unit, gc_queue);
 106
 107         /* Units that should be realized */
 108         LIST_HEAD(Unit, cgroup_queue);
 109
 110         sd_event *event;
 111
 112         /* We use two hash tables here, since the same PID might be
 113          * watched by two different units: once the unit that forked
 114          * it off, and possibly a different unit to which it was
 115          * joined as cgroup member. Since we know that it is either
 116          * one or two units for each PID we just use to hashmaps
 117          * here. */
 118         Hashmap *watch_pids1;  /* pid => Unit object n:1 */
 119         Hashmap *watch_pids2;  /* pid => Unit object n:1 */
 120
 121         /* A set contains all units which cgroup should be refreshed after startup */
 122         Set *startup_units;
 123
 124         /* A set which contains all currently failed units */
 125         Set *failed_units;
 126
 127         sd_event_source *run_queue_event_source;
 128
 129         char *notify_socket;
 130         int notify_fd;
 131         sd_event_source *notify_event_source;
 132
 133         int signal_fd;
 134         sd_event_source *signal_event_source;
 135
 136         int time_change_fd;
 137         sd_event_source *time_change_event_source;
 138
 139         sd_event_source *jobs_in_progress_event_source;
 140
 141         unsigned n_snapshots;
 142
 143         LookupPaths lookup_paths;
 144         Set *unit_path_cache;
 145
 146         char **environment;
 147
 148         usec_t runtime_watchdog;
 149         usec_t shutdown_watchdog;
 150
 151         dual_timestamp firmware_timestamp;
 152         dual_timestamp loader_timestamp;
 153         dual_timestamp kernel_timestamp;
 154         dual_timestamp initrd_timestamp;
 155         dual_timestamp userspace_timestamp;
 156         dual_timestamp finish_timestamp;
 157
 158         dual_timestamp security_start_timestamp;
 159         dual_timestamp security_finish_timestamp;
 160         dual_timestamp generators_start_timestamp;
 161         dual_timestamp generators_finish_timestamp;
 162         dual_timestamp units_load_start_timestamp;
 163         dual_timestamp units_load_finish_timestamp;
 164
 165         char *generator_unit_path;
 166         char *generator_unit_path_early;
 167         char *generator_unit_path_late;
 168
 169         struct udev* udev;
 170
 171         /* Data specific to the device subsystem */
 172         struct udev_monitor* udev_monitor;
 173         sd_event_source *udev_event_source;
 174         Hashmap *devices_by_sysfs;
 175
 176         /* Data specific to the mount subsystem */
 177         FILE *proc_self_mountinfo;
 178         sd_event_source *mount_event_source;
 179
 180         /* Data specific to the swap filesystem */
 181         FILE *proc_swaps;
 182         sd_event_source *swap_event_source;
 183         Hashmap *swaps_by_devnode;
 184
 185         /* Data specific to the D-Bus subsystem */
 186         sd_bus *api_bus, *system_bus;
 187         Set *private_buses;
 188         int private_listen_fd;
 189         sd_event_source *private_listen_event_source;
 190
 191         /* Contains all the clients that are subscribed to signals via
 192         the API bus. Note that private bus connections are always
 193         considered subscribes, since they last for very short only,
 194         and it is much simpler that way. */
 195         sd_bus_track *subscribed;
 196         char **deserialized_subscribed;
 197
 198         sd_bus_message *queued_message; /* This is used during reloading:
 199                                       * before the reload we queue the
 200                                       * reply message here, and
 201                                       * afterwards we send it */
 202         sd_bus *queued_message_bus; /* The connection to send the queued message on */
 203
 204         Hashmap *watch_bus;  /* D-Bus names => Unit object n:1 */
 205
 206         bool send_reloading_done;
 207
 208         uint32_t current_job_id;
 209         uint32_t default_unit_job_id;
 210
 211         /* Data specific to the Automount subsystem */
 212         int dev_autofs_fd;
 213
 214         /* Data specific to the cgroup subsystem */
 215         Hashmap *cgroup_unit;
 216         CGroupControllerMask cgroup_supported;
 217         char *cgroup_root;
 218
 219         int gc_marker;
 220         unsigned n_in_gc_queue;
 221
 222         /* Make sure the user cannot accidentally unmount our cgroup
 223          * file system */
 224         int pin_cgroupfs_fd;
 225
 226         /* Flags */
 227         SystemdRunningAs running_as;
 228         ManagerExitCode exit_code:5;
 229
 230         bool dispatching_load_queue:1;
 231         bool dispatching_dbus_queue:1;
 232
 233         bool taint_usr:1;
 234         bool first_boot:1;
 235
 236         bool test_run:1;
 237
 238         ShowStatus show_status;
 239         bool confirm_spawn;
 240         bool no_console_output;
 241
 242         ExecOutput default_std_output, default_std_error;
 243
 244         usec_t default_restart_usec, default_timeout_start_usec, default_timeout_stop_usec;
 245
 246         usec_t default_start_limit_interval;
 247         unsigned default_start_limit_burst;
 248
 249         bool default_cpu_accounting;
 250         bool default_memory_accounting;
 251         bool default_blockio_accounting;
 252
 253         usec_t default_timer_accuracy_usec;
 254
 255         struct rlimit *rlimit[_RLIMIT_MAX];
 256
 257         /* non-zero if we are reloading or reexecuting, */
 258         int n_reloading;
 259
 260         unsigned n_installed_jobs;
 261         unsigned n_failed_jobs;
 262
 263         /* Jobs in progress watching */
 264         unsigned n_running_jobs;
 265         unsigned n_on_console;
 266         unsigned jobs_in_progress_iteration;
 267
 268         /* Do we have any outstanding password prompts? */
 269         int have_ask_password;
 270         int ask_password_inotify_fd;
 271         sd_event_source *ask_password_event_source;
 272
 273         /* Type=idle pipes */
 274         int idle_pipe[4];
 275         sd_event_source *idle_pipe_event_source;
 276
 277         char *switch_root;
 278         char *switch_root_init;
 279
 280         /* This maps all possible path prefixes to the units needing
 281          * them. It's a hashmap with a path string as key and a Set as
 282          * value where Unit objects are contained. */
 283         Hashmap *units_requiring_mounts_for;
 284
 285         /* Reference to the kdbus bus control fd */
 286         int kdbus_fd;
 287
 288         /* Used for processing polkit authorization responses */
 289         Hashmap *polkit_registry;
 290 };
 291
 292 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **m);
 293 void manager_free(Manager *m);
 294
 295 int manager_enumerate(Manager *m);
 296 int manager_startup(Manager *m, FILE *serialization, FDSet *fds);
 297
 298 Job *manager_get_job(Manager *m, uint32_t id);
 299 Unit *manager_get_unit(Manager *m, const char *name);
 300
 301 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found);
 302
 303 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j);
 304
 305 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 306 int manager_load_unit(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 307 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u);
 308
 309 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool force, sd_bus_error *e, Job **_ret);
 310 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool force, sd_bus_error *e, Job **_ret);
 311
 312 void manager_dump_units(Manager *s, FILE *f, const char *prefix);
 313 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix);
 314
 315 void manager_clear_jobs(Manager *m);
 316
 317 unsigned manager_dispatch_load_queue(Manager *m);
 318
 319 int manager_environment_add(Manager *m, char **minus, char **plus);
 320 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit);
 321
 322 int manager_loop(Manager *m);
 323
 324 void manager_dispatch_bus_name_owner_changed(Manager *m, const char *name, const char* old_owner, const char *new_owner);
 325
 326 int manager_open_serialization(Manager *m, FILE **_f);
 327
 328 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root);
 329 int manager_deserialize(Manager *m, FILE *f, FDSet *fds);
 330
 331 int manager_reload(Manager *m);
 332
 333 bool manager_is_reloading_or_reexecuting(Manager *m) _pure_;
 334
 335 void manager_reset_failed(Manager *m);
 336
 337 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);
 338 void manager_send_unit_plymouth(Manager *m, Unit *u);
 339
 340 bool manager_unit_inactive_or_pending(Manager *m, const char *name);
 341
 342 void manager_check_finished(Manager *m);
 343
 344 void manager_run_generators(Manager *m);
 345 void manager_undo_generators(Manager *m);
 346
 347 void manager_recheck_journal(Manager *m);
 348
 349 void manager_set_show_status(Manager *m, ShowStatus mode);
 350 void manager_set_first_boot(Manager *m, bool b);
 351
 352 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) _printf_(4,5);
 353 void manager_flip_auto_status(Manager *m, bool enable);
 354
 355 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path);
 356
 357 const char *manager_get_runtime_prefix(Manager *m);
 358
 359 ManagerState manager_state(Manager *m);
 360
 361 const char *manager_state_to_string(ManagerState m) _const_;
 362 ManagerState manager_state_from_string(const char *s) _pure_;