Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f8409abd authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 

Pull ext4 updates from Ted Ts'o:
 "Clean ups and miscellaneous bug fixes, in particular for the new
  collapse_range and zero_range fallocate functions.  In addition,
  improve the scalability of adding and remove inodes from the orphan
  list"

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (25 commits)
  ext4: handle symlink properly with inline_data
  ext4: fix wrong assert in ext4_mb_normalize_request()
  ext4: fix zeroing of page during writeback
  ext4: remove unused local variable "stored" from ext4_readdir(...)
  ext4: fix ZERO_RANGE test failure in data journalling
  ext4: reduce contention on s_orphan_lock
  ext4: use sbi in ext4_orphan_{add|del}()
  ext4: use EXT_MAX_BLOCKS in ext4_es_can_be_merged()
  ext4: add missing BUFFER_TRACE before ext4_journal_get_write_access
  ext4: remove unnecessary double parentheses
  ext4: do not destroy ext4_groupinfo_caches if ext4_mb_init() fails
  ext4: make local functions static
  ext4: fix block bitmap validation when bigalloc, ^flex_bg
  ext4: fix block bitmap initialization under sparse_super2
  ext4: find the group descriptors on a 1k-block bigalloc,meta_bg filesystem
  ext4: avoid unneeded lookup when xattr name is invalid
  ext4: fix data integrity sync in ordered mode
  ext4: remove obsoleted check
  ext4: add a new spinlock i_raw_lock to protect the ext4's raw inode
  ext4: fix locking for O_APPEND writes
  ...
parents b20dcab9 bd9db175

fs/ext4/balloc.c

+37 −29
Original line number Diff line number Diff line
@@ -83,7 +83,7 @@ static inline int ext4_block_in_group(struct super_block *sb, 
/* Return the number of clusters used for file system metadata; this

 * represents the overhead needed by the file system.

 */

unsigned ext4_num_overhead_clusters(struct super_block *sb,

static unsigned ext4_num_overhead_clusters(struct super_block *sb,

					   ext4_group_t block_group,

					   struct ext4_group_desc *gdp)

{
@@ -176,7 +176,8 @@ static unsigned int num_clusters_in_group(struct super_block *sb, 
}



/* Initializes an uninitialized block bitmap */

void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,

static void ext4_init_block_bitmap(struct super_block *sb,

				   struct buffer_head *bh,

				   ext4_group_t block_group,

				   struct ext4_group_desc *gdp)

{
@@ -307,6 +308,7 @@ static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb, 
					    ext4_group_t block_group,

					    struct buffer_head *bh)

{

	struct ext4_sb_info *sbi = EXT4_SB(sb);

	ext4_grpblk_t offset;

	ext4_grpblk_t next_zero_bit;

	ext4_fsblk_t blk;
@@ -326,14 +328,14 @@ static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb, 
	/* check whether block bitmap block number is set */

	blk = ext4_block_bitmap(sb, desc);

	offset = blk - group_first_block;

	if (!ext4_test_bit(offset, bh->b_data))

	if (!ext4_test_bit(EXT4_B2C(sbi, offset), bh->b_data))

		/* bad block bitmap */

		return blk;



	/* check whether the inode bitmap block number is set */

	blk = ext4_inode_bitmap(sb, desc);

	offset = blk - group_first_block;

	if (!ext4_test_bit(offset, bh->b_data))

	if (!ext4_test_bit(EXT4_B2C(sbi, offset), bh->b_data))

		/* bad block bitmap */

		return blk;
@@ -341,15 +343,16 @@ static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb, 
	blk = ext4_inode_table(sb, desc);

	offset = blk - group_first_block;

	next_zero_bit = ext4_find_next_zero_bit(bh->b_data,

				offset + EXT4_SB(sb)->s_itb_per_group,

				offset);

	if (next_zero_bit < offset + EXT4_SB(sb)->s_itb_per_group)

			EXT4_B2C(sbi, offset + EXT4_SB(sb)->s_itb_per_group),

			EXT4_B2C(sbi, offset));

	if (next_zero_bit <

	    EXT4_B2C(sbi, offset + EXT4_SB(sb)->s_itb_per_group))

		/* bad bitmap for inode tables */

		return blk;

	return 0;

}



void ext4_validate_block_bitmap(struct super_block *sb,

static void ext4_validate_block_bitmap(struct super_block *sb,

				       struct ext4_group_desc *desc,

				       ext4_group_t block_group,

				       struct buffer_head *bh)
@@ -708,16 +711,6 @@ static inline int test_root(ext4_group_t a, int b) 
	}

}



static int ext4_group_sparse(ext4_group_t group)

{

	if (group <= 1)

		return 1;

	if (!(group & 1))

		return 0;

	return (test_root(group, 7) || test_root(group, 5) ||

		test_root(group, 3));

}



/**

 *	ext4_bg_has_super - number of blocks used by the superblock in group

 *	@sb: superblock for filesystem
@@ -728,11 +721,26 @@ static int ext4_group_sparse(ext4_group_t group) 
 */

int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)

