lib/ext2fs/mmp.c

   1 /*
   2  * Helper functions for multiple mount protection (MMP).
   3  *
   4  * Copyright (C) 2011 Whamcloud, Inc.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Library
   8  * General Public License, version 2.
   9  * %End-Header%
  10  */
  11
  12 #ifndef _GNU_SOURCE
  13 #define _GNU_SOURCE
  14 #endif
  15 #ifndef _DEFAULT_SOURCE
  16 #define _DEFAULT_SOURCE /* since glibc 2.20 _SVID_SOURCE is deprecated */
  17 #endif
  18
  19 #include "config.h"
  20
  21 #if HAVE_UNISTD_H
  22 #include <unistd.h>
  23 #endif
  24 #include <sys/time.h>
  25
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29
  30 #include "ext2fs/ext2_fs.h"
  31 #include "ext2fs/ext2fs.h"
  32
  33 #ifndef O_DIRECT
  34 #define O_DIRECT 0
  35 #endif
  36
  37 #if __GNUC_PREREQ (4, 6)
  38 #pragma GCC diagnostic push
  39 #ifndef CONFIG_MMP
  40 #pragma GCC diagnostic ignored "-Wunused-parameter"
  41 #endif
  42 #endif
  43
  44 errcode_t ext2fs_mmp_read(ext2_filsys fs, blk64_t mmp_blk, void *buf)
  45 {
  46 #ifdef CONFIG_MMP
  47         struct mmp_struct *mmp_cmp;
  48         errcode_t retval = 0;
  49
  50         if ((mmp_blk <= fs->super->s_first_data_block) ||
  51             (mmp_blk >= ext2fs_blocks_count(fs->super)))
  52                 return EXT2_ET_MMP_BAD_BLOCK;
  53
  54         /* ext2fs_open() reserves fd0,1,2 to avoid stdio collision, so checking
  55          * mmp_fd <= 0 is OK to validate that the fd is valid.  This opens its
  56          * own fd to read the MMP block to ensure that it is using O_DIRECT,
  57          * regardless of how the io_manager is doing reads, to avoid caching of
  58          * the MMP block by the io_manager or the VM.  It needs to be fresh. */
  59         if (fs->mmp_fd <= 0) {
  60                 fs->mmp_fd = open(fs->device_name, O_RDWR | O_DIRECT);
  61                 if (fs->mmp_fd < 0) {
  62                         retval = EXT2_ET_MMP_OPEN_DIRECT;
  63                         goto out;
  64                 }
  65         }
  66
  67         if (fs->mmp_cmp == NULL) {
  68                 int align = ext2fs_get_dio_alignment(fs->mmp_fd);
  69
  70                 retval = ext2fs_get_memalign(fs->blocksize, align,
  71                                              &fs->mmp_cmp);
  72                 if (retval)
  73                         return retval;
  74         }
  75
  76         if ((blk64_t) ext2fs_llseek(fs->mmp_fd, mmp_blk * fs->blocksize,
  77                                     SEEK_SET) !=
  78             mmp_blk * fs->blocksize) {
  79                 retval = EXT2_ET_LLSEEK_FAILED;
  80                 goto out;
  81         }
  82
  83         if (read(fs->mmp_fd, fs->mmp_cmp, fs->blocksize) != fs->blocksize) {
  84                 retval = EXT2_ET_SHORT_READ;
  85                 goto out;
  86         }
  87
  88         mmp_cmp = fs->mmp_cmp;
  89
  90         if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
  91             !ext2fs_mmp_csum_verify(fs, mmp_cmp))
  92                 retval = EXT2_ET_MMP_CSUM_INVALID;
  93
  94 #ifdef WORDS_BIGENDIAN
  95         ext2fs_swap_mmp(mmp_cmp);
  96 #endif
  97
  98         if (buf != NULL && buf != fs->mmp_cmp)
  99                 memcpy(buf, fs->mmp_cmp, fs->blocksize);
 100
 101         if (mmp_cmp->mmp_magic != EXT4_MMP_MAGIC) {
 102                 retval = EXT2_ET_MMP_MAGIC_INVALID;
 103                 goto out;
 104         }
 105
 106 out:
 107         return retval;
 108 #else
 109         return EXT2_ET_OP_NOT_SUPPORTED;
 110 #endif
 111 }
 112
 113 errcode_t ext2fs_mmp_write(ext2_filsys fs, blk64_t mmp_blk, void *buf)
 114 {
 115 #ifdef CONFIG_MMP
 116         struct mmp_struct *mmp_s = buf;
 117         struct timeval tv;
 118         errcode_t retval = 0;
 119
 120         gettimeofday(&tv, 0);
 121         mmp_s->mmp_time = tv.tv_sec;
 122         fs->mmp_last_written = tv.tv_sec;
 123
 124         if (fs->super->s_mmp_block < fs->super->s_first_data_block ||
 125             fs->super->s_mmp_block > ext2fs_blocks_count(fs->super))
 126                 return EXT2_ET_MMP_BAD_BLOCK;
 127
 128 #ifdef WORDS_BIGENDIAN
 129         ext2fs_swap_mmp(mmp_s);
 130 #endif
 131
 132         retval = ext2fs_mmp_csum_set(fs, mmp_s);
 133         if (retval)
 134                 return retval;
 135
 136         /* I was tempted to make this use O_DIRECT and the mmp_fd, but
 137          * this caused no end of grief, while leaving it as-is works. */
 138         retval = io_channel_write_blk64(fs->io, mmp_blk, -(int)sizeof(struct mmp_struct), buf);
 139
 140 #ifdef WORDS_BIGENDIAN
 141         ext2fs_swap_mmp(mmp_s);
 142 #endif
 143
 144         /* Make sure the block gets to disk quickly */
 145         io_channel_flush(fs->io);
 146         return retval;
 147 #else
 148         return EXT2_ET_OP_NOT_SUPPORTED;
 149 #endif
 150 }
 151
 152 #ifdef HAVE_SRANDOM
 153 #define srand(x)        srandom(x)
 154 #define rand()          random()
 155 #endif
 156
 157 unsigned ext2fs_mmp_new_seq(void)
 158 {
 159 #ifdef CONFIG_MMP
 160         unsigned new_seq;
 161         struct timeval tv;
 162
 163         gettimeofday(&tv, 0);
 164         srand((getpid() << 16) ^ getuid() ^ tv.tv_sec ^ tv.tv_usec);
 165
 166         gettimeofday(&tv, 0);
 167         /* Crank the random number generator a few times */
 168         for (new_seq = (tv.tv_sec ^ tv.tv_usec) & 0x1F; new_seq > 0; new_seq--)
 169                 rand();
 170
 171         do {
 172                 new_seq = rand();
 173         } while (new_seq > EXT4_MMP_SEQ_MAX);
 174
 175         return new_seq;
 176 #else
 177         return EXT2_ET_OP_NOT_SUPPORTED;
 178 #endif
 179 }
 180
 181 #ifdef CONFIG_MMP
 182 static errcode_t ext2fs_mmp_reset(ext2_filsys fs)
 183 {
 184         struct mmp_struct *mmp_s = NULL;
 185         errcode_t retval = 0;
 186
 187         if (fs->mmp_buf == NULL) {
 188                 retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf);
 189                 if (retval)
 190                         goto out;
 191         }
 192
 193         memset(fs->mmp_buf, 0, fs->blocksize);
 194         mmp_s = fs->mmp_buf;
 195
 196         mmp_s->mmp_magic = EXT4_MMP_MAGIC;
 197         mmp_s->mmp_seq = EXT4_MMP_SEQ_CLEAN;
 198         mmp_s->mmp_time = 0;
 199 #ifdef HAVE_GETHOSTNAME
 200         gethostname(mmp_s->mmp_nodename, sizeof(mmp_s->mmp_nodename));
 201 #else
 202         mmp_s->mmp_nodename[0] = '\0';
 203 #endif
 204         strncpy(mmp_s->mmp_bdevname, fs->device_name,
 205                 sizeof(mmp_s->mmp_bdevname));
 206
 207         mmp_s->mmp_check_interval = fs->super->s_mmp_update_interval;
 208         if (mmp_s->mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL)
 209                 mmp_s->mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL;
 210
 211         retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf);
 212 out:
 213         return retval;
 214 }
 215 #endif
 216
 217 errcode_t ext2fs_mmp_update(ext2_filsys fs)
 218 {
 219         return ext2fs_mmp_update2(fs, 0);
 220 }
 221
 222 errcode_t ext2fs_mmp_clear(ext2_filsys fs)
 223 {
 224 #ifdef CONFIG_MMP
 225         errcode_t retval = 0;
 226
 227         if (!(fs->flags & EXT2_FLAG_RW))
 228                 return EXT2_ET_RO_FILSYS;
 229
 230         retval = ext2fs_mmp_reset(fs);
 231
 232         return retval;
 233 #else
 234         return EXT2_ET_OP_NOT_SUPPORTED;
 235 #endif
 236 }
 237
 238 errcode_t ext2fs_mmp_init(ext2_filsys fs)
 239 {
 240 #ifdef CONFIG_MMP
 241         struct ext2_super_block *sb = fs->super;
 242         blk64_t mmp_block;
 243         errcode_t retval;
 244
 245         if (sb->s_mmp_update_interval == 0)
 246                 sb->s_mmp_update_interval = EXT4_MMP_UPDATE_INTERVAL;
 247         /* This is probably excessively large, but who knows? */
 248         else if (sb->s_mmp_update_interval > EXT4_MMP_MAX_UPDATE_INTERVAL)
 249                 return EXT2_ET_INVALID_ARGUMENT;
 250
 251         if (fs->mmp_buf == NULL) {
 252                 retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf);
 253                 if (retval)
 254                         goto out;
 255         }
 256
 257         retval = ext2fs_alloc_block2(fs, 0, fs->mmp_buf, &mmp_block);
 258         if (retval)
 259                 goto out;
 260
 261         sb->s_mmp_block = mmp_block;
 262
 263         retval = ext2fs_mmp_reset(fs);
 264         if (retval)
 265                 goto out;
 266
 267 out:
 268         return retval;
 269 #else
 270         return EXT2_ET_OP_NOT_SUPPORTED;
 271 #endif
 272 }
 273
 274 #ifndef min
 275 #define min(x, y) ((x) < (y) ? (x) : (y))
 276 #endif
 277
 278 /*
 279  * Make sure that the fs is not mounted or being fsck'ed while opening the fs.
 280  */
 281 errcode_t ext2fs_mmp_start(ext2_filsys fs)
 282 {
 283 #ifdef CONFIG_MMP
 284         struct mmp_struct *mmp_s;
 285         unsigned seq;
 286         unsigned int mmp_check_interval;
 287         errcode_t retval = 0;
 288
 289         if (fs->mmp_buf == NULL) {
 290                 retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf);
 291                 if (retval)
 292                         goto mmp_error;
 293         }
 294
 295         retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf);
 296         if (retval)
 297                 goto mmp_error;
 298
 299         mmp_s = fs->mmp_buf;
 300
 301         mmp_check_interval = fs->super->s_mmp_update_interval;
 302         if (mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL)
 303                 mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL;
 304
 305         seq = mmp_s->mmp_seq;
 306         if (seq == EXT4_MMP_SEQ_CLEAN)
 307                 goto clean_seq;
 308         if (seq == EXT4_MMP_SEQ_FSCK) {
 309                 retval = EXT2_ET_MMP_FSCK_ON;
 310                 goto mmp_error;
 311         }
 312
 313         if (seq > EXT4_MMP_SEQ_FSCK) {
 314                 retval = EXT2_ET_MMP_UNKNOWN_SEQ;
 315                 goto mmp_error;
 316         }
 317
 318         /*
 319          * If check_interval in MMP block is larger, use that instead of
 320          * check_interval from the superblock.
 321          */
 322         if (mmp_s->mmp_check_interval > mmp_check_interval)
 323                 mmp_check_interval = mmp_s->mmp_check_interval;
 324
 325         sleep(min(mmp_check_interval * 2 + 1, mmp_check_interval + 60));
 326
 327         retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf);
 328         if (retval)
 329                 goto mmp_error;
 330
 331         if (seq != mmp_s->mmp_seq) {
 332                 retval = EXT2_ET_MMP_FAILED;
 333                 goto mmp_error;
 334         }
 335
 336 clean_seq:
 337         if (!(fs->flags & EXT2_FLAG_RW))
 338                 goto mmp_error;
 339
 340         mmp_s->mmp_seq = seq = ext2fs_mmp_new_seq();
 341 #ifdef HAVE_GETHOSTNAME
 342         gethostname(mmp_s->mmp_nodename, sizeof(mmp_s->mmp_nodename));
 343 #else
 344         strcpy(mmp_s->mmp_nodename, "unknown host");
 345 #endif
 346         strncpy(mmp_s->mmp_bdevname, fs->device_name,
 347                 sizeof(mmp_s->mmp_bdevname));
 348
 349         retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf);
 350         if (retval)
 351                 goto mmp_error;
 352
 353         sleep(min(2 * mmp_check_interval + 1, mmp_check_interval + 60));
 354
 355         retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf);
 356         if (retval)
 357                 goto mmp_error;
 358
 359         if (seq != mmp_s->mmp_seq) {
 360                 retval = EXT2_ET_MMP_FAILED;
 361                 goto mmp_error;
 362         }
 363
 364         mmp_s->mmp_seq = EXT4_MMP_SEQ_FSCK;
 365         retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf);
 366         if (retval)
 367                 goto mmp_error;
 368
 369         return 0;
 370
 371 mmp_error:
 372         return retval;
 373 #else
 374         return EXT2_ET_OP_NOT_SUPPORTED;
 375 #endif
 376 }
 377
 378 /*
 379  * Clear the MMP usage in the filesystem.  If this function returns an
 380  * error EXT2_ET_MMP_CHANGE_ABORT it means the filesystem was modified
 381  * by some other process while in use, and changes should be dropped, or
 382  * risk filesystem corruption.
 383  */
 384 errcode_t ext2fs_mmp_stop(ext2_filsys fs)
 385 {
 386 #ifdef CONFIG_MMP
 387         struct mmp_struct *mmp, *mmp_cmp;
 388         errcode_t retval = 0;
 389
 390         if (!ext2fs_has_feature_mmp(fs->super) ||
 391             !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP))
 392                 goto mmp_error;
 393
 394         retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf);
 395         if (retval)
 396                 goto mmp_error;
 397
 398         /* Check if the MMP block is not changed. */
 399         mmp = fs->mmp_buf;
 400         mmp_cmp = fs->mmp_cmp;
 401         if (memcmp(mmp, mmp_cmp, sizeof(*mmp_cmp))) {
 402                 retval = EXT2_ET_MMP_CHANGE_ABORT;
 403                 goto mmp_error;
 404         }
 405
 406         mmp_cmp->mmp_seq = EXT4_MMP_SEQ_CLEAN;
 407         retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_cmp);
 408
 409 mmp_error:
 410         if (fs->mmp_fd > 0) {
 411                 close(fs->mmp_fd);
 412                 fs->mmp_fd = -1;
 413         }
 414
 415         return retval;
 416 #else
 417         if (!ext2fs_has_feature_mmp(fs->super) ||
 418             !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP))
 419                 return 0;
 420
 421         return EXT2_ET_OP_NOT_SUPPORTED;
 422 #endif
 423 }
 424
 425 #define EXT2_MIN_MMP_UPDATE_INTERVAL 60
 426
 427 /*
 428  * Update the on-disk mmp buffer, after checking that it hasn't been changed.
 429  */
 430 errcode_t ext2fs_mmp_update2(ext2_filsys fs, int immediately)
 431 {
 432 #ifdef CONFIG_MMP
 433         struct mmp_struct *mmp, *mmp_cmp;
 434         struct timeval tv;
 435         errcode_t retval = 0;
 436
 437         if (!ext2fs_has_feature_mmp(fs->super) ||
 438             !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP))
 439                 return 0;
 440
 441         gettimeofday(&tv, 0);
 442         if (!immediately &&
 443             tv.tv_sec - fs->mmp_last_written < EXT2_MIN_MMP_UPDATE_INTERVAL)
 444                 return 0;
 445
 446         retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, NULL);
 447         if (retval)
 448                 goto mmp_error;
 449
 450         mmp = fs->mmp_buf;
 451         mmp_cmp = fs->mmp_cmp;
 452
 453         if (memcmp(mmp, mmp_cmp, sizeof(*mmp_cmp)))
 454                 return EXT2_ET_MMP_CHANGE_ABORT;
 455
 456         mmp->mmp_time = tv.tv_sec;
 457         mmp->mmp_seq = EXT4_MMP_SEQ_FSCK;
 458         retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf);
 459
 460 mmp_error:
 461         return retval;
 462 #else
 463         if (!ext2fs_has_feature_mmp(fs->super) ||
 464             !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP))
 465                 return 0;
 466
 467         return EXT2_ET_OP_NOT_SUPPORTED;
 468 #endif
 469 }
 470 #if __GNUC_PREREQ (4, 6)
 471 #pragma GCC diagnostic pop
 472 #endif