src/fsck/fsck.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5   Copyright 2014 Holger Hans Peter Freyther
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <stdbool.h>
  24 #include <stdio.h>
  25 #include <sys/file.h>
  26 #include <sys/prctl.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29
  30 #include "sd-bus.h"
  31 #include "sd-device.h"
  32
  33 #include "alloc-util.h"
  34 #include "bus-common-errors.h"
  35 #include "bus-error.h"
  36 #include "bus-util.h"
  37 #include "device-util.h"
  38 #include "fd-util.h"
  39 #include "fs-util.h"
  40 #include "parse-util.h"
  41 #include "path-util.h"
  42 #include "proc-cmdline.h"
  43 #include "process-util.h"
  44 #include "signal-util.h"
  45 #include "socket-util.h"
  46 #include "special.h"
  47 #include "stdio-util.h"
  48 #include "util.h"
  49
  50 /* exit codes as defined in fsck(8) */
  51 enum {
  52         FSCK_SUCCESS = 0,
  53         FSCK_ERROR_CORRECTED = 1,
  54         FSCK_SYSTEM_SHOULD_REBOOT = 2,
  55         FSCK_ERRORS_LEFT_UNCORRECTED = 4,
  56         FSCK_OPERATIONAL_ERROR = 8,
  57         FSCK_USAGE_OR_SYNTAX_ERROR = 16,
  58         FSCK_USER_CANCELLED = 32,
  59         FSCK_SHARED_LIB_ERROR = 128,
  60 };
  61
  62 static bool arg_skip = false;
  63 static bool arg_force = false;
  64 static bool arg_show_progress = false;
  65 static const char *arg_repair = "-a";
  66
  67 static void start_target(const char *target, const char *mode) {
  68         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
  69         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
  70         int r;
  71
  72         assert(target);
  73
  74         r = bus_connect_system_systemd(&bus);
  75         if (r < 0) {
  76                 log_error_errno(r, "Failed to get D-Bus connection: %m");
  77                 return;
  78         }
  79
  80         log_info("Running request %s/start/replace", target);
  81
  82         /* Start these units only if we can replace base.target with it */
  83         r = sd_bus_call_method(bus,
  84                                "org.freedesktop.systemd1",
  85                                "/org/freedesktop/systemd1",
  86                                "org.freedesktop.systemd1.Manager",
  87                                "StartUnitReplace",
  88                                &error,
  89                                NULL,
  90                                "sss", "basic.target", target, mode);
  91
  92         /* Don't print a warning if we aren't called during startup */
  93         if (r < 0 && !sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_JOB))
  94                 log_error("Failed to start unit: %s", bus_error_message(&error, r));
  95 }
  96
  97 static int parse_proc_cmdline_item(const char *key, const char *value) {
  98         int r;
  99
 100         assert(key);
 101
 102         if (streq(key, "fsck.mode") && value) {
 103
 104                 if (streq(value, "auto"))
 105                         arg_force = arg_skip = false;
 106                 else if (streq(value, "force"))
 107                         arg_force = true;
 108                 else if (streq(value, "skip"))
 109                         arg_skip = true;
 110                 else
 111                         log_warning("Invalid fsck.mode= parameter '%s'. Ignoring.", value);
 112
 113         } else if (streq(key, "fsck.repair") && value) {
 114
 115                 if (streq(value, "preen"))
 116                         arg_repair = "-a";
 117                 else {
 118                         r = parse_boolean(value);
 119                         if (r > 0)
 120                                 arg_repair = "-y";
 121                         else if (r == 0)
 122                                 arg_repair = "-n";
 123                         else
 124                                 log_warning("Invalid fsck.repair= parameter '%s'. Ignoring.", value);
 125                 }
 126         }
 127
 128 #ifdef HAVE_SYSV_COMPAT
 129         else if (streq(key, "fastboot") && !value) {
 130                 log_warning("Please pass 'fsck.mode=skip' rather than 'fastboot' on the kernel command line.");
 131                 arg_skip = true;
 132
 133         } else if (streq(key, "forcefsck") && !value) {
 134                 log_warning("Please pass 'fsck.mode=force' rather than 'forcefsck' on the kernel command line.");
 135                 arg_force = true;
 136         }
 137 #endif
 138
 139         return 0;
 140 }
 141
 142 static void test_files(void) {
 143
 144 #ifdef HAVE_SYSV_COMPAT
 145         if (access("/fastboot", F_OK) >= 0) {
 146                 log_error("Please pass 'fsck.mode=skip' on the kernel command line rather than creating /fastboot on the root file system.");
 147                 arg_skip = true;
 148         }
 149
 150         if (access("/forcefsck", F_OK) >= 0) {
 151                 log_error("Please pass 'fsck.mode=force' on the kernel command line rather than creating /forcefsck on the root file system.");
 152                 arg_force = true;
 153         }
 154 #endif
 155
 156         arg_show_progress = access("/run/systemd/show-status", F_OK) >= 0;
 157 }
 158
 159 static double percent(int pass, unsigned long cur, unsigned long max) {
 160         /* Values stolen from e2fsck */
 161
 162         static const int pass_table[] = {
 163                 0, 70, 90, 92, 95, 100
 164         };
 165
 166         if (pass <= 0)
 167                 return 0.0;
 168
 169         if ((unsigned) pass >= ELEMENTSOF(pass_table) || max == 0)
 170                 return 100.0;
 171
 172         return (double) pass_table[pass-1] +
 173                 ((double) pass_table[pass] - (double) pass_table[pass-1]) *
 174                 (double) cur / (double) max;
 175 }
 176
 177 static int process_progress(int fd) {
 178         _cleanup_fclose_ FILE *console = NULL, *f = NULL;
 179         usec_t last = 0;
 180         bool locked = false;
 181         int clear = 0, r;
 182
 183         /* No progress pipe to process? Then we are a NOP. */
 184         if (fd < 0)
 185                 return 0;
 186
 187         f = fdopen(fd, "re");
 188         if (!f) {
 189                 safe_close(fd);
 190                 return -errno;
 191         }
 192
 193         console = fopen("/dev/console", "we");
 194         if (!console)
 195                 return -ENOMEM;
 196
 197         for (;;) {
 198                 int pass, m;
 199                 unsigned long cur, max;
 200                 _cleanup_free_ char *device = NULL;
 201                 double p;
 202                 usec_t t;
 203
 204                 if (fscanf(f, "%i %lu %lu %ms", &pass, &cur, &max, &device) != 4) {
 205
 206                         if (ferror(f))
 207                                 r = log_warning_errno(errno, "Failed to read from progress pipe: %m");
 208                         else if (feof(f))
 209                                 r = 0;
 210                         else {
 211                                 log_warning("Failed to parse progress pipe data");
 212                                 r = -EBADMSG;
 213                         }
 214                         break;
 215                 }
 216
 217                 /* Only show one progress counter at max */
 218                 if (!locked) {
 219                         if (flock(fileno(console), LOCK_EX|LOCK_NB) < 0)
 220                                 continue;
 221
 222                         locked = true;
 223                 }
 224
 225                 /* Only update once every 50ms */
 226                 t = now(CLOCK_MONOTONIC);
 227                 if (last + 50 * USEC_PER_MSEC > t)
 228                         continue;
 229
 230                 last = t;
 231
 232                 p = percent(pass, cur, max);
 233                 fprintf(console, "\r%s: fsck %3.1f%% complete...\r%n", device, p, &m);
 234                 fflush(console);
 235
 236                 if (m > clear)
 237                         clear = m;
 238         }
 239
 240         if (clear > 0) {
 241                 unsigned j;
 242
 243                 fputc('\r', console);
 244                 for (j = 0; j < (unsigned) clear; j++)
 245                         fputc(' ', console);
 246                 fputc('\r', console);
 247                 fflush(console);
 248         }
 249
 250         return r;
 251 }
 252
 253 static int fsck_progress_socket(void) {
 254         static const union sockaddr_union sa = {
 255                 .un.sun_family = AF_UNIX,
 256                 .un.sun_path = "/run/systemd/fsck.progress",
 257         };
 258
 259         int fd, r;
 260
 261         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 262         if (fd < 0)
 263                 return log_warning_errno(errno, "socket(): %m");
 264
 265         if (connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
 266                 r = log_full_errno(errno == ECONNREFUSED || errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
 267                                    errno, "Failed to connect to progress socket %s, ignoring: %m", sa.un.sun_path);
 268                 safe_close(fd);
 269                 return r;
 270         }
 271
 272         return fd;
 273 }
 274
 275 int main(int argc, char *argv[]) {
 276         _cleanup_close_pair_ int progress_pipe[2] = { -1, -1 };
 277         _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
 278         const char *device, *type;
 279         bool root_directory;
 280         siginfo_t status;
 281         struct stat st;
 282         int r;
 283         pid_t pid;
 284
 285         if (argc > 2) {
 286                 log_error("This program expects one or no arguments.");
 287                 return EXIT_FAILURE;
 288         }
 289
 290         log_set_target(LOG_TARGET_AUTO);
 291         log_parse_environment();
 292         log_open();
 293
 294         umask(0022);
 295
 296         r = parse_proc_cmdline(parse_proc_cmdline_item);
 297         if (r < 0)
 298                 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
 299
 300         test_files();
 301
 302         if (!arg_force && arg_skip) {
 303                 r = 0;
 304                 goto finish;
 305         }
 306
 307         if (argc > 1) {
 308                 device = argv[1];
 309
 310                 if (stat(device, &st) < 0) {
 311                         r = log_error_errno(errno, "Failed to stat %s: %m", device);
 312                         goto finish;
 313                 }
 314
 315                 if (!S_ISBLK(st.st_mode)) {
 316                         log_error("%s is not a block device.", device);
 317                         r = -EINVAL;
 318                         goto finish;
 319                 }
 320
 321                 r = sd_device_new_from_devnum(&dev, 'b', st.st_rdev);
 322                 if (r < 0) {
 323                         log_error_errno(r, "Failed to detect device %s: %m", device);
 324                         goto finish;
 325                 }
 326
 327                 root_directory = false;
 328         } else {
 329                 struct timespec times[2];
 330
 331                 /* Find root device */
 332
 333                 if (stat("/", &st) < 0) {
 334                         r = log_error_errno(errno, "Failed to stat() the root directory: %m");
 335                         goto finish;
 336                 }
 337
 338                 /* Virtual root devices don't need an fsck */
 339                 if (major(st.st_dev) == 0) {
 340                         log_debug("Root directory is virtual or btrfs, skipping check.");
 341                         r = 0;
 342                         goto finish;
 343                 }
 344
 345                 /* check if we are already writable */
 346                 times[0] = st.st_atim;
 347                 times[1] = st.st_mtim;
 348
 349                 if (utimensat(AT_FDCWD, "/", times, 0) == 0) {
 350                         log_info("Root directory is writable, skipping check.");
 351                         r = 0;
 352                         goto finish;
 353                 }
 354
 355                 r = sd_device_new_from_devnum(&dev, 'b', st.st_dev);
 356                 if (r < 0) {
 357                         log_error_errno(r, "Failed to detect root device: %m");
 358                         goto finish;
 359                 }
 360
 361                 r = sd_device_get_devname(dev, &device);
 362                 if (r < 0) {
 363                         log_error_errno(r, "Failed to detect device node of root directory: %m");
 364                         goto finish;
 365                 }
 366
 367                 root_directory = true;
 368         }
 369
 370         r = sd_device_get_property_value(dev, "ID_FS_TYPE", &type);
 371         if (r >= 0) {
 372                 r = fsck_exists(type);
 373                 if (r < 0)
 374                         log_warning_errno(r, "Couldn't detect if fsck.%s may be used for %s, proceeding: %m", type, device);
 375                 else if (r == 0) {
 376                         log_info("fsck.%s doesn't exist, not checking file system on %s.", type, device);
 377                         goto finish;
 378                 }
 379         }
 380
 381         if (arg_show_progress) {
 382                 if (pipe(progress_pipe) < 0) {
 383                         r = log_error_errno(errno, "pipe(): %m");
 384                         goto finish;
 385                 }
 386         }
 387
 388         pid = fork();
 389         if (pid < 0) {
 390                 r = log_error_errno(errno, "fork(): %m");
 391                 goto finish;
 392         }
 393         if (pid == 0) {
 394                 char dash_c[sizeof("-C")-1 + DECIMAL_STR_MAX(int) + 1];
 395                 int progress_socket = -1;
 396                 const char *cmdline[9];
 397                 int i = 0;
 398
 399                 /* Child */
 400
 401                 (void) reset_all_signal_handlers();
 402                 (void) reset_signal_mask();
 403                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
 404
 405                 /* Close the reading side of the progress pipe */
 406                 progress_pipe[0] = safe_close(progress_pipe[0]);
 407
 408                 /* Try to connect to a progress management daemon, if there is one */
 409                 progress_socket = fsck_progress_socket();
 410                 if (progress_socket >= 0) {
 411                         /* If this worked we close the progress pipe early, and just use the socket */
 412                         progress_pipe[1] = safe_close(progress_pipe[1]);
 413                         xsprintf(dash_c, "-C%i", progress_socket);
 414                 } else if (progress_pipe[1] >= 0) {
 415                         /* Otherwise if we have the progress pipe to our own local handle, we use it */
 416                         xsprintf(dash_c, "-C%i", progress_pipe[1]);
 417                 } else
 418                         dash_c[0] = 0;
 419
 420                 cmdline[i++] = "/sbin/fsck";
 421                 cmdline[i++] =  arg_repair;
 422                 cmdline[i++] = "-T";
 423
 424                 /*
 425                  * Since util-linux v2.25 fsck uses /run/fsck/<diskname>.lock files.
 426                  * The previous versions use flock for the device and conflict with
 427                  * udevd, see https://bugs.freedesktop.org/show_bug.cgi?id=79576#c5
 428                  */
 429                 cmdline[i++] = "-l";
 430
 431                 if (!root_directory)
 432                         cmdline[i++] = "-M";
 433
 434                 if (arg_force)
 435                         cmdline[i++] = "-f";
 436
 437                 if (!isempty(dash_c))
 438                         cmdline[i++] = dash_c;
 439
 440                 cmdline[i++] = device;
 441                 cmdline[i++] = NULL;
 442
 443                 execv(cmdline[0], (char**) cmdline);
 444                 _exit(FSCK_OPERATIONAL_ERROR);
 445         }
 446
 447         progress_pipe[1] = safe_close(progress_pipe[1]);
 448         (void) process_progress(progress_pipe[0]);
 449         progress_pipe[0] = -1;
 450
 451         r = wait_for_terminate(pid, &status);
 452         if (r < 0) {
 453                 log_error_errno(r, "waitid(): %m");
 454                 goto finish;
 455         }
 456
 457         if (status.si_code != CLD_EXITED || (status.si_status & ~1)) {
 458
 459                 if (status.si_code == CLD_KILLED || status.si_code == CLD_DUMPED)
 460                         log_error("fsck terminated by signal %s.", signal_to_string(status.si_status));
 461                 else if (status.si_code == CLD_EXITED)
 462                         log_error("fsck failed with error code %i.", status.si_status);
 463                 else
 464                         log_error("fsck failed due to unknown reason.");
 465
 466                 r = -EINVAL;
 467
 468                 if (status.si_code == CLD_EXITED && (status.si_status & FSCK_SYSTEM_SHOULD_REBOOT) && root_directory)
 469                         /* System should be rebooted. */
 470                         start_target(SPECIAL_REBOOT_TARGET, "replace-irreversibly");
 471                 else if (status.si_code == CLD_EXITED && (status.si_status & (FSCK_SYSTEM_SHOULD_REBOOT | FSCK_ERRORS_LEFT_UNCORRECTED)))
 472                         /* Some other problem */
 473                         start_target(SPECIAL_EMERGENCY_TARGET, "replace");
 474                 else {
 475                         log_warning("Ignoring error.");
 476                         r = 0;
 477                 }
 478
 479         } else
 480                 r = 0;
 481
 482         if (status.si_code == CLD_EXITED && (status.si_status & FSCK_ERROR_CORRECTED))
 483                 (void) touch("/run/systemd/quotacheck");
 484
 485 finish:
 486         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 487 }