chiark / gitweb /
Revert "bus-proxyd: use a loop instead of c&p"
[elogind.git] / src / fsck / fsck.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <stdio.h>
23 #include <stdbool.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <sys/file.h>
29
30 #include "sd-bus.h"
31 #include "libudev.h"
32
33 #include "util.h"
34 #include "special.h"
35 #include "bus-util.h"
36 #include "bus-error.h"
37 #include "bus-errors.h"
38 #include "fileio.h"
39 #include "udev-util.h"
40
41 static bool arg_skip = false;
42 static bool arg_force = false;
43 static bool arg_show_progress = false;
44
45 static void start_target(const char *target) {
46         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
47         _cleanup_bus_unref_ sd_bus *bus = NULL;
48         int r;
49
50         assert(target);
51
52         r = bus_open_system_systemd(&bus);
53         if (r < 0) {
54                 log_error("Failed to get D-Bus connection: %s", strerror(-r));
55                 return;
56         }
57
58         log_info("Running request %s/start/replace", target);
59
60         /* Start these units only if we can replace base.target with it */
61         r = sd_bus_call_method(bus,
62                                "org.freedesktop.systemd1",
63                                "/org/freedesktop/systemd1",
64                                "org.freedesktop.systemd1.Manager",
65                                "StartUnitReplace",
66                                &error,
67                                NULL,
68                                "sss", "basic.target", target, "replace");
69
70         /* Don't print a warning if we aren't called during startup */
71         if (r < 0 && !sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_JOB))
72                 log_error("Failed to start unit: %s", bus_error_message(&error, -r));
73 }
74
75 static int parse_proc_cmdline(void) {
76         char *line, *w, *state;
77         size_t l;
78         int r;
79
80         r = proc_cmdline(&line);
81         if (r < 0)
82                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
83         if (r <= 0)
84                 return 0;
85
86         FOREACH_WORD_QUOTED(w, l, line, state) {
87
88                 if (strneq(w, "fsck.mode=auto", l))
89                         arg_force = arg_skip = false;
90                 else if (strneq(w, "fsck.mode=force", l))
91                         arg_force = true;
92                 else if (strneq(w, "fsck.mode=skip", l))
93                         arg_skip = true;
94                 else if (startswith(w, "fsck"))
95                         log_warning("Invalid fsck parameter. Ignoring.");
96 #ifdef HAVE_SYSV_COMPAT
97                 else if (strneq(w, "fastboot", l)) {
98                         log_error("Please pass 'fsck.mode=skip' rather than 'fastboot' on the kernel command line.");
99                         arg_skip = true;
100                 } else if (strneq(w, "forcefsck", l)) {
101                         log_error("Please pass 'fsck.mode=force' rather than 'forcefsck' on the kernel command line.");
102                         arg_force = true;
103                 }
104 #endif
105         }
106
107         free(line);
108         return 0;
109 }
110
111 static void test_files(void) {
112 #ifdef HAVE_SYSV_COMPAT
113         if (access("/fastboot", F_OK) >= 0) {
114                 log_error("Please pass 'fsck.mode=skip' on the kernel command line rather than creating /fastboot on the root file system.");
115                 arg_skip = true;
116         }
117
118         if (access("/forcefsck", F_OK) >= 0) {
119                 log_error("Please pass 'fsck.mode=force' on the kernel command line rather than creating /forcefsck on the root file system.");
120                 arg_force = true;
121         }
122 #endif
123
124         if (access("/run/systemd/show-status", F_OK) >= 0 || plymouth_running())
125                 arg_show_progress = true;
126 }
127
128 static double percent(int pass, unsigned long cur, unsigned long max) {
129         /* Values stolen from e2fsck */
130
131         static const int pass_table[] = {
132                 0, 70, 90, 92, 95, 100
133         };
134
135         if (pass <= 0)
136                 return 0.0;
137
138         if ((unsigned) pass >= ELEMENTSOF(pass_table) || max == 0)
139                 return 100.0;
140
141         return (double) pass_table[pass-1] +
142                 ((double) pass_table[pass] - (double) pass_table[pass-1]) *
143                 (double) cur / (double) max;
144 }
145
146 static int process_progress(int fd) {
147         _cleanup_fclose_ FILE *console = NULL, *f = NULL;
148         usec_t last = 0;
149         bool locked = false;
150         int clear = 0;
151
152         f = fdopen(fd, "r");
153         if (!f) {
154                 close_nointr_nofail(fd);
155                 return -errno;
156         }
157
158         console = fopen("/dev/console", "w");
159         if (!console)
160                 return -ENOMEM;
161
162         while (!feof(f)) {
163                 int pass, m;
164                 unsigned long cur, max;
165                 _cleanup_free_ char *device = NULL;
166                 double p;
167                 usec_t t;
168
169                 if (fscanf(f, "%i %lu %lu %ms", &pass, &cur, &max, &device) != 4)
170                         break;
171
172                 /* Only show one progress counter at max */
173                 if (!locked) {
174                         if (flock(fileno(console), LOCK_EX|LOCK_NB) < 0)
175                                 continue;
176
177                         locked = true;
178                 }
179
180                 /* Only update once every 50ms */
181                 t = now(CLOCK_MONOTONIC);
182                 if (last + 50 * USEC_PER_MSEC > t)
183                         continue;
184
185                 last = t;
186
187                 p = percent(pass, cur, max);
188                 fprintf(console, "\r%s: fsck %3.1f%% complete...\r%n", device, p, &m);
189                 fflush(console);
190
191                 if (m > clear)
192                         clear = m;
193         }
194
195         if (clear > 0) {
196                 unsigned j;
197
198                 fputc('\r', console);
199                 for (j = 0; j < (unsigned) clear; j++)
200                         fputc(' ', console);
201                 fputc('\r', console);
202                 fflush(console);
203         }
204
205         return 0;
206 }
207
208 int main(int argc, char *argv[]) {
209         const char *cmdline[9];
210         int i = 0, r = EXIT_FAILURE, q;
211         pid_t pid;
212         siginfo_t status;
213         _cleanup_udev_unref_ struct udev *udev = NULL;
214         _cleanup_udev_device_unref_ struct udev_device *udev_device = NULL;
215         const char *device, *type;
216         bool root_directory;
217         int progress_pipe[2] = { -1, -1 };
218         char dash_c[2+10+1];
219         struct stat st;
220
221         if (argc > 2) {
222                 log_error("This program expects one or no arguments.");
223                 return EXIT_FAILURE;
224         }
225
226         log_set_target(LOG_TARGET_AUTO);
227         log_parse_environment();
228         log_open();
229
230         umask(0022);
231
232         parse_proc_cmdline();
233         test_files();
234
235         if (!arg_force && arg_skip)
236                 return 0;
237
238         udev = udev_new();
239         if (!udev) {
240                 log_oom();
241                 return EXIT_FAILURE;
242         }
243
244         if (argc > 1) {
245                 device = argv[1];
246                 root_directory = false;
247
248                 if (stat(device, &st) < 0) {
249                         log_error("Failed to stat '%s': %m", device);
250                         return EXIT_FAILURE;
251                 }
252
253                 udev_device = udev_device_new_from_devnum(udev, 'b', st.st_rdev);
254                 if (!udev_device) {
255                         log_error("Failed to detect device %s", device);
256                         return EXIT_FAILURE;
257                 }
258         } else {
259                 struct timespec times[2];
260
261                 /* Find root device */
262
263                 if (stat("/", &st) < 0) {
264                         log_error("Failed to stat() the root directory: %m");
265                         return EXIT_FAILURE;
266                 }
267
268                 /* Virtual root devices don't need an fsck */
269                 if (major(st.st_dev) == 0)
270                         return EXIT_SUCCESS;
271
272                 /* check if we are already writable */
273                 times[0] = st.st_atim;
274                 times[1] = st.st_mtim;
275                 if (utimensat(AT_FDCWD, "/", times, 0) == 0) {
276                         log_info("Root directory is writable, skipping check.");
277                         return EXIT_SUCCESS;
278                 }
279
280                 udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev);
281                 if (!udev_device) {
282                         log_error("Failed to detect root device.");
283                         return EXIT_FAILURE;
284                 }
285
286                 device = udev_device_get_devnode(udev_device);
287                 if (!device) {
288                         log_error("Failed to detect device node of root directory.");
289                         return EXIT_FAILURE;
290                 }
291
292                 root_directory = true;
293         }
294
295         type = udev_device_get_property_value(udev_device, "ID_FS_TYPE");
296         if (type) {
297                 const char *checker = strappenda("/sbin/fsck.", type);
298                 r = access(checker, X_OK);
299                 if (r < 0) {
300                         if (errno == ENOENT) {
301                                 log_info("%s doesn't exist, not checking file system.", checker);
302                                 return EXIT_SUCCESS;
303                         } else
304                                 log_warning("%s cannot be used: %m", checker);
305                 }
306         }
307
308         if (arg_show_progress)
309                 if (pipe(progress_pipe) < 0) {
310                         log_error("pipe(): %m");
311                         return EXIT_FAILURE;
312                 }
313
314         cmdline[i++] = "/sbin/fsck";
315         cmdline[i++] = "-a";
316         cmdline[i++] = "-T";
317         cmdline[i++] = "-l";
318
319         if (!root_directory)
320                 cmdline[i++] = "-M";
321
322         if (arg_force)
323                 cmdline[i++] = "-f";
324
325         if (progress_pipe[1] >= 0) {
326                 snprintf(dash_c, sizeof(dash_c), "-C%i", progress_pipe[1]);
327                 char_array_0(dash_c);
328                 cmdline[i++] = dash_c;
329         }
330
331         cmdline[i++] = device;
332         cmdline[i++] = NULL;
333
334         pid = fork();
335         if (pid < 0) {
336                 log_error("fork(): %m");
337                 goto finish;
338         } else if (pid == 0) {
339                 /* Child */
340                 if (progress_pipe[0] >= 0)
341                         close_nointr_nofail(progress_pipe[0]);
342                 execv(cmdline[0], (char**) cmdline);
343                 _exit(8); /* Operational error */
344         }
345
346         if (progress_pipe[1] >= 0) {
347                 close_nointr_nofail(progress_pipe[1]);
348                 progress_pipe[1] = -1;
349         }
350
351         if (progress_pipe[0] >= 0) {
352                 process_progress(progress_pipe[0]);
353                 progress_pipe[0] = -1;
354         }
355
356         q = wait_for_terminate(pid, &status);
357         if (q < 0) {
358                 log_error("waitid(): %s", strerror(-q));
359                 goto finish;
360         }
361
362         if (status.si_code != CLD_EXITED || (status.si_status & ~1)) {
363
364                 if (status.si_code == CLD_KILLED || status.si_code == CLD_DUMPED)
365                         log_error("fsck terminated by signal %s.", signal_to_string(status.si_status));
366                 else if (status.si_code == CLD_EXITED)
367                         log_error("fsck failed with error code %i.", status.si_status);
368                 else
369                         log_error("fsck failed due to unknown reason.");
370
371                 if (status.si_code == CLD_EXITED && (status.si_status & 2) && root_directory)
372                         /* System should be rebooted. */
373                         start_target(SPECIAL_REBOOT_TARGET);
374                 else if (status.si_code == CLD_EXITED && (status.si_status & 6))
375                         /* Some other problem */
376                         start_target(SPECIAL_EMERGENCY_TARGET);
377                 else {
378                         r = EXIT_SUCCESS;
379                         log_warning("Ignoring error.");
380                 }
381
382         } else
383                 r = EXIT_SUCCESS;
384
385         if (status.si_code == CLD_EXITED && (status.si_status & 1))
386                 touch("/run/systemd/quotacheck");
387
388 finish:
389         close_pipe(progress_pipe);
390
391         return r;
392 }