Enable per-file/directory DAX operations V3
Subsystems (12)
v3 cover Enable per-file/directory DAX operations V3
From: Ira Weiny <[email protected]>
Changes from V2:
* Move i_dax_sem to be a global percpu_rw_sem rather than per inode Internal discussions with Dan determined this would be easier, just as performant, and slightly less overhead that having it in the SB as suggested by Jan
* Fix locking order in comments and throughout code
* Change "mode" to "state" throughout commits
* Add CONFIG_FS_DAX wrapper to disable inode_[un]lock_state() when not configured
* Add static branch for which is activated by a device which supports DAX in XFS
* Change "lock/unlock" to up/down read/write as appropriate Previous names were over simplified
* Update comments/documentation
* Remove the xfs specific lock to the vfs (global) layer.
* Fix i_dax_sem locking order and comments
* Move 'i_mapped' count from struct inode to struct address_space and rename it to mmap_count
* Add inode_has_mappings() call
* Fix build issues
* Clean up syntax spacing and minor issues
* Update man page text for STATX_ATTR_DAX
* Add reviewed-by's
* Rebase to latest linux-next
Rename patch:
from: fs/xfs: Add lock/unlock state to xfs
to: fs/xfs: Add write DAX lock to xfs layer
Add patch:
fs/xfs: Clarify lockdep dependency for xfs_isilocked()
Drop patch:
fs/xfs: Fix truncate up
https://github.com/weiny2/linux-kernel/tree/dax-file-state-change-v3
At LSF/MM'19 [1] [2] we discussed applications that overestimate memory consumption due to their inability to detect whether the kernel will instantiate page cache for a file, and cases where a global dax enable via a mount option is too coarse.
The following patch series enables selecting the use of DAX on individual files and/or directories on xfs, and lays some groundwork to do so in ext4. In this scheme the dax mount option can be omitted to allow the per-file property to take effect.
The insight at LSF/MM was to separate the per-mount or per-file "physical" capability switch from an "effective" attribute for the file.
At LSF/MM we discussed the difficulties of switching the DAX state of a file with active mappings / page cache. It was thought the races could be avoided by limiting DAX state flips to 0-length files.
However, this turns out to not be true.[3] This is because address space operations (a_ops) may be in use at any time the inode is referenced and users have expressed a desire to be able to change the DAX state on a file with data in it. For those reasons this patch set allows changing the DAX state flag on a file as long as it is not current mapped.
Furthermore, DAX is a property of the inode and as such, many operations other than address space operations need to be protected during a DAX state change.
Therefore callbacks are placed within the inode operations and used to lock the inode as appropriate.
As in V1, Users are able to query the effective and physical flags separately at any time. Specifically the addition of the statx attribute bit allows them to ensure the file is operating in the DAX state they intend. This 'effective flag' and physical flags could differ when the filesystem is mounted with the dax flag for example.
It should be noted that the physical DAX flag inheritance is not shown in this patch set as it was maintained from previous work on XFS. The physical DAX flag and it's inheritance will need to be added to other file systems for user control.
[1] https://lwn.net/Articles/787973/
[2] https://lwn.net/Articles/787233/
[3] https://lkml.org/lkml/2019/10/20/96
[4] https://patchwork.kernel.org/patch/11310511/
To: [email protected]
Cc: Alexander Viro <[email protected]>
Cc: "Darrick J. Wong" <[email protected]>
Cc: Dan Williams <[email protected]>
Cc: Dave Chinner <[email protected]>
Cc: Christoph Hellwig <[email protected]>
Cc: "Theodore Y. Ts'o" <[email protected]>
Cc: Jan Kara <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Ira Weiny (12):
fs/stat: Define DAX statx attribute
fs/xfs: Isolate the physical DAX flag from effective fs/xfs: Separate functionality of xfs_inode_supports_dax() fs/xfs: Clean up DAX support check
fs: remove unneeded IS_DAX() check
fs/xfs: Check if the inode supports DAX under lock
fs: Add locking for a dynamic DAX state
fs/xfs: Clarify lockdep dependency for xfs_isilocked() fs/xfs: Add write DAX lock to xfs layer
fs: Prevent DAX state change if file is mmap'ed fs/xfs: Clean up locking in dax invalidate fs/xfs: Allow toggle of effective DAX flag
Documentation/filesystems/vfs.rst | 17 ++++++ fs/attr.c | 1 + fs/dax.c | 3 ++ fs/inode.c | 15 ++++-- fs/iomap/buffered-io.c | 1 + fs/open.c | 4 ++ fs/stat.c | 5 ++ fs/super.c | 3 ++ fs/xfs/xfs_inode.c | 24 +++++++-- fs/xfs/xfs_inode.h | 8 ++- fs/xfs/xfs_ioctl.c | 56 ++++++++++++-------- fs/xfs/xfs_iops.c | 51 ++++++++++++++---- fs/xfs/xfs_iops.h | 2 + fs/xfs/xfs_super.c | 16 +++--- include/linux/fs.h | 86 +++++++++++++++++++++++++++++-- include/uapi/linux/stat.h | 1 + mm/fadvise.c | 10 +++- mm/filemap.c | 4 ++ mm/huge_memory.c | 1 + mm/khugepaged.c | 2 + mm/madvise.c | 3 ++ mm/mmap.c | 19 ++++++- mm/util.c | 9 +++- 23 files changed, 287 insertions(+), 54 deletions(-)
Signature · 1 line
2.21.0
PATCH v3 1/12 fs/stat: Define DAX statx attribute
From: Ira Weiny <[email protected]>
In order for users to determine if a file is currently operating in DAX state (effective DAX). Define a statx attribute value and set that attribute if the effective DAX flag is set.
To go along with this we propose the following addition to the statx man page:
STATX_ATTR_DAX
The file is in the DAX (cpu direct access) state. DAX state attempts to minimize software cache effects for both I/O and memory mappings of this file. It requires a file system which has been configured to support DAX.
DAX generally assumes all accesses are via cpu load / store instructions which can minimize overhead for small accesses, but may adversely affect cpu utilization for large transfers.
File I/O is done directly to/from user-space buffers and memory mapped I/O may be performed with direct memory mappings that bypass kernel page cache.
While the DAX property tends to result in data being transferred synchronously, it does not give the same guarantees of O_SYNC where data and the necessary metadata are transferred together.
A DAX file may support being mapped with the MAP_SYNC flag, which enables a program to use CPU cache flush instructions to persist CPU store operations without an explicit fsync(2). See mmap(2) for more information.
---
Changes from V2:
Update man page text with comments from Darrick, Jan, Dan, and Dave.
fs/stat.c | 3 +++ include/uapi/linux/stat.h | 1 + 2 files changed, 4 insertions(+)
fs/stat.c +3 -0
@@ -79,6 +79,9 @@ int vfs_getattr_nosec(const struct path *path, struct kstat *stat,if (IS_AUTOMOUNT (inode)) stat->attributes |=STATX_ATTR_AUTOMOUNT ; +if (IS_DAX (inode)) + stat->attributes |=STATX_ATTR_DAX ; +if (inode->i_op->getattr)return inode->i_op->getattr (path, stat, request_mask, query_flags);
include/uapi/linux/stat.h +1 -0
@@ -169,6 +169,7 @@ struct statx {#define STATX_ATTR_ENCRYPTED 0x00000800/* [I] File requires key to decrypt in fs */ #define STATX_ATTR_AUTOMOUNT 0x00001000/* Dir: Automount trigger */ #define STATX_ATTR_VERITY 0x00100000/* [I] Verity protected file */ +#define STATX_ATTR_DAX 0x00002000/* [I] File is DAX */ #endif /* _UAPI_LINUX_STAT_H */
Signature · 1 line
2.21.0
PATCH v3 2/12 fs/xfs: Isolate the physical DAX flag from effective
In reply to [email protected]From: Ira Weiny <[email protected]>
xfs_ioctl_setattr_dax_invalidate() currently checks if the DAX flag is changing as a quick check.
But the implementation mixes the physical (XFS_DIFLAG2_DAX) and effective (S_DAX) DAX flags.
Remove the use of the effective flag when determining if a change of the physical flag is required.
--- fs/xfs/xfs_ioctl.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/xfs/xfs_ioctl.c +4 -2
@@ -1209,9 +1209,11 @@ xfs_ioctl_setattr_dax_invalidate( }/* If the DAX state is not changing, we have nothing to do here. */ -if ((fa->fsx_xflags &FS_XFLAG_DAX ) &&IS_DAX (inode)) +if ((fa->fsx_xflags &FS_XFLAG_DAX ) && + (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ))return 0 ; -if (!(fa->fsx_xflags &FS_XFLAG_DAX ) && !IS_DAX (inode)) +if (!(fa->fsx_xflags &FS_XFLAG_DAX ) && + !(ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ))return 0 ;if (S_ISDIR (inode->i_mode))
Signature · 1 line
2.21.0
PATCH v3 3/12 fs/xfs: Separate functionality of xfs_inode_supports_dax()
In reply to [email protected]From: Ira Weiny <[email protected]>
xfs_inode_supports_dax() should reflect if the inode can support DAX not that it is enabled for DAX. Leave that to other helper functions.
Change the caller of xfs_inode_supports_dax() to call xfs_inode_use_dax() which reflects new logic to override the effective DAX flag with either the mount option or the physical DAX flag.
To make the logic clear create 2 helper functions for the mount and physical flag.
--- fs/xfs/xfs_iops.c | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-)
fs/xfs/xfs_iops.c +26 -6
@@ -1236,6 +1236,15 @@ static const struct inode_operations xfs_inline_symlink_inode_operations = { .update_time = xfs_vn_update_time, }; +static bool +xfs_inode_mount_is_dax ( +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; + +return (mp->m_flags &XFS_MOUNT_DAX ) ==XFS_MOUNT_DAX ; +} +/* Figure out if this file actually supports DAX. */ static bool xfs_inode_supports_dax(
@@ -1247,11 +1256,6 @@ xfs_inode_supports_dax(if (!S_ISREG (VFS_I (ip)->i_mode) ||xfs_is_reflink_inode (ip))return false; -/* DAX mount option or DAX iflag must be set. */ -if (!(mp->m_flags &XFS_MOUNT_DAX ) && - !(ip->i_d.di_flags2 &XFS_DIFLAG2_DAX )) -return false; -/* Block size must match page size */ if (mp->m_sb.sb_blocksize !=PAGE_SIZE )return false;
@@ -1260,6 +1264,22 @@ xfs_inode_supports_dax(return xfs_inode_buftarg (ip)->bt_daxdev !=NULL ; } +static bool +xfs_inode_is_dax ( +struct xfs_inode *ip) +{ +return (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ) ==XFS_DIFLAG2_DAX ; +} + +static bool +xfs_inode_use_dax ( +struct xfs_inode *ip) +{ +return xfs_inode_supports_dax (ip) && + (xfs_inode_mount_is_dax (ip) || +xfs_inode_is_dax (ip)); +} + STATIC void xfs_diflags_to_iflags( struct inode *inode,
@@ -1278,7 +1298,7 @@ xfs_diflags_to_iflags( inode->i_flags |=S_SYNC ;if (flags &XFS_DIFLAG_NOATIME ) inode->i_flags |=S_NOATIME ; -if (xfs_inode_supports_dax (ip)) +if (xfs_inode_use_dax (ip)) inode->i_flags |=S_DAX ; }
Signature · 1 line
2.21.0
Re: [PATCH v3 03/12] fs/xfs: Separate functionality of xfs_inode_supports_dax()
Quoted 50 lines · On Sat, Feb 08, 2020 at 11:34:36AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
xfs_inode_supports_dax()should reflect if the inode can support DAX not that it is enabled for DAX. Leave that to other helper functions.Change the caller of
xfs_inode_supports_dax()to callxfs_inode_use_dax()which reflects new logic to override the effective DAX flag with either the mount option or the physical DAX flag.To make the logic clear create 2 helper functions for the mount and physical flag.
Signed-off-by Ira Weiny <[email protected]>--- fs/xfs/xfs_iops.c | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-)fs/xfs/xfs_iops.c +9
-5@@ -1236,6 +1236,15 @@ static const struct inode_operations xfs_inline_symlink_inode_operations = { .update_time = xfs_vn_update_time, }; +static bool +xfs_inode_mount_is_dax ( +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; + +return (mp->m_flags &XFS_MOUNT_DAX ) ==XFS_MOUNT_DAX ; +} +/* Figure out if this file actually supports DAX. */ static bool xfs_inode_supports_dax(@@ -1247,11 +1256,6 @@ xfs_inode_supports_dax(if (!S_ISREG (VFS_I (ip)->i_mode) ||xfs_is_reflink_inode (ip))return false; -/* DAX mount option or DAX iflag must be set. */ -if (!(mp->m_flags &XFS_MOUNT_DAX ) && - !(ip->i_d.di_flags2 &XFS_DIFLAG2_DAX )) -return false; -/* Block size must match page size */ if (mp->m_sb.sb_blocksize !=PAGE_SIZE )return false;
fs/xfs/xfs_iops.c xfs_inode_supports_dax( · line 1272
Quoted 9 lines
fs/xfs/xfs_iops.c +6
-0@@ -1260,6 +1264,22 @@ xfs_inode_supports_dax(return xfs_inode_buftarg (ip)->bt_daxdev !=NULL ; } +static bool +xfs_inode_is_dax ( +struct xfs_inode *ip) +{ +return (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ) ==XFS_DIFLAG2_DAX ; +}
I don't think these wrappers add any value at all - the naming of them is entirely confusing, too. e.g. "inode is dax" doesn't tell me that it is checking the on disk flags - it doesn't tell me how it is different to IS_DAX, or why I'd use one versus the other. And then xfs_inode_mount_is_dax() is just... worse.
Naming is hard. :)
fs/xfs/xfs_iops.c xfs_inode_supports_dax( · line 1281
Quoted 9 lines
fs/xfs/xfs_iops.c +9
-0+ +static bool +xfs_inode_use_dax ( +struct xfs_inode *ip) +{ +return xfs_inode_supports_dax (ip) && + (xfs_inode_mount_is_dax (ip) || +xfs_inode_is_dax (ip)); +}
Urk. Naming - we're not "using dax" here, we are checkign to see if we should enable DAX on this inode. IOWs:
static bool
xfs_inode_enable_dax(
struct xfs_inode *ip)
{
if (!xfs_inode_supports_dax(ip))
return false;
if (ip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
return true;
if (ip->i_mount->m_flags & XFS_MOUNT_DAX)
return true;
return false;
}Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 03/12] fs/xfs: Separate functionality of xfs_inode_supports_dax()
Quoted 3 lines · Dave Chinner
Quoted 2 lines · On Sat, Feb 08, 2020 at 11:34:36AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
[snip]
Quoted 14 lines
fs/xfs/xfs_iops.c xfs_inode_supports_dax( · line 1272
Quoted 7 lines
fs/xfs/xfs_iops.c +6
-0+static bool +xfs_inode_is_dax ( +struct xfs_inode *ip) +{ +return (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ) ==XFS_DIFLAG2_DAX ; +}I don't think these wrappers add any value at all - the naming of them is entirely confusing, too. e.g. "inode is dax" doesn't tell me that it is checking the on disk flags - it doesn't tell me how it is different to
IS_DAX, or why I'd use one versus the other. And thenxfs_inode_mount_is_dax()is just... worse.
Quoted 1 line
Naming is hard. :)
Sure... I'm particularly bad as well...
FWIW I don't see how xfs_inode_mount_is_dax() is worse, I rather think that is pretty clear but I'm not going to quibble over names because I know I'm rubbish at it and I'm certainly not enough of a FS person to make them clear... ;-)
Quoted 13 lines
fs/xfs/xfs_iops.c xfs_inode_supports_dax( · line 1281
Quoted 10 lines
fs/xfs/xfs_iops.c +9
-0+ +static bool +xfs_inode_use_dax ( +struct xfs_inode *ip) +{ +return xfs_inode_supports_dax (ip) && + (xfs_inode_mount_is_dax (ip) || +xfs_inode_is_dax (ip)); +}Urk. Naming - we're not "using dax" here, we are checkign to see if we should enable DAX on this inode. IOWs:
Well just to defend myself a little bit. My thought was:
"When setting i_flags, should I use dax?"
Quoted 4 lines
static bool
xfs_inode_enable_dax(
structxfs_inode*ip)
Quoted 10 lines
{
if (!xfs_inode_supports_dax(ip))
return false;
if (ip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
return true;
if (ip->i_mount->m_flags & XFS_MOUNT_DAX)
return true;
return false;
}Anyway, I'm good with this.
Changed for V4.
Thanks!
Ira
Quoted 7 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 4/12 fs/xfs: Clean up DAX support check
In reply to [email protected]From: Ira Weiny <[email protected]>
Rather than open coding xfs_inode_supports_dax() in xfs_ioctl_setattr_dax_invalidate() export xfs_inode_supports_dax() and call it in preparation for swapping dax flags.
This also means updating xfs_inode_supports_dax() to return true for a directory.
--- fs/xfs/xfs_ioctl.c | 16 +++------------- fs/xfs/xfs_iops.c | 8 ++++++-- fs/xfs/xfs_iops.h | 2 ++ 3 files changed, 11 insertions(+), 15 deletions(-)
fs/xfs/xfs_ioctl.c +3 -13
@@ -1190,23 +1190,13 @@ xfs_ioctl_setattr_dax_invalidate( int *join_flags) {struct inode *inode =VFS_I (ip); -struct super_block *sb = inode->i_sb;int error; *join_flags =0 ; -/* -* It is only valid to set the DAX flag on regular files and -* directories on filesystems where the block size is equal to the page -* size. On directories it serves as an inherited hint so we don't -* have to check the device for dax support or flush pagecache. -*/ -if (fa->fsx_xflags &FS_XFLAG_DAX ) { -struct xfs_buftarg *target =xfs_inode_buftarg (ip); - -if (!bdev_dax_supported (target->bt_bdev, sb->s_blocksize)) -return -EINVAL ; - } +if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && + !xfs_inode_supports_dax (ip)) +return -EINVAL ;/* If the DAX state is not changing, we have nothing to do here. */ if ((fa->fsx_xflags & FS_XFLAG_DAX) &&
fs/xfs/xfs_iops.c +6 -2
@@ -1246,14 +1246,18 @@ xfs_inode_mount_is_dax( }/* Figure out if this file actually supports DAX. */ -static bool +bool xfs_inode_supports_dax (struct xfs_inode *ip) {struct xfs_mount *mp = ip->i_mount;/* Only supported on non-reflinked files. */ -if (!S_ISREG (VFS_I (ip)->i_mode) ||xfs_is_reflink_inode (ip)) +if (xfs_is_reflink_inode (ip)) +return false; + +/* Only supported on regular files and directories. */ +if (!(S_ISREG (VFS_I (ip)->i_mode) ||S_ISDIR (VFS_I (ip)->i_mode)))return false;/* Block size must match page size */
fs/xfs/xfs_iops.h +2 -0
@@ -24,4 +24,6 @@ extern int xfs_setattr_nonsize(struct xfs_inode *ip, struct iattr *vap,extern int xfs_vn_setattr_nonsize (struct dentry *dentry,struct iattr *vap);extern int xfs_vn_setattr_size (struct dentry *dentry,struct iattr *vap); +extern bool xfs_inode_supports_dax (struct xfs_inode *ip); +#endif /* __XFS_IOPS_H__ */
Signature · 1 line
2.21.0
Re: [PATCH v3 04/12] fs/xfs: Clean up DAX support check
Quoted 8 lines · On Sat, Feb 08, 2020 at 11:34:37AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
Rather than open coding
xfs_inode_supports_dax()inxfs_ioctl_setattr_dax_invalidate()exportxfs_inode_supports_dax()and call it in preparation for swapping dax flags.This also means updating
xfs_inode_supports_dax()to return true for a directory.
That's not correct. This now means S_DAX gets set on directory inodes because both xfs_inode_supports_dax() and the on-disk inode flag checks return true in xfs_diflags_to_iflags(). Hence when we instantiate a directory inode with a DAX inherit hint set on it we'll set S_DAX on the inode and so IS_DAX() will return true for directory inodes...
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 04/12] fs/xfs: Clean up DAX support check
Quoted 10 lines · Dave Chinner
Quoted 8 lines · On Sat, Feb 08, 2020 at 11:34:37AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
Rather than open coding
xfs_inode_supports_dax()inxfs_ioctl_setattr_dax_invalidate()exportxfs_inode_supports_dax()and call it in preparation for swapping dax flags.This also means updating
xfs_inode_supports_dax()to return true for a directory.
Quoted 6 lines
That's not correct. This now means
S_DAXgets set on directory inodes because bothxfs_inode_supports_dax()and the on-disk inode flag checks return true inxfs_diflags_to_iflags(). Hence when we instantiate a directory inode with a DAX inherit hint set on it we'll setS_DAXon the inode and soIS_DAX()will return true for directory inodes...
I'm not following. Don't we want S_DAX to get set on directory inodes?
IIRC what we wanted was something like this where IS_DAX is the current state and "dax" is the inode flag:
/ <IS_DAX=0 dax=0>
dir1 <IS_DAX=0 dax=0> f0 <IS_DAX=0 dax=0> f1 <IS_DAX=1 dax=1> dir2 <IS_DAX=1 dax=1> f2 <IS_DAX=1 dax=1> f3 <IS_DAX=0 dax=0> dir3 <IS_DAX=1 dax=1> f4 <IS_DAX=1 dax=1> dir4 <IS_DAX=0 dax=0> f5 <IS_DAX=0 dax=0> f6 <IS_DAX=1 dax=1>
Where f1, dir2, f3, and dir4 required explicit state changes when they were created. Because they inherited their dax state from the parent. All the other creations happened based on the DAX state of the parent directory. So we need to store and know the state of the directories. What am I missing?
Ira
Quoted 7 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 04/12] fs/xfs: Clean up DAX support check
Quoted 11 lines · Ira Weiny
Quoted 10 lines · Dave Chinner
Quoted 8 lines · On Sat, Feb 08, 2020 at 11:34:37AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
Rather than open coding
xfs_inode_supports_dax()inxfs_ioctl_setattr_dax_invalidate()exportxfs_inode_supports_dax()and call it in preparation for swapping dax flags.This also means updating
xfs_inode_supports_dax()to return true for a directory.
Quoted 8 lines
Quoted 6 lines
That's not correct. This now means
S_DAXgets set on directory inodes because bothxfs_inode_supports_dax()and the on-disk inode flag checks return true inxfs_diflags_to_iflags(). Hence when we instantiate a directory inode with a DAX inherit hint set on it we'll setS_DAXon the inode and soIS_DAX()will return true for directory inodes...I'm not following. Don't we want
S_DAXto get set on directory inodes?
No, because S_DAX is used for controlling direct user data access, and we *never* let users directly access directory data. Even the filesystems don't access directory data directly - the transactional change model of journaling filesystems requires metadata to be buffered in memory and never directly modified.
Hence when filesystems like ext4 keep their directory data in the page cache, we do not want the kernel to think that this inode is accessed through the DAX subsystem - it is accessed via the buffered IO interfaces like page_cache_sync_readahead() and writeback is controlled by the journal. Hence setting S_DAX on these inodes is incorrect.
Whilst XFS doesn't use the page cache for it's metadata buffering, the issue is the same as it's also a journalling filesystem. hence setting S_DAX on XFS directory inodes is also incorrect.
Quoted 16 lines
IIRC what we wanted was something like this where
IS_DAXis the current state and "dax" is the inode flag:/ <IS_DAX=0 dax=0>
dir1 <IS_DAX=0 dax=0> f0 <IS_DAX=0 dax=0> f1 <IS_DAX=1 dax=1> dir2 <IS_DAX=1 dax=1> f2 <IS_DAX=1 dax=1> f3 <IS_DAX=0 dax=0> dir3 <IS_DAX=1 dax=1> f4 <IS_DAX=1 dax=1> dir4 <IS_DAX=0 dax=0> f5 <IS_DAX=0 dax=0> f6 <IS_DAX=1 dax=1>
Quoted 4 lines
Where f1, dir2, f3, and dir4 required explicit state changes when they were created. Because they inherited their dax state from the parent. All the other creations happened based on the DAX state of the parent directory. So we need to store and know the state of the directories. What am I missing?
I think that you are conflating internal filesystem feature management details (the inheritance of the DAX flag feature of directories) with kernel IO path behaviour (the inode S_DAX flag).
i.e. IS_DAX() indicates whether DAX is _actively being used_ to access the data of a regular file inode, not to indicate whether the on-disk flags used to manage default behaviour are set or not.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 5/12 fs: remove unneeded IS_DAX() check
In reply to [email protected]From: Ira Weiny <[email protected]>
The IS_DAX() check in io_is_direct() causes a race between changing the DAX state and creating the iocb flags.
Remove the check because DAX now emulates the page cache API and therefore it does not matter if the file state is DAX or not when the iocb flags are created.
--- include/linux/fs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
include/linux/fs.h +1 -1
@@ -3388,7 +3388,7 @@ extern int file_update_time(struct file *file);static inline bool io_is_direct (struct file *filp) { -return (filp->f_flags &O_DIRECT ) ||IS_DAX (filp->f_mapping->host); +return (filp->f_flags &O_DIRECT ); }static inline bool vma_is_dax (struct vm_area_struct *vma)
Signature · 1 line
2.21.0
Re: [PATCH v3 05/12] fs: remove unneeded IS_DAX() check
Quoted 8 lines · On Sat, Feb 08, 2020 at 11:34:38AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
The
IS_DAX()check inio_is_direct()causes a race between changing the DAX state and creating the iocb flags.Remove the check because DAX now emulates the page cache API and therefore it does not matter if the file state is DAX or not when the iocb flags are created.
This statement is ... weird.
DAX doesn't "emulate" the page cache API at all - it has it's own read/write methods that filesystems call based on the iomap infrastructure (dax_iomap_rw()). i.e. there are 3 different IO paths through the filesystems: the DAX IO path, the direct IO path, and the buffered IO path.
Indeed, it seems like this works a bit by luck: Ext4 and XFS always check IS_DAX(inode) in the read/write_iter methods before checking for IOCB_DIRECT, and hence the IOCB_DIRECT flag is ignored by the filesystems. i.e. when we got rid of the O_DIRECT paths from DAX, we forgot to clean up io_is_direct() and it's only due to the ordering of checks that we went down the DAX path correctly....
That said, the code change is good, but the commit message needs a rewrite.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Ira Weiny
Reviewed-by Jan KaraRe: [PATCH v3 05/12] fs: remove unneeded IS_DAX() check
Quoted 6 lines · Dave Chinner
Quoted 5 lines · On Sat, Feb 08, 2020 at 11:34:38AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
The
IS_DAX()check inio_is_direct()causes a race between changing the DAX state and creating the iocb flags.
Quoted 7 lines
Quoted 3 lines
Remove the check because DAX now emulates the page cache API and therefore it does not matter if the file state is DAX or not when the iocb flags are created.
This statement is ... weird.
DAX doesn't "emulate" the page cache API at all
ah... yea emulate is a bad word here.
Quoted 13 lines
- it has it's own
read/write methods that filesystems call based on the iomap infrastructure (dax_iomap_rw()). i.e. there are 3 different IO paths through the filesystems: the DAX IO path, the direct IO path, and the buffered IO path.Indeed, it seems like this works a bit by luck: Ext4 and XFS always check
IS_DAX(inode)in the read/write_iter methods before checking forIOCB_DIRECT, and hence theIOCB_DIRECTflag is ignored by the filesystems. i.e. when we got rid of theO_DIRECTpaths from DAX, we forgot to clean upio_is_direct()and it's only due to the ordering of checks that we went down the DAX path correctly....
Quoted 2 lines
That said, the code change is good, but the commit message needs a rewrite.
How about?
<commit msg>
fs: Remove unneeded IS_DAX() check
The IS_DAX() check in io_is_direct() causes a race between changing the DAX state and creating the iocb flags.
Remove the check because DAX now has it's own read/write methods and file systems which support DAX check IS_DAX() prior to IOCB_DIRECT. Therefore, it does not matter if the file state is DAX when the iocb flags are created, and we can avoid the race.
</commit msg>
Ira
Quoted 7 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 05/12] fs: remove unneeded IS_DAX() check
Quoted 33 lines · Ira Weiny
Quoted 6 lines · Dave Chinner
Quoted 5 lines · On Sat, Feb 08, 2020 at 11:34:38AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
The
IS_DAX()check inio_is_direct()causes a race between changing the DAX state and creating the iocb flags.Quoted 7 lines
Quoted 3 lines
Remove the check because DAX now emulates the page cache API and therefore it does not matter if the file state is DAX or not when the iocb flags are created.
This statement is ... weird.
DAX doesn't "emulate" the page cache API at all
ah... yea emulate is a bad word here.
Quoted 13 lines
- it has it's own
read/write methods that filesystems call based on the iomap infrastructure (dax_iomap_rw()). i.e. there are 3 different IO paths through the filesystems: the DAX IO path, the direct IO path, and the buffered IO path.Indeed, it seems like this works a bit by luck: Ext4 and XFS always check
IS_DAX(inode)in the read/write_iter methods before checking forIOCB_DIRECT, and hence theIOCB_DIRECTflag is ignored by the filesystems. i.e. when we got rid of theO_DIRECTpaths from DAX, we forgot to clean upio_is_direct()and it's only due to the ordering of checks that we went down the DAX path correctly....Quoted 2 lines
That said, the code change is good, but the commit message needs a rewrite.
Quoted 7 lines
How about?
<commit msg>
fs: Remove unneededIS_DAX()checkThe
IS_DAX()check inio_is_direct()causes a race between changing the DAX state and creating the iocb flags.
This is irrelevant - the check is simply wrong and has been since ~2016 when we moved DAX to use the iomap infrastructure...
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 05/12] fs: remove unneeded IS_DAX() check
Quoted 36 lines · Dave Chinner
Quoted 35 lines · Ira Weiny
Quoted 6 lines · Dave Chinner
Quoted 5 lines · On Sat, Feb 08, 2020 at 11:34:38AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
The
IS_DAX()check inio_is_direct()causes a race between changing the DAX state and creating the iocb flags.Quoted 7 lines
Quoted 3 lines
Remove the check because DAX now emulates the page cache API and therefore it does not matter if the file state is DAX or not when the iocb flags are created.
This statement is ... weird.
DAX doesn't "emulate" the page cache API at all
ah... yea emulate is a bad word here.
Quoted 13 lines
- it has it's own
read/write methods that filesystems call based on the iomap infrastructure (dax_iomap_rw()). i.e. there are 3 different IO paths through the filesystems: the DAX IO path, the direct IO path, and the buffered IO path.Indeed, it seems like this works a bit by luck: Ext4 and XFS always check
IS_DAX(inode)in the read/write_iter methods before checking forIOCB_DIRECT, and hence theIOCB_DIRECTflag is ignored by the filesystems. i.e. when we got rid of theO_DIRECTpaths from DAX, we forgot to clean upio_is_direct()and it's only due to the ordering of checks that we went down the DAX path correctly....Quoted 2 lines
That said, the code change is good, but the commit message needs a rewrite.
How about?
Quoted 8 lines
Quoted 5 lines
<commit msg>
fs: Remove unneededIS_DAX()checkThe
IS_DAX()check inio_is_direct()causes a race between changing the DAX state and creating the iocb flags.This is irrelevant - the check is simply wrong and has been since ~2016 when we moved DAX to use the iomap infrastructure...
Deleted.
Ira
Quoted 8 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 6/12 fs/xfs: Check if the inode supports DAX under lock
In reply to [email protected]From: Ira Weiny <[email protected]>
One of the checks for an inode supporting DAX is if the inode is reflinked. During a non-DAX to DAX state change we could race with the file being reflinked and end up with a reflinked file being in DAX state.
Prevent this race by checking for DAX support under the MMAP_LOCK.
--- fs/xfs/xfs_ioctl.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
fs/xfs/xfs_ioctl.c +7 -4
@@ -1194,10 +1194,6 @@ xfs_ioctl_setattr_dax_invalidate( *join_flags =0 ; -if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && - !xfs_inode_supports_dax (ip)) -return -EINVAL ; -/* If the DAX state is not changing, we have nothing to do here. */ if ((fa->fsx_xflags &FS_XFLAG_DAX ) && (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ))
@@ -1211,6 +1207,13 @@ xfs_ioctl_setattr_dax_invalidate(/* lock, flush and invalidate mapping in preparation for flag change */ xfs_ilock (ip,XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ); + +if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && + !xfs_inode_supports_dax (ip)) { + error = -EINVAL ; + goto out_unlock; + } + error =filemap_write_and_wait (inode->i_mapping);if (error) goto out_unlock;
Signature · 1 line
2.21.0
Re: [PATCH v3 06/12] fs/xfs: Check if the inode supports DAX under lock
Quoted 8 lines · On Sat, Feb 08, 2020 at 11:34:39AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
One of the checks for an inode supporting DAX is if the inode is reflinked. During a non-DAX to DAX state change we could race with the file being reflinked and end up with a reflinked file being in DAX state.
Prevent this race by checking for DAX support under the
MMAP_LOCK.
The on disk inode flags are protected by the XFS_ILOCK, not the MMAP_LOCK. i.e. the MMAPLOCK provides data access serialisation, not metadata modification serialisation.
Quoted 22 lines
Signed-off-by Ira Weiny <[email protected]>--- fs/xfs/xfs_ioctl.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)fs/xfs/xfs_ioctl.c +0
-4@@ -1194,10 +1194,6 @@ xfs_ioctl_setattr_dax_invalidate( *join_flags =0 ; -if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && - !xfs_inode_supports_dax (ip)) -return -EINVAL ; -/* If the DAX state is not changing, we have nothing to do here. */ if ((fa->fsx_xflags &FS_XFLAG_DAX ) && (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ))
fs/xfs/xfs_ioctl.c xfs_ioctl_setattr_dax_invalidate( · line 1215
Quoted 9 lines
fs/xfs/xfs_ioctl.c +6
-0@@ -1211,6 +1207,13 @@ xfs_ioctl_setattr_dax_invalidate(/* lock, flush and invalidate mapping in preparation for flag change */ xfs_ilock (ip,XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ); + +if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && + !xfs_inode_supports_dax (ip)) { + error = -EINVAL ; + goto out_unlock; + }
Yes, you might be able to get away with reflink vs dax flag serialisation on the inode flag modification, but it is not correct and leaves a landmine for future inode flag modifications that are done without holding either the MMAP or IOLOCK.
e.g. concurrent calls to xfs_ioctl_setattr() setting/clearing flags other than the on disk DAX flag are all serialised by the ILOCK_EXCL and will no be serialised against this DAX check. Hence if there are other flags that we add in future that affect the result of xfs_inode_supports_dax(), this code will not be correctly serialised.
This raciness in checking the DAX flags is the reason that xfs_ioctl_setattr_xflags() redoes all the reflink vs dax checks once it's called under the XFS_ILOCK_EXCL during the actual change transaction....
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 06/12] fs/xfs: Check if the inode supports DAX under lock
Quoted 8 lines · Dave Chinner
Quoted 7 lines · On Sat, Feb 08, 2020 at 11:34:39AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
One of the checks for an inode supporting DAX is if the inode is reflinked. During a non-DAX to DAX state change we could race with the file being reflinked and end up with a reflinked file being in DAX state.
Quoted 5 lines
Quoted 1 line
Prevent this race by checking for DAX support under the
MMAP_LOCK.The on disk inode flags are protected by the
XFS_ILOCK, not theMMAP_LOCK. i.e. the MMAPLOCK provides data access serialisation, not metadata modification serialisation.
Ah...
Quoted 45 lines
Quoted 23 lines
Signed-off-by Ira Weiny <[email protected]>--- fs/xfs/xfs_ioctl.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)fs/xfs/xfs_ioctl.c +0
-4@@ -1194,10 +1194,6 @@ xfs_ioctl_setattr_dax_invalidate( *join_flags =0 ; -if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && - !xfs_inode_supports_dax (ip)) -return -EINVAL ; -/* If the DAX state is not changing, we have nothing to do here. */ if ((fa->fsx_xflags &FS_XFLAG_DAX ) && (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ))fs/xfs/xfs_ioctl.c xfs_ioctl_setattr_dax_invalidate( · line 1215
Quoted 9 lines
fs/xfs/xfs_ioctl.c +6
-0@@ -1211,6 +1207,13 @@ xfs_ioctl_setattr_dax_invalidate(/* lock, flush and invalidate mapping in preparation for flag change */ xfs_ilock (ip,XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ); + +if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && + !xfs_inode_supports_dax (ip)) { + error = -EINVAL ; + goto out_unlock; + }Yes, you might be able to get away with reflink vs dax flag serialisation on the inode flag modification, but it is not correct and leaves a landmine for future inode flag modifications that are done without holding either the MMAP or IOLOCK.
e.g. concurrent calls to
xfs_ioctl_setattr()setting/clearing flags other than the on disk DAX flag are all serialised by theILOCK_EXCLand will no be serialised against this DAX check. Hence if there are other flags that we add in future that affect the result ofxfs_inode_supports_dax(), this code will not be correctly serialised.
Quoted 4 lines
This raciness in checking the DAX flags is the reason that
xfs_ioctl_setattr_xflags()redoes all the reflink vs dax checks once it's called under theXFS_ILOCK_EXCLduring the actual change transaction....
Ok I found this by trying to make sure that the xfs_inode_supports_dax() call was always returning valid data. So I don't have a specific test which was failing.
Looking at the code again, it sounds like I was wrong about which locks protect what and with your explanation above it looks like there is nothing to be done here and I can drop the patch.
Would you agree?
Thanks for the review!
Ira
Quoted 7 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 06/12] fs/xfs: Check if the inode supports DAX under lock
Quoted 71 lines · Ira Weiny
Quoted 8 lines · Dave Chinner
Quoted 7 lines · On Sat, Feb 08, 2020 at 11:34:39AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
One of the checks for an inode supporting DAX is if the inode is reflinked. During a non-DAX to DAX state change we could race with the file being reflinked and end up with a reflinked file being in DAX state.
Quoted 5 lines
Quoted 1 line
Prevent this race by checking for DAX support under the
MMAP_LOCK.The on disk inode flags are protected by the
XFS_ILOCK, not theMMAP_LOCK. i.e. the MMAPLOCK provides data access serialisation, not metadata modification serialisation.Ah...
Quoted 45 lines
Quoted 23 lines
Signed-off-by Ira Weiny <[email protected]>--- fs/xfs/xfs_ioctl.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)fs/xfs/xfs_ioctl.c +0
-4@@ -1194,10 +1194,6 @@ xfs_ioctl_setattr_dax_invalidate( *join_flags =0 ; -if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && - !xfs_inode_supports_dax (ip)) -return -EINVAL ; -/* If the DAX state is not changing, we have nothing to do here. */ if ((fa->fsx_xflags &FS_XFLAG_DAX ) && (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ))fs/xfs/xfs_ioctl.c xfs_ioctl_setattr_dax_invalidate( · line 1215
Quoted 9 lines
fs/xfs/xfs_ioctl.c +6
-0@@ -1211,6 +1207,13 @@ xfs_ioctl_setattr_dax_invalidate(/* lock, flush and invalidate mapping in preparation for flag change */ xfs_ilock (ip,XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ); + +if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && + !xfs_inode_supports_dax (ip)) { + error = -EINVAL ; + goto out_unlock; + }Yes, you might be able to get away with reflink vs dax flag serialisation on the inode flag modification, but it is not correct and leaves a landmine for future inode flag modifications that are done without holding either the MMAP or IOLOCK.
e.g. concurrent calls to
xfs_ioctl_setattr()setting/clearing flags other than the on disk DAX flag are all serialised by theILOCK_EXCLand will no be serialised against this DAX check. Hence if there are other flags that we add in future that affect the result ofxfs_inode_supports_dax(), this code will not be correctly serialised.Quoted 4 lines
This raciness in checking the DAX flags is the reason that
xfs_ioctl_setattr_xflags()redoes all the reflink vs dax checks once it's called under theXFS_ILOCK_EXCLduring the actual change transaction....Ok I found this by trying to make sure that the
xfs_inode_supports_dax()call was always returning valid data. So I don't have a specific test which was failing.
Quoted 5 lines
Looking at the code again, it sounds like I was wrong about which locks protect what and with your explanation above it looks like there is nothing to be done here and I can drop the patch.
Would you agree?
*nod*
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 06/12] fs/xfs: Check if the inode supports DAX under lock
Quoted 5 lines · Dave Chinner
Quoted 4 lines · Ira Weiny
Quoted 3 lines · Dave Chinner
Quoted 2 lines · On Sat, Feb 08, 2020 at 11:34:39AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
[snip]
Quoted 10 lines
Quoted 10 lines
Quoted 5 lines
This raciness in checking the DAX flags is the reason that
xfs_ioctl_setattr_xflags()redoes all the reflink vs dax checks once it's called under theXFS_ILOCK_EXCLduring the actual change transaction....Ok I found this by trying to make sure that the
xfs_inode_supports_dax()call was always returning valid data. So I don't have a specific test which was failing.
Quoted 7 lines
Quoted 5 lines
Looking at the code again, it sounds like I was wrong about which locks protect what and with your explanation above it looks like there is nothing to be done here and I can drop the patch.
Would you agree?
*nod*
Thanks! done.
Ira
Quoted 7 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH v3 7/12 fs: Add locking for a dynamic DAX state
In reply to [email protected]From: Ira Weiny <[email protected]>
DAX requires special address space operations but many other functions check the IS_DAX() state.
While DAX is a property of the inode we perfer a lock at the super block level because of the overhead of a rwsem within the inode.
Define a vfs per superblock percpu rs semaphore to lock the DAX state while performing various VFS layer operations. Write lock calls are provided here but are used in subsequent patches by the file systems themselves.
---
Changes from V2
Rebase on linux-next-08-02-2020
Fix locking order
Change all references from mode to state where appropriate add CONFIG_FS_DAX requirement for state change
Use a static branch to enable locking only when a dax capable
device has been seen.
Move the lock to a global vfs lock
this does a few things
1) preps us better for ext4 support
2) removes funky callbacks from inode ops
3) remove complexity from XFS and probably from ext4 later
We can do this because
1) the locking order is required to be at the highest level anyway, so why complicate xfs
2) We had to move the sem to the super_block because it is too heavy for the inode.
3) After internal discussions with Dan we decided that this would be easier, just as performant, and with slightly less overhead than in the VFS SB.
We also change the functions names to up/down; read/write as appropriate. Previous names were over simplified.
Update comments and documentation
Documentation/filesystems/vfs.rst | 17 +++++++ fs/attr.c | 1 + fs/dax.c | 3 ++ fs/inode.c | 14 ++++-- fs/iomap/buffered-io.c | 1 + fs/open.c | 4 ++ fs/stat.c | 2 + fs/super.c | 3 ++ include/linux/fs.h | 78 ++++++++++++++++++++++++++++++- mm/fadvise.c | 10 +++- mm/filemap.c | 4 ++ mm/huge_memory.c | 1 + mm/khugepaged.c | 2 + mm/madvise.c | 3 ++ mm/util.c | 9 +++- 15 files changed, 144 insertions(+), 8 deletions(-)
Documentation/filesystems/vfs.rst +17 -0
@@ -934,6 +934,23 @@ cache in your filesystem. The following members are defined: Called during swapoff on files where swap_activate was successful. +Changing DAX 'state' dynamically +---------------------------------- + +Some file systems which support DAX want to be able to change the DAX state +dyanically. To switch the state safely we lock the inode state in all "normal" +file system operations and restrict state changes to those operations. The +specific rules are. + + 1) the direct_IO address_space_operation must be supported in all + potential a_ops vectors for any state suported by the inode. + 2) FS's should enable the static branch lock_dax_state_static_key when a DAX + capable device is detected. + 3) DAX state changes shall not be allowed while the file is mmap'ed + 4) For non-mmaped operations the VFS layer must take the read lock for any + use of IS_DAX() + 5) Filesystems take the write lock when changing DAX states. + The File Object ===============
fs/attr.c +1 -0
@@ -332,6 +332,7 @@ int notify_change(struct dentry * dentry, struct iattr * attr, struct inode **deif (error)return error; +/* DAX read state should already be held here */ if (inode->i_op->setattr) error = inode->i_op->setattr (dentry, attr);else
fs/dax.c +3 -0
@@ -30,6 +30,9 @@#define CREATE_TRACE_POINTS #include <trace/events/fs_dax.h> +DEFINE_STATIC_KEY_FALSE (lock_dax_state_static_key); +EXPORT_SYMBOL (lock_dax_state_static_key); +static inline unsigned int pe_order (enum page_entry_size pe_size) {if (pe_size ==PE_SIZE_PTE )
fs/inode.c +11 -3
@@ -1616,11 +1616,19 @@ EXPORT_SYMBOL(iput);*/ int bmap (struct inode *inode,sector_t *block) { -if (!inode->i_mapping->a_ops->bmap) -return -EINVAL ; +int ret =0 ; + +inode_dax_state_down_read (inode); +if (!inode->i_mapping->a_ops->bmap) { + ret = -EINVAL ; + goto err; + } *block = inode->i_mapping->a_ops->bmap (inode->i_mapping, *block); -return 0 ; + +err: +inode_dax_state_up_read (inode); +return ret; }EXPORT_SYMBOL (bmap);#endif
fs/iomap/buffered-io.c +1 -0
@@ -999,6 +999,7 @@ iomap_zero_range_actor(struct inode *inode, loff_t pos, loff_t count, offset =offset_in_page (pos); bytes =min_t (loff_t,PAGE_SIZE - offset, count); +/* DAX state read should already be held here */ if (IS_DAX (inode)) status =iomap_dax_zero (pos, offset, bytes, iomap);else
fs/open.c +4 -0
@@ -59,10 +59,12 @@ int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,if (ret) newattrs.ia_valid |= ret |ATTR_FORCE ; +inode_dax_state_down_read (dentry->d_inode);inode_lock (dentry->d_inode);/* Note any delegations or leases have already been broken: */ ret =notify_change (dentry, &newattrs,NULL );inode_unlock (dentry->d_inode); +inode_dax_state_up_read (dentry->d_inode);return ret; }
@@ -306,7 +308,9 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)return -EOPNOTSUPP ;file_start_write (file); +inode_dax_state_down_read (inode); ret = file->f_op->fallocate (file, mode, offset, len); +inode_dax_state_up_read (inode);/* * Create inotify and fanotify events.
fs/stat.c +2 -0
@@ -79,8 +79,10 @@ int vfs_getattr_nosec(const struct path *path, struct kstat *stat,if (IS_AUTOMOUNT (inode)) stat->attributes |=STATX_ATTR_AUTOMOUNT ; +inode_dax_state_down_read (inode);if (IS_DAX (inode)) stat->attributes |=STATX_ATTR_DAX ; +inode_dax_state_up_read (inode);if (inode->i_op->getattr) return inode->i_op->getattr(path, stat, request_mask,
fs/super.c +3 -0
@@ -51,6 +51,9 @@ static char *sb_writers_name[SB_FREEZE_LEVELS] = { "sb_internal", }; +DEFINE_PERCPU_RWSEM (sb_dax_rwsem); +EXPORT_SYMBOL (sb_dax_rwsem); +/* * One thing we have to be careful of with a per-sb shrinker is that we don't * drop the last active reference to the superblock from within the shrinker.
include/linux/fs.h +76 -2
110 lines not on this page · raw message
mm/fadvise.c +8 -2
@@ -47,7 +47,10 @@ int generic_fadvise(struct file *file, loff_t offset, loff_t len, int advice) bdi =inode_to_bdi (mapping->host); +inode_dax_state_down_read (inode);if (IS_DAX (inode) || (bdi == &noop_backing_dev_info)) { +int ret =0 ; +switch (advice) {case POSIX_FADV_NORMAL :case POSIX_FADV_RANDOM :
@@ -58,10 +61,13 @@ int generic_fadvise(struct file *file, loff_t offset, loff_t len, int advice)/* no bad return value, but ignore advice */ break ;default : -return -EINVAL ; + ret = -EINVAL ; } -return 0 ; + +inode_dax_state_up_read (inode); +return ret; } +inode_dax_state_up_read (inode);/* * Careful about overflows. Len == 0 means "as much as possible". Use
mm/filemap.c +4 -0
@@ -2293,6 +2293,8 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)* and return. Otherwise fallthrough to buffered io for * the rest of the read. Buffered reads will not work for * DAX files, so don't bother trying. +* +* IS_DAX is protected under ->read_iter lock */ if (retval <0 || !count || iocb->ki_pos >= size ||IS_DAX (inode))
@@ -3377,6 +3379,8 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)* holes, for example. For DAX files, a buffered write will * not succeed (even if it did, DAX does not handle dirty * page-cache pages correctly). +* +* IS_DAX is protected under ->write_iter lock */ if (written <0 || !iov_iter_count (from) ||IS_DAX (inode)) goto out;
mm/huge_memory.c +1 -0
@@ -572,6 +572,7 @@ unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,unsigned long ret;loff_t off = (loff_t )pgoff <<PAGE_SHIFT ; +/* Should not need locking here because mmap is not allowed */ if (!IS_DAX (filp->f_mapping->host) || !IS_ENABLED (CONFIG_FS_DAX_PMD )) goto out;
mm/khugepaged.c +2 -0
@@ -1592,9 +1592,11 @@ static void collapse_file(struct mm_struct *mm, }else {/* !is_shmem */ if (!page ||xa_is_value (page)) {xas_unlock_irq (&xas); +inode_dax_state_down_read (file->f_inode);page_cache_sync_readahead (mapping, &file->f_ra, file, index,PAGE_SIZE ); +inode_dax_state_up_read (file->f_inode);/* drain pagevecs to help isolate_lru_page() */ lru_add_drain (); page =find_lock_page (mapping, index);
mm/madvise.c +3 -0
@@ -275,10 +275,13 @@ static long madvise_willneed(struct vm_area_struct *vma,return -EBADF ;#endif +inode_dax_state_down_read (file_inode (file));if (IS_DAX (file_inode (file))) { +inode_dax_state_up_read (file_inode (file));/* no bad return value, but ignore advice */ return 0 ; } +inode_dax_state_up_read (file_inode (file));/* * Filesystem's fadvise may need to take various locks. We need to
mm/util.c +8 -1
@@ -501,11 +501,18 @@ unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr, ret =security_mmap_file (file, prot, flag);if (!ret) { -if (down_write_killable (&mm->mmap_sem)) +if (file) +inode_dax_state_down_read (file_inode (file)); +if (down_write_killable (&mm->mmap_sem)) { +if (file) +inode_dax_state_up_read (file_inode (file));return -EINTR ; + } ret =do_mmap_pgoff (file, addr, len, prot, flag, pgoff, &populate, &uf);up_write (&mm->mmap_sem); +if (file) +inode_dax_state_up_read (file_inode (file));userfaultfd_unmap_complete (mm, &uf);if (populate)mm_populate (ret, populate);
Signature · 1 line
2.21.0
Re: [PATCH v3 07/12] fs: Add locking for a dynamic DAX state
Quoted 9 lines · On Sat, Feb 08, 2020 at 11:34:40AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
DAX requires special address space operations but many other functions check the
IS_DAX()state.While DAX is a property of the inode we perfer a lock at the super block level because of the overhead of a rwsem within the inode.
Define a vfs per superblock percpu rs semaphore to lock the DAX state
????
Quoted 35 lines
while performing various VFS layer operations. Write lock calls are provided here but are used in subsequent patches by the file systems themselves.
Signed-off-by Ira Weiny <[email protected]>---
Changes from V2Rebase on linux-next-08-02-2020
Fix locking order
Change all references from mode to state where appropriate addCONFIG_FS_DAXrequirement for state change
Use a static branch to enable locking only when a dax capable
device has been seen.Move the lock to a global vfs lock
this does a few things
1) preps us better for ext4 support
2) removes funky callbacks from inode ops
3) remove complexity from XFS and probably from ext4 laterWe can do this because
1) the locking order is required to be at the highest level anyway, so why complicate xfs
2) We had to move the sem to thesuper_blockbecause it is too heavy for the inode.
3) After internal discussions with Dan we decided that this would be easier, just as performant, and with slightly less overhead than in the VFS SB.
Quoted 3 lines
We also change the functions names to up/down; read/write as appropriate. Previous names were over simplified.
This, IMO, is a bit of a train wreck.
This patch has nothing to do with "DAX state", it's about serialising access to the aops vector. There should be zero references to DAX in this patch at all, except maybe to say "switching DAX on dynamically requires atomic switching of address space ops".
Big problems I see here:
1. static key to turn it on globally.
- just a gross hack around doing it properly with a per-sb mechanism and enbaling it only on filesystems that are on DAX capable block devices.
- you're already passing in an inode to all these functions. It's
trivial to do: if (!inode->i_sb->s_flags & S_DYNAMIC_AOPS) return /* do sb->s_aops_lock manipulation */
2. global lock
- OMG!
- global lock will cause entire system IO/page fault stalls when someone does recursive/bulk DAX flag modification operations. Per-cpu rwsem Contention on large systems will be utterly awful.
- ext4's use case almost never hits the exclusive lock side of the percpu-rwsem - only when changing the journal mode flag on the inode. And it only affects writeback in progress, so it's not going to have massive concurrency on it like a VFS level global lock has. -> Bad model to follow.
- per-sb lock is trivial - see #1 - which limits scope to single filesystem
- per-inode rwsem would make this problem go away entirely.
3. If we can use a global per-cpu rwsem, why can't we just use a per-inode rwsem?
- locking context rules are the same
- rwsem scales pretty damn well for shared ops
- no "global" contention problems
- small enough that we can put another rwsem in the inode.
4. "inode_dax_state_up_read"
- Eye bleeds.
- this is about the aops structure serialisation, not dax.
- The name makes no sense in the places that it has been added.
5. We already have code that does almost exactly what we need: the superblock freezing infrastructure.
- freezing implements a "hold operations on this superblock until further notice" model we can easily follow.
- sb_start_write/sb_end_write provides a simple API model and a clean, clear and concise naming convention we can use, too.
Really, I'm struggling to understand how we got to "global locking that stops the world" from "need to change per-inode state atomically". Can someone please explain to me why this patch isn't just a simple set of largely self-explanitory functions like this:
XX_start_aop()XX_end_aop()
XX_lock_aops()XX_switch_aops(aops)XX_unlock_aops()
where "XX" is "sb" or "inode" depending on what locking granularity is used...
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 07/12] fs: Add locking for a dynamic DAX state
Quoted 6 lines · Dave Chinner
Quoted 5 lines · On Sat, Feb 08, 2020 at 11:34:40AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
DAX requires special address space operations but many other functions check the
IS_DAX()state.
Quoted 6 lines
Quoted 4 lines
While DAX is a property of the inode we perfer a lock at the super block level because of the overhead of a rwsem within the inode.
Define a vfs per superblock percpu rs semaphore to lock the DAX state
????
oops... I must have forgotten to update the commit message when I did the global RW sem. I implemented the per-SB, percpu rwsem first but it was suggested that the percpu nature of the lock combined with the anticipated infrequent use of the write side made using a global easier.
But before I proceed on V4 I'd like to get consensus on which of the 2 locking models to go with.
1) percpu per superblock lock
2) per inode rwsem
Depending on my mood I can convince myself of both being performant but the percpu is very attractive because I don't anticipate many changes of state during run time. OTOH concurrent threads accessing the same file at run time may also be low so there is likely to be little read contention across CPU's on the per-inode lock?
Opinions?
Quoted 36 lines
Quoted 36 lines
while performing various VFS layer operations. Write lock calls are provided here but are used in subsequent patches by the file systems themselves.
Signed-off-by Ira Weiny <[email protected]>---
Changes from V2Rebase on linux-next-08-02-2020
Fix locking order
Change all references from mode to state where appropriate addCONFIG_FS_DAXrequirement for state change
Use a static branch to enable locking only when a dax capable
device has been seen.Move the lock to a global vfs lock
this does a few things
1) preps us better for ext4 support
2) removes funky callbacks from inode ops
3) remove complexity from XFS and probably from ext4 laterWe can do this because
1) the locking order is required to be at the highest level anyway, so why complicate xfs
2) We had to move the sem to thesuper_blockbecause it is too heavy for the inode.
3) After internal discussions with Dan we decided that this would be easier, just as performant, and with slightly less overhead than in the VFS SB.
Quoted 8 lines
Quoted 3 lines
We also change the functions names to up/down; read/write as appropriate. Previous names were over simplified.This, IMO, is a bit of a train wreck.
This patch has nothing to do with "DAX state", it's about serialising access to the aops vector.
It is a bit more than just the aops vector. It also has to protect against checks of IS_DAX() which occur through many of the file operations.
Quoted 5 lines
There should be zero
references to DAX in this patch at all, except maybe to say "switching DAX on dynamically requires atomic switching of address space ops".
I'm ok with removing the dax references. However, it very specifically protects against IS_DAX checks. Adding in protection for other states will require care IMO. This is why I preserved the dax naming because I did not want to over step what is protected with the locking. I do _want_ it to protect more. But I can't guarantee it, have not tested it, and so made the calls specific to dax.
Quoted 7 lines
Big problems I see here:
1. static key to turn it on globally.
- just a gross hack around doing it properly with a per-sb mechanism and enbaling it only on filesystems that are on DAX capable block devices.
Fair enough. This was a reaction to Darricks desire to get this out of the way when DAX was not in the system. The static branch seemed like a good thing for users who don't have DAX capable hardware while running kernels and FS's which have DAX enabled.
http://lkml.iu.edu/hypermail/linux/kernel/2001.1/05691.html
Quoted 6 lines
- you're already passing in an inode to all these functions. It's
trivial to do: if (!inode->i_sb->s_flags & S_DYNAMIC_AOPS) return /* do sb->s_aops_lock manipulation */
Yea that would be ok IMO.
Darrick would just having this be CONFIG_FS_DAX as per this patch be ok with you. I guess the static key may have been a bit of overkill?
Quoted 3 lines
2. global lock
- OMG!
I know. The thinking on this is that the locking is percpu which is near 0 overhead in the read case and we are rarely going to take exclusive access.
Quoted 4 lines
- global lock will cause entire system IO/page fault stalls when someone does recursive/bulk DAX flag modification operations. Per-cpu rwsem Contention on large systems will be utterly awful.
Yea that is probably bad... I certainly did not test the responsiveness of this. FWIW if the system only has 1 FS the per-SB lock is not going to be any different from the global which was part of our thinking.
Quoted 5 lines
- ext4's use case almost never hits the exclusive lock side of the percpu-rwsem - only when changing the journal mode flag on the inode. And it only affects writeback in progress, so it's not going to have massive concurrency on it like a VFS level global lock has. -> Bad model to follow.
I admit I did not research the ext4's journal mode locking that much.
Quoted 2 lines
- per-sb lock is trivial - see #1 - which limits scope to single filesystem
I agree and... well the commit message shows I actually implemented it that way at first... :-/
Quoted 1 line
- per-inode rwsem would make this problem go away entirely.
But would that be ok for concurrent read performance which is going to be used 99.99% of the time? Maybe Darricks comments made me panic a little bit too much overhead WRT locking and its potential impact on users not using DAX?
Quoted 3 lines
3. If we can use a global per-cpu rwsem, why can't we just use a per-inode rwsem?
Per-cpu lock was attractive because of its near 0 overhead to take the read lock which happens a lot during normal operations.
Quoted 2 lines
- locking context rules are the same
- rwsem scales pretty damn well for shared ops
Does it? I'm not sure.
Quoted 2 lines
- no "global" contention problems
- small enough that we can put another rwsem in the inode.
Everything else I agree with... :-D
Quoted 5 lines
4. "
inode_dax_state_up_read"
- Eye bleeds.
- this is about the aops structure serialisation, not dax.
- The name makes no sense in the places that it has been added.
Again it is about more than just the aops. IS_DAX() needs to be protected in all the file operations calls as well or we can get races with the logic in those calls and a state switch.
Quoted 3 lines
5. We already have code that does almost exactly what we need: the superblock freezing infrastructure.
I think freeze does a lot more than we need.
Quoted 4 lines
- freezing implements a "hold operations on this superblock until further notice" model we can easily follow.
- sb_start_write/sb_end_write provides a simple API model and a clean, clear and concise naming convention we can use, too.
Ok as a model... If going with the per-SB lock. After working through my response I'm leaning toward a per-inode lock again. This was the way I did this to begin with.
I want feedback before reworking for V4, please.
Quoted 9 lines
Really, I'm struggling to understand how we got to "global locking that stops the world" from "need to change per-inode state atomically". Can someone please explain to me why this patch isn't just a simple set of largely self-explanitory functions like this:
XX_start_aop()XX_end_aop()
Quoted 6 lines
XX_lock_aops()XX_switch_aops(aops)XX_unlock_aops()where "XX" is "sb" or "inode" depending on what locking granularity is used...
Because failing to protect the logic around IS_DAX() results in failures in the read/write and direct IO paths.
So we need to lock the file operations as well.
Thanks for the review, :-D
Ira
Quoted 7 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 07/12] fs: Add locking for a dynamic DAX state
Quoted 26 lines · Ira Weiny
Quoted 6 lines · Dave Chinner
Quoted 5 lines · On Sat, Feb 08, 2020 at 11:34:40AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
DAX requires special address space operations but many other functions check the
IS_DAX()state.Quoted 6 lines
Quoted 4 lines
While DAX is a property of the inode we perfer a lock at the super block level because of the overhead of a rwsem within the inode.
Define a vfs per superblock percpu rs semaphore to lock the DAX state
????
oops... I must have forgotten to update the commit message when I did the global RW sem. I implemented the per-SB, percpu rwsem first but it was suggested that the percpu nature of the lock combined with the anticipated infrequent use of the write side made using a global easier.
But before I proceed on V4 I'd like to get consensus on which of the 2 locking models to go with.
1) percpu per superblock lock
2) per inode rwsem
Quoted 7 lines
Depending on my mood I can convince myself of both being performant but the percpu is very attractive because I don't anticipate many changes of state during run time. OTOH concurrent threads accessing the same file at run time may also be low so there is likely to be little read contention across CPU's on the per-inode lock?
Opinions?
As one who thought a global lock would be reasonable relative to how often dax address_space_operations are swapped out (on the order of taking cgroup_threadgroup_rwsem for write), I think a per-superblock lock is also an ok starting point. We can always go to finer grained locking in the future if we see evidence that the benefits of percpu are lost to stopping the world at the superblock level.
Re: [PATCH v3 07/12] fs: Add locking for a dynamic DAX state
In reply to Ira WeinyQuoted 73 lines · Ira Weiny
Quoted 6 lines · Dave Chinner
Quoted 5 lines · On Sat, Feb 08, 2020 at 11:34:40AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
DAX requires special address space operations but many other functions check the
IS_DAX()state.Quoted 6 lines
Quoted 4 lines
While DAX is a property of the inode we perfer a lock at the super block level because of the overhead of a rwsem within the inode.
Define a vfs per superblock percpu rs semaphore to lock the DAX state
????
oops... I must have forgotten to update the commit message when I did the global RW sem. I implemented the per-SB, percpu rwsem first but it was suggested that the percpu nature of the lock combined with the anticipated infrequent use of the write side made using a global easier.
But before I proceed on V4 I'd like to get consensus on which of the 2 locking models to go with.
1) percpu per superblock lock
2) per inode rwsemDepending on my mood I can convince myself of both being performant but the percpu is very attractive because I don't anticipate many changes of state during run time. OTOH concurrent threads accessing the same file at run time may also be low so there is likely to be little read contention across CPU's on the per-inode lock?
Opinions?
Quoted 40 lines
Quoted 39 lines
while performing various VFS layer operations. Write lock calls are provided here but are used in subsequent patches by the file systems themselves.
Signed-off-by Ira Weiny <[email protected]>---
Changes from V2Rebase on linux-next-08-02-2020
Fix locking order
Change all references from mode to state where appropriate addCONFIG_FS_DAXrequirement for state change
Use a static branch to enable locking only when a dax capable
device has been seen.Move the lock to a global vfs lock
this does a few things
1) preps us better for ext4 support
2) removes funky callbacks from inode ops
3) remove complexity from XFS and probably from ext4 laterWe can do this because
1) the locking order is required to be at the highest level anyway, so why complicate xfs
2) We had to move the sem to thesuper_blockbecause it is too heavy for the inode.
3) After internal discussions with Dan we decided that this would be easier, just as performant, and with slightly less overhead than in the VFS SB.We also change the functions names to up/down; read/write as appropriate. Previous names were over simplified.
Quoted 7 lines
Quoted 4 lines
This, IMO, is a bit of a train wreck.
This patch has nothing to do with "DAX state", it's about serialising access to the aops vector.
It is a bit more than just the aops vector. It also has to protect against checks of
IS_DAX()which occur through many of the file operations.
I think you are looking at this incorrectly. The IS_DAX() construct is just determining what path to the aops method we take. regardless of whether IS_DAX() is true or not, we need to execute an aop method, and so aops vector protection is required regardless of how IS_DAX() evaluates.
But we do require IS_DAX() to evaluate consistently through an entire aops protected region, as there may be multiple aops method calls in a aops context (e.g. write page faults). Hence we have to ensure that IS_DAX() changes atomically w.r.t. to the aops vector switches. This is simply:
sb_aops_lock() inode->i_flags |= S_DAX sb_aops_switch(new_aops) sb_aops_unlock().
This guarantees that inside sb_aops_start/end(), IS_DAX() checks are stable because we change the state atomically with the aops vector.
We are *not* providing serialisation of inode->i_flags access or updates here; all we need to do is ensure that the S_DAX flag is consistent and stable across an aops access region. If we are not in an aops call chain or will not call an aops method, we just don't care if the IS_DAX() call is racy as whatever we call is still static and if it's DAAX sensitive it can call IS_DAX() itself when needed.
Again, this isn't about DAX at all, it's about being able to switch aops vectors in a safe and reliable manner. The IS_DAX() constraints are really a minor addition on top of the "stable aops vector" regions we are laying down here.
Quoted 7 lines
Quoted 6 lines
Big problems I see here:
1. static key to turn it on globally.
- just a gross hack around doing it properly with a per-sb mechanism and enbaling it only on filesystems that are on DAX capable block devices.
Quoted 6 lines
Fair enough. This was a reaction to Darricks desire to get this out of the way when DAX was not in the system. The static branch seemed like a good thing for users who don't have DAX capable hardware while running kernels and FS's which have DAX enabled.
I think that's largely premature optimisation, and it backs us into the "all or nothing" corner which is a bad place to be for what is per-filesystem functionality.
Quoted 13 lines
Quoted 6 lines
- you're already passing in an inode to all these functions. It's
trivial to do: if (!inode->i_sb->s_flags & S_DYNAMIC_AOPS) return /* do sb->s_aops_lock manipulation */Yea that would be ok IMO.
Darrick would just having this be
CONFIG_FS_DAXas per this patch be ok with you. I guess the static key may have been a bit of overkill?Quoted 1 line
Quoted 5 lines
Quoted 2 lines
2. global lock
- OMG!I know. The thinking on this is that the locking is percpu which is near 0 overhead in the read case and we are rarely going to take exclusive access.
The problem is that users can effectively run:
$ xfs_io -c "chattr -R -D -x" /path/to/dax_fs
And then it walks over millions of individual inodes turning off the DAX flag on each of them. And if each of those inodes takes a global per-cpu rwsem that blocks all read/write IO and page faults on everything even for a short time, then this is will have a major impact on the entire system and users will be very unhappy.
Quoted 8 lines
Quoted 4 lines
- global lock will cause entire system IO/page fault stalls when someone does recursive/bulk DAX flag modification operations. Per-cpu rwsem Contention on large systems will be utterly awful.
Yea that is probably bad... I certainly did not test the responsiveness of this. FWIW if the system only has 1 FS the per-SB lock is not going to be any different from the global which was part of our thinking.
Don't forget that things like /proc, /sys, etc are all filesystems. Hence the global lock will affect accesses to -everything- in the system, not just the DAX enabled filesystem. Global locks are -bad-.
Quoted 11 lines
Quoted 5 lines
- ext4's use case almost never hits the exclusive lock side of the percpu-rwsem - only when changing the journal mode flag on the inode. And it only affects writeback in progress, so it's not going to have massive concurrency on it like a VFS level global lock has. -> Bad model to follow.
I admit I did not research the ext4's journal mode locking that much.
Quoted 2 lines
- per-sb lock is trivial - see #1 - which limits scope to single filesystem
Quoted 8 lines
I agree and... well the commit message shows I actually implemented it that way at first... :-/
Quoted 1 line
- per-inode rwsem would make this problem go away entirely.
But would that be ok for concurrent read performance which is going to be used 99.99% of the time? Maybe Darricks comments made me panic a little bit too much overhead WRT locking and its potential impact on users not using DAX?
I know that a rwsem in shared mode can easily handle 2M lock cycles/s across a 32p machine without contention (concurrent AIO-DIO read/writes to a single file) so the baseline performance of a rwsem is likely good enough to start from.
It's simple, and we can run tests easily enough to find out where it starts to become a performance limitation. This whole "global percpu rwsem thing stinks like premature optimisation. Do the simple, straight forward thing first, then get numbers and analysis the limitations to determine what the second generation of the functionality needs to fix.
IMO, we don't have to solve every scalability problem with the initial implementation. Let's just make it work first, then worry about extreme scalability when we have some idea of where those scalability problems are.
Quoted 10 lines
Quoted 2 lines
3. If we can use a global per-cpu rwsem, why can't we just use a per-inode rwsem?
Per-cpu lock was attractive because of its near 0 overhead to take the read lock which happens a lot during normal operations.
Quoted 2 lines
- locking context rules are the same
- rwsem scales pretty damn well for shared opsDoes it? I'm not sure.
If you haven't tested it, then we are definitely in the realm of premature optimisation...
Quoted 20 lines
Quoted 3 lines
- no "global" contention problems
- small enough that we can put another rwsem in the inode.Everything else I agree with... :-D
Quoted 5 lines
4. "
inode_dax_state_up_read"
- Eye bleeds.
- this is about the aops structure serialisation, not dax.
- The name makes no sense in the places that it has been added.Again it is about more than just the aops.
IS_DAX()needs to be protected in all the file operations calls as well or we can get races with the logic in those calls and a state switch.Quoted 3 lines
5. We already have code that does almost exactly what we need: the superblock freezing infrastructure.
Quoted 8 lines
I think freeze does a lot more than we need.
Quoted 4 lines
- freezing implements a "hold operations on this superblock until further notice" model we can easily follow.
- sb_start_write/sb_end_write provides a simple API model and a clean, clear and concise naming convention we can use, too.Ok as a model... If going with the per-SB lock.
Ok, you completely missed my point. You're still looking at this as a set of "locks" and serialisation.
Freezing is *not a lock* - it provides a series of "drain points" where we can transparently block new operations, then wait for all existing operations to complete so we can make a state change, and then once that is done we unblock all the waiters....
IOWs, the freeze model provides an ordered barrier mechanism, and that's precisely what we need for aops protection...
Yes, it may be implemented with locks internally, but that's implementation detail of the barrier mechanism, not an indication what functionality it is actually providing.
Quoted 5 lines
After working through my
response I'm leaning toward a per-inode lock again. This was the way I did this to begin with.I want feedback before reworking for V4, please.
IMO, always do the simple thing first.
Only do a more complex thing if the simple thing doesn't work or doesn't perform sufficiently well for an initial implemenation. Otherwise we end up with crazy solutions from premature optimisation that simply aren't viable.
Quoted 12 lines
Quoted 12 lines
Really, I'm struggling to understand how we got to "global locking that stops the world" from "need to change per-inode state atomically". Can someone please explain to me why this patch isn't just a simple set of largely self-explanitory functions like this:
XX_start_aop()XX_end_aop()
XX_lock_aops()XX_switch_aops(aops)XX_unlock_aops()
Quoted 7 lines
Quoted 2 lines
where "XX" is "sb" or "inode" depending on what locking granularity is used...
Because failing to protect the logic around
IS_DAX()results in failures in the read/write and direct IO paths.So we need to lock the file operations as well.
Again, there is no "locking" here. We just need to annotate regions where the aops vector must remain stable. If a fop calls an aop that the aops vector does not change while it is the middle of executing the fop. Hence such fops calls will need to be inside XX_start_aop()/XX_end_aop() markers.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v3 07/12] fs: Add locking for a dynamic DAX state
Quoted 129 lines · Dave Chinner
Quoted 73 lines · Ira Weiny
Quoted 6 lines · Dave Chinner
Quoted 5 lines · On Sat, Feb 08, 2020 at 11:34:40AM -0800, [email protected] wrote:
From: Ira Weiny <[email protected]>
DAX requires special address space operations but many other functions check the
IS_DAX()state.Quoted 6 lines
Quoted 4 lines
While DAX is a property of the inode we perfer a lock at the super block level because of the overhead of a rwsem within the inode.
Define a vfs per superblock percpu rs semaphore to lock the DAX state
????
oops... I must have forgotten to update the commit message when I did the global RW sem. I implemented the per-SB, percpu rwsem first but it was suggested that the percpu nature of the lock combined with the anticipated infrequent use of the write side made using a global easier.
But before I proceed on V4 I'd like to get consensus on which of the 2 locking models to go with.
1) percpu per superblock lock
2) per inode rwsemDepending on my mood I can convince myself of both being performant but the percpu is very attractive because I don't anticipate many changes of state during run time. OTOH concurrent threads accessing the same file at run time may also be low so there is likely to be little read contention across CPU's on the per-inode lock?
Opinions?
Quoted 40 lines
Quoted 39 lines
while performing various VFS layer operations. Write lock calls are provided here but are used in subsequent patches by the file systems themselves.
Signed-off-by Ira Weiny <[email protected]>---
Changes from V2Rebase on linux-next-08-02-2020
Fix locking order
Change all references from mode to state where appropriate addCONFIG_FS_DAXrequirement for state change
Use a static branch to enable locking only when a dax capable
device has been seen.Move the lock to a global vfs lock
this does a few things
1) preps us better for ext4 support
2) removes funky callbacks from inode ops
3) remove complexity from XFS and probably from ext4 laterWe can do this because
1) the locking order is required to be at the highest level anyway, so why complicate xfs
2) We had to move the sem to thesuper_blockbecause it is too heavy for the inode.
3) After internal discussions with Dan we decided that this would be easier, just as performant, and with slightly less overhead than in the VFS SB.We also change the functions names to up/down; read/write as appropriate. Previous names were over simplified.
Quoted 7 lines
Quoted 4 lines
This, IMO, is a bit of a train wreck.
This patch has nothing to do with "DAX state", it's about serialising access to the aops vector.
It is a bit more than just the aops vector. It also has to protect against checks of
IS_DAX()which occur through many of the file operations.I think you are looking at this incorrectly. The
IS_DAX()construct is just determining what path to the aops method we take. regardless of whetherIS_DAX()is true or not, we need to execute an aop method, and so aops vector protection is required regardless of howIS_DAX()evaluates.But we do require
IS_DAX()to evaluate consistently through an entire aops protected region, as there may be multiple aops method calls in a aops context (e.g. write page faults). Hence we have to ensure thatIS_DAX()changes atomically w.r.t. to the aops vector switches. This is simply:sb_aops_lock() inode->i_flags |= S_DAX sb_aops_switch(new_aops) sb_aops_unlock().This guarantees that inside sb_aops_start/end(),
IS_DAX()checks are stable because we change the state atomically with the aops vector.We are *not* providing serialisation of
inode->i_flagsaccess or updates here; all we need to do is ensure that theS_DAXflag is consistent and stable across an aops access region. If we are not in an aops call chain or will not call an aops method, we just don't care if theIS_DAX()call is racy as whatever we call is still static and if it's DAAX sensitive it can callIS_DAX()itself when needed.Again, this isn't about DAX at all, it's about being able to switch aops vectors in a safe and reliable manner. The
IS_DAX()constraints are really a minor addition on top of the "stable aops vector" regions we are laying down here.Quoted 12 lines
Quoted 6 lines
Big problems I see here:
1. static key to turn it on globally.
- just a gross hack around doing it properly with a per-sb mechanism and enbaling it only on filesystems that are on DAX capable block devices.Fair enough. This was a reaction to Darricks desire to get this out of the way when DAX was not in the system. The static branch seemed like a good thing for users who don't have DAX capable hardware while running kernels and FS's which have DAX enabled.
Quoted 5 lines
I think that's largely premature optimisation, and it backs us into the "all or nothing" corner which is a bad place to be for what is per-filesystem functionality.
Oh, wow, uh... this was a total misunderstanding. Having a per-inode primitive to grant ourselves the ability to change fops/aops safely was fine, I just wanted to have it compile out of existence if CONFIG_DAX=n (or some other cleverish way if this mount will never support DAX (e.g. scsi disk)). I wasn't asking for it to move to the superblock or become a Big Kernel Primitive.
--D
Quoted 183 lines
Quoted 14 lines
Quoted 7 lines
- you're already passing in an inode to all these functions. It's
trivial to do: if (!inode->i_sb->s_flags & S_DYNAMIC_AOPS) return /* do sb->s_aops_lock manipulation */Yea that would be ok IMO.
Darrick would just having this be
CONFIG_FS_DAXas per this patch be ok with you. I guess the static key may have been a bit of overkill?Quoted 1 line
Quoted 5 lines
Quoted 2 lines
2. global lock
- OMG!I know. The thinking on this is that the locking is percpu which is near 0 overhead in the read case and we are rarely going to take exclusive access.
The problem is that users can effectively run:
$ xfs_io -c "chattr -R -D -x" /path/to/dax_fsAnd then it walks over millions of individual inodes turning off the DAX flag on each of them. And if each of those inodes takes a global per-cpu rwsem that blocks all read/write IO and page faults on everything even for a short time, then this is will have a major impact on the entire system and users will be very unhappy.
Quoted 8 lines
Quoted 4 lines
- global lock will cause entire system IO/page fault stalls when someone does recursive/bulk DAX flag modification operations. Per-cpu rwsem Contention on large systems will be utterly awful.
Yea that is probably bad... I certainly did not test the responsiveness of this. FWIW if the system only has 1 FS the per-SB lock is not going to be any different from the global which was part of our thinking.
Don't forget that things like /proc, /sys, etc are all filesystems. Hence the global lock will affect accesses to -everything- in the system, not just the DAX enabled filesystem. Global locks are -bad-.
Quoted 11 lines
Quoted 5 lines
- ext4's use case almost never hits the exclusive lock side of the percpu-rwsem - only when changing the journal mode flag on the inode. And it only affects writeback in progress, so it's not going to have massive concurrency on it like a VFS level global lock has. -> Bad model to follow.
I admit I did not research the ext4's journal mode locking that much.
Quoted 2 lines
- per-sb lock is trivial - see #1 - which limits scope to single filesystem
Quoted 8 lines
I agree and... well the commit message shows I actually implemented it that way at first... :-/
Quoted 1 line
- per-inode rwsem would make this problem go away entirely.
But would that be ok for concurrent read performance which is going to be used 99.99% of the time? Maybe Darricks comments made me panic a little bit too much overhead WRT locking and its potential impact on users not using DAX?
I know that a rwsem in shared mode can easily handle 2M lock cycles/s across a 32p machine without contention (concurrent AIO-DIO read/writes to a single file) so the baseline performance of a rwsem is likely good enough to start from.
It's simple, and we can run tests easily enough to find out where it starts to become a performance limitation. This whole "global percpu rwsem thing stinks like premature optimisation. Do the simple, straight forward thing first, then get numbers and analysis the limitations to determine what the second generation of the functionality needs to fix.
IMO, we don't have to solve every scalability problem with the initial implementation. Let's just make it work first, then worry about extreme scalability when we have some idea of where those scalability problems are.
Quoted 10 lines
Quoted 2 lines
3. If we can use a global per-cpu rwsem, why can't we just use a per-inode rwsem?
Per-cpu lock was attractive because of its near 0 overhead to take the read lock which happens a lot during normal operations.
Quoted 2 lines
- locking context rules are the same
- rwsem scales pretty damn well for shared opsDoes it? I'm not sure.
If you haven't tested it, then we are definitely in the realm of premature optimisation...
Quoted 20 lines
Quoted 3 lines
- no "global" contention problems
- small enough that we can put another rwsem in the inode.Everything else I agree with... :-D
Quoted 5 lines
4. "
inode_dax_state_up_read"
- Eye bleeds.
- this is about the aops structure serialisation, not dax.
- The name makes no sense in the places that it has been added.Again it is about more than just the aops.
IS_DAX()needs to be protected in all the file operations calls as well or we can get races with the logic in those calls and a state switch.Quoted 3 lines
5. We already have code that does almost exactly what we need: the superblock freezing infrastructure.
Quoted 8 lines
I think freeze does a lot more than we need.
Quoted 4 lines
- freezing implements a "hold operations on this superblock until further notice" model we can easily follow.
- sb_start_write/sb_end_write provides a simple API model and a clean, clear and concise naming convention we can use, too.Ok as a model... If going with the per-SB lock.
Ok, you completely missed my point. You're still looking at this as a set of "locks" and serialisation.
Freezing is *not a lock* - it provides a series of "drain points" where we can transparently block new operations, then wait for all existing operations to complete so we can make a state change, and then once that is done we unblock all the waiters....
IOWs, the freeze model provides an ordered barrier mechanism, and that's precisely what we need for aops protection...
Yes, it may be implemented with locks internally, but that's implementation detail of the barrier mechanism, not an indication what functionality it is actually providing.
Quoted 5 lines
After working through my
response I'm leaning toward a per-inode lock again. This was the way I did this to begin with.I want feedback before reworking for V4, please.
IMO, always do the simple thing first.
Only do a more complex thing if the simple thing doesn't work or doesn't perform sufficiently well for an initial implemenation. Otherwise we end up with crazy solutions from premature optimisation that simply aren't viable.
Quoted 12 lines
Quoted 12 lines
Really, I'm struggling to understand how we got to "global locking that stops the world" from "need to change per-inode state atomically". Can someone please explain to me why this patch isn't just a simple set of largely self-explanitory functions like this:
XX_start_aop()XX_end_aop()
XX_lock_aops()XX_switch_aops(aops)XX_unlock_aops()Quoted 7 lines
Quoted 2 lines
where "XX" is "sb" or "inode" depending on what locking granularity is used...
Because failing to protect the logic around
IS_DAX()results in failures in the read/write and direct IO paths.So we need to lock the file operations as well.
Again, there is no "locking" here. We just need to annotate regions where the aops vector must remain stable. If a fop calls an aop that the aops vector does not change while it is the middle of executing the fop. Hence such fops calls will need to be inside XX_start_aop()/XX_end_aop() markers.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
kbuild test robot
build botRe: [PATCH v3 07/12] fs: Add locking for a dynamic DAX state
In reply to [email protected]I love your patch! Yet something to improve:
Hi,
I love your patch! Yet something to improve:
[auto build test ERROR on linus/master]
[also build test ERROR on v5.6-rc1 next-20200211]
[cannot apply to xfs-linux/for-next linux/master djwong-xfs/djwong-devel] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/ira-weiny-intel-com/Enable-per-file-directory-DAX-operations-V3/20200211-193842 base: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 0a679e13ea30f85a1aef0669ee0c5a9fd7860b34 config: sh-randconfig-a001-20200211 (attached as .config) compiler: sh4-linux-gcc (GCC) 7.5.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
GCC_VERSION=7.5.0 make.cross ARCH=sh
If you fix the issue, kindly add following tag
All errors (new ones prefixed by >>):
In file included from include/linux/debugfs.h:15:0,
from drivers//pinctrl/core.c:23:
include/linux/fs.h:1916:1: warning: data definition has no type or storage class
DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1916:1: error: type defaults to 'int' in declaration of 'DECLARE_STATIC_KEY_FALSE' [-Werror=implicit-int]
include/linux/fs.h:1916:1: warning: parameter names (without types) in function declaration
include/linux/fs.h: In function 'inode_dax_state_down_read':
>> include/linux/fs.h:1920:7: error: implicit declaration of function 'static_branch_unlikely' [-Werror=implicit-function-declaration]
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1920:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h:1920:31: note: each undeclared identifier is reported only once for each function it appears in
include/linux/fs.h: In function 'inode_dax_state_up_read':
include/linux/fs.h:1926:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_down_write':
include/linux/fs.h:1932:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_up_write':
include/linux/fs.h:1938:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'enable_dax_state_static_branch':
>> include/linux/fs.h:1944:2: error: implicit declaration of function 'static_branch_enable'; did you mean 'stack_trace_save'? [-Werror=implicit-function-declaration]
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~
stack_trace_save
>> include/linux/fs.h:1944:24: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'enable_dax_state_static_branch'?
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~~
enable_dax_state_static_branch
cc1: some warnings being treated as errors
--
In file included from include/linux/seq_file.h:11:0,
from include/linux/pinctrl/pinctrl.h:16,
from include/linux/gpio/driver.h:11,
from drivers//gpio/gpio-dwapb.c:10:
include/linux/fs.h:1916:1: warning: data definition has no type or storage class
DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1916:1: error: type defaults to 'int' in declaration of 'DECLARE_STATIC_KEY_FALSE' [-Werror=implicit-int]
include/linux/fs.h:1916:1: warning: parameter names (without types) in function declaration
include/linux/fs.h: In function 'inode_dax_state_down_read':
>> include/linux/fs.h:1920:7: error: implicit declaration of function 'static_branch_unlikely' [-Werror=implicit-function-declaration]
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1920:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h:1920:31: note: each undeclared identifier is reported only once for each function it appears in
include/linux/fs.h: In function 'inode_dax_state_up_read':
include/linux/fs.h:1926:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_down_write':
include/linux/fs.h:1932:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_up_write':
include/linux/fs.h:1938:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'enable_dax_state_static_branch':
>> include/linux/fs.h:1944:2: error: implicit declaration of function 'static_branch_enable'; did you mean 'local_bh_enable'? [-Werror=implicit-function-declaration]
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~
local_bh_enable
>> include/linux/fs.h:1944:24: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'enable_dax_state_static_branch'?
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~~
enable_dax_state_static_branch
cc1: some warnings being treated as errors
--
In file included from include/linux/tty.h:5:0,
from drivers//tty/tty_ioctl.c:16:
include/linux/fs.h:1916:1: warning: data definition has no type or storage class
DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1916:1: error: type defaults to 'int' in declaration of 'DECLARE_STATIC_KEY_FALSE' [-Werror=implicit-int]
include/linux/fs.h:1916:1: warning: parameter names (without types) in function declaration
include/linux/fs.h: In function 'inode_dax_state_down_read':
>> include/linux/fs.h:1920:7: error: implicit declaration of function 'static_branch_unlikely' [-Werror=implicit-function-declaration]
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1920:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h:1920:31: note: each undeclared identifier is reported only once for each function it appears in
include/linux/fs.h: In function 'inode_dax_state_up_read':
include/linux/fs.h:1926:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h: In function 'inode_dax_state_down_write':
include/linux/fs.h:1932:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h: In function 'inode_dax_state_up_write':
include/linux/fs.h:1938:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h: In function 'enable_dax_state_static_branch':
>> include/linux/fs.h:1944:2: error: implicit declaration of function 'static_branch_enable'; did you mean 'stack_trace_save'? [-Werror=implicit-function-declaration]
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~
stack_trace_save
include/linux/fs.h:1944:24: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
cc1: some warnings being treated as errors
--
In file included from include/linux/seq_file.h:11:0,
from include/linux/sh_clk.h:6,
from drivers//sh/clk/cpg.c:15:
include/linux/fs.h:1916:1: warning: data definition has no type or storage class
DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1916:1: error: type defaults to 'int' in declaration of 'DECLARE_STATIC_KEY_FALSE' [-Werror=implicit-int]
include/linux/fs.h:1916:1: warning: parameter names (without types) in function declaration
include/linux/fs.h: In function 'inode_dax_state_down_read':
>> include/linux/fs.h:1920:7: error: implicit declaration of function 'static_branch_unlikely' [-Werror=implicit-function-declaration]
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1920:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h:1920:31: note: each undeclared identifier is reported only once for each function it appears in
include/linux/fs.h: In function 'inode_dax_state_up_read':
include/linux/fs.h:1926:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_down_write':
include/linux/fs.h:1932:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_up_write':
include/linux/fs.h:1938:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'enable_dax_state_static_branch':
>> include/linux/fs.h:1944:2: error: implicit declaration of function 'static_branch_enable'; did you mean 'local_bh_enable'? [-Werror=implicit-function-declaration]
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~
local_bh_enable
>> include/linux/fs.h:1944:24: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'enable_dax_state_static_branch'?
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~~
enable_dax_state_static_branch
drivers//sh/clk/cpg.c: In function 'r8':
drivers//sh/clk/cpg.c:41:17: warning: passing argument 1 of 'ioread8' discards 'const' qualifier from pointer target type [-Wdiscarded-qualifiers]
return ioread8(addr);
^~~~
In file included from arch/sh/include/asm/io.h:21:0,
from include/linux/io.h:13,
from drivers//sh/clk/cpg.c:14:
include/asm-generic/iomap.h:29:21: note: expected 'void *' but argument is of type 'const void *'
extern unsigned int ioread8(void __iomem *);
^~~~~~~
drivers//sh/clk/cpg.c: In function 'r16':
drivers//sh/clk/cpg.c:46:18: warning: passing argument 1 of 'ioread16' discards 'const' qualifier from pointer target type [-Wdiscarded-qualifiers]
return ioread16(addr);
^~~~
In file included from arch/sh/include/asm/io.h:21:0,
from include/linux/io.h:13,
from drivers//sh/clk/cpg.c:14:
include/asm-generic/iomap.h:30:21: note: expected 'void *' but argument is of type 'const void *'
extern unsigned int ioread16(void __iomem *);
^~~~~~~~
drivers//sh/clk/cpg.c: In function 'r32':
drivers//sh/clk/cpg.c:51:18: warning: passing argument 1 of 'ioread32' discards 'const' qualifier from pointer target type [-Wdiscarded-qualifiers]
return ioread32(addr);
^~~~
In file included from arch/sh/include/asm/io.h:21:0,
from include/linux/io.h:13,
from drivers//sh/clk/cpg.c:14:
include/asm-generic/iomap.h:32:21: note: expected 'void *' but argument is of type 'const void *'
extern unsigned int ioread32(void __iomem *);
^~~~~~~~
cc1: some warnings being treated as errors
--
In file included from include/linux/security.h:28:0,
from include/linux/fs_context.h:14,
from fs/fs_parser.c:9:
include/linux/fs.h:1916:1: warning: data definition has no type or storage class
DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1916:1: error: type defaults to 'int' in declaration of 'DECLARE_STATIC_KEY_FALSE' [-Werror=implicit-int]
include/linux/fs.h:1916:1: warning: parameter names (without types) in function declaration
include/linux/fs.h: In function 'inode_dax_state_down_read':
>> include/linux/fs.h:1920:7: error: implicit declaration of function 'static_branch_unlikely' [-Werror=implicit-function-declaration]
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1920:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h:1920:31: note: each undeclared identifier is reported only once for each function it appears in
include/linux/fs.h: In function 'inode_dax_state_up_read':
include/linux/fs.h:1926:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h: In function 'inode_dax_state_down_write':
include/linux/fs.h:1932:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h: In function 'inode_dax_state_up_write':
include/linux/fs.h:1938:31: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
include/linux/fs.h: In function 'enable_dax_state_static_branch':
>> include/linux/fs.h:1944:2: error: implicit declaration of function 'static_branch_enable'; did you mean 'local_bh_enable'? [-Werror=implicit-function-declaration]
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~
local_bh_enable
include/linux/fs.h:1944:24: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'proc_do_static_key'?
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~~
proc_do_static_key
cc1: some warnings being treated as errors
--
In file included from include/linux/buffer_head.h:12:0,
from fs//gfs2/glock.c:12:
include/linux/fs.h:1916:1: warning: data definition has no type or storage class
DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1916:1: error: type defaults to 'int' in declaration of 'DECLARE_STATIC_KEY_FALSE' [-Werror=implicit-int]
include/linux/fs.h:1916:1: warning: parameter names (without types) in function declaration
include/linux/fs.h: In function 'inode_dax_state_down_read':
>> include/linux/fs.h:1920:7: error: implicit declaration of function 'static_branch_unlikely' [-Werror=implicit-function-declaration]
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1920:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h:1920:31: note: each undeclared identifier is reported only once for each function it appears in
include/linux/fs.h: In function 'inode_dax_state_up_read':
include/linux/fs.h:1926:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_down_write':
include/linux/fs.h:1932:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_up_write':
include/linux/fs.h:1938:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'enable_dax_state_static_branch':
>> include/linux/fs.h:1944:2: error: implicit declaration of function 'static_branch_enable'; did you mean 'stack_trace_save'? [-Werror=implicit-function-declaration]
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~
stack_trace_save
>> include/linux/fs.h:1944:24: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'enable_dax_state_static_branch'?
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~~
enable_dax_state_static_branch
In file included from fs//gfs2/trace_gfs2.h:632:0,
from fs//gfs2/glock.c:49:
include/trace/define_trace.h: At top level:
include/trace/define_trace.h:95:42: fatal error: ./trace_gfs2.h: No such file or directory
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
^ cc1: some warnings being treated as errors
compilation terminated.
--
In file included from fs//cifs/cifssmb.c:30:0:
include/linux/fs.h:1916:1: warning: data definition has no type or storage class
DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1916:1: error: type defaults to 'int' in declaration of 'DECLARE_STATIC_KEY_FALSE' [-Werror=implicit-int]
include/linux/fs.h:1916:1: warning: parameter names (without types) in function declaration
include/linux/fs.h: In function 'inode_dax_state_down_read':
>> include/linux/fs.h:1920:7: error: implicit declaration of function 'static_branch_unlikely' [-Werror=implicit-function-declaration]
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~
>> include/linux/fs.h:1920:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h:1920:31: note: each undeclared identifier is reported only once for each function it appears in
include/linux/fs.h: In function 'inode_dax_state_up_read':
include/linux/fs.h:1926:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_down_write':
include/linux/fs.h:1932:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'inode_dax_state_up_write':
include/linux/fs.h:1938:31: error: 'lock_dax_state_static_key' undeclared (first use in this function)
if (!static_branch_unlikely(&lock_dax_state_static_key))
^~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/fs.h: In function 'enable_dax_state_static_branch':
>> include/linux/fs.h:1944:2: error: implicit declaration of function 'static_branch_enable'; did you mean 'stack_trace_save'? [-Werror=implicit-function-declaration]
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~
stack_trace_save
>> include/linux/fs.h:1944:24: error: 'lock_dax_state_static_key' undeclared (first use in this function); did you mean 'enable_dax_state_static_branch'?
static_branch_enable(&lock_dax_state_static_key);
^~~~~~~~~~~~~~~~~~~~~~~~~
enable_dax_state_static_branch
In file included from fs//cifs/cifsglob.h:32:0,
from fs//cifs/cifssmb.c:40:
fs//cifs/smb2pdu.h: At top level:
fs//cifs/smb2pdu.h:28:10: fatal error: cifsacl.h: No such file or directory
#include <cifsacl.h>
^~~~~~~~~~~ cc1: some warnings being treated as errors
compilation terminated.
..
vim +1916 include/linux/fs.h
1902
1903 #if defined(CONFIG_FS_DAX)
1904 /*
1905 * Filesystems wishing to support dynamic DAX states must do the following.
1906 *
1907 * 1) the direct_IO address_space_operation must be supported in all
1908 * potential a_ops vectors for any state suported by the inode.
1909 * 2) FS's should enable the static branch lock_dax_state_static_key when a DAX
1910 * capable device is detected.
1911 * 3) DAX state changes shall not be allowed while the file is mmap'ed
1912 * 4) For non-mmaped operations the VFS layer must take the read lock for any
1913 * use of IS_DAX()
1914 * 5) Filesystems take the write lock when changing DAX states.
1915 */
> 1916 DECLARE_STATIC_KEY_FALSE(lock_dax_state_static_key);
1917 extern struct percpu_rw_semaphore sb_dax_rwsem;
1918 static inline void inode_dax_state_down_read(struct inode *inode)
1919 {
> 1920 if (!static_branch_unlikely(&lock_dax_state_static_key))
1921 return;
1922 percpu_down_read(&sb_dax_rwsem);
1923 }
1924 static inline void inode_dax_state_up_read(struct inode *inode)
1925 {
1926 if (!static_branch_unlikely(&lock_dax_state_static_key))
1927 return;
1928 percpu_up_read(&sb_dax_rwsem);
1929 }
1930 static inline void inode_dax_state_down_write(struct inode *inode)
1931 {
> 1932 if (!static_branch_unlikely(&lock_dax_state_static_key))
1933 return;
1934 percpu_down_write(&sb_dax_rwsem);
1935 }
1936 static inline void inode_dax_state_up_write(struct inode *inode)
1937 {
> 1938 if (!static_branch_unlikely(&lock_dax_state_static_key))
1939 return;
1940 percpu_up_write(&sb_dax_rwsem);
1941 }
1942 static inline void enable_dax_state_static_branch(void)
1943 {
> 1944 static_branch_enable(&lock_dax_state_static_key); 1945 }
1946 #else /* !CONFIG_FS_DAX */
1947 #define inode_dax_state_down_read(inode) do { (void)(inode); } while (0)
1948 #define inode_dax_state_up_read(inode) do { (void)(inode); } while (0)
1949 #define inode_dax_state_down_write(inode) do { (void)(inode); } while (0)
1950 #define inode_dax_state_up_write(inode) do { (void)(inode); } while (0)
1951 #define enable_dax_state_static_branch()
1952 #endif /* CONFIG_FS_DAX */
1953
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
PATCH v3 8/12 fs/xfs: Clarify lockdep dependency for xfs_isilocked()
In reply to [email protected]From: Ira Weiny <[email protected]>
xfs_isilocked() can't work fully without CONFIG_LOCKDEP. However, making xfs_isilocked() dependant on CONFIG_LOCKDEP is not feasible because it is used for more than the i_rwsem. Therefore a short-circuit was provided via debug_locks. However, this caused confusion while working through the xfs locking.
Rather than use debug_locks as a flag specify this clearly using IS_ENABLED(CONFIG_LOCKDEP).
---
Changes from V2:
This patch is new for V3
fs/xfs/xfs_inode.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/xfs/xfs_inode.c +1 -1
@@ -364,7 +364,7 @@ xfs_isilocked(if (lock_flags & (XFS_IOLOCK_EXCL |XFS_IOLOCK_SHARED )) {if (!(lock_flags &XFS_IOLOCK_SHARED )) -return !debug_locks || +return !IS_ENABLED (CONFIG_LOCKDEP ) ||lockdep_is_held_type (&VFS_I (ip)->i_rwsem,0 );return rwsem_is_locked (&VFS_I (ip)->i_rwsem); }
Signature · 1 line
2.21.0
PATCH v3 9/12 fs/xfs: Add write DAX lock to xfs layer
In reply to [email protected]From: Ira Weiny <[email protected]>
XFS requires regular files to be locked for write while changing to/from DAX state.
Take the DAX write lock while changing DAX state.
We define a new XFS_DAX_EXCL lock type to carry the lock through to transaction completion.
---
Changes from V2:
Change name of patch (WAS: fs/xfs: Add lock/unlock state to xfs) Remove the xfs specific lock and move to the vfs layer.
We still use XFS_LOCK_DAX_EXCL to be able to pass this flag through to the transaction code. But we no longer have a lock specific to xfs. This removes a lot of code from the XFS layer, preps us for using this in ext4, and is actually more straight forward now that all the locking requirements are better known.
Fix locking order comment
Rework for new 'state' names
(Other comments on the previous patch are not applicable with new patch as much of the code was removed in favor of the vfs level lock)
fs/xfs/xfs_inode.c | 22 ++++++++++++++++++++-- fs/xfs/xfs_inode.h | 7 +++++-- 2 files changed, 25 insertions(+), 4 deletions(-)
fs/xfs/xfs_inode.c +20 -2
@@ -142,12 +142,12 @@ xfs_ilock_attr_map_shared(* * Basic locking order: * -* i_rwsem -> i_mmap_lock -> page_lock -> i_ilock +* s_dax_sem -> i_rwsem -> i_mmap_lock -> page_lock -> i_ilock * * mmap_sem locking order: * * i_rwsem -> page lock -> mmap_sem -* mmap_sem -> i_mmap_lock -> page_lock +* s_dax_sem -> mmap_sem -> i_mmap_lock -> page_lock * * The difference in mmap_sem locking order mean that we cannot hold the * i_mmap_lock over syscall based read(2)/write(2) based IO. These IO paths can
@@ -182,6 +182,9 @@ xfs_ilock( (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));ASSERT ((lock_flags & ~(XFS_LOCK_MASK |XFS_LOCK_SUBCLASS_MASK )) ==0 ); +if (lock_flags &XFS_DAX_EXCL ) +inode_dax_state_down_write (VFS_I (ip)); +if (lock_flags &XFS_IOLOCK_EXCL ) {down_write_nested (&VFS_I (ip)->i_rwsem,XFS_IOLOCK_DEP (lock_flags));
@@ -224,6 +227,8 @@ xfs_ilock_nowait(* You can't set both SHARED and EXCL for the same lock, * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED, * and XFS_ILOCK_EXCL are valid values to set in lock_flags. +* +* XFS_DAX_* is not allowed */ ASSERT ((lock_flags & (XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL )) != (XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL ));
@@ -232,6 +237,7 @@ xfs_ilock_nowait(ASSERT ((lock_flags & (XFS_ILOCK_SHARED |XFS_ILOCK_EXCL )) != (XFS_ILOCK_SHARED |XFS_ILOCK_EXCL ));ASSERT ((lock_flags & ~(XFS_LOCK_MASK |XFS_LOCK_SUBCLASS_MASK )) ==0 ); +ASSERT ((lock_flags &XFS_DAX_EXCL ) ==0 );if (lock_flags &XFS_IOLOCK_EXCL ) {if (!down_write_trylock (&VFS_I (ip)->i_rwsem))
@@ -318,6 +324,9 @@ xfs_iunlock(else if (lock_flags &XFS_ILOCK_SHARED )mrunlock_shared (&ip->i_lock); +if (lock_flags &XFS_DAX_EXCL ) +inode_dax_state_up_write (VFS_I (ip)); +trace_xfs_iunlock (ip, lock_flags, _RET_IP_); }
@@ -333,6 +342,8 @@ xfs_ilock_demote(ASSERT (lock_flags & (XFS_IOLOCK_EXCL |XFS_MMAPLOCK_EXCL |XFS_ILOCK_EXCL ));ASSERT ((lock_flags & ~(XFS_IOLOCK_EXCL |XFS_MMAPLOCK_EXCL |XFS_ILOCK_EXCL )) ==0 ); +/* XFS_DAX_* is not allowed */ +ASSERT ((lock_flags &XFS_DAX_EXCL ) ==0 );if (lock_flags &XFS_ILOCK_EXCL )mrdemote (&ip->i_lock);
@@ -465,6 +476,9 @@ xfs_lock_inodes(ASSERT (!(lock_mode &XFS_ILOCK_EXCL ) || inodes <=XFS_ILOCK_MAX_SUBCLASS +1 ); +/* XFS_DAX_* is not allowed */ +ASSERT ((lock_mode &XFS_DAX_EXCL ) ==0 ); +if (lock_mode &XFS_IOLOCK_EXCL ) {ASSERT (!(lock_mode & (XFS_MMAPLOCK_EXCL |XFS_ILOCK_EXCL ))); }else if (lock_mode &XFS_MMAPLOCK_EXCL )
@@ -566,6 +580,10 @@ xfs_lock_two_inodes(ASSERT (!(ip0_mode & (XFS_MMAPLOCK_SHARED |XFS_MMAPLOCK_EXCL )) || !(ip1_mode & (XFS_ILOCK_SHARED |XFS_ILOCK_EXCL ))); +/* XFS_DAX_* is not allowed */ +ASSERT ((ip0_mode &XFS_DAX_EXCL ) ==0 ); +ASSERT ((ip1_mode &XFS_DAX_EXCL ) ==0 ); +ASSERT (ip0->i_ino != ip1->i_ino);if (ip0->i_ino > ip1->i_ino) {
fs/xfs/xfs_inode.h +5 -2
@@ -278,10 +278,12 @@ static inline void xfs_ifunlock(struct xfs_inode *ip)#define XFS_ILOCK_SHARED (1<<3)#define XFS_MMAPLOCK_EXCL (1<<4)#define XFS_MMAPLOCK_SHARED (1<<5) +#define XFS_DAX_EXCL (1<<6)#define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \ | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \ - | XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED) + | XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED \ + | XFS_DAX_EXCL)#define XFS_LOCK_FLAGS \ { XFS_IOLOCK_EXCL, "IOLOCK_EXCL" }, \
@@ -289,7 +291,8 @@ static inline void xfs_ifunlock(struct xfs_inode *ip) { XFS_ILOCK_EXCL, "ILOCK_EXCL" }, \ { XFS_ILOCK_SHARED, "ILOCK_SHARED" }, \ { XFS_MMAPLOCK_EXCL, "MMAPLOCK_EXCL" }, \ - { XFS_MMAPLOCK_SHARED, "MMAPLOCK_SHARED" } + { XFS_MMAPLOCK_SHARED, "MMAPLOCK_SHARED" }, \ + { XFS_DAX_EXCL, "DAX_EXCL" }/*
Signature · 1 line
2.21.0
PATCH v3 10/12 fs: Prevent DAX state change if file is mmap'ed
In reply to [email protected]From: Ira Weiny <[email protected]>
Page faults need to ensure the inode DAX configuration is correct and consistent with the vmf information at the time of the fault. There is no easy way to ensure the vmf information is correct if a DAX change is in progress. Furthermore, there is no good use case to require changing DAX configs while the file is mmap'ed.
Track mmap's of the file and fail the DAX change if the file is mmap'ed.
---
Changes from V2:
move 'i_mapped' to struct address_space and rename mmap_count Add inode_has_mappings() helper for FS's
Change reference to "mode" to "state"
fs/inode.c | 1 + fs/xfs/xfs_ioctl.c | 8 ++++++++ include/linux/fs.h | 6 ++++++ mm/mmap.c | 19 +++++++++++++++++-- 4 files changed, 32 insertions(+), 2 deletions(-)
fs/inode.c +1 -0
@@ -371,6 +371,7 @@ static void __address_space_init_once(struct address_space *mapping)INIT_LIST_HEAD (&mapping->private_list);spin_lock_init (&mapping->private_lock); mapping->i_mmap =RB_ROOT_CACHED ; +atomic64_set (&mapping->mmap_count,0 ); }void address_space_init_once (struct address_space *mapping)
fs/xfs/xfs_ioctl.c +8 -0
@@ -1214,6 +1214,14 @@ xfs_ioctl_setattr_dax_invalidate( goto out_unlock; } +/* +* If there is a mapping in place we must remain in our current state. +*/ +if (inode_has_mappings (inode)) { + error = -EBUSY ; + goto out_unlock; + } + error =filemap_write_and_wait (inode->i_mapping);if (error) goto out_unlock;
include/linux/fs.h +6 -0
@@ -459,6 +459,7 @@ struct address_space {#endif struct rb_root_cached i_mmap;struct rw_semaphore i_mmap_rwsem; +atomic64_t mmap_count;unsigned long nrpages;unsigned long nrexceptional;pgoff_t writeback_index;
@@ -1951,6 +1952,11 @@ static inline void enable_dax_state_static_branch(void)#define enable_dax_state_static_branch ()#endif /* CONFIG_FS_DAX */ +static inline bool inode_has_mappings (struct inode *inode) +{ +return (atomic64_read (&inode->i_mapping->mmap_count) !=0 ); +} +static inline ssize_t call_read_iter (struct file *file,struct kiocb *kio,struct iov_iter *iter) {
mm/mmap.c +17 -2
@@ -171,12 +171,17 @@ void unlink_file_vma(struct vm_area_struct *vma)static struct vm_area_struct *remove_vma (struct vm_area_struct *vma) {struct vm_area_struct *next = vma->vm_next; +struct file *f = vma->vm_file;might_sleep ();if (vma->vm_ops && vma->vm_ops->close) vma->vm_ops->close (vma); -if (vma->vm_file) -fput (vma->vm_file); +if (f) { +struct inode *inode =file_inode (f); +if (inode) +atomic64_dec (&inode->i_mapping->mmap_count); +fput (f); + }mpol_put (vma_policy (vma));vm_area_free (vma);return next;
@@ -1830,6 +1835,16 @@ unsigned long mmap_region(struct file *file, unsigned long addr,vma_set_page_prot (vma); +/* +* Track if there is mapping in place such that a state change +* does not occur on a file which is mapped +*/ +if (file) { +struct inode *inode =file_inode (file); + +atomic64_inc (&inode->i_mapping->mmap_count); + } +return addr; unmap_and_free_vma:
Signature · 1 line
2.21.0
PATCH v3 11/12 fs/xfs: Clean up locking in dax invalidate
In reply to [email protected]From: Ira Weiny <[email protected]>
Define a variable to hold the lock flags to ensure that the correct locks are returned or released on error.
--- fs/xfs/xfs_ioctl.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
fs/xfs/xfs_ioctl.c +6 -4
@@ -1190,7 +1190,7 @@ xfs_ioctl_setattr_dax_invalidate( int *join_flags) {struct inode *inode =VFS_I (ip); -int error; +int error, flags; *join_flags =0 ;
@@ -1205,8 +1205,10 @@ xfs_ioctl_setattr_dax_invalidate(if (S_ISDIR (inode->i_mode))return 0 ; + flags =XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ; +/* lock, flush and invalidate mapping in preparation for flag change */ -xfs_ilock (ip,XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ); +xfs_ilock (ip, flags);if ((fa->fsx_xflags &FS_XFLAG_DAX ) ==FS_XFLAG_DAX && !xfs_inode_supports_dax (ip)) {
@@ -1229,11 +1231,11 @@ xfs_ioctl_setattr_dax_invalidate(if (error) goto out_unlock; - *join_flags =XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ; + *join_flags = flags;return 0 ; out_unlock: -xfs_iunlock (ip,XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ); +xfs_iunlock (ip, flags);return error; }
Signature · 1 line
2.21.0
PATCH v3 12/12 fs/xfs: Allow toggle of effective DAX flag
In reply to [email protected]From: Ira Weiny <[email protected]>
Now that locking of the inode is in place we can allow a DAX state change while under the new lock.
---
Changes from V2:
Add in lock_dax_state_static_key static branch enabling.
fs/xfs/xfs_inode.h | 1 + fs/xfs/xfs_ioctl.c | 15 ++++++++++++--- fs/xfs/xfs_iops.c | 15 +++++++++++---- fs/xfs/xfs_super.c | 16 +++++++++------- 4 files changed, 33 insertions(+), 14 deletions(-)
fs/xfs/xfs_inode.h +1 -0
@@ -469,6 +469,7 @@ int xfs_break_layouts(struct inode *inode, uint *iolock,/* from xfs_iops.c */ extern void xfs_setup_inode (struct xfs_inode *ip);extern void xfs_setup_iops (struct xfs_inode *ip); +extern void xfs_setup_a_ops (struct xfs_inode *ip);/* * When setting up a newly allocated inode, we need to call
fs/xfs/xfs_ioctl.c +12 -3
@@ -1123,12 +1123,11 @@ xfs_diflags_to_linux( inode->i_flags |=S_NOATIME ; else inode->i_flags &= ~S_NOATIME; -#if 0 /* disabled until the flag switching races are sorted out */ if (xflags &FS_XFLAG_DAX ) inode->i_flags |=S_DAX ;else inode->i_flags &= ~S_DAX ; -#endif + } static int
@@ -1194,6 +1193,10 @@ xfs_ioctl_setattr_dax_invalidate( *join_flags =0 ; +#if !defined(CONFIG_FS_DAX ) +return -EINVAL ; +#endif +/* If the DAX state is not changing, we have nothing to do here. */ if ((fa->fsx_xflags &FS_XFLAG_DAX ) && (ip->i_d.di_flags2 &XFS_DIFLAG2_DAX ))
@@ -1205,7 +1208,7 @@ xfs_ioctl_setattr_dax_invalidate(if (S_ISDIR (inode->i_mode))return 0 ; - flags =XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL ; + flags =XFS_MMAPLOCK_EXCL |XFS_IOLOCK_EXCL |XFS_DAX_EXCL ;/* lock, flush and invalidate mapping in preparation for flag change */ xfs_ilock (ip, flags);
@@ -1526,6 +1529,9 @@ xfs_ioctl_setattr(else ip->i_d.di_cowextsize =0 ; +if (join_flags &XFS_DAX_EXCL ) +xfs_setup_a_ops (ip); + code =xfs_trans_commit (tp);/*
@@ -1635,6 +1641,9 @@ xfs_ioc_setxflags( goto out_drop_write; } +if (join_flags &XFS_DAX_EXCL ) +xfs_setup_a_ops (ip); + error =xfs_trans_commit (tp); out_drop_write:mnt_drop_write_file (filp);
fs/xfs/xfs_iops.c +11 -4
@@ -1366,6 +1366,16 @@ xfs_setup_inode( } } +void xfs_setup_a_ops (struct xfs_inode *ip) +{ +struct inode *inode = &ip->i_vnode; + +if (IS_DAX (inode)) + inode->i_mapping->a_ops = &xfs_dax_aops; +else + inode->i_mapping->a_ops = &xfs_address_space_operations; +} +void xfs_setup_iops (struct xfs_inode *ip)
@@ -1376,10 +1386,7 @@ xfs_setup_iops(case S_IFREG : inode->i_op = &xfs_inode_operations; inode->i_fop = &xfs_file_operations; -if (IS_DAX (inode)) - inode->i_mapping->a_ops = &xfs_dax_aops; -else - inode->i_mapping->a_ops = &xfs_address_space_operations; +xfs_setup_a_ops (ip);break ;case S_IFDIR :if (xfs_sb_version_hasasciici (&XFS_M (inode->i_sb)->m_sb))
fs/xfs/xfs_super.c +9 -7
@@ -1332,6 +1332,7 @@ xfs_fc_fill_super(struct xfs_mount *mp = sb->s_fs_info;struct inode *root;int flags =0 , error; +bool rtdev_is_dax = false, datadev_is_dax; mp->m_super = sb;
@@ -1437,17 +1438,18 @@ xfs_fc_fill_super(if (XFS_SB_VERSION_NUM (&mp->m_sb) ==XFS_SB_VERSION_5 ) sb->s_flags |=SB_I_VERSION ; -if (mp->m_flags &XFS_MOUNT_DAX ) { -bool rtdev_is_dax = false, datadev_is_dax; + datadev_is_dax =bdev_dax_supported (mp->m_ddev_targp->bt_bdev, + sb->s_blocksize); +if (mp->m_rtdev_targp) + rtdev_is_dax =bdev_dax_supported (mp->m_rtdev_targp->bt_bdev, + sb->s_blocksize); +if (rtdev_is_dax || datadev_is_dax) +enable_dax_state_static_branch (); +if (mp->m_flags &XFS_MOUNT_DAX ) {xfs_warn (mp,"DAX enabled. Warning: EXPERIMENTAL, use at your own risk" ); - datadev_is_dax =bdev_dax_supported (mp->m_ddev_targp->bt_bdev, - sb->s_blocksize); -if (mp->m_rtdev_targp) - rtdev_is_dax =bdev_dax_supported ( - mp->m_rtdev_targp->bt_bdev, sb->s_blocksize);if (!rtdev_is_dax && !datadev_is_dax) {xfs_alert (mp,"DAX unsupported by block device. Turning off DAX." );
Signature · 1 line
2.21.0
Hi, Ira,
Could you please include documentation patches as part of this series?
Thanks,
Jeff
Quoted 3 lines · Jeff Moyer
Hi, Ira,
Could you please include documentation patches as part of this series?
I do have an update to the vfs.rst doc in
fs: Add locking for a dynamic DAX state
I'm happy to do more but was there something specific you would like to see? Or documentation in xfs perhaps?
Ira
Quoted 4 lines
Thanks,
Jeff
Quoted 11 lines · Ira Weiny
Quoted 3 lines · Jeff Moyer
Hi, Ira,
Could you please include documentation patches as part of this series?
I do have an update to the
vfs.rstdoc infs: Add locking for a dynamic DAX state
I'm happy to do more but was there something specific you would like to see? Or documentation in xfs perhaps?
Sorry, I was referring to your statx man page addition. It would be nice if we could find a home for the information in your cover letter, too. Right now, I'm not sure how application developers are supposed to figure out how to use the per-inode settings.
If I read your cover letter correctly, the mount option overrides any on-disk setting. Is that right? Given that we document the dax mount option as "the way to get dax," it may be a good idea to allow for a user to selectively disable dax, even when -o dax is specified. Is that possible?
-Jeff
Quoted 7 lines · Jeff Moyer
Quoted 5 lines · Ira Weiny
Quoted 3 lines · Jeff Moyer
Hi, Ira,
Could you please include documentation patches as part of this series?
Quoted 8 lines
Quoted 6 lines
I do have an update to the
vfs.rstdoc infs: Add locking for a dynamic DAX state
I'm happy to do more but was there something specific you would like to see? Or documentation in xfs perhaps?
Sorry, I was referring to your statx man page addition.
Ah yea I guess I could include that as a patch. I just wanted to get buy off on the whole thing prior to setting documentation in.
Quoted 4 lines
It would be
nice if we could find a home for the information in your cover letter, too. Right now, I'm not sure how application developers are supposed to figure out how to use the per-inode settings.
I'm not sure either. But this is probably a good start:
https://www.kernel.org/doc/Documentation/filesystems/dax.txt
Something under the Usage section like:
Documentation/filesystems/dax.txt +12 -2
@@ -20,8 +20,18 @@ Usage If you have a block device which supports DAX, you can make a filesystem on it as usual. The DAX code currently only supports files with a block size equal to your kernel's PAGE_SIZE, so you may need to specify a block -size when creating the filesystem. When mounting it, use the "-o dax" -option on the command line or add 'dax' to the options in /etc/fstab. +size when creating the filesystem. + +Files can then be enabled to use dax using the statx system call or an +application using it like 'xfs_io'. Directories can also be enabled for dax +to have the file system automatically enable dax on all files within those +directories. + +Alternately, when mounting it one can use the "-o dax" option on the command +line or add 'dax' to the options in /etc/fstab to globaly override all files to +use dax on that filesystem. Using the "-o dax" does not change the state of +individual files so remounting without "-o dax" will revert them to the state +saved in the filesystem meta data. Implementation Tips for Block Driver Writers
Quoted 3 lines
If I read your cover letter correctly, the mount option overrides any on-disk setting. Is that right?
Yes
Quoted 4 lines
Given that we document the dax mount
option as "the way to get dax," it may be a good idea to allow for a user to selectively disable dax, even when -o dax is specified. Is that possible?
Not with this patch set. And I'm not sure how that would work. The idea was that -o dax was simply an override for users who were used to having their entire FS be dax. We wanted to depreciate the use of "-o dax" in general. The individual settings are saved so I don't think it makes sense to ignore the -o dax in favor of those settings. Basically that would IMO make the -o dax useless.
Ira
Quoted 3 lines · Ira Weiny
Quoted 2 lines · Jeff Moyer
Ira Weiny <[email protected]> writes:
[snip]
Quoted 11 lines
Quoted 4 lines
Given that we document the dax mount
option as "the way to get dax," it may be a good idea to allow for a user to selectively disable dax, even when -o dax is specified. Is that possible?Not with this patch set. And I'm not sure how that would work. The idea was that -o dax was simply an override for users who were used to having their entire FS be dax. We wanted to depreciate the use of "-o dax" in general. The individual settings are saved so I don't think it makes sense to ignore the -o dax in favor of those settings. Basically that would IMO make the -o dax useless.
Oh and I forgot to mention that setting 'dax' on the root of the FS basically provides '-o dax' functionality by default with the ability to "turn it off" for files.
Ira
Quoted 3 lines
Ira
Quoted 19 lines · Ira Weiny
Quoted 3 lines · Ira Weiny
Quoted 2 lines · Jeff Moyer
Ira Weiny <[email protected]> writes:
[snip]
Quoted 11 lines
Quoted 4 lines
Given that we document the dax mount
option as "the way to get dax," it may be a good idea to allow for a user to selectively disable dax, even when -o dax is specified. Is that possible?Not with this patch set. And I'm not sure how that would work. The idea was that -o dax was simply an override for users who were used to having their entire FS be dax. We wanted to depreciate the use of "-o dax" in general. The individual settings are saved so I don't think it makes sense to ignore the -o dax in favor of those settings. Basically that would IMO make the -o dax useless.
Quoted 3 lines
Oh and I forgot to mention that setting 'dax' on the root of the FS basically provides '-o dax' functionality by default with the ability to "turn it off" for files.
Please don't further confuse FS_XFLAG_DAX and S_DAX. They are two separate flags with two separate behaviors:
FS_XFLAG_DAX is a filesystem inode metadata flag.
Setting FS_XFLAG_DAX on a directory causes all files and directories created within that directory to inherit FS_XFLAG_DAX.
Mounting with -o dax causes all files and directories created to have FS_XFLAG_DAX set regardless of the parent's status.
The FS_XFLAG_DAX can be get and set via the fs[g]etxattr ioctl.
-------
S_DAX is the flag that controls the IO path in the kernel for a given inode.
Loading a file inode into the kernel (via _iget) with FS_XFLAG_DAX set or creating a file inode that inherits FS_XFLAG_DAX causes the incore inode to have the S_DAX flag set if the storage device supports it.
Files with S_DAX set use the dax IO paths through the kernel.
The S_DAX flag can be queried via statx.
--D
Quoted 5 lines
Ira
Quoted 3 lines
Ira
Quoted 20 lines · Darrick J. Wong
Quoted 19 lines · Ira Weiny
Quoted 3 lines · Ira Weiny
Quoted 2 lines · Jeff Moyer
Ira Weiny <[email protected]> writes:
[snip]
Quoted 11 lines
Quoted 4 lines
Given that we document the dax mount
option as "the way to get dax," it may be a good idea to allow for a user to selectively disable dax, even when -o dax is specified. Is that possible?Not with this patch set. And I'm not sure how that would work. The idea was that -o dax was simply an override for users who were used to having their entire FS be dax. We wanted to depreciate the use of "-o dax" in general. The individual settings are saved so I don't think it makes sense to ignore the -o dax in favor of those settings. Basically that would IMO make the -o dax useless.
Quoted 5 lines
Quoted 3 lines
Oh and I forgot to mention that setting 'dax' on the root of the FS basically provides '-o dax' functionality by default with the ability to "turn it off" for files.
Please don't further confuse
FS_XFLAG_DAXandS_DAX.
Yes... the above text is wrong WRT statx. But setting the physical XFS_DIFLAG2_DAX flag on the root directory will by default cause all files and directories created there to be XFS_DIFLAG2_DAX and so forth on down the tree unless explicitly changed. This will be the same as mounting with '-o dax' but with the ability to turn off dax for individual files. Which I think is the functionality Jeff is wanting.
Quoted 11 lines
They are two
separate flags with two separate behaviors:
FS_XFLAG_DAXis a filesystem inode metadata flag.Setting
FS_XFLAG_DAXon a directory causes all files and directories created within that directory to inheritFS_XFLAG_DAX.Mounting with -o dax causes all files and directories created to have
FS_XFLAG_DAXset regardless of the parent's status.
I don't believe this is true, either before _or_ after this patch set.
'-o dax' only causes XFS_MOUNT_DAX to be set which then cause S_DAX to be set. It does not affect FS_XFLAG_DAX. This is important because we don't want '-o dax' to suddenly convert all files to DAX if '-o dax' is not used.
Quoted 2 lines
The
FS_XFLAG_DAXcan be get and set via the fs[g]etxattr ioctl.
Right statx was the wrong tool...
fs[g|s]etattr via the xfs_io -c 'chatttr|lsattr' is the correct tool.
Quoted 9 lines
-------
S_DAXis the flag that controls the IO path in the kernel for a given inode.Loading a file inode into the kernel (via
_iget) withFS_XFLAG_DAXset or creating a file inode that inheritsFS_XFLAG_DAXcauses the incore inode to have theS_DAXflag set if the storage device supports it.
Yes after reworking "Clean up DAX support check" I believe I've got it correct now. Soon to be in V4.
Quoted 4 lines
Files with
S_DAXset use the dax IO paths through the kernel.The
S_DAXflag can be queried via statx.
Yes as a verification that the file is at that moment operating as dax. It will not return true for a directory ever. My bad for saying that. Sorry I got my tools flags mixed up...
Ira
Quoted 26 lines · Ira Weiny
Quoted 24 lines · Darrick J. Wong
Quoted 22 lines · Ira Weiny
Quoted 3 lines · Ira Weiny
Quoted 2 lines · Jeff Moyer
Ira Weiny <[email protected]> writes:
[snip]
Quoted 11 lines
Quoted 4 lines
Given that we document the dax mount
option as "the way to get dax," it may be a good idea to allow for a user to selectively disable dax, even when -o dax is specified. Is that possible?Not with this patch set. And I'm not sure how that would work. The idea was that -o dax was simply an override for users who were used to having their entire FS be dax. We wanted to depreciate the use of "-o dax" in general. The individual settings are saved so I don't think it makes sense to ignore the -o dax in favor of those settings. Basically that would IMO make the -o dax useless.
Oh and I forgot to mention that setting 'dax' on the root of the FS basically provides '-o dax' functionality by default with the ability to "turn it off" for files.
Quoted 8 lines
Quoted 1 line
Please don't further confuse
FS_XFLAG_DAXandS_DAX.Yes... the above text is wrong WRT statx. But setting the physical
XFS_DIFLAG2_DAXflag on the root directory will by default cause all files and directories created there to beXFS_DIFLAG2_DAXand so forth on down the tree unless explicitly changed. This will be the same as mounting with '-o dax' but with the ability to turn off dax for individual files. Which I think is the functionality Jeff is wanting.
To be clear you mean turn off XFS_DIFLAG2_DAX, not mask S_DAX when you say "turn off dax", right?
The mount option simply forces "S_DAX" on all regular files as long as the underlying device (or soon to be superblock for virtiofs) supports it. There is no method to mask S_DAX when the filesystem was mounted with -o dax. Otherwise we would seem to need yet another physical flag to "always disable" dax.
Quoted 36 lines · Dan Williams
Quoted 26 lines · Ira Weiny
Quoted 24 lines · Darrick J. Wong
Quoted 22 lines · Ira Weiny
Quoted 3 lines · Ira Weiny
Quoted 2 lines · Jeff Moyer
Ira Weiny <[email protected]> writes:
[snip]
Quoted 11 lines
Quoted 4 lines
Given that we document the dax mount
option as "the way to get dax," it may be a good idea to allow for a user to selectively disable dax, even when -o dax is specified. Is that possible?Not with this patch set. And I'm not sure how that would work. The idea was that -o dax was simply an override for users who were used to having their entire FS be dax. We wanted to depreciate the use of "-o dax" in general. The individual settings are saved so I don't think it makes sense to ignore the -o dax in favor of those settings. Basically that would IMO make the -o dax useless.
Oh and I forgot to mention that setting 'dax' on the root of the FS basically provides '-o dax' functionality by default with the ability to "turn it off" for files.
Quoted 8 lines
Quoted 1 line
Please don't further confuse
FS_XFLAG_DAXandS_DAX.Yes... the above text is wrong WRT statx. But setting the physical
XFS_DIFLAG2_DAXflag on the root directory will by default cause all files and directories created there to beXFS_DIFLAG2_DAXand so forth on down the tree unless explicitly changed. This will be the same as mounting with '-o dax' but with the ability to turn off dax for individual files. Which I think is the functionality Jeff is wanting.
Quoted 2 lines
To be clear you mean turn off
XFS_DIFLAG2_DAX, not maskS_DAXwhen you say "turn off dax", right?
Yes.
[disclaimer: the following assumes the underlying 'device' (superblock) supports DAX]
... which results in S_DAX == false when the file is opened without the mount option. The key would be that all directories/files created under a root with XFS_DIFLAG2_DAX == true would inherit their flag and be XFS_DIFLAG2_DAX == true all the way down the tree. Any file not wanting DAX would need to set XFS_DIFLAG2_DAX == false. And setting false could be used on a directory to allow a user or group to not use dax on files in that sub-tree.
Then without '-o dax' (XFS_MOUNT_DAX == false) all files when opened set S_DAX equal to XFS_DIFLAG2_DAX value. (Directories, as of V4, never get S_DAX set.)
If '-o dax' (XFS_MOUNT_DAX == true) then S_DAX is set on all files.
[IF the underlying 'device' (superblock) does _not_ support DAX]
... S_DAX is _never_ set but the underlying XFS_DIFLAG2_DAX flags can be toggled and will be inherited as above. Because S_DAX is never set access to that file will be restricted to "not dax"...[1]
I could go into that level of detail in the doc if needed? I feel like we need a more general name for XFS_DIFLAG2_DAX if I do.[2]
Quoted 6 lines
The mount option simply forces "
S_DAX" on all regular files as long as the underlying device (or soon to be superblock for virtiofs) supports it. There is no method to maskS_DAXwhen the filesystem was mounted with -o dax. Otherwise we would seem to need yet another physical flag to "always disable" dax.
Exactly. I don't think we want to support that. From this thread alone it seems we have enough complexity and that would be another layer...
;-)
Ira
[1] I'm beginning to think that if I type dax one more time I'm going to go crazy... :-P
[2] I have patches in the wings to introduce EXT4_DAX_FL as an ext4 on disk bit which would be equivalent to XFS_DIFLAG2_DAX. If anyone wants a better name let me know.
Quoted 10 lines · Ira Weiny
[disclaimer: the following assumes the underlying 'device' (superblock) supports DAX]
... which results in
S_DAX== false when the file is opened without the mount option. The key would be that all directories/files created under a root withXFS_DIFLAG2_DAX== true would inherit their flag and beXFS_DIFLAG2_DAX== true all the way down the tree. Any file not wanting DAX would need to setXFS_DIFLAG2_DAX== false. And setting false could be used on a directory to allow a user or group to not use dax on files in that sub-tree.
Quoted 4 lines
Then without '-o dax' (
XFS_MOUNT_DAX== false) all files when opened setS_DAXequal toXFS_DIFLAG2_DAXvalue. (Directories, as of V4, never getS_DAXset.)If '-o dax' (
XFS_MOUNT_DAX== true) thenS_DAXis set on all files.
One more clarifying question. Let's say I set XFS_DIFLAG2_DAX on an inode. I then open the file, and perform mmap/load/store/etc. I close the file, and I unset XFS_DIFLAG2_DAX. Will the next open treat the file as S_DAX or not? My guess is the inode won't be evicted, and so S_DAX will remain set.
The reason I ask is I've had requests from application developers to do just this. They want to be able to switch back and forth between dax modes.
Thanks,
Jeff
Quoted 2 lines
[1] I'm beginning to think that if I type dax one more time I'm going to go crazy... :-P
dax dax dax!
Quoted 15 lines · Jeff Moyer
Quoted 13 lines · Ira Weiny
[disclaimer: the following assumes the underlying 'device' (superblock) supports DAX]
... which results in
S_DAX== false when the file is opened without the mount option. The key would be that all directories/files created under a root withXFS_DIFLAG2_DAX== true would inherit their flag and beXFS_DIFLAG2_DAX== true all the way down the tree. Any file not wanting DAX would need to setXFS_DIFLAG2_DAX== false. And setting false could be used on a directory to allow a user or group to not use dax on files in that sub-tree.Then without '-o dax' (
XFS_MOUNT_DAX== false) all files when opened setS_DAXequal toXFS_DIFLAG2_DAXvalue. (Directories, as of V4, never getS_DAXset.)
Quoted 7 lines
Quoted 1 line
If '-o dax' (
XFS_MOUNT_DAX== true) thenS_DAXis set on all files.One more clarifying question. Let's say I set
XFS_DIFLAG2_DAXon an inode. I then open the file, and perform mmap/load/store/etc. I close the file, and I unsetXFS_DIFLAG2_DAX. Will the next open treat the file asS_DAXor not? My guess is the inode won't be evicted, and soS_DAXwill remain set.
The inode will not be evicted, or even it happens to be xfs_io will reload it to unset the XFS_DIFLAG2_DAX flag. And the S_DAX flag changes _with_ the XFS_DIFLAG2_DAX change when it can (when the underlying storage supports S_DAX).
Trying to change XFS_DIFLAG2_DAX while the file is mmap'ed returns -EBUSY.
Ira
Quoted 13 lines
The reason I ask is I've had requests from application developers to do just this. They want to be able to switch back and forth between dax modes.
Thanks,
JeffQuoted 2 lines
[1] I'm beginning to think that if I type dax one more time I'm going to go crazy... :-P
dax dax dax!
Quoted 24 lines · Ira Weiny
Quoted 15 lines · Jeff Moyer
Quoted 13 lines · Ira Weiny
[disclaimer: the following assumes the underlying 'device' (superblock) supports DAX]
... which results in
S_DAX== false when the file is opened without the mount option. The key would be that all directories/files created under a root withXFS_DIFLAG2_DAX== true would inherit their flag and beXFS_DIFLAG2_DAX== true all the way down the tree. Any file not wanting DAX would need to setXFS_DIFLAG2_DAX== false. And setting false could be used on a directory to allow a user or group to not use dax on files in that sub-tree.Then without '-o dax' (
XFS_MOUNT_DAX== false) all files when opened setS_DAXequal toXFS_DIFLAG2_DAXvalue. (Directories, as of V4, never getS_DAXset.)Quoted 7 lines
Quoted 1 line
If '-o dax' (
XFS_MOUNT_DAX== true) thenS_DAXis set on all files.One more clarifying question. Let's say I set
XFS_DIFLAG2_DAXon an inode. I then open the file, and perform mmap/load/store/etc. I close the file, and I unsetXFS_DIFLAG2_DAX. Will the next open treat the file asS_DAXor not? My guess is the inode won't be evicted, and soS_DAXwill remain set.
Quoted 4 lines
The inode will not be evicted, or even it happens to be
xfs_iowill reload it to unset theXFS_DIFLAG2_DAXflag. And theS_DAXflag changes _with_ theXFS_DIFLAG2_DAXchange when it can (when the underlying storage supportsS_DAX).
OK, so it will be possible to change the effective mode.
I'll try to get some testing in on this series, now.
Thanks!
Jeff
Hi, Ira,
Quoted 1 line · Jeff Moyer
I'll try to get some testing in on this series, now.
This series panics in xfstests generic/013, when run like so:
MKFS_OPTIONS="-m reflink=0" MOUNT_OPTIONS="-o dax" ./check -g auto
I'd dig in further, but it's late on a Friday. You understand. :)
Cheers,
Jeff
Quoted 11 lines · Jeff Moyer
Hi, Ira,
Quoted 1 line · Jeff Moyer
I'll try to get some testing in on this series, now.
This series panics in xfstests generic/013, when run like so:
MKFS_OPTIONS="-m reflink=0" MOUNT_OPTIONS="-o dax" ./check -g auto
I'd dig in further, but it's late on a Friday. You understand. :)
Sorry, I should have at least given you a clue. Below is the stack trace. We're going down the buffered I/O path, even though the fs is mounted with -o dax. Somewhere the inode isn't getting marked properly.
-Jeff
[ 549.461099] BUG: kernel NULL pointer dereference, address: 0000000000000000 [ 549.468053] #PF: supervisor instruction fetch in kernel mode [ 549.473713] #PF: error_code(0x0010) - not-present page [ 549.478851] PGD 17c7e06067 P4D 17c7e06067 PUD 17c7e01067 PMD 0 [ 549.484773] Oops: 0010 [#1] SMP NOPTI [ 549.488438] CPU: 68 PID: 19851 Comm: fsstress Not tainted 5.6.0-rc1+ #42 [ 549.495134] Hardware name: Intel Corporation S2600WFD/S2600WFD, BIOS SE5C620.86B.0D.01.0395.022720191340 02/27/2019 [ 549.505562] RIP: 0010:0x0 [ 549.508186] Code: Bad RIP value. [ 549.511418] RSP: 0018:ffffab132dc9fa98 EFLAGS: 00010246 [ 549.516642] RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000001 [ 549.523768] RDX: 0000000000000000 RSI: ffffdcf75e7060c0 RDI: ffff8c3805d22300 [ 549.530900] RBP: ffffab132dc9fb08 R08: 0000000000000000 R09: 00002308a18f9f3f [ 549.538030] R10: 0000000000000000 R11: ffffdcf75f4b19c0 R12: ffff8c37cfe6d2b8 [ 549.545155] R13: ffffab132dc9fb60 R14: ffffdcf75e7060c8 R15: ffffdcf75e7060c0 [ 549.552288] FS: 00007f849d20cb80(0000) GS:ffff8c3821100000(0000) knlGS:0000000000000000 [ 549.560373] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 549.566117] CR2: ffffffffffffffd6 CR3: 00000017d3088005 CR4: 00000000007606e0 [ 549.573250] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 549.580383] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 549.587515] PKRU: 55555554 [ 549.590228] Call Trace: [ 549.592683] read_pages+0x120/0x190 [ 549.596173] __do_page_cache_readahead+0x1c1/0x1e0 [ 549.600965] ondemand_readahead+0x182/0x2f0 [ 549.605152] generic_file_buffered_read+0x5a6/0xaf0 [ 549.610032] ? security_inode_permission+0x30/0x50 [ 549.614824] ? _cond_resched+0x15/0x30 [ 549.618620] xfs_file_buffered_aio_read+0x47/0xe0 [xfs] [ 549.623861] xfs_file_read_iter+0x6e/0xd0 [xfs] [ 549.628394] generic_file_splice_read+0x100/0x220 [ 549.633099] splice_direct_to_actor+0xd5/0x220 [ 549.637543] ? pipe_to_sendpage+0xa0/0xa0 [ 549.641557] do_splice_direct+0x9a/0xd0 [ 549.645396] vfs_copy_file_range+0x153/0x320 [ 549.649667] __x64_sys_copy_file_range+0xdd/0x200 [ 549.654375] do_syscall_64+0x55/0x1d0 [ 549.658039] entry_SYSCALL_64_after_hwframe+0x44/0xa9 [ 549.663091] RIP: 0033:0x7f849c7086bd [ 549.666671] Code: 00 c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d 9b 67 2c 00 f7 d8 64 89 01 48 [ 549.685414] RSP: 002b:00007fff81b78678 EFLAGS: 00000246 ORIG_RAX: 0000000000000146 [ 549.692980] RAX: ffffffffffffffda RBX: 00000000000000c9 RCX: 00007f849c7086bd [ 549.700112] RDX: 0000000000000004 RSI: 00007fff81b786b0 RDI: 0000000000000003 [ 549.707242] RBP: 00000000005d92ef R08: 0000000000006cb4 R09: 0000000000000000 [ 549.714375] R10: 00007fff81b786b8 R11: 0000000000000246 R12: 0000000000000003 [ 549.721508] R13: 0000000000006cb4 R14: 0000000000037f58 R15: 0000000000365871 [ 549.728641] Modules linked in: xt_CHECKSUM nft_chain_nat xt_MASQUERADE nf_nat xt_conntrack nf_conntrack nf_defrag_ipv6 nf_defrag_ipv4 ipt_REJECT nf_reject_ipv4 nft_counter nft_compat nf_tables nfnetlink tun bridge stp llc rfkill sunrpc vfat fat intel_rapl_msr intel_rapl_common skx_edac x86_pkg_temp_thermal intel_powerclamp coretemp kvm_intel iTCO_wdt iTCO_vendor_support kvm irqbypass crct10dif_pclmul ipmi_ssif crc32_pclmul ghash_clmulni_intel intel_cstate intel_uncore mei_me ipmi_si joydev intel_rapl_perf ioatdma pcspkr ipmi_devintf sg i2c_i801 lpc_ich mei dca ipmi_msghandler dax_pmem dax_pmem_core acpi_power_meter acpi_pad xfs libcrc32c nd_pmem nd_btt sd_mod sr_mod cdrom ast i2c_algo_bit drm_vram_helper drm_ttm_helper ttm drm_kms_helper syscopyarea sysfillrect sysimgblt fb_sys_fops cec crc32c_intel i40e drm nvme ahci nvme_core libahci t10_pi libata wmi nfit libnvdimm [ 549.805384] CR2: 0000000000000000 [ 549.808744] ---[ end trace 62568a4ecc43ee90 ]---
Quoted 11 lines · Jeff Moyer
Hi, Ira,
Quoted 1 line · Jeff Moyer
I'll try to get some testing in on this series, now.
This series panics in xfstests generic/013, when run like so:
MKFS_OPTIONS="-m reflink=0" MOUNT_OPTIONS="-o dax" ./check -g auto
I'd dig in further, but it's late on a Friday. You understand. :)
Yep... and a long weekend if you are in the US... I ran the test with V4 and got the panic below.
Is this similar to what you see? If so I'll work on it in V4. FWIW with '-o dax' specified I don't see how fsstress is causing an issue with my patch set. Does fsstress attempt to change dax states? I don't see that in the test but I'm not real familiar with generic/013 and fsstress.
If my disassembly of read_pages is correct it looks like readpage is null which makes sense because all files should be IS_DAX() == true due to the mount option...
But tracing code indicates that the patch:
fs: remove unneeded IS_DAX() check
... may be the culprit and the following fix may work...
mm/filemap.c +1 -1
@@ -2257,7 +2257,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)if (!count) goto out;/* skip atime */ -if (iocb->ki_flags &IOCB_DIRECT ) { +if (iocb->ki_flags &IOCB_DIRECT ||IS_DAX (inode)) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;
And of course now my server is not responding so I can't reboot to test it... :-(
I'll continue tomorrow after I go press the power button on the machine since IPMI has decided not to work... :-(
Ira
[ 1204.461801] BUG: kernel NULL pointer dereference, address: 0000000000000000 [ 1204.472375] #PF: supervisor instruction fetch in kernel mode [ 1204.481440] #PF: error_code(0x0010) - not-present page [ 1204.489920] PGD 80000003c273d067 P4D 80000003c273d067 PUD 36a73b067 PMD 0 [ 1204.500396] Oops: 0010 [#1] SMP KASAN PTI [ 1204.507617] CPU: 6 PID: 15714 Comm: fsstress Not tainted 5.5.0-next-20200207+ #1 [ 1204.518632] Hardware name: Intel Corporation SandyBridge Platform/00, BIOS SE5C600.86B.02.04.0003.102320141138 10/23/2014 [ 1204.533715] RIP: 0010:0x0 [ 1204.539444] Code: Bad RIP value. [ 1204.545813] RSP: 0018:ffff88837dedf528 EFLAGS: 00010246 [ 1204.554454] RAX: 0000000000000000 RBX: ffffea000cb6ae08 RCX: ffffffff813765fc [ 1204.565223] RDX: dffffc0000000000 RSI: ffffea000cb6ae00 RDI: ffff8887b032a800 [ 1204.575943] RBP: ffff88837dedf618 R08: fffff9400196d5c1 R09: fffff9400196d5c1 [ 1204.586657] R10: fffff9400196d5c0 R11: ffffea000cb6ae07 R12: ffffea000cb6ae00 [ 1204.597362] R13: ffffffffa0ac3da0 R14: 0000000000000000 R15: ffff888342a14040 [ 1204.608061] FS: 00007fc47c0a8b80(0000) GS:ffff8883c7100000(0000) knlGS:0000000000000000 [ 1204.619869] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 1204.629010] CR2: ffffffffffffffd6 CR3: 0000000325892002 CR4: 00000000000606e0 [ 1204.639695] Call Trace: [ 1204.645128] read_pages+0x23d/0x2f0 [ 1204.651691] ? read_cache_pages+0x2b0/0x2b0 [ 1204.659030] ? policy_node+0x56/0x60 [ 1204.665675] __do_page_cache_readahead+0x28b/0x2b0 [ 1204.673641] ? read_pages+0x2f0/0x2f0 [ 1204.680286] ondemand_readahead+0x2bf/0x5d0 [ 1204.687561] generic_file_buffered_read+0x992/0x1170 [ 1204.695703] ? read_cache_page_gfp+0x20/0x20 [ 1204.703052] ? down_read_nested+0x10b/0x2d0 [ 1204.710266] ? downgrade_write+0x270/0x270 [ 1204.717399] ? lock_acquire+0x101/0x200 [ 1204.724171] ? generic_file_splice_read+0x20d/0x350 [ 1204.732067] ? generic_file_read_iter+0x3b/0x220 [ 1204.739736] ? xfs_file_buffered_aio_read+0x87/0x1d0 [xfs] [ 1204.748351] xfs_file_buffered_aio_read+0x92/0x1d0 [xfs] [ 1204.756759] xfs_file_read_iter+0x120/0x1f0 [xfs] [ 1204.764420] generic_file_splice_read+0x239/0x350 [ 1204.772072] ? pipe_to_user+0x80/0x80 [ 1204.778476] splice_direct_to_actor+0x1d8/0x460 [ 1204.785831] ? pipe_to_sendpage+0x1a0/0x1a0 [ 1204.792769] ? do_splice_to+0xc0/0xc0 [ 1204.799144] ? selinux_file_permission+0x1d2/0x210 [ 1204.806734] do_splice_direct+0x10c/0x170 [ 1204.813393] ? splice_direct_to_actor+0x460/0x460 [ 1204.820830] ? debug_lockdep_rcu_enabled+0x23/0x60 [ 1204.828349] ? __sb_start_write+0x12c/0x1f0 [ 1204.835177] vfs_copy_file_range+0x309/0x5c0 [ 1204.842085] ? __x64_sys_sendfile+0x160/0x160 [ 1204.849039] ? from_kgid+0xa0/0xa0 [ 1204.854879] ? _copy_to_user+0x6a/0x80 [ 1204.861067] ? cp_new_stat+0x271/0x2c0 [ 1204.867238] ? __ia32_sys_lstat+0x30/0x30 [ 1204.873672] ? down_read_non_owner+0x2e0/0x2e0 [ 1204.880579] __x64_sys_copy_file_range+0x17a/0x310 [ 1204.887844] ? __ia32_sys_copy_file_range+0x320/0x320 [ 1204.895369] ? lockdep_hardirqs_off+0x1a/0x140 [ 1204.902142] do_syscall_64+0x78/0x300 [ 1204.908056] entry_SYSCALL_64_after_hwframe+0x49/0xbe [ 1204.915507] RIP: 0033:0x7fc47c1a1d6d [ 1204.921283] Code: 00 c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d eb 80 0c 00 f7 d8 64 89 01 48 [ 1204.946109] RSP: 002b:00007ffd9cc4cc08 EFLAGS: 00000202 ORIG_RAX: 0000000000000146 [ 1204.956531] RAX: ffffffffffffffda RBX: 0000000000000047 RCX: 00007fc47c1a1d6d [ 1204.966477] RDX: 0000000000000004 RSI: 00007ffd9cc4cc40 RDI: 0000000000000003 [ 1204.976394] RBP: 000000000061a35e R08: 000000000000f15b R09: 0000000000000000 [ 1204.986279] R10: 00007ffd9cc4cc48 R11: 0000000000000202 R12: 0000000000000003 [ 1204.996142] R13: 000000000000f15b R14: 00000000000326f7 R15: 0000000000159373 [ 1205.005983] Modules linked in: vfat fat isofs rfkill ib_isert
iscsi_target_mod ib_srpt target_core_mod ib_srp scsi_transport_srp opa_vnic rpcrdma sunrpc rdma_ucm ib_iser ib_umad rdma_cm ib_ipoib iw_cm dax_pmem_compat libiscsi iTCO_wdt device_dax nd_pmem ib_cm dax_pmem_core nd_btt iTCO_vendor_support scsi_transport_iscsi snd_hda_codec_realtek snd_hda_codec_generic ledtrig_audio sb_edac x86_pkg_temp_thermal intel_powerclamp coretemp crct10dif_pclmul crc32_pclmul ghash_clmulni_intel snd_hda_intel hfi1 snd_intel_dspcfg snd_hda_codec snd_hda_core aesni_intel snd_hwdep crypto_simd snd_pcm rdmavt snd_timer nd_e820 ib_uverbs cryptd libnvdimm snd ib_core soundcore glue_helper ipmi_si mei_me ipmi_devintf pcspkr mei i2c_i801 ipmi_msghandler lpc_ich mfd_core ioatdma wmi acpi_cpufreq sch_fq_codel xfs libcrc32c mlx4_en sr_mod cdrom sd_mod t10_pi mgag200 drm_kms_helper syscopyarea sysfillrect sysimgblt fb_sys_fops drm_vram_helper drm_ttm_helper ahci ttm crc32c_intel libahci mlx4_core isci igb libsas drm
[ 1205.006047] dca scsi_transport_sas firewire_ohci i2c_algo_bit firewire_core crc_itu_t libata i2c_core dm_mod [last unloaded: mlx4_ib] [ 1205.140277] CR2: 0000000000000000 [ 1205.146689] ---[ end trace cf133ac3f2876827 ]---
Quoted 4 lines
Cheers,
Jeff
Quoted 4 lines · Ira Weiny
Yep... and a long weekend if you are in the US... I ran the test with V4 and got the panic below.
Is this similar to what you see? If so I'll work on it in V4. FWIW with '-o
Yes, precisely.
Quoted 3 lines
dax' specified I don't see how fsstress is causing an issue with my patch set. Does fsstress attempt to change dax states? I don't see that in the test but I'm not real familiar with generic/013 and fsstress.
Not that I'm aware of, no.
Quoted 14 lines
If my disassembly of
read_pagesis correct it looks like readpage is null which makes sense because all files should beIS_DAX()== true due to the mount option...But tracing code indicates that the patch:
fs: remove unneeded
IS_DAX()check... may be the culprit and the following fix may work...
mm/filemap.c +0
-0
mm/filemap.c generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) · line 2263
Quoted 8 lines
mm/filemap.c +1
-1@@ -2257,7 +2257,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)if (!count) goto out;/* skip atime */ -if (iocb->ki_flags &IOCB_DIRECT ) { +if (iocb->ki_flags &IOCB_DIRECT ||IS_DAX (inode)) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;
Well, you'll have to up-level the inode variable instantiation, obviously. That solves this particular issue. The next traceback you'll hit is in the writeback path:
[ 116.044545] ------------[ cut here ]------------ [ 116.049163] WARNING: CPU: 48 PID: 4469 at fs/dax.c:862 dax_writeback_mapping_range+0x397/0x530 ... [ 116.134509] CPU: 48 PID: 4469 Comm: fsstress Not tainted 5.6.0-rc1+ #43 [ 116.141121] Hardware name: Intel Corporation S2600WFD/S2600WFD, BIOS SE5C620.86B.0D.01.0395.022720191340 02/27/2019 [ 116.151549] RIP: 0010:dax_writeback_mapping_range+0x397/0x530 [ 116.157294] Code: ff ff 31 db 48 8b 7c 24 28 c6 07 00 0f 1f 40 00 fb 48 8b 7c 24 10 e8 98 fc 29 00 0f 1f 44 00 00 e9 f1 fc ff ff 4c 8b 64 24 08 <0f> 0b be fb ff ff ff 4c 89 e7 e8 fa 87 ed ff f0 41 80 8c 24 80 00 [ 116.176036] RSP: 0018:ffffb9b162fa7c18 EFLAGS: 00010046 [ 116.181261] RAX: 0000000000000000 RBX: 00000000000001ac RCX: 0000000000000020 [ 116.188387] RDX: 0000000000000000 RSI: 00000000000001ac RDI: ffffb9b162fa7c40 [ 116.195519] RBP: 0000000000000020 R08: ffff9a73dc24d6b0 R09: 0000000000000020 [ 116.202648] R10: 0000000000000000 R11: 0000000000000238 R12: ffff9a73d92c66b8 [ 116.209774] R13: ffffe4a09f0cb200 R14: 0000000000000000 R15: ffffe4a09f0cb200 [ 116.216907] FS: 00007f2dbcd22b80(0000) GS:ffff9a7420c00000(0000) knlGS:0000000000000000 [ 116.224992] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 116.230735] CR2: 00007fa21808b648 CR3: 000000179e0a2003 CR4: 00000000007606e0 [ 116.237860] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 116.244990] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 116.252115] PKRU: 55555554 [ 116.254827] Call Trace: [ 116.257286] do_writepages+0x41/0xd0 [ 116.260862] __filemap_fdatawrite_range+0xcb/0x100 [ 116.265653] filemap_write_and_wait_range+0x38/0x90 [ 116.270579] xfs_setattr_size+0x2c2/0x3e0 [xfs] [ 116.275126] xfs_file_fallocate+0x239/0x440 [xfs] [ 116.279831] ? selinux_file_permission+0x108/0x140 [ 116.284622] vfs_fallocate+0x14d/0x2f0 [ 116.288374] ksys_fallocate+0x3c/0x80 [ 116.292039] __x64_sys_fallocate+0x1a/0x20 [ 116.296139] do_syscall_64+0x55/0x1d0 [ 116.299806] entry_SYSCALL_64_after_hwframe+0x44/0xa9 [ 116.304856] RIP: 0033:0x7f2dbc21983b [ 116.308435] Code: ff ff eb ba 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 8d 05 25 0e 2d 00 49 89 ca 8b 00 85 c0 75 14 b8 1d 01 00 00 0f 05 <48> 3d 00 f0 ff ff 77 5d c3 0f 1f 40 00 41 55 49 89 cd 41 54 49 89
That's here:
/*
* A page got tagged dirty in DAX mapping? Something is seriously
* wrong.
*/
if (WARN_ON(!xa_is_value(entry)))
return -EIO;Cheers,
Jeff
Quoted 8 lines · Jeff Moyer
Quoted 4 lines · Ira Weiny
Yep... and a long weekend if you are in the US... I ran the test with V4 and got the panic below.
Is this similar to what you see? If so I'll work on it in V4. FWIW with '-o
Yes, precisely.
Ok...
Quoted 24 lines
Quoted 4 lines
dax' specified I don't see how fsstress is causing an issue with my patch set. Does fsstress attempt to change dax states? I don't see that in the test but I'm not real familiar with generic/013 and fsstress.
Not that I'm aware of, no.
Quoted 17 lines
If my disassembly of
read_pagesis correct it looks like readpage is null which makes sense because all files should beIS_DAX()== true due to the mount option...But tracing code indicates that the patch:
fs: remove unneeded
IS_DAX()check... may be the culprit and the following fix may work...
mm/filemap.c +0
-0@@ -2257,7 +2257,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)if (!count) goto out;/* skip atime */
Quoted 8 lines
mm/filemap.c generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) · line 2263
Quoted 5 lines
mm/filemap.c +1
-1-if (iocb->ki_flags &IOCB_DIRECT ) { +if (iocb->ki_flags &IOCB_DIRECT ||IS_DAX (inode)) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;Well, you'll have to up-level the inode variable instantiation, obviously. That solves this particular issue.
Well... This seems to be a random issue. I've had BMC issues with my server most of the day... But even with this patch I still get the failure in read_pages(). :-/
And I have gotten it to both succeed and fail with qemu... :-/
Quoted 38 lines
The next traceback
you'll hit is in the writeback path:[ 116.044545] ------------[ cut here ]------------ [ 116.049163] WARNING: CPU: 48 PID: 4469 at fs/dax.c:862 dax_writeback_mapping_range+0x397/0x530 ... [ 116.134509] CPU: 48 PID: 4469 Comm: fsstress Not tainted 5.6.0-rc1+ #43 [ 116.141121] Hardware name: Intel Corporation S2600WFD/S2600WFD, BIOS SE5C620.86B.0D.01.0395.022720191340 02/27/2019 [ 116.151549] RIP: 0010:dax_writeback_mapping_range+0x397/0x530 [ 116.157294] Code: ff ff 31 db 48 8b 7c 24 28 c6 07 00 0f 1f 40 00 fb 48 8b 7c 24 10 e8 98 fc 29 00 0f 1f 44 00 00 e9 f1 fc ff ff 4c 8b 64 24 08 <0f> 0b be fb ff ff ff 4c 89 e7 e8 fa 87 ed ff f0 41 80 8c 24 80 00 [ 116.176036] RSP: 0018:ffffb9b162fa7c18 EFLAGS: 00010046 [ 116.181261] RAX: 0000000000000000 RBX: 00000000000001ac RCX: 0000000000000020 [ 116.188387] RDX: 0000000000000000 RSI: 00000000000001ac RDI: ffffb9b162fa7c40 [ 116.195519] RBP: 0000000000000020 R08: ffff9a73dc24d6b0 R09: 0000000000000020 [ 116.202648] R10: 0000000000000000 R11: 0000000000000238 R12: ffff9a73d92c66b8 [ 116.209774] R13: ffffe4a09f0cb200 R14: 0000000000000000 R15: ffffe4a09f0cb200 [ 116.216907] FS: 00007f2dbcd22b80(0000) GS:ffff9a7420c00000(0000) knlGS:0000000000000000 [ 116.224992] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 116.230735] CR2: 00007fa21808b648 CR3: 000000179e0a2003 CR4: 00000000007606e0 [ 116.237860] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 116.244990] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 116.252115] PKRU: 55555554 [ 116.254827] Call Trace: [ 116.257286] do_writepages+0x41/0xd0 [ 116.260862] __filemap_fdatawrite_range+0xcb/0x100 [ 116.265653] filemap_write_and_wait_range+0x38/0x90 [ 116.270579] xfs_setattr_size+0x2c2/0x3e0 [xfs] [ 116.275126] xfs_file_fallocate+0x239/0x440 [xfs] [ 116.279831] ? selinux_file_permission+0x108/0x140 [ 116.284622] vfs_fallocate+0x14d/0x2f0 [ 116.288374] ksys_fallocate+0x3c/0x80 [ 116.292039] __x64_sys_fallocate+0x1a/0x20 [ 116.296139] do_syscall_64+0x55/0x1d0 [ 116.299806] entry_SYSCALL_64_after_hwframe+0x44/0xa9 [ 116.304856] RIP: 0033:0x7f2dbc21983b [ 116.308435] Code: ff ff eb ba 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 8d 05 25 0e 2d 00 49 89 ca 8b 00 85 c0 75 14 b8 1d 01 00 00 0f 05 <48> 3d 00 f0 ff ff 77 5d c3 0f 1f 40 00 41 55 49 89 cd 41 54 49 89
Quoted 8 lines
That's here:
/* * A page got tagged dirty in DAX mapping? Something is seriously * wrong. */ if (WARN_ON(!xa_is_value(entry))) return -EIO;
I have not gotten this. Having to walk to the lab to power cycle the machine has slowed my progress...
Ira
Quoted 4 lines
Cheers,
Jeff
Quoted 28 lines · Ira Weiny
Quoted 18 lines · Jeff Moyer
Quoted 17 lines · Ira Weiny
If my disassembly of
read_pagesis correct it looks like readpage is null which makes sense because all files should beIS_DAX()== true due to the mount option...But tracing code indicates that the patch:
fs: remove unneeded
IS_DAX()check... may be the culprit and the following fix may work...
mm/filemap.c +0
-0@@ -2257,7 +2257,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)if (!count) goto out;/* skip atime */ Quoted 8 lines
mm/filemap.c generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) · line 2263
Quoted 5 lines
mm/filemap.c +1
-1-if (iocb->ki_flags &IOCB_DIRECT ) { +if (iocb->ki_flags &IOCB_DIRECT ||IS_DAX (inode)) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;Well, you'll have to up-level the inode variable instantiation, obviously. That solves this particular issue.
Quoted 5 lines
Well... This seems to be a random issue. I've had BMC issues with my server most of the day... But even with this patch I still get the failure in
read_pages(). :-/And I have gotten it to both succeed and fail with qemu... :-/
... here is the fix. I made the change in xfs_diflags_to_linux() early on with out factoring in the flag logic changes we have agreed upon...
fs/xfs/xfs_ioctl.c +2 -2
@@ -1123,11 +1123,11 @@ xfs_diflags_to_linux( inode->i_flags |=S_NOATIME ; else inode->i_flags &= ~S_NOATIME; -if (xflags &FS_XFLAG_DAX ) + +if (xfs_inode_enable_dax (ip)) inode->i_flags |=S_DAX ;else inode->i_flags &= ~S_DAX ; - }
But the one thing which tripped me up, and concerns me, is we have 2 functions which set the inode flags.
xfs_diflags_to_iflags()xfs_diflags_to_linux()
xfs_diflags_to_iflags() is geared toward initialization but logically they do the same thing. I see no reason to keep them separate. Does anyone?
Based on this find, the discussion on behavior in this thread, and the comments from Dave I'm reworking the series because the flag check/set functions have all changed and I really want to be as clear as possible with both the patches and the resulting code.[*] So v4 should be out today including attempting to document what we have discussed here and being as clear as possible on the behavior. :-D
Thanks so much for testing this!
Ira
[*] I will probably throw in a patch to remove xfs_diflags_to_iflags() as I really don't see a reason to keep it.
Quoted 71 lines · Ira Weiny
Quoted 28 lines · Ira Weiny
Quoted 18 lines · Jeff Moyer
Quoted 17 lines · Ira Weiny
If my disassembly of
read_pagesis correct it looks like readpage is null which makes sense because all files should beIS_DAX()== true due to the mount option...But tracing code indicates that the patch:
fs: remove unneeded
IS_DAX()check... may be the culprit and the following fix may work...
mm/filemap.c +0
-0@@ -2257,7 +2257,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)if (!count) goto out;/* skip atime */ Quoted 8 lines
mm/filemap.c generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) · line 2263
Quoted 5 lines
mm/filemap.c +1
-1-if (iocb->ki_flags &IOCB_DIRECT ) { +if (iocb->ki_flags &IOCB_DIRECT ||IS_DAX (inode)) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;Well, you'll have to up-level the inode variable instantiation, obviously. That solves this particular issue.
Quoted 5 lines
Well... This seems to be a random issue. I've had BMC issues with my server most of the day... But even with this patch I still get the failure in
read_pages(). :-/And I have gotten it to both succeed and fail with qemu... :-/
... here is the fix. I made the change in
xfs_diflags_to_linux()early on with out factoring in the flag logic changes we have agreed upon...fs/xfs/xfs_ioctl.c +2
-2@@ -1123,11 +1123,11 @@ xfs_diflags_to_linux( inode->i_flags |=S_NOATIME ; else inode->i_flags &= ~S_NOATIME; -if (xflags &FS_XFLAG_DAX ) + +if (xfs_inode_enable_dax (ip)) inode->i_flags |=S_DAX ;else inode->i_flags &= ~S_DAX ; - }But the one thing which tripped me up, and concerns me, is we have 2 functions which set the inode flags.
xfs_diflags_to_iflags()xfs_diflags_to_linux()
xfs_diflags_to_iflags()is geared toward initialization but logically they do the same thing. I see no reason to keep them separate. Does anyone?Based on this find, the discussion on behavior in this thread, and the comments from Dave I'm reworking the series because the flag check/set functions have all changed and I really want to be as clear as possible with both the patches and the resulting code.[*] So v4 should be out today including attempting to document what we have discussed here and being as clear as possible on the behavior. :-D
Quoted 7 lines
Thanks so much for testing this!
Ira
[*] I will probably throw in a patch to remove
xfs_diflags_to_iflags()as I really don't see a reason to keep it.
I prefer you keep the one in xfs_iops.c since ioctls are a higher level function than general inode operations.
--D
Quoted 74 lines · Darrick J. Wong
Quoted 73 lines · Ira Weiny
Quoted 28 lines · Ira Weiny
Quoted 18 lines · Jeff Moyer
Quoted 17 lines · Ira Weiny
If my disassembly of
read_pagesis correct it looks like readpage is null which makes sense because all files should beIS_DAX()== true due to the mount option...But tracing code indicates that the patch:
fs: remove unneeded
IS_DAX()check... may be the culprit and the following fix may work...
mm/filemap.c +0
-0@@ -2257,7 +2257,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)if (!count) goto out;/* skip atime */ Quoted 8 lines
mm/filemap.c generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) · line 2263
Quoted 5 lines
mm/filemap.c +1
-1-if (iocb->ki_flags &IOCB_DIRECT ) { +if (iocb->ki_flags &IOCB_DIRECT ||IS_DAX (inode)) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;Well, you'll have to up-level the inode variable instantiation, obviously. That solves this particular issue.
Quoted 5 lines
Well... This seems to be a random issue. I've had BMC issues with my server most of the day... But even with this patch I still get the failure in
read_pages(). :-/And I have gotten it to both succeed and fail with qemu... :-/
... here is the fix. I made the change in
xfs_diflags_to_linux()early on with out factoring in the flag logic changes we have agreed upon...fs/xfs/xfs_ioctl.c +2
-2@@ -1123,11 +1123,11 @@ xfs_diflags_to_linux( inode->i_flags |=S_NOATIME ; else inode->i_flags &= ~S_NOATIME; -if (xflags &FS_XFLAG_DAX ) + +if (xfs_inode_enable_dax (ip)) inode->i_flags |=S_DAX ;else inode->i_flags &= ~S_DAX ; - }But the one thing which tripped me up, and concerns me, is we have 2 functions which set the inode flags.
xfs_diflags_to_iflags()xfs_diflags_to_linux()
xfs_diflags_to_iflags()is geared toward initialization but logically they do the same thing. I see no reason to keep them separate. Does anyone?Based on this find, the discussion on behavior in this thread, and the comments from Dave I'm reworking the series because the flag check/set functions have all changed and I really want to be as clear as possible with both the patches and the resulting code.[*] So v4 should be out today including attempting to document what we have discussed here and being as clear as possible on the behavior. :-D
Thanks so much for testing this!
Quoted 8 lines
Quoted 5 lines
Ira
[*] I will probably throw in a patch to remove
xfs_diflags_to_iflags()as I really don't see a reason to keep it.I prefer you keep the one in
xfs_iops.csince ioctls are a higher level function than general inode operations.
Makes sense. Do you prefer the xfs_diflags_to_iflags() name as well?
Ira
Quoted 2 lines
--D
Quoted 77 lines · Ira Weiny
Quoted 76 lines · Darrick J. Wong
Quoted 75 lines · Ira Weiny
Quoted 28 lines · Ira Weiny
Quoted 18 lines · Jeff Moyer
Quoted 17 lines · Ira Weiny
If my disassembly of
read_pagesis correct it looks like readpage is null which makes sense because all files should beIS_DAX()== true due to the mount option...But tracing code indicates that the patch:
fs: remove unneeded
IS_DAX()check... may be the culprit and the following fix may work...
mm/filemap.c +0
-0@@ -2257,7 +2257,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)if (!count) goto out;/* skip atime */ Quoted 8 lines
mm/filemap.c generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) · line 2263
Quoted 5 lines
mm/filemap.c +1
-1-if (iocb->ki_flags &IOCB_DIRECT ) { +if (iocb->ki_flags &IOCB_DIRECT ||IS_DAX (inode)) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;Well, you'll have to up-level the inode variable instantiation, obviously. That solves this particular issue.
Quoted 5 lines
Well... This seems to be a random issue. I've had BMC issues with my server most of the day... But even with this patch I still get the failure in
read_pages(). :-/And I have gotten it to both succeed and fail with qemu... :-/
... here is the fix. I made the change in
xfs_diflags_to_linux()early on with out factoring in the flag logic changes we have agreed upon...fs/xfs/xfs_ioctl.c +2
-2@@ -1123,11 +1123,11 @@ xfs_diflags_to_linux( inode->i_flags |=S_NOATIME ; else inode->i_flags &= ~S_NOATIME; -if (xflags &FS_XFLAG_DAX ) + +if (xfs_inode_enable_dax (ip)) inode->i_flags |=S_DAX ;else inode->i_flags &= ~S_DAX ; - }But the one thing which tripped me up, and concerns me, is we have 2 functions which set the inode flags.
xfs_diflags_to_iflags()xfs_diflags_to_linux()
xfs_diflags_to_iflags()is geared toward initialization but logically they do the same thing. I see no reason to keep them separate. Does anyone?Based on this find, the discussion on behavior in this thread, and the comments from Dave I'm reworking the series because the flag check/set functions have all changed and I really want to be as clear as possible with both the patches and the resulting code.[*] So v4 should be out today including attempting to document what we have discussed here and being as clear as possible on the behavior. :-D
Thanks so much for testing this!
Ira
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
[*] I will probably throw in a patch to remove
xfs_diflags_to_iflags()as I really don't see a reason to keep it.I prefer you keep the one in
xfs_iops.csince ioctls are a higher level function than general inode operations.Makes sense. Do you prefer the
xfs_diflags_to_iflags()name as well?
I don't really care one way or another, so ... iflags wins by arbitrary choice! 8)
--D
Quoted 4 lines
Ira
Quoted 2 lines
--D