Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 (8f616cd5) · Commits · 戴 / test

fs/ext4/acl.c

+94 −94

Original line number	Original line	Diff line number	Diff line
	@@ -47,6 +47,7 @@ ext4_acl_from_disk(const void *value, size_t size)
	goto fail;		goto fail;
	acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);		acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
	acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);		acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);

	switch (acl->a_entries[n].e_tag) {		switch (acl->a_entries[n].e_tag) {
	case ACL_USER_OBJ:		case ACL_USER_OBJ:
	case ACL_GROUP_OBJ:		case ACL_GROUP_OBJ:
	@@ -103,8 +104,7 @@ ext4_acl_to_disk(const struct posix_acl acl, size_t size)
	switch (acl->a_entries[n].e_tag) {		switch (acl->a_entries[n].e_tag) {
	case ACL_USER:		case ACL_USER:
	case ACL_GROUP:		case ACL_GROUP:
	entry->e_id =		entry->e_id = cpu_to_le32(acl->a_entries[n].e_id);
	cpu_to_le32(acl->a_entries[n].e_id);
	e += sizeof(ext4_acl_entry);		e += sizeof(ext4_acl_entry);
	break;		break;

fs/ext4/balloc.c

+7 −4

Original line number	Original line	Diff line number	Diff line
	@@ -314,25 +314,28 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
	if (unlikely(!bh)) {		if (unlikely(!bh)) {
	ext4_error(sb, __func__,		ext4_error(sb, __func__,
	"Cannot read block bitmap - "		"Cannot read block bitmap - "
	"block_group = %d, block_bitmap = %llu",		"block_group = %lu, block_bitmap = %llu",
	(int)block_group, (unsigned long long)bitmap_blk);		block_group, bitmap_blk);
	return NULL;		return NULL;
	}		}
	if (bh_uptodate_or_lock(bh))		if (bh_uptodate_or_lock(bh))
	return bh;		return bh;

			spin_lock(sb_bgl_lock(EXT4_SB(sb), block_group));
	if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {		if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
	ext4_init_block_bitmap(sb, bh, block_group, desc);		ext4_init_block_bitmap(sb, bh, block_group, desc);
	set_buffer_uptodate(bh);		set_buffer_uptodate(bh);
	unlock_buffer(bh);		unlock_buffer(bh);
			spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
	return bh;		return bh;
	}		}
			spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
	if (bh_submit_read(bh) < 0) {		if (bh_submit_read(bh) < 0) {
	put_bh(bh);		put_bh(bh);
	ext4_error(sb, __func__,		ext4_error(sb, __func__,
	"Cannot read block bitmap - "		"Cannot read block bitmap - "
	"block_group = %d, block_bitmap = %llu",		"block_group = %lu, block_bitmap = %llu",
	(int)block_group, (unsigned long long)bitmap_blk);		block_group, bitmap_blk);
	return NULL;		return NULL;
	}		}
	ext4_valid_block_bitmap(sb, desc, block_group, bh);		ext4_valid_block_bitmap(sb, desc, block_group, bh);

fs/ext4/ext4.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1044,7 +1044,6 @@ extern void ext4_mb_update_group_info(struct ext4_group_info *grp,


	/* inode.c */		/* inode.c */
	void ext4_da_release_space(struct inode *inode, int used, int to_free);
	int ext4_forget(handle_t handle, int is_metadata, struct inode inode,		int ext4_forget(handle_t handle, int is_metadata, struct inode inode,
	struct buffer_head *bh, ext4_fsblk_t blocknr);		struct buffer_head *bh, ext4_fsblk_t blocknr);
	struct buffer_head ext4_getblk(handle_t , struct inode *,		struct buffer_head ext4_getblk(handle_t , struct inode *,

fs/ext4/extents.c

+32 −23

Original line number	Original line	Diff line number	Diff line
	@@ -99,7 +99,7 @@ static int ext4_ext_journal_restart(handle_t *handle, int needed)
	if (handle->h_buffer_credits > needed)		if (handle->h_buffer_credits > needed)
	return 0;		return 0;
	err = ext4_journal_extend(handle, needed);		err = ext4_journal_extend(handle, needed);
	if (err)		if (err <= 0)
	return err;		return err;
	return ext4_journal_restart(handle, needed);		return ext4_journal_restart(handle, needed);
	}		}
	@@ -1910,9 +1910,13 @@ ext4_ext_rm_leaf(handle_t handle, struct inode inode,
	BUG_ON(b != ex_ee_block + ex_ee_len - 1);		BUG_ON(b != ex_ee_block + ex_ee_len - 1);
	}		}

	/* at present, extent can't cross block group: */		/*
	/* leaf + bitmap + group desc + sb + inode */		* 3 for leaf, sb, and inode plus 2 (bmap and group
	credits = 5;		* descriptor) for each block group; assume two block
			* groups plus ex_ee_len/blocks_per_block_group for
			* the worst case
			*/
			credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));
	if (ex == EXT_FIRST_EXTENT(eh)) {		if (ex == EXT_FIRST_EXTENT(eh)) {
	correct_index = 1;		correct_index = 1;
	credits += (ext_depth(inode)) + 1;		credits += (ext_depth(inode)) + 1;
	@@ -2323,7 +2327,10 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
	unsigned int newdepth;		unsigned int newdepth;
	/* If extent has less than EXT4_EXT_ZERO_LEN zerout directly */		/* If extent has less than EXT4_EXT_ZERO_LEN zerout directly */
	if (allocated <= EXT4_EXT_ZERO_LEN) {		if (allocated <= EXT4_EXT_ZERO_LEN) {
	/* Mark first half uninitialized.		/*
			* iblock == ee_block is handled by the zerouout
			* at the beginning.
			* Mark first half uninitialized.
	* Mark second half initialized and zero out the		* Mark second half initialized and zero out the
	* initialized extent		* initialized extent
	*/		*/
	@@ -2346,7 +2353,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
	ex->ee_len = orig_ex.ee_len;		ex->ee_len = orig_ex.ee_len;
	ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));		ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
	ext4_ext_dirty(handle, inode, path + depth);		ext4_ext_dirty(handle, inode, path + depth);
	/* zeroed the full extent */		/* blocks available from iblock */
	return allocated;		return allocated;

	} else if (err)		} else if (err)
	@@ -2374,6 +2381,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
	err = PTR_ERR(path);		err = PTR_ERR(path);
	return err;		return err;
	}		}
			/* get the second half extent details */
	ex = path[depth].p_ext;		ex = path[depth].p_ext;
	err = ext4_ext_get_access(handle, inode,		err = ext4_ext_get_access(handle, inode,
	path + depth);		path + depth);
	@@ -2403,6 +2411,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
	ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));		ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
	ext4_ext_dirty(handle, inode, path + depth);		ext4_ext_dirty(handle, inode, path + depth);
	/* zeroed the full extent */		/* zeroed the full extent */
			/* blocks available from iblock */
	return allocated;		return allocated;

	} else if (err)		} else if (err)
	@@ -2418,7 +2427,6 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
	*/		*/
	orig_ex.ee_len = cpu_to_le16(ee_len -		orig_ex.ee_len = cpu_to_le16(ee_len -
	ext4_ext_get_actual_len(ex3));		ext4_ext_get_actual_len(ex3));
	if (newdepth != depth) {
	depth = newdepth;		depth = newdepth;
	ext4_ext_drop_refs(path);		ext4_ext_drop_refs(path);
	path = ext4_ext_find_extent(inode, iblock, path);		path = ext4_ext_find_extent(inode, iblock, path);
	@@ -2434,7 +2442,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
	err = ext4_ext_get_access(handle, inode, path + depth);		err = ext4_ext_get_access(handle, inode, path + depth);
	if (err)		if (err)
	goto out;		goto out;
	}
	allocated = max_blocks;		allocated = max_blocks;

	/* If extent has less than EXT4_EXT_ZERO_LEN and we are trying		/* If extent has less than EXT4_EXT_ZERO_LEN and we are trying
	@@ -2452,6 +2460,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
	ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));		ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
	ext4_ext_dirty(handle, inode, path + depth);		ext4_ext_dirty(handle, inode, path + depth);
	/* zero out the first half */		/* zero out the first half */
			/* blocks available from iblock */
	return allocated;		return allocated;
	}		}
	}		}