{

	if (EXT4_HAS_RO_COMPAT_FEATURE(sb,

				EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) &&

			!ext4_group_sparse(group))

	struct ext4_super_block *es = EXT4_SB(sb)->s_es;



	if (group == 0)

		return 1;

	if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) {

		if (group == le32_to_cpu(es->s_backup_bgs[0]) ||

		    group == le32_to_cpu(es->s_backup_bgs[1]))

			return 1;

		return 0;

	}

	if ((group <= 1) || !EXT4_HAS_RO_COMPAT_FEATURE(sb,

					EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER))

		return 1;

	if (!(group & 1))

		return 0;

	if (test_root(group, 3) || (test_root(group, 5)) ||

	    test_root(group, 7))

		return 1;



	return 0;

}



static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,

fs/ext4/dir.c

+1 −2
Original line number Diff line number Diff line
@@ -105,7 +105,7 @@ int __ext4_check_dir_entry(const char *function, unsigned int line, 
static int ext4_readdir(struct file *file, struct dir_context *ctx)

{

	unsigned int offset;

	int i, stored;

	int i;

	struct ext4_dir_entry_2 *de;

	int err;

	struct inode *inode = file_inode(file);
@@ -133,7 +133,6 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx) 
			return ret;

	}



	stored = 0;

	offset = ctx->pos & (sb->s_blocksize - 1);



	while (ctx->pos < inode->i_size) {

fs/ext4/ext4.h

+18 −41
Original line number Diff line number Diff line
@@ -158,7 +158,6 @@ struct ext4_allocation_request { 
#define EXT4_MAP_MAPPED		(1 << BH_Mapped)

#define EXT4_MAP_UNWRITTEN	(1 << BH_Unwritten)

#define EXT4_MAP_BOUNDARY	(1 << BH_Boundary)

#define EXT4_MAP_UNINIT		(1 << BH_Uninit)

/* Sometimes (in the bigalloc case, from ext4_da_get_block_prep) the caller of

 * ext4_map_blocks wants to know whether or not the underlying cluster has

 * already been accounted for. EXT4_MAP_FROM_CLUSTER conveys to the caller that
@@ -169,7 +168,7 @@ struct ext4_allocation_request { 
#define EXT4_MAP_FROM_CLUSTER	(1 << BH_AllocFromCluster)

#define EXT4_MAP_FLAGS		(EXT4_MAP_NEW | EXT4_MAP_MAPPED |\

				 EXT4_MAP_UNWRITTEN | EXT4_MAP_BOUNDARY |\

				 EXT4_MAP_UNINIT | EXT4_MAP_FROM_CLUSTER)

				 EXT4_MAP_FROM_CLUSTER)



struct ext4_map_blocks {

	ext4_fsblk_t m_pblk;
@@ -184,7 +183,7 @@ struct ext4_map_blocks { 
#define	EXT4_IO_END_UNWRITTEN	0x0001



/*

 * For converting uninitialized extents on a work queue. 'handle' is used for

 * For converting unwritten extents on a work queue. 'handle' is used for

 * buffered writeback.

 */

typedef struct ext4_io_end {
@@ -537,26 +536,26 @@ enum { 
/*

 * Flags used by ext4_map_blocks()

 */

	/* Allocate any needed blocks and/or convert an unitialized

	/* Allocate any needed blocks and/or convert an unwritten

	   extent to be an initialized ext4 */

#define EXT4_GET_BLOCKS_CREATE			0x0001

	/* Request the creation of an unitialized extent */

#define EXT4_GET_BLOCKS_UNINIT_EXT		0x0002

#define EXT4_GET_BLOCKS_CREATE_UNINIT_EXT	(EXT4_GET_BLOCKS_UNINIT_EXT|\

	/* Request the creation of an unwritten extent */

#define EXT4_GET_BLOCKS_UNWRIT_EXT		0x0002

#define EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT	(EXT4_GET_BLOCKS_UNWRIT_EXT|\

						 EXT4_GET_BLOCKS_CREATE)

	/* Caller is from the delayed allocation writeout path

	 * finally doing the actual allocation of delayed blocks */

#define EXT4_GET_BLOCKS_DELALLOC_RESERVE	0x0004

	/* caller is from the direct IO path, request to creation of an

	unitialized extents if not allocated, split the uninitialized

	unwritten extents if not allocated, split the unwritten

	extent if blocks has been preallocated already*/

#define EXT4_GET_BLOCKS_PRE_IO			0x0008

#define EXT4_GET_BLOCKS_CONVERT			0x0010

#define EXT4_GET_BLOCKS_IO_CREATE_EXT		(EXT4_GET_BLOCKS_PRE_IO|\

					 EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)

					 EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)

	/* Convert extent to initialized after IO complete */

#define EXT4_GET_BLOCKS_IO_CONVERT_EXT		(EXT4_GET_BLOCKS_CONVERT|\

					 EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)

					 EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)

	/* Eventual metadata allocation (due to growing extent tree)

	 * should not fail, so try to use reserved blocks for that.*/

