From: Theodore Ts'o <tytso@mit.edu>
Date: Mon, 20 May 2013 01:45:16 +0000 (-0400)
Subject: Merge branch 'maint' into next
X-Git-Tag: v1.43-WIP-2015-05-18~396
X-Git-Url: https://git.whamcloud.com/gitweb?a=commitdiff_plain;h=581ecb6d8808a083add919f066f44cf7e70f9c4a;p=tools%2Fe2fsprogs.git

Merge branch 'maint' into next

Conflicts:
	e2fsck/pass1b.c
	e2fsck/rehash.c
	lib/ext2fs/crc32c.c
	lib/ext2fs/gen_bitmap64.c
	misc/tune2fs.c
---

581ecb6d8808a083add919f066f44cf7e70f9c4a
diff --cc e2fsck/pass1b.c
index 05cbd10,cd6c883..16a81b9
--- a/e2fsck/pass1b.c
+++ b/e2fsck/pass1b.c
@@@ -643,19 -643,20 +643,20 @@@ static void delete_file(e2fsck_t ctx, e
  		fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
  	if (ctx->inode_bad_map)
  		ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
- 	ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
- 	quota_data_sub(ctx->qctx, &inode, ino, pb.dup_blocks * fs->blocksize);
- 	quota_data_inodes(ctx->qctx, &inode, ino, -1);
+ 	ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(dp->inode.i_mode));
+ 	quota_data_sub(ctx->qctx, &dp->inode, ino,
+ 		       pb.dup_blocks * fs->blocksize);
+ 	quota_data_inodes(ctx->qctx, &dp->inode, ino, -1);
  
  	/* Inode may have changed by block_iterate, so reread it */
