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