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_errno(r, "Failed to get D-Bus connection: %m");
  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         q = parse_proc_cmdline(parse_proc_cmdline_item);
 240         if (q < 0)
 241                 log_warning_errno(q, "Failed to parse kernel command line, ignoring: %m");
 242
 243         test_files();
 244
 245         if (!arg_force && arg_skip)
 246                 return 0;
 247
 248         udev = udev_new();
 249         if (!udev) {
 250                 log_oom();
 251                 return EXIT_FAILURE;
 252         }
 253
 254         if (argc > 1) {
 255                 device = argv[1];
 256                 root_directory = false;
 257
 258                 if (stat(device, &st) < 0) {
 259                         log_error_errno(errno, "Failed to stat '%s': %m", device);
 260                         return EXIT_FAILURE;
 261                 }
 262
 263                 udev_device = udev_device_new_from_devnum(udev, 'b', st.st_rdev);
 264                 if (!udev_device) {
 265                         log_error("Failed to detect device %s", device);
 266                         return EXIT_FAILURE;
 267                 }
 268         } else {
 269                 struct timespec times[2];
 270
 271                 /* Find root device */
 272
 273                 if (stat("/", &st) < 0) {
 274                         log_error_errno(errno, "Failed to stat() the root directory: %m");
 275                         return EXIT_FAILURE;
 276                 }
 277
 278                 /* Virtual root devices don't need an fsck */
 279                 if (major(st.st_dev) == 0)
 280                         return EXIT_SUCCESS;
 281
 282                 /* check if we are already writable */
 283                 times[0] = st.st_atim;
 284                 times[1] = st.st_mtim;
 285                 if (utimensat(AT_FDCWD, "/", times, 0) == 0) {
 286                         log_info("Root directory is writable, skipping check.");
 287                         return EXIT_SUCCESS;
 288                 }
 289
 290                 udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev);
 291                 if (!udev_device) {
 292                         log_error("Failed to detect root device.");
 293                         return EXIT_FAILURE;
 294                 }
 295
 296                 device = udev_device_get_devnode(udev_device);
 297                 if (!device) {
 298                         log_error("Failed to detect device node of root directory.");
 299                         return EXIT_FAILURE;
 300                 }
 301
 302                 root_directory = true;
 303         }
 304
 305         type = udev_device_get_property_value(udev_device, "ID_FS_TYPE");
 306         if (type) {
 307                 r = fsck_exists(type);
 308                 if (r == -ENOENT) {
 309                         log_info("fsck.%s doesn't exist, not checking file system on %s", type, device);
 310                         return EXIT_SUCCESS;
 311                 } else if (r < 0)
 312                         log_warning_errno(r, "fsck.%s cannot be used for %s: %m", type, device);
 313         }
 314
 315         if (arg_show_progress)
 316                 if (pipe(progress_pipe) < 0) {
 317                         log_error_errno(errno, "pipe(): %m");
 318                         return EXIT_FAILURE;
 319                 }
 320
 321         cmdline[i++] = "/sbin/fsck";
 322         cmdline[i++] =  arg_repair;
 323         cmdline[i++] = "-T";
 324
 325         /*
 326          * Since util-linux v2.25 fsck uses /run/fsck/<diskname>.lock files.
 327          * The previous versions use flock for the device and conflict with
 328          * udevd, see https://bugs.freedesktop.org/show_bug.cgi?id=79576#c5
 329          */
 330         cmdline[i++] = "-l";
 331
 332         if (!root_directory)
 333                 cmdline[i++] = "-M";
 334
 335         if (arg_force)
 336                 cmdline[i++] = "-f";
 337
 338         if (progress_pipe[1] >= 0) {
 339                 snprintf(dash_c, sizeof(dash_c), "-C%i", progress_pipe[1]);
 340                 char_array_0(dash_c);
 341                 cmdline[i++] = dash_c;
 342         }
 343
 344         cmdline[i++] = device;
 345         cmdline[i++] = NULL;
 346
 347         pid = fork();
 348         if (pid < 0) {
 349                 log_error_errno(errno, "fork(): %m");
 350                 goto finish;
 351         } else if (pid == 0) {
 352                 /* Child */
 353                 if (progress_pipe[0] >= 0)
 354                         safe_close(progress_pipe[0]);
 355                 execv(cmdline[0], (char**) cmdline);
 356                 _exit(8); /* Operational error */
 357         }
 358
 359         progress_pipe[1] = safe_close(progress_pipe[1]);
 360
 361         if (progress_pipe[0] >= 0) {
 362                 process_progress(progress_pipe[0]);
 363                 progress_pipe[0] = -1;
 364         }
 365
 366         q = wait_for_terminate(pid, &status);
 367         if (q < 0) {
 368                 log_error_errno(q, "waitid(): %m");
 369                 goto finish;
 370         }
 371
 372         if (status.si_code != CLD_EXITED || (status.si_status & ~1)) {
 373
 374                 if (status.si_code == CLD_KILLED || status.si_code == CLD_DUMPED)
 375                         log_error("fsck terminated by signal %s.", signal_to_string(status.si_status));
 376                 else if (status.si_code == CLD_EXITED)
 377                         log_error("fsck failed with error code %i.", status.si_status);
 378                 else
 379                         log_error("fsck failed due to unknown reason.");
 380
 381                 if (status.si_code == CLD_EXITED && (status.si_status & 2) && root_directory)
 382                         /* System should be rebooted. */
 383                         start_target(SPECIAL_REBOOT_TARGET);
 384                 else if (status.si_code == CLD_EXITED && (status.si_status & 6))
 385                         /* Some other problem */
 386                         start_target(SPECIAL_EMERGENCY_TARGET);
 387                 else {
 388                         r = EXIT_SUCCESS;
 389                         log_warning("Ignoring error.");
 390                 }
 391
 392         } else
 393                 r = EXIT_SUCCESS;
 394
 395         if (status.si_code == CLD_EXITED && (status.si_status & 1))
 396                 touch("/run/systemd/quotacheck");
 397
 398 finish:
 399         safe_close_pair(progress_pipe);
 400
 401         return r;
 402 }