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