fs: allow per-device dax status checking for filesystems

BugLink: http://bugs.launchpad.net/bugs/1808399
commit ba23cba9b3bdc967aabdc6ff1e3e9b11ce05bb4f upstream.

Change bdev_dax_supported so it takes a bdev parameter.  This enables
multi-device filesystems like xfs to check that a dax device can work for
the particular filesystem.  Once that's in place, actually fix all the
parts of XFS where we need to be able to distinguish between datadev and
rtdev.

This patch fixes the problem where we screw up the dax support checking
in xfs if the datadev and rtdev have different dax capabilities.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
[rez: Re-added __bdev_dax_supported() for !CONFIG_FS_DAX cases]
Signed-off-by: Ross Zwisler <ross.zwisler@linux.intel.com>
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Kamal Mostafa <kamal@canonical.com>
Signed-off-by: Khalid Elmously <khalid.elmously@canonical.com>

diff --git a/drivers/dax/super.c b/drivers/dax/super.c
index 473af694ad1cbee97db06646a715776a5d9e7889..2feab5a5953834ac8b7227f1ce7054c1a4186a9b 100644 (file)
--- a/drivers/dax/super.c
+++ b/drivers/dax/super.c
@@ -74,7 +74,7 @@ EXPORT_SYMBOL_GPL(fs_dax_get_by_bdev);
 
 /**
  * __bdev_dax_supported() - Check if the device supports dax for filesystem
- * @sb: The superblock of the device
+ * @bdev: block device to check
  * @blocksize: The block size of the device
  *
  * This is a library function for filesystems to check if the block device
@@ -82,33 +82,33 @@ EXPORT_SYMBOL_GPL(fs_dax_get_by_bdev);
  *
  * Return: negative errno if unsupported, 0 if supported.
  */
-int __bdev_dax_supported(struct super_block *sb, int blocksize)
+int __bdev_dax_supported(struct block_device *bdev, int blocksize)
 {
-       struct block_device *bdev = sb->s_bdev;
        struct dax_device *dax_dev;
        pgoff_t pgoff;
        int err, id;
        void *kaddr;
        pfn_t pfn;
        long len;
+       char buf[BDEVNAME_SIZE];
 
        if (blocksize != PAGE_SIZE) {
-               pr_debug("VFS (%s): error: unsupported blocksize for dax\n",
-                               sb->s_id);
+               pr_debug("%s: error: unsupported blocksize for dax\n",
+                               bdevname(bdev, buf));
                return -EINVAL;
        }
 
        err = bdev_dax_pgoff(bdev, 0, PAGE_SIZE, &pgoff);
        if (err) {
-               pr_debug("VFS (%s): error: unaligned partition for dax\n",
-                               sb->s_id);
+               pr_debug("%s: error: unaligned partition for dax\n",
+                               bdevname(bdev, buf));
                return err;
        }
 
        dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);
        if (!dax_dev) {
-               pr_debug("VFS (%s): error: device does not support dax\n",
-                               sb->s_id);
+               pr_debug("%s: error: device does not support dax\n",
+                               bdevname(bdev, buf));
                return -EOPNOTSUPP;
        }
 
@@ -119,8 +119,8 @@ int __bdev_dax_supported(struct super_block *sb, int blocksize)
        put_dax(dax_dev);
 
        if (len < 1) {
-               pr_debug("VFS (%s): error: dax access failed (%ld)\n",
-                               sb->s_id, len);
+               pr_debug("%s: error: dax access failed (%ld)\n",
+                               bdevname(bdev, buf), len);
                return len < 0 ? len : -EIO;
        }
 
@@ -128,8 +128,8 @@ int __bdev_dax_supported(struct super_block *sb, int blocksize)
                        || pfn_t_devmap(pfn))
                /* pass */;
        else {
-               pr_debug("VFS (%s): error: dax support not enabled\n",
-                               sb->s_id);
+               pr_debug("%s: error: dax support not enabled\n",
+                               bdevname(bdev, buf));
                return -EOPNOTSUPP;
        }
 

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 38f9222606eeb22409c6e0b87044a8c45a66cb68..a0de090b18d51a21660238dd8296470a5aa899b1 100644 (file)
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -958,7 +958,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
 
        if (sbi->s_mount_opt & EXT2_MOUNT_DAX) {
-               err = bdev_dax_supported(sb, blocksize);
+               err = bdev_dax_supported(sb->s_bdev, blocksize);
                if (err) {
                        ext2_msg(sb, KERN_ERR,
                                "DAX unsupported by block device. Turning off DAX.");

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 1ed7eabe0f8a147c068030ae7203939cca5fbd4f..2c5b5dc5b6acfe91bfdd6b605ef5ce3341289605 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -3806,7 +3806,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                                        " that may contain inline data");
                        sbi->s_mount_opt &= ~EXT4_MOUNT_DAX;
                }
