Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 (391f2a16) · Commits · 戴 / test

fs/ext4/crypto.c

+2 −4

Original line number	Diff line number	Diff line
		@@ -384,14 +384,12 @@ int ext4_decrypt(struct page *page)
		EXT4_DECRYPT, page->index, page, page);
		}

		int ext4_encrypted_zeroout(struct inode inode, struct ext4_extent ex)
		int ext4_encrypted_zeroout(struct inode *inode, ext4_lblk_t lblk,
		ext4_fsblk_t pblk, ext4_lblk_t len)
		{
		struct ext4_crypto_ctx *ctx;
		struct page *ciphertext_page = NULL;
		struct bio *bio;
		ext4_lblk_t lblk = le32_to_cpu(ex->ee_block);
		ext4_fsblk_t pblk = ext4_ext_pblock(ex);
		unsigned int len = ext4_ext_get_actual_len(ex);
		int ret, err = 0;

		#if 0

fs/ext4/crypto_key.c

+4 −0

Original line number	Diff line number	Diff line
		@@ -213,9 +213,11 @@ retry:
		res = -ENOKEY;
		goto out;
		}
		down_read(&keyring_key->sem);
		ukp = user_key_payload(keyring_key);
		if (ukp->datalen != sizeof(struct ext4_encryption_key)) {
		res = -EINVAL;
		up_read(&keyring_key->sem);
		goto out;
		}
		master_key = (struct ext4_encryption_key *)ukp->data;
		@@ -226,10 +228,12 @@ retry:
		"ext4: key size incorrect: %d\n",
		master_key->size);
		res = -ENOKEY;
		up_read(&keyring_key->sem);
		goto out;
		}
		res = ext4_derive_key_aes(ctx.nonce, master_key->raw,
		raw_key);
		up_read(&keyring_key->sem);
		if (res)
		goto out;
		got_key:

fs/ext4/ext4.h

+86 −13

