Split buffer's b_fspriv field

By splitting the b_fspriv field into two different fields (b_log_item
and b_li_list). It's possible to get rid of an old ABI workaround, by
using the new b_log_item field to store xfs_buf_log_item separated from
the log items attached to the buffer, which will be linked in the new
b_li_list field.

This way, there is no more need to reorder the log items list to place
the buf_log_item at the beginning of the list, simplifying a bit the
logic to handle buffer IO.

This also opens the possibility to change buffer's log items list into a
proper list_head.

b_log_item field is still defined as a void *, because it is still used
by the log buffers to store xlog_in_core structures, and there is no
need to add an extra field on xfs_buf just for xlog_in_core.

Signed-off-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Bill O'Donnell <billodo@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
[darrick: minor style changes]
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index 6883a7668de6d44b9bfa81d881f7b9d83d68c8d8..c02781a4c091b7cdc51cb422da40f64b70b29b7e 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -590,8 +590,8 @@ static void
 xfs_agfl_write_verify(
        struct xfs_buf  *bp)
 {
-       struct xfs_mount *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_mount        *mp = bp->b_target->bt_mount;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        xfs_failaddr_t          fa;
 
        /* no verification of non-crc AGFLs */
@@ -2487,8 +2487,8 @@ static void
 xfs_agf_write_verify(
        struct xfs_buf  *bp)
 {
-       struct xfs_mount *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_mount        *mp = bp->b_target->bt_mount;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        xfs_failaddr_t          fa;
 
        fa = xfs_agf_verify(bp);

diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index efe5f8acbd4521072e436bf6c7dc290f18262212..2135b8e67dcc15fdb969939c5fd6b18d09d0fdda 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -309,7 +309,7 @@ xfs_attr3_leaf_write_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
        xfs_failaddr_t          fa;
 

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index 567cff5ed5112f54bdf36a6f4fae15535c7977f3..79ee4a1951d14b6649585167cd6cb5cc05977d68 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -273,7 +273,7 @@ xfs_btree_lblock_calc_crc(
        struct xfs_buf          *bp)
 {
        struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        if (!xfs_sb_version_hascrc(&bp->b_target->bt_mount->m_sb))
                return;
@@ -311,7 +311,7 @@ xfs_btree_sblock_calc_crc(
        struct xfs_buf          *bp)
 {
        struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        if (!xfs_sb_version_hascrc(&bp->b_target->bt_mount->m_sb))
                return;

diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index cf07585b9d83de46a6c88787a595ff8dcb374452..ea187b4a7991c15343d1405af8720e20b2166abc 100644 (file)
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -182,7 +182,7 @@ xfs_da3_node_write_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
        xfs_failaddr_t          fa;
 

diff --git a/fs/xfs/libxfs/xfs_dir2_block.c b/fs/xfs/libxfs/xfs_dir2_block.c
index fe951fa1a583e483d81b9e9a20a62ed2d3b62517..2da86a394bcf05c4091db70b3651a4c52158bc81 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -103,7 +103,7 @@ xfs_dir3_block_write_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
        xfs_failaddr_t          fa;
 

diff --git a/fs/xfs/libxfs/xfs_dir2_data.c b/fs/xfs/libxfs/xfs_dir2_data.c
index a1e30c751c00267dbee126069f4452a46f60fa45..920279485275cf658f31cc5ae023f5cc05cb62c2 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_data.c
+++ b/fs/xfs/libxfs/xfs_dir2_data.c
@@ -320,7 +320,7 @@ xfs_dir3_data_write_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
        xfs_failaddr_t          fa;
 

diff --git a/fs/xfs/libxfs/xfs_dir2_leaf.c b/fs/xfs/libxfs/xfs_dir2_leaf.c
index a7ad649398c70402a97ec21ec62455e0bf3ebe18..d7e630f41f9cd20a23a2986f65beedad4c0fe87a 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -208,7 +208,7 @@ __write_verify(
        uint16_t        magic)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
        xfs_failaddr_t          fa;
 

diff --git a/fs/xfs/libxfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index bb893ae02696a7b4a8bef37e2f16bc3c94df5047..239d97a6429606ae1b37bcd5a1fb11763c341bd2 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -141,7 +141,7 @@ xfs_dir3_free_write_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
        xfs_failaddr_t          fa;
 

diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 3625d1da7462427857113c3e6d2f2d428e55d88d..0e2cf5f0be1f364cb4651a4e3cf2edd64653fb79 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -2557,8 +2557,8 @@ static void
 xfs_agi_write_verify(
        struct xfs_buf  *bp)
 {
-       struct xfs_mount *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_mount        *mp = bp->b_target->bt_mount;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        xfs_failaddr_t          fa;
 
        fa = xfs_agi_verify(bp);

diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index e0c826403c6acf37674f2627f2cc5ad015840584..46af6aa60a8edac7179cc07a2ea07537d9ae05e8 100644 (file)
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -688,7 +688,7 @@ xfs_sb_write_verify(
        struct xfs_buf          *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        int                     error;
 
        error = xfs_sb_verify(bp, false);

diff --git a/fs/xfs/libxfs/xfs_symlink_remote.c b/fs/xfs/libxfs/xfs_symlink_remote.c
index 091e3cf0868f9f4775531b8ce247281ea5b01fa1..5ef5f354587e9c0dc8b5e5042e11e7f6a873b56d 100644 (file)
--- a/fs/xfs/libxfs/xfs_symlink_remote.c
+++ b/fs/xfs/libxfs/xfs_symlink_remote.c
@@ -149,7 +149,7 @@ xfs_symlink_write_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        xfs_failaddr_t          fa;
 
        /* no verification of non-crc buffers */

diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 5b5b4861c729ad83ca6f6acc05a603710ad1d4d9..6fcba7536d7e9da5cca5ce0908a8bfaf66c050f7 100644 (file)
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -176,7 +176,8 @@ typedef struct xfs_buf {
        struct workqueue_struct *b_ioend_wq;    /* I/O completion wq */
        xfs_buf_iodone_t        b_iodone;       /* I/O completion function */
        struct completion       b_iowait;       /* queue for I/O waiters */
-       void                    *b_fspriv;
+       void                    *b_log_item;
+       struct xfs_log_item     *b_li_list;
        struct xfs_trans        *b_transp;
        struct page             **b_pages;      /* array of page pointers */
        struct page             *b_page_array[XB_PAGES]; /* inline pages */

diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 8afcfa3ed976945eef958e265df6ece9f3d4b788..8354fab9796ec1c6a54e80416fba7e892a012055 100644 (file)
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -411,7 +411,7 @@ xfs_buf_item_unpin(
        int                     stale = bip->bli_flags & XFS_BLI_STALE;
        int                     freed;
 
-       ASSERT(bp->b_fspriv == bip);
+       ASSERT(bp->b_log_item == bip);
        ASSERT(atomic_read(&bip->bli_refcount) > 0);
 
        trace_xfs_buf_item_unpin(bip);
@@ -456,13 +456,14 @@ xfs_buf_item_unpin(
                 */
                if (bip->bli_flags & XFS_BLI_STALE_INODE) {
                        xfs_buf_do_callbacks(bp);
-                       bp->b_fspriv = NULL;
+                       bp->b_log_item = NULL;
+                       bp->b_li_list = NULL;
                        bp->b_iodone = NULL;
                } else {
                        spin_lock(&ailp->xa_lock);
                        xfs_trans_ail_delete(ailp, lip, SHUTDOWN_LOG_IO_ERROR);
                        xfs_buf_item_relse(bp);
-                       ASSERT(bp->b_fspriv == NULL);
+                       ASSERT(bp->b_log_item == NULL);
                }
                xfs_buf_relse(bp);
        } else if (freed && remove) {
@@ -722,18 +723,15 @@ xfs_buf_item_free_format(
 
 /*
  * Allocate a new buf log item to go with the given buffer.
- * Set the buffer's b_fsprivate field to point to the new
- * buf log item.  If there are other item's attached to the
- * buffer (see xfs_buf_attach_iodone() below), then put the
- * buf log item at the front.
+ * Set the buffer's b_log_item field to point to the new
+ * buf log item.
  */
 int
 xfs_buf_item_init(
        struct xfs_buf  *bp,
        struct xfs_mount *mp)
 {
-       struct xfs_log_item     *lip = bp->b_fspriv;
-       struct xfs_buf_log_item *bip;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        int                     chunks;
        int                     map_size;
        int                     error;
@@ -741,13 +739,14 @@ xfs_buf_item_init(
 
        /*
         * Check to see if there is already a buf log item for
-        * this buffer.  If there is, it is guaranteed to be
-        * the first.  If we do already have one, there is
+        * this buffer. If we do already have one, there is
         * nothing to do here so return.
         */
        ASSERT(bp->b_target->bt_mount == mp);
-       if (lip != NULL && lip->li_type == XFS_LI_BUF)
+       if (bip != NULL) {
+               ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
                return 0;
+       }
 
        bip = kmem_zone_zalloc(xfs_buf_item_zone, KM_SLEEP);
        xfs_log_item_init(mp, &bip->bli_item, XFS_LI_BUF, &xfs_buf_item_ops);
@@ -781,13 +780,7 @@ xfs_buf_item_init(
                bip->bli_formats[i].blf_map_size = map_size;
        }
 
-       /*
-        * Put the buf item into the list of items attached to the
-        * buffer at the front.
-        */
-       if (bp->b_fspriv)
-               bip->bli_item.li_bio_list = bp->b_fspriv;
-       bp->b_fspriv = bip;
+       bp->b_log_item = bip;
        xfs_buf_hold(bp);
        return 0;
 }
@@ -961,13 +954,14 @@ void
 xfs_buf_item_relse(
        xfs_buf_t       *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
+       struct xfs_log_item     *lip = bp->b_li_list;
 
        trace_xfs_buf_item_relse(bp, _RET_IP_);
        ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL));
 
-       bp->b_fspriv = bip->bli_item.li_bio_list;
-       if (bp->b_fspriv == NULL)
+       bp->b_log_item = NULL;
+       if (lip == NULL)
                bp->b_iodone = NULL;
 
        xfs_buf_rele(bp);
@@ -980,9 +974,7 @@ xfs_buf_item_relse(
  * to be called when the buffer's I/O completes.  If it is not set
  * already, set the buffer's b_iodone() routine to be
  * xfs_buf_iodone_callbacks() and link the log item into the list of
- * items rooted at b_fsprivate.  Items are always added as the second
- * entry in the list if there is a first, because the buf item code
- * assumes that the buf log item is first.
+ * items rooted at b_li_list.
  */
 void
 xfs_buf_attach_iodone(
@@ -995,12 +987,12 @@ xfs_buf_attach_iodone(
        ASSERT(xfs_buf_islocked(bp));
 
        lip->li_cb = cb;
-       head_lip = bp->b_fspriv;
+       head_lip = bp->b_li_list;
        if (head_lip) {
                lip->li_bio_list = head_lip->li_bio_list;
                head_lip->li_bio_list = lip;
        } else {
-               bp->b_fspriv = lip;
+               bp->b_li_list = lip;
        }
 
        ASSERT(bp->b_iodone == NULL ||
@@ -1024,10 +1016,17 @@ STATIC void
 xfs_buf_do_callbacks(
        struct xfs_buf          *bp)
 {
+       struct xfs_buf_log_item *blip = bp->b_log_item;
        struct xfs_log_item     *lip;
 
-       while ((lip = bp->b_fspriv) != NULL) {
-               bp->b_fspriv = lip->li_bio_list;
+       /* If there is a buf_log_item attached, run its callback */
+       if (blip) {
+               lip = &blip->bli_item;
+               lip->li_cb(bp, lip);
+       }
+
+       while ((lip = bp->b_li_list) != NULL) {
+               bp->b_li_list = lip->li_bio_list;
                ASSERT(lip->li_cb != NULL);
                /*
                 * Clear the next pointer so we don't have any
@@ -1052,10 +1051,19 @@ STATIC void
 xfs_buf_do_callbacks_fail(
        struct xfs_buf          *bp)
 {
+       struct xfs_log_item     *lip = bp->b_li_list;
        struct xfs_log_item     *next;
-       struct xfs_log_item     *lip = bp->b_fspriv;
-       struct xfs_ail          *ailp = lip->li_ailp;
+       struct xfs_ail          *ailp;
 
+       /*
+        * Buffer log item errors are handled directly by xfs_buf_item_push()
+        * and xfs_buf_iodone_callback_error, and they have no IO error
+        * callbacks. Check only for items in b_li_list.
+        */
+       if (lip == NULL)
+               return;
+
+       ailp = lip->li_ailp;
        spin_lock(&ailp->xa_lock);
        for (; lip; lip = next) {
                next = lip->li_bio_list;
@@ -1069,12 +1077,20 @@ static bool
 xfs_buf_iodone_callback_error(
        struct xfs_buf          *bp)
 {
-       struct xfs_log_item     *lip = bp->b_fspriv;
-       struct xfs_mount        *mp = lip->li_mountp;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
+       struct xfs_log_item     *lip = bp->b_li_list;
+       struct xfs_mount        *mp;
        static ulong            lasttime;
        static xfs_buftarg_t    *lasttarg;
        struct xfs_error_cfg    *cfg;
 
+       /*
+        * The failed buffer might not have a buf_log_item attached or the
+        * log_item list might be empty. Get the mp from the available
+        * xfs_log_item
+        */
+       mp = bip ? bip->bli_item.li_mountp : lip->li_mountp;
+
        /*
         * If we've already decided to shutdown the filesystem because of
         * I/O errors, there's no point in giving this a retry.
@@ -1183,7 +1199,8 @@ xfs_buf_iodone_callbacks(
        bp->b_first_retry_time = 0;
 
        xfs_buf_do_callbacks(bp);
-       bp->b_fspriv = NULL;
+       bp->b_log_item = NULL;
+       bp->b_li_list = NULL;
        bp->b_iodone = NULL;
        xfs_buf_ioend(bp);
 }

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index c9e40d4fc9396b3c0ff47387a2e94fcc86eb2181..8a3ff6343d91b78ac599f5aa1fc66c6628ea12ab 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2272,7 +2272,7 @@ xfs_ifree_cluster(
                 * stale first, we will not attempt to lock them in the loop
                 * below as the XFS_ISTALE flag will be set.
                 */
-               lip = bp->b_fspriv;
+               lip = bp->b_li_list;
                while (lip) {
                        if (lip->li_type == XFS_LI_INODE) {
                                iip = (xfs_inode_log_item_t *)lip;
@@ -3649,7 +3649,7 @@ xfs_iflush_int(
        /* generate the checksum. */
        xfs_dinode_calc_crc(mp, dip);
 
-       ASSERT(bp->b_fspriv != NULL);
+       ASSERT(bp->b_li_list != NULL);
        ASSERT(bp->b_iodone != NULL);
        return 0;
 

diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 6ee5c3bf19ad9e7940d03e882625c2955962a24d..993736032b4bce5324f1d97b001d49aca6c0c3e0 100644 (file)
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -722,7 +722,7 @@ xfs_iflush_done(
         * Scan the buffer IO completions for other inodes being completed and
         * attach them to the current inode log item.
         */
-       blip = bp->b_fspriv;
+       blip = bp->b_li_list;
        prev = NULL;
        while (blip != NULL) {
                if (blip->li_cb != xfs_iflush_done) {
@@ -734,7 +734,7 @@ xfs_iflush_done(
                /* remove from list */
                next = blip->li_bio_list;
                if (!prev) {
-                       bp->b_fspriv = next;
+                       bp->b_li_list = next;
                } else {
                        prev->li_bio_list = next;
                }

diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index c1f266c34af727d2ad45306544512d52809338ed..20483b654ef11bf1ee3c4c8ffabbf10bace7d8a2 100644 (file)
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1242,7 +1242,7 @@ xlog_space_left(
 static void
 xlog_iodone(xfs_buf_t *bp)
 {
-       struct xlog_in_core     *iclog = bp->b_fspriv;
+       struct xlog_in_core     *iclog = bp->b_log_item;
        struct xlog             *l = iclog->ic_log;
        int                     aborted = 0;
 
@@ -1773,7 +1773,7 @@ STATIC int
 xlog_bdstrat(
        struct xfs_buf          *bp)
 {
-       struct xlog_in_core     *iclog = bp->b_fspriv;
+       struct xlog_in_core     *iclog = bp->b_log_item;
 
        xfs_buf_lock(bp);
        if (iclog->ic_state & XLOG_STATE_IOERROR) {
@@ -1919,7 +1919,7 @@ xlog_sync(
        }
 
        bp->b_io_length = BTOBB(count);
-       bp->b_fspriv = iclog;
+       bp->b_log_item = iclog;
        bp->b_flags &= ~XBF_FLUSH;
        bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
 
@@ -1958,7 +1958,7 @@ xlog_sync(
                XFS_BUF_SET_ADDR(bp, 0);             /* logical 0 */
                xfs_buf_associate_memory(bp,
                                (char *)&iclog->ic_header + count, split);
-               bp->b_fspriv = iclog;
+               bp->b_log_item = iclog;
                bp->b_flags &= ~XBF_FLUSH;
                bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
 

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index d864380b6575b683d1f8d4b7361e72de42c70b69..00240c9ee72e2c07cc653c33885dea21caf1097e 100644 (file)
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -400,9 +400,9 @@ xlog_recover_iodone(
         * On v5 supers, a bli could be attached to update the metadata LSN.
         * Clean it up.
         */
-       if (bp->b_fspriv)
+       if (bp->b_log_item)
                xfs_buf_item_relse(bp);
-       ASSERT(bp->b_fspriv == NULL);
+       ASSERT(bp->b_log_item == NULL);
 
        bp->b_iodone = NULL;
        xfs_buf_ioend(bp);
@@ -2630,7 +2630,7 @@ xlog_recover_validate_buf_type(
                ASSERT(!bp->b_iodone || bp->b_iodone == xlog_recover_iodone);
                bp->b_iodone = xlog_recover_iodone;
                xfs_buf_item_init(bp, mp);
-               bip = bp->b_fspriv;
+               bip = bp->b_log_item;
                bip->bli_item.li_lsn = current_lsn;
        }
 }

diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 74563cd2970c5505e0a18d6d9f9a9ef0cc9666de..653ce379d36bf4798d350932fcd857f5635f0976 100644 (file)
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -82,12 +82,12 @@ _xfs_trans_bjoin(
        ASSERT(bp->b_transp == NULL);
 
        /*
-        * The xfs_buf_log_item pointer is stored in b_fsprivate.  If
+        * The xfs_buf_log_item pointer is stored in b_log_item.  If
         * it doesn't have one yet, then allocate one and initialize it.
         * The checks to see if one is there are in xfs_buf_item_init().
         */
        xfs_buf_item_init(bp, tp->t_mountp);
-       bip = bp->b_fspriv;
+       bip = bp->b_log_item;
        ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
        ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
        ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
@@ -118,7 +118,7 @@ xfs_trans_bjoin(
        struct xfs_buf          *bp)
 {
        _xfs_trans_bjoin(tp, bp, 0);
-       trace_xfs_trans_bjoin(bp->b_fspriv);
+       trace_xfs_trans_bjoin(bp->b_log_item);
 }
 
 /*
@@ -159,7 +159,7 @@ xfs_trans_get_buf_map(
                }
 
                ASSERT(bp->b_transp == tp);
-               bip = bp->b_fspriv;
+               bip = bp->b_log_item;
                ASSERT(bip != NULL);
                ASSERT(atomic_read(&bip->bli_refcount) > 0);
                bip->bli_recur++;
@@ -175,7 +175,7 @@ xfs_trans_get_buf_map(
        ASSERT(!bp->b_error);
 
        _xfs_trans_bjoin(tp, bp, 1);
-       trace_xfs_trans_get_buf(bp->b_fspriv);
+       trace_xfs_trans_get_buf(bp->b_log_item);
        return bp;
 }
 
@@ -211,7 +211,7 @@ xfs_trans_getsb(
         */
        bp = mp->m_sb_bp;
        if (bp->b_transp == tp) {
-               bip = bp->b_fspriv;
+               bip = bp->b_log_item;
                ASSERT(bip != NULL);
                ASSERT(atomic_read(&bip->bli_refcount) > 0);
                bip->bli_recur++;
@@ -224,7 +224,7 @@ xfs_trans_getsb(
                return NULL;
 
        _xfs_trans_bjoin(tp, bp, 1);
-       trace_xfs_trans_getsb(bp->b_fspriv);
+       trace_xfs_trans_getsb(bp->b_log_item);
        return bp;
 }
 
@@ -267,7 +267,7 @@ xfs_trans_read_buf_map(
        if (bp) {
                ASSERT(xfs_buf_islocked(bp));
                ASSERT(bp->b_transp == tp);
-               ASSERT(bp->b_fspriv != NULL);
+               ASSERT(bp->b_log_item != NULL);
                ASSERT(!bp->b_error);
                ASSERT(bp->b_flags & XBF_DONE);
 
@@ -280,7 +280,7 @@ xfs_trans_read_buf_map(
                        return -EIO;
                }
 
-               bip = bp->b_fspriv;
+               bip = bp->b_log_item;
                bip->bli_recur++;
 
                ASSERT(atomic_read(&bip->bli_refcount) > 0);
@@ -330,7 +330,7 @@ xfs_trans_read_buf_map(
 
        if (tp) {
                _xfs_trans_bjoin(tp, bp, 1);
-               trace_xfs_trans_read_buf(bp->b_fspriv);
+               trace_xfs_trans_read_buf(bp->b_log_item);
        }
        *bpp = bp;
        return 0;
@@ -370,7 +370,7 @@ xfs_trans_brelse(
        }
 
        ASSERT(bp->b_transp == tp);
-       bip = bp->b_fspriv;
+       bip = bp->b_log_item;
        ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
        ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
        ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
@@ -462,7 +462,7 @@ xfs_trans_bhold(
        xfs_trans_t             *tp,
        xfs_buf_t               *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(bp->b_transp == tp);
        ASSERT(bip != NULL);
@@ -483,7 +483,7 @@ xfs_trans_bhold_release(
        xfs_trans_t             *tp,
        xfs_buf_t               *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(bp->b_transp == tp);
        ASSERT(bip != NULL);
@@ -504,7 +504,7 @@ xfs_trans_dirty_buf(
        struct xfs_trans        *tp,
        struct xfs_buf          *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(bp->b_transp == tp);
        ASSERT(bip != NULL);
@@ -561,7 +561,7 @@ xfs_trans_log_buf(
        uint                    first,
        uint                    last)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(first <= last && last < BBTOB(bp->b_length));
        ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED));
@@ -607,7 +607,7 @@ xfs_trans_binval(
        xfs_trans_t             *tp,
        xfs_buf_t               *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
        int                     i;
 
        ASSERT(bp->b_transp == tp);
@@ -662,7 +662,7 @@ xfs_trans_inode_buf(
        xfs_trans_t             *tp,
        xfs_buf_t               *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(bp->b_transp == tp);
        ASSERT(bip != NULL);
@@ -686,7 +686,7 @@ xfs_trans_stale_inode_buf(
        xfs_trans_t             *tp,
        xfs_buf_t               *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(bp->b_transp == tp);
        ASSERT(bip != NULL);
@@ -711,7 +711,7 @@ xfs_trans_inode_alloc_buf(
        xfs_trans_t             *tp,
        xfs_buf_t               *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(bp->b_transp == tp);
        ASSERT(bip != NULL);
@@ -733,7 +733,7 @@ xfs_trans_ordered_buf(
        struct xfs_trans        *tp,
        struct xfs_buf          *bp)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(bp->b_transp == tp);
        ASSERT(bip != NULL);
@@ -763,7 +763,7 @@ xfs_trans_buf_set_type(
        struct xfs_buf          *bp,
        enum xfs_blft           type)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        if (!tp)
                return;
@@ -780,8 +780,8 @@ xfs_trans_buf_copy_type(
        struct xfs_buf          *dst_bp,
        struct xfs_buf          *src_bp)
 {
-       struct xfs_buf_log_item *sbip = src_bp->b_fspriv;
-       struct xfs_buf_log_item *dbip = dst_bp->b_fspriv;
+       struct xfs_buf_log_item *sbip = src_bp->b_log_item;
+       struct xfs_buf_log_item *dbip = dst_bp->b_log_item;
        enum xfs_blft           type;
 
        type = xfs_blft_from_flags(&sbip->__bli_format);
@@ -805,7 +805,7 @@ xfs_trans_dquot_buf(
        xfs_buf_t               *bp,
        uint                    type)
 {
-       struct xfs_buf_log_item *bip = bp->b_fspriv;
+       struct xfs_buf_log_item *bip = bp->b_log_item;
 
        ASSERT(type == XFS_BLF_UDQUOT_BUF ||
               type == XFS_BLF_PDQUOT_BUF ||