xfs: replace dop_low with transaction flag

Source kernel commit: 1214f1cf663b0939fbb8f1bccdc74c1d1e452d53

The dop_low field enables the low free space allocation mode when a
previous allocation has detected difficulty allocating blocks. It
has historically been part of the xfs_defer_ops structure, which
means if enabled, it remains enabled across a set of transactions
until the deferred operations have completed and the dfops is reset.

Now that the dfops is embedded in the transaction, we can save a bit
more space by using a transaction flag rather than a standalone
boolean. Drop the ->dop_low field and replace it with a transaction
flag that is set at the same points, carried across rolling
transactions and cleared on completion of deferred operations. This
essentially emulates the behavior of ->dop_low and so should not
change behavior.

Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/include/xfs_trans.h b/include/xfs_trans.h
index c11e694f8d6b1936a611f2df963a5c023fa80e6c..c35f1f4187b2a292dec3d9b7fada1a42394d456b 100644 (file)
--- a/include/xfs_trans.h
+++ b/include/xfs_trans.h
@@ -70,8 +70,6 @@ struct xfs_defer_ops {
        /* relog these with each roll */
        struct xfs_inode                *dop_inodes[XFS_DEFER_OPS_NR_INODES];
        struct xfs_buf          *dop_bufs[XFS_DEFER_OPS_NR_BUFS];
-
-       bool                    dop_low;        /* alloc in low mode */
 };
 
 typedef struct xfs_trans {

diff --git a/libxfs/xfs_bmap.c b/libxfs/xfs_bmap.c
index f94dd2b92abbf291f9a65348295ab0a63f5d2dbe..ffcfd16b325c6c712331bc2ce1b79f447dad1713 100644 (file)
--- a/libxfs/xfs_bmap.c
+++ b/libxfs/xfs_bmap.c
@@ -691,7 +691,7 @@ xfs_bmap_extents_to_btree(
        if (tp->t_firstblock == NULLFSBLOCK) {
                args.type = XFS_ALLOCTYPE_START_BNO;
                args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino);
-       } else if (tp->t_dfops->dop_low) {
+       } else if (tp->t_flags & XFS_TRANS_LOWMODE) {
                args.type = XFS_ALLOCTYPE_START_BNO;
                args.fsbno = tp->t_firstblock;
        } else {
@@ -3440,7 +3440,7 @@ xfs_bmap_btalloc(
                        error = xfs_bmap_btalloc_nullfb(ap, &args, &blen);
                if (error)
                        return error;
-       } else if (ap->tp->t_dfops->dop_low) {
+       } else if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
                if (xfs_inode_is_filestream(ap->ip))
                        args.type = XFS_ALLOCTYPE_FIRST_AG;
                else
@@ -3475,7 +3475,7 @@ xfs_bmap_btalloc(
         * is >= the stripe unit and the allocation offset is
         * at the end of file.
         */
-       if (!ap->tp->t_dfops->dop_low && ap->aeof) {
+       if (!(ap->tp->t_flags & XFS_TRANS_LOWMODE) && ap->aeof) {
                if (!ap->offset) {
                        args.alignment = stripe_align;
                        atype = args.type;
@@ -3567,7 +3567,7 @@ xfs_bmap_btalloc(
                args.total = ap->minlen;
                if ((error = xfs_alloc_vextent(&args)))
                        return error;
-               ap->tp->t_dfops->dop_low = true;
+               ap->tp->t_flags |= XFS_TRANS_LOWMODE;
        }
        if (args.fsbno != NULLFSBLOCK) {
                /*

diff --git a/libxfs/xfs_bmap_btree.c b/libxfs/xfs_bmap_btree.c
index 4c513d0e333a062b6c93846ae5d09c021e07aeb5..91cc40f94f491ad708c1a4990fd835dfe9788c82 100644 (file)
--- a/libxfs/xfs_bmap_btree.c
+++ b/libxfs/xfs_bmap_btree.c
@@ -223,7 +223,7 @@ xfs_bmbt_alloc_block(
                 * block allocation here and corrupt the filesystem.
                 */
                args.minleft = args.tp->t_blk_res;
-       } else if (cur->bc_tp->t_dfops->dop_low) {
+       } else if (cur->bc_tp->t_flags & XFS_TRANS_LOWMODE) {
                args.type = XFS_ALLOCTYPE_START_BNO;
        } else {
                args.type = XFS_ALLOCTYPE_NEAR_BNO;
@@ -250,7 +250,7 @@ xfs_bmbt_alloc_block(
                error = xfs_alloc_vextent(&args);
                if (error)
                        goto error0;
-               cur->bc_tp->t_dfops->dop_low = true;
+               cur->bc_tp->t_flags |= XFS_TRANS_LOWMODE;
        }
        if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) {
                *stat = 0;

diff --git a/libxfs/xfs_defer.c b/libxfs/xfs_defer.c
index 5342d683e4b8f60c1602372a12ea463bfe8c808d..b7e4319c170bb808372aad654b9ca814d0dbf5eb 100644 (file)
--- a/libxfs/xfs_defer.c
+++ b/libxfs/xfs_defer.c
@@ -330,9 +330,14 @@ xfs_defer_reset(
 
        ASSERT(!xfs_defer_has_unfinished_work(dop));
 
-       dop->dop_low = false;
        memset(dop->dop_inodes, 0, sizeof(dop->dop_inodes));
        memset(dop->dop_bufs, 0, sizeof(dop->dop_bufs));
+
+       /*
+        * Low mode state transfers across transaction rolls to mirror dfops
+        * lifetime. Clear it now that dfops is reset.
+        */
+       tp->t_flags &= ~XFS_TRANS_LOWMODE;
 }
 
 /*
@@ -590,7 +595,14 @@ xfs_defer_move(
 
        memcpy(dst->dop_inodes, src->dop_inodes, sizeof(dst->dop_inodes));
        memcpy(dst->dop_bufs, src->dop_bufs, sizeof(dst->dop_bufs));
-       dst->dop_low = src->dop_low;
+
+       /*
+        * Low free space mode was historically controlled by a dfops field.
+        * This meant that low mode state potentially carried across multiple
+        * transaction rolls. Transfer low mode on a dfops move to preserve
+        * that behavior.
+        */
+       dtp->t_flags |= (stp->t_flags & XFS_TRANS_LOWMODE);
 
        xfs_defer_reset(stp);
 }

diff --git a/libxfs/xfs_defer.h b/libxfs/xfs_defer.h
index d60c50498fdfbb6e0c4f5e16fa22c922f0c07255..8908a2716774a9c01cd702f216b3cf92962c2030 100644 (file)
--- a/libxfs/xfs_defer.h
+++ b/libxfs/xfs_defer.h
@@ -25,17 +25,6 @@ struct xfs_defer_pending {
 
 /*
  * Header for deferred operation list.
- *
- * dop_low is used by the allocator to activate the lowspace algorithm -
- * when free space is running low the extent allocator may choose to
- * allocate an extent from an AG without leaving sufficient space for
- * a btree split when inserting the new extent.  In this case the allocator
- * will enable the lowspace algorithm which is supposed to allow further
- * allocations (such as btree splits and newroots) to allocate from
- * sequential AGs.  In order to avoid locking AGs out of order the lowspace
- * algorithm will start searching for free space from AG 0.  If the correct
- * transaction reservations have been made then this algorithm will eventually
- * find all the space it needs.
  */
 enum xfs_defer_ops_type {
        XFS_DEFER_OPS_TYPE_BMAP,

diff --git a/libxfs/xfs_shared.h b/libxfs/xfs_shared.h
index 22089f1c880a3d89b10f04b7acdb019995a3b686..1c5debe748f0aca5431fa45daf7fbc078270378e 100644 (file)
--- a/libxfs/xfs_shared.h
+++ b/libxfs/xfs_shared.h
@@ -64,6 +64,18 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp,
 #define XFS_TRANS_RESERVE      0x20    /* OK to use reserved data blocks */
 #define XFS_TRANS_NO_WRITECOUNT 0x40   /* do not elevate SB writecount */
 #define XFS_TRANS_NOFS         0x80    /* pass KM_NOFS to kmem_alloc */
+/*
+ * LOWMODE is used by the allocator to activate the lowspace algorithm - when
+ * free space is running low the extent allocator may choose to allocate an
+ * extent from an AG without leaving sufficient space for a btree split when
+ * inserting the new extent. In this case the allocator will enable the
+ * lowspace algorithm which is supposed to allow further allocations (such as
+ * btree splits and newroots) to allocate from sequential AGs. In order to
+ * avoid locking AGs out of order the lowspace algorithm will start searching
+ * for free space from AG 0. If the correct transaction reservations have been
+ * made then this algorithm will eventually find all the space it needs.
+ */
+#define XFS_TRANS_LOWMODE      0x100   /* allocate in low space mode */
 
 /*
  * Field values for xfs_trans_mod_sb.