Home | History | Annotate | Download | only in e2fsck
      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 #ifdef HAVE_SYS_MOUNT_H
     16 #include <sys/param.h>
     17 #include <sys/mount.h>
     18 #define MNT_FL (MS_MGC_VAL | MS_RDONLY)
     19 #endif
     20 #ifdef HAVE_SYS_STAT_H
     21 #include <sys/stat.h>
     22 #endif
     23 
     24 #define E2FSCK_INCLUDE_INLINE_FUNCS
     25 #include "jfs_user.h"
     26 #include "problem.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 /*
     34  * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths.
     35  * This creates a larger static binary, and a smaller binary using
     36  * shared libraries.  It's also probably slightly less CPU-efficient,
     37  * which is why it's not on by default.  But, it's a good way of
     38  * testing the functions in inode_io.c and fileio.c.
     39  */
     40 #undef USE_INODE_IO
     41 
     42 /* Kernel compatibility functions for handling the journal.  These allow us
     43  * to use the recovery.c file virtually unchanged from the kernel, so we
     44  * don't have to do much to keep kernel and user recovery in sync.
     45  */
     46 int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys)
     47 {
     48 #ifdef USE_INODE_IO
     49 	*phys = block;
     50 	return 0;
     51 #else
     52 	struct inode 	*inode = journal->j_inode;
     53 	errcode_t	retval;
     54 	blk_t		pblk;
     55 
     56 	if (!inode) {
     57 		*phys = block;
     58 		return 0;
     59 	}
     60 
     61 	retval= ext2fs_bmap(inode->i_ctx->fs, inode->i_ino,
     62 			    &inode->i_ext2, NULL, 0, block, &pblk);
     63 	*phys = pblk;
     64 	return (retval);
     65 #endif
     66 }
     67 
     68 struct buffer_head *getblk(kdev_t kdev, blk_t blocknr, int blocksize)
     69 {
     70 	struct buffer_head *bh;
     71 	int bufsize = sizeof(*bh) + kdev->k_ctx->fs->blocksize -
     72 		sizeof(bh->b_data);
     73 
     74 	bh = e2fsck_allocate_memory(kdev->k_ctx, bufsize, "block buffer");
     75 	if (!bh)
     76 		return NULL;
     77 
     78 #ifdef CONFIG_JBD_DEBUG
     79 	if (journal_enable_debug >= 3)
     80 		bh_count++;
     81 #endif
     82 	jfs_debug(4, "getblk for block %lu (%d bytes)(total %d)\n",
     83 		  (unsigned long) blocknr, blocksize, bh_count);
     84 
     85 	bh->b_ctx = kdev->k_ctx;
     86 	if (kdev->k_dev == K_DEV_FS)
     87 		bh->b_io = kdev->k_ctx->fs->io;
     88 	else
     89 		bh->b_io = kdev->k_ctx->journal_io;
     90 	bh->b_size = blocksize;
     91 	bh->b_blocknr = blocknr;
     92 
     93 	return bh;
     94 }
     95 
     96 void sync_blockdev(kdev_t kdev)
     97 {
     98 	io_channel	io;
     99 
    100 	if (kdev->k_dev == K_DEV_FS)
    101 		io = kdev->k_ctx->fs->io;
    102 	else
    103 		io = kdev->k_ctx->journal_io;
    104 
    105 	io_channel_flush(io);
    106 }
    107 
    108 void ll_rw_block(int rw, int nr, struct buffer_head *bhp[])
    109 {
    110 	int retval;
    111 	struct buffer_head *bh;
    112 
    113 	for (; nr > 0; --nr) {
    114 		bh = *bhp++;
    115 		if (rw == READ && !bh->b_uptodate) {
    116 			jfs_debug(3, "reading block %lu/%p\n",
    117 				  (unsigned long) bh->b_blocknr, (void *) bh);
    118 			retval = io_channel_read_blk(bh->b_io,
    119 						     bh->b_blocknr,
    120 						     1, bh->b_data);
    121 			if (retval) {
    122 				com_err(bh->b_ctx->device_name, retval,
    123 					"while reading block %lu\n",
    124 					(unsigned long) bh->b_blocknr);
    125 				bh->b_err = retval;
    126 				continue;
    127 			}
    128 			bh->b_uptodate = 1;
    129 		} else if (rw == WRITE && bh->b_dirty) {
    130 			jfs_debug(3, "writing block %lu/%p\n",
    131 				  (unsigned long) bh->b_blocknr, (void *) bh);
    132 			retval = io_channel_write_blk(bh->b_io,
    133 						      bh->b_blocknr,
    134 						      1, bh->b_data);
    135 			if (retval) {
    136 				com_err(bh->b_ctx->device_name, retval,
    137 					"while writing block %lu\n",
    138 					(unsigned long) bh->b_blocknr);
    139 				bh->b_err = retval;
    140 				continue;
    141 			}
    142 			bh->b_dirty = 0;
    143 			bh->b_uptodate = 1;
    144 		} else {
    145 			jfs_debug(3, "no-op %s for block %lu\n",
    146 				  rw == READ ? "read" : "write",
    147 				  (unsigned long) bh->b_blocknr);
    148 		}
    149 	}
    150 }
    151 
    152 void mark_buffer_dirty(struct buffer_head *bh)
    153 {
    154 	bh->b_dirty = 1;
    155 }
    156 
    157 static void mark_buffer_clean(struct buffer_head * bh)
    158 {
    159 	bh->b_dirty = 0;
    160 }
    161 
    162 void brelse(struct buffer_head *bh)
    163 {
    164 	if (bh->b_dirty)
    165 		ll_rw_block(WRITE, 1, &bh);
    166 	jfs_debug(3, "freeing block %lu/%p (total %d)\n",
    167 		  (unsigned long) bh->b_blocknr, (void *) bh, --bh_count);
    168 	ext2fs_free_mem(&bh);
    169 }
    170 
    171 int buffer_uptodate(struct buffer_head *bh)
    172 {
    173 	return bh->b_uptodate;
    174 }
    175 
    176 void mark_buffer_uptodate(struct buffer_head *bh, int val)
    177 {
    178 	bh->b_uptodate = val;
    179 }
    180 
    181 void wait_on_buffer(struct buffer_head *bh)
    182 {
    183 	if (!bh->b_uptodate)
    184 		ll_rw_block(READ, 1, &bh);
    185 }
    186 
    187 
    188 static void e2fsck_clear_recover(e2fsck_t ctx, int error)
    189 {
    190 	ctx->fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
    191 
    192 	/* if we had an error doing journal recovery, we need a full fsck */
    193 	if (error)
    194 		ctx->fs->super->s_state &= ~EXT2_VALID_FS;
    195 	ext2fs_mark_super_dirty(ctx->fs);
    196 }
    197 
    198 /*
    199  * This is a helper function to check the validity of the journal.
    200  */
    201 struct process_block_struct {
    202 	e2_blkcnt_t	last_block;
    203 };
    204 
    205 static int process_journal_block(ext2_filsys fs,
    206 				 blk_t	*block_nr,
    207 				 e2_blkcnt_t blockcnt,
    208 				 blk_t ref_block EXT2FS_ATTR((unused)),
    209 				 int ref_offset EXT2FS_ATTR((unused)),
    210 				 void *priv_data)
    211 {
    212 	struct process_block_struct *p;
    213 	blk_t	blk = *block_nr;
    214 
    215 	p = (struct process_block_struct *) priv_data;
    216 
    217 	if (blk < fs->super->s_first_data_block ||
    218 	    blk >= fs->super->s_blocks_count)
    219 		return BLOCK_ABORT;
    220 
    221 	if (blockcnt >= 0)
    222 		p->last_block = blockcnt;
    223 	return 0;
    224 }
    225 
    226 static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
    227 {
    228 	struct process_block_struct pb;
    229 	struct ext2_super_block *sb = ctx->fs->super;
    230 	struct ext2_super_block jsuper;
    231 	struct problem_context	pctx;
    232 	struct buffer_head 	*bh;
    233 	struct inode		*j_inode = NULL;
    234 	struct kdev_s		*dev_fs = NULL, *dev_journal;
    235 	const char		*journal_name = 0;
    236 	journal_t		*journal = NULL;
    237 	errcode_t		retval = 0;
    238 	io_manager		io_ptr = 0;
    239 	unsigned long		start = 0;
    240 	int			ext_journal = 0;
    241 	int			tried_backup_jnl = 0;
    242 
    243 	clear_problem_context(&pctx);
    244 
    245 	journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal");
    246 	if (!journal) {
    247 		return EXT2_ET_NO_MEMORY;
    248 	}
    249 
    250 	dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev");
    251 	if (!dev_fs) {
    252 		retval = EXT2_ET_NO_MEMORY;
    253 		goto errout;
    254 	}
    255 	dev_journal = dev_fs+1;
    256 
    257 	dev_fs->k_ctx = dev_journal->k_ctx = ctx;
    258 	dev_fs->k_dev = K_DEV_FS;
    259 	dev_journal->k_dev = K_DEV_JOURNAL;
    260 
    261 	journal->j_dev = dev_journal;
    262 	journal->j_fs_dev = dev_fs;
    263 	journal->j_inode = NULL;
    264 	journal->j_blocksize = ctx->fs->blocksize;
    265 
    266 	if (uuid_is_null(sb->s_journal_uuid)) {
    267 		if (!sb->s_journal_inum) {
    268 			retval = EXT2_ET_BAD_INODE_NUM;
    269 			goto errout;
    270 		}
    271 		j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode),
    272 						 "journal inode");
    273 		if (!j_inode) {
    274 			retval = EXT2_ET_NO_MEMORY;
    275 			goto errout;
    276 		}
    277 
    278 		j_inode->i_ctx = ctx;
    279 		j_inode->i_ino = sb->s_journal_inum;
    280 
    281 		if ((retval = ext2fs_read_inode(ctx->fs,
    282 						sb->s_journal_inum,
    283 						&j_inode->i_ext2))) {
    284 		try_backup_journal:
    285 			if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
    286 			    tried_backup_jnl)
    287 				goto errout;
    288 			memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
    289 			memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
    290 			       EXT2_N_BLOCKS*4);
    291 			j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
    292 			j_inode->i_ext2.i_links_count = 1;
    293 			j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
    294 			e2fsck_use_inode_shortcuts(ctx, 1);
    295 			ctx->stashed_ino = j_inode->i_ino;
    296 			ctx->stashed_inode = &j_inode->i_ext2;
    297 			tried_backup_jnl++;
    298 		}
    299 		if (!j_inode->i_ext2.i_links_count ||
    300 		    !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
    301 			retval = EXT2_ET_NO_JOURNAL;
    302 			goto try_backup_journal;
    303 		}
    304 		if (j_inode->i_ext2.i_size / journal->j_blocksize <
    305 		    JFS_MIN_JOURNAL_BLOCKS) {
    306 			retval = EXT2_ET_JOURNAL_TOO_SMALL;
    307 			goto try_backup_journal;
    308 		}
    309 		pb.last_block = -1;
    310 		retval = ext2fs_block_iterate2(ctx->fs, j_inode->i_ino,
    311 					       BLOCK_FLAG_HOLE, 0,
    312 					       process_journal_block, &pb);
    313 		if ((pb.last_block+1) * ctx->fs->blocksize <
    314 		    j_inode->i_ext2.i_size) {
    315 			retval = EXT2_ET_JOURNAL_TOO_SMALL;
    316 			goto try_backup_journal;
    317 		}
    318 		if (tried_backup_jnl && !(ctx->options & E2F_OPT_READONLY)) {
    319 			retval = ext2fs_write_inode(ctx->fs, sb->s_journal_inum,
    320 						    &j_inode->i_ext2);
    321 			if (retval)
    322 				goto errout;
    323 		}
    324 
    325 		journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize;
    326 
    327 #ifdef USE_INODE_IO
    328 		retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum,
    329 						 &j_inode->i_ext2,
    330 						 &journal_name);
    331 		if (retval)
    332 			goto errout;
    333 
    334 		io_ptr = inode_io_manager;
    335 #else
    336 		journal->j_inode = j_inode;
    337 		ctx->journal_io = ctx->fs->io;
    338 		if ((retval = journal_bmap(journal, 0, &start)) != 0)
    339 			goto errout;
    340 #endif
    341 	} else {
    342 		ext_journal = 1;
    343 		if (!ctx->journal_name) {
    344 			char uuid[37];
    345 
    346 			uuid_unparse(sb->s_journal_uuid, uuid);
    347 			ctx->journal_name = blkid_get_devname(ctx->blkid,
    348 							      "UUID", uuid);
    349 			if (!ctx->journal_name)
    350 				ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
    351 		}
    352 		journal_name = ctx->journal_name;
    353 
    354 		if (!journal_name) {
    355 			fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx);
    356 			retval = EXT2_ET_LOAD_EXT_JOURNAL;
    357 			goto errout;
    358 		}
    359 
    360 		jfs_debug(1, "Using journal file %s\n", journal_name);
    361 		io_ptr = unix_io_manager;
    362 	}
    363 
    364 #if 0
    365 	test_io_backing_manager = io_ptr;
    366 	io_ptr = test_io_manager;
    367 #endif
    368 #ifndef USE_INODE_IO
    369 	if (ext_journal)
    370 #endif
    371 		retval = io_ptr->open(journal_name, IO_FLAG_RW,
    372 				      &ctx->journal_io);
    373 	if (retval)
    374 		goto errout;
    375 
    376 	io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize);
    377 
    378 	if (ext_journal) {
    379 		if (ctx->fs->blocksize == 1024)
    380 			start = 1;
    381 		bh = getblk(dev_journal, start, ctx->fs->blocksize);
    382 		if (!bh) {
    383 			retval = EXT2_ET_NO_MEMORY;
    384 			goto errout;
    385 		}
    386 		ll_rw_block(READ, 1, &bh);
    387 		if ((retval = bh->b_err) != 0) {
    388 			brelse(bh);
    389 			goto errout;
    390 		}
    391 		memcpy(&jsuper, start ? bh->b_data :  bh->b_data + 1024,
    392 		       sizeof(jsuper));
    393 		brelse(bh);
    394 #ifdef WORDS_BIGENDIAN
    395 		if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
    396 			ext2fs_swap_super(&jsuper);
    397 #endif
    398 		if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
    399 		    !(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
    400 			fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx);
    401 			retval = EXT2_ET_LOAD_EXT_JOURNAL;
    402 			goto errout;
    403 		}
    404 		/* Make sure the journal UUID is correct */
    405 		if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid,
    406 			   sizeof(jsuper.s_uuid))) {
    407 			fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx);
    408 			retval = EXT2_ET_LOAD_EXT_JOURNAL;
    409 			goto errout;
    410 		}
    411 
    412 		journal->j_maxlen = jsuper.s_blocks_count;
    413 		start++;
    414 	}
    415 
    416 	if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) {
    417 		retval = EXT2_ET_NO_MEMORY;
    418 		goto errout;
    419 	}
    420 
    421 	journal->j_sb_buffer = bh;
    422 	journal->j_superblock = (journal_superblock_t *)bh->b_data;
    423 
    424 #ifdef USE_INODE_IO
    425 	if (j_inode)
    426 		ext2fs_free_mem(&j_inode);
    427 #endif
    428 
    429 	*ret_journal = journal;
    430 	e2fsck_use_inode_shortcuts(ctx, 0);
    431 	return 0;
    432 
    433 errout:
    434 	e2fsck_use_inode_shortcuts(ctx, 0);
    435 	if (dev_fs)
    436 		ext2fs_free_mem(&dev_fs);
    437 	if (j_inode)
    438 		ext2fs_free_mem(&j_inode);
    439 	if (journal)
    440 		ext2fs_free_mem(&journal);
    441 	return retval;
    442 }
    443 
    444 static errcode_t e2fsck_journal_fix_bad_inode(e2fsck_t ctx,
    445 					      struct problem_context *pctx)
    446 {
    447 	struct ext2_super_block *sb = ctx->fs->super;
    448 	int recover = ctx->fs->super->s_feature_incompat &
    449 		EXT3_FEATURE_INCOMPAT_RECOVER;
    450 	int has_journal = ctx->fs->super->s_feature_compat &
    451 		EXT3_FEATURE_COMPAT_HAS_JOURNAL;
    452 
    453 	if (has_journal || sb->s_journal_inum) {
    454 		/* The journal inode is bogus, remove and force full fsck */
    455 		pctx->ino = sb->s_journal_inum;
    456 		if (fix_problem(ctx, PR_0_JOURNAL_BAD_INODE, pctx)) {
    457 			if (has_journal && sb->s_journal_inum)
    458 				printf("*** ext3 journal has been deleted - "
    459 				       "filesystem is now ext2 only ***\n\n");
    460 			sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
    461 			sb->s_journal_inum = 0;
    462 			ctx->flags |= E2F_FLAG_JOURNAL_INODE;
    463 			ctx->fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
    464 			e2fsck_clear_recover(ctx, 1);
    465 			return 0;
    466 		}
    467 		return EXT2_ET_BAD_INODE_NUM;
    468 	} else if (recover) {
    469 		if (fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, pctx)) {
    470 			e2fsck_clear_recover(ctx, 1);
    471 			return 0;
    472 		}
    473 		return EXT2_ET_UNSUPP_FEATURE;
    474 	}
    475 	return 0;
    476 }
    477 
    478 #define V1_SB_SIZE	0x0024
    479 static void clear_v2_journal_fields(journal_t *journal)
    480 {
    481 	e2fsck_t ctx = journal->j_dev->k_ctx;
    482 	struct problem_context pctx;
    483 
    484 	clear_problem_context(&pctx);
    485 
    486 	if (!fix_problem(ctx, PR_0_CLEAR_V2_JOURNAL, &pctx))
    487 		return;
    488 
    489 	memset(((char *) journal->j_superblock) + V1_SB_SIZE, 0,
    490 	       ctx->fs->blocksize-V1_SB_SIZE);
    491 	mark_buffer_dirty(journal->j_sb_buffer);
    492 }
    493 
    494 
    495 static errcode_t e2fsck_journal_load(journal_t *journal)
    496 {
    497 	e2fsck_t ctx = journal->j_dev->k_ctx;
    498 	journal_superblock_t *jsb;
    499 	struct buffer_head *jbh = journal->j_sb_buffer;
    500 	struct problem_context pctx;
    501 
    502 	clear_problem_context(&pctx);
    503 
    504 	ll_rw_block(READ, 1, &jbh);
    505 	if (jbh->b_err) {
    506 		com_err(ctx->device_name, jbh->b_err,
    507 			_("reading journal superblock\n"));
    508 		return jbh->b_err;
    509 	}
    510 
    511 	jsb = journal->j_superblock;
    512 	/* If we don't even have JFS_MAGIC, we probably have a wrong inode */
    513 	if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER))
    514 		return e2fsck_journal_fix_bad_inode(ctx, &pctx);
    515 
    516 	switch (ntohl(jsb->s_header.h_blocktype)) {
    517 	case JFS_SUPERBLOCK_V1:
    518 		journal->j_format_version = 1;
    519 		if (jsb->s_feature_compat ||
    520 		    jsb->s_feature_incompat ||
    521 		    jsb->s_feature_ro_compat ||
    522 		    jsb->s_nr_users)
    523 			clear_v2_journal_fields(journal);
    524 		break;
    525 
    526 	case JFS_SUPERBLOCK_V2:
    527 		journal->j_format_version = 2;
    528 		if (ntohl(jsb->s_nr_users) > 1 &&
    529 		    uuid_is_null(ctx->fs->super->s_journal_uuid))
    530 			clear_v2_journal_fields(journal);
    531 		if (ntohl(jsb->s_nr_users) > 1) {
    532 			fix_problem(ctx, PR_0_JOURNAL_UNSUPP_MULTIFS, &pctx);
    533 			return EXT2_ET_JOURNAL_UNSUPP_VERSION;
    534 		}
    535 		break;
    536 
    537 	/*
    538 	 * These should never appear in a journal super block, so if
    539 	 * they do, the journal is badly corrupted.
    540 	 */
    541 	case JFS_DESCRIPTOR_BLOCK:
    542 	case JFS_COMMIT_BLOCK:
    543 	case JFS_REVOKE_BLOCK:
    544 		return EXT2_ET_CORRUPT_SUPERBLOCK;
    545 
    546 	/* If we don't understand the superblock major type, but there
    547 	 * is a magic number, then it is likely to be a new format we
    548 	 * just don't understand, so leave it alone. */
    549 	default:
    550 		return EXT2_ET_JOURNAL_UNSUPP_VERSION;
    551 	}
    552 
    553 	if (JFS_HAS_INCOMPAT_FEATURE(journal, ~JFS_KNOWN_INCOMPAT_FEATURES))
    554 		return EXT2_ET_UNSUPP_FEATURE;
    555 
    556 	if (JFS_HAS_RO_COMPAT_FEATURE(journal, ~JFS_KNOWN_ROCOMPAT_FEATURES))
    557 		return EXT2_ET_RO_UNSUPP_FEATURE;
    558 
    559 	/* We have now checked whether we know enough about the journal
    560 	 * format to be able to proceed safely, so any other checks that
    561 	 * fail we should attempt to recover from. */
    562 	if (jsb->s_blocksize != htonl(journal->j_blocksize)) {
    563 		com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK,
    564 			_("%s: no valid journal superblock found\n"),
    565 			ctx->device_name);
    566 		return EXT2_ET_CORRUPT_SUPERBLOCK;
    567 	}
    568 
    569 	if (ntohl(jsb->s_maxlen) < journal->j_maxlen)
    570 		journal->j_maxlen = ntohl(jsb->s_maxlen);
    571 	else if (ntohl(jsb->s_maxlen) > journal->j_maxlen) {
    572 		com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK,
    573 			_("%s: journal too short\n"),
    574 			ctx->device_name);
    575 		return EXT2_ET_CORRUPT_SUPERBLOCK;
    576 	}
    577 
    578 	journal->j_tail_sequence = ntohl(jsb->s_sequence);
    579 	journal->j_transaction_sequence = journal->j_tail_sequence;
    580 	journal->j_tail = ntohl(jsb->s_start);
    581 	journal->j_first = ntohl(jsb->s_first);
    582 	journal->j_last = ntohl(jsb->s_maxlen);
    583 
    584 	return 0;
    585 }
    586 
    587 static void e2fsck_journal_reset_super(e2fsck_t ctx, journal_superblock_t *jsb,
    588 				       journal_t *journal)
    589 {
    590 	char *p;
    591 	union {
    592 		uuid_t uuid;
    593 		__u32 val[4];
    594 	} u;
    595 	__u32 new_seq = 0;
    596 	int i;
    597 
    598 	/* Leave a valid existing V1 superblock signature alone.
    599 	 * Anything unrecognisable we overwrite with a new V2
    600 	 * signature. */
    601 
    602 	if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER) ||
    603 	    jsb->s_header.h_blocktype != htonl(JFS_SUPERBLOCK_V1)) {
    604 		jsb->s_header.h_magic = htonl(JFS_MAGIC_NUMBER);
    605 		jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2);
    606 	}
    607 
    608 	/* Zero out everything else beyond the superblock header */
    609 
    610 	p = ((char *) jsb) + sizeof(journal_header_t);
    611 	memset (p, 0, ctx->fs->blocksize-sizeof(journal_header_t));
    612 
    613 	jsb->s_blocksize = htonl(ctx->fs->blocksize);
    614 	jsb->s_maxlen = htonl(journal->j_maxlen);
    615 	jsb->s_first = htonl(1);
    616 
    617 	/* Initialize the journal sequence number so that there is "no"
    618 	 * chance we will find old "valid" transactions in the journal.
    619 	 * This avoids the need to zero the whole journal (slow to do,
    620 	 * and risky when we are just recovering the filesystem).
    621 	 */
    622 	uuid_generate(u.uuid);
    623 	for (i = 0; i < 4; i ++)
    624 		new_seq ^= u.val[i];
    625 	jsb->s_sequence = htonl(new_seq);
    626 
    627 	mark_buffer_dirty(journal->j_sb_buffer);
    628 	ll_rw_block(WRITE, 1, &journal->j_sb_buffer);
    629 }
    630 
    631 static errcode_t e2fsck_journal_fix_corrupt_super(e2fsck_t ctx,
    632 						  journal_t *journal,
    633 						  struct problem_context *pctx)
    634 {
    635 	struct ext2_super_block *sb = ctx->fs->super;
    636 	int recover = ctx->fs->super->s_feature_incompat &
    637 		EXT3_FEATURE_INCOMPAT_RECOVER;
    638 
    639 	if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
    640 		if (fix_problem(ctx, PR_0_JOURNAL_BAD_SUPER, pctx)) {
    641 			e2fsck_journal_reset_super(ctx, journal->j_superblock,
    642 						   journal);
    643 			journal->j_transaction_sequence = 1;
    644 			e2fsck_clear_recover(ctx, recover);
    645 			return 0;
    646 		}
    647 		return EXT2_ET_CORRUPT_SUPERBLOCK;
    648 	} else if (e2fsck_journal_fix_bad_inode(ctx, pctx))
    649 		return EXT2_ET_CORRUPT_SUPERBLOCK;
    650 
    651 	return 0;
    652 }
    653 
    654 static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal,
    655 				   int reset, int drop)
    656 {
    657 	journal_superblock_t *jsb;
    658 
    659 	if (drop)
    660 		mark_buffer_clean(journal->j_sb_buffer);
    661 	else if (!(ctx->options & E2F_OPT_READONLY)) {
    662 		jsb = journal->j_superblock;
    663 		jsb->s_sequence = htonl(journal->j_transaction_sequence);
    664 		if (reset)
    665 			jsb->s_start = 0; /* this marks the journal as empty */
    666 		mark_buffer_dirty(journal->j_sb_buffer);
    667 	}
    668 	brelse(journal->j_sb_buffer);
    669 
    670 	if (ctx->journal_io) {
    671 		if (ctx->fs && ctx->fs->io != ctx->journal_io)
    672 			io_channel_close(ctx->journal_io);
    673 		ctx->journal_io = 0;
    674 	}
    675 
    676 #ifndef USE_INODE_IO
    677 	if (journal->j_inode)
    678 		ext2fs_free_mem(&journal->j_inode);
    679 #endif
    680 	if (journal->j_fs_dev)
    681 		ext2fs_free_mem(&journal->j_fs_dev);
    682 	ext2fs_free_mem(&journal);
    683 }
    684 
    685 /*
    686  * This function makes sure that the superblock fields regarding the
    687  * journal are consistent.
    688  */
    689 int e2fsck_check_ext3_journal(e2fsck_t ctx)
    690 {
    691 	struct ext2_super_block *sb = ctx->fs->super;
    692 	journal_t *journal;
    693 	int recover = ctx->fs->super->s_feature_incompat &
    694 		EXT3_FEATURE_INCOMPAT_RECOVER;
    695 	struct problem_context pctx;
    696 	problem_t problem;
    697 	int reset = 0, force_fsck = 0;
    698 	int retval;
    699 
    700 	/* If we don't have any journal features, don't do anything more */
    701 	if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
    702 	    !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 &&
    703 	    uuid_is_null(sb->s_journal_uuid))
    704  		return 0;
    705 
    706 	clear_problem_context(&pctx);
    707 	pctx.num = sb->s_journal_inum;
    708 
    709 	retval = e2fsck_get_journal(ctx, &journal);
    710 	if (retval) {
    711 		if ((retval == EXT2_ET_BAD_INODE_NUM) ||
    712 		    (retval == EXT2_ET_BAD_BLOCK_NUM) ||
    713 		    (retval == EXT2_ET_JOURNAL_TOO_SMALL) ||
    714 		    (retval == EXT2_ET_NO_JOURNAL))
    715 			return e2fsck_journal_fix_bad_inode(ctx, &pctx);
    716 		return retval;
    717 	}
    718 
    719 	retval = e2fsck_journal_load(journal);
    720 	if (retval) {
    721 		if ((retval == EXT2_ET_CORRUPT_SUPERBLOCK) ||
    722 		    ((retval == EXT2_ET_UNSUPP_FEATURE) &&
    723 		    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_INCOMPAT,
    724 				  &pctx))) ||
    725 		    ((retval == EXT2_ET_RO_UNSUPP_FEATURE) &&
    726 		    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_ROCOMPAT,
    727 				  &pctx))) ||
    728 		    ((retval == EXT2_ET_JOURNAL_UNSUPP_VERSION) &&
    729 		    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_VERSION, &pctx))))
    730 			retval = e2fsck_journal_fix_corrupt_super(ctx, journal,
    731 								  &pctx);
    732 		e2fsck_journal_release(ctx, journal, 0, 1);
    733 		return retval;
    734 	}
    735 
    736 	/*
    737 	 * We want to make the flags consistent here.  We will not leave with
    738 	 * needs_recovery set but has_journal clear.  We can't get in a loop
    739 	 * with -y, -n, or -p, only if a user isn't making up their mind.
    740 	 */
    741 no_has_journal:
    742 	if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
    743 		recover = sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
    744 		pctx.str = "inode";
    745 		if (fix_problem(ctx, PR_0_JOURNAL_HAS_JOURNAL, &pctx)) {
    746 			if (recover &&
    747 			    !fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, &pctx))
    748 				goto no_has_journal;
    749 			/*
    750 			 * Need a full fsck if we are releasing a
    751 			 * journal stored on a reserved inode.
    752 			 */
    753 			force_fsck = recover ||
    754 				(sb->s_journal_inum < EXT2_FIRST_INODE(sb));
    755 			/* Clear all of the journal fields */
    756 			sb->s_journal_inum = 0;
    757 			sb->s_journal_dev = 0;
    758 			memset(sb->s_journal_uuid, 0,
    759 			       sizeof(sb->s_journal_uuid));
    760 			e2fsck_clear_recover(ctx, force_fsck);
    761 		} else if (!(ctx->options & E2F_OPT_READONLY)) {
    762 			sb->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL;
    763 			ctx->fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
    764 			ext2fs_mark_super_dirty(ctx->fs);
    765 		}
    766 	}
    767 
    768 	if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
    769 	    !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
    770 	    journal->j_superblock->s_start != 0) {
    771 		/* Print status information */
    772 		fix_problem(ctx, PR_0_JOURNAL_RECOVERY_CLEAR, &pctx);
    773 		if (ctx->superblock)
    774 			problem = PR_0_JOURNAL_RUN_DEFAULT;
    775 		else
    776 			problem = PR_0_JOURNAL_RUN;
    777 		if (fix_problem(ctx, problem, &pctx)) {
    778 			ctx->options |= E2F_OPT_FORCE;
    779 			sb->s_feature_incompat |=
    780 				EXT3_FEATURE_INCOMPAT_RECOVER;
    781 			ext2fs_mark_super_dirty(ctx->fs);
    782 		} else if (fix_problem(ctx,
    783 				       PR_0_JOURNAL_RESET_JOURNAL, &pctx)) {
    784 			reset = 1;
    785 			sb->s_state &= ~EXT2_VALID_FS;
    786 			ext2fs_mark_super_dirty(ctx->fs);
    787 		}
    788 		/*
    789 		 * If the user answers no to the above question, we
    790 		 * ignore the fact that journal apparently has data;
    791 		 * accidentally replaying over valid data would be far
    792 		 * worse than skipping a questionable recovery.
    793 		 *
    794 		 * XXX should we abort with a fatal error here?  What
    795 		 * will the ext3 kernel code do if a filesystem with
    796 		 * !NEEDS_RECOVERY but with a non-zero
    797 		 * journal->j_superblock->s_start is mounted?
    798 		 */
    799 	}
    800 
    801 	e2fsck_journal_release(ctx, journal, reset, 0);
    802 	return retval;
    803 }
    804 
    805 static errcode_t recover_ext3_journal(e2fsck_t ctx)
    806 {
    807 	struct problem_context	pctx;
    808 	journal_t *journal;
    809 	int retval;
    810 
    811 	clear_problem_context(&pctx);
    812 
    813 	journal_init_revoke_caches();
    814 	retval = e2fsck_get_journal(ctx, &journal);
    815 	if (retval)
    816 		return retval;
    817 
    818 	retval = e2fsck_journal_load(journal);
    819 	if (retval)
    820 		goto errout;
    821 
    822 	retval = journal_init_revoke(journal, 1024);
    823 	if (retval)
    824 		goto errout;
    825 
    826 	retval = -journal_recover(journal);
    827 	if (retval)
    828 		goto errout;
    829 
    830 	if (journal->j_failed_commit) {
    831 		pctx.ino = journal->j_failed_commit;
    832 		fix_problem(ctx, PR_0_JNL_TXN_CORRUPT, &pctx);
    833 		ctx->fs->super->s_state |= EXT2_ERROR_FS;
    834 		ext2fs_mark_super_dirty(ctx->fs);
    835 	}
    836 
    837 
    838 	if (journal->j_superblock->s_errno) {
    839 		ctx->fs->super->s_state |= EXT2_ERROR_FS;
    840 		ext2fs_mark_super_dirty(ctx->fs);
    841 		journal->j_superblock->s_errno = 0;
    842 		mark_buffer_dirty(journal->j_sb_buffer);
    843 	}
    844 
    845 errout:
    846 	journal_destroy_revoke(journal);
    847 	journal_destroy_revoke_caches();
    848 	e2fsck_journal_release(ctx, journal, 1, 0);
    849 	return retval;
    850 }
    851 
    852 int e2fsck_run_ext3_journal(e2fsck_t ctx)
    853 {
    854 	io_manager io_ptr = ctx->fs->io->manager;
    855 	int blocksize = ctx->fs->blocksize;
    856 	errcode_t	retval, recover_retval;
    857 	io_stats	stats = 0;
    858 	unsigned long long kbytes_written = 0;
    859 
    860 	printf(_("%s: recovering journal\n"), ctx->device_name);
    861 	if (ctx->options & E2F_OPT_READONLY) {
    862 		printf(_("%s: won't do journal recovery while read-only\n"),
    863 		       ctx->device_name);
    864 		return EXT2_ET_FILE_RO;
    865 	}
    866 
    867 	if (ctx->fs->flags & EXT2_FLAG_DIRTY)
    868 		ext2fs_flush(ctx->fs);	/* Force out any modifications */
    869 
    870 	recover_retval = recover_ext3_journal(ctx);
    871 
    872 	/*
    873 	 * Reload the filesystem context to get up-to-date data from disk
    874 	 * because journal recovery will change the filesystem under us.
    875 	 */
    876 	if (ctx->fs->super->s_kbytes_written &&
    877 	    ctx->fs->io->manager->get_stats)
    878 		ctx->fs->io->manager->get_stats(ctx->fs->io, &stats);
    879 	if (stats && stats->bytes_written)
    880 		kbytes_written = stats->bytes_written >> 10;
    881 	ext2fs_free(ctx->fs);
    882 	retval = ext2fs_open(ctx->filesystem_name, EXT2_FLAG_RW,
    883 			     ctx->superblock, blocksize, io_ptr,
    884 			     &ctx->fs);
    885 	if (retval) {
    886 		com_err(ctx->program_name, retval,
    887 			_("while trying to re-open %s"),
    888 			ctx->device_name);
    889 		fatal_error(ctx, 0);
    890 	}
    891 	ctx->fs->priv_data = ctx;
    892 	ctx->fs->now = ctx->now;
    893 	ctx->fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
    894 	ctx->fs->super->s_kbytes_written += kbytes_written;
    895 
    896 	/* Set the superblock flags */
    897 	e2fsck_clear_recover(ctx, recover_retval);
    898 	return recover_retval;
    899 }
    900 
    901 /*
    902  * This function will move the journal inode from a visible file in
    903  * the filesystem directory hierarchy to the reserved inode if necessary.
    904  */
    905 static const char * const journal_names[] = {
    906 	".journal", "journal", ".journal.dat", "journal.dat", 0 };
    907 
    908 void e2fsck_move_ext3_journal(e2fsck_t ctx)
    909 {
    910 	struct ext2_super_block *sb = ctx->fs->super;
    911 	struct problem_context	pctx;
    912 	struct ext2_inode 	inode;
    913 	ext2_filsys		fs = ctx->fs;
    914 	ext2_ino_t		ino;
    915 	errcode_t		retval;
    916 	const char * const *	cpp;
    917 	int			group, mount_flags;
    918 
    919 	clear_problem_context(&pctx);
    920 
    921 	/*
    922 	 * If the filesystem is opened read-only, or there is no
    923 	 * journal, then do nothing.
    924 	 */
    925 	if ((ctx->options & E2F_OPT_READONLY) ||
    926 	    (sb->s_journal_inum == 0) ||
    927 	    !(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL))
    928 		return;
    929 
    930 	/*
    931 	 * Read in the journal inode
    932 	 */
    933 	if (ext2fs_read_inode(fs, sb->s_journal_inum, &inode) != 0)
    934 		return;
    935 
    936 	/*
    937 	 * If it's necessary to backup the journal inode, do so.
    938 	 */
    939 	if ((sb->s_jnl_backup_type == 0) ||
    940 	    ((sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) &&
    941 	     memcmp(inode.i_block, sb->s_jnl_blocks, EXT2_N_BLOCKS*4))) {
    942 		if (fix_problem(ctx, PR_0_BACKUP_JNL, &pctx)) {
    943 			memcpy(sb->s_jnl_blocks, inode.i_block,
    944 			       EXT2_N_BLOCKS*4);
    945 			sb->s_jnl_blocks[16] = inode.i_size;
    946 			sb->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS;
    947 			ext2fs_mark_super_dirty(fs);
    948 			fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
    949 		}
    950 	}
    951 
    952 	/*
    953 	 * If the journal is already the hidden inode, then do nothing
    954 	 */
    955 	if (sb->s_journal_inum == EXT2_JOURNAL_INO)
    956 		return;
    957 
    958 	/*
    959 	 * The journal inode had better have only one link and not be readable.
    960 	 */
    961 	if (inode.i_links_count != 1)
    962 		return;
    963 
    964 	/*
    965 	 * If the filesystem is mounted, or we can't tell whether
    966 	 * or not it's mounted, do nothing.
    967 	 */
    968 	retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags);
    969 	if (retval || (mount_flags & EXT2_MF_MOUNTED))
    970 		return;
    971 
    972 	/*
    973 	 * If we can't find the name of the journal inode, then do
    974 	 * nothing.
    975 	 */
    976 	for (cpp = journal_names; *cpp; cpp++) {
    977 		retval = ext2fs_lookup(fs, EXT2_ROOT_INO, *cpp,
    978 				       strlen(*cpp), 0, &ino);
    979 		if ((retval == 0) && (ino == sb->s_journal_inum))
    980 			break;
    981 	}
    982 	if (*cpp == 0)
    983 		return;
    984 
    985 	/* We need the inode bitmap to be loaded */
    986 	retval = ext2fs_read_bitmaps(fs);
    987 	if (retval)
    988 		return;
    989 
    990 	pctx.str = *cpp;
    991 	if (!fix_problem(ctx, PR_0_MOVE_JOURNAL, &pctx))
    992 		return;
    993 
    994 	/*
    995 	 * OK, we've done all the checks, let's actually move the
    996 	 * journal inode.  Errors at this point mean we need to force
    997 	 * an ext2 filesystem check.
    998 	 */
    999 	if ((retval = ext2fs_unlink(fs, EXT2_ROOT_INO, *cpp, ino, 0)) != 0)
   1000 		goto err_out;
   1001 	if ((retval = ext2fs_write_inode(fs, EXT2_JOURNAL_INO, &inode)) != 0)
   1002 		goto err_out;
   1003 	sb->s_journal_inum = EXT2_JOURNAL_INO;
   1004 	ext2fs_mark_super_dirty(fs);
   1005 	fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
   1006 	inode.i_links_count = 0;
   1007 	inode.i_dtime = ctx->now;
   1008 	if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0)
   1009 		goto err_out;
   1010 
   1011 	group = ext2fs_group_of_ino(fs, ino);
   1012 	ext2fs_unmark_inode_bitmap(fs->inode_map, ino);
   1013 	ext2fs_mark_ib_dirty(fs);
   1014 	fs->group_desc[group].bg_free_inodes_count++;
   1015 	ext2fs_group_desc_csum_set(fs, group);
   1016 	fs->super->s_free_inodes_count++;
   1017 	return;
   1018 
   1019 err_out:
   1020 	pctx.errcode = retval;
   1021 	fix_problem(ctx, PR_0_ERR_MOVE_JOURNAL, &pctx);
   1022 	fs->super->s_state &= ~EXT2_VALID_FS;
   1023 	ext2fs_mark_super_dirty(fs);
   1024 	return;
   1025 }
   1026 
   1027 /*
   1028  * This function makes sure the superblock hint for the external
   1029  * journal is correct.
   1030  */
   1031 int e2fsck_fix_ext3_journal_hint(e2fsck_t ctx)
   1032 {
   1033 	struct ext2_super_block *sb = ctx->fs->super;
   1034 	struct problem_context pctx;
   1035 	char uuid[37], *journal_name;
   1036 	struct stat st;
   1037 
   1038 	if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) ||
   1039 	    uuid_is_null(sb->s_journal_uuid))
   1040  		return 0;
   1041 
   1042 	uuid_unparse(sb->s_journal_uuid, uuid);
   1043 	journal_name = blkid_get_devname(ctx->blkid, "UUID", uuid);
   1044 	if (!journal_name)
   1045 		return 0;
   1046 
   1047 	if (stat(journal_name, &st) < 0)
   1048 		return 0;
   1049 
   1050 	if (st.st_rdev != sb->s_journal_dev) {
   1051 		clear_problem_context(&pctx);
   1052 		pctx.num = st.st_rdev;
   1053 		if (fix_problem(ctx, PR_0_EXTERNAL_JOURNAL_HINT, &pctx)) {
   1054 			sb->s_journal_dev = st.st_rdev;
   1055 			ext2fs_mark_super_dirty(ctx->fs);
   1056 		}
   1057 	}
   1058 
   1059 	free(journal_name);
   1060 	return 0;
   1061 }
   1062