Original line number	Diff line number	Diff line
		@@ -378,14 +378,22 @@ struct flex_groups {
		#define EXT4_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
		#define EXT4_RESERVED_FL 0x80000000 /* reserved for ext4 lib */

		#define EXT4_FL_USER_VISIBLE 0x004BDFFF /* User visible flags */
		#define EXT4_FL_USER_MODIFIABLE 0x004380FF /* User modifiable flags */
		#define EXT4_FL_USER_VISIBLE 0x304BDFFF /* User visible flags */
		#define EXT4_FL_USER_MODIFIABLE 0x204380FF /* User modifiable flags */

		#define EXT4_FL_XFLAG_VISIBLE (EXT4_SYNC_FL \| \
		EXT4_IMMUTABLE_FL \| \
		EXT4_APPEND_FL \| \
		EXT4_NODUMP_FL \| \
		EXT4_NOATIME_FL \| \
		EXT4_PROJINHERIT_FL)

		/* Flags that should be inherited by new inodes from their parent. */
		#define EXT4_FL_INHERITED (EXT4_SECRM_FL \| EXT4_UNRM_FL \| EXT4_COMPR_FL \|\
		EXT4_SYNC_FL \| EXT4_NODUMP_FL \| EXT4_NOATIME_FL \|\
		EXT4_NOCOMPR_FL \| EXT4_JOURNAL_DATA_FL \|\
		EXT4_NOTAIL_FL \| EXT4_DIRSYNC_FL)
		EXT4_NOTAIL_FL \| EXT4_DIRSYNC_FL \|\
		EXT4_PROJINHERIT_FL)

		/* Flags that are appropriate for regular files (all but dir-specific ones). */
		#define EXT4_REG_FLMASK (~(EXT4_DIRSYNC_FL \| EXT4_TOPDIR_FL))
		@@ -555,10 +563,12 @@ enum {
		#define EXT4_GET_BLOCKS_NO_NORMALIZE 0x0040
		/* Request will not result in inode size update (user for fallocate) */
		#define EXT4_GET_BLOCKS_KEEP_SIZE 0x0080
		/* Do not take i_data_sem locking in ext4_map_blocks */
		#define EXT4_GET_BLOCKS_NO_LOCK 0x0100
		/* Convert written extents to unwritten */
		#define EXT4_GET_BLOCKS_CONVERT_UNWRITTEN 0x0200
		#define EXT4_GET_BLOCKS_CONVERT_UNWRITTEN 0x0100
		/* Write zeros to newly created written extents */
		#define EXT4_GET_BLOCKS_ZERO 0x0200
		#define EXT4_GET_BLOCKS_CREATE_ZERO (EXT4_GET_BLOCKS_CREATE \|\
		EXT4_GET_BLOCKS_ZERO)

		/*
		* The bit position of these flags must not overlap with any of the
		@@ -616,6 +626,46 @@ enum {
		#define EXT4_IOC_GET_ENCRYPTION_PWSALT _IOW('f', 20, __u8[16])
		#define EXT4_IOC_GET_ENCRYPTION_POLICY _IOW('f', 21, struct ext4_encryption_policy)

		#ifndef FS_IOC_FSGETXATTR
		/* Until the uapi changes get merged for project quota... */

		#define FS_IOC_FSGETXATTR _IOR('X', 31, struct fsxattr)
		#define FS_IOC_FSSETXATTR _IOW('X', 32, struct fsxattr)

		/*
		* Structure for FS_IOC_FSGETXATTR and FS_IOC_FSSETXATTR.
		*/
		struct fsxattr {
		__u32 fsx_xflags; /* xflags field value (get/set) */
		__u32 fsx_extsize; /* extsize field value (get/set)*/
		__u32 fsx_nextents; /* nextents field value (get) */
		__u32 fsx_projid; /* project identifier (get/set) */
		unsigned char fsx_pad[12];
		};

		/*
		* Flags for the fsx_xflags field
		*/
		#define FS_XFLAG_REALTIME 0x00000001 /* data in realtime volume */
		#define FS_XFLAG_PREALLOC 0x00000002 /* preallocated file extents */
		#define FS_XFLAG_IMMUTABLE 0x00000008 /* file cannot be modified */
		#define FS_XFLAG_APPEND 0x00000010 /* all writes append */
		#define FS_XFLAG_SYNC 0x00000020 /* all writes synchronous */
		#define FS_XFLAG_NOATIME 0x00000040 /* do not update access time */
		#define FS_XFLAG_NODUMP 0x00000080 /* do not include in backups */
		#define FS_XFLAG_RTINHERIT 0x00000100 /* create with rt bit set */
		#define FS_XFLAG_PROJINHERIT 0x00000200 /* create with parents projid */
		#define FS_XFLAG_NOSYMLINKS 0x00000400 /* disallow symlink creation */
		#define FS_XFLAG_EXTSIZE 0x00000800 /* extent size allocator hint */
		#define FS_XFLAG_EXTSZINHERIT 0x00001000 /* inherit inode extent size */
		#define FS_XFLAG_NODEFRAG 0x00002000 /* do not defragment */
		#define FS_XFLAG_FILESTREAM 0x00004000 /* use filestream allocator */
		#define FS_XFLAG_HASATTR 0x80000000 /* no DIFLAG for this */
		#endif /* !defined(FS_IOC_FSGETXATTR) */

		#define EXT4_IOC_FSGETXATTR FS_IOC_FSGETXATTR
		#define EXT4_IOC_FSSETXATTR FS_IOC_FSSETXATTR

		#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
		/*
		* ioctl commands in 32 bit emulation
		@@ -910,6 +960,15 @@ struct ext4_inode_info {
		* by other means, so we have i_data_sem.
		*/
		struct rw_semaphore i_data_sem;
		/*
		* i_mmap_sem is for serializing page faults with truncate / punch hole
		* operations. We have to make sure that new page cannot be faulted in
		* a section of the inode that is being punched. We cannot easily use
		* i_data_sem for this since we need protection for the whole punch
		* operation and i_data_sem ranks below transaction start so we have
		* to occasionally drop it.
		*/
		struct rw_semaphore i_mmap_sem;
		struct inode vfs_inode;
		struct jbd2_inode *jinode;

		@@ -993,6 +1052,7 @@ struct ext4_inode_info {
		/* Encryption params */
		struct ext4_crypt_info *i_crypt_info;
		#endif
		kprojid_t i_projid;
		};

		/*
		@@ -1248,7 +1308,7 @@ struct ext4_super_block {
		#endif

		/* Number of quota types we support */
		#define EXT4_MAXQUOTAS 2
		#define EXT4_MAXQUOTAS 3

		/*
		* fourth extended-fs super-block data in memory
		@@ -1754,7 +1814,8 @@ EXT4_FEATURE_INCOMPAT_FUNCS(encrypt, ENCRYPT)
		EXT4_FEATURE_RO_COMPAT_HUGE_FILE \|\
		EXT4_FEATURE_RO_COMPAT_BIGALLOC \|\
		EXT4_FEATURE_RO_COMPAT_METADATA_CSUM\|\
		EXT4_FEATURE_RO_COMPAT_QUOTA)
		EXT4_FEATURE_RO_COMPAT_QUOTA \|\
		EXT4_FEATURE_RO_COMPAT_PROJECT)

		#define EXTN_FEATURE_FUNCS(ver) \
		static inline bool ext4_has_unknown_ext##ver##_compat_features(struct super_block *sb) \
		@@ -1796,6 +1857,11 @@ static inline bool ext4_has_incompat_features(struct super_block *sb)
		#define EXT4_DEF_RESUID 0
		#define EXT4_DEF_RESGID 0

		/*
		* Default project ID
		*/
		#define EXT4_DEF_PROJID 0

		#define EXT4_DEF_INODE_READAHEAD_BLKS 32

		/*
		@@ -2234,7 +2300,8 @@ void ext4_restore_control_page(struct page *data_page);
		struct page ext4_encrypt(struct inode inode,
		struct page *plaintext_page);
		int ext4_decrypt(struct page *page);
		int ext4_encrypted_zeroout(struct inode inode, struct ext4_extent ex);
		int ext4_encrypted_zeroout(struct inode *inode, ext4_lblk_t lblk,
		ext4_fsblk_t pblk, ext4_lblk_t len);

		#ifdef CONFIG_EXT4_FS_ENCRYPTION
		int ext4_init_crypto(void);
		@@ -2440,7 +2507,7 @@ struct buffer_head ext4_getblk(handle_t , struct inode *, ext4_lblk_t, int);
		struct buffer_head ext4_bread(handle_t , struct inode *, ext4_lblk_t, int);
		int ext4_get_block_write(struct inode *inode, sector_t iblock,
		struct buffer_head *bh_result, int create);
		int ext4_get_block_dax(struct inode *inode, sector_t iblock,
		int ext4_dax_mmap_get_block(struct inode *inode, sector_t iblock,
		struct buffer_head *bh_result, int create);
		int ext4_get_block(struct inode *inode, sector_t iblock,
		struct buffer_head *bh_result, int create);
		@@ -2484,9 +2551,13 @@ extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
		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);
		extern int ext4_filemap_fault(struct vm_area_struct vma, struct vm_fault vmf);
		extern qsize_t ext4_get_reserved_space(struct inode inode);
		extern int ext4_get_projid(struct inode inode, kprojid_t projid);
		extern void ext4_da_update_reserve_space(struct inode *inode,
		int used, int quota_claim);
		extern int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk,
		ext4_fsblk_t pblk, ext4_lblk_t len);

		/* indirect.c */
		extern int ext4_ind_map_blocks(handle_t handle, struct inode inode,
		@@ -2848,6 +2919,9 @@ static inline int ext4_update_inode_size(struct inode *inode, loff_t newsize)
		return changed;
		}

		int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset,
		loff_t len);

		struct ext4_group_info {
		unsigned long bb_state;
		struct rb_root bb_free_root;
		@@ -2986,8 +3060,7 @@ extern int ext4_da_write_inline_data_end(struct inode *inode, loff_t pos,
		struct page *page);
		extern int ext4_try_add_inline_entry(handle_t *handle,
		struct ext4_filename *fname,
		struct dentry *dentry,
		struct inode *inode);
		struct inode dir, struct inode inode);
		extern int ext4_try_create_inline_dir(handle_t *handle,
		struct inode *parent,
		struct inode *inode);

