xfs
[Top] [All Lists]

[PATCH 02/10] xfs: separate buffer indexing from block map

To: xfs@xxxxxxxxxxx
Subject: [PATCH 02/10] xfs: separate buffer indexing from block map
From: Dave Chinner <david@xxxxxxxxxxxxx>
Date: Tue, 24 Apr 2012 16:33:32 +1000
In-reply-to: <1335249220-22274-1-git-send-email-david@xxxxxxxxxxxxx>
References: <1335249220-22274-1-git-send-email-david@xxxxxxxxxxxxx>
From: Dave Chinner <dchinner@xxxxxxxxxx>

To support discontiguous buffers in the buffer cache, we need to
separate the cache index variables from the I/O map. While this is
currently a 1:1 mapping, discontiguous buffer support will break
this relationship.

However, for caching purposes, we can still treat them the same as a
contiguous buffer - the block number of the first block and the
length of the buffer - as that is still a unique representation.
Also, the only way we will ever access the discontiguous regions of
buffers is via bulding the complete buffer in the first place, so
using the initial block number and entire buffer length is a sane
way to index the buffers.

Add a block mapping vector construct to the xfs_buf and use it in
the places where we are doing IO instead of the current
b_bn/b_length variables.

Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
---
 fs/xfs/xfs_buf.c |   21 +++++++++++++--------
 fs/xfs/xfs_buf.h |   17 +++++++++++++----
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 172d3cc..0a07db4 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -199,6 +199,7 @@ xfs_buf_alloc(
         * most cases but may be reset (e.g. XFS recovery).
         */
        bp->b_length = numblks;
+       bp->b_map.bm_len = numblks;
        bp->b_io_length = numblks;
        bp->b_flags = flags;
 
@@ -209,6 +210,7 @@ xfs_buf_alloc(
         * buffer that hasn't been fully initialised.
         */
        bp->b_bn = XFS_BUF_DADDR_NULL;
+       bp->b_map.bm_bn = XFS_BUF_DADDR_NULL;
        atomic_set(&bp->b_pin_count, 0);
        init_waitqueue_head(&bp->b_waiters);
 
@@ -334,8 +336,9 @@ xfs_buf_allocate_memory(
        }
 
 use_alloc_page:
-       start = BBTOB(bp->b_bn) >> PAGE_SHIFT;
-       end = (BBTOB(bp->b_bn + bp->b_length) + PAGE_SIZE - 1) >> PAGE_SHIFT;
+       start = BBTOB(bp->b_map.bm_bn) >> PAGE_SHIFT;
+       end = (BBTOB(bp->b_map.bm_bn + bp->b_length) + PAGE_SIZE - 1)
+                                                               >> PAGE_SHIFT;
        page_count = end - start;
        error = _xfs_buf_get_pages(bp, page_count, flags);
        if (unlikely(error))
@@ -572,7 +575,7 @@ xfs_buf_get(
         * that we can do IO on it.
         */
        bp->b_bn = blkno;
-       bp->b_io_length = bp->b_length;
+       bp->b_map.bm_bn = blkno;
 
 found:
        if (!bp->b_addr) {
@@ -596,7 +599,7 @@ _xfs_buf_read(
        xfs_buf_flags_t         flags)
 {
        ASSERT(!(flags & XBF_WRITE));
-       ASSERT(bp->b_bn != XFS_BUF_DADDR_NULL);
+       ASSERT(bp->b_map.bm_bn != XFS_BUF_DADDR_NULL);
 
        bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_READ_AHEAD);
        bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);
@@ -677,8 +680,8 @@ xfs_buf_read_uncached(
                return NULL;
 
        /* set up the buffer for a read IO */
-       XFS_BUF_SET_ADDR(bp, daddr);
-       XFS_BUF_READ(bp);
+       bp->b_map.bm_bn = daddr;
+       bp->b_flags |= XBF_READ;
 
        xfsbdstrat(target->bt_mount, bp);
        error = xfs_buf_iowait(bp);
@@ -707,6 +710,8 @@ xfs_buf_set_empty(
        bp->b_length = numblks;
        bp->b_io_length = numblks;
        bp->b_bn = XFS_BUF_DADDR_NULL;
+       bp->b_map.bm_bn = XFS_BUF_DADDR_NULL;
+       bp->b_map.bm_len = bp->b_length;
 }
 
 static inline struct page *
@@ -1171,7 +1176,7 @@ _xfs_buf_ioapply(
        struct bio              *bio;
        int                     offset = bp->b_offset;
        int                     size = BBTOB(bp->b_io_length);
-       sector_t                sector = bp->b_bn;
+       sector_t                sector = bp->b_map.bm_bn;
 
        total_nr_pages = bp->b_page_count;
        map_i = 0;
@@ -1576,7 +1581,7 @@ xfs_buf_cmp(
        struct xfs_buf  *bp = container_of(b, struct xfs_buf, b_list);
        xfs_daddr_t             diff;
 
-       diff = ap->b_bn - bp->b_bn;
+       diff = ap->b_map.bm_bn - bp->b_map.bm_bn;
        if (diff < 0)
                return -1;
        if (diff > 0)
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 7f1d139..cc616969 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -58,6 +58,7 @@ typedef enum {
 #define _XBF_PAGES     (1 << 20)/* backed by refcounted pages */
 #define _XBF_KMEM      (1 << 21)/* backed by heap memory */
 #define _XBF_DELWRI_Q  (1 << 22)/* buffer on a delwri queue */
+#define _XBF_COMPOUND  (1 << 23)/* compound buffer */
 
 typedef unsigned int xfs_buf_flags_t;
 
@@ -75,7 +76,8 @@ typedef unsigned int xfs_buf_flags_t;
        { XBF_UNMAPPED,         "UNMAPPED" },   /* ditto */\
        { _XBF_PAGES,           "PAGES" }, \
        { _XBF_KMEM,            "KMEM" }, \
-       { _XBF_DELWRI_Q,        "DELWRI_Q" }
+       { _XBF_DELWRI_Q,        "DELWRI_Q" }, \
+       { _XBF_COMPOUND,        "COMPOUND" }
 
 typedef struct xfs_buftarg {
        dev_t                   bt_dev;
@@ -98,6 +100,11 @@ typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
 
 #define XB_PAGES       2
 
+struct xfs_buf_map {
+       xfs_daddr_t             bm_bn;  /* block number for I/O */
+       int                     bm_len; /* size of I/O */
+};
+
 typedef struct xfs_buf {
        /*
         * first cacheline holds all the fields needed for an uncontended cache
@@ -107,7 +114,7 @@ typedef struct xfs_buf {
         * fast-path on locking.
         */
        struct rb_node          b_rbnode;       /* rbtree node */
-       xfs_daddr_t             b_bn;           /* block number for I/O */
+       xfs_daddr_t             b_bn;           /* block number of buffer */
        int                     b_length;       /* size of buffer in BBs */
        atomic_t                b_hold;         /* reference count */
        atomic_t                b_lru_ref;      /* lru reclaim ref count */
@@ -127,12 +134,14 @@ typedef struct xfs_buf {
        struct xfs_trans        *b_transp;
        struct page             **b_pages;      /* array of page pointers */
        struct page             *b_page_array[XB_PAGES]; /* inline pages */
+       struct xfs_buf_map      b_map;          /* compound buffer map */
        int                     b_io_length;    /* IO size in BBs */
        atomic_t                b_pin_count;    /* pin count */
        atomic_t                b_io_remaining; /* #outstanding I/O requests */
        unsigned int            b_page_count;   /* size of page array */
        unsigned int            b_offset;       /* page offset in first page */
        unsigned short          b_error;        /* error code on I/O */
+
 #ifdef XFS_BUF_LOCK_TRACKING
        int                     b_last_holder;
 #endif
@@ -233,8 +242,8 @@ void xfs_buf_stale(struct xfs_buf *bp);
 #define XFS_BUF_UNWRITE(bp)    ((bp)->b_flags &= ~XBF_WRITE)
 #define XFS_BUF_ISWRITE(bp)    ((bp)->b_flags & XBF_WRITE)
 
-#define XFS_BUF_ADDR(bp)               ((bp)->b_bn)
-#define XFS_BUF_SET_ADDR(bp, bno)      ((bp)->b_bn = (xfs_daddr_t)(bno))
+#define XFS_BUF_ADDR(bp)               ((bp)->b_map.bm_bn)
+#define XFS_BUF_SET_ADDR(bp, bno)      ((bp)->b_map.bm_bn = (xfs_daddr_t)(bno))
 
 static inline void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref)
 {
-- 
1.7.9.5

<Prev in Thread] Current Thread [Next in Thread>