xfs: add a xfs_inode_buftarg helper

Add a new xfs_inode_buftarg helper that gets the data I/O buftarg for a
given inode.  Replace the existing xfs_find_bdev_for_inode and
xfs_find_daxdev_for_inode helpers with this new general one and cleanup
some of the callers.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 5d3503f6412a44328ea22c7a1d6936aa12065d19..3a688eb5c5ae4e07e70b78f58ce6261a22770340 100644 (file)
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -30,32 +30,6 @@ XFS_WPC(struct iomap_writepage_ctx *ctx)
        return container_of(ctx, struct xfs_writepage_ctx, ctx);
 }
 
-struct block_device *
-xfs_find_bdev_for_inode(
-       struct inode            *inode)
-{
-       struct xfs_inode        *ip = XFS_I(inode);
-       struct xfs_mount        *mp = ip->i_mount;
-
-       if (XFS_IS_REALTIME_INODE(ip))
-               return mp->m_rtdev_targp->bt_bdev;
-       else
-               return mp->m_ddev_targp->bt_bdev;
-}
-
-struct dax_device *
-xfs_find_daxdev_for_inode(
-       struct inode            *inode)
-{
-       struct xfs_inode        *ip = XFS_I(inode);
-       struct xfs_mount        *mp = ip->i_mount;
-
-       if (XFS_IS_REALTIME_INODE(ip))
-               return mp->m_rtdev_targp->bt_daxdev;
-       else
-               return mp->m_ddev_targp->bt_daxdev;
-}
-
 /*
  * Fast and loose check if this write could update the on-disk inode size.
  */
@@ -609,9 +583,11 @@ xfs_dax_writepages(
        struct address_space    *mapping,
        struct writeback_control *wbc)
 {
-       xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
+       struct xfs_inode        *ip = XFS_I(mapping->host);
+
+       xfs_iflags_clear(ip, XFS_ITRUNCATED);
        return dax_writeback_mapping_range(mapping,
-                       xfs_find_bdev_for_inode(mapping->host), wbc);
+                       xfs_inode_buftarg(ip)->bt_bdev, wbc);
 }
 
 STATIC sector_t
@@ -661,7 +637,7 @@ xfs_iomap_swapfile_activate(
        struct file                     *swap_file,
        sector_t                        *span)
 {
-       sis->bdev = xfs_find_bdev_for_inode(file_inode(swap_file));
+       sis->bdev = xfs_inode_buftarg(XFS_I(file_inode(swap_file)))->bt_bdev;
        return iomap_swapfile_activate(sis, swap_file, span,
                        &xfs_read_iomap_ops);
 }

diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index 687b11f34fa2ac6d64b3913a9153c9d4924f39ac..e0bd684197643d3bcbd3460b230cd517b1ca471d 100644 (file)
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -11,7 +11,4 @@ extern const struct address_space_operations xfs_dax_aops;
 
 int    xfs_setfilesize(struct xfs_inode *ip, xfs_off_t offset, size_t size);
 
-extern struct block_device *xfs_find_bdev_for_inode(struct inode *);
-extern struct dax_device *xfs_find_daxdev_for_inode(struct inode *);
-
 #endif /* __XFS_AOPS_H__ */

diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 99bf372ed551c75dc37601072869d1d5f1b9240e..ba53201dcaf65649b4af5feb7751e98556a3d2c7 100644 (file)
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -53,15 +53,16 @@ xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
  */
 int
 xfs_zero_extent(
-       struct xfs_inode *ip,
-       xfs_fsblock_t   start_fsb,
-       xfs_off_t       count_fsb)
+       struct xfs_inode        *ip,
+       xfs_fsblock_t           start_fsb,
+       xfs_off_t               count_fsb)
 {
-       struct xfs_mount *mp = ip->i_mount;
-       xfs_daddr_t     sector = xfs_fsb_to_db(ip, start_fsb);
-       sector_t        block = XFS_BB_TO_FSBT(mp, sector);
+       struct xfs_mount        *mp = ip->i_mount;
+       struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
+       xfs_daddr_t             sector = xfs_fsb_to_db(ip, start_fsb);
+       sector_t                block = XFS_BB_TO_FSBT(mp, sector);
 
-       return blkdev_issue_zeroout(xfs_find_bdev_for_inode(VFS_I(ip)),
+       return blkdev_issue_zeroout(target->bt_bdev,
                block << (mp->m_super->s_blocksize_bits - 9),
                count_fsb << (mp->m_super->s_blocksize_bits - 9),
                GFP_NOFS, 0);

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 24659667d5cb8941eea96a8f5b5153d51feca6be..ee4ebb7904f6bad816cb73f313f4382eb2dfea5f 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -1229,22 +1229,22 @@ static const struct vm_operations_struct xfs_file_vm_ops = {
 
 STATIC int
 xfs_file_mmap(
-       struct file     *filp,
-       struct vm_area_struct *vma)
+       struct file             *file,
+       struct vm_area_struct   *vma)
 {
-       struct dax_device       *dax_dev;
+       struct inode            *inode = file_inode(file);
+       struct xfs_buftarg      *target = xfs_inode_buftarg(XFS_I(inode));
 
-       dax_dev = xfs_find_daxdev_for_inode(file_inode(filp));
        /*
         * We don't support synchronous mappings for non-DAX files and
         * for DAX files if underneath dax_device is not synchronous.
         */
-       if (!daxdev_mapping_supported(vma, dax_dev))
+       if (!daxdev_mapping_supported(vma, target->bt_daxdev))
                return -EOPNOTSUPP;
 
-       file_accessed(filp);
+       file_accessed(file);
        vma->vm_ops = &xfs_file_vm_ops;
-       if (IS_DAX(file_inode(filp)))
+       if (IS_DAX(inode))
                vma->vm_flags |= VM_HUGEPAGE;
        return 0;
 }

diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 558173f95a03a27f6f2ae71294fda2e77515d43e..bcfb35a9c5ca8d64555998e4571c35bb284ba85f 100644 (file)
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -219,6 +219,13 @@ static inline bool xfs_inode_has_cow_data(struct xfs_inode *ip)
        return ip->i_cowfp && ip->i_cowfp->if_bytes;
 }
 
+/*
+ * Return the buftarg used for data allocations on a given inode.
+ */
+#define xfs_inode_buftarg(ip) \
+       (XFS_IS_REALTIME_INODE(ip) ? \
+               (ip)->i_mount->m_rtdev_targp : (ip)->i_mount->m_ddev_targp)
+
 /*
  * In-core inode flags.
  */

diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index d58f0d6a699e672cfec235a02d8f032051f4facc..b7b5c17131cd7c7926c882c4c4b4c7e23a131f8f 100644 (file)
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -1311,10 +1311,9 @@ xfs_ioctl_setattr_dax_invalidate(
         * have to check the device for dax support or flush pagecache.
         */
        if (fa->fsx_xflags & FS_XFLAG_DAX) {
-               if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
-                       return -EINVAL;
-               if (!bdev_dax_supported(xfs_find_bdev_for_inode(VFS_I(ip)),
-                               sb->s_blocksize))
+               struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
+
+               if (!bdev_dax_supported(target->bt_bdev, sb->s_blocksize))
                        return -EINVAL;
        }
 

diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index e8fb500e1880deebe6940d546b2da8b468714ed6..8317b936d3c1d33cbeed6bde713d811ce6b568da 100644 (file)
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -57,6 +57,7 @@ xfs_bmbt_to_iomap(
        u16                     flags)
 {
        struct xfs_mount        *mp = ip->i_mount;
+       struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
 
        if (unlikely(!xfs_valid_startblock(ip, imap->br_startblock)))
                return xfs_alert_fsblock_zero(ip, imap);
@@ -77,8 +78,8 @@ xfs_bmbt_to_iomap(
        }
        iomap->offset = XFS_FSB_TO_B(mp, imap->br_startoff);
        iomap->length = XFS_FSB_TO_B(mp, imap->br_blockcount);
-       iomap->bdev = xfs_find_bdev_for_inode(VFS_I(ip));
-       iomap->dax_dev = xfs_find_daxdev_for_inode(VFS_I(ip));
+       iomap->bdev = target->bt_bdev;
+       iomap->dax_dev = target->bt_daxdev;
        iomap->flags = flags;
 
        if (xfs_ipincount(ip) &&
@@ -94,12 +95,14 @@ xfs_hole_to_iomap(
        xfs_fileoff_t           offset_fsb,
        xfs_fileoff_t           end_fsb)
 {
+       struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
+
        iomap->addr = IOMAP_NULL_ADDR;
        iomap->type = IOMAP_HOLE;
        iomap->offset = XFS_FSB_TO_B(ip->i_mount, offset_fsb);
        iomap->length = XFS_FSB_TO_B(ip->i_mount, end_fsb - offset_fsb);
-       iomap->bdev = xfs_find_bdev_for_inode(VFS_I(ip));
-       iomap->dax_dev = xfs_find_daxdev_for_inode(VFS_I(ip));
+       iomap->bdev = target->bt_bdev;
+       iomap->dax_dev = target->bt_daxdev;
 }
 
 static inline xfs_fileoff_t

diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 329a34af8e796c77e49b87970eec2e760089b76c..404f2dd58698bed235f9c67779f42f184a26b7c0 100644 (file)
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -1227,7 +1227,7 @@ xfs_inode_supports_dax(
                return false;
 
        /* Device has to support DAX too. */
-       return xfs_find_daxdev_for_inode(VFS_I(ip)) != NULL;
+       return xfs_inode_buftarg(ip)->bt_daxdev != NULL;
 }
 
 STATIC void