fs/ext4/extents.c

+83 −70

Original line number	Diff line number	Diff line
		@@ -3119,19 +3119,11 @@ static int ext4_ext_zeroout(struct inode inode, struct ext4_extent ex)
		{
		ext4_fsblk_t ee_pblock;
		unsigned int ee_len;
		int ret;

		ee_len = ext4_ext_get_actual_len(ex);
		ee_pblock = ext4_ext_pblock(ex);

		if (ext4_encrypted_inode(inode))
		return ext4_encrypted_zeroout(inode, ex);

		ret = sb_issue_zeroout(inode->i_sb, ee_pblock, ee_len, GFP_NOFS);
		if (ret > 0)
		ret = 0;

		return ret;
		return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock,
		ee_len);
		}

		/*
		@@ -4052,6 +4044,14 @@ ext4_ext_handle_unwritten_extents(handle_t handle, struct inode inode,
		}
		/* IO end_io complete, convert the filled extent to written */
		if (flags & EXT4_GET_BLOCKS_CONVERT) {
		if (flags & EXT4_GET_BLOCKS_ZERO) {
		if (allocated > map->m_len)
		allocated = map->m_len;
		err = ext4_issue_zeroout(inode, map->m_lblk, newblock,
		allocated);
		if (err < 0)
		goto out2;
		}
		ret = ext4_convert_unwritten_extents_endio(handle, inode, map,
		ppath);
		if (ret >= 0) {
		@@ -4685,10 +4685,6 @@ static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset,
		if (len <= EXT_UNWRITTEN_MAX_LEN)
		flags \|= EXT4_GET_BLOCKS_NO_NORMALIZE;

		/* Wait all existing dio workers, newcomers will block on i_mutex */
		ext4_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);

		/*
		* credits to insert 1 extent into extent tree
		*/
		@@ -4752,8 +4748,6 @@ retry:
		goto retry;
		}

		ext4_inode_resume_unlocked_dio(inode);

		return ret > 0 ? ret2 : ret;
		}

		@@ -4770,7 +4764,6 @@ static long ext4_zero_range(struct file *file, loff_t offset,
		int partial_begin, partial_end;
		loff_t start, end;
		ext4_lblk_t lblk;
		struct address_space *mapping = inode->i_mapping;
		unsigned int blkbits = inode->i_blkbits;

		trace_ext4_zero_range(inode, offset, len, mode);
		@@ -4785,17 +4778,6 @@ static long ext4_zero_range(struct file *file, loff_t offset,
		return ret;
		}

		/*
		* Write out all dirty pages to avoid race conditions
		* Then release them.
		*/
		if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
		ret = filemap_write_and_wait_range(mapping, offset,
		offset + len - 1);
		if (ret)
		return ret;
		}

		/*
		* Round up offset. This is not fallocate, we neet to zero out
		* blocks, so convert interior block aligned part of the range to
		@@ -4839,6 +4821,10 @@ static long ext4_zero_range(struct file *file, loff_t offset,
		if (mode & FALLOC_FL_KEEP_SIZE)
		flags \|= EXT4_GET_BLOCKS_KEEP_SIZE;

		/* Wait all existing dio workers, newcomers will block on i_mutex */
		ext4_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);

		/* Preallocate the range including the unaligned edges */
		if (partial_begin \|\| partial_end) {
		ret = ext4_alloc_file_blocks(file,
		@@ -4847,7 +4833,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
		round_down(offset, 1 << blkbits)) >> blkbits,
		new_size, flags, mode);
		if (ret)
		goto out_mutex;
		goto out_dio;

		}

		@@ -4856,16 +4842,23 @@ static long ext4_zero_range(struct file *file, loff_t offset,
		flags \|= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN \|
		EXT4_EX_NOCACHE);

		/*
		* Prevent page faults from reinstantiating pages we have
		* released from page cache.
		*/
		down_write(&EXT4_I(inode)->i_mmap_sem);
		ret = ext4_update_disksize_before_punch(inode, offset, len);
		if (ret) {
		up_write(&EXT4_I(inode)->i_mmap_sem);
		goto out_dio;
		}
		/* Now release the pages and zero block aligned part of pages */
		truncate_pagecache_range(inode, start, end - 1);
		inode->i_mtime = inode->i_ctime = ext4_current_time(inode);

		/* Wait all existing dio workers, newcomers will block on i_mutex */
		ext4_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);

		ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
		flags, mode);
		up_write(&EXT4_I(inode)->i_mmap_sem);
		if (ret)
		goto out_dio;
		}
		@@ -4998,8 +4991,13 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
		goto out;
		}

		/* Wait all existing dio workers, newcomers will block on i_mutex */
		ext4_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);

		ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
		flags, mode);
		ext4_inode_resume_unlocked_dio(inode);
		if (ret)
		goto out;

		@@ -5494,21 +5492,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
		return ret;
		}

		/*
		* Need to round down offset to be aligned with page size boundary
		* for page size > block size.
		*/
		ioffset = round_down(offset, PAGE_SIZE);

		/* Write out all dirty pages */
		ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
		LLONG_MAX);
		if (ret)
		return ret;

		/* Take mutex lock */
		mutex_lock(&inode->i_mutex);

		/*
		* There is no need to overlap collapse range with EOF, in which case
		* it is effectively a truncate operation
		@@ -5524,17 +5508,43 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
		goto out_mutex;
		}

		truncate_pagecache(inode, ioffset);

		/* Wait for existing dio to complete */
		ext4_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);

		/*
		* Prevent page faults from reinstantiating pages we have released from
		* page cache.
		*/
		down_write(&EXT4_I(inode)->i_mmap_sem);
		/*
		* Need to round down offset to be aligned with page size boundary
		* for page size > block size.
		*/
		ioffset = round_down(offset, PAGE_SIZE);
		/*
		* Write tail of the last page before removed range since it will get
		* removed from the page cache below.
		*/
		ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset);
		if (ret)
		goto out_mmap;
		/*
		* Write data that will be shifted to preserve them when discarding
		* page cache below. We are also protected from pages becoming dirty
		* by i_mmap_sem.
		*/
		ret = filemap_write_and_wait_range(inode->i_mapping, offset + len,
		LLONG_MAX);
		if (ret)
		goto out_mmap;
		truncate_pagecache(inode, ioffset);

		credits = ext4_writepage_trans_blocks(inode);
		handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
		if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out_dio;
		goto out_mmap;
		}

		down_write(&EXT4_I(inode)->i_data_sem);
		@@ -5573,7 +5583,8 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)

		out_stop:
		ext4_journal_stop(handle);
		out_dio:
		out_mmap:
		up_write(&EXT4_I(inode)->i_mmap_sem);
		ext4_inode_resume_unlocked_dio(inode);
		out_mutex:
		mutex_unlock(&inode->i_mutex);
		@@ -5627,21 +5638,7 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
		return ret;
		}

		/*
		* Need to round down to align start offset to page size boundary
		* for page size > block size.
		*/
		ioffset = round_down(offset, PAGE_SIZE);

		/* Write out all dirty pages */
		ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
		LLONG_MAX);
		if (ret)
		return ret;

		/* Take mutex lock */
		mutex_lock(&inode->i_mutex);

		/* Currently just for extent based files */
		if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
		ret = -EOPNOTSUPP;
		@@ -5660,17 +5657,32 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
		goto out_mutex;
		}

		truncate_pagecache(inode, ioffset);

		/* Wait for existing dio to complete */
		ext4_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);

		/*
		* Prevent page faults from reinstantiating pages we have released from
		* page cache.
		*/
		down_write(&EXT4_I(inode)->i_mmap_sem);
		/*
		* Need to round down to align start offset to page size boundary
		* for page size > block size.
		*/
		ioffset = round_down(offset, PAGE_SIZE);
		/* Write out all dirty pages */
		ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
		LLONG_MAX);
		if (ret)
		goto out_mmap;
		truncate_pagecache(inode, ioffset);

		credits = ext4_writepage_trans_blocks(inode);
		handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
		if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out_dio;
		goto out_mmap;
		}

		/* Expand file to avoid data loss if there is error while shifting */
		@@ -5741,7 +5753,8 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)

		out_stop:
		ext4_journal_stop(handle);
		out_dio:
		out_mmap:
		up_write(&EXT4_I(inode)->i_mmap_sem);
		ext4_inode_resume_unlocked_dio(inode);
		out_mutex:
		mutex_unlock(&inode->i_mutex);

