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