xfs: disallow atomic writes on DAX

Atomic writes are not currently supported for DAX, but two problems exist:
- we may go down DAX write path for IOCB_ATOMIC, which does not handle
  IOCB_ATOMIC properly
- we report non-zero atomic write limits in statx (for DAX inodes)

We may want atomic writes support on DAX in future, but just disallow for
now.

For this, ensure when IOCB_ATOMIC is set that we check the write size
versus the atomic write min and max before branching off to the DAX write
path. This is not strictly required for DAX, as we should not get this far
in the write path as FMODE_CAN_ATOMIC_WRITE should not be set.

In addition, due to reflink being supported for DAX, we automatically get
CoW-based atomic writes support being advertised. Remedy this by
disallowing atomic writes for a DAX inode for both sw and hw modes.

Reported-by: Darrick J. Wong <djwong@kernel.org>
Fixes: 9dffc58f2384 ("xfs: update atomic write limits")
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: John Garry <john.g.garry@oracle.com>
Signed-off-by: Carlos Maiolino <cem@kernel.org>

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 55a304cb3aef4fbfa0cc78d112870f20323e9de2..f96fbf5c54c99986708b928fec69dc2f37f6d604 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -1101,9 +1101,6 @@ xfs_file_write_iter(
        if (xfs_is_shutdown(ip->i_mount))
                return -EIO;
 
-       if (IS_DAX(inode))
-               return xfs_file_dax_write(iocb, from);
-
        if (iocb->ki_flags & IOCB_ATOMIC) {
                if (ocount < xfs_get_atomic_write_min(ip))
                        return -EINVAL;
@@ -1116,6 +1113,9 @@ xfs_file_write_iter(
                        return ret;
        }
 
+       if (IS_DAX(inode))
+               return xfs_file_dax_write(iocb, from);
+
        if (iocb->ki_flags & IOCB_DIRECT) {
                /*
                 * Allow a directio write to fall back to a buffered

diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 07fbdcc4cbf582c25fabcd7746e3a54edb6fc7c9..bd6d335571943d113b24173bc83daf930bab2623 100644 (file)
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -358,9 +358,20 @@ static inline bool xfs_inode_has_bigrtalloc(const struct xfs_inode *ip)
 
 static inline bool xfs_inode_can_hw_atomic_write(const struct xfs_inode *ip)
 {
+       if (IS_DAX(VFS_IC(ip)))
+               return false;
+
        return xfs_inode_buftarg(ip)->bt_awu_max > 0;
 }
 
+static inline bool xfs_inode_can_sw_atomic_write(const struct xfs_inode *ip)
+{
+       if (IS_DAX(VFS_IC(ip)))
+               return false;
+
+       return xfs_can_sw_atomic_write(ip->i_mount);
+}
+
 /*
  * In-core inode flags.
  */

diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 149b5460fbfd8016cb62728d38235e8de7eccb31..603effabe1ee12d6414fa132f7fcbf79bbbcaf99 100644 (file)
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -616,7 +616,8 @@ xfs_get_atomic_write_min(
         * write of exactly one single fsblock if the bdev will make that
         * guarantee for us.
         */
-       if (xfs_inode_can_hw_atomic_write(ip) || xfs_can_sw_atomic_write(mp))
+       if (xfs_inode_can_hw_atomic_write(ip) ||
+           xfs_inode_can_sw_atomic_write(ip))
                return mp->m_sb.sb_blocksize;
 
        return 0;
@@ -633,7 +634,7 @@ xfs_get_atomic_write_max(
         * write of exactly one single fsblock if the bdev will make that
         * guarantee for us.
         */
-       if (!xfs_can_sw_atomic_write(mp)) {
+       if (!xfs_inode_can_sw_atomic_write(ip)) {
                if (xfs_inode_can_hw_atomic_write(ip))
                        return mp->m_sb.sb_blocksize;
                return 0;