fs/ext4/file.c

+58 −24

Original line number	Diff line number	Diff line
		@@ -193,43 +193,35 @@ out:
		}

		#ifdef CONFIG_FS_DAX
		static void ext4_end_io_unwritten(struct buffer_head *bh, int uptodate)
		{
		struct inode *inode = bh->b_assoc_map->host;
		/* XXX: breaks on 32-bit > 16TB. Is that even supported? */
		loff_t offset = (loff_t)(uintptr_t)bh->b_private << inode->i_blkbits;
		int err;
		if (!uptodate)
		return;
		WARN_ON(!buffer_unwritten(bh));
		err = ext4_convert_unwritten_extents(NULL, inode, offset, bh->b_size);
		}

		static int ext4_dax_fault(struct vm_area_struct vma, struct vm_fault vmf)
		{
		int result;
		handle_t *handle = NULL;
		struct super_block *sb = file_inode(vma->vm_file)->i_sb;
		struct inode *inode = file_inode(vma->vm_file);
		struct super_block *sb = inode->i_sb;
		bool write = vmf->flags & FAULT_FLAG_WRITE;

		if (write) {
		sb_start_pagefault(sb);
		file_update_time(vma->vm_file);
		down_read(&EXT4_I(inode)->i_mmap_sem);
		handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
		EXT4_DATA_TRANS_BLOCKS(sb));
		}
		} else
		down_read(&EXT4_I(inode)->i_mmap_sem);

		if (IS_ERR(handle))
		result = VM_FAULT_SIGBUS;
		else
		result = __dax_fault(vma, vmf, ext4_get_block_dax,
		ext4_end_io_unwritten);
		result = __dax_fault(vma, vmf, ext4_dax_mmap_get_block, NULL);

		if (write) {
		if (!IS_ERR(handle))
		ext4_journal_stop(handle);
		up_read(&EXT4_I(inode)->i_mmap_sem);
		sb_end_pagefault(sb);
		}
		} else
		up_read(&EXT4_I(inode)->i_mmap_sem);

		return result;
		}
		@@ -246,44 +238,86 @@ static int ext4_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr,
		if (write) {
		sb_start_pagefault(sb);
		file_update_time(vma->vm_file);
		down_read(&EXT4_I(inode)->i_mmap_sem);
		handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
		ext4_chunk_trans_blocks(inode,
		PMD_SIZE / PAGE_SIZE));
		}
		} else
		down_read(&EXT4_I(inode)->i_mmap_sem);

		if (IS_ERR(handle))
		result = VM_FAULT_SIGBUS;
		else
		result = __dax_pmd_fault(vma, addr, pmd, flags,
		ext4_get_block_dax, ext4_end_io_unwritten);
		ext4_dax_mmap_get_block, NULL);

		if (write) {
		if (!IS_ERR(handle))
		ext4_journal_stop(handle);
		up_read(&EXT4_I(inode)->i_mmap_sem);
		sb_end_pagefault(sb);
		}
		} else
		up_read(&EXT4_I(inode)->i_mmap_sem);

		return result;
		}

		static int ext4_dax_mkwrite(struct vm_area_struct vma, struct vm_fault vmf)
		{
		return dax_mkwrite(vma, vmf, ext4_get_block_dax,
		ext4_end_io_unwritten);
		int err;
		struct inode *inode = file_inode(vma->vm_file);

		sb_start_pagefault(inode->i_sb);
		file_update_time(vma->vm_file);
		down_read(&EXT4_I(inode)->i_mmap_sem);
		err = __dax_mkwrite(vma, vmf, ext4_dax_mmap_get_block, NULL);
		up_read(&EXT4_I(inode)->i_mmap_sem);
		sb_end_pagefault(inode->i_sb);

		return err;
		}

		/*
		* Handle write fault for VM_MIXEDMAP mappings. Similarly to ext4_dax_mkwrite()
		* handler we check for races agaist truncate. Note that since we cycle through
		* i_mmap_sem, we are sure that also any hole punching that began before we
		* were called is finished by now and so if it included part of the file we
		* are working on, our pte will get unmapped and the check for pte_same() in
		* wp_pfn_shared() fails. Thus fault gets retried and things work out as
		* desired.
		*/
		static int ext4_dax_pfn_mkwrite(struct vm_area_struct *vma,
		struct vm_fault *vmf)
		{
		struct inode *inode = file_inode(vma->vm_file);
		struct super_block *sb = inode->i_sb;
		int ret = VM_FAULT_NOPAGE;
		loff_t size;

		sb_start_pagefault(sb);
		file_update_time(vma->vm_file);
		down_read(&EXT4_I(inode)->i_mmap_sem);
		size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;
		if (vmf->pgoff >= size)
		ret = VM_FAULT_SIGBUS;
		up_read(&EXT4_I(inode)->i_mmap_sem);
		sb_end_pagefault(sb);

		return ret;
		}

		static const struct vm_operations_struct ext4_dax_vm_ops = {
		.fault = ext4_dax_fault,
		.pmd_fault = ext4_dax_pmd_fault,
		.page_mkwrite = ext4_dax_mkwrite,
		.pfn_mkwrite = dax_pfn_mkwrite,
		.pfn_mkwrite = ext4_dax_pfn_mkwrite,
		};
		#else
		#define ext4_dax_vm_ops ext4_file_vm_ops
		#endif

		static const struct vm_operations_struct ext4_file_vm_ops = {
		.fault = filemap_fault,
		.fault = ext4_filemap_fault,
		.map_pages = filemap_map_pages,
		.page_mkwrite = ext4_page_mkwrite,
		};

Admin message