Skip to contentSkip to conversation

lib: deduplicate buffer_head/kernel emulation

PATCH New Andreas Dilger 1 participant 3 messages Sep 19, 2023

lore
Share & tools
lore
#0 lore raw

PATCH v2 5/7 lib: deduplicate buffer_head/kernel emulation

From: Alexey Lyashkov <[email protected]>

Move buffer_head and device code into libsupport to allow it to be shared between debugfs and e2fsck.

---
 debugfs/journal.c | 147 ----------------------------------------------
 e2fsck/journal.c  | 143 --------------------------------------------
 2 files changed, 290 deletions(-)
debugfs/journal.c +0 -147
index 8c84be25..6e8dec35 100644
@@ -26,8 +26,6 @@
 #include "uuid/uuid.h"
 #include "journal.h"
 
-static int bh_count = 0;
-
 #if EXT2_FLAT_INCLUDES
 #include "blkid.h"
 #else
@@ -47,151 +45,6 @@ static int bh_count = 0;
  * to use the recovery.c file virtually unchanged from the kernel, so we
  * don't have to do much to keep kernel and user recovery in sync.
  */
-int jbd2_journal_bmap(journal_t *journal, unsigned long block,
-		      unsigned long long *phys)
-{
-#ifdef USE_INODE_IO
-	*phys = block;
-	return 0;
-#else
-	struct inode	*inode = journal->j_inode;
-	errcode_t	retval;
-	blk64_t		pblk;
-
-	if (!inode) {
-		*phys = block;
-		return 0;
-	}
-
-	retval = ext2fs_bmap2(inode->i_fs, inode->i_ino,
-			      &inode->i_ext2, NULL, 0, (blk64_t) block,
-			      0, &pblk);
-	*phys = pblk;
-	return (int) retval;
-#endif
-}
-
-struct buffer_head *getblk(kdev_t kdev, unsigned long long blocknr,
-			   int blocksize)
-{
-	struct buffer_head *bh;
-	int bufsize = sizeof(*bh) + kdev->k_fs->blocksize -
-		sizeof(bh->b_data);
-	errcode_t retval;
-
-	retval = ext2fs_get_memzero(bufsize, &bh);
-	if (retval)
-		return NULL;
-
-	if (journal_enable_debug >= 3)
-		bh_count++;
-	jfs_debug(4, "getblk for block %llu (%d bytes)(total %d)\n",
-		  blocknr, blocksize, bh_count);
-
-	bh->b_fs = kdev->k_fs;
-	if (kdev->k_dev == K_DEV_FS)
-		bh->b_io = kdev->k_fs->io;
-	else
-		bh->b_io = kdev->k_fs->journal_io;
-	bh->b_size = blocksize;
-	bh->b_blocknr = blocknr;
-
-	return bh;
-}
-
-int sync_blockdev(kdev_t kdev)
-{
-	io_channel	io;
-
-	if (kdev->k_dev == K_DEV_FS)
-		io = kdev->k_fs->io;
-	else
-		io = kdev->k_fs->journal_io;
-
-	return io_channel_flush(io) ? EIO : 0;
-}
-
-void ll_rw_block(int rw, int op_flags EXT2FS_ATTR((unused)), int nr,
-		 struct buffer_head *bhp[])
-{
-	errcode_t retval;
-	struct buffer_head *bh;
-
-	for (; nr > 0; --nr) {
-		bh = *bhp++;
-		if (rw == REQ_OP_READ && !bh->b_uptodate) {
-			jfs_debug(3, "reading block %llu/%p\n",
-				  bh->b_blocknr, (void *) bh);
-			retval = io_channel_read_blk64(bh->b_io,
-						     bh->b_blocknr,
-						     1, bh->b_data);
-			if (retval) {
-				com_err(bh->b_fs->device_name, retval,
-					"while reading block %llu\n",
-					bh->b_blocknr);
-				bh->b_err = (int) retval;
-				continue;
-			}
-			bh->b_uptodate = 1;
-		} else if (rw == REQ_OP_WRITE && bh->b_dirty) {
-			jfs_debug(3, "writing block %llu/%p\n",
-				  bh->b_blocknr,
-				  (void *) bh);
-			retval = io_channel_write_blk64(bh->b_io,
-						      bh->b_blocknr,
-						      1, bh->b_data);
-			if (retval) {
-				com_err(bh->b_fs->device_name, retval,
-					"while writing block %llu\n",
-					bh->b_blocknr);
-				bh->b_err = (int) retval;
-				continue;
-			}
-			bh->b_dirty = 0;
-			bh->b_uptodate = 1;
-		} else {
-			jfs_debug(3, "no-op %s for block %llu\n",
-				  rw == REQ_OP_READ ? "read" : "write",
-				  bh->b_blocknr);
-		}
-	}
-}
-
-void mark_buffer_dirty(struct buffer_head *bh)
-{
-	bh->b_dirty = 1;
-}
-
-static void mark_buffer_clean(struct buffer_head *bh)
-{
-	bh->b_dirty = 0;
-}
-
-void brelse(struct buffer_head *bh)
-{
-	if (bh->b_dirty)
-		ll_rw_block(REQ_OP_WRITE, 0, 1, &bh);
-	jfs_debug(3, "freeing block %llu/%p (total %d)\n",
-		  bh->b_blocknr, (void *) bh, --bh_count);
-	ext2fs_free_mem(&bh);
-}
-
-int buffer_uptodate(struct buffer_head *bh)
-{
-	return bh->b_uptodate;
-}
-
-void mark_buffer_uptodate(struct buffer_head *bh, int val)
-{
-	bh->b_uptodate = val;
-}
-
-void wait_on_buffer(struct buffer_head *bh)
-{
-	if (!bh->b_uptodate)
-		ll_rw_block(REQ_OP_READ, 0, 1, &bh);
-}
-
 
 static void ext2fs_clear_recover(ext2_filsys fs, int error)
 {
e2fsck/journal.c +0 -143

155 lines not on this page · raw message

Signature · 1 line
2.25.1
#1 lore raw

PATCH 6/7 misc: deduplicate log2/log10 functions

Remove duplicate log2() and log10() functions and replace them with a single pair of functions ext2fs_log2() and ext2fs_log10().

Change-Id Ifc86efe7e5f0243eb914c6d24319cc7dee3ebbe5
---
 debugfs/debugfs.c   | 16 ++--------------
 debugfs/filefrag.c  | 18 +++---------------
 lib/ext2fs/ext2fs.h | 24 ++++++++++++++++++++++++
 lib/ext2fs/extent.c | 17 +++--------------
 misc/e2freefrag.c   | 20 ++++----------------
 misc/e4crypt.c      | 14 +-------------
 misc/filefrag.c     | 32 ++++----------------------------
 misc/mk_hugefiles.c |  2 +-
 misc/mke2fs.c       | 35 +++++++----------------------------
 misc/mke2fs.h       |  1 -
 10 files changed, 49 insertions(+), 130 deletions(-)
debugfs/debugfs.c +2 -14
index 742bf794..66428f7d 100644
@@ -652,18 +652,6 @@ static void dump_blocks(FILE *f, const char *prefix, ext2_ino_t inode)
 	fprintf(f,"\n");
 }
 
