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