fs/ext4/ialloc.c

+34 −24

Original line number	Original line	Diff line number	Diff line
	@@ -97,34 +97,44 @@ unsigned ext4_init_inode_bitmap(struct super_block sb, struct buffer_head bh,
	* Return buffer_head of bitmap on success or NULL.		* Return buffer_head of bitmap on success or NULL.
	*/		*/
	static struct buffer_head *		static struct buffer_head *
	read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)		ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
	{		{
	struct ext4_group_desc *desc;		struct ext4_group_desc *desc;
	struct buffer_head *bh = NULL;		struct buffer_head *bh = NULL;
			ext4_fsblk_t bitmap_blk;

	desc = ext4_get_group_desc(sb, block_group, NULL);		desc = ext4_get_group_desc(sb, block_group, NULL);
	if (!desc)		if (!desc)
	goto error_out;		return NULL;
			bitmap_blk = ext4_inode_bitmap(sb, desc);
			bh = sb_getblk(sb, bitmap_blk);
			if (unlikely(!bh)) {
			ext4_error(sb, __func__,
			"Cannot read inode bitmap - "
			"block_group = %lu, inode_bitmap = %llu",
			block_group, bitmap_blk);
			return NULL;
			}
			if (bh_uptodate_or_lock(bh))
			return bh;

			spin_lock(sb_bgl_lock(EXT4_SB(sb), block_group));
	if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {		if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
	bh = sb_getblk(sb, ext4_inode_bitmap(sb, desc));		ext4_init_inode_bitmap(sb, bh, block_group, desc);
	if (!buffer_uptodate(bh)) {
	lock_buffer(bh);
	if (!buffer_uptodate(bh)) {
	ext4_init_inode_bitmap(sb, bh, block_group,
	desc);
	set_buffer_uptodate(bh);		set_buffer_uptodate(bh);
	}
	unlock_buffer(bh);		unlock_buffer(bh);
			spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
			return bh;
	}		}
	} else {		spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
	bh = sb_bread(sb, ext4_inode_bitmap(sb, desc));		if (bh_submit_read(bh) < 0) {
	}		put_bh(bh);
	if (!bh)		ext4_error(sb, __func__,
	ext4_error(sb, "read_inode_bitmap",
	"Cannot read inode bitmap - "		"Cannot read inode bitmap - "
	"block_group = %lu, inode_bitmap = %llu",		"block_group = %lu, inode_bitmap = %llu",
	block_group, ext4_inode_bitmap(sb, desc));		block_group, bitmap_blk);
	error_out:		return NULL;
			}
	return bh;		return bh;
	}		}

	@@ -200,7 +210,7 @@ void ext4_free_inode (handle_t handle, struct inode inode)
	}		}
	block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);		block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);		bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
	bitmap_bh = read_inode_bitmap(sb, block_group);		bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
	if (!bitmap_bh)		if (!bitmap_bh)
	goto error_return;		goto error_return;

	@@ -623,7 +633,7 @@ got_group:
	goto fail;		goto fail;

	brelse(bitmap_bh);		brelse(bitmap_bh);
	bitmap_bh = read_inode_bitmap(sb, group);		bitmap_bh = ext4_read_inode_bitmap(sb, group);
	if (!bitmap_bh)		if (!bitmap_bh)
	goto fail;		goto fail;

	@@ -728,7 +738,7 @@ got:

	/* When marking the block group with		/* When marking the block group with
	* ~EXT4_BG_INODE_UNINIT we don't want to depend		* ~EXT4_BG_INODE_UNINIT we don't want to depend
	* on the value of bg_itable_unsed even though		* on the value of bg_itable_unused even though
	* mke2fs could have initialized the same for us.		* mke2fs could have initialized the same for us.
	* Instead we calculated the value below		* Instead we calculated the value below
	*/		*/
	@@ -891,7 +901,7 @@ struct inode ext4_orphan_get(struct super_block sb, unsigned long ino)

	block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);		block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);		bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
	bitmap_bh = read_inode_bitmap(sb, block_group);		bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
	if (!bitmap_bh) {		if (!bitmap_bh) {
	ext4_warning(sb, __func__,		ext4_warning(sb, __func__,
	"inode bitmap error for orphan %lu", ino);		"inode bitmap error for orphan %lu", ino);
	@@ -969,7 +979,7 @@ unsigned long ext4_count_free_inodes (struct super_block * sb)
	continue;		continue;
	desc_count += le16_to_cpu(gdp->bg_free_inodes_count);		desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
	brelse(bitmap_bh);		brelse(bitmap_bh);
	bitmap_bh = read_inode_bitmap(sb, i);		bitmap_bh = ext4_read_inode_bitmap(sb, i);
	if (!bitmap_bh)		if (!bitmap_bh)
	continue;		continue;

Admin message