- 	e2fsck_read_inode(ctx, ino, &inode, "delete_file");
- 	e2fsck_clear_inode(ctx, ino, &inode, 0, "delete_file");
- 	if (ext2fs_file_acl_block(fs, &inode) &&
+ 	e2fsck_read_inode(ctx, ino, &dp->inode, "delete_file");
+ 	e2fsck_clear_inode(ctx, ino, &dp->inode, 0, "delete_file");
+ 	if (ext2fs_file_acl_block(fs, &dp->inode) &&
  	    (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
  		count = 1;
 -		pctx.errcode = ext2fs_adjust_ea_refcount2(fs,
 +		pctx.errcode = ext2fs_adjust_ea_refcount3(fs,
- 					ext2fs_file_acl_block(fs, &inode),
+ 					ext2fs_file_acl_block(fs, &dp->inode),
 -						   block_buf, -1, &count);
 +					block_buf, -1, &count, ino);
  		if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
  			pctx.errcode = 0;
  			count = 1;
diff --cc e2fsck/rehash.c
index 9cfb516,3d509ad..df3afab
--- a/e2fsck/rehash.c
+++ b/e2fsck/rehash.c
@@@ -78,10 -59,9 +78,10 @@@ struct fill_dir_struct 
  	e2fsck_t ctx;
  	struct hash_entry *harray;
  	int max_array, num_array;
- 	int dir_size;
+ 	unsigned int dir_size;
  	int compress;
  	ino_t parent;
 +	ext2_ino_t dir;
  };
  
  struct hash_entry {
@@@ -428,12 -404,9 +428,11 @@@ static errcode_t copy_dir_entries(e2fsc
  	char			*block_start;
  	struct hash_entry 	*ent;
  	struct ext2_dir_entry	*dirent;
- 	unsigned int		rec_len, prev_rec_len;
- 	int			i, left;
+ 	unsigned int		rec_len, prev_rec_len, left, slack, offset;
+ 	int			i;
  	ext2_dirhash_t		prev_hash;
- 	int			offset, slack;
 +	int			csum_size = 0;
 +	struct			ext2_dir_entry_tail *t;
  
  	if (ctx->htree_slack_percentage == 255) {
  		profile_get_uint(ctx->profile, "options",
diff --cc lib/ext2fs/gen_bitmap64.c
index 44ac499,d02488c..2880afa
--- a/lib/ext2fs/gen_bitmap64.c
+++ b/lib/ext2fs/gen_bitmap64.c
@@@ -173,11 -173,11 +173,11 @@@ errcode_t ext2fs_alloc_generic_bmap(ext
  	return 0;
  }
  
 -#ifdef BMAP_STATS
 +#ifdef ENABLE_BMAP_STATS
- void ext2fs_print_bmap_statistics(ext2fs_generic_bitmap bitmap)
+ static void ext2fs_print_bmap_statistics(ext2fs_generic_bitmap bitmap)
  {
  	struct ext2_bmap_statistics *stats = &bitmap->stats;
 -#ifdef BMAP_STATS_OPS
 +#ifdef ENABLE_BMAP_STATS_OPS
  	float mark_seq_perc = 0.0, test_seq_perc = 0.0;
  	float mark_back_perc = 0.0, test_back_perc = 0.0;
  #endif
diff --cc misc/tune2fs.c
index 332aafd,b088f17..4f8cedc
--- a/misc/tune2fs.c
+++ b/misc/tune2fs.c
@@@ -394,374 -367,6 +394,374 @@@ static void request_fsck_afterwards(ext
  		printf(_("(and reboot afterwards!)\n"));
  }
  
 +/* Rewrite extents */
 +static errcode_t rewrite_extents(ext2_filsys fs, ext2_ino_t ino,
 +				 struct ext2_inode *inode)
 +{
 +	ext2_extent_handle_t	handle;
 +	struct ext2fs_extent	extent;
 +	int			op = EXT2_EXTENT_ROOT;
 +	errcode_t		errcode;
 +
 +	if (!(inode->i_flags & EXT4_EXTENTS_FL))
 +		return 0;
 +
 +	errcode = ext2fs_extent_open(fs, ino, &handle);
 +	if (errcode)
 +		return errcode;
 +
 +	while (1) {
 +		errcode = ext2fs_extent_get(handle, op, &extent);
 +		if (errcode)
 +			break;
 +
 +		/* Root node is in the separately checksummed inode */
 +		if (op == EXT2_EXTENT_ROOT) {
 +			op = EXT2_EXTENT_NEXT;
 +			continue;
 +		}
 +		op = EXT2_EXTENT_NEXT;
 +
 +		/* Only visit the first extent in each extent block */
 +		if (extent.e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)
 +			continue;
 +		errcode = ext2fs_extent_replace(handle, 0, &extent);
 +		if (errcode)
 +			break;
 +	}
 +
 +	/* Ok if we run off the end */
 +	if (errcode == EXT2_ET_EXTENT_NO_NEXT)
 +		errcode = 0;
 +	return errcode;
 +}
 +
 +/*
 + * Rewrite directory blocks with checksums
 + */
 +struct rewrite_dir_context {
 +	char *buf;
 +	errcode_t errcode;
 +	ext2_ino_t dir;
 +	int is_htree;
 +};
 +
 +static int rewrite_dir_block(ext2_filsys fs,
 +			     blk64_t	*blocknr,
 +			     e2_blkcnt_t blockcnt,
 +			     blk64_t	ref_block EXT2FS_ATTR((unused)),
 +			     int	ref_offset EXT2FS_ATTR((unused)),
 +			     void	*priv_data)
 +{
 +	struct ext2_dx_countlimit *dcl = NULL;
 +	struct rewrite_dir_context *ctx = priv_data;
 +	int dcl_offset, changed = 0;
 +
 +	ctx->errcode = ext2fs_read_dir_block4(fs, *blocknr, ctx->buf, 0,
 +					      ctx->dir);
 +	if (ctx->errcode)
 +		return BLOCK_ABORT;
 +
 +	/* if htree node... */
 +	if (ctx->is_htree)
 +		ext2fs_get_dx_countlimit(fs, (struct ext2_dir_entry *)ctx->buf,
 +					 &dcl, &dcl_offset);
 +	if (dcl) {
 +		if (!EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 +				EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
 +			/* Ensure limit is the max size */
 +			int max_entries = (fs->blocksize - dcl_offset) /
 +					  sizeof(struct ext2_dx_entry);
 +			if (ext2fs_le16_to_cpu(dcl->limit) != max_entries) {
 +				changed = 1;
 +				dcl->limit = ext2fs_cpu_to_le16(max_entries);
 +			}
 +		} else {
 +			/* If htree block is full then rebuild the dir */
 +			if (ext2fs_le16_to_cpu(dcl->count) ==
 +			    ext2fs_le16_to_cpu(dcl->limit)) {
 +				request_dir_fsck_afterwards(fs);
 +				return 0;
 +			}
 +			/*
 +			 * Ensure dcl->limit is small enough to leave room for
 +			 * the checksum tail.
 +			 */
 +			int max_entries = (fs->blocksize - (dcl_offset +
 +						sizeof(struct ext2_dx_tail))) /
 +					  sizeof(struct ext2_dx_entry);
 +			if (ext2fs_le16_to_cpu(dcl->limit) != max_entries)
 +				dcl->limit = ext2fs_cpu_to_le16(max_entries);
 +			/* Always rewrite checksum */
 +			changed = 1;
 +		}
 +	} else {
 +		unsigned int rec_len, name_size;
 +		char *top = ctx->buf + fs->blocksize;
 +		struct ext2_dir_entry *de = (struct ext2_dir_entry *)ctx->buf;
 +		struct ext2_dir_entry *last_de = NULL, *penultimate_de = NULL;
 +
 +		/* Find last and penultimate dirent */
 +		while ((char *)de < top) {
 +			penultimate_de = last_de;
 +			last_de = de;
 +			ctx->errcode = ext2fs_get_rec_len(fs, de, &rec_len);
 +			if (!ctx->errcode && !rec_len)
 +				ctx->errcode = EXT2_ET_DIR_CORRUPTED;
 +			if (ctx->errcode)
 +				return BLOCK_ABORT;
 +			de = (struct ext2_dir_entry *)(((void *)de) + rec_len);
 +		}
 +		ctx->errcode = ext2fs_get_rec_len(fs, last_de, &rec_len);
 +		if (ctx->errcode)
 +			return BLOCK_ABORT;
 +		name_size = last_de->name_len & 0xFF;
 +
 +		if (!EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 +				EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
 +			if (!penultimate_de)
 +				return 0;
 +			if (last_de->inode ||
 +			    name_size ||
 +			    rec_len != sizeof(struct ext2_dir_entry_tail))
 +				return 0;
 +			/*
 +			 * The last dirent is unused and the right length to
 +			 * have stored a checksum.  Erase it.
 +			 */
 +			ctx->errcode = ext2fs_get_rec_len(fs, penultimate_de,
 +							  &rec_len);
 +			if (!rec_len)
 +				ctx->errcode = EXT2_ET_DIR_CORRUPTED;
 +			if (ctx->errcode)
 +				return BLOCK_ABORT;
 +			ext2fs_set_rec_len(fs, rec_len +
 +					sizeof(struct ext2_dir_entry_tail),
 +					penultimate_de);
 +			changed = 1;
 +		} else {
 +			int csum_size = sizeof(struct ext2_dir_entry_tail);
 +			struct ext2_dir_entry_tail *t;
 +
 +			/*
 +			 * If the last dirent looks like the tail, just update
 +			 * the checksum.
 +			 */
 +			if (!last_de->inode &&
 +			    rec_len == csum_size) {
 +				t = (struct ext2_dir_entry_tail *)last_de;
 +				t->det_reserved_name_len =
 +						EXT2_DIR_NAME_LEN_CSUM;
 +				changed = 1;
 +				goto out;
 +			}
 +			if (name_size & 3)
 +				name_size = (name_size & ~3) + 4;
 +			/* If there's not enough space for the tail, e2fsck */
 +			if (rec_len <= (8 + name_size + csum_size)) {
 +				request_dir_fsck_afterwards(fs);
 +				return 0;
 +			}
 +			/* Shorten that last de and insert the tail */
 +			ext2fs_set_rec_len(fs, rec_len - csum_size, last_de);
 +			t = EXT2_DIRENT_TAIL(ctx->buf, fs->blocksize);
 +			ext2fs_initialize_dirent_tail(fs, t);
 +
 +			/* Always update checksum */
 +			changed = 1;
 +		}
 +	}
 +
 +out:
 +	if (!changed)
 +		return 0;
 +
 +	ctx->errcode = ext2fs_write_dir_block4(fs, *blocknr, ctx->buf,
 +					       0, ctx->dir);
 +	if (ctx->errcode)
 +		return BLOCK_ABORT;
 +
 +	return 0;
 +}
 +
 +errcode_t rewrite_directory(ext2_filsys fs, ext2_ino_t dir,
 +			    struct ext2_inode *inode)
 +{
 +	errcode_t	retval;
 +	struct rewrite_dir_context ctx;
 +
 +	retval = ext2fs_get_mem(fs->blocksize, &ctx.buf);
 +	if (retval)
 +		return retval;
 +
 +	ctx.is_htree = (inode->i_flags & EXT2_INDEX_FL);
 +	ctx.dir = dir;
 +	ctx.errcode = 0;
 +	retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_READ_ONLY |
 +						BLOCK_FLAG_DATA_ONLY,
 +				       0, rewrite_dir_block, &ctx);
 +
 +	ext2fs_free_mem(&ctx.buf);
 +	if (retval)
 +		return retval;
 +
 +	return ctx.errcode;
 +}
 +
 +/*
 + * Forcibly set checksums in all inodes.
 + */
 +static void rewrite_inodes(ext2_filsys fs)
 +{
 +	int length = EXT2_INODE_SIZE(fs->super);
 +	struct ext2_inode *inode;
 +	char		*ea_buf;
 +	ext2_inode_scan	scan;
 +	errcode_t	retval;
 +	ext2_ino_t	ino;
 +	blk64_t		file_acl_block;
 +
 +	if (fs->super->s_creator_os != EXT2_OS_LINUX)
 +		return;
 +
 +	retval = ext2fs_open_inode_scan(fs, 0, &scan);
 +	if (retval) {
 +		com_err("set_csum", retval, "while opening inode scan");
 +		exit(1);
 +	}
 +
 +	retval = ext2fs_get_mem(length, &inode);
 +	if (retval) {
 +		com_err("set_csum", retval, "while allocating memory");
 +		exit(1);
 +	}
 +
 +	retval = ext2fs_get_mem(fs->blocksize, &ea_buf);
 +	if (retval) {
 +		com_err("set_csum", retval, "while allocating memory");
 +		exit(1);
 +	}
 +
 +	do {
 +		retval = ext2fs_get_next_inode_full(scan, &ino, inode, length);
 +		if (retval) {
 +			com_err("set_csum", retval, "while getting next inode");
 +			exit(1);
 +		}
 +		if (!ino)
 +			break;
 +
 +		retval = ext2fs_write_inode_full(fs, ino, inode, length);
 +		if (retval) {
 +			com_err("set_csum", retval, "while writing inode");
 +			exit(1);
 +		}
 +
 +		retval = rewrite_extents(fs, ino, inode);
 +		if (retval) {
 +			com_err("rewrite_extents", retval,
 +				"while rewriting extents");
 +			exit(1);
 +		}
 +
 +		if (LINUX_S_ISDIR(inode->i_mode)) {
 +			retval = rewrite_directory(fs, ino, inode);
 +			if (retval) {
 +				com_err("rewrite_directory", retval,
 +					"while rewriting directories");
 +				exit(1);
 +			}
 +		}
 +
 +		file_acl_block = ext2fs_file_acl_block(fs, inode);
 +		if (!file_acl_block)
 +			continue;
 +		retval = ext2fs_read_ext_attr3(fs, file_acl_block, ea_buf, ino);
 +		if (retval) {
 +			com_err("rewrite_eablock", retval,
 +				"while rewriting extended attribute");
 +			exit(1);
 +		}
 +		retval = ext2fs_write_ext_attr3(fs, file_acl_block, ea_buf,
 +						ino);
 +		if (retval) {
 +			com_err("rewrite_eablock", retval,
 +				"while rewriting extended attribute");
 +			exit(1);
 +		}
 +	} while (ino);
 +
 +	ext2fs_free_mem(&inode);
 +	ext2fs_free_mem(&ea_buf);
 +	ext2fs_close_inode_scan(scan);
 +}
 +
 +static void rewrite_metadata_checksums(ext2_filsys fs)
 +{
- 	int i;
++	dgrp_t i;
 +
 +	fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
 +	ext2fs_init_csum_seed(fs);
 +	for (i = 0; i < fs->group_desc_count; i++)
 +		ext2fs_group_desc_csum_set(fs, i);
 +	rewrite_inodes(fs);
 +	ext2fs_read_bitmaps(fs);
 +	ext2fs_mark_ib_dirty(fs);
 +	ext2fs_mark_bb_dirty(fs);
 +	ext2fs_mmp_update2(fs, 1);
 +	fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
 +	fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
 +	if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 +				       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
 +		fs->super->s_checksum_type = EXT2_CRC32C_CHKSUM;
 +	else
 +		fs->super->s_checksum_type = 0;
 +	ext2fs_mark_super_dirty(fs);
 +}
 +
 +static void enable_uninit_bg(ext2_filsys fs)
 +{
 +	struct ext2_group_desc *gd;
- 	int i;
++	dgrp_t i;
 +
 +	for (i = 0; i < fs->group_desc_count; i++) {
 +		gd = ext2fs_group_desc(fs, fs->group_desc, i);
 +		gd->bg_itable_unused = 0;
 +		gd->bg_flags = EXT2_BG_INODE_ZEROED;
 +		ext2fs_group_desc_csum_set(fs, i);
 +	}
 +	fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
 +}
 +
 +static void disable_uninit_bg(ext2_filsys fs, __u32 csum_feature_flag)
 +{
 +	struct ext2_group_desc *gd;
- 	int i;
++	dgrp_t i;
 +
 +	/* Load bitmaps to ensure that the uninit ones get written out */
 +	fs->super->s_feature_ro_compat |= csum_feature_flag;
 +	ext2fs_read_bitmaps(fs);
 +	ext2fs_mark_ib_dirty(fs);
 +	ext2fs_mark_bb_dirty(fs);
 +	fs->super->s_feature_ro_compat &= ~csum_feature_flag;
 +
 +	for (i = 0; i < fs->group_desc_count; i++) {
 +		gd = ext2fs_group_desc(fs, fs->group_desc, i);
 +		if ((gd->bg_flags & EXT2_BG_INODE_ZEROED) == 0) {
 +			/*
 +			 * XXX what we really should do is zap
 +			 * uninitialized inode tables instead.
 +			 */
 +			request_fsck_afterwards(fs);
 +			break;
 +		}
 +		gd->bg_itable_unused = 0;
 +		gd->bg_flags = 0;
 +		ext2fs_group_desc_csum_set(fs, i);
 +	}
 +	fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
 +}
 +
  /*
   * Update the feature set as provided by the user.
   */