-static int int_log10(unsigned long long arg)
-{
-	int     l = 0;
-
-	arg = arg / 10;
-	while (arg) {
-		l++;
-		arg = arg / 10;
-	}
-	return l;
-}
-
 #define DUMP_LEAF_EXTENTS	0x01
 #define DUMP_NODE_EXTENTS	0x02
 #define DUMP_EXTENT_TABLE	0x04
@@ -1065,11 +1053,11 @@ void do_dump_extents(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 		return;
 	}
 
-	logical_width = int_log10((EXT2_I_SIZE(&inode)+current_fs->blocksize-1)/
+	logical_width = ext2fs_log10((EXT2_I_SIZE(&inode)+current_fs->blocksize-1)/
 				  current_fs->blocksize) + 1;
 	if (logical_width < 5)
 		logical_width = 5;
-	physical_width = int_log10(ext2fs_blocks_count(current_fs->super)) + 1;
+	physical_width = ext2fs_log10(ext2fs_blocks_count(current_fs->super)) + 1;
 	if (physical_width < 5)
 		physical_width = 5;
 
debugfs/filefrag.c +3 -15
index 31c1440c..080c2c37 100644
@@ -54,18 +54,6 @@ struct filefrag_struct {
 	struct dir_list *dir_list, *dir_last;
 };
 
-static int int_log10(unsigned long long arg)
-{
-	int     l = 0;
-
-	arg = arg / 10;
-	while (arg) {
-		l++;
-		arg = arg / 10;
-	}
-	return l;
-}
-
 static void print_header(struct filefrag_struct *fs)
 {
 	if (fs->options & VERBOSE_OPT) {
@@ -135,8 +123,8 @@ static void filefrag(ext2_ino_t ino, struct ext2_inode *inode,
 	errcode_t	retval;
 	int		blocksize = current_fs->blocksize;
 
-	fs->logical_width = int_log10((EXT2_I_SIZE(inode) + blocksize - 1) /
-				      blocksize) + 1;
+	fs->logical_width = ext2fs_log10((EXT2_I_SIZE(inode) + blocksize - 1) /
+					 blocksize) + 1;
 	if (fs->logical_width < 7)
 		fs->logical_width = 7;
 	fs->ext = 0;
@@ -313,7 +301,7 @@ void do_filefrag(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)),
 		return;
 
 	fs.f = open_pager();
-	fs.physical_width = int_log10(ext2fs_blocks_count(current_fs->super));
+	fs.physical_width = ext2fs_log10(ext2fs_blocks_count(current_fs->super));
 	fs.physical_width++;
 	if (fs.physical_width < 8)
 		fs.physical_width = 8;
lib/ext2fs/ext2fs.h +24 -0
index b5477c10..8e02d6b6 100644
@@ -2119,6 +2119,30 @@ _INLINE_ int ext2fs_htree_intnode_maxrecs(ext2_filsys fs, int blocks)
 						sizeof(struct ext2_dx_entry));
 }
 
+_INLINE_ int ext2fs_log2(unsigned long long arg)
+{
+	int l = 0;
+
+	arg >>= 1;
+	while (arg) {
+		l++;
+		arg >>= 1;
+	}
+	return l;
+}
+
+_INLINE_ int ext2fs_log10(unsigned long long arg)
+{
+	int l = 0;
+
+	arg /= 10;
+	while (arg) {
+		l++;
+		arg /= 10;
+	}
+	return l;
+}
+
 /*
  * This is an efficient, overflow safe way of calculating ceil((1.0 * a) / b)
  */
lib/ext2fs/extent.c +3 -14
index 82e75ccd..f747a561 100644
@@ -1720,18 +1720,6 @@ errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle,
 	return 0;
 }
 