#define EXT4_GET_BLOCKS_METADATA_NOFAIL		0x0020
@@ -876,6 +875,8 @@ struct ext4_inode_info { 
	struct inode vfs_inode;

	struct jbd2_inode *jinode;



	spinlock_t i_raw_lock;	/* protects updates to the raw inode */



	/*

	 * File creation time. Its function is same as that of

	 * struct timespec i_{a,c,m}time in the generic inode.
@@ -1159,7 +1160,8 @@ struct ext4_super_block { 
	__le32	s_usr_quota_inum;	/* inode for tracking user quota */

	__le32	s_grp_quota_inum;	/* inode for tracking group quota */

	__le32	s_overhead_clusters;	/* overhead blocks/clusters in fs */

	__le32	s_reserved[108];	/* Padding to the end of the block */

	__le32	s_backup_bgs[2];	/* groups with sparse_super2 SBs */

	__le32	s_reserved[106];	/* Padding to the end of the block */

	__le32	s_checksum;		/* crc32c(superblock) */

};
@@ -1505,6 +1507,7 @@ static inline void ext4_clear_state_flags(struct ext4_inode_info *ei) 
#define EXT4_FEATURE_COMPAT_EXT_ATTR		0x0008

#define EXT4_FEATURE_COMPAT_RESIZE_INODE	0x0010

#define EXT4_FEATURE_COMPAT_DIR_INDEX		0x0020

#define EXT4_FEATURE_COMPAT_SPARSE_SUPER2	0x0200



#define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER	0x0001

