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