diff mbox

[v4,1/3] fs: allow per-device dax status checking for filesystems

Message ID 151871655228.27617.3514495396592472682.stgit@djiang5-desk3.ch.intel.com (mailing list archive)
State New, archived
Headers show

Commit Message

Dave Jiang Feb. 15, 2018, 5:42 p.m. UTC
From: Darrick J. Wong <darrick.wong@oracle.com>

Refactor __bdev_dax_supported into a sb_dax_supported helper for
single-bdev filesystems and a regular bdev_dax_supported that 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>
---
 drivers/dax/super.c |    9 +++++----
 fs/ext2/super.c     |    2 +-
 fs/ext4/super.c     |    2 +-
 fs/xfs/xfs_ioctl.c  |    3 ++-
 fs/xfs/xfs_iops.c   |   30 +++++++++++++++++++++++++-----
 fs/xfs/xfs_super.c  |   11 +++++++++--
 include/linux/dax.h |   16 ++++++++++++----
 7 files changed, 55 insertions(+), 18 deletions(-)

Comments

Christoph Hellwig Feb. 15, 2018, 5:52 p.m. UTC | #1
>  /**
> - * __bdev_dax_supported() - Check if the device supports dax for filesystem
> + * 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,9 +83,9 @@ 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 super_block *sb, struct block_device *bdev,
> +		       int blocksize)
>  {
> -	struct block_device *bdev = sb->s_bdev;
>  	struct dax_device *dax_dev;
>  	pgoff_t pgoff;
>  	int err, id;

This now only uses sb for sb->s_id.  It might be better to use bdevname
to print the device name and don't bother passing a sb at all.
Dave Jiang Feb. 15, 2018, 5:58 p.m. UTC | #2
On 02/15/2018 10:52 AM, Christoph Hellwig wrote:
>>  /**
>> - * __bdev_dax_supported() - Check if the device supports dax for filesystem
>> + * 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,9 +83,9 @@ 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 super_block *sb, struct block_device *bdev,
>> +		       int blocksize)
>>  {
>> -	struct block_device *bdev = sb->s_bdev;
>>  	struct dax_device *dax_dev;
>>  	pgoff_t pgoff;
>>  	int err, id;
> 
> This now only uses sb for sb->s_id.  It might be better to use bdevname
> to print the device name and don't bother passing a sb at all.
> 

I think Darrick wanted to keep the API the same for non-XFS users. I'm
ok with dropping the passed in sb if Darrick has no objections.
Christoph Hellwig Feb. 15, 2018, 6:05 p.m. UTC | #3
On Thu, Feb 15, 2018 at 10:58:54AM -0700, Dave Jiang wrote:
> I think Darrick wanted to keep the API the same for non-XFS users. I'm
> ok with dropping the passed in sb if Darrick has no objections.

But the old API is gone - everyone either uses the new
sb_dax_supported, or the updated bdev_dax_supported.
Darrick J. Wong Feb. 15, 2018, 7:06 p.m. UTC | #4
On Thu, Feb 15, 2018 at 10:58:54AM -0700, Dave Jiang wrote:
> On 02/15/2018 10:52 AM, Christoph Hellwig wrote:
> >>  /**
> >> - * __bdev_dax_supported() - Check if the device supports dax for filesystem
> >> + * 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,9 +83,9 @@ 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 super_block *sb, struct block_device *bdev,
> >> +		       int blocksize)
> >>  {
> >> -	struct block_device *bdev = sb->s_bdev;
> >>  	struct dax_device *dax_dev;
> >>  	pgoff_t pgoff;
> >>  	int err, id;
> > 
> > This now only uses sb for sb->s_id.  It might be better to use bdevname
> > to print the device name and don't bother passing a sb at all.
> > 
> 
> I think Darrick wanted to keep the API the same for non-XFS users. I'm
> ok with dropping the passed in sb if Darrick has no objections.

Fine with me to use bdevname.

--D

> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
kernel test robot March 1, 2018, 1:22 a.m. UTC | #5
Hi Darrick,

I love your patch! Yet something to improve:

[auto build test ERROR on linus/master]
[also build test ERROR on v4.16-rc3 next-20180228]
[cannot apply to dgc-xfs/for-next]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Dave-Jiang/minimal-DAX-support-for-XFS-realtime-device/20180218-154220
config: i386-randconfig-c0-03010621 (attached as .config)
compiler: gcc-7 (Debian 7.3.0-1) 7.3.0
reproduce:
        # save the attached .config to linux build tree
        make ARCH=i386 

All errors (new ones prefixed by >>):

>> drivers/dax/super.c:86:5: error: redefinition of 'bdev_dax_supported'
    int bdev_dax_supported(struct super_block *sb, struct block_device *bdev,
        ^~~~~~~~~~~~~~~~~~
   In file included from drivers/dax/super.c:23:0:
   include/linux/dax.h:62:19: note: previous definition of 'bdev_dax_supported' was here
    static inline int bdev_dax_supported(struct super_block *sb,
                      ^~~~~~~~~~~~~~~~~~

vim +/bdev_dax_supported +86 drivers/dax/super.c

    74	
    75	/**
    76	 * bdev_dax_supported() - Check if the device supports dax for filesystem
    77	 * @sb: The superblock of the device
    78	 * @bdev: block device to check
    79	 * @blocksize: The block size of the device
    80	 *
    81	 * This is a library function for filesystems to check if the block device
    82	 * can be mounted with dax option.
    83	 *
    84	 * Return: negative errno if unsupported, 0 if supported.
    85	 */
  > 86	int bdev_dax_supported(struct super_block *sb, struct block_device *bdev,
    87			       int blocksize)
    88	{
    89		struct dax_device *dax_dev;
    90		pgoff_t pgoff;
    91		int err, id;
    92		void *kaddr;
    93		pfn_t pfn;
    94		long len;
    95	
    96		if (blocksize != PAGE_SIZE) {
    97			pr_debug("VFS (%s): error: unsupported blocksize for dax\n",
    98					sb->s_id);
    99			return -EINVAL;
   100		}
   101	
   102		err = bdev_dax_pgoff(bdev, 0, PAGE_SIZE, &pgoff);
   103		if (err) {
   104			pr_debug("VFS (%s): error: unaligned partition for dax\n",
   105					sb->s_id);
   106			return err;
   107		}
   108	
   109		dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);
   110		if (!dax_dev) {
   111			pr_debug("VFS (%s): error: device does not support dax\n",
   112					sb->s_id);
   113			return -EOPNOTSUPP;
   114		}
   115	
   116		id = dax_read_lock();
   117		len = dax_direct_access(dax_dev, pgoff, 1, &kaddr, &pfn);
   118		dax_read_unlock(id);
   119	
   120		put_dax(dax_dev);
   121	
   122		if (len < 1) {
   123			pr_debug("VFS (%s): error: dax access failed (%ld)\n",
   124					sb->s_id, len);
   125			return len < 0 ? len : -EIO;
   126		}
   127	
   128		if ((IS_ENABLED(CONFIG_FS_DAX_LIMITED) && pfn_t_special(pfn))
   129				|| pfn_t_devmap(pfn))
   130			/* pass */;
   131		else {
   132			pr_debug("VFS (%s): error: dax support not enabled\n",
   133					sb->s_id);
   134			return -EOPNOTSUPP;
   135		}
   136	
   137		return 0;
   138	}
   139	EXPORT_SYMBOL_GPL(bdev_dax_supported);
   140	#endif
   141	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