#define EXT4_FEATURE_RO_COMPAT_LARGE_FILE	0x0002
@@ -1953,10 +1956,6 @@ extern void ext4_get_group_no_and_offset(struct super_block *sb, 
extern ext4_group_t ext4_get_group_number(struct super_block *sb,

					  ext4_fsblk_t block);



extern void ext4_validate_block_bitmap(struct super_block *sb,

				       struct ext4_group_desc *desc,

				       ext4_group_t block_group,

				       struct buffer_head *bh);

extern unsigned int ext4_block_group(struct super_block *sb,

			ext4_fsblk_t blocknr);

extern ext4_grpblk_t ext4_block_group_offset(struct super_block *sb,
@@ -1985,16 +1984,9 @@ extern int ext4_wait_block_bitmap(struct super_block *sb, 
				  struct buffer_head *bh);

extern struct buffer_head *ext4_read_block_bitmap(struct super_block *sb,

						  ext4_group_t block_group);

extern void ext4_init_block_bitmap(struct super_block *sb,

				   struct buffer_head *bh,

				   ext4_group_t group,

				   struct ext4_group_desc *desc);

extern unsigned ext4_free_clusters_after_init(struct super_block *sb,

					      ext4_group_t block_group,

					      struct ext4_group_desc *gdp);

extern unsigned ext4_num_overhead_clusters(struct super_block *sb,

					   ext4_group_t block_group,

					   struct ext4_group_desc *gdp);

ext4_fsblk_t ext4_inode_to_goal_block(struct inode *);



/* dir.c */
@@ -2137,8 +2129,6 @@ extern int ext4_alloc_da_blocks(struct inode *inode); 
extern void ext4_set_aops(struct inode *inode);

extern int ext4_writepage_trans_blocks(struct inode *);

extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);

extern int ext4_block_truncate_page(handle_t *handle,

		struct address_space *mapping, loff_t from);

extern int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,

			     loff_t lstart, loff_t lend);

extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
@@ -2198,8 +2188,6 @@ extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count); 


/* super.c */

extern int ext4_calculate_overhead(struct super_block *sb);

extern int ext4_superblock_csum_verify(struct super_block *sb,

				       struct ext4_super_block *es);

extern void ext4_superblock_csum_set(struct super_block *sb);

extern void *ext4_kvmalloc(size_t size, gfp_t flags);

extern void *ext4_kvzalloc(size_t size, gfp_t flags);
@@ -2571,19 +2559,11 @@ extern const struct file_operations ext4_dir_operations; 
extern const struct inode_operations ext4_file_inode_operations;

extern const struct file_operations ext4_file_operations;

extern loff_t ext4_llseek(struct file *file, loff_t offset, int origin);

extern void ext4_unwritten_wait(struct inode *inode);



/* inline.c */

extern int ext4_has_inline_data(struct inode *inode);

extern int ext4_get_inline_size(struct inode *inode);

extern int ext4_get_max_inline_size(struct inode *inode);

extern int ext4_find_inline_data_nolock(struct inode *inode);

extern void ext4_write_inline_data(struct inode *inode,

				   struct ext4_iloc *iloc,

				   void *buffer, loff_t pos,

				   unsigned int len);

extern int ext4_prepare_inline_data(handle_t *handle, struct inode *inode,

				    unsigned int len);

extern int ext4_init_inline_data(handle_t *handle, struct inode *inode,

				 unsigned int len);

extern int ext4_destroy_inline_data(handle_t *handle, struct inode *inode);
@@ -2771,23 +2751,20 @@ extern void ext4_io_submit(struct ext4_io_submit *io); 
extern int ext4_bio_write_page(struct ext4_io_submit *io,

			       struct page *page,

			       int len,

			       struct writeback_control *wbc);

			       struct writeback_control *wbc,

			       bool keep_towrite);



/* mmp.c */

extern int ext4_multi_mount_protect(struct super_block *, ext4_fsblk_t);

extern void ext4_mmp_csum_set(struct super_block *sb, struct mmp_struct *mmp);

extern int ext4_mmp_csum_verify(struct super_block *sb,

				struct mmp_struct *mmp);



