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

Commit 09dc942c authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (40 commits)
  ext4: Adding error check after calling ext4_mb_regular_allocator()
  ext4: Fix dirtying of journalled buffers in data=journal mode
  ext4: re-inline ext4_rec_len_(to|from)_disk functions
  jbd2: Remove t_handle_lock from start_this_handle()
  jbd2: Change j_state_lock to be a rwlock_t
  jbd2: Use atomic variables to avoid taking t_handle_lock in jbd2_journal_stop
  ext4: Add mount options in superblock
  ext4: force block allocation on quota_off
  ext4: fix freeze deadlock under IO
  ext4: drop inode from orphan list if ext4_delete_inode() fails
  ext4: check to make make sure bd_dev is set before dereferencing it
  jbd2: Make barrier messages less scary
  ext4: don't print scary messages for allocation failures post-abort
  ext4: fix EFBIG edge case when writing to large non-extent file
  ext4: fix ext4_get_blocks references
  ext4: Always journal quota file modifications
  ext4: Fix potential memory leak in ext4_fill_super
  ext4: Don't error out the fs if the user tries to make a file too big
  ext4: allocate stripe-multiple IOs on stripe boundaries
  ext4: move aio completion after unwritten extent conversion
  ...

Fix up conflicts in fs/ext4/inode.c as per Ted.

Fix up xfs conflicts as per earlier xfs merge.
parents 90e0c225 6c7a120a

fs/ext4/acl.c

+1 −0
Original line number Diff line number Diff line
@@ -204,6 +204,7 @@ ext4_set_acl(handle_t *handle, struct inode *inode, int type, 
				return error;

			else {

				inode->i_mode = mode;

				inode->i_ctime = ext4_current_time(inode);

				ext4_mark_inode_dirty(handle, inode);

				if (error == 0)

					acl = NULL;

fs/ext4/balloc.c

+1 −5
Original line number Diff line number Diff line
@@ -377,14 +377,11 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb, 
	ext4_grpblk_t bit;

	unsigned int i;

	struct ext4_group_desc *desc;

	struct ext4_super_block *es;

	struct ext4_sb_info *sbi;

	struct ext4_sb_info *sbi = EXT4_SB(sb);

	int err = 0, ret, blk_free_count;

	ext4_grpblk_t blocks_freed;

	struct ext4_group_info *grp;



	sbi = EXT4_SB(sb);

	es = sbi->s_es;

	ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1);



	ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
@@ -477,7 +474,6 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb, 
	ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);

	if (!err)

		err = ret;

	sb->s_dirt = 1;



error_return:

	brelse(bitmap_bh);

fs/ext4/block_validity.c

+6 −2
Original line number Diff line number Diff line
@@ -229,17 +229,21 @@ int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk, 


	if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||

	    (start_blk + count < start_blk) ||

	    (start_blk + count > ext4_blocks_count(sbi->s_es)))

	    (start_blk + count > ext4_blocks_count(sbi->s_es))) {

		sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);

		return 0;

	}

	while (n) {

		entry = rb_entry(n, struct ext4_system_zone, node);

		if (start_blk + count - 1 < entry->start_blk)

			n = n->rb_left;

		else if (start_blk >= (entry->start_blk + entry->count))

			n = n->rb_right;

		else

		else {

			sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);

			return 0;

		}

	}

	return 1;

}

fs/ext4/dir.c

+12 −11
Original line number Diff line number Diff line
@@ -61,7 +61,8 @@ static unsigned char get_dtype(struct super_block *sb, int filetype) 
}





