fs/ext4/mmp.c

   1 #include <linux/fs.h>
   2 #include <linux/random.h>
   3 #include <linux/buffer_head.h>
   4 #include <linux/utsname.h>
   5 #include <linux/kthread.h>
   6
   7 #include "ext4.h"
   8
   9 /* Checksumming functions */
  10 static __le32 ext4_mmp_csum(struct super_block *sb, struct mmp_struct *mmp)
  11 {
  12         struct ext4_sb_info *sbi = EXT4_SB(sb);
  13         int offset = offsetof(struct mmp_struct, mmp_checksum);
  14         __u32 csum;
  15
  16         csum = ext4_chksum(sbi, sbi->s_csum_seed, (char *)mmp, offset);
  17
  18         return cpu_to_le32(csum);
  19 }
  20
  21 static int ext4_mmp_csum_verify(struct super_block *sb, struct mmp_struct *mmp)
  22 {
  23         if (!ext4_has_metadata_csum(sb))
  24                 return 1;
  25
  26         return mmp->mmp_checksum == ext4_mmp_csum(sb, mmp);
  27 }
  28
  29 static void ext4_mmp_csum_set(struct super_block *sb, struct mmp_struct *mmp)
  30 {
  31         if (!ext4_has_metadata_csum(sb))
  32                 return;
  33
  34         mmp->mmp_checksum = ext4_mmp_csum(sb, mmp);
  35 }
  36
  37 /*
  38  * Write the MMP block using WRITE_SYNC to try to get the block on-disk
  39  * faster.
  40  */
  41 static int write_mmp_block(struct super_block *sb, struct buffer_head *bh)
  42 {
  43         struct mmp_struct *mmp = (struct mmp_struct *)(bh->b_data);
  44
  45         /*
  46          * We protect against freezing so that we don't create dirty buffers
  47          * on frozen filesystem.
  48          */
  49         sb_start_write(sb);
  50         ext4_mmp_csum_set(sb, mmp);
  51         lock_buffer(bh);
  52         bh->b_end_io = end_buffer_write_sync;
  53         get_bh(bh);
  54         submit_bh(WRITE_SYNC | REQ_META | REQ_PRIO, bh);
  55         wait_on_buffer(bh);
  56         sb_end_write(sb);
  57         if (unlikely(!buffer_uptodate(bh)))
  58                 return 1;
  59
  60         return 0;
  61 }
  62
  63 /*
  64  * Read the MMP block. It _must_ be read from disk and hence we clear the
  65  * uptodate flag on the buffer.
  66  */
  67 static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,
  68                           ext4_fsblk_t mmp_block)
  69 {
  70         struct mmp_struct *mmp;
  71         int ret;
  72
  73         if (*bh)
  74                 clear_buffer_uptodate(*bh);
  75
  76         /* This would be sb_bread(sb, mmp_block), except we need to be sure
  77          * that the MD RAID device cache has been bypassed, and that the read
  78          * is not blocked in the elevator. */
  79         if (!*bh) {
  80                 *bh = sb_getblk(sb, mmp_block);
  81                 if (!*bh) {
  82                         ret = -ENOMEM;
  83                         goto warn_exit;
  84                 }
  85         }
  86
  87         get_bh(*bh);
  88         lock_buffer(*bh);
  89         (*bh)->b_end_io = end_buffer_read_sync;
  90         submit_bh(READ_SYNC | REQ_META | REQ_PRIO, *bh);
  91         wait_on_buffer(*bh);
  92         if (!buffer_uptodate(*bh)) {
  93                 brelse(*bh);
  94                 *bh = NULL;
  95                 ret = -EIO;
  96                 goto warn_exit;
  97         }
  98
  99         mmp = (struct mmp_struct *)((*bh)->b_data);
 100         if (le32_to_cpu(mmp->mmp_magic) != EXT4_MMP_MAGIC)
 101                 ret = -EFSCORRUPTED;
 102         else if (!ext4_mmp_csum_verify(sb, mmp))
 103                 ret = -EFSBADCRC;
 104         else
 105                 return 0;
 106
 107 warn_exit:
 108         ext4_warning(sb, "Error %d while reading MMP block %llu",
 109                      ret, mmp_block);
 110         return ret;
 111 }
 112
 113 /*
 114  * Dump as much information as possible to help the admin.
 115  */
 116 void __dump_mmp_msg(struct super_block *sb, struct mmp_struct *mmp,
 117                     const char *function, unsigned int line, const char *msg)
 118 {
 119         __ext4_warning(sb, function, line, "%s", msg);
 120         __ext4_warning(sb, function, line,
 121                        "MMP failure info: last update time: %llu, last update "
 122                        "node: %s, last update device: %s\n",
 123                        (long long unsigned int) le64_to_cpu(mmp->mmp_time),
 124                        mmp->mmp_nodename, mmp->mmp_bdevname);
 125 }
 126
 127 /*
 128  * kmmpd will update the MMP sequence every s_mmp_update_interval seconds
 129  */
 130 static int kmmpd(void *data)
 131 {
 132         struct super_block *sb = ((struct mmpd_data *) data)->sb;
 133         struct buffer_head *bh = ((struct mmpd_data *) data)->bh;
 134         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 135         struct mmp_struct *mmp;
 136         ext4_fsblk_t mmp_block;
 137         u32 seq = 0;
 138         unsigned long failed_writes = 0;
 139         int mmp_update_interval = le16_to_cpu(es->s_mmp_update_interval);
 140         unsigned mmp_check_interval;
 141         unsigned long last_update_time;
 142         unsigned long diff;
 143         int retval;
 144
 145         mmp_block = le64_to_cpu(es->s_mmp_block);
 146         mmp = (struct mmp_struct *)(bh->b_data);
 147         mmp->mmp_time = cpu_to_le64(get_seconds());
 148         /*
 149          * Start with the higher mmp_check_interval and reduce it if
 150          * the MMP block is being updated on time.
 151          */
 152         mmp_check_interval = max(EXT4_MMP_CHECK_MULT * mmp_update_interval,
 153                                  EXT4_MMP_MIN_CHECK_INTERVAL);
 154         mmp->mmp_check_interval = cpu_to_le16(mmp_check_interval);
 155         bdevname(bh->b_bdev, mmp->mmp_bdevname);
 156
 157         memcpy(mmp->mmp_nodename, init_utsname()->nodename,
 158                sizeof(mmp->mmp_nodename));
 159
 160         while (!kthread_should_stop()) {
 161                 if (++seq > EXT4_MMP_SEQ_MAX)
 162                         seq = 1;
 163
 164                 mmp->mmp_seq = cpu_to_le32(seq);
 165                 mmp->mmp_time = cpu_to_le64(get_seconds());
 166                 last_update_time = jiffies;
 167
 168                 retval = write_mmp_block(sb, bh);
 169                 /*
 170                  * Don't spew too many error messages. Print one every
 171                  * (s_mmp_update_interval * 60) seconds.
 172                  */
 173                 if (retval) {
 174                         if ((failed_writes % 60) == 0)
 175                                 ext4_error(sb, "Error writing to MMP block");
 176                         failed_writes++;
 177                 }
 178
 179                 if (!(le32_to_cpu(es->s_feature_incompat) &
 180                     EXT4_FEATURE_INCOMPAT_MMP)) {
 181                         ext4_warning(sb, "kmmpd being stopped since MMP feature"
 182                                      " has been disabled.");
 183                         EXT4_SB(sb)->s_mmp_tsk = NULL;
 184                         goto failed;
 185                 }
 186
 187                 if (sb->s_flags & MS_RDONLY) {
 188                         ext4_warning(sb, "kmmpd being stopped since filesystem "
 189                                      "has been remounted as readonly.");
 190                         EXT4_SB(sb)->s_mmp_tsk = NULL;
 191                         goto failed;
 192                 }
 193
 194                 diff = jiffies - last_update_time;
 195                 if (diff < mmp_update_interval * HZ)
 196                         schedule_timeout_interruptible(mmp_update_interval *
 197                                                        HZ - diff);
 198
 199                 /*
 200                  * We need to make sure that more than mmp_check_interval
 201                  * seconds have not passed since writing. If that has happened
 202                  * we need to check if the MMP block is as we left it.
 203                  */
 204                 diff = jiffies - last_update_time;
 205                 if (diff > mmp_check_interval * HZ) {
 206                         struct buffer_head *bh_check = NULL;
 207                         struct mmp_struct *mmp_check;
 208
 209                         retval = read_mmp_block(sb, &bh_check, mmp_block);
 210                         if (retval) {
 211                                 ext4_error(sb, "error reading MMP data: %d",
 212                                            retval);
 213
 214                                 EXT4_SB(sb)->s_mmp_tsk = NULL;
 215                                 goto failed;
 216                         }
 217
 218                         mmp_check = (struct mmp_struct *)(bh_check->b_data);
 219                         if (mmp->mmp_seq != mmp_check->mmp_seq ||
 220                             memcmp(mmp->mmp_nodename, mmp_check->mmp_nodename,
 221                                    sizeof(mmp->mmp_nodename))) {
 222                                 dump_mmp_msg(sb, mmp_check,
 223                                              "Error while updating MMP info. "
 224                                              "The filesystem seems to have been"
 225                                              " multiply mounted.");
 226                                 ext4_error(sb, "abort");
 227                                 goto failed;
 228                         }
 229                         put_bh(bh_check);
 230                 }
 231
 232                  /*
 233                  * Adjust the mmp_check_interval depending on how much time
 234                  * it took for the MMP block to be written.
 235                  */
 236                 mmp_check_interval = max(min(EXT4_MMP_CHECK_MULT * diff / HZ,
 237                                              EXT4_MMP_MAX_CHECK_INTERVAL),
 238                                          EXT4_MMP_MIN_CHECK_INTERVAL);
 239                 mmp->mmp_check_interval = cpu_to_le16(mmp_check_interval);
 240         }
 241
 242         /*
 243          * Unmount seems to be clean.
 244          */
 245         mmp->mmp_seq = cpu_to_le32(EXT4_MMP_SEQ_CLEAN);
 246         mmp->mmp_time = cpu_to_le64(get_seconds());
 247
 248         retval = write_mmp_block(sb, bh);
 249
 250 failed:
 251         kfree(data);
 252         brelse(bh);
 253         return retval;
 254 }
 255
 256 /*
 257  * Get a random new sequence number but make sure it is not greater than
 258  * EXT4_MMP_SEQ_MAX.
 259  */
 260 static unsigned int mmp_new_seq(void)
 261 {
 262         u32 new_seq;
 263
 264         do {
 265                 new_seq = prandom_u32();
 266         } while (new_seq > EXT4_MMP_SEQ_MAX);
 267
 268         return new_seq;
 269 }
 270
 271 /*
 272  * Protect the filesystem from being mounted more than once.
 273  */
 274 int ext4_multi_mount_protect(struct super_block *sb,
 275                                     ext4_fsblk_t mmp_block)
 276 {
 277         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 278         struct buffer_head *bh = NULL;
 279         struct mmp_struct *mmp = NULL;
 280         struct mmpd_data *mmpd_data;
 281         u32 seq;
 282         unsigned int mmp_check_interval = le16_to_cpu(es->s_mmp_update_interval);
 283         unsigned int wait_time = 0;
 284         int retval;
 285
 286         if (mmp_block < le32_to_cpu(es->s_first_data_block) ||
 287             mmp_block >= ext4_blocks_count(es)) {
 288                 ext4_warning(sb, "Invalid MMP block in superblock");
 289                 goto failed;
 290         }
 291
 292         retval = read_mmp_block(sb, &bh, mmp_block);
 293         if (retval)
 294                 goto failed;
 295
 296         mmp = (struct mmp_struct *)(bh->b_data);
 297
 298         if (mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL)
 299                 mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL;
 300
 301         /*
 302          * If check_interval in MMP block is larger, use that instead of
 303          * update_interval from the superblock.
 304          */
 305         if (le16_to_cpu(mmp->mmp_check_interval) > mmp_check_interval)
 306                 mmp_check_interval = le16_to_cpu(mmp->mmp_check_interval);
 307
 308         seq = le32_to_cpu(mmp->mmp_seq);
 309         if (seq == EXT4_MMP_SEQ_CLEAN)
 310                 goto skip;
 311
 312         if (seq == EXT4_MMP_SEQ_FSCK) {
 313                 dump_mmp_msg(sb, mmp, "fsck is running on the filesystem");
 314                 goto failed;
 315         }
 316
 317         wait_time = min(mmp_check_interval * 2 + 1,
 318                         mmp_check_interval + 60);
 319
 320         /* Print MMP interval if more than 20 secs. */
 321         if (wait_time > EXT4_MMP_MIN_CHECK_INTERVAL * 4)
 322                 ext4_warning(sb, "MMP interval %u higher than expected, please"
 323                              " wait.\n", wait_time * 2);
 324
 325         if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
 326                 ext4_warning(sb, "MMP startup interrupted, failing mount\n");
 327                 goto failed;
 328         }
 329
 330         retval = read_mmp_block(sb, &bh, mmp_block);
 331         if (retval)
 332                 goto failed;
 333         mmp = (struct mmp_struct *)(bh->b_data);
 334         if (seq != le32_to_cpu(mmp->mmp_seq)) {
 335                 dump_mmp_msg(sb, mmp,
 336                              "Device is already active on another node.");
 337                 goto failed;
 338         }
 339
 340 skip:
 341         /*
 342          * write a new random sequence number.
 343          */
 344         seq = mmp_new_seq();
 345         mmp->mmp_seq = cpu_to_le32(seq);
 346
 347         retval = write_mmp_block(sb, bh);
 348         if (retval)
 349                 goto failed;
 350
 351         /*
 352          * wait for MMP interval and check mmp_seq.
 353          */
 354         if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
 355                 ext4_warning(sb, "MMP startup interrupted, failing mount\n");
 356                 goto failed;
 357         }
 358
 359         retval = read_mmp_block(sb, &bh, mmp_block);
 360         if (retval)
 361                 goto failed;
 362         mmp = (struct mmp_struct *)(bh->b_data);
 363         if (seq != le32_to_cpu(mmp->mmp_seq)) {
 364                 dump_mmp_msg(sb, mmp,
 365                              "Device is already active on another node.");
 366                 goto failed;
 367         }
 368
 369         mmpd_data = kmalloc(sizeof(struct mmpd_data), GFP_KERNEL);
 370         if (!mmpd_data) {
 371                 ext4_warning(sb, "not enough memory for mmpd_data");
 372                 goto failed;
 373         }
 374         mmpd_data->sb = sb;
 375         mmpd_data->bh = bh;
 376
 377         /*
 378          * Start a kernel thread to update the MMP block periodically.
 379          */
 380         EXT4_SB(sb)->s_mmp_tsk = kthread_run(kmmpd, mmpd_data, "kmmpd-%s",
 381                                              bdevname(bh->b_bdev,
 382                                                       mmp->mmp_bdevname));
 383         if (IS_ERR(EXT4_SB(sb)->s_mmp_tsk)) {
 384                 EXT4_SB(sb)->s_mmp_tsk = NULL;
 385                 kfree(mmpd_data);
 386                 ext4_warning(sb, "Unable to create kmmpd thread for %s.",
 387                              sb->s_id);
 388                 goto failed;
 389         }
 390
 391         return 0;
 392
 393 failed:
 394         brelse(bh);
 395         return 1;
 396 }
 397
 398