chiark / gitweb /
core: output unit status output strings to console, only if we actually are changing...
[elogind.git] / 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_;