int ext4_check_dir_entry(const char *function, struct inode *dir,

int __ext4_check_dir_entry(const char *function, unsigned int line,

			   struct inode *dir,

			   struct ext4_dir_entry_2 *de,

			   struct buffer_head *bh,

			   unsigned int offset)
@@ -83,11 +84,10 @@ int ext4_check_dir_entry(const char *function, struct inode *dir, 
		error_msg = "inode out of bounds";



	if (error_msg != NULL)

		ext4_error_inode(function, dir,

			"bad entry in directory: %s - block=%llu"

		ext4_error_inode(dir, function, line, bh->b_blocknr,

			"bad entry in directory: %s - "

			"offset=%u(%u), inode=%u, rec_len=%d, name_len=%d",

			error_msg, (unsigned long long) bh->b_blocknr,

			(unsigned) (offset%bh->b_size), offset,

			error_msg, (unsigned) (offset%bh->b_size), offset,

			le32_to_cpu(de->inode),

			rlen, de->name_len);

	return error_msg == NULL ? 1 : 0;
@@ -121,7 +121,8 @@ static int ext4_readdir(struct file *filp, 
		 * We don't set the inode dirty flag since it's not

		 * critical that it get flushed back to the disk.

		 */

		ext4_clear_inode_flag(filp->f_path.dentry->d_inode, EXT4_INODE_INDEX);

		ext4_clear_inode_flag(filp->f_path.dentry->d_inode,

				      EXT4_INODE_INDEX);

	}

	stored = 0;

	offset = filp->f_pos & (sb->s_blocksize - 1);
@@ -193,7 +194,7 @@ revalidate: 
		while (!error && filp->f_pos < inode->i_size

		       && offset < sb->s_blocksize) {

			de = (struct ext4_dir_entry_2 *) (bh->b_data + offset);

			if (!ext4_check_dir_entry("ext4_readdir", inode, de,

			if (!ext4_check_dir_entry(inode, de,

						  bh, offset)) {

				/*

				 * On error, skip the f_pos to the next block
@@ -343,7 +344,7 @@ int ext4_htree_store_dirent(struct file *dir_file, __u32 hash, 
	struct dir_private_info *info;

	int len;



	info = (struct dir_private_info *) dir_file->private_data;

	info = dir_file->private_data;

	p = &info->root.rb_node;



	/* Create and allocate the fname structure */

fs/ext4/ext4.h

+119 −33
Original line number Diff line number Diff line
@@ -57,10 +57,13 @@ 
#endif



#define EXT4_ERROR_INODE(inode, fmt, a...) \

	ext4_error_inode(__func__, (inode), (fmt), ## a)

	ext4_error_inode((inode), __func__, __LINE__, 0, (fmt), ## a)



#define EXT4_ERROR_INODE_BLOCK(inode, block, fmt, a...)			\

	ext4_error_inode((inode), __func__, __LINE__, (block), (fmt), ## a)



#define EXT4_ERROR_FILE(file, fmt, a...)	\

	ext4_error_file(__func__, (file), (fmt), ## a)

	ext4_error_file(__func__, __LINE__, (file), (fmt), ## a)



/* data type for block offset of block group */

typedef int ext4_grpblk_t;
@@ -167,13 +170,15 @@ struct mpage_da_data { 
};

#define	EXT4_IO_UNWRITTEN	0x1

typedef struct ext4_io_end {

	struct list_head	list;		/* per-file finished AIO list */

	struct list_head	list;		/* per-file finished IO list */

	struct inode		*inode;		/* file being written to */

	unsigned int		flag;		/* unwritten or not */

	struct page		*page;		/* page struct for buffer write */

	loff_t			offset;		/* offset in the file */

	ssize_t			size;		/* size of the extent */

	struct work_struct	work;		/* data work queue */

	struct kiocb		*iocb;		/* iocb struct for AIO */

	int			result;		/* error value for AIO */

} ext4_io_end_t;



/*
@@ -460,7 +465,7 @@ struct ext4_new_group_data { 
};



/*

 * Flags used by ext4_get_blocks()

 * Flags used by ext4_map_blocks()

 */

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

	   extent to be an initialized ext4 */
@@ -873,7 +878,6 @@ struct ext4_inode_info { 
#define EXT4_MOUNT_POSIX_ACL		0x08000	/* POSIX Access Control Lists */

#define EXT4_MOUNT_NO_AUTO_DA_ALLOC	0x10000	/* No auto delalloc mapping */

#define EXT4_MOUNT_BARRIER		0x20000 /* Use block barriers */

#define EXT4_MOUNT_NOBH			0x40000 /* No bufferheads */

#define EXT4_MOUNT_QUOTA		0x80000 /* Some quota option set */

#define EXT4_MOUNT_USRQUOTA		0x100000 /* "old" user quota */

#define EXT4_MOUNT_GRPQUOTA		0x200000 /* "old" group quota */
@@ -982,7 +986,7 @@ struct ext4_super_block { 
	__le32	s_last_orphan;		/* start of list of inodes to delete */

	__le32	s_hash_seed[4];		/* HTREE hash seed */

	__u8	s_def_hash_version;	/* Default hash version to use */

	__u8	s_reserved_char_pad;

	__u8	s_jnl_backup_type;

	__le16  s_desc_size;		/* size of group descriptor */

/*100*/	__le32	s_default_mount_opts;

	__le32	s_first_meta_bg;	/* First metablock block group */
@@ -1000,12 +1004,34 @@ struct ext4_super_block { 
	__le64  s_mmp_block;            /* Block for multi-mount protection */

	__le32  s_raid_stripe_width;    /* blocks on all data disks (N*stride)*/

	__u8	s_log_groups_per_flex;  /* FLEX_BG group size */

	__u8	s_reserved_char_pad2;

	__u8	s_reserved_char_pad;

	__le16  s_reserved_pad;

	__le64	s_kbytes_written;	/* nr of lifetime kilobytes written */

	__u32   s_reserved[160];        /* Padding to the end of the block */

	__le32	s_snapshot_inum;	/* Inode number of active snapshot */

	__le32	s_snapshot_id;		/* sequential ID of active snapshot */

	__le64	s_snapshot_r_blocks_count; /* reserved blocks for active

					      snapshot's future use */

	__le32	s_snapshot_list;	/* inode number of the head of the

					   on-disk snapshot list */

#define EXT4_S_ERR_START offsetof(struct ext4_super_block, s_error_count)

	__le32	s_error_count;		/* number of fs errors */

	__le32	s_first_error_time;	/* first time an error happened */

	__le32	s_first_error_ino;	/* inode involved in first error */

	__le64	s_first_error_block;	/* block involved of first error */

	__u8	s_first_error_func[32];	/* function where the error happened */

	__le32	s_first_error_line;	/* line number where error happened */

	__le32	s_last_error_time;	/* most recent time of an error */

	__le32	s_last_error_ino;	/* inode involved in last error */

	__le32	s_last_error_line;	/* line number where error happened */

	__le64	s_last_error_block;	/* block involved of last error */

	__u8	s_last_error_func[32];	/* function where the error happened */

#define EXT4_S_ERR_END offsetof(struct ext4_super_block, s_mount_opts)

	__u8	s_mount_opts[64];

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

};



#define EXT4_S_ERR_LEN (EXT4_S_ERR_END - EXT4_S_ERR_START)



#ifdef __KERNEL__



/*
@@ -1143,6 +1169,9 @@ struct ext4_sb_info { 


	/* workqueue for dio unwritten */

	struct workqueue_struct *dio_unwritten_wq;



	/* timer for periodic error stats printing */

	struct timer_list s_err_report;

};



static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
@@ -1313,6 +1342,10 @@ EXT4_INODE_BIT_FNS(state, state_flags) 
#define EXT4_DEFM_JMODE_DATA	0x0020

#define EXT4_DEFM_JMODE_ORDERED	0x0040

#define EXT4_DEFM_JMODE_WBACK	0x0060

#define EXT4_DEFM_NOBARRIER	0x0100

#define EXT4_DEFM_BLOCK_VALIDITY 0x0200

#define EXT4_DEFM_DISCARD	0x0400

#define EXT4_DEFM_NODELALLOC	0x0800



/*

 * Default journal batch times
@@ -1378,6 +1411,43 @@ struct ext4_dir_entry_2 { 
					 ~EXT4_DIR_ROUND)

#define EXT4_MAX_REC_LEN		((1<<16)-1)



/*

 * If we ever get support for fs block sizes > page_size, we'll need

 * to remove the #if statements in the next two functions...

 */

static inline unsigned int

ext4_rec_len_from_disk(__le16 dlen, unsigned blocksize)

{

	unsigned len = le16_to_cpu(dlen);



#if (PAGE_CACHE_SIZE >= 65536)

	if (len == EXT4_MAX_REC_LEN || len == 0)

		return blocksize;

	return (len & 65532) | ((len & 3) << 16);

#else

	return len;

#endif

}



static inline __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize)

{

	if ((len > blocksize) || (blocksize > (1 << 18)) || (len & 3))

		BUG();

#if (PAGE_CACHE_SIZE >= 65536)

	if (len < 65536)

		return cpu_to_le16(len);

	if (len == blocksize) {

		if (blocksize == 65536)

			return cpu_to_le16(EXT4_MAX_REC_LEN);

		else

			return cpu_to_le16(0);

	}

	return cpu_to_le16((len & 65532) | ((len >> 16) & 3));

#else

	return cpu_to_le16(len);

#endif

}



/*

 * Hash Tree Directory indexing

 * (c) Daniel Phillips, 2001
@@ -1510,9 +1580,11 @@ extern unsigned ext4_init_block_bitmap(struct super_block *sb, 
		ext4_init_block_bitmap(sb, NULL, group, desc)



/* dir.c */

extern int ext4_check_dir_entry(const char *, struct inode *,

extern int __ext4_check_dir_entry(const char *, unsigned int, struct inode *,

				  struct ext4_dir_entry_2 *,

				  struct buffer_head *, unsigned int);

#define ext4_check_dir_entry(dir, de, bh, offset) \

	__ext4_check_dir_entry(__func__, __LINE__, (dir), (de), (bh), (offset))

extern int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,

				    __u32 minor_hash,

				    struct ext4_dir_entry_2 *dirent);
@@ -1601,8 +1673,6 @@ extern long ext4_compat_ioctl(struct file *, unsigned int, unsigned long); 
extern int ext4_ext_migrate(struct inode *);



/* namei.c */

extern unsigned int ext4_rec_len_from_disk(__le16 dlen, unsigned blocksize);

extern __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize);

extern int ext4_orphan_add(handle_t *, struct inode *);

extern int ext4_orphan_del(handle_t *, struct inode *);

extern int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
@@ -1616,25 +1686,38 @@ extern int ext4_group_extend(struct super_block *sb, 
				ext4_fsblk_t n_blocks_count);



/* super.c */

extern void __ext4_error(struct super_block *, const char *, const char *, ...)

	__attribute__ ((format (printf, 3, 4)));

#define ext4_error(sb, message...)	__ext4_error(sb, __func__, ## message)

extern void ext4_error_inode(const char *, struct inode *, const char *, ...)

	__attribute__ ((format (printf, 3, 4)));

extern void ext4_error_file(const char *, struct file *, const char *, ...)

	__attribute__ ((format (printf, 3, 4)));

extern void __ext4_std_error(struct super_block *, const char *, int);

extern void ext4_abort(struct super_block *, const char *, const char *, ...)

	__attribute__ ((format (printf, 3, 4)));

extern void __ext4_warning(struct super_block *, const char *,

extern void __ext4_error(struct super_block *, const char *, unsigned int,

			 const char *, ...)

	__attribute__ ((format (printf, 3, 4)));

#define ext4_warning(sb, message...)	__ext4_warning(sb, __func__, ## message)

	__attribute__ ((format (printf, 4, 5)));

#define ext4_error(sb, message...)	__ext4_error(sb, __func__,	\

						     __LINE__, ## message)

extern void ext4_error_inode(struct inode *, const char *, unsigned int,

			     ext4_fsblk_t, const char *, ...)

	__attribute__ ((format (printf, 5, 6)));

extern void ext4_error_file(struct file *, const char *, unsigned int,

			    const char *, ...)

	__attribute__ ((format (printf, 4, 5)));

extern void __ext4_std_error(struct super_block *, const char *,

			     unsigned int, int);

extern void __ext4_abort(struct super_block *, const char *, unsigned int,

		       const char *, ...)

	__attribute__ ((format (printf, 4, 5)));

#define ext4_abort(sb, message...)	__ext4_abort(sb, __func__, \

						       __LINE__, ## message)

extern void __ext4_warning(struct super_block *, const char *, unsigned int,

			  const char *, ...)

	__attribute__ ((format (printf, 4, 5)));

#define ext4_warning(sb, message...)	__ext4_warning(sb, __func__, \

						       __LINE__, ## message)

extern void ext4_msg(struct super_block *, const char *, const char *, ...)

	__attribute__ ((format (printf, 3, 4)));

extern void ext4_grp_locked_error(struct super_block *, ext4_group_t,

				const char *, const char *, ...)

	__attribute__ ((format (printf, 4, 5)));

extern void __ext4_grp_locked_error(const char *, unsigned int, \

				    struct super_block *, ext4_group_t, \

				    unsigned long, ext4_fsblk_t, \

				    const char *, ...)

	__attribute__ ((format (printf, 7, 8)));

#define ext4_grp_locked_error(sb, grp, message...) \

	__ext4_grp_locked_error(__func__, __LINE__, (sb), (grp), ## message)

extern void ext4_update_dynamic_rev(struct super_block *sb);

extern int ext4_update_compat_feature(handle_t *handle, struct super_block *sb,

					__u32 compat);
@@ -1768,7 +1851,7 @@ static inline unsigned int ext4_flex_bg_size(struct ext4_sb_info *sbi) 
#define ext4_std_error(sb, errno)				\

do {								\

	if ((errno))						\

		__ext4_std_error((sb), __func__, (errno));	\

		__ext4_std_error((sb), __func__, __LINE__, (errno));	\

} while (0)



#ifdef CONFIG_SMP
@@ -1860,6 +1943,12 @@ static inline void ext4_unlock_group(struct super_block *sb, 
	spin_unlock(ext4_group_lock_ptr(sb, group));

}



static inline void ext4_mark_super_dirty(struct super_block *sb)

{

	if (EXT4_SB(sb)->s_journal == NULL)

		sb->s_dirt =1;

}



/*

 * Inodes and files operations

 */
@@ -1905,9 +1994,6 @@ extern int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset, 
			  ssize_t len);

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

			   struct ext4_map_blocks *map, int flags);

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

			   sector_t block, unsigned int max_blocks,

			   struct buffer_head *bh, int flags);

extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,

			__u64 start, __u64 len);

/* move_extent.c */