-               err = bdev_dax_supported(sb, blocksize);
+               err = bdev_dax_supported(sb->s_bdev, blocksize);
                if (err) {
                        ext4_msg(sb, KERN_ERR,
                                "DAX unsupported by block device. Turning off DAX.");

diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 20dc65fef6a42fa52ad412b9cd5619aa1434245b..544147466545939dfd6d8433039acd67ee3a4c97 100644 (file)
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -1102,7 +1102,8 @@ xfs_ioctl_setattr_dax_invalidate(
        if (fa->fsx_xflags & FS_XFLAG_DAX) {
                if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
                        return -EINVAL;
-               if (bdev_dax_supported(sb, sb->s_blocksize) < 0)
+               if (bdev_dax_supported(xfs_find_bdev_for_inode(VFS_I(ip)),
+                               sb->s_blocksize) < 0)
                        return -EINVAL;
        }
 

diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 56475fcd76f224216f89e4c0d3cead876d3b547c..66cd61c172af26876c4547cf28cd1af446a002f2 100644 (file)
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -1182,6 +1182,30 @@ static const struct inode_operations xfs_inline_symlink_inode_operations = {
        .update_time            = xfs_vn_update_time,
 };
 
+/* Figure out if this file actually supports DAX. */
+static 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))
+               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;
+
+       /* Device has to support DAX too. */
+       return xfs_find_daxdev_for_inode(VFS_I(ip)) != NULL;
+}
+
 STATIC void
 xfs_diflags_to_iflags(
        struct inode            *inode,
@@ -1200,11 +1224,7 @@ xfs_diflags_to_iflags(
                inode->i_flags |= S_SYNC;
        if (flags & XFS_DIFLAG_NOATIME)
                inode->i_flags |= S_NOATIME;
-       if (S_ISREG(inode->i_mode) &&
-           ip->i_mount->m_sb.sb_blocksize == PAGE_SIZE &&
-           !xfs_is_reflink_inode(ip) &&
-           (ip->i_mount->m_flags & XFS_MOUNT_DAX ||
-            ip->i_d.di_flags2 & XFS_DIFLAG2_DAX))
+       if (xfs_inode_supports_dax(ip))
                inode->i_flags |= S_DAX;
 }
 

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 1dacccc367f81725a678ea3a6ed50528a731920d..bf4a9fb7c392ef69770d39ffcd56349dc4fb46ed 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1649,11 +1649,17 @@ xfs_fs_fill_super(
                sb->s_flags |= SB_I_VERSION;
 
        if (mp->m_flags & XFS_MOUNT_DAX) {
+               int     error2 = 0;
+
                xfs_warn(mp,
                "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
 
-               error = bdev_dax_supported(sb, sb->s_blocksize);
-               if (error) {
+               error = bdev_dax_supported(mp->m_ddev_targp->bt_bdev,
+                               sb->s_blocksize);
+               if (mp->m_rtdev_targp)
+                       error2 = bdev_dax_supported(mp->m_rtdev_targp->bt_bdev,
+                                       sb->s_blocksize);
+               if (error && error2) {
                        xfs_alert(mp,
                        "DAX unsupported by block device. Turning off DAX.");
                        mp->m_flags &= ~XFS_MOUNT_DAX;

diff --git a/include/linux/dax.h b/include/linux/dax.h
index 5258346c558c783b22bc5352e05e2042e2f20afb..c6acd1df1e070ebbeba5f2e1287d7826b18ea347 100644 (file)
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -40,10 +40,10 @@ static inline void put_dax(struct dax_device *dax_dev)
 
 int bdev_dax_pgoff(struct block_device *, sector_t, size_t, pgoff_t *pgoff);
 #if IS_ENABLED(CONFIG_FS_DAX)
-int __bdev_dax_supported(struct super_block *sb, int blocksize);
-static inline int bdev_dax_supported(struct super_block *sb, int blocksize)
+int __bdev_dax_supported(struct block_device *bdev, int blocksize);
+static inline int bdev_dax_supported(struct block_device *bdev, int blocksize)
 {
-       return __bdev_dax_supported(sb, blocksize);
+       return __bdev_dax_supported(bdev, blocksize);
 }
 
 static inline struct dax_device *fs_dax_get_by_host(const char *host)
@@ -58,7 +58,8 @@ static inline void fs_put_dax(struct dax_device *dax_dev)
 
 struct dax_device *fs_dax_get_by_bdev(struct block_device *bdev);
 #else
-static inline int bdev_dax_supported(struct super_block *sb, int blocksize)
+static inline int bdev_dax_supported(struct block_device *bdev,
+               int blocksize)
 {
        return -EOPNOTSUPP;
 }