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