/*

 * Note that these flags will never ever appear in a buffer_head's state flag.

 * See EXT4_MAP_... to see where this is used.

 */

enum ext4_state_bits {

	BH_Uninit	/* blocks are allocated but uninitialized on disk */

	 = BH_JBDPrivateStart,

	BH_AllocFromCluster,	/* allocated blocks were part of already

	BH_AllocFromCluster	/* allocated blocks were part of already

				 * allocated cluster. */

	= BH_JBDPrivateStart

};



/*

fs/ext4/ext4_extents.h

+11 −11
Original line number Diff line number Diff line
@@ -137,21 +137,21 @@ struct ext4_ext_path { 
 * EXT_INIT_MAX_LEN is the maximum number of blocks we can have in an

 * initialized extent. This is 2^15 and not (2^16 - 1), since we use the

 * MSB of ee_len field in the extent datastructure to signify if this

 * particular extent is an initialized extent or an uninitialized (i.e.

 * particular extent is an initialized extent or an unwritten (i.e.

 * preallocated).

 * EXT_UNINIT_MAX_LEN is the maximum number of blocks we can have in an

 * uninitialized extent.

 * EXT_UNWRITTEN_MAX_LEN is the maximum number of blocks we can have in an

 * unwritten extent.

 * If ee_len is <= 0x8000, it is an initialized extent. Otherwise, it is an

 * uninitialized one. In other words, if MSB of ee_len is set, it is an

 * uninitialized extent with only one special scenario when ee_len = 0x8000.

 * In this case we can not have an uninitialized extent of zero length and

 * unwritten one. In other words, if MSB of ee_len is set, it is an

 * unwritten extent with only one special scenario when ee_len = 0x8000.

 * In this case we can not have an unwritten extent of zero length and

 * thus we make it as a special case of initialized extent with 0x8000 length.

 * This way we get better extent-to-group alignment for initialized extents.

 * Hence, the maximum number of blocks we can have in an *initialized*

 * extent is 2^15 (32768) and in an *uninitialized* extent is 2^15-1 (32767).

 * extent is 2^15 (32768) and in an *unwritten* extent is 2^15-1 (32767).

 */

#define EXT_INIT_MAX_LEN	(1UL << 15)

#define EXT_UNINIT_MAX_LEN	(EXT_INIT_MAX_LEN - 1)

#define EXT_UNWRITTEN_MAX_LEN	(EXT_INIT_MAX_LEN - 1)





#define EXT_FIRST_EXTENT(__hdr__) \
@@ -187,14 +187,14 @@ static inline unsigned short ext_depth(struct inode *inode) 
	return le16_to_cpu(ext_inode_hdr(inode)->eh_depth);

}



static inline void ext4_ext_mark_uninitialized(struct ext4_extent *ext)

static inline void ext4_ext_mark_unwritten(struct ext4_extent *ext)

{

	/* We can not have an uninitialized extent of zero length! */

	/* We can not have an unwritten extent of zero length! */

	BUG_ON((le16_to_cpu(ext->ee_len) & ~EXT_INIT_MAX_LEN) == 0);

	ext->ee_len |= cpu_to_le16(EXT_INIT_MAX_LEN);

}



static inline int ext4_ext_is_uninitialized(struct ext4_extent *ext)

static inline int ext4_ext_is_unwritten(struct ext4_extent *ext)

{

	/* Extent with ee_len of 0x8000 is treated as an initialized extent */

	return (le16_to_cpu(ext->ee_len) > EXT_INIT_MAX_LEN);

fs/ext4/ext4_jbd2.c

+4 −3
Original line number Diff line number Diff line
@@ -122,8 +122,9 @@ handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line, 
	return handle;

}



void ext4_journal_abort_handle(const char *caller, unsigned int line,

			       const char *err_fn, struct buffer_head *bh,

static void ext4_journal_abort_handle(const char *caller, unsigned int line,

				      const char *err_fn,

				      struct buffer_head *bh,

				      handle_t *handle, int err)

{

	char nbuf[16];