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