debugfs/journal.c

   1 /*
   2  * journal.c --- code for handling the "ext3" journal
   3  *
   4  * Copyright (C) 2000 Andreas Dilger
   5  * Copyright (C) 2000 Theodore Ts'o
   6  *
   7  * Parts of the code are based on fs/jfs/journal.c by Stephen C. Tweedie
   8  * Copyright (C) 1999 Red Hat Software
   9  *
  10  * This file may be redistributed under the terms of the
  11  * GNU General Public License version 2 or at your discretion
  12  * any later version.
  13  */
  14
  15 #include "config.h"
  16 #ifdef HAVE_SYS_MOUNT_H
  17 #include <sys/param.h>
  18 #include <sys/mount.h>
  19 #define MNT_FL (MS_MGC_VAL | MS_RDONLY)
  20 #endif
  21 #ifdef HAVE_SYS_STAT_H
  22 #include <sys/stat.h>
  23 #endif
  24
  25 #define E2FSCK_INCLUDE_INLINE_FUNCS
  26 #include "jfs_user.h"
  27 #include "uuid/uuid.h"
  28
  29 #ifdef CONFIG_JBD_DEBUG         /* Enabled by configure --enable-jfs-debug */
  30 static int bh_count = 0;
  31 #endif
  32
  33 #if EXT2_FLAT_INCLUDES
  34 #include "blkid.h"
  35 #else
  36 #include "blkid/blkid.h"
  37 #endif
  38
  39 /*
  40  * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths.
  41  * This creates a larger static binary, and a smaller binary using
  42  * shared libraries.  It's also probably slightly less CPU-efficient,
  43  * which is why it's not on by default.  But, it's a good way of
  44  * testing the functions in inode_io.c and fileio.c.
  45  */
  46 #undef USE_INODE_IO
  47
  48 /* Checksumming functions */
  49 static int ext2fs_journal_verify_csum_type(journal_t *j,
  50                                            journal_superblock_t *jsb)
  51 {
  52         if (!journal_has_csum_v2or3(j))
  53                 return 1;
  54
  55         return jsb->s_checksum_type == JBD2_CRC32C_CHKSUM;
  56 }
  57
  58 static __u32 ext2fs_journal_sb_csum(journal_superblock_t *jsb)
  59 {
  60         __u32 crc, old_crc;
  61
  62         old_crc = jsb->s_checksum;
  63         jsb->s_checksum = 0;
  64         crc = ext2fs_crc32c_le(~0, (unsigned char *)jsb,
  65                                sizeof(journal_superblock_t));
  66         jsb->s_checksum = old_crc;
  67
  68         return crc;
  69 }
  70
  71 static int ext2fs_journal_sb_csum_verify(journal_t *j,
  72                                          journal_superblock_t *jsb)
  73 {
  74         __u32 provided, calculated;
  75
  76         if (!journal_has_csum_v2or3(j))
  77                 return 1;
  78
  79         provided = ext2fs_be32_to_cpu(jsb->s_checksum);
  80         calculated = ext2fs_journal_sb_csum(jsb);
  81
  82         return provided == calculated;
  83 }
  84
  85 static errcode_t ext2fs_journal_sb_csum_set(journal_t *j,
  86                                             journal_superblock_t *jsb)
  87 {
  88         __u32 crc;
  89
  90         if (!journal_has_csum_v2or3(j))
  91                 return 0;
  92
  93         crc = ext2fs_journal_sb_csum(jsb);
  94         jsb->s_checksum = ext2fs_cpu_to_be32(crc);
  95         return 0;
  96 }
  97
  98 /* Kernel compatibility functions for handling the journal.  These allow us
  99  * to use the recovery.c file virtually unchanged from the kernel, so we
 100  * don't have to do much to keep kernel and user recovery in sync.
 101  */
 102 int journal_bmap(journal_t *journal, blk64_t block, unsigned long long *phys)
 103 {
 104 #ifdef USE_INODE_IO
 105         *phys = block;
 106         return 0;
 107 #else
 108         struct inode    *inode = journal->j_inode;
 109         errcode_t       retval;
 110         blk64_t         pblk;
 111
 112         if (!inode) {
 113                 *phys = block;
 114                 return 0;
 115         }
 116
 117         retval = ext2fs_bmap2(inode->i_fs, inode->i_ino,
 118                               &inode->i_ext2, NULL, 0, block, 0, &pblk);
 119         *phys = pblk;
 120         return (int) retval;
 121 #endif
 122 }
 123
 124 struct buffer_head *getblk(kdev_t kdev, blk64_t blocknr, int blocksize)
 125 {
 126         struct buffer_head *bh;
 127         int bufsize = sizeof(*bh) + kdev->k_fs->blocksize -
 128                 sizeof(bh->b_data);
 129         errcode_t retval;
 130
 131         retval = ext2fs_get_memzero(bufsize, &bh);
 132         if (retval)
 133                 return NULL;
 134
 135 #ifdef CONFIG_JBD_DEBUG
 136         if (journal_enable_debug >= 3)
 137                 bh_count++;
 138 #endif
 139         jfs_debug(4, "getblk for block %llu (%d bytes)(total %d)\n",
 140                   (unsigned long long) blocknr, blocksize, bh_count);
 141
 142         bh->b_fs = kdev->k_fs;
 143         if (kdev->k_dev == K_DEV_FS)
 144                 bh->b_io = kdev->k_fs->io;
 145         else
 146                 bh->b_io = kdev->k_fs->journal_io;
 147         bh->b_size = blocksize;
 148         bh->b_blocknr = blocknr;
 149
 150         return bh;
 151 }
 152
 153 int sync_blockdev(kdev_t kdev)
 154 {
 155         io_channel      io;
 156
 157         if (kdev->k_dev == K_DEV_FS)
 158                 io = kdev->k_fs->io;
 159         else
 160                 io = kdev->k_fs->journal_io;
 161
 162         return io_channel_flush(io) ? EIO : 0;
 163 }
 164
 165 void ll_rw_block(int rw, int nr, struct buffer_head *bhp[])
 166 {
 167         errcode_t retval;
 168         struct buffer_head *bh;
 169
 170         for (; nr > 0; --nr) {
 171                 bh = *bhp++;
 172                 if (rw == READ && !bh->b_uptodate) {
 173                         jfs_debug(3, "reading block %llu/%p\n",
 174                                   bh->b_blocknr, (void *) bh);
 175                         retval = io_channel_read_blk64(bh->b_io,
 176                                                      bh->b_blocknr,
 177                                                      1, bh->b_data);
 178                         if (retval) {
 179                                 com_err(bh->b_fs->device_name, retval,
 180                                         "while reading block %llu\n",
 181                                         bh->b_blocknr);
 182                                 bh->b_err = (int) retval;
 183                                 continue;
 184                         }
 185                         bh->b_uptodate = 1;
 186                 } else if (rw == WRITE && bh->b_dirty) {
 187                         jfs_debug(3, "writing block %llu/%p\n",
 188                                   bh->b_blocknr,
 189                                   (void *) bh);
 190                         retval = io_channel_write_blk64(bh->b_io,
 191                                                       bh->b_blocknr,
 192                                                       1, bh->b_data);
 193                         if (retval) {
 194                                 com_err(bh->b_fs->device_name, retval,
 195                                         "while writing block %llu\n",
 196                                         bh->b_blocknr);
 197                                 bh->b_err = (int) retval;
 198                                 continue;
 199                         }
 200                         bh->b_dirty = 0;
 201                         bh->b_uptodate = 1;
 202                 } else {
 203                         jfs_debug(3, "no-op %s for block %llu\n",
 204                                   rw == READ ? "read" : "write",
 205                                   bh->b_blocknr);
 206                 }
 207         }
 208 }
 209
 210 void mark_buffer_dirty(struct buffer_head *bh)
 211 {
 212         bh->b_dirty = 1;
 213 }
 214
 215 static void mark_buffer_clean(struct buffer_head *bh)
 216 {
 217         bh->b_dirty = 0;
 218 }
 219
 220 void brelse(struct buffer_head *bh)
 221 {
 222         if (bh->b_dirty)
 223                 ll_rw_block(WRITE, 1, &bh);
 224         jfs_debug(3, "freeing block %llu/%p (total %d)\n",
 225                   bh->b_blocknr, (void *) bh, --bh_count);
 226         ext2fs_free_mem(&bh);
 227 }
 228
 229 int buffer_uptodate(struct buffer_head *bh)
 230 {
 231         return bh->b_uptodate;
 232 }
 233
 234 void mark_buffer_uptodate(struct buffer_head *bh, int val)
 235 {
 236         bh->b_uptodate = val;
 237 }
 238
 239 void wait_on_buffer(struct buffer_head *bh)
 240 {
 241         if (!bh->b_uptodate)
 242                 ll_rw_block(READ, 1, &bh);
 243 }
 244
 245
 246 static void ext2fs_clear_recover(ext2_filsys fs, int error)
 247 {
 248         fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
 249
 250         /* if we had an error doing journal recovery, we need a full fsck */
 251         if (error)
 252                 fs->super->s_state &= ~EXT2_VALID_FS;
 253         ext2fs_mark_super_dirty(fs);
 254 }
 255
 256 /*
 257  * This is a helper function to check the validity of the journal.
 258  */
 259 struct process_block_struct {
 260         e2_blkcnt_t     last_block;
 261 };
 262
 263 static int process_journal_block(ext2_filsys fs,
 264                                  blk64_t        *block_nr,
 265                                  e2_blkcnt_t blockcnt,
 266                                  blk64_t ref_block EXT2FS_ATTR((unused)),
 267                                  int ref_offset EXT2FS_ATTR((unused)),
 268                                  void *priv_data)
 269 {
 270         struct process_block_struct *p;
 271         blk64_t blk = *block_nr;
 272
 273         p = (struct process_block_struct *) priv_data;
 274
 275         if (!blk || blk < fs->super->s_first_data_block ||
 276             blk >= ext2fs_blocks_count(fs->super))
 277                 return BLOCK_ABORT;
 278
 279         if (blockcnt >= 0)
 280                 p->last_block = blockcnt;
 281         return 0;
 282 }
 283
 284 static errcode_t ext2fs_get_journal(ext2_filsys fs, journal_t **ret_journal)
 285 {
 286         struct process_block_struct pb;
 287         struct ext2_super_block *sb = fs->super;
 288         struct ext2_super_block jsuper;
 289         struct buffer_head      *bh;
 290         struct inode            *j_inode = NULL;
 291         struct kdev_s           *dev_fs = NULL, *dev_journal;
 292         const char              *journal_name = 0;
 293         journal_t               *journal = NULL;
 294         errcode_t               retval = 0;
 295         io_manager              io_ptr = 0;
 296         unsigned long long      start = 0;
 297         int                     ext_journal = 0;
 298         int                     tried_backup_jnl = 0;
 299
 300         retval = ext2fs_get_memzero(sizeof(journal_t), &journal);
 301         if (retval)
 302                 return retval;
 303
 304         retval = ext2fs_get_memzero(2 * sizeof(struct kdev_s), &dev_fs);
 305         if (retval)
 306                 goto errout;
 307         dev_journal = dev_fs+1;
 308
 309         dev_fs->k_fs = dev_journal->k_fs = fs;
 310         dev_fs->k_dev = K_DEV_FS;
 311         dev_journal->k_dev = K_DEV_JOURNAL;
 312
 313         journal->j_dev = dev_journal;
 314         journal->j_fs_dev = dev_fs;
 315         journal->j_inode = NULL;
 316         journal->j_blocksize = fs->blocksize;
 317
 318         if (uuid_is_null(sb->s_journal_uuid)) {
 319                 if (!sb->s_journal_inum) {
 320                         retval = EXT2_ET_BAD_INODE_NUM;
 321                         goto errout;
 322                 }
 323                 retval = ext2fs_get_memzero(sizeof(*j_inode), &j_inode);
 324                 if (retval)
 325                         goto errout;
 326
 327                 j_inode->i_fs = fs;
 328                 j_inode->i_ino = sb->s_journal_inum;
 329
 330                 retval = ext2fs_read_inode(fs, sb->s_journal_inum,
 331                                            &j_inode->i_ext2);
 332                 if (retval) {
 333 try_backup_journal:
 334                         if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
 335                             tried_backup_jnl)
 336                                 goto errout;
 337                         memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
 338                         memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
 339                                EXT2_N_BLOCKS*4);
 340                         j_inode->i_ext2.i_size_high = sb->s_jnl_blocks[15];
 341                         j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
 342                         j_inode->i_ext2.i_links_count = 1;
 343                         j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
 344                         tried_backup_jnl++;
 345                 }
 346                 if (!j_inode->i_ext2.i_links_count ||
 347                     !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
 348                         retval = EXT2_ET_NO_JOURNAL;
 349                         goto try_backup_journal;
 350                 }
 351                 if (EXT2_I_SIZE(&j_inode->i_ext2) / journal->j_blocksize <
 352                     JFS_MIN_JOURNAL_BLOCKS) {
 353                         retval = EXT2_ET_JOURNAL_TOO_SMALL;
 354                         goto try_backup_journal;
 355                 }
 356                 pb.last_block = -1;
 357                 retval = ext2fs_block_iterate3(fs, j_inode->i_ino,
 358                                                BLOCK_FLAG_HOLE, 0,
 359                                                process_journal_block, &pb);
 360                 if ((pb.last_block + 1) * fs->blocksize <
 361                     (int) EXT2_I_SIZE(&j_inode->i_ext2)) {
 362                         retval = EXT2_ET_JOURNAL_TOO_SMALL;
 363                         goto try_backup_journal;
 364                 }
 365                 if (tried_backup_jnl && (fs->flags & EXT2_FLAG_RW)) {
 366                         retval = ext2fs_write_inode(fs, sb->s_journal_inum,
 367                                                     &j_inode->i_ext2);
 368                         if (retval)
 369                                 goto errout;
 370                 }
 371
 372                 journal->j_maxlen = EXT2_I_SIZE(&j_inode->i_ext2) /
 373                         journal->j_blocksize;
 374
 375 #ifdef USE_INODE_IO
 376                 retval = ext2fs_inode_io_intern2(fs, sb->s_journal_inum,
 377                                                  &j_inode->i_ext2,
 378                                                  &journal_name);
 379                 if (retval)
 380                         goto errout;
 381
 382                 io_ptr = inode_io_manager;
 383 #else
 384                 journal->j_inode = j_inode;
 385                 fs->journal_io = fs->io;
 386                 retval = (errcode_t)journal_bmap(journal, 0, &start);
 387                 if (retval)
 388                         goto errout;
 389 #endif
 390         } else {
 391                 ext_journal = 1;
 392                 if (!fs->journal_name) {
 393                         char uuid[37];
 394                         blkid_cache blkid;
 395
 396                         blkid_get_cache(&blkid, NULL);
 397                         uuid_unparse(sb->s_journal_uuid, uuid);
 398                         fs->journal_name = blkid_get_devname(blkid,
 399                                                               "UUID", uuid);
 400                         if (!fs->journal_name)
 401                                 fs->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
 402                         blkid_put_cache(blkid);
 403                 }
 404                 journal_name = fs->journal_name;
 405
 406                 if (!journal_name) {
 407                         retval = EXT2_ET_LOAD_EXT_JOURNAL;
 408                         goto errout;
 409                 }
 410
 411                 jfs_debug(1, "Using journal file %s\n", journal_name);
 412                 io_ptr = unix_io_manager;
 413         }
 414
 415 #if 0
 416         test_io_backing_manager = io_ptr;
 417         io_ptr = test_io_manager;
 418 #endif
 419 #ifndef USE_INODE_IO
 420         if (ext_journal)
 421 #endif
 422         {
 423                 retval = io_ptr->open(journal_name, fs->flags & EXT2_FLAG_RW,
 424                                       &fs->journal_io);
 425         }
 426         if (retval)
 427                 goto errout;
 428
 429         io_channel_set_blksize(fs->journal_io, fs->blocksize);
 430
 431         if (ext_journal) {
 432                 blk64_t maxlen;
 433
 434                 start = ext2fs_journal_sb_start(fs->blocksize) - 1;
 435                 bh = getblk(dev_journal, start, fs->blocksize);
 436                 if (!bh) {
 437                         retval = EXT2_ET_NO_MEMORY;
 438                         goto errout;
 439                 }
 440                 ll_rw_block(READ, 1, &bh);
 441                 retval = bh->b_err;
 442                 if (retval) {
 443                         brelse(bh);
 444                         goto errout;
 445                 }
 446                 memcpy(&jsuper, start ? bh->b_data :
 447                                 bh->b_data + SUPERBLOCK_OFFSET,
 448                        sizeof(jsuper));
 449 #ifdef WORDS_BIGENDIAN
 450                 if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
 451                         ext2fs_swap_super(&jsuper);
 452 #endif
 453                 if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
 454                     !(jsuper.s_feature_incompat &
 455                       EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
 456                         retval = EXT2_ET_LOAD_EXT_JOURNAL;
 457                         brelse(bh);
 458                         goto errout;
 459                 }
 460                 /* Make sure the journal UUID is correct */
 461                 if (memcmp(jsuper.s_uuid, fs->super->s_journal_uuid,
 462                            sizeof(jsuper.s_uuid))) {
 463                         retval = EXT2_ET_LOAD_EXT_JOURNAL;
 464                         brelse(bh);
 465                         goto errout;
 466                 }
 467
 468                 /* Check the superblock checksum */
 469                 if (jsuper.s_feature_ro_compat &
 470                     EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
 471                         struct struct_ext2_filsys fsx;
 472                         struct ext2_super_block superx;
 473                         void *p;
 474
 475                         p = start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET;
 476                         memcpy(&fsx, fs, sizeof(fsx));
 477                         memcpy(&superx, fs->super, sizeof(superx));
 478                         fsx.super = &superx;
 479                         fsx.super->s_feature_ro_compat |=
 480                                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM;
 481                         if (!ext2fs_superblock_csum_verify(&fsx, p)) {
 482                                 retval = EXT2_ET_LOAD_EXT_JOURNAL;
 483                                 brelse(bh);
 484                                 goto errout;
 485                         }
 486                 }
 487                 brelse(bh);
 488
 489                 maxlen = ext2fs_blocks_count(&jsuper);
 490                 journal->j_maxlen = (maxlen < 1ULL << 32) ? maxlen :
 491                                     (1ULL << 32) - 1;
 492                 start++;
 493         }
 494
 495         bh = getblk(dev_journal, start, journal->j_blocksize);
 496         if (!bh) {
 497                 retval = EXT2_ET_NO_MEMORY;
 498                 goto errout;
 499         }
 500
 501         journal->j_sb_buffer = bh;
 502         journal->j_superblock = (journal_superblock_t *)bh->b_data;
 503
 504 #ifdef USE_INODE_IO
 505         if (j_inode)
 506                 ext2fs_free_mem(&j_inode);
 507 #endif
 508
 509         *ret_journal = journal;
 510         return 0;
 511
 512 errout:
 513         if (dev_fs)
 514                 ext2fs_free_mem(&dev_fs);
 515         if (j_inode)
 516                 ext2fs_free_mem(&j_inode);
 517         if (journal)
 518                 ext2fs_free_mem(&journal);
 519         return retval;
 520 }
 521
 522 static errcode_t ext2fs_journal_fix_bad_inode(ext2_filsys fs)
 523 {
 524         struct ext2_super_block *sb = fs->super;
 525         int recover = fs->super->s_feature_incompat &
 526                 EXT3_FEATURE_INCOMPAT_RECOVER;
 527         int has_journal = fs->super->s_feature_compat &
 528                 EXT3_FEATURE_COMPAT_HAS_JOURNAL;
 529
 530         if (has_journal || sb->s_journal_inum) {
 531                 /* The journal inode is bogus, remove and force full fsck */
 532                 return EXT2_ET_BAD_INODE_NUM;
 533         } else if (recover) {
 534                 return EXT2_ET_UNSUPP_FEATURE;
 535         }
 536         return 0;
 537 }
 538
 539 #define V1_SB_SIZE      0x0024
 540 static void clear_v2_journal_fields(journal_t *journal)
 541 {
 542         ext2_filsys fs = journal->j_dev->k_fs;
 543
 544         memset(((char *) journal->j_superblock) + V1_SB_SIZE, 0,
 545                fs->blocksize-V1_SB_SIZE);
 546         mark_buffer_dirty(journal->j_sb_buffer);
 547 }
 548
 549
 550 static errcode_t ext2fs_journal_load(journal_t *journal)
 551 {
 552         ext2_filsys fs = journal->j_dev->k_fs;
 553         journal_superblock_t *jsb;
 554         struct buffer_head *jbh = journal->j_sb_buffer;
 555
 556         ll_rw_block(READ, 1, &jbh);
 557         if (jbh->b_err)
 558                 return jbh->b_err;
 559
 560         jsb = journal->j_superblock;
 561         /* If we don't even have JFS_MAGIC, we probably have a wrong inode */
 562         if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER))
 563                 return ext2fs_journal_fix_bad_inode(fs);
 564
 565         switch (ntohl(jsb->s_header.h_blocktype)) {
 566         case JFS_SUPERBLOCK_V1:
 567                 journal->j_format_version = 1;
 568                 if (jsb->s_feature_compat ||
 569                     jsb->s_feature_incompat ||
 570                     jsb->s_feature_ro_compat ||
 571                     jsb->s_nr_users)
 572                         clear_v2_journal_fields(journal);
 573                 break;
 574
 575         case JFS_SUPERBLOCK_V2:
 576                 journal->j_format_version = 2;
 577                 if (ntohl(jsb->s_nr_users) > 1 &&
 578                     uuid_is_null(fs->super->s_journal_uuid))
 579                         clear_v2_journal_fields(journal);
 580                 if (ntohl(jsb->s_nr_users) > 1)
 581                         return EXT2_ET_JOURNAL_UNSUPP_VERSION;
 582                 break;
 583
 584         /*
 585          * These should never appear in a journal super block, so if
 586          * they do, the journal is badly corrupted.
 587          */
 588         case JFS_DESCRIPTOR_BLOCK:
 589         case JFS_COMMIT_BLOCK:
 590         case JFS_REVOKE_BLOCK:
 591                 return EXT2_ET_CORRUPT_SUPERBLOCK;
 592
 593         /* If we don't understand the superblock major type, but there
 594          * is a magic number, then it is likely to be a new format we
 595          * just don't understand, so leave it alone. */
 596         default:
 597                 return EXT2_ET_JOURNAL_UNSUPP_VERSION;
 598         }
 599
 600         if (JFS_HAS_INCOMPAT_FEATURE(journal, ~JFS_KNOWN_INCOMPAT_FEATURES))
 601                 return EXT2_ET_UNSUPP_FEATURE;
 602
 603         if (JFS_HAS_RO_COMPAT_FEATURE(journal, ~JFS_KNOWN_ROCOMPAT_FEATURES))
 604                 return EXT2_ET_RO_UNSUPP_FEATURE;
 605
 606         /* Checksum v1-3 are mutually exclusive features. */
 607         if (JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_CSUM_V2) &&
 608             JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_CSUM_V3))
 609                 return EXT2_ET_CORRUPT_SUPERBLOCK;
 610
 611         if (journal_has_csum_v2or3(journal) &&
 612             JFS_HAS_COMPAT_FEATURE(journal, JFS_FEATURE_COMPAT_CHECKSUM))
 613                 return EXT2_ET_CORRUPT_SUPERBLOCK;
 614
 615         if (!ext2fs_journal_verify_csum_type(journal, jsb) ||
 616             !ext2fs_journal_sb_csum_verify(journal, jsb))
 617                 return EXT2_ET_CORRUPT_SUPERBLOCK;
 618
 619         if (journal_has_csum_v2or3(journal))
 620                 journal->j_csum_seed = jbd2_chksum(journal, ~0, jsb->s_uuid,
 621                                                    sizeof(jsb->s_uuid));
 622
 623         /* We have now checked whether we know enough about the journal
 624          * format to be able to proceed safely, so any other checks that
 625          * fail we should attempt to recover from. */
 626         if (jsb->s_blocksize != htonl(journal->j_blocksize))
 627                 return EXT2_ET_CORRUPT_SUPERBLOCK;
 628
 629         if (ntohl(jsb->s_maxlen) < journal->j_maxlen)
 630                 journal->j_maxlen = ntohl(jsb->s_maxlen);
 631         else if (ntohl(jsb->s_maxlen) > journal->j_maxlen)
 632                 return EXT2_ET_CORRUPT_SUPERBLOCK;
 633
 634         journal->j_tail_sequence = ntohl(jsb->s_sequence);
 635         journal->j_transaction_sequence = journal->j_tail_sequence;
 636         journal->j_tail = ntohl(jsb->s_start);
 637         journal->j_first = ntohl(jsb->s_first);
 638         journal->j_last = ntohl(jsb->s_maxlen);
 639
 640         return 0;
 641 }
 642
 643 void ext2fs_journal_release(ext2_filsys fs, journal_t *journal,
 644                                    int reset, int drop)
 645 {
 646         journal_superblock_t *jsb;
 647
 648         if (drop)
 649                 mark_buffer_clean(journal->j_sb_buffer);
 650         else if (fs->flags & EXT2_FLAG_RW) {
 651                 jsb = journal->j_superblock;
 652                 jsb->s_sequence = htonl(journal->j_tail_sequence);
 653                 if (reset)
 654                         jsb->s_start = 0; /* this marks the journal as empty */
 655                 ext2fs_journal_sb_csum_set(journal, jsb);
 656                 mark_buffer_dirty(journal->j_sb_buffer);
 657         }
 658         brelse(journal->j_sb_buffer);
 659
 660         if (fs->journal_io) {
 661                 if (fs && fs->io != fs->journal_io)
 662                         io_channel_close(fs->journal_io);
 663                 fs->journal_io = 0;
 664         }
 665
 666 #ifndef USE_INODE_IO
 667         if (journal->j_inode)
 668                 ext2fs_free_mem(&journal->j_inode);
 669 #endif
 670         if (journal->j_fs_dev)
 671                 ext2fs_free_mem(&journal->j_fs_dev);
 672         ext2fs_free_mem(&journal);
 673 }
 674
 675 /*
 676  * This function makes sure that the superblock fields regarding the
 677  * journal are consistent.
 678  */
 679 errcode_t ext2fs_check_ext3_journal(ext2_filsys fs)
 680 {
 681         struct ext2_super_block *sb = fs->super;
 682         journal_t *journal;
 683         int recover = fs->super->s_feature_incompat &
 684                 EXT3_FEATURE_INCOMPAT_RECOVER;
 685         int reset = 0;
 686         errcode_t retval;
 687
 688         /* If we don't have any journal features, don't do anything more */
 689         if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
 690             !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 &&
 691             uuid_is_null(sb->s_journal_uuid))
 692                 return 0;
 693
 694         retval = ext2fs_get_journal(fs, &journal);
 695         if (retval)
 696                 return retval;
 697
 698         retval = ext2fs_journal_load(journal);
 699         if (retval) {
 700                 ext2fs_journal_release(fs, journal, 0, 1);
 701                 return retval;
 702         }
 703
 704         /*
 705          * We want to make the flags consistent here.  We will not leave with
 706          * needs_recovery set but has_journal clear.  We can't get in a loop
 707          * with -y, -n, or -p, only if a user isn't making up their mind.
 708          */
 709         if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL))
 710                 return EXT2_ET_JOURNAL_FLAGS_WRONG;
 711
 712         if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
 713             !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
 714             journal->j_superblock->s_start != 0)
 715                 return EXT2_ET_JOURNAL_FLAGS_WRONG;
 716
 717         /*
 718          * If we don't need to do replay the journal, check to see if
 719          * the journal's errno is set; if so, we need to mark the file
 720          * system as being corrupt and clear the journal's s_errno.
 721          */
 722         if (!(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
 723             journal->j_superblock->s_errno) {
 724                 fs->super->s_state |= EXT2_ERROR_FS;
 725                 ext2fs_mark_super_dirty(fs);
 726                 journal->j_superblock->s_errno = 0;
 727                 ext2fs_journal_sb_csum_set(journal, journal->j_superblock);
 728                 mark_buffer_dirty(journal->j_sb_buffer);
 729         }
 730
 731         ext2fs_journal_release(fs, journal, reset, 0);
 732         return retval;
 733 }
 734
 735 static errcode_t recover_ext3_journal(ext2_filsys fs)
 736 {
 737         journal_t *journal;
 738         errcode_t retval;
 739
 740         journal_init_revoke_caches();
 741         retval = ext2fs_get_journal(fs, &journal);
 742         if (retval)
 743                 return retval;
 744
 745         retval = ext2fs_journal_load(journal);
 746         if (retval)
 747                 goto errout;
 748
 749         retval = journal_init_revoke(journal, 1024);
 750         if (retval)
 751                 goto errout;
 752
 753         retval = -journal_recover(journal);
 754         if (retval)
 755                 goto errout;
 756
 757         if (journal->j_failed_commit) {
 758                 journal->j_superblock->s_errno = -EINVAL;
 759                 mark_buffer_dirty(journal->j_sb_buffer);
 760         }
 761
 762 errout:
 763         journal_destroy_revoke(journal);
 764         journal_destroy_revoke_caches();
 765         ext2fs_journal_release(fs, journal, 1, 0);
 766         return retval;
 767 }
 768
 769 errcode_t ext2fs_run_ext3_journal(ext2_filsys *fsp)
 770 {
 771         ext2_filsys fs = *fsp;
 772         io_manager io_ptr = fs->io->manager;
 773         errcode_t       retval, recover_retval;
 774         io_stats        stats = 0;
 775         unsigned long long kbytes_written = 0;
 776         char *fsname;
 777         int fsflags;
 778         int fsblocksize;
 779
 780         if (!(fs->flags & EXT2_FLAG_RW))
 781                 return EXT2_ET_FILE_RO;
 782
 783         if (fs->flags & EXT2_FLAG_DIRTY)
 784                 ext2fs_flush(fs);       /* Force out any modifications */
 785
 786         recover_retval = recover_ext3_journal(fs);
 787
 788         /*
 789          * Reload the filesystem context to get up-to-date data from disk
 790          * because journal recovery will change the filesystem under us.
 791          */
 792         if (fs->super->s_kbytes_written &&
 793             fs->io->manager->get_stats)
 794                 fs->io->manager->get_stats(fs->io, &stats);
 795         if (stats && stats->bytes_written)
 796                 kbytes_written = stats->bytes_written >> 10;
 797
 798         ext2fs_mmp_stop(fs);
 799         fsname = strdup(fs->device_name);
 800         fsflags = fs->flags;
 801         fsblocksize = fs->blocksize;
 802         ext2fs_free(fs);
 803         retval = ext2fs_open(fsname, fsflags,
 804                              0, fsblocksize, io_ptr,
 805                              fsp);
 806         free(fsname);
 807         if (retval)
 808                 return retval;
 809
 810         fs = *fsp;
 811         fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
 812         fs->super->s_kbytes_written += kbytes_written;
 813
 814         /* Set the superblock flags */
 815         ext2fs_clear_recover(fs, recover_retval != 0);
 816
 817         /*
 818          * Do one last sanity check, and propagate journal->s_errno to
 819          * the EXT2_ERROR_FS flag in the fs superblock if needed.
 820          */
 821         retval = ext2fs_check_ext3_journal(fs);
 822         return retval ? retval : recover_retval;
 823 }
 824
 825 errcode_t ext2fs_open_journal(ext2_filsys fs, journal_t **j)
 826 {
 827         journal_t *journal;
 828         errcode_t retval;
 829
 830         journal_init_revoke_caches();
 831         retval = ext2fs_get_journal(fs, &journal);
 832         if (retval)
 833                 return retval;
 834
 835         retval = ext2fs_journal_load(journal);
 836         if (retval)
 837                 goto errout;
 838
 839         retval = journal_init_revoke(journal, 1024);
 840         if (retval)
 841                 goto errout;
 842
 843         if (journal->j_failed_commit) {
 844                 journal->j_superblock->s_errno = -EINVAL;
 845                 mark_buffer_dirty(journal->j_sb_buffer);
 846         }
 847
 848         *j = journal;
 849         return 0;
 850
 851 errout:
 852         journal_destroy_revoke(journal);
 853         journal_destroy_revoke_caches();
 854         ext2fs_journal_release(fs, journal, 1, 0);
 855         return retval;
 856 }
 857
 858 errcode_t ext2fs_close_journal(ext2_filsys fs, journal_t **j)
 859 {
 860         journal_t *journal = *j;
 861
 862         journal_destroy_revoke(journal);
 863         journal_destroy_revoke_caches();
 864         ext2fs_journal_release(fs, journal, 0, 0);
 865         *j = NULL;
 866
 867         return 0;
 868 }
 869
 870 void jbd2_commit_block_csum_set(journal_t *j, struct buffer_head *bh)
 871 {
 872         struct commit_header *h;
 873         __u32 csum;
 874
 875         if (!journal_has_csum_v2or3(j))
 876                 return;
 877
 878         h = (struct commit_header *)(bh->b_data);
 879         h->h_chksum_type = 0;
 880         h->h_chksum_size = 0;
 881         h->h_chksum[0] = 0;
 882         csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
 883         h->h_chksum[0] = ext2fs_cpu_to_be32(csum);
 884 }
 885
 886 void jbd2_revoke_csum_set(journal_t *j, struct buffer_head *bh)
 887 {
 888         struct journal_revoke_tail *tail;
 889         __u32 csum;
 890
 891         if (!journal_has_csum_v2or3(j))
 892                 return;
 893
 894         tail = (struct journal_revoke_tail *)(bh->b_data + j->j_blocksize -
 895                         sizeof(struct journal_revoke_tail));
 896         tail->r_checksum = 0;
 897         csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
 898         tail->r_checksum = ext2fs_cpu_to_be32(csum);
 899 }
 900
 901 void jbd2_descr_block_csum_set(journal_t *j, struct buffer_head *bh)
 902 {
 903         struct journal_block_tail *tail;
 904         __u32 csum;
 905
 906         if (!journal_has_csum_v2or3(j))
 907                 return;
 908
 909         tail = (struct journal_block_tail *)(bh->b_data + j->j_blocksize -
 910                         sizeof(struct journal_block_tail));
 911         tail->t_checksum = 0;
 912         csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
 913         tail->t_checksum = ext2fs_cpu_to_be32(csum);
 914 }
 915
 916 void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
 917                              struct buffer_head *bh, __u32 sequence)
 918 {
 919         journal_block_tag3_t *tag3 = (journal_block_tag3_t *)tag;
 920         __u32 csum32;
 921         __be32 seq;
 922
 923         if (!journal_has_csum_v2or3(j))
 924                 return;
 925
 926         seq = ext2fs_cpu_to_be32(sequence);
 927         csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
 928         csum32 = jbd2_chksum(j, csum32, bh->b_data, bh->b_size);
 929
 930         if (JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V3))
 931                 tag3->t_checksum = ext2fs_cpu_to_be32(csum32);
 932         else
 933                 tag->t_checksum = ext2fs_cpu_to_be16(csum32);
 934 }
 935