Re: [PATCH v7 1/1] f2fs: dax: implement direct access

[Sun Qiuyang]

Hi Jaegeuk,

Thank you for the edits and comments. I will accept them, except that 
f2fs_iomap_end() does not need to return any error. See below for details.

> Hi Qiuyang,
>
> On 07/18, sunqiuyang wrote:
> > From: Qiuyang Sun <sunqiuyang@xxxxxxxxxx>
> >
> > This patch implements Direct Access (DAX) in F2FS, including:
> > - a mount option to choose whether to enable DAX or not
> > - read/write and mmap of regular files in the DAX way
> > - zero-out of unaligned partial blocks in the DAX way
> > - garbage collection of DAX files, by mapping both old and new physical
> >   addresses of a data page into memory and copy data between them directly
> > - incompatibility of DAX with inline data, atomic or volatile write, etc.
> >
> > Signed-off-by: Qiuyang Sun <sunqiuyang@xxxxxxxxxx>
> > ---
> > Changlog v6 -> v7:
> > - Document the mount option "dax" for this feature in f2fs.txt
> > - Minor cleanup in dax_move_data_page()
> >
> > ---
> >  Documentation/filesystems/f2fs.txt |   2 +
> >  fs/f2fs/data.c                     | 132 +++++++++++++++++++++++--
> >  fs/f2fs/f2fs.h                     |   9 ++
> >  fs/f2fs/file.c                     | 192 ++++++++++++++++++++++++++++++++++++-
> >  fs/f2fs/gc.c                       | 105 +++++++++++++++++++-
> >  fs/f2fs/inline.c                   |   4 +
> >  fs/f2fs/inode.c                    |   8 +-
> >  fs/f2fs/namei.c                    |   5 +
> >  fs/f2fs/super.c                    |  15 +++
> >  9 files changed, 459 insertions(+), 13 deletions(-)
> >
> > diff --git a/Documentation/filesystems/f2fs.txt b/Documentation/filesystems/f2fs.txt
> > index 273ccb2..c86c421 100644
> > --- a/Documentation/filesystems/f2fs.txt
> > +++ b/Documentation/filesystems/f2fs.txt
> > @@ -164,6 +164,8 @@ io_bits=%u             Set the bit size of write IO requests. It should be set
> >                         with "mode=lfs".
> >  usrquota               Enable plain user disk quota accounting.
> >  grpquota               Enable plain group disk quota accounting.
> > +dax                    Use direct access (no page cache). See
> > +                       Documentation/filesystems/dax.txt.
> >
> >  ================================================================================
> >  DEBUGFS ENTRIES
> > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> > index 87c1f41..26b908a 100644
> > --- a/fs/f2fs/data.c
> > +++ b/fs/f2fs/data.c
> > @@ -910,6 +910,15 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  				err = -EIO;
> >  				goto sync_out;
> >  			}
> > +			/*
> > +			 * If newly allocated blocks are to be zeroed out later,
> > +			 * a single f2fs_map_blocks must not contain both old
> > +			 * and new blocks at the same time.
> > +			 */
> > +			if (flag == F2FS_GET_BLOCK_ZERO
> > +					&& (map->m_flags & F2FS_MAP_MAPPED)
> > +					&& !(map->m_flags & F2FS_MAP_NEW))
> > +				goto sync_out;
> >  			if (flag == F2FS_GET_BLOCK_PRE_AIO) {
> >  				if (blkaddr == NULL_ADDR) {
> >  					prealloc++;
> > @@ -938,7 +947,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  						blkaddr != NEW_ADDR)
> >  				goto sync_out;
> >  		}
> > -	}
> > +	} else if (flag == F2FS_GET_BLOCK_ZERO && map->m_flags & F2FS_MAP_NEW)
>
> 	} else if () {
> 	}
>
> > +		goto sync_out;
> >
> >  	if (flag == F2FS_GET_BLOCK_PRE_AIO)
> >  		goto skip;
> > @@ -996,6 +1006,12 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  	goto next_dnode;
> >
> >  sync_out:
> > +	if (flag == F2FS_GET_BLOCK_ZERO && map->m_flags & F2FS_MAP_NEW) {
> > +		clean_bdev_aliases(inode->i_sb->s_bdev,
> > +				map->m_pblk, map->m_len);
> > +		err = sb_issue_zeroout(inode->i_sb, map->m_pblk,
> > +				map->m_len, GFP_NOFS);
> > +	}
> >  	f2fs_put_dnode(&dn);
> >  unlock_out:
> >  	if (create) {
> > @@ -1808,16 +1824,19 @@ static int f2fs_write_data_pages(struct address_space *mapping,
> >  	return 0;
> >  }
> >
> > -static void f2fs_write_failed(struct address_space *mapping, loff_t to)
> > +static void f2fs_write_failed(struct address_space *mapping, loff_t to,
> > +								bool lock)
> >  {
> >  	struct inode *inode = mapping->host;
> >  	loff_t i_size = i_size_read(inode);
> >
> >  	if (to > i_size) {
> > -		down_write(&F2FS_I(inode)->i_mmap_sem);
> > +		if (lock)
> > +			down_write(&F2FS_I(inode)->i_mmap_sem);
> >  		truncate_pagecache(inode, i_size);
> >  		truncate_blocks(inode, i_size, true);
> > -		up_write(&F2FS_I(inode)->i_mmap_sem);
> > +		if (lock)
> > +			up_write(&F2FS_I(inode)->i_mmap_sem);
> >  	}
> >  }
> >
> > @@ -2000,7 +2019,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
> >
> >  fail:
> >  	f2fs_put_page(page, 1);
> > -	f2fs_write_failed(mapping, pos + len);
> > +	f2fs_write_failed(mapping, pos + len, true);
> >  	return err;
> >  }
> >
> > @@ -2077,7 +2096,7 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
> >  		if (err > 0)
> >  			set_inode_flag(inode, FI_UPDATE_WRITE);
> >  		else if (err < 0)
> > -			f2fs_write_failed(mapping, offset + count);
> > +			f2fs_write_failed(mapping, offset + count, true);
> >  	}
> >
> >  	trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
> > @@ -2274,3 +2293,104 @@ int f2fs_migrate_page(struct address_space *mapping,
> >  	.migratepage    = f2fs_migrate_page,
> >  #endif
> >  };
> > +
> > +#ifdef CONFIG_FS_DAX
> > +#include <linux/iomap.h>
> > +#include <linux/dax.h>
> > +
> > +static int f2fs_iomap_begin(struct inode *inode, loff_t offset,
> > +	loff_t length, unsigned int flags, struct iomap *iomap)
> > +{
> > +	struct block_device *bdev;
> > +	unsigned long first_block = F2FS_BYTES_TO_BLK(offset);
> > +	unsigned long last_block = F2FS_BYTES_TO_BLK(offset + length - 1);
> > +	struct f2fs_map_blocks map;
> > +	int ret;
> > +
> > +	if (WARN_ON_ONCE(f2fs_has_inline_data(inode)))
> > +		return -ERANGE;
>
> Why not f2fs_convert_inline_inode(inode)?
>
> > +
> > +	map.m_lblk = first_block;
> > +	map.m_len = last_block - first_block + 1;
> > +	map.m_next_pgofs = NULL;
> > +
> > +	if (!(flags & IOMAP_WRITE))
>
> 	if () {
> 		...
> 	} else {
> 		...
> 	}
>
> > +		ret = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_FIEMAP);
> > +	else {
> > +	/* i_size should be kept here and changed later in f2fs_iomap_end */
> > +		loff_t original_i_size = i_size_read(inode);
> > +
> > +		ret = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_ZERO);
> > +		if (i_size_read(inode) > original_i_size) {
> > +			f2fs_i_size_write(inode, original_i_size);
> > +			if (ret)
> > +				f2fs_write_failed(inode->i_mapping,
> > +						offset + length,
> > +						!(flags & IOMAP_FAULT));
> > +		}
> > +	}
> > +
> > +	if (ret)
> > +		return ret;
> > +
> > +	iomap->flags = 0;
> > +	bdev = inode->i_sb->s_bdev;
> > +	iomap->bdev = bdev;
> > +	if (blk_queue_dax(bdev->bd_queue))
> > +		iomap->dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);
> > +	else
> > +		iomap->dax_dev = NULL;
> > +	iomap->offset = F2FS_BLK_TO_BYTES((u64)first_block);
> > +
> > +	if (map.m_len == 0) {
> > +		iomap->type = IOMAP_HOLE;
> > +		iomap->blkno = IOMAP_NULL_BLOCK;
> > +		iomap->length = F2FS_BLKSIZE;
> > +	} else {
> > +		if (map.m_flags & F2FS_MAP_UNWRITTEN)
> > +			iomap->type = IOMAP_UNWRITTEN;
>
> 		if () {
> 			...
> 		} else if {
> 			...
> 		} else {
> 			...
> 		}
>
> > +		else if (map.m_flags & F2FS_MAP_MAPPED)
> > +			iomap->type = IOMAP_MAPPED;
> > +		else {
> > +			WARN_ON_ONCE(1);
> > +			return -EIO;
> > +		}
> > +		iomap->blkno =
> > +			(sector_t)map.m_pblk << F2FS_LOG_SECTORS_PER_BLOCK;
> > +		iomap->length = F2FS_BLK_TO_BYTES((u64)map.m_len);
> > +	}
> > +
> > +	if (map.m_flags & F2FS_MAP_NEW)
> > +		iomap->flags |= IOMAP_F_NEW;
> > +	return 0;
> > +}
> > +
> > +static int f2fs_iomap_end(struct inode *inode, loff_t offset, loff_t length,
> > +	ssize_t written, unsigned int flags, struct iomap *iomap)
> > +{
> > +	put_dax(iomap->dax_dev);
> > +	if (!(flags & IOMAP_WRITE) || (flags & IOMAP_FAULT))
> > +		return 0;
> > +
> > +	if (offset + written > i_size_read(inode))
> > +		f2fs_i_size_write(inode, offset + written);
> > +
> > +	if (iomap->offset + iomap->length >
> > +			ALIGN(i_size_read(inode), F2FS_BLKSIZE)) {
> > +		block_t written_blk = F2FS_BYTES_TO_BLK(offset + written);
> > +		block_t end_blk = F2FS_BYTES_TO_BLK(offset + length);
> > +
> > +		if (written_blk < end_blk)
> > +			f2fs_write_failed(inode->i_mapping, offset + length,
> > +									true);
> > +	}
> > +
> > +	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
>
> Don't we need to return any error, if (written_blk < end_blk) ?

In this patch, f2fs_iomap_end() is called from 3 paths:
1. dax_iomap_rw() => iomap_apply() => iomap_end()
2. iomap_zero_range() => iomap_apply() => iomap_end()
3. dax_iomap_fault() => dax_iomap_[pte|pmd]_fault() => iomap_end()

For 1 & 2: The return value of f2fs_iomap_end() will affect that of 
iomap_apply() only if (written == 0), written being the return value of 
actor(). In that case, no matter f2fs_iomap_end() returns 0 or some 
negative value (error), the return value of iomap_apply() will always be 
<=0, thus making no difference in dax_iomap_rw() or iomap_zero_range(), 
which only checks "if (ret <= 0)".

For 3: the return value of f2fs_iomap_end() is simply discarded.

Therefore, I think we can just return 0 in all situations.

Thanks,

> > +	return 0;
> > +}
> > +
> > +struct iomap_ops f2fs_iomap_ops = {
> > +	.iomap_begin	= f2fs_iomap_begin,
> > +	.iomap_end	= f2fs_iomap_end,
> > +};
> > +#endif
> > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> > index 94a88b2..0bbe011 100644
> > --- a/fs/f2fs/f2fs.h
> > +++ b/fs/f2fs/f2fs.h
> > @@ -91,6 +91,11 @@ struct f2fs_fault_info {
> >  #define F2FS_MOUNT_LFS			0x00040000
> >  #define F2FS_MOUNT_USRQUOTA		0x00080000
> >  #define F2FS_MOUNT_GRPQUOTA		0x00100000
>
> > +#ifdef CONFIG_FS_DAX
> > +#define F2FS_MOUNT_DAX			0x00200000 /* Direct Access */
>
> Could you assign 0x00400000 for upcoming F2FS_MOUNT_PRJQUOTA?
>
> > +#else
> > +#define F2FS_MOUNT_DAX			0
> > +#endif
> >
> >  #define clear_opt(sbi, option)	((sbi)->mount_opt.opt &= ~F2FS_MOUNT_##option)
> >  #define set_opt(sbi, option)	((sbi)->mount_opt.opt |= F2FS_MOUNT_##option)
> > @@ -479,6 +484,7 @@ struct f2fs_map_blocks {
> >  #define F2FS_GET_BLOCK_BMAP		3
> >  #define F2FS_GET_BLOCK_PRE_DIO		4
> >  #define F2FS_GET_BLOCK_PRE_AIO		5
> > +#define F2FS_GET_BLOCK_ZERO		6
> >
> >  /*
> >   * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
> > @@ -2437,6 +2443,9 @@ void f2fs_invalidate_page(struct page *page, unsigned int offset,
> >  int f2fs_migrate_page(struct address_space *mapping, struct page *newpage,
> >  			struct page *page, enum migrate_mode mode);
> >  #endif
> > +#ifdef CONFIG_FS_DAX
> > +extern struct iomap_ops f2fs_iomap_ops;
> > +#endif
> >
> >  /*
> >   * gc.c
> > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> > index a0e6d2c..0e62e97 100644
> > --- a/fs/f2fs/file.c
> > +++ b/fs/f2fs/file.c
> > @@ -23,6 +23,10 @@
> >  #include <linux/uio.h>
> >  #include <linux/uuid.h>
> >  #include <linux/file.h>
> > +#ifdef CONFIG_FS_DAX
> > +#include <linux/dax.h>
> > +#include <linux/iomap.h>
> > +#endif
> >
> >  #include "f2fs.h"
> >  #include "node.h"
> > @@ -121,6 +125,64 @@ static int f2fs_vm_page_mkwrite(struct vm_fault *vmf)
> >  	.page_mkwrite	= f2fs_vm_page_mkwrite,
> >  };
> >
> > +#ifdef CONFIG_FS_DAX
> > +static int f2fs_dax_huge_fault(struct vm_fault *vmf,
> > +	enum page_entry_size pe_size)
> > +{
> > +	int result;
> > +	struct inode *inode = file_inode(vmf->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(vmf->vma->vm_file);
> > +	}
> > +	down_read(&F2FS_I(inode)->i_mmap_sem);
> > +	result = dax_iomap_fault(vmf, pe_size, &f2fs_iomap_ops);
> > +	up_read(&F2FS_I(inode)->i_mmap_sem);
> > +	if (write)
> > +		sb_end_pagefault(sb);
> > +
> > +	return result;
> > +}
> > +
> > +static int f2fs_dax_fault(struct vm_fault *vmf)
> > +{
> > +	return f2fs_dax_huge_fault(vmf, PE_SIZE_PTE);
> > +}
> > +
> > +static int f2fs_dax_pfn_mkwrite(struct vm_fault *vmf)
> > +{
> > +	struct inode *inode = file_inode(vmf->vma->vm_file);
> > +	struct super_block *sb = inode->i_sb;
> > +	loff_t size;
> > +	int ret;
> > +
> > +	sb_start_pagefault(sb);
> > +	file_update_time(vmf->vma->vm_file);
> > +	down_read(&F2FS_I(inode)->i_mmap_sem);
> > +	size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;
> > +	if (vmf->pgoff >= size)
> > +		ret = VM_FAULT_SIGBUS;
> > +	else
> > +		ret = dax_pfn_mkwrite(vmf);
> > +	up_read(&F2FS_I(inode)->i_mmap_sem);
> > +	sb_end_pagefault(sb);
> > +
> > +	return ret;
> > +}
> > +
> > +static const struct vm_operations_struct f2fs_dax_vm_ops = {
> > +	.fault		= f2fs_dax_fault,
> > +	.huge_fault	= f2fs_dax_huge_fault,
> > +	.page_mkwrite	= f2fs_dax_fault,
> > +	.pfn_mkwrite	= f2fs_dax_pfn_mkwrite,
> > +};
> > +#else
> > +#define f2fs_dax_vm_ops f2fs_file_vm_ops
> > +#endif
> > +
> >  static int get_parent_ino(struct inode *inode, nid_t *pino)
> >  {
> >  	struct dentry *dentry;
> > @@ -436,7 +498,13 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
> >  		return err;
> >
> >  	file_accessed(file);
> > -	vma->vm_ops = &f2fs_file_vm_ops;
> > +
> > +	if (IS_DAX(inode)) {
> > +		vma->vm_ops = &f2fs_dax_vm_ops;
> > +		vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
> > +	} else
> > +		vma->vm_ops = &f2fs_file_vm_ops;
> > +
> >  	return 0;
> >  }
> >
> > @@ -519,6 +587,17 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
> >  	if (!offset && !cache_only)
> >  		return 0;
> >
> > +#ifdef CONFIG_FS_DAX
>
> Do we need CONFIG_FS_DAX? If it's not set, it seems IS_DAX() is always false.
>
> > +	if (IS_DAX(inode)) {
> > +		int ret;
> > +
> > +		down_read(&F2FS_I(inode)->dio_rwsem[WRITE]);
> > +		ret = iomap_zero_range(inode, from, PAGE_SIZE - offset,
> > +			NULL, &f2fs_iomap_ops);
> > +		up_read(&F2FS_I(inode)->dio_rwsem[WRITE]);
> > +		return ret;
> > +	}
> > +#endif
> >  	if (cache_only) {
> >  		page = find_lock_page(mapping, index);
> >  		if (page && PageUptodate(page))
> > @@ -799,6 +878,18 @@ static int fill_zero(struct inode *inode, pgoff_t index,
> >  	if (!len)
> >  		return 0;
> >
> > +#ifdef CONFIG_FS_DAX
>
> Ditto.
>
> > +	if (IS_DAX(inode)) {
> > +		int ret;
> > +
> > +		down_read(&F2FS_I(inode)->dio_rwsem[WRITE]);
> > +		ret = iomap_zero_range(inode,
> > +			F2FS_BLK_TO_BYTES((loff_t)index) + start,
> > +			len, NULL, &f2fs_iomap_ops);
> > +		up_read(&F2FS_I(inode)->dio_rwsem[WRITE]);
> > +		return ret;
> > +	}
> > +#endif
> >  	f2fs_balance_fs(sbi, true);
> >
> >  	f2fs_lock_op(sbi);
> > @@ -1121,6 +1212,11 @@ static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
> >  	loff_t new_size;
> >  	int ret;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	/* The current implementation does not apply to DAX files. */
> > +	if (IS_DAX(inode))
> > +		return -EINVAL;
> > +#endif
>
> How about adding f2fs_dax_file()?
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> #ifdef CONFIG_FS_DAX
> #define f2fs_dax_file(inode)	IS_DAX(inode)
> #else
> #define f2fs_dax_file(inode)	false
> #fi
>
> >  	if (offset + len >= i_size_read(inode))
> >  		return -EINVAL;
> >
> > @@ -1311,6 +1407,11 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
> >  	loff_t new_size;
> >  	int ret = 0;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	/* The current implementation does not apply to DAX files. */
> > +	if (IS_DAX(inode))
> > +		return -EINVAL;
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> >  	new_size = i_size_read(inode) + len;
> >  	ret = inode_newsize_ok(inode, new_size);
> >  	if (ret)
> > @@ -1581,6 +1682,10 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
> >  	struct inode *inode = file_inode(filp);
> >  	int ret;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	if (IS_DAX(inode))
> > +		return -EINVAL;
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> >  	if (!inode_owner_or_capable(inode))
> >  		return -EACCES;
> >
> > @@ -1630,6 +1735,9 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
> >  	struct inode *inode = file_inode(filp);
> >  	int ret;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	f2fs_bug_on(F2FS_I_SB(inode), IS_DAX(inode));
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> >  	if (!inode_owner_or_capable(inode))
> >  		return -EACCES;
> >
> > @@ -1666,6 +1774,10 @@ static int f2fs_ioc_start_volatile_write(struct file *filp)
> >  	struct inode *inode = file_inode(filp);
> >  	int ret;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	if (IS_DAX(inode))
> > +		return -EINVAL;
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> >  	if (!inode_owner_or_capable(inode))
> >  		return -EACCES;
> >
> > @@ -1701,6 +1813,9 @@ static int f2fs_ioc_release_volatile_write(struct file *filp)
> >  	struct inode *inode = file_inode(filp);
> >  	int ret;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	f2fs_bug_on(F2FS_I_SB(inode), IS_DAX(inode));
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> >  	if (!inode_owner_or_capable(inode))
> >  		return -EACCES;
> >
> > @@ -1730,6 +1845,9 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
> >  	struct inode *inode = file_inode(filp);
> >  	int ret;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	f2fs_bug_on(F2FS_I_SB(inode), IS_DAX(inode));
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> >  	if (!inode_owner_or_capable(inode))
> >  		return -EACCES;
> >
> > @@ -2144,6 +2262,10 @@ static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
> >  	struct f2fs_defragment range;
> >  	int err;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	if (IS_DAX(inode))
> > +		return -EINVAL;
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return -ENOTSUPP;
>
> >  	if (!capable(CAP_SYS_ADMIN))
> >  		return -EPERM;
> >
> > @@ -2193,6 +2315,10 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
> >  	size_t dst_osize;
> >  	int ret;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	if (IS_DAX(src) || IS_DAX(dst))
> > +		return -EINVAL;
> > +#endif
>
> 	if (f2fs_dax_file(src) || f2fs_dax_file(dst))
> 		return -ENOTSUPP;
>
> >  	if (file_in->f_path.mnt != file_out->f_path.mnt ||
> >  				src->i_sb != dst->i_sb)
> >  		return -EXDEV;
> > @@ -2434,6 +2560,61 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
> >  	}
> >  }
> >
> > +#ifdef CONFIG_FS_DAX
> > +static ssize_t f2fs_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
> > +{
> > +	struct inode *inode = file_inode(iocb->ki_filp);
> > +	ssize_t ret;
> > +
> > +	inode_lock_shared(inode);
> > +
> > +	if (!IS_DAX(inode)) {
> > +		inode_unlock_shared(inode);
> > +		return generic_file_read_iter(iocb, to);
> > +	}
> > +
> > +	down_read(&F2FS_I(inode)->dio_rwsem[READ]);
> > +	ret = dax_iomap_rw(iocb, to, &f2fs_iomap_ops);
> > +	up_read(&F2FS_I(inode)->dio_rwsem[READ]);
> > +	inode_unlock_shared(inode);
> > +
> > +	file_accessed(iocb->ki_filp);
> > +	return ret;
> > +}
>
> How about this?
>
> #ifdef CONFIG_FS_DAX
> static ssize_t f2fs_dax_read_iter()
> {
> 	...
> }
>
> static ssize_t f2fs_dax_write_iter()
> {
> 	...
> }
> #else
> #define f2fs_dax_read_iter	generic_file_read_iter
> #define f2fs_dax_write_iter	__generic_file_write_iter
> #endif
>
> static ssize_t f2fs_file_read_iter()
> {
> 	if (!iov_iter_count(to))
> 		return 0; /* skip atime */
>
> 	if (f2fs_dax_file(iocb->ki_filp))
> 		return f2fs_dax_read_iter(iocb, to);
>
> 	return generic_file_read_iter(iocb, to);
> }
>
> ...
>
> >  static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> >  {
> >  	struct file *file = iocb->ki_filp;
> > @@ -2455,7 +2636,10 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> >  			return err;
> >  		}
> >  		blk_start_plug(&plug);
> > -		ret = __generic_file_write_iter(iocb, from);
> > +		if (IS_DAX(inode))
>
> 		if (f2fs_dax_file(inode))
>
> > +			ret = f2fs_dax_write_iter(iocb, from);
> > +		else
> > +			ret = __generic_file_write_iter(iocb, from);
> >  		blk_finish_plug(&plug);
> >  		clear_inode_flag(inode, FI_NO_PREALLOC);
> >  	}
> > @@ -2504,7 +2688,11 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
> >
> >  const struct file_operations f2fs_file_operations = {
> >  	.llseek		= f2fs_llseek,
>
> Let's just add f2fs_file_read_iter() without CONFIG_FS_DAX.
>
> > +#ifdef CONFIG_FS_DAX
> > +	.read_iter	= f2fs_file_read_iter,
> > +#else
> >  	.read_iter	= generic_file_read_iter,
> > +#endif
> >  	.write_iter	= f2fs_file_write_iter,
> >  	.open		= f2fs_file_open,
> >  	.release	= f2fs_release_file,
> > diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
> > index fa3d2e2..289d748 100644
> > --- a/fs/f2fs/gc.c
> > +++ b/fs/f2fs/gc.c
> > @@ -700,6 +700,101 @@ static void move_encrypted_block(struct inode *inode, block_t bidx,
> >  	f2fs_put_page(page, 1);
> >  }
> >
> > +#ifdef CONFIG_FS_DAX
> > +#include <linux/dax.h>
> > +
> > +static void dax_move_data_page(struct inode *inode, block_t bidx,
> > +				unsigned int segno, int off)
> > +{
> > +	struct block_device *bdev = inode->i_sb->s_bdev;
> > +	struct dax_device *dax_dev;
> > +	struct dnode_of_data dn;
> > +	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> > +	struct f2fs_summary sum;
> > +	struct node_info ni;
> > +	block_t old_blkaddr, new_blkaddr;
> > +	int err, id;
> > +	long map_len;
> > +	pgoff_t pgoff;
> > +	void *kaddr_old, *kaddr_new;
> > +	pfn_t pfn;
> > +
> > +	f2fs_bug_on(sbi, f2fs_is_atomic_file(inode));
> > +
> > +	if (!check_valid_map(sbi, segno, off))
> > +		return;
> > +
> > +	if (!blk_queue_dax(bdev->bd_queue))
>
> 		BUG_ON()?
>
> > +		return;
> > +
> > +	dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);
> > +
> > +	if (!down_write_trylock(&F2FS_I(inode)->i_mmap_sem))
> > +		goto release;
> > +
> > +	unmap_mapping_range(inode->i_mapping, (loff_t)bidx << PAGE_SHIFT,
> > +			PAGE_SIZE, 1);
> > +	/* find the old block address */
> > +	set_new_dnode(&dn, inode, NULL, NULL, 0);
> > +	err = get_dnode_of_data(&dn, bidx, LOOKUP_NODE);
> > +	if (err)
> > +		goto out;
> > +	old_blkaddr = dn.data_blkaddr;
> > +	/* This page is already truncated */
> > +	if (old_blkaddr == NULL_ADDR)
> > +		goto put_dn;
> > +
> > +	/* allocate a new block address */
> > +	get_node_info(sbi, dn.nid, &ni);
> > +	set_summary(&sum, dn.nid, dn.ofs_in_node, ni.version);
> > +	allocate_data_block(sbi, NULL, old_blkaddr, &new_blkaddr,
> > +			&sum, CURSEG_COLD_DATA, NULL, false);
> > +
> > +	/* copy data page from old to new address in dax_bdev */
> > +	id = dax_read_lock();
> > +	err = bdev_dax_pgoff(bdev, SECTOR_FROM_BLOCK(old_blkaddr),
> > +			PAGE_SIZE, &pgoff);
> > +	if (err)
> > +		goto recover;
> > +	map_len = dax_direct_access(dax_dev, pgoff, 1, &kaddr_old, &pfn);
> > +	if (map_len < 0)
> > +		goto recover;
> > +	err = bdev_dax_pgoff(bdev, SECTOR_FROM_BLOCK(new_blkaddr),
> > +			PAGE_SIZE, &pgoff);
> > +	if (err)
> > +		goto recover;
> > +	map_len = dax_direct_access(dax_dev, pgoff, 1, &kaddr_new, &pfn);
> > +	if (map_len < 0)
> > +		goto recover;
> > +	copy_page((void __force *)kaddr_new, (void __force *)kaddr_old);
> > +
> > +	f2fs_update_data_blkaddr(&dn, new_blkaddr);
> > +	set_inode_flag(inode, FI_APPEND_WRITE);
> > +	if (bidx == 0)
> > +		set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
> > +
> > +recover:
> > +	if (err || map_len < 0)
> > +		__f2fs_replace_block(sbi, &sum, new_blkaddr, old_blkaddr,
> > +							true, true);
> > +	dax_read_unlock(id);
> > +put_dn:
> > +	f2fs_put_dnode(&dn);
> > +out:
> > +	unmap_mapping_range(inode->i_mapping, (loff_t)bidx << PAGE_SHIFT,
> > +			PAGE_SIZE, 1);
> > +	up_write(&F2FS_I(inode)->i_mmap_sem);
> > +release:
> > +	put_dax(dax_dev);
> > +}
> > +#else
> > +static void dax_move_data_page(struct inode *inode, block_t bidx,
> > +				unsigned int segno, int off)
> > +{
>
> 	BUG_ON(1);
>
> > +	return;
> > +}
> > +#endif
> > +
> >  static void move_data_page(struct inode *inode, block_t bidx, int gc_type,
> >  							unsigned int segno, int off)
> >  {
> > @@ -818,9 +913,9 @@ static void gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
> >  			if (IS_ERR(inode) || is_bad_inode(inode))
> >  				continue;
> >
> > -			/* if encrypted inode, let's go phase 3 */
> > -			if (f2fs_encrypted_inode(inode) &&
> > -						S_ISREG(inode->i_mode)) {
> > +			/* if DAX or encrypted inode, let's go phase 3 */
> > +			if (IS_DAX(inode) || (f2fs_encrypted_inode(inode) &&
> > +						S_ISREG(inode->i_mode))) {
> >  				add_gc_inode(gc_list, inode);
> >  				continue;
> >  			}
> > @@ -858,7 +953,9 @@ static void gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
> >
> >  			start_bidx = start_bidx_of_node(nofs, inode)
> >  								+ ofs_in_node;
> > -			if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
> > +			if (IS_DAX(inode))
>
> 			if (f2fs_dax_file(inode))
>
> > +				dax_move_data_page(inode, start_bidx, segno, off);
> > +			else if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
> >  				move_encrypted_block(inode, start_bidx, segno, off);
> >  			else
> >  				move_data_page(inode, start_bidx, gc_type, segno, off);
> > diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
> > index e0fd437..fd8b290 100644
> > --- a/fs/f2fs/inline.c
> > +++ b/fs/f2fs/inline.c
> > @@ -28,6 +28,10 @@ bool f2fs_may_inline_data(struct inode *inode)
> >  	if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
> >  		return false;
> >
> > +#ifdef CONFIG_FS_DAX
> > +	if (IS_DAX(inode))
> > +		return false;
> > +#endif
>
> 	if (f2fs_dax_file(inode))
> 		return false;
>
> >  	return true;
> >  }
> >
> > diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
> > index 6cd312a..7741461 100644
> > --- a/fs/f2fs/inode.c
> > +++ b/fs/f2fs/inode.c
> > @@ -43,8 +43,14 @@ void f2fs_set_inode_flags(struct inode *inode)
> >  		new_fl |= S_NOATIME;
> >  	if (flags & FS_DIRSYNC_FL)
> >  		new_fl |= S_DIRSYNC;
> > +#ifdef CONFIG_FS_DAX
> > +	if (test_opt(F2FS_I_SB(inode), DAX) && S_ISREG(inode->i_mode) &&
> > +		!f2fs_has_inline_data(inode) && !f2fs_encrypted_inode(inode) &&
> > +		!f2fs_is_atomic_file(inode) && !f2fs_is_volatile_file(inode))
> > +		new_fl |= S_DAX;
> > +#endif
> >  	inode_set_flags(inode, new_fl,
> > -			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
> > +			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_DAX);
> >  }
> >
> >  static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
> > diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
> > index 760d852..afc52e0 100644
> > --- a/fs/f2fs/namei.c
> > +++ b/fs/f2fs/namei.c
> > @@ -70,6 +70,11 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
> >  	if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode))
> >  		f2fs_set_encrypted_inode(inode);
> >
> > +#ifdef CONFIG_FS_DAX
> > +	if (test_opt(sbi, DAX) && S_ISREG(inode->i_mode) &&
> > +		!f2fs_has_inline_data(inode) && !f2fs_encrypted_inode(inode))
> > +		inode->i_flags |= S_DAX;
> > +#endif
> >  	set_inode_flag(inode, FI_NEW_INODE);
> >
> >  	if (test_opt(sbi, INLINE_XATTR))
> > diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> > index 32e4c02..aefe931 100644
> > --- a/fs/f2fs/super.c
> > +++ b/fs/f2fs/super.c
> > @@ -109,6 +109,7 @@ enum {
> >  	Opt_nolazytime,
> >  	Opt_usrquota,
> >  	Opt_grpquota,
> > +	Opt_dax,
> >  	Opt_err,
> >  };
> >
> > @@ -146,6 +147,7 @@ enum {
> >  	{Opt_nolazytime, "nolazytime"},
> >  	{Opt_usrquota, "usrquota"},
> >  	{Opt_grpquota, "grpquota"},
> > +	{Opt_dax, "dax"},
> >  	{Opt_err, NULL},
> >  };
> >
> > @@ -399,6 +401,15 @@ static int parse_options(struct super_block *sb, char *options)
> >  					"quota operations not supported");
> >  			break;
> >  #endif
> > +#ifdef CONFIG_FS_DAX
> > +		case Opt_dax:
> > +			set_opt(sbi, DAX);
> > +			break;
> > +#else
> > +		case Opt_dax:
> > +			f2fs_msg(sb, KERN_INFO, "dax option not supported");
> > +			break;
> > +#endif
> >  		default:
> >  			f2fs_msg(sb, KERN_ERR,
> >  				"Unrecognized mount option \"%s\" or missing value",
> > @@ -814,6 +825,10 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
> >  	if (test_opt(sbi, GRPQUOTA))
> >  		seq_puts(seq, ",grpquota");
> >  #endif
> > +#ifdef CONFIG_FS_DAX
> > +	if (test_opt(sbi, DAX))
> > +		seq_puts(seq, ",dax");
> > +#endif
> >
> >  	return 0;
> >  }
> > --
> > 1.8.3.1
>
> .