-static int ul_log2(unsigned long arg)
-{
-	int	l = 0;
-
-	arg >>= 1;
-	while (arg) {
-		l++;
-		arg >>= 1;
-	}
-	return l;
-}
-
 size_t ext2fs_max_extent_depth(ext2_extent_handle_t handle)
 {
 	size_t iblock_sz = sizeof(((struct ext2_inode *)NULL)->i_block);
@@ -1746,8 +1734,9 @@ size_t ext2fs_max_extent_depth(ext2_extent_handle_t handle)
 	if (last_blocksize && last_blocksize == handle->fs->blocksize)
 		return last_result;
 
-	last_result = 1 + ((ul_log2(EXT_MAX_EXTENT_LBLK) - ul_log2(iblock_extents)) /
-		    ul_log2(extents_per_block));
+	last_result = 1 + ((ext2fs_log2(EXT_MAX_EXTENT_LBLK) -
+			    ext2fs_log2(iblock_extents)) /
+			   ext2fs_log2(extents_per_block));
 	last_blocksize = handle->fs->blocksize;
 	return last_result;
 }
misc/e2freefrag.c +4 -16
index 04f155b6..903789f0 100644
@@ -57,28 +57,16 @@ static void usage(const char *prog)
 #endif
 }
 
-static int ul_log2(unsigned long arg)
-{
-        int     l = 0;
-
-        arg >>= 1;
-        while (arg) {
-                l++;
-                arg >>= 1;
-        }
-        return l;
-}
-
 static void init_chunk_info(ext2_filsys fs, struct chunk_info *info)
 {
 	int i;
 
-	info->blocksize_bits = ul_log2((unsigned long)fs->blocksize);
+	info->blocksize_bits = ext2fs_log2(fs->blocksize);
 	if (info->chunkbytes) {
-		info->chunkbits = ul_log2(info->chunkbytes);
+		info->chunkbits = ext2fs_log2(info->chunkbytes);
 		info->blks_in_chunk = info->chunkbytes >> info->blocksize_bits;
 	} else {
-		info->chunkbits = ul_log2(DEFAULT_CHUNKSIZE);
+		info->chunkbits = ext2fs_log2(DEFAULT_CHUNKSIZE);
 		info->blks_in_chunk = DEFAULT_CHUNKSIZE >> info->blocksize_bits;
 	}
 
@@ -97,7 +85,7 @@ static void update_chunk_stats(struct chunk_info *info,
 {
 	unsigned long idx;
 
-	idx = ul_log2(chunk_size) + 1;
+	idx = ext2fs_log2(chunk_size) + 1;
 	if (idx >= MAX_HIST)
 		idx = MAX_HIST-1;
 	info->histogram.fc_chunks[idx]++;
misc/e4crypt.c +1 -13
index 67d25d88..6f23927d 100644
@@ -114,18 +114,6 @@ static const size_t hexchars_size = 16;
 #define EXT4_IOC_SET_ENCRYPTION_POLICY      _IOR('f', 19, struct ext4_encryption_policy)
 #define EXT4_IOC_GET_ENCRYPTION_POLICY      _IOW('f', 21, struct ext4_encryption_policy)
 
-static int int_log2(int arg)
-{
-	int     l = 0;
-
-	arg >>= 1;
-	while (arg) {
-		l++;
-		arg >>= 1;
-	}
-	return l;
-}
-
 static void validate_paths(int argc, char *argv[], int path_start_index)
 {
 	int x;
@@ -386,7 +374,7 @@ static void set_policy(struct salt *set_salt, int pad,
 			EXT4_ENCRYPTION_MODE_AES_256_XTS;
 		policy.filenames_encryption_mode =
 			EXT4_ENCRYPTION_MODE_AES_256_CTS;
-		policy.flags = int_log2(pad >> 2);
+		policy.flags = ext2fs_log2(pad >> 2);
 		memcpy(policy.master_key_descriptor, salt->key_desc,
 		       EXT4_KEY_DESCRIPTOR_SIZE);
 		rc = ioctl(fd, EXT4_IOC_SET_ENCRYPTION_POLICY, &policy);
misc/filefrag.c +4 -28
index eaaa90a8..13a533e5 100644
@@ -76,30 +76,6 @@ const char *hex_fmt = "%4d: %*llx..%*llx: %*llx..%*llx: %6llx: %s\n";
 #define	EXT4_EXTENTS_FL			0x00080000 /* Inode uses extents */
 #define	EXT3_IOC_GETFLAGS		_IOR('f', 1, long)
 
-static int ulong_log2(unsigned long arg)
-{
-	int     l = 0;
-
-	arg >>= 1;
-	while (arg) {
-		l++;
-		arg >>= 1;
-	}
-	return l;
-}
-
-static int ulong_log10(unsigned long long arg)
-{
-	int     l = 0;
-
-	arg = arg / 10;
-	while (arg) {
-		l++;
-		arg = arg / 10;
-	}
-	return l;
-}
-
 static unsigned int div_ceil(unsigned int a, unsigned int b)
 {
 	if (!a)
@@ -483,20 +459,20 @@ static int frag_report(const char *filename)
 	}
 	last_device = st.st_dev;
 
-	width = ulong_log10(fsinfo.f_blocks);
+	width = ext2fs_log10(fsinfo.f_blocks);
 	if (width > physical_width)
 		physical_width = width;
 
 	numblocks = (st.st_size + blksize - 1) / blksize;
 	if (blocksize != 0)
-		blk_shift = ulong_log2(blocksize);
+		blk_shift = ext2fs_log2(blocksize);
 	else
-		blk_shift = ulong_log2(blksize);
+		blk_shift = ext2fs_log2(blksize);
 
 	if (use_extent_cache)
 		width = 10;
 	else
-		width = ulong_log10(numblocks);
+		width = ext2fs_log10(numblocks);
 	if (width > logical_width)
 		logical_width = width;
 	if (verbose) {
misc/mk_hugefiles.c +1 -1
index 3caaf1b6..17788bcd 100644
@@ -417,7 +417,7 @@ errcode_t mk_hugefiles(ext2_filsys fs, const char *device_name)
 	fn_prefix = get_string_from_profile(fs_types, "hugefiles_name",
 					    "hugefile");
 	idx_digits = get_int_from_profile(fs_types, "hugefiles_digits", 5);
-	d = int_log10(num_files) + 1;
+	d = ext2fs_log10(num_files) + 1;
 	if (idx_digits > d)
 		d = idx_digits;
 	dsize = strlen(fn_prefix) + d + 16;
misc/mke2fs.c +7 -28
index ba5f179a..c6e26e70 100644
@@ -144,27 +144,6 @@ static void usage(void)
 	exit(1);
 }
 
-static int int_log2(unsigned long long arg)
-{
-	int	l = 0;
-
-	arg >>= 1;
-	while (arg) {
-		l++;
-		arg >>= 1;
-	}
-	return l;
-}
-
-int int_log10(unsigned long long arg)
-{
-	int	l;
-
-	for (l=0; arg ; l++)
-		arg = arg / 10;
-	return l;
-}
-
 #ifdef __linux__
 static int parse_version_number(const char *s)
 {
@@ -743,7 +722,7 @@ skip_details:
 			continue;
 		if (i != 1)
 			printf(", ");
-		need = int_log10(group_block) + 2;
+		need = ext2fs_log10(group_block) + 2;
 		if (need > col_left) {
 			printf("\n\t");
 			col_left = 72;
@@ -1669,8 +1648,8 @@ profile_error:
 					blocksize);
 			if (blocksize > 0)
 				fs_param.s_log_block_size =
-					int_log2(blocksize >>
-						 EXT2_MIN_BLOCK_LOG_SIZE);
+					ext2fs_log2(blocksize >>
+						    EXT2_MIN_BLOCK_LOG_SIZE);
 			break;
 		case 'c':	/* Check for bad blocks */
 			cflag++;
@@ -1949,7 +1928,7 @@ profile_error:
 		blocksize = jfs->blocksize;
 		printf(_("Using journal device's blocksize: %d\n"), blocksize);
 		fs_param.s_log_block_size =
-			int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
+			ext2fs_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
 		ext2fs_close_free(&jfs);
 	}
 
@@ -2188,7 +2167,7 @@ profile_error:
 	}
 
 	fs_param.s_log_block_size =
-		int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
+		ext2fs_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
 
 	/*
 	 * We now need to do a sanity check of fs_blocks_count for
@@ -2312,7 +2291,7 @@ profile_error:
 							    "cluster_size",
 							    blocksize*16);
 		fs_param.s_log_cluster_size =
-			int_log2(cluster_size >> EXT2_MIN_CLUSTER_LOG_SIZE);
+			ext2fs_log2(cluster_size >> EXT2_MIN_CLUSTER_LOG_SIZE);
 		if (fs_param.s_log_cluster_size &&
 		    fs_param.s_log_cluster_size < fs_param.s_log_block_size) {
 			com_err(program_name, 0, "%s",
@@ -2580,7 +2559,7 @@ profile_error:
 				  "flex_bg size may not be specified"));
 			exit(1);
 		}
-		fs_param.s_log_groups_per_flex = int_log2(flex_bg_size);
+		fs_param.s_log_groups_per_flex = ext2fs_log2(flex_bg_size);
 	}
 
 	if (inode_size && fs_param.s_rev_level >= EXT2_DYNAMIC_REV) {
misc/mke2fs.h +0 -1
index ce72cb3f..c718fceb 100644
@@ -21,7 +21,6 @@ extern char *get_string_from_profile(char **types, const char *opt,
 				     const char *def_val);
 extern int get_int_from_profile(char **types, const char *opt, int def_val);
 extern int get_bool_from_profile(char **types, const char *opt, int def_val);
-extern int int_log10(unsigned long long arg);
 
 /* mk_hugefiles.c */
 extern errcode_t mk_hugefiles(ext2_filsys fs, const char *device_name);
Signature · 1 line
2.25.1
#2 lore raw

PATCH 7/7 lib: make journal.c more consistent

In reply to Andreas Dilger

Make the journal.c files more consistent between e2fsck and debugfs. Declare a local "ext2_filsys fs" variable in many functions so that the common use of "ctx->fs" can be removed.

The file cannot be exactly the same, but removing a number of minor differences makes it more clear where real differences are when comparing the files with vimdiff, and will simplify resolution of remaining differences later.

Change-Id I27fd60e955967665746a6cca60f60e76f23ebbe5
---
 debugfs/journal.c |  65 ++++++++----
 e2fsck/journal.c  | 259 ++++++++++++++++++++++++++--------------------
 2 files changed, 186 insertions(+), 138 deletions(-)
debugfs/journal.c +42 -23
index 6e8dec35..bb95e9d1 100644
@@ -23,8 +23,6 @@
 #endif
 
 #define E2FSCK_INCLUDE_INLINE_FUNCS
-#include "uuid/uuid.h"
-#include "journal.h"
 
 #if EXT2_FLAT_INCLUDES
 #include "blkid.h"
@@ -32,6 +30,9 @@
 #include "blkid/blkid.h"
 #endif
 
+#include "uuid/uuid.h"
+#include "journal.h"
+
 /*
  * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths.
  * This creates a larger static binary, and a smaller binary using
@@ -107,12 +108,14 @@ static errcode_t ext2fs_get_journal(ext2_filsys fs, journal_t **ret_journal)
 	int			tried_backup_jnl = 0;
 
 	retval = ext2fs_get_memzero(sizeof(journal_t), &journal);
-	if (retval)
+	if (retval) {
 		return retval;
+	}
 
 	retval = ext2fs_get_memzero(2 * sizeof(struct kdev_s), &dev_fs);
-	if (retval)
+	if (retval) {
 		goto errout;
+	}
 	dev_journal = dev_fs+1;
 
 	dev_fs->k_fs = dev_journal->k_fs = fs;
@@ -125,13 +128,21 @@ static errcode_t ext2fs_get_journal(ext2_filsys fs, journal_t **ret_journal)
 	journal->j_blocksize = fs->blocksize;
 
 	if (uuid_is_null(sb->s_journal_uuid)) {
-		if (!sb->s_journal_inum) {
+		/*
+		 * The full set of superblock sanity checks haven't
+		 * been performed yet, so we need to do some basic
+		 * checks here to avoid potential array overruns.
+		 */
+		if (!sb->s_journal_inum ||
+		    (sb->s_journal_inum >
+		     (fs->group_desc_count * sb->s_inodes_per_group))) {
 			retval = EXT2_ET_BAD_INODE_NUM;
 			goto errout;
 		}
 		retval = ext2fs_get_memzero(sizeof(*j_inode), &j_inode);
-		if (retval)
+		if (retval) {
 			goto errout;
+		}
 
 		j_inode->i_fs = fs;
 		j_inode->i_ino = sb->s_journal_inum;
@@ -153,7 +164,8 @@ try_backup_journal:
 			tried_backup_jnl++;
 		}
 		if (!j_inode->i_ext2.i_links_count ||
-		    !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
+		    !LINUX_S_ISREG(j_inode->i_ext2.i_mode) ||
+		    (j_inode->i_ext2.i_flags & EXT4_ENCRYPT_FL)) {
 			retval = EXT2_ET_NO_JOURNAL;
 			goto try_backup_journal;
 		}
@@ -229,7 +241,8 @@ try_backup_journal:
 	if (ext_journal)
 #endif
 	{
-		retval = io_ptr->open(journal_name, fs->flags & EXT2_FLAG_RW,
+		int flags = fs->flags & EXT2_FLAG_RW;
+		retval = io_ptr->open(journal_name, flags,
 				      &fs->journal_io);
 	}
 	if (retval)
@@ -294,7 +307,7 @@ try_backup_journal:
 
 		maxlen = ext2fs_blocks_count(&jsuper);
 		journal->j_total_len = (maxlen < 1ULL << 32) ? maxlen :
-				    (1ULL << 32) - 1;
+				(1ULL << 32) - 1;
 		start++;
 	}
 
@@ -358,8 +371,9 @@ static errcode_t ext2fs_journal_load(journal_t *journal)
 	struct buffer_head *jbh = journal->j_sb_buffer;
 
 	ll_rw_block(REQ_OP_READ, 0, 1, &jbh);
-	if (jbh->b_err)
+	if (jbh->b_err) {
 		return jbh->b_err;
+	}
 
 	jsb = journal->j_superblock;
 	/* If we don't even have JBD2_MAGIC, we probably have a wrong inode */
@@ -381,8 +395,9 @@ static errcode_t ext2fs_journal_load(journal_t *journal)
 		if (ntohl(jsb->s_nr_users) > 1 &&
 		    uuid_is_null(fs->super->s_journal_uuid))
 			clear_v2_journal_fields(journal);
-		if (ntohl(jsb->s_nr_users) > 1)
+		if (ntohl(jsb->s_nr_users) > 1) {
 			return EXT2_ET_JOURNAL_UNSUPP_VERSION;
+		}
 		break;
 
 	/*
@@ -426,13 +441,15 @@ static errcode_t ext2fs_journal_load(journal_t *journal)
 	/* We have now checked whether we know enough about the journal
 	 * format to be able to proceed safely, so any other checks that
 	 * fail we should attempt to recover from. */
-	if (jsb->s_blocksize != htonl(journal->j_blocksize))
+	if (jsb->s_blocksize != htonl(journal->j_blocksize)) {
 		return EXT2_ET_CORRUPT_JOURNAL_SB;
+	}
 
 	if (ntohl(jsb->s_maxlen) < journal->j_total_len)
 		journal->j_total_len = ntohl(jsb->s_maxlen);
-	else if (ntohl(jsb->s_maxlen) > journal->j_total_len)
+	else if (ntohl(jsb->s_maxlen) > journal->j_total_len) {
 		return EXT2_ET_CORRUPT_JOURNAL_SB;
+	}
 
 	journal->j_tail_sequence = ntohl(jsb->s_sequence);
 	journal->j_transaction_sequence = journal->j_tail_sequence;
@@ -461,12 +478,14 @@ static errcode_t ext2fs_check_ext3_journal(ext2_filsys fs)
 		return 0;
 
 	retval = ext2fs_get_journal(fs, &journal);
-	if (retval)
+	if (retval) {
 		return retval;
+	}
 
 	retval = ext2fs_journal_load(journal);
-	if (retval)
+	if (retval) {
 		goto err;
+	}
 
 	/*
 	 * We want to make the flags consistent here.  We will not leave with
@@ -552,15 +571,17 @@ errcode_t ext2fs_run_ext3_journal(ext2_filsys *fsp)
 {
 	ext2_filsys fs = *fsp;
 	io_manager io_ptr = fs->io->manager;
+	int blocksize = fs->blocksize;
 	errcode_t	retval, recover_retval;
 	io_stats	stats = 0;
 	unsigned long long kbytes_written = 0;
-	char *fsname;
-	int fsflags;
-	int fsblocksize;
+	char *fsname = fs->device_name;
+	int fsflags = fs->flags;
+	int superblock = 0;
 
-	if (!(fs->flags & EXT2_FLAG_RW))
+	if (!(fs->flags & EXT2_FLAG_RW)) {
 		return EXT2_ET_FILE_RO;
+	}
 
 	if (fs->flags & EXT2_FLAG_DIRTY)
 		ext2fs_flush(fs);	/* Force out any modifications */
@@ -578,13 +599,11 @@ errcode_t ext2fs_run_ext3_journal(ext2_filsys *fsp)
 		kbytes_written = stats->bytes_written >> 10;
 
 	ext2fs_mmp_stop(fs);
-	fsname = fs->device_name;
 	fs->device_name = NULL;
-	fsflags = fs->flags;
-	fsblocksize = fs->blocksize;
 	ext2fs_free(fs);
 	*fsp = NULL;
-	retval = ext2fs_open(fsname, fsflags, 0, fsblocksize, io_ptr, fsp);
+	retval = ext2fs_open(fsname, fsflags, superblock, blocksize, io_ptr,
+			     fsp);
 	ext2fs_free_mem(&fsname);
 	if (retval)
 		return retval;
e2fsck/journal.c +144 -115

666 lines not on this page · raw message

Signature · 1 line
2.25.1