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 <string.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <sys/file.h>
  30 #include <sys/stat.h>
  31
  32 #include "sd-bus.h"
  33 #include "libudev.h"
  34
  35 #include "util.h"
  36 #include "special.h"
  37 #include "bus-util.h"
  38 #include "bus-error.h"
  39 #include "bus-common-errors.h"
  40 #include "fileio.h"
  41 #include "udev-util.h"
  42 #include "path-util.h"
  43 #include "socket-util.h"
  44 #include "fsckd/fsckd.h"
  45
  46 static bool arg_skip = false;
  47 static bool arg_force = false;
  48 static bool arg_show_progress = false;
  49 static const char *arg_repair = "-a";
  50
  51 static void start_target(const char *target) {
  52         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
  53         _cleanup_bus_close_unref_ sd_bus *bus = NULL;
  54         int r;
  55
  56         assert(target);
  57
  58         r = bus_open_system_systemd(&bus);
  59         if (r < 0) {
  60                 log_error_errno(r, "Failed to get D-Bus connection: %m");
  61                 return;
  62         }
  63
  64         log_info("Running request %s/start/replace", target);
  65
  66         /* Start these units only if we can replace base.target with it */
  67         r = sd_bus_call_method(bus,
  68                                "org.freedesktop.systemd1",
  69                                "/org/freedesktop/systemd1",
  70                                "org.freedesktop.systemd1.Manager",
  71                                "StartUnitReplace",
  72                                &error,
  73                                NULL,
  74                                "sss", "basic.target", target, "replace");
  75
  76         /* Don't print a warning if we aren't called during startup */
  77         if (r < 0 && !sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_JOB))
  78                 log_error("Failed to start unit: %s", bus_error_message(&error, -r));
  79 }
  80
  81 static int parse_proc_cmdline_item(const char *key, const char *value) {
  82
  83         if (streq(key, "fsck.mode") && value) {
  84
  85                 if (streq(value, "auto"))
  86                         arg_force = arg_skip = false;
  87                 else if (streq(value, "force"))
  88                         arg_force = true;
  89                 else if (streq(value, "skip"))
  90                         arg_skip = true;
  91                 else
  92                         log_warning("Invalid fsck.mode= parameter '%s'. Ignoring.", value);
  93
  94         } else if (streq(key, "fsck.repair") && value) {
  95
  96                 if (streq(value, "preen"))
  97                         arg_repair = "-a";
  98                 else if (streq(value, "yes"))
  99                         arg_repair = "-y";
 100                 else if (streq(value, "no"))
 101                         arg_repair = "-n";
 102                 else
 103                         log_warning("Invalid fsck.repair= parameter '%s'. Ignoring.", value);
 104         }
 105
 106 #ifdef HAVE_SYSV_COMPAT
 107         else if (streq(key, "fastboot") && !value) {
 108                 log_warning("Please pass 'fsck.mode=skip' rather than 'fastboot' on the kernel command line.");
 109                 arg_skip = true;
 110
 111         } else if (streq(key, "forcefsck") && !value) {
 112                 log_warning("Please pass 'fsck.mode=force' rather than 'forcefsck' on the kernel command line.");
 113                 arg_force = true;
 114         }
 115 #endif
 116
 117         return 0;
 118 }
 119
 120 static void test_files(void) {
 121
 122 #ifdef HAVE_SYSV_COMPAT
 123         if (access("/fastboot", F_OK) >= 0) {
 124                 log_error("Please pass 'fsck.mode=skip' on the kernel command line rather than creating /fastboot on the root file system.");
 125                 arg_skip = true;
 126         }
 127
 128         if (access("/forcefsck", F_OK) >= 0) {
 129                 log_error("Please pass 'fsck.mode=force' on the kernel command line rather than creating /forcefsck on the root file system.");
 130                 arg_force = true;
 131         }
 132 #endif
 133
 134         if (access("/run/systemd/show-status", F_OK) >= 0 || plymouth_running())
 135                 arg_show_progress = true;
 136 }
 137
 138 static int process_progress(int fd, dev_t device_num) {
 139         _cleanup_fclose_ FILE *f = NULL;
 140         usec_t last = 0;
 141         _cleanup_close_ int fsckd_fd = -1;
 142         static const union sockaddr_union sa = {
 143                 .un.sun_family = AF_UNIX,
 144                 .un.sun_path = FSCKD_SOCKET_PATH,
 145         };
 146
 147         fsckd_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
 148         if (fsckd_fd < 0)
 149                 return log_warning_errno(errno, "Cannot open fsckd socket, we won't report fsck progress: %m");
 150         if (connect(fsckd_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0)
 151                 return log_warning_errno(errno, "Cannot connect to fsckd socket, we won't report fsck progress: %m");
 152
 153         f = fdopen(fd, "r");
 154         if (!f)
 155                 return log_warning_errno(errno, "Cannot connect to fsck, we won't report fsck progress: %m");
 156
 157         while (!feof(f)) {
 158                 int pass;
 159                 size_t cur, max;
 160                 ssize_t n;
 161                 usec_t t;
 162                 _cleanup_free_ char *device = NULL;
 163                 FsckProgress progress;
 164
 165                 if (fscanf(f, "%i %lu %lu %ms", &pass, &cur, &max, &device) != 4)
 166                         break;
 167
 168                 /* Only update once every 50ms */
 169                 t = now(CLOCK_MONOTONIC);
 170                 if (last + 50 * USEC_PER_MSEC > t)
 171                         continue;
 172
 173                 last = t;
 174
 175                 /* send progress to fsckd */
 176                 progress.devnum = device_num;
 177                 progress.cur = cur;
 178                 progress.max = max;
 179                 progress.pass = pass;
 180
 181                 n = send(fsckd_fd, &progress, sizeof(FsckProgress), 0);
 182                 if (n < 0 || (size_t) n < sizeof(FsckProgress))
 183                         log_warning_errno(errno, "Cannot communicate fsck progress to fsckd: %m");
 184         }
 185
 186         return 0;
 187 }
 188
 189 int main(int argc, char *argv[]) {
 190         const char *cmdline[9];
 191         int i = 0, r = EXIT_FAILURE, q;
 192         pid_t pid;
 193         siginfo_t status;
 194         _cleanup_udev_unref_ struct udev *udev = NULL;
 195         _cleanup_udev_device_unref_ struct udev_device *udev_device = NULL;
 196         const char *device, *type;
 197         bool root_directory;
 198         int progress_pipe[2] = { -1, -1 };
 199         char dash_c[sizeof("-C")-1 + DECIMAL_STR_MAX(int) + 1];
 200         struct stat st;
 201
 202         if (argc > 2) {
 203                 log_error("This program expects one or no arguments.");
 204                 return EXIT_FAILURE;
 205         }
 206
 207         log_set_target(LOG_TARGET_AUTO);
 208         log_parse_environment();
 209         log_open();
 210
 211         umask(0022);
 212
 213         q = parse_proc_cmdline(parse_proc_cmdline_item);
 214         if (q < 0)
 215                 log_warning_errno(q, "Failed to parse kernel command line, ignoring: %m");
 216
 217         test_files();
 218
 219         if (!arg_force && arg_skip)
 220                 return 0;
 221
 222         udev = udev_new();
 223         if (!udev) {
 224                 log_oom();
 225                 return EXIT_FAILURE;
 226         }
 227
 228         if (argc > 1) {
 229                 device = argv[1];
 230                 root_directory = false;
 231
 232                 if (stat(device, &st) < 0) {
 233                         log_error_errno(errno, "Failed to stat '%s': %m", device);
 234                         return EXIT_FAILURE;
 235                 }
 236
 237                 udev_device = udev_device_new_from_devnum(udev, 'b', st.st_rdev);
 238                 if (!udev_device) {
 239                         log_error("Failed to detect device %s", device);
 240                         return EXIT_FAILURE;
 241                 }
 242         } else {
 243                 struct timespec times[2];
 244
 245                 /* Find root device */
 246
 247                 if (stat("/", &st) < 0) {
 248                         log_error_errno(errno, "Failed to stat() the root directory: %m");
 249                         return EXIT_FAILURE;
 250                 }
 251
 252                 /* Virtual root devices don't need an fsck */
 253                 if (major(st.st_dev) == 0)
 254                         return EXIT_SUCCESS;
 255
 256                 /* check if we are already writable */
 257                 times[0] = st.st_atim;
 258                 times[1] = st.st_mtim;
 259                 if (utimensat(AT_FDCWD, "/", times, 0) == 0) {
 260                         log_info("Root directory is writable, skipping check.");
 261                         return EXIT_SUCCESS;
 262                 }
 263
 264                 udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev);
 265                 if (!udev_device) {
 266                         log_error("Failed to detect root device.");
 267                         return EXIT_FAILURE;
 268                 }
 269
 270                 device = udev_device_get_devnode(udev_device);
 271                 if (!device) {
 272                         log_error("Failed to detect device node of root directory.");
 273                         return EXIT_FAILURE;
 274                 }
 275
 276                 root_directory = true;
 277         }
 278
 279         type = udev_device_get_property_value(udev_device, "ID_FS_TYPE");
 280         if (type) {
 281                 r = fsck_exists(type);
 282                 if (r == -ENOENT) {
 283                         log_info("fsck.%s doesn't exist, not checking file system on %s", type, device);
 284                         return EXIT_SUCCESS;
 285                 } else if (r < 0)
 286                         log_warning_errno(r, "fsck.%s cannot be used for %s: %m", type, device);
 287         }
 288
 289         if (arg_show_progress)
 290                 if (pipe(progress_pipe) < 0) {
 291                         log_error_errno(errno, "pipe(): %m");
 292                         return EXIT_FAILURE;
 293                 }
 294
 295         cmdline[i++] = "/sbin/fsck";
 296         cmdline[i++] =  arg_repair;
 297         cmdline[i++] = "-T";
 298
 299         /*
 300          * Since util-linux v2.25 fsck uses /run/fsck/<diskname>.lock files.
 301          * The previous versions use flock for the device and conflict with
 302          * udevd, see https://bugs.freedesktop.org/show_bug.cgi?id=79576#c5
 303          */
 304         cmdline[i++] = "-l";
 305
 306         if (!root_directory)
 307                 cmdline[i++] = "-M";
 308
 309         if (arg_force)
 310                 cmdline[i++] = "-f";
 311
 312         if (progress_pipe[1] >= 0) {
 313                 xsprintf(dash_c, "-C%i", progress_pipe[1]);
 314                 cmdline[i++] = dash_c;
 315         }
 316
 317         cmdline[i++] = device;
 318         cmdline[i++] = NULL;
 319
 320         pid = fork();
 321         if (pid < 0) {
 322                 log_error_errno(errno, "fork(): %m");
 323                 goto finish;
 324         } else if (pid == 0) {
 325                 /* Child */
 326                 if (progress_pipe[0] >= 0)
 327                         safe_close(progress_pipe[0]);
 328                 execv(cmdline[0], (char**) cmdline);
 329                 _exit(8); /* Operational error */
 330         }
 331
 332         progress_pipe[1] = safe_close(progress_pipe[1]);
 333
 334         if (progress_pipe[0] >= 0) {
 335                 process_progress(progress_pipe[0], st.st_rdev);
 336                 progress_pipe[0] = -1;
 337         }
 338
 339         q = wait_for_terminate(pid, &status);
 340         if (q < 0) {
 341                 log_error_errno(q, "waitid(): %m");
 342                 goto finish;
 343         }
 344
 345         if (status.si_code != CLD_EXITED || (status.si_status & ~1)) {
 346
 347                 if (status.si_code == CLD_KILLED || status.si_code == CLD_DUMPED)
 348                         log_error("fsck terminated by signal %s.", signal_to_string(status.si_status));
 349                 else if (status.si_code == CLD_EXITED)
 350                         log_error("fsck failed with error code %i.", status.si_status);
 351                 else
 352                         log_error("fsck failed due to unknown reason.");
 353
 354                 if (status.si_code == CLD_EXITED && (status.si_status & 2) && root_directory)
 355                         /* System should be rebooted. */
 356                         start_target(SPECIAL_REBOOT_TARGET);
 357                 else if (status.si_code == CLD_EXITED && (status.si_status & 6))
 358                         /* Some other problem */
 359                         start_target(SPECIAL_EMERGENCY_TARGET);
 360                 else {
 361                         r = EXIT_SUCCESS;
 362                         log_warning("Ignoring error.");
 363                 }
 364
 365         } else
 366                 r = EXIT_SUCCESS;
 367
 368         if (status.si_code == CLD_EXITED && (status.si_status & 1))
 369                 touch("/run/systemd/quotacheck");
 370
 371 finish:
 372         safe_close_pair(progress_pipe);
 373
 374         return r;
 375 }