diff mbox

Patch

diff --git a/drivers/dax/super.c b/drivers/dax/super.c
index 473af694ad1c..8a3a168a267f 100644
--- a/drivers/dax/super.c
+++ b/drivers/dax/super.c
@@ -73,8 +73,9 @@  EXPORT_SYMBOL_GPL(fs_dax_get_by_bdev);
 #endif
 
 /**
- * __bdev_dax_supported() - Check if the device supports dax for filesystem
+ * 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,9 +83,9 @@  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 super_block *sb, struct block_device *bdev,
+		       int blocksize)
 {
-	struct block_device *bdev = sb->s_bdev;
 	struct dax_device *dax_dev;
 	pgoff_t pgoff;
 	int err, id;
@@ -135,7 +136,7 @@  int __bdev_dax_supported(struct super_block *sb, int blocksize)
 
 	return 0;
 }
-EXPORT_SYMBOL_GPL(__bdev_dax_supported);
+EXPORT_SYMBOL_GPL(bdev_dax_supported);
 #endif
 
 enum dax_device_flags {
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 7666c065b96f..28ca694e9e92 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -961,7 +961,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 = sb_dax_supported(sb, 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 39bf464c35f1..a09f832aad35 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -3714,7 +3714,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 = sb_dax_supported(sb, 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 89fb1eb80aae..277355f5c084 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -1103,7 +1103,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(sb, 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 56475fcd76f2..66cd61c172af 100644
--- 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 7aba628dc527..f6c74ef9722c 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1657,11 +1657,18 @@  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(sb, mp->m_ddev_targp->bt_bdev,
+				sb->s_blocksize);
+		if (mp->m_rtdev_targp)
+			error2 = bdev_dax_supported(sb,
+					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 0185ecdae135..e640c8a19ec0 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -40,10 +40,11 @@  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 super_block *sb, struct block_device *bdev,
+		       int blocksize);
+static inline int sb_dax_supported(struct super_block *sb, int blocksize)
 {
-	return __bdev_dax_supported(sb, blocksize);
+	return bdev_dax_supported(sb, sb->s_bdev, blocksize);
 }
 
 static inline struct dax_device *fs_dax_get_by_host(const char *host)
@@ -58,7 +59,14 @@  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 super_block *sb,
+				     struct block_device *bdev,
+				     int blocksize)
+{
+	return -EOPNOTSUPP;
+}
+
+static inline int sb_dax_supported(struct super_block *sb, int blocksize)
 {
 	return -EOPNOTSUPP;
 }