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