[PATCH 00/10] xfs: discontiguous buffer support a.k.a. die xfs_dabuf die

[PATCH 00/10] xfs: discontiguous buffer support a.k.a. die xfs_dabuf die

[Dave Chinner]

This patch series builds on top the current patch queue I posted
yesterday. This series replaces the struct xfs-dabuf with an xfs_buf
that can serve the same purpose.

Directory buffers may be made up of multiple extents, but are
currently formed by creating individual buffers and then copying the
data out of them into a linear memory region in a dabuf structure.
All dabuf operations then require walking all the underlying buffers
to change the state of the underlying buffers, and once a dabuf is
modified the contents need to be copied back to the underlying
buffers before they are logged.

All of these operations can be done on a normal xfs_buf, but the
normal xfs_buf does not support multiple disk block ranges or doing
multiple disjoint I/Os to read or write a buffer. Supporting
multiple disk block ranges is not difficult - we simply need to
attach an iovec-like array to the buffer rather than just using a
single block number and length.

Splitting the buffer up into multiple IOs for read and write is not
difficult, either. We already track the number of IO remaining to
complete an IO, so this can be used to wait for the multiple IO
dispatched to complete (for both read and write).

The only interesting twist to this is logging the changes. We can
treat the discontiguous buffer as a single buffer for most purposes
except for formatting the changes into the log. When formatting, we
need to split the changes into a format item per underlying region
so that recovery does not need to know about compound buffers and
can recover each segment of a directory block indivdually as it does
now. The fact that recovery will replay all or none of the
transaction ensures this process is still atomic from a change
recovery point of view.

Further, even though log recovery doesn't use discontiguous buffers,
there will be no confusion between a short buffer written by
recovery and a discontiguous buffer read by the directory code after
mount because the lengths of the buffer will be different. hence we
need no changes to mount or log recovery processing as we already
ensure that all log recovery changes hve been written to disk before
we finish the mount process.

The reason for making this changes is that we can now use a buffer
cache callback to do all the metadata CRC calculations and
verifications across both contiguous and discontiguous directory
blocks. It greatly simplifies the implementation of this code and
makes it consistent with all other metadata buffers. It should also
provide a performance improvement because it avoids double copying
and reduces the number of cached buffers.

I've tested this on 4k/4k (FSB/DB sizes), 512b/64k, and 4k/64k
combinations with xfstests and some dbench, fsmark and compilebench
stress loads. More testing is welcome....

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 01/10] xfs: add trace points for log forces

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

To enable easy tracing of the location of log forces and the
frequency of them via perf, add a pair of trace points to the log
force functions.  This will help debug where excessive log forces
are being issued from by simple perf commands like:

# ~/perf/perf top -e xfs:xfs_log_force -G -U

Which gives this sort of output:

Events: 141  xfs:xfs_log_force
-  100.00%  [kernel]  [k] xfs_log_force
   - xfs_log_force
        87.04% xfsaild
           kthread
           kernel_thread_helper
      - 12.87% xfs_buf_lock
           _xfs_buf_find
           xfs_buf_get
           xfs_trans_get_buf
           xfs_da_do_buf
           xfs_da_get_buf
           xfs_dir2_data_init
           xfs_dir2_leaf_addname
           xfs_dir_createname
           xfs_create
           xfs_vn_mknod
           xfs_vn_create
           vfs_create
           do_last.isra.41
           path_openat
           do_filp_open
           do_sys_open
           sys_open
           system_call_fastpath

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_log.c   |    2 ++
 fs/xfs/xfs_trace.h |   16 ++++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 9b10a15..6b965bf 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -2941,6 +2941,7 @@ xfs_log_force(
 {
 	int	error;
 
+	trace_xfs_log_force(mp, 0);
 	error = _xfs_log_force(mp, flags, NULL);
 	if (error)
 		xfs_warn(mp, "%s: error %d returned.", __func__, error);
@@ -3089,6 +3090,7 @@ xfs_log_force_lsn(
 {
 	int	error;
 
+	trace_xfs_log_force(mp, lsn);
 	error = _xfs_log_force_lsn(mp, lsn, flags, NULL);
 	if (error)
 		xfs_warn(mp, "%s: error %d returned.", __func__, error);
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index febff43..7cf9d35 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -874,6 +874,22 @@ DECLARE_EVENT_CLASS(xfs_log_item_class,
 		  __print_flags(__entry->flags, "|", XFS_LI_FLAGS))
 )
 
+TRACE_EVENT(xfs_log_force,
+	TP_PROTO(struct xfs_mount *mp, xfs_lsn_t lsn),
+	TP_ARGS(mp, lsn),
+	TP_STRUCT__entry(
+		__field(dev_t, dev)
+		__field(xfs_lsn_t, lsn)
+	),
+	TP_fast_assign(
+		__entry->dev = mp->m_super->s_dev;
+		__entry->lsn = lsn;
+	),
+	TP_printk("dev %d:%d lsn 0x%llx",
+		  MAJOR(__entry->dev), MINOR(__entry->dev),
+		  __entry->lsn)
+)
+
 #define DEFINE_LOG_ITEM_EVENT(name) \
 DEFINE_EVENT(xfs_log_item_class, name, \
 	TP_PROTO(struct xfs_log_item *lip), \
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 01/10] xfs: add trace points for log forces

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> To enable easy tracing of the location of log forces and the
> frequency of them via perf, add a pair of trace points to the log
> force functions.  This will help debug where excessive log forces
> are being issued from by simple perf commands like:

Good idea.


Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

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@redhat.com>
---
 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

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> 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@redhat.com>
...
> +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 */

Looks good.
Do you plan to eventually remove b_bn and b_length from xfs_buf?

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Dave Chinner]

On Mon, Apr 30, 2012 at 02:28:44PM -0500, Mark Tinguely wrote:
> On 04/24/12 01:33, Dave Chinner wrote:
> >From: Dave Chinner<dchinner@redhat.com>
> >
> >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@redhat.com>
> ...
> >+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 */
> 
> Looks good.
> Do you plan to eventually remove b_bn and b_length from xfs_buf?

No. b_bn is a fast way of identifying unique buffers for cache
lookups and is located in the same cacheline as the tree node so we
don't take an extra cache miss on every buffer we traverse during
tree walks in _xfs_buf_find(). Also, b_length is used so often it is
much cleaner to keep it around than it s to iterate over all the
maps to calculate it every time it is needed.

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Mark Tinguely]

On 04/30/12 18:24, Dave Chinner wrote:
> On Mon, Apr 30, 2012 at 02:28:44PM -0500, Mark Tinguely wrote:
>> On 04/24/12 01:33, Dave Chinner wrote:
>>> From: Dave Chinner<dchinner@redhat.com>
>>>
>>> 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@redhat.com>
>> ...
>>> +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 */
>>
>> Looks good.
>> Do you plan to eventually remove b_bn and b_length from xfs_buf?
>
> No. b_bn is a fast way of identifying unique buffers for cache
> lookups and is located in the same cacheline as the tree node so we
> don't take an extra cache miss on every buffer we traverse during
> tree walks in _xfs_buf_find(). Also, b_length is used so often it is
> much cleaner to keep it around than it s to iterate over all the
> maps to calculate it every time it is needed.
>
> Cheers,
>
> Dave.

Thanks for the reply. I was thinking that maybe the "inline" map could 
do both of those things. It is not used if there are multiple maps and 
is the same value as the original variables if there is only one map.

--Mark Tinguely.

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Dave Chinner]

On Tue, May 01, 2012 at 08:16:59AM -0500, Mark Tinguely wrote:
> On 04/30/12 18:24, Dave Chinner wrote:
> >On Mon, Apr 30, 2012 at 02:28:44PM -0500, Mark Tinguely wrote:
> >>On 04/24/12 01:33, Dave Chinner wrote:
> >>>From: Dave Chinner<dchinner@redhat.com>
> >>>
> >>>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@redhat.com>
> >>...
> >>>+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 */
> >>
> >>Looks good.
> >>Do you plan to eventually remove b_bn and b_length from xfs_buf?
> >
> >No. b_bn is a fast way of identifying unique buffers for cache
> >lookups and is located in the same cacheline as the tree node so we
> >don't take an extra cache miss on every buffer we traverse during
> >tree walks in _xfs_buf_find(). Also, b_length is used so often it is
> >much cleaner to keep it around than it s to iterate over all the
> >maps to calculate it every time it is needed.
> 
> Thanks for the reply. I was thinking that maybe the "inline" map
> could do both of those things. It is not used if there are multiple
> maps and is the same value as the original variables if there is
> only one map.

I thought about doing that, but then the code gets harder to follow.
e.g. why do we use bp->b_map.b_bn in some places, and
bp->b_maps[0].b_bn in others when most of the time they both point
to the same thing? It just maps it too easy to
misunderstand/misuse/confuse the difference between the buffer
identifiers and the real IO block addresses. I prefer the clarity of
purpose that retaining b_bn/b_length gives, even though there is a
slight increase in memory usage....

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 03/10] xfs: convert internal buffer functions to pass maps

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

While the external interface currently uses separate blockno/length
variables, we need to move internal interfaces to passing and
parsing vector maps. This will then allow us to add external
interfaces to support discontiguous buffer maps as the internal code
will already support them.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_buf.c |  207 ++++++++++++++++++++++++++++++++++++++++++------------
 fs/xfs/xfs_buf.h |   46 +++++++++---
 2 files changed, 199 insertions(+), 54 deletions(-)

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 0a07db4..1766edd 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -164,14 +164,49 @@ xfs_buf_stale(
 	ASSERT(atomic_read(&bp->b_hold) >= 1);
 }
 
+STATIC int
+_xfs_buf_get_maps(
+	struct xfs_buf		*bp,
+	int			map_count)
+{
+	ASSERT(bp->b_maps == NULL);
+	bp->b_map_count = map_count;
+
+	if (map_count == 1) {
+		bp->b_maps = &bp->b_map;
+		return 0;
+	}
+
+	bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
+				KM_NOFS);
+	if (!bp->b_maps)
+		return ENOMEM;
+	return 0;
+}
+
+/*
+ *	Frees b_pages if it was allocated.
+ */
+STATIC void
+_xfs_buf_free_maps(
+	struct xfs_buf	*bp)
+{
+	if (bp->b_maps != &bp->b_map) {
+		kmem_free(bp->b_maps);
+		bp->b_maps = NULL;
+	}
+}
+
 struct xfs_buf *
-xfs_buf_alloc(
+_xfs_buf_alloc(
 	struct xfs_buftarg	*target,
-	xfs_daddr_t		blkno,
-	size_t			numblks,
+	struct xfs_buf_map	*map,
+	int			nmaps,
 	xfs_buf_flags_t		flags)
 {
 	struct xfs_buf		*bp;
+	int			error;
+	int			i;
 
 	bp = kmem_zone_zalloc(xfs_buf_zone, KM_NOFS);
 	if (unlikely(!bp))
@@ -192,16 +227,27 @@ xfs_buf_alloc(
 	sema_init(&bp->b_sema, 0); /* held, no waiters */
 	XB_SET_OWNER(bp);
 	bp->b_target = target;
+	bp->b_flags = flags;
 
 	/*
 	 * Set length and io_length to the same value initially.
 	 * I/O routines should use io_length, which will be the same in
 	 * 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;
+	bp->b_bn = XFS_BUF_DADDR_NULL;
+	error = _xfs_buf_get_maps(bp, nmaps);
+	if (error)  {
+		kmem_zone_free(xfs_buf_zone, bp);
+		return NULL;
+	}
+
+	bp->b_length = 0;
+	for (i = 0; i < nmaps; i++) {
+		bp->b_maps[i].bm_bn = map[i].bm_bn;
+		bp->b_maps[i].bm_len = map[i].bm_len;
+		bp->b_length += map[i].bm_len;
+	}
+	bp->b_io_length = bp->b_length;
 
 	/*
 	 * We do not set the block number here in the buffer because we have not
@@ -209,8 +255,6 @@ xfs_buf_alloc(
 	 * in this state, so this ensures that we are unable to do IO on a
 	 * 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);
 
@@ -289,6 +333,7 @@ xfs_buf_free(
 	} else if (bp->b_flags & _XBF_KMEM)
 		kmem_free(bp->b_addr);
 	_xfs_buf_free_pages(bp);
+	_xfs_buf_free_maps(bp);
 	kmem_zone_free(xfs_buf_zone, bp);
 }
 
@@ -435,8 +480,8 @@ _xfs_buf_map_pages(
 xfs_buf_t *
 _xfs_buf_find(
 	struct xfs_buftarg	*btp,
-	xfs_daddr_t		blkno,
-	size_t			numblks,
+	struct xfs_buf_map	*map,
+	int			nmaps,
 	xfs_buf_flags_t		flags,
 	xfs_buf_t		*new_bp)
 {
@@ -445,7 +490,13 @@ _xfs_buf_find(
 	struct rb_node		**rbp;
 	struct rb_node		*parent;
 	xfs_buf_t		*bp;
+	xfs_daddr_t		blkno = map[0].bm_bn;
+	int			numblks = 0;
+	int			i;
 
+	for (i = 0; i < nmaps; i++) {
+		numblks += map[i].bm_len;
+	}
 	numbytes = BBTOB(numblks);
 
 	/* Check for IOs smaller than the sector size / not sector aligned */
@@ -545,23 +596,27 @@ xfs_buf_get(
 {
 	struct xfs_buf		*bp;
 	struct xfs_buf		*new_bp;
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
 	int			error = 0;
 
-	bp = _xfs_buf_find(target, blkno, numblks, flags, NULL);
+	bp = _xfs_buf_find(target, &map, 1, flags, NULL);
 	if (likely(bp))
 		goto found;
 
-	new_bp = xfs_buf_alloc(target, blkno, numblks, flags);
+	new_bp = _xfs_buf_alloc(target, &map, 1, flags);
 	if (unlikely(!new_bp))
 		return NULL;
 
 	error = xfs_buf_allocate_memory(new_bp, flags);
 	if (error) {
-		kmem_zone_free(xfs_buf_zone, new_bp);
+		xfs_buf_free(new_bp);
 		return NULL;
 	}
 
-	bp = _xfs_buf_find(target, blkno, numblks, flags, new_bp);
+	bp = _xfs_buf_find(target, &map, 1, flags, new_bp);
 	if (!bp) {
 		xfs_buf_free(new_bp);
 		return NULL;
@@ -575,7 +630,6 @@ xfs_buf_get(
 	 * that we can do IO on it.
 	 */
 	bp->b_bn = blkno;
-	bp->b_map.bm_bn = blkno;
 
 found:
 	if (!bp->b_addr) {
@@ -680,7 +734,9 @@ xfs_buf_read_uncached(
 		return NULL;
 
 	/* set up the buffer for a read IO */
-	bp->b_map.bm_bn = daddr;
+	ASSERT(bp->b_map_count == 1);
+	bp->b_bn = daddr;
+	bp->b_maps[0].bm_bn = daddr;
 	bp->b_flags |= XBF_READ;
 
 	xfsbdstrat(target->bt_mount, bp);
@@ -709,9 +765,11 @@ xfs_buf_set_empty(
 	bp->b_addr = NULL;
 	bp->b_length = numblks;
 	bp->b_io_length = numblks;
+
+	ASSERT(bp->b_map_count == 1);
 	bp->b_bn = XFS_BUF_DADDR_NULL;
-	bp->b_map.bm_bn = XFS_BUF_DADDR_NULL;
-	bp->b_map.bm_len = bp->b_length;
+	bp->b_maps[0].bm_bn = XFS_BUF_DADDR_NULL;
+	bp->b_maps[0].bm_len = bp->b_length;
 }
 
 static inline struct page *
@@ -775,9 +833,13 @@ xfs_buf_get_uncached(
 {
 	unsigned long		page_count;
 	int			error, i;
-	xfs_buf_t		*bp;
+	struct xfs_buf		*bp;
+	struct xfs_buf_map	map = {
+		.bm_len = numblks,
+	};
 
-	bp = xfs_buf_alloc(target, 0, numblks, 0);
+
+	bp = _xfs_buf_alloc(target, &map, 1, 0);
 	if (unlikely(bp == NULL))
 		goto fail;
 
@@ -808,6 +870,7 @@ xfs_buf_get_uncached(
 		__free_page(bp->b_pages[i]);
 	_xfs_buf_free_pages(bp);
  fail_free_buf:
+	_xfs_buf_free_maps(bp);
 	kmem_zone_free(xfs_buf_zone, bp);
  fail:
 	return NULL;
@@ -1168,36 +1231,39 @@ xfs_buf_bio_end_io(
 	bio_put(bio);
 }
 
-STATIC void
-_xfs_buf_ioapply(
-	xfs_buf_t		*bp)
+static void
+_xfs_buf_ioapply_map(
+	struct xfs_buf	*bp,
+	int		map,
+	int		*buf_offset,
+	int		*count,
+	int		rw)
 {
-	int			rw, map_i, total_nr_pages, nr_pages;
+	int			page_index;
+	int			total_nr_pages = bp->b_page_count;
+	int			nr_pages;
 	struct bio		*bio;
-	int			offset = bp->b_offset;
-	int			size = BBTOB(bp->b_io_length);
-	sector_t		sector = bp->b_map.bm_bn;
+	sector_t		sector =  bp->b_maps[map].bm_bn;
+	int			size;
+	int			offset;
 
 	total_nr_pages = bp->b_page_count;
-	map_i = 0;
 
-	if (bp->b_flags & XBF_WRITE) {
-		if (bp->b_flags & XBF_SYNCIO)
-			rw = WRITE_SYNC;
-		else
-			rw = WRITE;
-		if (bp->b_flags & XBF_FUA)
-			rw |= REQ_FUA;
-		if (bp->b_flags & XBF_FLUSH)
-			rw |= REQ_FLUSH;
-	} else if (bp->b_flags & XBF_READ_AHEAD) {
-		rw = READA;
-	} else {
-		rw = READ;
+	/* skip the pages in the buffer before the start offset */
+	page_index = 0;
+	offset = *buf_offset;
+	while (offset >= PAGE_SIZE) {
+		page_index++;
+		offset -= PAGE_SIZE;
 	}
 
-	/* we only use the buffer cache for meta-data */
-	rw |= REQ_META;
+	/*
+	 * Limit the IO size to the length of the current vector, and update the
+	 * remaining IO count for the next time around.
+	 */
+	size = min_t(int, BBTOB(bp->b_maps[map].bm_len), *count);
+	*count -= size;
+	*buf_offset += size;
 
 next_chunk:
 	atomic_inc(&bp->b_io_remaining);
@@ -1212,13 +1278,14 @@ next_chunk:
 	bio->bi_private = bp;
 
 
-	for (; size && nr_pages; nr_pages--, map_i++) {
+	for (; size && nr_pages; nr_pages--, page_index++) {
 		int	rbytes, nbytes = PAGE_SIZE - offset;
 
 		if (nbytes > size)
 			nbytes = size;
 
-		rbytes = bio_add_page(bio, bp->b_pages[map_i], nbytes, offset);
+		rbytes = bio_add_page(bio, bp->b_pages[page_index], nbytes,
+				      offset);
 		if (rbytes < nbytes)
 			break;
 
@@ -1240,6 +1307,54 @@ next_chunk:
 		xfs_buf_ioerror(bp, EIO);
 		bio_put(bio);
 	}
+
+}
+
+STATIC void
+_xfs_buf_ioapply(
+	struct xfs_buf	*bp)
+{
+	struct blk_plug	plug;
+	int		rw;
+	int		offset;
+	int		size;
+	int		i;
+
+	if (bp->b_flags & XBF_WRITE) {
+		if (bp->b_flags & XBF_SYNCIO)
+			rw = WRITE_SYNC;
+		else
+			rw = WRITE;
+		if (bp->b_flags & XBF_FUA)
+			rw |= REQ_FUA;
+		if (bp->b_flags & XBF_FLUSH)
+			rw |= REQ_FLUSH;
+	} else if (bp->b_flags & XBF_READ_AHEAD) {
+		rw = READA;
+	} else {
+		rw = READ;
+	}
+
+	/* we only use the buffer cache for meta-data */
+	rw |= REQ_META;
+
+	/*
+	 * Walk all the vectors issuing IO on them. Set up the initial offset
+	 * into the buffer and the desired IO size before we start -
+	 * _xfs_buf_ioapply_vec() will modify them appropriately for each
+	 * subsequent call.
+	 */
+	offset = bp->b_offset;
+	size = BBTOB(bp->b_io_length);
+	blk_start_plug(&plug);
+	for (i = 0; i < bp->b_map_count; i++) {
+		_xfs_buf_ioapply_map(bp, i, &offset, &size, rw);
+		if (bp->b_error)
+			break;
+		if (size <= 0)
+			break;	/* all done */
+	}
+	blk_finish_plug(&plug);
 }
 
 void
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index cc616969..3de9e80 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -134,7 +134,9 @@ 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 */
+	struct xfs_buf_map	*b_maps;	/* compound buffer map */
+	struct xfs_buf_map	b_map;		/* inline compound buffer map */
+	int			b_map_count;
 	int			b_io_length;	/* IO size in BBs */
 	atomic_t		b_pin_count;	/* pin count */
 	atomic_t		b_io_remaining;	/* #outstanding I/O requests */
@@ -149,11 +151,41 @@ typedef struct xfs_buf {
 
 
 /* Finding and Reading Buffers */
-struct xfs_buf *_xfs_buf_find(struct xfs_buftarg *target, xfs_daddr_t blkno,
-				size_t numblks, xfs_buf_flags_t flags,
-				struct xfs_buf *new_bp);
-#define xfs_incore(buftarg,blkno,len,lockit) \
-	_xfs_buf_find(buftarg, blkno ,len, lockit, NULL)
+struct xfs_buf *_xfs_buf_find(struct xfs_buftarg *target,
+			      struct xfs_buf_map *map, int nmaps,
+			      xfs_buf_flags_t flags, struct xfs_buf *new_bp);
+
+static inline struct xfs_buf *
+xfs_incore(
+	struct xfs_buftarg	*target,
+	xfs_daddr_t		blkno,
+	size_t			numblks,
+	xfs_buf_flags_t		flags)
+{
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
+	return _xfs_buf_find(target, &map, 1, flags, NULL);
+}
+
+struct xfs_buf *_xfs_buf_alloc(struct xfs_buftarg *target,
+			       struct xfs_buf_map *map, int nmaps,
+			       xfs_buf_flags_t flags);
+
+static inline struct xfs_buf *
+xfs_buf_alloc(
+	struct xfs_buftarg	*target,
+	xfs_daddr_t		blkno,
+	size_t			numblks,
+	xfs_buf_flags_t		flags)
+{
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
+	return _xfs_buf_alloc(target, &map, 1, flags);
+}
 
 struct xfs_buf *xfs_buf_get(struct xfs_buftarg *target, xfs_daddr_t blkno,
 				size_t numblks, xfs_buf_flags_t flags);
@@ -163,8 +195,6 @@ void xfs_buf_readahead(struct xfs_buftarg *target, xfs_daddr_t blkno,
 				size_t numblks);
 
 struct xfs_buf *xfs_buf_get_empty(struct xfs_buftarg *target, size_t numblks);
-struct xfs_buf *xfs_buf_alloc(struct xfs_buftarg *target, xfs_daddr_t blkno,
-				size_t numblks, xfs_buf_flags_t flags);
 void xfs_buf_set_empty(struct xfs_buf *bp, size_t numblks);
 int xfs_buf_associate_memory(struct xfs_buf *bp, void *mem, size_t length);
 
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 03/10] xfs: convert internal buffer functions to pass maps

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> While the external interface currently uses separate blockno/length
> variables, we need to move internal interfaces to passing and
> parsing vector maps. This will then allow us to add external
> interfaces to support discontiguous buffer maps as the internal code
> will already support them.
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>


Looks good.

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 04/10] xfs: add discontiguous buffer map interface

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

With the internal interfaces supporting discontiguous buffer maps,
add external lookup, read and get interfaces so they can start to be
used.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_buf.c |   42 +++++++++++++++++++----------------------
 fs/xfs/xfs_buf.h |   55 ++++++++++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 68 insertions(+), 29 deletions(-)

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 1766edd..1503094 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -588,25 +588,21 @@ found:
  * more hits than misses.
  */
 struct xfs_buf *
-xfs_buf_get(
-	xfs_buftarg_t		*target,
-	xfs_daddr_t		blkno,
-	size_t			numblks,
+xfs_buf_get_map(
+	struct xfs_buftarg	*target,
+	struct xfs_buf_map	*map,
+	int			nmaps,
 	xfs_buf_flags_t		flags)
 {
 	struct xfs_buf		*bp;
 	struct xfs_buf		*new_bp;
-	struct xfs_buf_map	map = {
-		.bm_bn = blkno,
-		.bm_len = numblks,
-	};
 	int			error = 0;
 
-	bp = _xfs_buf_find(target, &map, 1, flags, NULL);
+	bp = _xfs_buf_find(target, map, nmaps, flags, NULL);
 	if (likely(bp))
 		goto found;
 
-	new_bp = _xfs_buf_alloc(target, &map, 1, flags);
+	new_bp = _xfs_buf_alloc(target, map, nmaps, flags);
 	if (unlikely(!new_bp))
 		return NULL;
 
@@ -616,7 +612,7 @@ xfs_buf_get(
 		return NULL;
 	}
 
-	bp = _xfs_buf_find(target, &map, 1, flags, new_bp);
+	bp = _xfs_buf_find(target, map, nmaps, flags, new_bp);
 	if (!bp) {
 		xfs_buf_free(new_bp);
 		return NULL;
@@ -629,7 +625,7 @@ xfs_buf_get(
 	 * Now we have a workable buffer, fill in the block number so
 	 * that we can do IO on it.
 	 */
-	bp->b_bn = blkno;
+	bp->b_bn = map[0].bm_bn;
 
 found:
 	if (!bp->b_addr) {
@@ -665,17 +661,17 @@ _xfs_buf_read(
 }
 
 xfs_buf_t *
-xfs_buf_read(
-	xfs_buftarg_t		*target,
-	xfs_daddr_t		blkno,
-	size_t			numblks,
+xfs_buf_read_map(
+	struct xfs_buftarg	*target,
+	struct xfs_buf_map	*map,
+	int			nmaps,
 	xfs_buf_flags_t		flags)
 {
-	xfs_buf_t		*bp;
+	struct xfs_buf		*bp;
 
 	flags |= XBF_READ;
 
-	bp = xfs_buf_get(target, blkno, numblks, flags);
+	bp = xfs_buf_get_map(target, map, nmaps, flags);
 	if (bp) {
 		trace_xfs_buf_read(bp, flags, _RET_IP_);
 
@@ -703,15 +699,15 @@ xfs_buf_read(
  *	safe manner.
  */
 void
-xfs_buf_readahead(
-	xfs_buftarg_t		*target,
-	xfs_daddr_t		blkno,
-	size_t			numblks)
+xfs_buf_readahead_map(
+	struct xfs_buftarg	*target,
+	struct xfs_buf_map	*map,
+	int			nmaps)
 {
 	if (bdi_read_congested(target->bt_bdi))
 		return;
 
-	xfs_buf_read(target, blkno, numblks,
+	xfs_buf_read_map(target, map, nmaps,
 		     XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD);
 }
 
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 3de9e80..118d586 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -187,12 +187,55 @@ xfs_buf_alloc(
 	return _xfs_buf_alloc(target, &map, 1, flags);
 }
 
-struct xfs_buf *xfs_buf_get(struct xfs_buftarg *target, xfs_daddr_t blkno,
-				size_t numblks, xfs_buf_flags_t flags);
-struct xfs_buf *xfs_buf_read(struct xfs_buftarg *target, xfs_daddr_t blkno,
-				size_t numblks, xfs_buf_flags_t flags);
-void xfs_buf_readahead(struct xfs_buftarg *target, xfs_daddr_t blkno,
-				size_t numblks);
+struct xfs_buf *xfs_buf_get_map(struct xfs_buftarg *target,
+			       struct xfs_buf_map *map, int nmaps,
+			       xfs_buf_flags_t flags);
+struct xfs_buf *xfs_buf_read_map(struct xfs_buftarg *target,
+			       struct xfs_buf_map *map, int nmaps,
+			       xfs_buf_flags_t flags);
+void xfs_buf_readahead_map(struct xfs_buftarg *target,
+			       struct xfs_buf_map *map, int nmaps);
+
+static inline struct xfs_buf *
+xfs_buf_get(
+	struct xfs_buftarg	*target,
+	xfs_daddr_t		blkno,
+	size_t			numblks,
+	xfs_buf_flags_t		flags)
+{
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
+	return xfs_buf_get_map(target, &map, 1, flags);
+}
+
+static inline struct xfs_buf *
+xfs_buf_read(
+	struct xfs_buftarg	*target,
+	xfs_daddr_t		blkno,
+	size_t			numblks,
+	xfs_buf_flags_t		flags)
+{
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
+	return xfs_buf_read_map(target, &map, 1, flags);
+}
+
+static inline void
+xfs_buf_readahead(
+	struct xfs_buftarg	*target,
+	xfs_daddr_t		blkno,
+	size_t			numblks)
+{
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
+	return xfs_buf_readahead_map(target, &map, 1);
+}
 
 struct xfs_buf *xfs_buf_get_empty(struct xfs_buftarg *target, size_t numblks);
 void xfs_buf_set_empty(struct xfs_buf *bp, size_t numblks);
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 04/10] xfs: add discontiguous buffer map interface

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> With the internal interfaces supporting discontiguous buffer maps,
> add external lookup, read and get interfaces so they can start to be
> used.
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>

Looks good.

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 05/10] xfs: add discontiguous buffer support to transactions

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

Now that the buffer cache supports discontiguous buffers, add
support to the transaction buffer interface for getting and reading
buffers.

Note that this patch does not convert the buffer item logging to
support discontiguous buffers. That will be done as a separate
commit.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_trans.h     |   50 +++++++++++++++++++++++++++++++----
 fs/xfs/xfs_trans_buf.c |   68 ++++++++++++++++++++++++------------------------
 2 files changed, 79 insertions(+), 39 deletions(-)

diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index a5d31d5..7a50ad3 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -450,11 +450,51 @@ xfs_trans_t	*xfs_trans_dup(xfs_trans_t *);
 int		xfs_trans_reserve(xfs_trans_t *, uint, uint, uint,
 				  uint, uint);
 void		xfs_trans_mod_sb(xfs_trans_t *, uint, int64_t);
-struct xfs_buf	*xfs_trans_get_buf(xfs_trans_t *, struct xfs_buftarg *, xfs_daddr_t,
-				   int, uint);
-int		xfs_trans_read_buf(struct xfs_mount *, xfs_trans_t *,
-				   struct xfs_buftarg *, xfs_daddr_t, int, uint,
-				   struct xfs_buf **);
+
+struct xfs_buf	*xfs_trans_get_buf_map(struct xfs_trans *tp,
+				       struct xfs_buftarg *target,
+				       struct xfs_buf_map *map, int nmaps,
+				       uint flags);
+
+static inline struct xfs_buf *
+xfs_trans_get_buf(
+	struct xfs_trans	*tp,
+	struct xfs_buftarg	*target,
+	xfs_daddr_t		blkno,
+	int			numblks,
+	uint			flags)
+{
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
+	return xfs_trans_get_buf_map(tp, target, &map, 1, flags);
+}
+
+int		xfs_trans_read_buf_map(struct xfs_mount *mp,
+				       struct xfs_trans *tp,
+				       struct xfs_buftarg *target,
+				       struct xfs_buf_map *map, int nmaps,
+				       xfs_buf_flags_t flags,
+				       struct xfs_buf **bpp);
+
+static inline int
+xfs_trans_read_buf(
+	struct xfs_mount	*mp,
+	struct xfs_trans	*tp,
+	struct xfs_buftarg	*target,
+	xfs_daddr_t		blkno,
+	int			numblks,
+	xfs_buf_flags_t		flags,
+	struct xfs_buf		**bpp)
+{
+	struct xfs_buf_map	map = {
+		.bm_bn = blkno,
+		.bm_len = numblks,
+	};
+	return xfs_trans_read_buf_map(mp, tp, target, &map, 1, flags, bpp);
+}
+
 struct xfs_buf	*xfs_trans_getsb(xfs_trans_t *, struct xfs_mount *, int);
 
 void		xfs_trans_brelse(xfs_trans_t *, struct xfs_buf *);
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 21c5a5e..6311b99 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -41,20 +41,26 @@ STATIC struct xfs_buf *
 xfs_trans_buf_item_match(
 	struct xfs_trans	*tp,
 	struct xfs_buftarg	*target,
-	xfs_daddr_t		blkno,
-	int			len)
+	struct xfs_buf_map	*map,
+	int			nmaps)
 {
 	struct xfs_log_item_desc *lidp;
 	struct xfs_buf_log_item	*blip;
+	int			len = 0;
+	int			i;
+
+	for (i = 0; i < nmaps; i++)
+		len += map[i].bm_len;
 
-	len = BBTOB(len);
 	list_for_each_entry(lidp, &tp->t_items, lid_trans) {
 		blip = (struct xfs_buf_log_item *)lidp->lid_item;
 		if (blip->bli_item.li_type == XFS_LI_BUF &&
 		    blip->bli_buf->b_target == target &&
-		    XFS_BUF_ADDR(blip->bli_buf) == blkno &&
-		    BBTOB(blip->bli_buf->b_length) == len)
+		    XFS_BUF_ADDR(blip->bli_buf) == map[0].bm_bn &&
+		    blip->bli_buf->b_length == len) {
+			ASSERT(blip->bli_buf->b_map_count == nmaps);
 			return blip->bli_buf;
+		}
 	}
 
 	return NULL;
@@ -128,21 +134,19 @@ xfs_trans_bjoin(
  * If the transaction pointer is NULL, make this just a normal
  * get_buf() call.
  */
-xfs_buf_t *
-xfs_trans_get_buf(xfs_trans_t	*tp,
-		  xfs_buftarg_t	*target_dev,
-		  xfs_daddr_t	blkno,
-		  int		len,
-		  uint		flags)
+struct xfs_buf *
+xfs_trans_get_buf_map(
+	struct xfs_trans	*tp,
+	struct xfs_buftarg	*target,
+	struct xfs_buf_map	*map,
+	int			nmaps,
+	xfs_buf_flags_t		flags)
 {
 	xfs_buf_t		*bp;
 	xfs_buf_log_item_t	*bip;
 
-	/*
-	 * Default to a normal get_buf() call if the tp is NULL.
-	 */
-	if (tp == NULL)
-		return xfs_buf_get(target_dev, blkno, len, flags);
+	if (!tp)
+		return xfs_buf_get_map(target, map, nmaps, flags);
 
 	/*
 	 * If we find the buffer in the cache with this transaction
@@ -150,7 +154,7 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
 	 * have it locked.  In this case we just increment the lock
 	 * recursion count and return the buffer to the caller.
 	 */
-	bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len);
+	bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
 	if (bp != NULL) {
 		ASSERT(xfs_buf_islocked(bp));
 		if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) {
@@ -167,7 +171,7 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
 		return (bp);
 	}
 
-	bp = xfs_buf_get(target_dev, blkno, len, flags);
+	bp = xfs_buf_get_map(target, map, nmaps, flags);
 	if (bp == NULL) {
 		return NULL;
 	}
@@ -246,26 +250,22 @@ int	xfs_error_mod = 33;
  * read_buf() call.
  */
 int
-xfs_trans_read_buf(
-	xfs_mount_t	*mp,
-	xfs_trans_t	*tp,
-	xfs_buftarg_t	*target,
-	xfs_daddr_t	blkno,
-	int		len,
-	uint		flags,
-	xfs_buf_t	**bpp)
+xfs_trans_read_buf_map(
+	struct xfs_mount	*mp,
+	struct xfs_trans	*tp,
+	struct xfs_buftarg	*target,
+	struct xfs_buf_map	*map,
+	int			nmaps,
+	xfs_buf_flags_t		flags,
+	struct xfs_buf		**bpp)
 {
 	xfs_buf_t		*bp;
 	xfs_buf_log_item_t	*bip;
 	int			error;
 
 	*bpp = NULL;
-
-	/*
-	 * Default to a normal get_buf() call if the tp is NULL.
-	 */
-	if (tp == NULL) {
-		bp = xfs_buf_read(target, blkno, len, flags);
+	if (!tp) {
+		bp = xfs_buf_read_map(target, map, nmaps, flags);
 		if (!bp)
 			return (flags & XBF_TRYLOCK) ?
 					EAGAIN : XFS_ERROR(ENOMEM);
@@ -303,7 +303,7 @@ xfs_trans_read_buf(
 	 * If the buffer is not yet read in, then we read it in, increment
 	 * the lock recursion count, and return it to the caller.
 	 */
-	bp = xfs_trans_buf_item_match(tp, target, blkno, len);
+	bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
 	if (bp != NULL) {
 		ASSERT(xfs_buf_islocked(bp));
 		ASSERT(bp->b_transp == tp);
@@ -349,7 +349,7 @@ xfs_trans_read_buf(
 		return 0;
 	}
 
-	bp = xfs_buf_read(target, blkno, len, flags);
+	bp = xfs_buf_read_map(target, map, nmaps, flags);
 	if (bp == NULL) {
 		*bpp = NULL;
 		return (flags & XBF_TRYLOCK) ?
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 05/10] xfs: add discontiguous buffer support to transactions

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> Now that the buffer cache supports discontiguous buffers, add
> support to the transaction buffer interface for getting and reading
> buffers.
>
> Note that this patch does not convert the buffer item logging to
> support discontiguous buffers. That will be done as a separate
> commit.
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>
> ---

Looks good.

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 06/10] xfs: struct xfs_buf_log_format isn't variable sized.

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

The struct xfs_buf_log_format wants to think the dirty bitmap is
variable sized.  In fact, it is variable size on disk simply due to
the way we map it from the in-memory structure, but we still just
use a fixed size memory allocation for the in-memory structure.

Hence it makes no sense to set the function up as a variable sized
structure when we already know it's maximum size, and we always
allocate it as such. Simplify the structure by making the dirty
bitmap a fixed sized array and just using the size of the structure
for the allocation size.

This will make it much simpler to allocate and manipulate an array
of format structures for discontiguous buffer support.

The previous struct xfs_buf_log_item size according to
/proc/slabinfo was 224 bytes. pahole doesn't give the same size
because of the variable size definition. With this modification,
pahole reports the same as /proc/slabinfo:

	/* size: 224, cachelines: 4, members: 6 */

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_alloc_btree.h |   14 --------------
 fs/xfs/xfs_buf_item.h    |   36 ++++++++++++++++++------------------
 fs/xfs/xfs_super.c       |    5 ++---
 fs/xfs/xfs_types.h       |   14 ++++++++++++++
 4 files changed, 34 insertions(+), 35 deletions(-)

diff --git a/fs/xfs/xfs_alloc_btree.h b/fs/xfs/xfs_alloc_btree.h
index a6caa00..359fb86 100644
--- a/fs/xfs/xfs_alloc_btree.h
+++ b/fs/xfs/xfs_alloc_btree.h
@@ -51,20 +51,6 @@ typedef struct xfs_alloc_rec_incore {
 typedef __be32 xfs_alloc_ptr_t;
 
 /*
- * Minimum and maximum blocksize and sectorsize.
- * The blocksize upper limit is pretty much arbitrary.
- * The sectorsize upper limit is due to sizeof(sb_sectsize).
- */
-#define XFS_MIN_BLOCKSIZE_LOG	9	/* i.e. 512 bytes */
-#define XFS_MAX_BLOCKSIZE_LOG	16	/* i.e. 65536 bytes */
-#define XFS_MIN_BLOCKSIZE	(1 << XFS_MIN_BLOCKSIZE_LOG)
-#define XFS_MAX_BLOCKSIZE	(1 << XFS_MAX_BLOCKSIZE_LOG)
-#define XFS_MIN_SECTORSIZE_LOG	9	/* i.e. 512 bytes */
-#define XFS_MAX_SECTORSIZE_LOG	15	/* i.e. 32768 bytes */
-#define XFS_MIN_SECTORSIZE	(1 << XFS_MIN_SECTORSIZE_LOG)
-#define XFS_MAX_SECTORSIZE	(1 << XFS_MAX_SECTORSIZE_LOG)
-
-/*
  * Block numbers in the AG:
  * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
  */
diff --git a/fs/xfs/xfs_buf_item.h b/fs/xfs/xfs_buf_item.h
index b6ecd20..ff26867 100644
--- a/fs/xfs/xfs_buf_item.h
+++ b/fs/xfs/xfs_buf_item.h
@@ -21,23 +21,6 @@
 extern kmem_zone_t	*xfs_buf_item_zone;
 
 /*
- * This is the structure used to lay out a buf log item in the
- * log.  The data map describes which 128 byte chunks of the buffer
- * have been logged.
- * For 6.2 and beyond, this is XFS_LI_BUF.  We use this to log everything.
- */
-typedef struct xfs_buf_log_format {
-	unsigned short	blf_type;	/* buf log item type indicator */
-	unsigned short	blf_size;	/* size of this item */
-	ushort		blf_flags;	/* misc state */
-	ushort		blf_len;	/* number of blocks in this buf */
-	__int64_t	blf_blkno;	/* starting blkno of this buf */
-	unsigned int	blf_map_size;	/* size of data bitmap in words */
-	unsigned int	blf_data_map[1];/* variable size bitmap of */
-					/*   regions of buffer in this item */
-} xfs_buf_log_format_t;
-
-/*
  * This flag indicates that the buffer contains on disk inodes
  * and requires special recovery handling.
  */
@@ -61,6 +44,23 @@ typedef struct xfs_buf_log_format {
 #define	NBWORD			(NBBY * sizeof(unsigned int))
 
 /*
+ * This is the structure used to lay out a buf log item in the
+ * log.  The data map describes which 128 byte chunks of the buffer
+ * have been logged.
+ */
+#define XFS_BLF_DATAMAP_SIZE	((XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK) / NBWORD)
+
+typedef struct xfs_buf_log_format {
+	unsigned short	blf_type;	/* buf log item type indicator */
+	unsigned short	blf_size;	/* size of this item */
+	ushort		blf_flags;	/* misc state */
+	ushort		blf_len;	/* number of blocks in this buf */
+	__int64_t	blf_blkno;	/* starting blkno of this buf */
+	unsigned int	blf_map_size;	/* used size of data bitmap in words */
+	unsigned int	blf_data_map[XFS_BLF_DATAMAP_SIZE]; /* dirty bitmap */
+} xfs_buf_log_format_t;
+
+/*
  * buf log item flags
  */
 #define	XFS_BLI_HOLD		0x01
@@ -102,7 +102,7 @@ typedef struct xfs_buf_log_item {
 	char			*bli_orig;	/* original buffer copy */
 	char			*bli_logged;	/* bytes logged (bitmap) */
 #endif
-	xfs_buf_log_format_t	bli_format;	/* in-log header */
+	struct xfs_buf_log_format bli_format;	/* embedded in-log header */
 } xfs_buf_log_item_t;
 
 void	xfs_buf_item_init(struct xfs_buf *, struct xfs_mount *);
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 36528d2..65b51d2 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1514,9 +1514,8 @@ xfs_init_zones(void)
 	 * size possible under XFS.  This wastes a little bit of memory,
 	 * but it is much faster.
 	 */
-	xfs_buf_item_zone = kmem_zone_init((sizeof(xfs_buf_log_item_t) +
-				(((XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK) /
-				  NBWORD) * sizeof(int))), "xfs_buf_item");
+	xfs_buf_item_zone = kmem_zone_init(sizeof(struct xfs_buf_log_item),
+					   "xfs_buf_item");
 	if (!xfs_buf_item_zone)
 		goto out_destroy_log_item_desc_zone;
 
diff --git a/fs/xfs/xfs_types.h b/fs/xfs/xfs_types.h
index 398cf68..7a41874 100644
--- a/fs/xfs/xfs_types.h
+++ b/fs/xfs/xfs_types.h
@@ -133,6 +133,20 @@ typedef __uint64_t	xfs_filblks_t;	/* number of blocks in a file */
 #define	MAXAEXTNUM	((xfs_aextnum_t)0x7fff)		/* signed short */
 
 /*
+ * Minimum and maximum blocksize and sectorsize.
+ * The blocksize upper limit is pretty much arbitrary.
+ * The sectorsize upper limit is due to sizeof(sb_sectsize).
+ */
+#define XFS_MIN_BLOCKSIZE_LOG	9	/* i.e. 512 bytes */
+#define XFS_MAX_BLOCKSIZE_LOG	16	/* i.e. 65536 bytes */
+#define XFS_MIN_BLOCKSIZE	(1 << XFS_MIN_BLOCKSIZE_LOG)
+#define XFS_MAX_BLOCKSIZE	(1 << XFS_MAX_BLOCKSIZE_LOG)
+#define XFS_MIN_SECTORSIZE_LOG	9	/* i.e. 512 bytes */
+#define XFS_MAX_SECTORSIZE_LOG	15	/* i.e. 32768 bytes */
+#define XFS_MIN_SECTORSIZE	(1 << XFS_MIN_SECTORSIZE_LOG)
+#define XFS_MAX_SECTORSIZE	(1 << XFS_MAX_SECTORSIZE_LOG)
+
+/*
  * Min numbers of data/attr fork btree root pointers.
  */
 #define MINDBTPTRS	3
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 06/10] xfs: struct xfs_buf_log_format isn't variable sized.

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> The struct xfs_buf_log_format wants to think the dirty bitmap is
> variable sized.  In fact, it is variable size on disk simply due to
> the way we map it from the in-memory structure, but we still just
> use a fixed size memory allocation for the in-memory structure.
>
> Hence it makes no sense to set the function up as a variable sized
> structure when we already know it's maximum size, and we always
> allocate it as such. Simplify the structure by making the dirty
> bitmap a fixed sized array and just using the size of the structure
> for the allocation size.
>
> This will make it much simpler to allocate and manipulate an array
> of format structures for discontiguous buffer support.
>
> The previous struct xfs_buf_log_item size according to
> /proc/slabinfo was 224 bytes. pahole doesn't give the same size
> because of the variable size definition. With this modification,
> pahole reports the same as /proc/slabinfo:
>
> 	/* size: 224, cachelines: 4, members: 6 */
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>

Looks good.

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 07/10] xfs: support discontiguous buffers in the xfs_buf_log_item

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

>From the perspective of the log, we need to keep each segment of a
discontigous buffer in separate buffer format structures. This means log
recovery will recover all the changes on a per segment basis without
requiring any knowledge of the fact that it was logged from a
compound buffer.

To do this, we need to be able to determine what buffer segment any
given offset into the compound buffer sits over. This enables us to
translate the dirty bitmap in the number of separate buffer format
structures required.

We also need to be able to determine the number of bitmap elements
that a given buffer segment has, as this determines the size of the
buffer format structure. Hence we need to be able to determine the
both the start offset into the buffer and the length of a given
segment to be able to calculate this.

With this information, we can preallocate, build and format the
correct log vector array for each segment in a compound buffer to
appear exactly the same as individually logged buffers in the log.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_buf_item.c |  337 +++++++++++++++++++++++++++++++++++--------------
 fs/xfs/xfs_buf_item.h |    2 +
 2 files changed, 247 insertions(+), 92 deletions(-)

diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 45df2b8..a1b83a8 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -153,33 +153,25 @@ STATIC void	xfs_buf_do_callbacks(struct xfs_buf *bp);
  * If the XFS_BLI_STALE flag has been set, then log nothing.
  */
 STATIC uint
-xfs_buf_item_size(
-	struct xfs_log_item	*lip)
+xfs_buf_item_size_segment(
+	struct xfs_buf_log_item	*bip,
+	struct xfs_buf_log_format *blfp)
 {
-	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);
 	struct xfs_buf		*bp = bip->bli_buf;
 	uint			nvecs;
 	int			next_bit;
 	int			last_bit;
 
-	ASSERT(atomic_read(&bip->bli_refcount) > 0);
-	if (bip->bli_flags & XFS_BLI_STALE) {
-		/*
-		 * The buffer is stale, so all we need to log
-		 * is the buf log format structure with the
-		 * cancel flag in it.
-		 */
-		trace_xfs_buf_item_size_stale(bip);
-		ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
-		return 1;
-	}
+	last_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);
+	if (last_bit == -1)
+		return 0;
+
+	/*
+	 * initial count for a dirty buffer is 2 vectors - the format structure
+	 * and the first dirty region.
+	 */
+	nvecs = 2;
 
-	ASSERT(bip->bli_flags & XFS_BLI_LOGGED);
-	nvecs = 1;
-	last_bit = xfs_next_bit(bip->bli_format.blf_data_map,
-					 bip->bli_format.blf_map_size, 0);
-	ASSERT(last_bit != -1);
-	nvecs++;
 	while (last_bit != -1) {
 		/*
 		 * This takes the bit number to start looking from and
@@ -187,16 +179,15 @@ xfs_buf_item_size(
 		 * if there are no more bits set or the start bit is
 		 * beyond the end of the bitmap.
 		 */
-		next_bit = xfs_next_bit(bip->bli_format.blf_data_map,
-						 bip->bli_format.blf_map_size,
-						 last_bit + 1);
+		next_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size,
+					last_bit + 1);
 		/*
 		 * If we run out of bits, leave the loop,
 		 * else if we find a new set of bits bump the number of vecs,
 		 * else keep scanning the current set of bits.
 		 */
 		if (next_bit == -1) {
-			last_bit = -1;
+			break;
 		} else if (next_bit != last_bit + 1) {
 			last_bit = next_bit;
 			nvecs++;
@@ -210,22 +201,73 @@ xfs_buf_item_size(
 		}
 	}
 
-	trace_xfs_buf_item_size(bip);
 	return nvecs;
 }
 
 /*
- * This is called to fill in the vector of log iovecs for the
- * given log buf item.  It fills the first entry with a buf log
- * format structure, and the rest point to contiguous chunks
- * within the buffer.
+ * This returns the number of log iovecs needed to log the given buf log item.
+ *
+ * It calculates this as 1 iovec for the buf log format structure and 1 for each
+ * stretch of non-contiguous chunks to be logged.  Contiguous chunks are logged
+ * in a single iovec.
+ *
+ * Discontiguous buffers need a format structure per region that that is being
+ * logged. This makes the changes in the buffer appear to log recovery as though
+ * they came from separate buffers, just like would occur if multiple buffers
+ * were used instead of a single discontiguous buffer. This enables
+ * discontiguous buffers to be in-memory constructs, completely transparent to
+ * what ends up on disk.
+ *
+ * If the XFS_BLI_STALE flag has been set, then log nothing but the buf log
+ * format structures.
  */
-STATIC void
-xfs_buf_item_format(
-	struct xfs_log_item	*lip,
-	struct xfs_log_iovec	*vecp)
+STATIC uint
+xfs_buf_item_size(
+	struct xfs_log_item	*lip)
 {
 	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);
+	uint			nvecs;
+	int			i;
+
+	ASSERT(atomic_read(&bip->bli_refcount) > 0);
+	if (bip->bli_flags & XFS_BLI_STALE) {
+		/*
+		 * The buffer is stale, so all we need to log
+		 * is the buf log format structure with the
+		 * cancel flag in it.
+		 */
+		trace_xfs_buf_item_size_stale(bip);
+		ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
+		return bip->bli_format_count;
+	}
+
+	ASSERT(bip->bli_flags & XFS_BLI_LOGGED);
+
+	/*
+	 * the vector count is based on the number of buffer vectors we have
+	 * dirty bits in. This will only be greater than one when we have a
+	 * compound buffer with more than one segment dirty. Hence for compound
+	 * buffers we need to track which segment the dirty bits correspond to,
+	 * and when we move from one segment to the next increment the vector
+	 * count for the extra buf log format structure that will need to be
+	 * written.
+	 */
+	nvecs = 0;
+	for (i = 0; i < bip->bli_format_count; i++) {
+		nvecs += xfs_buf_item_size_segment(bip, &bip->bli_formats[i]);
+	}
+
+	trace_xfs_buf_item_size(bip);
+	return nvecs;
+}
+
+static struct xfs_log_iovec *
+xfs_buf_item_format_segment(
+	struct xfs_buf_log_item	*bip,
+	struct xfs_log_iovec	*vecp,
+	uint			offset,
+	struct xfs_buf_log_format *blfp)
+{
 	struct xfs_buf	*bp = bip->bli_buf;
 	uint		base_size;
 	uint		nvecs;
@@ -235,38 +277,34 @@ xfs_buf_item_format(
 	uint		nbits;
 	uint		buffer_offset;
 
-	ASSERT(atomic_read(&bip->bli_refcount) > 0);
-	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||
-	       (bip->bli_flags & XFS_BLI_STALE));
+	/* copy the flags across from the base format item */
+	blfp->blf_flags = bip->bli_format.blf_flags;
 
 	/*
-	 * The size of the base structure is the size of the
-	 * declared structure plus the space for the extra words
-	 * of the bitmap.  We subtract one from the map size, because
-	 * the first element of the bitmap is accounted for in the
-	 * size of the base structure.
+	 * Base size is the actual size of the ondisk structure - it reflects
+	 * the actual size of the dirty bitmap rather than the size of the in
+	 * memory structure. The xfs_buf_log_format size is the maximum,
+	 * subtract the unused part of the bitmap from it.
 	 */
-	base_size =
-		(uint)(sizeof(xfs_buf_log_format_t) +
-		       ((bip->bli_format.blf_map_size - 1) * sizeof(uint)));
-	vecp->i_addr = &bip->bli_format;
+	base_size = sizeof(struct xfs_buf_log_format) -
+		    ((XFS_BLF_DATAMAP_SIZE - blfp->blf_map_size) * sizeof(uint));
+	vecp->i_addr = blfp;
 	vecp->i_len = base_size;
 	vecp->i_type = XLOG_REG_TYPE_BFORMAT;
 	vecp++;
 	nvecs = 1;
 
 	/*
-	 * If it is an inode buffer, transfer the in-memory state to the
-	 * format flags and clear the in-memory state. We do not transfer
+	 * If it is an inode buffer, transfer the in-memory state to the format
+	 * flags. The in-memory state gets cleared later. We do not transfer
 	 * this state if the inode buffer allocation has not yet been committed
-	 * to the log as setting the XFS_BLI_INODE_BUF flag will prevent
-	 * correct replay of the inode allocation.
+	 * to the log as setting the XFS_BLI_INODE_BUF flag will prevent correct
+	 * replay of the inode allocation.
 	 */
 	if (bip->bli_flags & XFS_BLI_INODE_BUF) {
 		if (!((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&
-		      xfs_log_item_in_current_chkpt(lip)))
-			bip->bli_format.blf_flags |= XFS_BLF_INODE_BUF;
-		bip->bli_flags &= ~XFS_BLI_INODE_BUF;
+		      xfs_log_item_in_current_chkpt(&bip->bli_item)))
+			blfp->blf_flags |= XFS_BLF_INODE_BUF;
 	}
 
 	if (bip->bli_flags & XFS_BLI_STALE) {
@@ -276,16 +314,15 @@ xfs_buf_item_format(
 		 * cancel flag in it.
 		 */
 		trace_xfs_buf_item_format_stale(bip);
-		ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
-		bip->bli_format.blf_size = nvecs;
-		return;
+		ASSERT(blfp->blf_flags & XFS_BLF_CANCEL);
+		blfp->blf_size = nvecs;
+		return vecp;
 	}
 
 	/*
 	 * Fill in an iovec for each set of contiguous chunks.
 	 */
-	first_bit = xfs_next_bit(bip->bli_format.blf_data_map,
-					 bip->bli_format.blf_map_size, 0);
+	first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);
 	ASSERT(first_bit != -1);
 	last_bit = first_bit;
 	nbits = 1;
@@ -296,9 +333,8 @@ xfs_buf_item_format(
 		 * if there are no more bits set or the start bit is
 		 * beyond the end of the bitmap.
 		 */
-		next_bit = xfs_next_bit(bip->bli_format.blf_data_map,
-						 bip->bli_format.blf_map_size,
-						 (uint)last_bit + 1);
+		next_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size,
+					(uint)last_bit + 1);
 		/*
 		 * If we run out of bits fill in the last iovec and get
 		 * out of the loop.
@@ -309,14 +345,14 @@ xfs_buf_item_format(
 		 * keep counting and scanning.
 		 */
 		if (next_bit == -1) {
-			buffer_offset = first_bit * XFS_BLF_CHUNK;
+			buffer_offset = offset + first_bit * XFS_BLF_CHUNK;
 			vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
 			vecp->i_len = nbits * XFS_BLF_CHUNK;
 			vecp->i_type = XLOG_REG_TYPE_BCHUNK;
 			nvecs++;
 			break;
 		} else if (next_bit != last_bit + 1) {
-			buffer_offset = first_bit * XFS_BLF_CHUNK;
+			buffer_offset = offset + first_bit * XFS_BLF_CHUNK;
 			vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
 			vecp->i_len = nbits * XFS_BLF_CHUNK;
 			vecp->i_type = XLOG_REG_TYPE_BCHUNK;
@@ -325,14 +361,17 @@ xfs_buf_item_format(
 			first_bit = next_bit;
 			last_bit = next_bit;
 			nbits = 1;
-		} else if (xfs_buf_offset(bp, next_bit << XFS_BLF_SHIFT) !=
-			   (xfs_buf_offset(bp, last_bit << XFS_BLF_SHIFT) +
+		} else if (xfs_buf_offset(bp, offset +
+					      (next_bit << XFS_BLF_SHIFT)) !=
+			   (xfs_buf_offset(bp, offset +
+					       (last_bit << XFS_BLF_SHIFT)) +
 			    XFS_BLF_CHUNK)) {
-			buffer_offset = first_bit * XFS_BLF_CHUNK;
+			buffer_offset = offset + first_bit * XFS_BLF_CHUNK;
 			vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
 			vecp->i_len = nbits * XFS_BLF_CHUNK;
 			vecp->i_type = XLOG_REG_TYPE_BCHUNK;
-/* You would think we need to bump the nvecs here too, but we do not
+/*
+ * You would think we need to bump the nvecs here too, but we do not
  * this number is used by recovery, and it gets confused by the boundary
  * split here
  *			nvecs++;
@@ -347,6 +386,37 @@ xfs_buf_item_format(
 		}
 	}
 	bip->bli_format.blf_size = nvecs;
+	return vecp;
+}
+
+/*
+ * This is called to fill in the vector of log iovecs for the
+ * given log buf item.  It fills the first entry with a buf log
+ * format structure, and the rest point to contiguous chunks
+ * within the buffer.
+ */
+STATIC void
+xfs_buf_item_format(
+	struct xfs_log_item	*lip,
+	struct xfs_log_iovec	*vecp)
+{
+	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);
+	struct xfs_buf		*bp = bip->bli_buf;
+	uint			offset = 0;
+	int			i;
+
+	ASSERT(atomic_read(&bip->bli_refcount) > 0);
+	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||
+	       (bip->bli_flags & XFS_BLI_STALE));
+
+	for (i = 0; i < bip->bli_format_count; i++) {
+		vecp = xfs_buf_item_format_segment(bip, vecp, offset,
+						&bip->bli_formats[i]);
+		offset += bp->b_maps[i].bm_len;
+	}
+
+	/* clear the in-memory inode buffer state now formatting is done. */
+	bip->bli_flags &= ~XFS_BLI_INODE_BUF;
 
 	/*
 	 * Check to make sure everything is consistent.
@@ -622,6 +692,35 @@ static const struct xfs_item_ops xfs_buf_item_ops = {
 	.iop_committing = xfs_buf_item_committing
 };
 
+STATIC int
+xfs_buf_item_get_format(
+	struct xfs_buf_log_item	*bip,
+	int			count)
+{
+	ASSERT(bip->bli_formats == NULL);
+	bip->bli_format_count = count;
+
+	if (count == 1) {
+		bip->bli_formats = &bip->bli_format;
+		return 0;
+	}
+
+	bip->bli_formats = kmem_zalloc(count * sizeof(struct xfs_buf_log_format),
+				KM_SLEEP);
+	if (!bip->bli_formats)
+		return ENOMEM;
+	return 0;
+}
+
+STATIC void
+xfs_buf_item_free_format(
+	struct xfs_buf_log_item	*bip)
+{
+	if (bip->bli_formats != &bip->bli_format) {
+		kmem_free(bip->bli_formats);
+		bip->bli_formats = NULL;
+	}
+}
 
 /*
  * Allocate a new buf log item to go with the given buffer.
@@ -639,6 +738,8 @@ xfs_buf_item_init(
 	xfs_buf_log_item_t	*bip;
 	int			chunks;
 	int			map_size;
+	int			error;
+	int			i;
 
 	/*
 	 * Check to see if there is already a buf log item for
@@ -650,25 +751,32 @@ xfs_buf_item_init(
 	if (lip != NULL && lip->li_type == XFS_LI_BUF)
 		return;
 
-	/*
-	 * chunks is the number of XFS_BLF_CHUNK size pieces
-	 * the buffer can be divided into. Make sure not to
-	 * truncate any pieces.  map_size is the size of the
-	 * bitmap needed to describe the chunks of the buffer.
-	 */
-	chunks = (int)((BBTOB(bp->b_length) + (XFS_BLF_CHUNK - 1)) >>
-								XFS_BLF_SHIFT);
-	map_size = (int)((chunks + NBWORD) >> BIT_TO_WORD_SHIFT);
-
-	bip = (xfs_buf_log_item_t*)kmem_zone_zalloc(xfs_buf_item_zone,
-						    KM_SLEEP);
+	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);
 	bip->bli_buf = bp;
 	xfs_buf_hold(bp);
-	bip->bli_format.blf_type = XFS_LI_BUF;
-	bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp);
-	bip->bli_format.blf_len = (ushort)bp->b_length;
-	bip->bli_format.blf_map_size = map_size;
+
+	/*
+	 * chunks is the number of XFS_BLF_CHUNK size pieces the buffer
+	 * can be divided into. Make sure not to truncate any pieces.
+	 * map_size is the size of the bitmap needed to describe the
+	 * chunks of the buffer.
+	 *
+	 * Discontiguous buffer support follows the layout of the underlying
+	 * buffer. This makes the implementation as simple as possible.
+	 */
+	error = xfs_buf_item_get_format(bip, bp->b_map_count);
+	ASSERT(error == 0);
+
+	for (i = 0; i < bip->bli_format_count; i++) {
+		chunks = DIV_ROUND_UP(bp->b_maps[i].bm_len, XFS_BLF_CHUNK);
+		map_size = (chunks + NBWORD) >> BIT_TO_WORD_SHIFT;
+
+		bip->bli_formats[i].blf_type = XFS_LI_BUF;
+		bip->bli_formats[i].blf_blkno = bp->b_maps[i].bm_bn;
+		bip->bli_formats[i].blf_len = bp->b_maps[i].bm_len;
+		bip->bli_formats[i].blf_map_size = map_size;
+	}
 
 #ifdef XFS_TRANS_DEBUG
 	/*
@@ -699,10 +807,11 @@ xfs_buf_item_init(
  * item's bitmap.
  */
 void
-xfs_buf_item_log(
-	xfs_buf_log_item_t	*bip,
+xfs_buf_item_log_segment(
+	struct xfs_buf_log_item	*bip,
 	uint			first,
-	uint			last)
+	uint			last,
+	uint			*map)
 {
 	uint		first_bit;
 	uint		last_bit;
@@ -715,12 +824,6 @@ xfs_buf_item_log(
 	uint		mask;
 
 	/*
-	 * Mark the item as having some dirty data for
-	 * quick reference in xfs_buf_item_dirty.
-	 */
-	bip->bli_flags |= XFS_BLI_DIRTY;
-
-	/*
 	 * Convert byte offsets to bit numbers.
 	 */
 	first_bit = first >> XFS_BLF_SHIFT;
@@ -736,7 +839,7 @@ xfs_buf_item_log(
 	 * to set a bit in.
 	 */
 	word_num = first_bit >> BIT_TO_WORD_SHIFT;
-	wordp = &(bip->bli_format.blf_data_map[word_num]);
+	wordp = &map[word_num];
 
 	/*
 	 * Calculate the starting bit in the first word.
@@ -783,6 +886,55 @@ xfs_buf_item_log(
 	xfs_buf_item_log_debug(bip, first, last);
 }
 
+/*
+ * Mark bytes first through last inclusive as dirty in the buf
+ * item's bitmap.
+ */
+void
+xfs_buf_item_log(
+	xfs_buf_log_item_t	*bip,
+	uint			first,
+	uint			last)
+{
+	int			i;
+	uint			start;
+	uint			end;
+	struct xfs_buf		*bp = bip->bli_buf;
+
+	/*
+	 * Mark the item as having some dirty data for
+	 * quick reference in xfs_buf_item_dirty.
+	 */
+	bip->bli_flags |= XFS_BLI_DIRTY;
+
+	if (bip->bli_format_count == 1) {
+		xfs_buf_item_log_segment(bip, first, last,
+					 &bip->bli_format.blf_data_map[0]);
+		return;
+	}
+
+	/*
+	 * walk each buffer segment and mark them dirty appropriately.
+	 */
+	start = 0;
+	for (i = 0; i < bip->bli_format_count; i++) {
+		if (start > last)
+			break;
+		end = start + bp->b_maps[i].bm_len;
+		if (first > end) {
+			start += bp->b_maps[i].bm_len;
+			continue;
+		}
+		if (end > last)
+			end = last;
+
+		xfs_buf_item_log_segment(bip, start, end,
+					 &bip->bli_formats[i].blf_data_map[0]);
+
+		start += bp->b_maps[i].bm_len;
+	}
+}
+
 
 /*
  * Return 1 if the buffer has some data that has been logged (at any
@@ -804,6 +956,7 @@ xfs_buf_item_free(
 	kmem_free(bip->bli_logged);
 #endif /* XFS_TRANS_DEBUG */
 
+	xfs_buf_item_free_format(bip);
 	kmem_zone_free(xfs_buf_item_zone, bip);
 }
 
diff --git a/fs/xfs/xfs_buf_item.h b/fs/xfs/xfs_buf_item.h
index ff26867..6850f49 100644
--- a/fs/xfs/xfs_buf_item.h
+++ b/fs/xfs/xfs_buf_item.h
@@ -102,6 +102,8 @@ typedef struct xfs_buf_log_item {
 	char			*bli_orig;	/* original buffer copy */
 	char			*bli_logged;	/* bytes logged (bitmap) */
 #endif
+	int			bli_format_count;	/* count of headers */
+	struct xfs_buf_log_format *bli_formats;	/* array of in-log header ptrs */
 	struct xfs_buf_log_format bli_format;	/* embedded in-log header */
 } xfs_buf_log_item_t;
 
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 07/10] xfs: support discontiguous buffers in the xfs_buf_log_item

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
>> From the perspective of the log, we need to keep each segment of a
> discontigous buffer in separate buffer format structures. This means log
> recovery will recover all the changes on a per segment basis without
> requiring any knowledge of the fact that it was logged from a
> compound buffer.
>
> To do this, we need to be able to determine what buffer segment any
> given offset into the compound buffer sits over. This enables us to
> translate the dirty bitmap in the number of separate buffer format
> structures required.
>
> We also need to be able to determine the number of bitmap elements
> that a given buffer segment has, as this determines the size of the
> buffer format structure. Hence we need to be able to determine the
> both the start offset into the buffer and the length of a given
> segment to be able to calculate this.
>
> With this information, we can preallocate, build and format the
> correct log vector array for each segment in a compound buffer to
> appear exactly the same as individually logged buffers in the log.
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>


Looks good.

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 08/10] xfs: use multiple irec xfs buf support in dabuf

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_da_btree.c |  538 ++++++++++++++++++++++---------------------------
 fs/xfs/xfs_da_btree.h |    6 +-
 2 files changed, 239 insertions(+), 305 deletions(-)

diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 015b946..76e5dba 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -85,7 +85,7 @@ STATIC void xfs_da_node_unbalance(xfs_da_state_t *state,
  */
 STATIC uint	xfs_da_node_lasthash(xfs_dabuf_t *bp, int *count);
 STATIC int	xfs_da_node_order(xfs_dabuf_t *node1_bp, xfs_dabuf_t *node2_bp);
-STATIC xfs_dabuf_t *xfs_da_buf_make(int nbuf, xfs_buf_t **bps);
+STATIC xfs_dabuf_t *xfs_da_buf_make(xfs_buf_t *bp);
 STATIC int	xfs_da_blk_unlink(xfs_da_state_t *state,
 				  xfs_da_state_blk_t *drop_blk,
 				  xfs_da_state_blk_t *save_blk);
@@ -1967,35 +1967,75 @@ xfs_da_map_covers_blocks(
 }
 
 /*
- * Make a dabuf.
- * Used for get_buf, read_buf, read_bufr, and reada_buf.
+ * Convert a struct xfs_bmbt_irec to a struct xfs_buf_map.
+ *
+ * For the single map case, it is assumed that the caller has provided a pointer
+ * to a valid xfs_buf_map.  For the multiple map case, this function will
+ * allocate the xfs_buf_map to hold all the maps and replace the caller's single
+ * map pointer with the allocated map.
  */
-STATIC int
-xfs_da_do_buf(
-	xfs_trans_t	*trans,
-	xfs_inode_t	*dp,
-	xfs_dablk_t	bno,
-	xfs_daddr_t	*mappedbnop,
-	xfs_dabuf_t	**bpp,
-	int		whichfork,
-	int		caller)
+static int
+xfs_buf_map_from_irec(
+	struct xfs_mount	*mp,
+	struct xfs_buf_map	**mapp,
+	unsigned int		*nmaps,
+	struct xfs_bmbt_irec	*irecs,
+	unsigned int		nirecs)
 {
-	xfs_buf_t	*bp = NULL;
-	xfs_buf_t	**bplist;
-	int		error=0;
-	int		i;
-	xfs_bmbt_irec_t	map;
-	xfs_bmbt_irec_t	*mapp;
-	xfs_daddr_t	mappedbno;
-	xfs_mount_t	*mp;
-	int		nbplist=0;
-	int		nfsb;
-	int		nmap;
-	xfs_dabuf_t	*rbp;
+	struct xfs_buf_map	*map;
+	int			i;
+
+	ASSERT(*nmaps == 1);
+	ASSERT(nirecs >= 1);
+
+	if (nirecs > 1) {
+		map = kmem_zalloc(nirecs * sizeof(struct xfs_buf_map), KM_SLEEP);
+		if (!map)
+			return ENOMEM;
+		*mapp = map;
+	}
+
+	*nmaps = nirecs;
+	map = *mapp;
+	for (i = 0; i < *nmaps; i++) {
+		ASSERT(irecs[i].br_startblock != DELAYSTARTBLOCK &&
+		       irecs[i].br_startblock != HOLESTARTBLOCK);
+		map[i].bm_bn = XFS_FSB_TO_DADDR(mp, irecs[i].br_startblock);
+		map[i].bm_len = XFS_FSB_TO_BB(mp, irecs[i].br_blockcount);
+	}
+	return 0;
+}
+
+/*
+ * Map the block we are given ready for reading. There are three possible return
+ * values:
+ *	-1 - will be returned if we land in a hole and mappedbno == -2 so the
+ *	     caller knows not to execute a subsequent read.
+ *	 0 - if we mapped the block successfully
+ *	>0 - positive error number if there was an error.
+ */
+static int
+xfs_dabuf_map(
+	struct xfs_trans	*trans,
+	struct xfs_inode	*dp,
+	xfs_dablk_t		bno,
+	xfs_daddr_t		mappedbno,
+	int			whichfork,
+	struct xfs_buf_map	**map,
+	int			*nmaps)
+{
+	struct xfs_mount	*mp = dp->i_mount;
+	int			nfsb;
+	int			error = 0;
+	struct xfs_bmbt_irec	irec;
+	struct xfs_bmbt_irec	*irecs = &irec;
+	int			nirecs;
+
+	ASSERT(map && *map);
+	ASSERT(*nmaps == 1);
 
-	mp = dp->i_mount;
 	nfsb = (whichfork == XFS_DATA_FORK) ? mp->m_dirblkfsbs : 1;
-	mappedbno = *mappedbnop;
+
 	/*
 	 * Caller doesn't have a mapping.  -2 means don't complain
 	 * if we land in a hole.
@@ -2004,112 +2044,152 @@ xfs_da_do_buf(
 		/*
 		 * Optimize the one-block case.
 		 */
-		if (nfsb == 1)
-			mapp = &map;
-		else
-			mapp = kmem_alloc(sizeof(*mapp) * nfsb, KM_SLEEP);
+		if (nfsb != 1)
+			irecs = kmem_zalloc(sizeof(irec) * nfsb, KM_SLEEP);
 
-		nmap = nfsb;
-		error = xfs_bmapi_read(dp, (xfs_fileoff_t)bno, nfsb, mapp,
-				       &nmap, xfs_bmapi_aflag(whichfork));
+		nirecs = nfsb;
+		error = xfs_bmapi_read(dp, (xfs_fileoff_t)bno, nfsb, irecs,
+				       &nirecs, xfs_bmapi_aflag(whichfork));
 		if (error)
-			goto exit0;
+			goto out;
 	} else {
-		map.br_startblock = XFS_DADDR_TO_FSB(mp, mappedbno);
-		map.br_startoff = (xfs_fileoff_t)bno;
-		map.br_blockcount = nfsb;
-		mapp = &map;
-		nmap = 1;
+		irecs->br_startblock = XFS_DADDR_TO_FSB(mp, mappedbno);
+		irecs->br_startoff = (xfs_fileoff_t)bno;
+		irecs->br_blockcount = nfsb;
+		irecs->br_state = 0;
+		nirecs = 1;
 	}
-	if (!xfs_da_map_covers_blocks(nmap, mapp, bno, nfsb)) {
-		error = mappedbno == -2 ? 0 : XFS_ERROR(EFSCORRUPTED);
+
+	if (!xfs_da_map_covers_blocks(nirecs, irecs, bno, nfsb)) {
+		error = mappedbno == -2 ? -1 : XFS_ERROR(EFSCORRUPTED);
 		if (unlikely(error == EFSCORRUPTED)) {
 			if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
+				int i;
 				xfs_alert(mp, "%s: bno %lld dir: inode %lld",
 					__func__, (long long)bno,
 					(long long)dp->i_ino);
-				for (i = 0; i < nmap; i++) {
+				for (i = 0; i < *nmaps; i++) {
 					xfs_alert(mp,
 "[%02d] br_startoff %lld br_startblock %lld br_blockcount %lld br_state %d",
 						i,
-						(long long)mapp[i].br_startoff,
-						(long long)mapp[i].br_startblock,
-						(long long)mapp[i].br_blockcount,
-						mapp[i].br_state);
+						(long long)irecs[i].br_startoff,
+						(long long)irecs[i].br_startblock,
+						(long long)irecs[i].br_blockcount,
+						irecs[i].br_state);
 				}
 			}
 			XFS_ERROR_REPORT("xfs_da_do_buf(1)",
 					 XFS_ERRLEVEL_LOW, mp);
 		}
-		goto exit0;
+		goto out;
 	}
-	if (caller != 3 && nmap > 1) {
-		bplist = kmem_alloc(sizeof(*bplist) * nmap, KM_SLEEP);
-		nbplist = 0;
-	} else
-		bplist = NULL;
-	/*
-	 * Turn the mapping(s) into buffer(s).
-	 */
-	for (i = 0; i < nmap; i++) {
-		int	nmapped;
-
-		mappedbno = XFS_FSB_TO_DADDR(mp, mapp[i].br_startblock);
-		if (i == 0)
-			*mappedbnop = mappedbno;
-		nmapped = (int)XFS_FSB_TO_BB(mp, mapp[i].br_blockcount);
-		switch (caller) {
-		case 0:
-			bp = xfs_trans_get_buf(trans, mp->m_ddev_targp,
-				mappedbno, nmapped, 0);
-			error = bp ? bp->b_error : XFS_ERROR(EIO);
-			break;
-		case 1:
-		case 2:
-			bp = NULL;
-			error = xfs_trans_read_buf(mp, trans, mp->m_ddev_targp,
-				mappedbno, nmapped, 0, &bp);
-			break;
-		case 3:
-			xfs_buf_readahead(mp->m_ddev_targp, mappedbno, nmapped);
+	error = xfs_buf_map_from_irec(mp, map, nmaps, irecs, nirecs);
+out:
+	if (irecs != &irec)
+		kmem_free(irecs);
+	return error;
+}
+
+/*
+ * Get a buffer for the dir/attr block.
+ */
+int
+xfs_da_get_buf(
+	struct xfs_trans	*trans,
+	struct xfs_inode	*dp,
+	xfs_dablk_t		bno,
+	xfs_daddr_t		mappedbno,
+	xfs_dabuf_t		**bpp,
+	int			whichfork)
+{
+	struct xfs_buf		*bp;
+	struct xfs_buf_map	map;
+	struct xfs_buf_map	*mapp;
+	int			nmap;
+	int			error;
+
+	*bpp = NULL;
+	mapp = &map;
+	nmap = 1;
+	error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
+				&mapp, &nmap);
+	if (error) {
+		/* mapping a hole is not an error, but we don't continue */
+		if (error == -1)
 			error = 0;
-			bp = NULL;
-			break;
-		}
-		if (error) {
-			if (bp)
-				xfs_trans_brelse(trans, bp);
-			goto exit1;
-		}
-		if (!bp)
-			continue;
-		if (caller == 1) {
-			if (whichfork == XFS_ATTR_FORK)
-				xfs_buf_set_ref(bp, XFS_ATTR_BTREE_REF);
-			else
-				xfs_buf_set_ref(bp, XFS_DIR_BTREE_REF);
-		}
-		if (bplist) {
-			bplist[nbplist++] = bp;
-		}
+		goto out_free;
 	}
-	/*
-	 * Build a dabuf structure.
-	 */
-	if (bplist) {
-		rbp = xfs_da_buf_make(nbplist, bplist);
-	} else if (bp)
-		rbp = xfs_da_buf_make(1, &bp);
+
+	bp = xfs_trans_get_buf_map(trans, dp->i_mount->m_ddev_targp,
+				    mapp, nmap, 0);
+	error = bp ? bp->b_error : XFS_ERROR(EIO);
+	if (error) {
+		xfs_trans_brelse(trans, bp);
+		goto out_free;
+	}
+
+	*bpp = xfs_da_buf_make(bp);
+
+out_free:
+	if (mapp != &map)
+		kmem_free(mapp);
+
+	return error;
+}
+
+/*
+ * Get a buffer for the dir/attr block, fill in the contents.
+ */
+int
+xfs_da_read_buf(
+	struct xfs_trans	*trans,
+	struct xfs_inode	*dp,
+	xfs_dablk_t		bno,
+	xfs_daddr_t		mappedbno,
+	xfs_dabuf_t		**bpp,
+	int			whichfork)
+{
+	struct xfs_buf		*bp;
+	struct xfs_buf_map	map;
+	struct xfs_buf_map	*mapp;
+	int			nmap;
+	int			error;
+
+	*bpp = NULL;
+	mapp = &map;
+	nmap = 1;
+	error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
+				&mapp, &nmap);
+	if (error) {
+		/* mapping a hole is not an error, but we don't continue */
+		if (error == -1)
+			error = 0;
+		goto out_free;
+	}
+
+	error = xfs_trans_read_buf_map(dp->i_mount, trans,
+					dp->i_mount->m_ddev_targp,
+					mapp, nmap, 0, &bp);
+	if (error)
+		goto out_free;
+
+	if (whichfork == XFS_ATTR_FORK)
+		xfs_buf_set_ref(bp, XFS_ATTR_BTREE_REF);
 	else
-		rbp = NULL;
+		xfs_buf_set_ref(bp, XFS_DIR_BTREE_REF);
+
+	*bpp = xfs_da_buf_make(bp);
+
 	/*
-	 * For read_buf, check the magic number.
+	 * This verification code will be moved to a CRC verification callback
+	 * function so just leave it here unchanged until then.
 	 */
-	if (caller == 1) {
-		xfs_dir2_data_hdr_t	*hdr = rbp->data;
-		xfs_dir2_free_t		*free = rbp->data;
-		xfs_da_blkinfo_t	*info = rbp->data;
+	{
+		xfs_dir2_data_hdr_t	*hdr = (*bpp)->data;
+		xfs_dir2_free_t		*free = (*bpp)->data;
+		xfs_da_blkinfo_t	*info = (*bpp)->data;
 		uint			magic, magic1;
+		struct xfs_mount	*mp = dp->i_mount;
 
 		magic = be16_to_cpu(info->magic);
 		magic1 = be32_to_cpu(hdr->magic);
@@ -2123,66 +2203,20 @@ xfs_da_do_buf(
 				   (free->hdr.magic != cpu_to_be32(XFS_DIR2_FREE_MAGIC)),
 				mp, XFS_ERRTAG_DA_READ_BUF,
 				XFS_RANDOM_DA_READ_BUF))) {
-			trace_xfs_da_btree_corrupt(rbp->bps[0], _RET_IP_);
+			trace_xfs_da_btree_corrupt(bp, _RET_IP_);
 			XFS_CORRUPTION_ERROR("xfs_da_do_buf(2)",
 					     XFS_ERRLEVEL_LOW, mp, info);
 			error = XFS_ERROR(EFSCORRUPTED);
-			xfs_da_brelse(trans, rbp);
-			nbplist = 0;
-			goto exit1;
+			xfs_da_brelse(trans, *bpp);
+			goto out_free;
 		}
 	}
-	if (bplist) {
-		kmem_free(bplist);
-	}
-	if (mapp != &map) {
-		kmem_free(mapp);
-	}
-	if (bpp)
-		*bpp = rbp;
-	return 0;
-exit1:
-	if (bplist) {
-		for (i = 0; i < nbplist; i++)
-			xfs_trans_brelse(trans, bplist[i]);
-		kmem_free(bplist);
-	}
-exit0:
+
+out_free:
 	if (mapp != &map)
 		kmem_free(mapp);
-	if (bpp)
-		*bpp = NULL;
-	return error;
-}
-
-/*
- * Get a buffer for the dir/attr block.
- */
-int
-xfs_da_get_buf(
-	xfs_trans_t	*trans,
-	xfs_inode_t	*dp,
-	xfs_dablk_t	bno,
-	xfs_daddr_t		mappedbno,
-	xfs_dabuf_t	**bpp,
-	int		whichfork)
-{
-	return xfs_da_do_buf(trans, dp, bno, &mappedbno, bpp, whichfork, 0);
-}
 
-/*
- * Get a buffer for the dir/attr block, fill in the contents.
- */
-int
-xfs_da_read_buf(
-	xfs_trans_t	*trans,
-	xfs_inode_t	*dp,
-	xfs_dablk_t	bno,
-	xfs_daddr_t		mappedbno,
-	xfs_dabuf_t	**bpp,
-	int		whichfork)
-{
-	return xfs_da_do_buf(trans, dp, bno, &mappedbno, bpp, whichfork, 1);
+	return error;
 }
 
 /*
@@ -2190,18 +2224,38 @@ xfs_da_read_buf(
  */
 xfs_daddr_t
 xfs_da_reada_buf(
-	xfs_trans_t	*trans,
-	xfs_inode_t	*dp,
-	xfs_dablk_t	bno,
-	int		whichfork)
+	struct xfs_trans	*trans,
+	struct xfs_inode	*dp,
+	xfs_dablk_t		bno,
+	int			whichfork)
 {
-	xfs_daddr_t		rval;
+	xfs_daddr_t		mappedbno = -1;
+	struct xfs_buf_map	map;
+	struct xfs_buf_map	*mapp;
+	int			nmap;
+	int			error;
+
+	mapp = &map;
+	nmap = 1;
+	error = xfs_dabuf_map(trans, dp, bno, -1, whichfork,
+				&mapp, &nmap);
+	if (error) {
+		/* mapping a hole is not an error, but we don't continue */
+		if (error == -1)
+			error = 0;
+		goto out_free;
+	}
 
-	rval = -1;
-	if (xfs_da_do_buf(trans, dp, bno, &rval, NULL, whichfork, 3))
+	mappedbno = mapp[0].bm_bn;
+	xfs_buf_readahead_map(dp->i_mount->m_ddev_targp, mapp, nmap);
+
+out_free:
+	if (mapp != &map)
+		kmem_free(mapp);
+
+	if (error)
 		return -1;
-	else
-		return rval;
+	return mappedbno;
 }
 
 kmem_zone_t *xfs_da_state_zone;	/* anchor for state struct zone */
@@ -2261,78 +2315,25 @@ xfs_da_state_free(xfs_da_state_t *state)
  */
 /* ARGSUSED */
 STATIC xfs_dabuf_t *
-xfs_da_buf_make(int nbuf, xfs_buf_t **bps)
+xfs_da_buf_make(xfs_buf_t *bp)
 {
-	xfs_buf_t	*bp;
 	xfs_dabuf_t	*dabuf;
-	int		i;
-	int		off;
 
-	if (nbuf == 1)
-		dabuf = kmem_zone_alloc(xfs_dabuf_zone, KM_NOFS);
-	else
-		dabuf = kmem_alloc(XFS_DA_BUF_SIZE(nbuf), KM_NOFS);
-	dabuf->dirty = 0;
-	if (nbuf == 1) {
-		dabuf->nbuf = 1;
-		bp = bps[0];
-		dabuf->bbcount = bp->b_length;
-		dabuf->data = bp->b_addr;
-		dabuf->bps[0] = bp;
-	} else {
-		dabuf->nbuf = nbuf;
-		for (i = 0, dabuf->bbcount = 0; i < nbuf; i++) {
-			dabuf->bps[i] = bp = bps[i];
-			dabuf->bbcount += bp->b_length;
-		}
-		dabuf->data = kmem_alloc(BBTOB(dabuf->bbcount), KM_SLEEP);
-		for (i = off = 0; i < nbuf; i++, off += BBTOB(bp->b_length)) {
-			bp = bps[i];
-			memcpy((char *)dabuf->data + off, bp->b_addr,
-				BBTOB(bp->b_length));
-		}
-	}
+	dabuf = kmem_zone_alloc(xfs_dabuf_zone, KM_NOFS);
+	dabuf->bbcount = bp->b_length;
+	dabuf->data = bp->b_addr;
+	dabuf->bp = bp;
 	return dabuf;
 }
 
 /*
- * Un-dirty a dabuf.
- */
-STATIC void
-xfs_da_buf_clean(xfs_dabuf_t *dabuf)
-{
-	xfs_buf_t	*bp;
-	int		i;
-	int		off;
-
-	if (dabuf->dirty) {
-		ASSERT(dabuf->nbuf > 1);
-		dabuf->dirty = 0;
-		for (i = off = 0; i < dabuf->nbuf;
-				i++, off += BBTOB(bp->b_length)) {
-			bp = dabuf->bps[i];
-			memcpy(bp->b_addr, dabuf->data + off,
-						BBTOB(bp->b_length));
-		}
-	}
-}
-
-/*
  * Release a dabuf.
  */
 void
 xfs_da_buf_done(xfs_dabuf_t *dabuf)
 {
-	ASSERT(dabuf);
-	ASSERT(dabuf->nbuf && dabuf->data && dabuf->bbcount && dabuf->bps[0]);
-	if (dabuf->dirty)
-		xfs_da_buf_clean(dabuf);
-	if (dabuf->nbuf > 1) {
-		kmem_free(dabuf->data);
-		kmem_free(dabuf);
-	} else {
-		kmem_zone_free(xfs_dabuf_zone, dabuf);
-	}
+	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
+	kmem_zone_free(xfs_dabuf_zone, dabuf);
 }
 
 /*
@@ -2341,41 +2342,9 @@ xfs_da_buf_done(xfs_dabuf_t *dabuf)
 void
 xfs_da_log_buf(xfs_trans_t *tp, xfs_dabuf_t *dabuf, uint first, uint last)
 {
-	xfs_buf_t	*bp;
-	uint		f;
-	int		i;
-	uint		l;
-	int		off;
-
-	ASSERT(dabuf->nbuf && dabuf->data && dabuf->bbcount && dabuf->bps[0]);
-	if (dabuf->nbuf == 1) {
-		ASSERT(dabuf->data == dabuf->bps[0]->b_addr);
-		xfs_trans_log_buf(tp, dabuf->bps[0], first, last);
-		return;
-	}
-	dabuf->dirty = 1;
-	ASSERT(first <= last);
-	for (i = off = 0; i < dabuf->nbuf; i++, off += BBTOB(bp->b_length)) {
-		bp = dabuf->bps[i];
-		f = off;
-		l = f + BBTOB(bp->b_length) - 1;
-		if (f < first)
-			f = first;
-		if (l > last)
-			l = last;
-		if (f <= l)
-			xfs_trans_log_buf(tp, bp, f - off, l - off);
-		/*
-		 * B_DONE is set by xfs_trans_log buf.
-		 * If we don't set it on a new buffer (get not read)
-		 * then if we don't put anything in the buffer it won't
-		 * be set, and at commit it it released into the cache,
-		 * and then a read will fail.
-		 */
-		else if (!(XFS_BUF_ISDONE(bp)))
-		  XFS_BUF_DONE(bp);
-	}
-	ASSERT(last < off);
+	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
+	ASSERT(dabuf->data == dabuf->bp->b_addr);
+	xfs_trans_log_buf(tp, dabuf->bp, first, last);
 }
 
 /*
@@ -2386,24 +2355,9 @@ xfs_da_log_buf(xfs_trans_t *tp, xfs_dabuf_t *dabuf, uint first, uint last)
 void
 xfs_da_brelse(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
 {
-	xfs_buf_t	*bp;
-	xfs_buf_t	**bplist;
-	int		i;
-	int		nbuf;
-
-	ASSERT(dabuf->nbuf && dabuf->data && dabuf->bbcount && dabuf->bps[0]);
-	if ((nbuf = dabuf->nbuf) == 1) {
-		bplist = &bp;
-		bp = dabuf->bps[0];
-	} else {
-		bplist = kmem_alloc(nbuf * sizeof(*bplist), KM_SLEEP);
-		memcpy(bplist, dabuf->bps, nbuf * sizeof(*bplist));
-	}
+	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
+	xfs_trans_brelse(tp, dabuf->bp);
 	xfs_da_buf_done(dabuf);
-	for (i = 0; i < nbuf; i++)
-		xfs_trans_brelse(tp, bplist[i]);
-	if (bplist != &bp)
-		kmem_free(bplist);
 }
 
 /*
@@ -2412,24 +2366,9 @@ xfs_da_brelse(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
 void
 xfs_da_binval(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
 {
-	xfs_buf_t	*bp;
-	xfs_buf_t	**bplist;
-	int		i;
-	int		nbuf;
-
-	ASSERT(dabuf->nbuf && dabuf->data && dabuf->bbcount && dabuf->bps[0]);
-	if ((nbuf = dabuf->nbuf) == 1) {
-		bplist = &bp;
-		bp = dabuf->bps[0];
-	} else {
-		bplist = kmem_alloc(nbuf * sizeof(*bplist), KM_SLEEP);
-		memcpy(bplist, dabuf->bps, nbuf * sizeof(*bplist));
-	}
+	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
 	xfs_da_buf_done(dabuf);
-	for (i = 0; i < nbuf; i++)
-		xfs_trans_binval(tp, bplist[i]);
-	if (bplist != &bp)
-		kmem_free(bplist);
+	xfs_trans_binval(tp, dabuf->bp);
 }
 
 /*
@@ -2438,7 +2377,6 @@ xfs_da_binval(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
 xfs_daddr_t
 xfs_da_blkno(xfs_dabuf_t *dabuf)
 {
-	ASSERT(dabuf->nbuf);
 	ASSERT(dabuf->data);
-	return XFS_BUF_ADDR(dabuf->bps[0]);
+	return XFS_BUF_ADDR(dabuf->bp);
 }
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h
index dbf7c07..0b64c4a 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/xfs_da_btree.h
@@ -141,14 +141,10 @@ typedef struct xfs_da_args {
  * same place as the b_addr field for the buffer, else to kmem_alloced memory.
  */
 typedef struct xfs_dabuf {
-	int		nbuf;		/* number of buffer pointers present */
-	short		dirty;		/* data needs to be copied back */
 	short		bbcount;	/* how large is data in bbs */
 	void		*data;		/* pointer for buffers' data */
-	struct xfs_buf	*bps[1];	/* actually nbuf of these */
+	struct xfs_buf	*bp;		/* actually nbuf of these */
 } xfs_dabuf_t;
-#define	XFS_DA_BUF_SIZE(n)	\
-	(sizeof(xfs_dabuf_t) + sizeof(struct xfs_buf *) * ((n) - 1))
 
 /*
  * Storage for holding state during Btree searches and split/join ops.
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 08/10] xfs: use multiple irec xfs buf support in dabuf

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>
> ---

Nice feature.

Looks good.

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 09/10] xfs: remove struct xfs_dabuf and infrastructure

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

The struct xfs_dabuf now only tracks a single xfs_buf and all the
information it holds can be gained directly from the xfs_buf. Hence
we can remove the struct dabuf and pass the xfs_buf around
everywhere.

Kill the struct dabuf and the associated infrastructure.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_attr.c       |   78 +++++------
 fs/xfs/xfs_attr_leaf.c  |  255 +++++++++++++++++++----------------
 fs/xfs/xfs_attr_leaf.h  |   21 ++-
 fs/xfs/xfs_da_btree.c   |  337 +++++++++++++++++------------------------------
 fs/xfs/xfs_da_btree.h   |   32 +----
 fs/xfs/xfs_dir2.c       |    4 +-
 fs/xfs/xfs_dir2_block.c |  118 +++++++----------
 fs/xfs/xfs_dir2_data.c  |   50 +++----
 fs/xfs/xfs_dir2_leaf.c  |  191 +++++++++++++--------------
 fs/xfs/xfs_dir2_node.c  |  236 ++++++++++++++-------------------
 fs/xfs/xfs_dir2_priv.h  |   46 +++----
 fs/xfs/xfs_dir2_sf.c    |    4 +-
 fs/xfs/xfs_super.c      |    9 +-
 13 files changed, 602 insertions(+), 779 deletions(-)

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index a17ff01..0ca1f0b 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -893,7 +893,7 @@ STATIC int
 xfs_attr_leaf_addname(xfs_da_args_t *args)
 {
 	xfs_inode_t *dp;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int retval, error, committed, forkoff;
 
 	trace_xfs_attr_leaf_addname(args);
@@ -915,11 +915,11 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
 	 */
 	retval = xfs_attr_leaf_lookup_int(bp, args);
 	if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
-		xfs_da_brelse(args->trans, bp);
+		xfs_trans_brelse(args->trans, bp);
 		return(retval);
 	} else if (retval == EEXIST) {
 		if (args->flags & ATTR_CREATE) {	/* pure create op */
-			xfs_da_brelse(args->trans, bp);
+			xfs_trans_brelse(args->trans, bp);
 			return(retval);
 		}
 
@@ -937,7 +937,6 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
 	 * if required.
 	 */
 	retval = xfs_attr_leaf_add(bp, args);
-	xfs_da_buf_done(bp);
 	if (retval == ENOSPC) {
 		/*
 		 * Promote the attribute list to the Btree format, then
@@ -1065,8 +1064,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
 			 */
 			if (committed)
 				xfs_trans_ijoin(args->trans, dp, 0);
-		} else
-			xfs_da_buf_done(bp);
+		}
 
 		/*
 		 * Commit the remove and start the next trans in series.
@@ -1092,7 +1090,7 @@ STATIC int
 xfs_attr_leaf_removename(xfs_da_args_t *args)
 {
 	xfs_inode_t *dp;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error, committed, forkoff;
 
 	trace_xfs_attr_leaf_removename(args);
@@ -1111,7 +1109,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
 	ASSERT(bp != NULL);
 	error = xfs_attr_leaf_lookup_int(bp, args);
 	if (error == ENOATTR) {
-		xfs_da_brelse(args->trans, bp);
+		xfs_trans_brelse(args->trans, bp);
 		return(error);
 	}
 
@@ -1141,8 +1139,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
 		 */
 		if (committed)
 			xfs_trans_ijoin(args->trans, dp, 0);
-	} else
-		xfs_da_buf_done(bp);
+	}
 	return(0);
 }
 
@@ -1155,7 +1152,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
 STATIC int
 xfs_attr_leaf_get(xfs_da_args_t *args)
 {
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 
 	args->blkno = 0;
@@ -1167,11 +1164,11 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
 
 	error = xfs_attr_leaf_lookup_int(bp, args);
 	if (error != EEXIST)  {
-		xfs_da_brelse(args->trans, bp);
+		xfs_trans_brelse(args->trans, bp);
 		return(error);
 	}
 	error = xfs_attr_leaf_getvalue(bp, args);
-	xfs_da_brelse(args->trans, bp);
+	xfs_trans_brelse(args->trans, bp);
 	if (!error && (args->rmtblkno > 0) && !(args->flags & ATTR_KERNOVAL)) {
 		error = xfs_attr_rmtval_get(args);
 	}
@@ -1186,23 +1183,23 @@ xfs_attr_leaf_list(xfs_attr_list_context_t *context)
 {
 	xfs_attr_leafblock_t *leaf;
 	int error;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 
 	context->cursor->blkno = 0;
 	error = xfs_da_read_buf(NULL, context->dp, 0, -1, &bp, XFS_ATTR_FORK);
 	if (error)
 		return XFS_ERROR(error);
 	ASSERT(bp != NULL);
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	if (unlikely(leaf->hdr.info.magic != cpu_to_be16(XFS_ATTR_LEAF_MAGIC))) {
 		XFS_CORRUPTION_ERROR("xfs_attr_leaf_list", XFS_ERRLEVEL_LOW,
 				     context->dp->i_mount, leaf);
-		xfs_da_brelse(NULL, bp);
+		xfs_trans_brelse(NULL, bp);
 		return XFS_ERROR(EFSCORRUPTED);
 	}
 
 	error = xfs_attr_leaf_list_int(bp, context);
-	xfs_da_brelse(NULL, bp);
+	xfs_trans_brelse(NULL, bp);
 	return XFS_ERROR(error);
 }
 
@@ -1489,7 +1486,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
 	xfs_da_state_t *state;
 	xfs_da_state_blk_t *blk;
 	xfs_inode_t *dp;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int retval, error, committed, forkoff;
 
 	trace_xfs_attr_node_removename(args);
@@ -1601,14 +1598,13 @@ xfs_attr_node_removename(xfs_da_args_t *args)
 		 */
 		ASSERT(state->path.active == 1);
 		ASSERT(state->path.blk[0].bp);
-		xfs_da_buf_done(state->path.blk[0].bp);
 		state->path.blk[0].bp = NULL;
 
 		error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp,
 						     XFS_ATTR_FORK);
 		if (error)
 			goto out;
-		ASSERT((((xfs_attr_leafblock_t *)bp->data)->hdr.info.magic) ==
+		ASSERT((((xfs_attr_leafblock_t *)bp->b_addr)->hdr.info.magic) ==
 		       cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 
 		if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
@@ -1635,7 +1631,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
 			if (committed)
 				xfs_trans_ijoin(args->trans, dp, 0);
 		} else
-			xfs_da_brelse(args->trans, bp);
+			xfs_trans_brelse(args->trans, bp);
 	}
 	error = 0;
 
@@ -1665,8 +1661,7 @@ xfs_attr_fillstate(xfs_da_state_t *state)
 	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
 	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
 		if (blk->bp) {
-			blk->disk_blkno = xfs_da_blkno(blk->bp);
-			xfs_da_buf_done(blk->bp);
+			blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
 			blk->bp = NULL;
 		} else {
 			blk->disk_blkno = 0;
@@ -1681,8 +1676,7 @@ xfs_attr_fillstate(xfs_da_state_t *state)
 	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
 	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
 		if (blk->bp) {
-			blk->disk_blkno = xfs_da_blkno(blk->bp);
-			xfs_da_buf_done(blk->bp);
+			blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
 			blk->bp = NULL;
 		} else {
 			blk->disk_blkno = 0;
@@ -1792,7 +1786,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
 	 * If not in a transaction, we have to release all the buffers.
 	 */
 	for (i = 0; i < state->path.active; i++) {
-		xfs_da_brelse(args->trans, state->path.blk[i].bp);
+		xfs_trans_brelse(args->trans, state->path.blk[i].bp);
 		state->path.blk[i].bp = NULL;
 	}
 
@@ -1808,7 +1802,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
 	xfs_da_intnode_t *node;
 	xfs_da_node_entry_t *btree;
 	int error, i;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 
 	cursor = context->cursor;
 	cursor->initted = 1;
@@ -1825,30 +1819,30 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
 		if ((error != 0) && (error != EFSCORRUPTED))
 			return(error);
 		if (bp) {
-			node = bp->data;
+			node = bp->b_addr;
 			switch (be16_to_cpu(node->hdr.info.magic)) {
 			case XFS_DA_NODE_MAGIC:
 				trace_xfs_attr_list_wrong_blk(context);
-				xfs_da_brelse(NULL, bp);
+				xfs_trans_brelse(NULL, bp);
 				bp = NULL;
 				break;
 			case XFS_ATTR_LEAF_MAGIC:
-				leaf = bp->data;
+				leaf = bp->b_addr;
 				if (cursor->hashval > be32_to_cpu(leaf->entries[
 				    be16_to_cpu(leaf->hdr.count)-1].hashval)) {
 					trace_xfs_attr_list_wrong_blk(context);
-					xfs_da_brelse(NULL, bp);
+					xfs_trans_brelse(NULL, bp);
 					bp = NULL;
 				} else if (cursor->hashval <=
 					     be32_to_cpu(leaf->entries[0].hashval)) {
 					trace_xfs_attr_list_wrong_blk(context);
-					xfs_da_brelse(NULL, bp);
+					xfs_trans_brelse(NULL, bp);
 					bp = NULL;
 				}
 				break;
 			default:
 				trace_xfs_attr_list_wrong_blk(context);
-				xfs_da_brelse(NULL, bp);
+				xfs_trans_brelse(NULL, bp);
 				bp = NULL;
 			}
 		}
@@ -1873,7 +1867,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
 						 context->dp->i_mount);
 				return(XFS_ERROR(EFSCORRUPTED));
 			}
-			node = bp->data;
+			node = bp->b_addr;
 			if (node->hdr.info.magic ==
 			    cpu_to_be16(XFS_ATTR_LEAF_MAGIC))
 				break;
@@ -1883,7 +1877,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
 						     XFS_ERRLEVEL_LOW,
 						     context->dp->i_mount,
 						     node);
-				xfs_da_brelse(NULL, bp);
+				xfs_trans_brelse(NULL, bp);
 				return(XFS_ERROR(EFSCORRUPTED));
 			}
 			btree = node->btree;
@@ -1898,10 +1892,10 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
 				}
 			}
 			if (i == be16_to_cpu(node->hdr.count)) {
-				xfs_da_brelse(NULL, bp);
+				xfs_trans_brelse(NULL, bp);
 				return(0);
 			}
-			xfs_da_brelse(NULL, bp);
+			xfs_trans_brelse(NULL, bp);
 		}
 	}
 	ASSERT(bp != NULL);
@@ -1912,24 +1906,24 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
 	 * adding the information.
 	 */
 	for (;;) {
-		leaf = bp->data;
+		leaf = bp->b_addr;
 		if (unlikely(leaf->hdr.info.magic !=
 			     cpu_to_be16(XFS_ATTR_LEAF_MAGIC))) {
 			XFS_CORRUPTION_ERROR("xfs_attr_node_list(4)",
 					     XFS_ERRLEVEL_LOW,
 					     context->dp->i_mount, leaf);
-			xfs_da_brelse(NULL, bp);
+			xfs_trans_brelse(NULL, bp);
 			return(XFS_ERROR(EFSCORRUPTED));
 		}
 		error = xfs_attr_leaf_list_int(bp, context);
 		if (error) {
-			xfs_da_brelse(NULL, bp);
+			xfs_trans_brelse(NULL, bp);
 			return error;
 		}
 		if (context->seen_enough || leaf->hdr.info.forw == 0)
 			break;
 		cursor->blkno = be32_to_cpu(leaf->hdr.info.forw);
-		xfs_da_brelse(NULL, bp);
+		xfs_trans_brelse(NULL, bp);
 		error = xfs_da_read_buf(NULL, context->dp, cursor->blkno, -1,
 					      &bp, XFS_ATTR_FORK);
 		if (error)
@@ -1941,7 +1935,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
 			return(XFS_ERROR(EFSCORRUPTED));
 		}
 	}
-	xfs_da_brelse(NULL, bp);
+	xfs_trans_brelse(NULL, bp);
 	return(0);
 }
 
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 7d89d80..d330111 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -54,10 +54,10 @@
  * Routines used for growing the Btree.
  */
 STATIC int xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t which_block,
-				    xfs_dabuf_t **bpp);
-STATIC int xfs_attr_leaf_add_work(xfs_dabuf_t *leaf_buffer, xfs_da_args_t *args,
-					      int freemap_index);
-STATIC void xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *leaf_buffer);
+				struct xfs_buf **bpp);
+STATIC int xfs_attr_leaf_add_work(struct xfs_buf *leaf_buffer,
+				  xfs_da_args_t *args, int freemap_index);
+STATIC void xfs_attr_leaf_compact(xfs_trans_t *tp, struct xfs_buf *leaf_buffer);
 STATIC void xfs_attr_leaf_rebalance(xfs_da_state_t *state,
 						   xfs_da_state_blk_t *blk1,
 						   xfs_da_state_blk_t *blk2);
@@ -71,9 +71,9 @@ STATIC int xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
  * Routines used for shrinking the Btree.
  */
 STATIC int xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp,
-				  xfs_dabuf_t *bp, int level);
+				  struct xfs_buf *bp, int level);
 STATIC int xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp,
-				  xfs_dabuf_t *bp);
+				  struct xfs_buf *bp);
 STATIC int xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
 				   xfs_dablk_t blkno, int blkcnt);
 
@@ -480,7 +480,7 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
 	char *tmpbuffer;
 	int error, i, size;
 	xfs_dablk_t blkno;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	xfs_ifork_t *ifp;
 
 	trace_xfs_attr_sf_to_leaf(args);
@@ -550,8 +550,6 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
 	error = 0;
 
 out:
-	if(bp)
-		xfs_da_buf_done(bp);
 	kmem_free(tmpbuffer);
 	return(error);
 }
@@ -737,14 +735,16 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
  * a shortform attribute list.
  */
 int
-xfs_attr_shortform_allfit(xfs_dabuf_t *bp, xfs_inode_t *dp)
+xfs_attr_shortform_allfit(
+	struct xfs_buf	*bp,
+	struct xfs_inode *dp)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_entry_t *entry;
 	xfs_attr_leaf_name_local_t *name_loc;
 	int bytes, i;
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 
 	entry = &leaf->entries[0];
@@ -774,7 +774,10 @@ xfs_attr_shortform_allfit(xfs_dabuf_t *bp, xfs_inode_t *dp)
  * Convert a leaf attribute list to shortform attribute list
  */
 int
-xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff)
+xfs_attr_leaf_to_shortform(
+	struct xfs_buf	*bp,
+	xfs_da_args_t	*args,
+	int		forkoff)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_entry_t *entry;
@@ -791,10 +794,10 @@ xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff)
 	ASSERT(tmpbuffer != NULL);
 
 	ASSERT(bp != NULL);
-	memcpy(tmpbuffer, bp->data, XFS_LBSIZE(dp->i_mount));
+	memcpy(tmpbuffer, bp->b_addr, XFS_LBSIZE(dp->i_mount));
 	leaf = (xfs_attr_leafblock_t *)tmpbuffer;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
-	memset(bp->data, 0, XFS_LBSIZE(dp->i_mount));
+	memset(bp->b_addr, 0, XFS_LBSIZE(dp->i_mount));
 
 	/*
 	 * Clean out the prior contents of the attribute list.
@@ -855,7 +858,7 @@ xfs_attr_leaf_to_node(xfs_da_args_t *args)
 	xfs_attr_leafblock_t *leaf;
 	xfs_da_intnode_t *node;
 	xfs_inode_t *dp;
-	xfs_dabuf_t *bp1, *bp2;
+	struct xfs_buf *bp1, *bp2;
 	xfs_dablk_t blkno;
 	int error;
 
@@ -877,10 +880,9 @@ xfs_attr_leaf_to_node(xfs_da_args_t *args)
 	if (error)
 		goto out;
 	ASSERT(bp2 != NULL);
-	memcpy(bp2->data, bp1->data, XFS_LBSIZE(dp->i_mount));
-	xfs_da_buf_done(bp1);
+	memcpy(bp2->b_addr, bp1->b_addr, XFS_LBSIZE(dp->i_mount));
 	bp1 = NULL;
-	xfs_da_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
+	xfs_trans_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
 
 	/*
 	 * Set up the new root node.
@@ -888,21 +890,17 @@ xfs_attr_leaf_to_node(xfs_da_args_t *args)
 	error = xfs_da_node_create(args, 0, 1, &bp1, XFS_ATTR_FORK);
 	if (error)
 		goto out;
-	node = bp1->data;
-	leaf = bp2->data;
+	node = bp1->b_addr;
+	leaf = bp2->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	/* both on-disk, don't endian-flip twice */
 	node->btree[0].hashval =
 		leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval;
 	node->btree[0].before = cpu_to_be32(blkno);
 	node->hdr.count = cpu_to_be16(1);
-	xfs_da_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1);
+	xfs_trans_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1);
 	error = 0;
 out:
-	if (bp1)
-		xfs_da_buf_done(bp1);
-	if (bp2)
-		xfs_da_buf_done(bp2);
 	return(error);
 }
 
@@ -916,12 +914,15 @@ out:
  * or a leaf in a node attribute list.
  */
 STATIC int
-xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t blkno, xfs_dabuf_t **bpp)
+xfs_attr_leaf_create(
+	xfs_da_args_t	*args,
+	xfs_dablk_t	blkno,
+	struct xfs_buf	**bpp)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_hdr_t *hdr;
 	xfs_inode_t *dp;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 
 	trace_xfs_attr_leaf_create(args);
@@ -933,7 +934,7 @@ xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t blkno, xfs_dabuf_t **bpp)
 	if (error)
 		return(error);
 	ASSERT(bp != NULL);
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
 	hdr = &leaf->hdr;
 	hdr->info.magic = cpu_to_be16(XFS_ATTR_LEAF_MAGIC);
@@ -947,7 +948,7 @@ xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t blkno, xfs_dabuf_t **bpp)
 	hdr->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr->firstused) -
 					   sizeof(xfs_attr_leaf_hdr_t));
 
-	xfs_da_log_buf(args->trans, bp, 0, XFS_LBSIZE(dp->i_mount) - 1);
+	xfs_trans_log_buf(args->trans, bp, 0, XFS_LBSIZE(dp->i_mount) - 1);
 
 	*bpp = bp;
 	return(0);
@@ -1014,7 +1015,9 @@ xfs_attr_leaf_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
  * Add a name to the leaf attribute list structure.
  */
 int
-xfs_attr_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args)
+xfs_attr_leaf_add(
+	struct xfs_buf		*bp,
+	struct xfs_da_args	*args)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_hdr_t *hdr;
@@ -1023,7 +1026,7 @@ xfs_attr_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args)
 
 	trace_xfs_attr_leaf_add(args);
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT((args->index >= 0)
 		&& (args->index <= be16_to_cpu(leaf->hdr.count)));
@@ -1085,7 +1088,10 @@ xfs_attr_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args)
  * Add a name to a leaf attribute list structure.
  */
 STATIC int
-xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
+xfs_attr_leaf_add_work(
+	struct xfs_buf	*bp,
+	xfs_da_args_t	*args,
+	int		mapindex)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_hdr_t *hdr;
@@ -1096,7 +1102,7 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
 	xfs_mount_t *mp;
 	int tmp, i;
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	hdr = &leaf->hdr;
 	ASSERT((mapindex >= 0) && (mapindex < XFS_ATTR_LEAF_MAPSIZE));
@@ -1110,7 +1116,7 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
 		tmp  = be16_to_cpu(hdr->count) - args->index;
 		tmp *= sizeof(xfs_attr_leaf_entry_t);
 		memmove((char *)(entry+1), (char *)entry, tmp);
-		xfs_da_log_buf(args->trans, bp,
+		xfs_trans_log_buf(args->trans, bp,
 		    XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
 	}
 	be16_add_cpu(&hdr->count, 1);
@@ -1142,7 +1148,7 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
 			args->index2++;
 		}
 	}
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 			  XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
 	ASSERT((args->index == 0) ||
 	       (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
@@ -1174,7 +1180,7 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
 		args->rmtblkno = 1;
 		args->rmtblkcnt = XFS_B_TO_FSB(mp, args->valuelen);
 	}
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 	     XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
 				   xfs_attr_leaf_entsize(leaf, args->index)));
 
@@ -1198,7 +1204,7 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
 		}
 	}
 	be16_add_cpu(&hdr->usedbytes, xfs_attr_leaf_entsize(leaf, args->index));
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 		XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
 	return(0);
 }
@@ -1207,7 +1213,9 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
  * Garbage collect a leaf attribute list block by copying it to a new buffer.
  */
 STATIC void
-xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp)
+xfs_attr_leaf_compact(
+	struct xfs_trans *trans,
+	struct xfs_buf	*bp)
 {
 	xfs_attr_leafblock_t *leaf_s, *leaf_d;
 	xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
@@ -1217,14 +1225,14 @@ xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp)
 	mp = trans->t_mountp;
 	tmpbuffer = kmem_alloc(XFS_LBSIZE(mp), KM_SLEEP);
 	ASSERT(tmpbuffer != NULL);
-	memcpy(tmpbuffer, bp->data, XFS_LBSIZE(mp));
-	memset(bp->data, 0, XFS_LBSIZE(mp));
+	memcpy(tmpbuffer, bp->b_addr, XFS_LBSIZE(mp));
+	memset(bp->b_addr, 0, XFS_LBSIZE(mp));
 
 	/*
 	 * Copy basic information
 	 */
 	leaf_s = (xfs_attr_leafblock_t *)tmpbuffer;
-	leaf_d = bp->data;
+	leaf_d = bp->b_addr;
 	hdr_s = &leaf_s->hdr;
 	hdr_d = &leaf_d->hdr;
 	hdr_d->info = hdr_s->info;	/* struct copy */
@@ -1247,7 +1255,7 @@ xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp)
 	 */
 	xfs_attr_leaf_moveents(leaf_s, 0, leaf_d, 0,
 				be16_to_cpu(hdr_s->count), mp);
-	xfs_da_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
+	xfs_trans_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
 
 	kmem_free(tmpbuffer);
 }
@@ -1279,8 +1287,8 @@ xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 	 */
 	ASSERT(blk1->magic == XFS_ATTR_LEAF_MAGIC);
 	ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);
-	leaf1 = blk1->bp->data;
-	leaf2 = blk2->bp->data;
+	leaf1 = blk1->bp->b_addr;
+	leaf2 = blk2->bp->b_addr;
 	ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	args = state->args;
@@ -1298,8 +1306,8 @@ xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 		tmp_blk = blk1;
 		blk1 = blk2;
 		blk2 = tmp_blk;
-		leaf1 = blk1->bp->data;
-		leaf2 = blk2->bp->data;
+		leaf1 = blk1->bp->b_addr;
+		leaf2 = blk2->bp->b_addr;
 		swap = 1;
 	}
 	hdr1 = &leaf1->hdr;
@@ -1346,8 +1354,8 @@ xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 		xfs_attr_leaf_moveents(leaf1, be16_to_cpu(hdr1->count) - count,
 				leaf2, 0, count, state->mp);
 
-		xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
-		xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
+		xfs_trans_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
+		xfs_trans_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
 	} else if (count > be16_to_cpu(hdr1->count)) {
 		/*
 		 * I assert that since all callers pass in an empty
@@ -1378,8 +1386,8 @@ xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 		xfs_attr_leaf_moveents(leaf2, 0, leaf1,
 				be16_to_cpu(hdr1->count), count, state->mp);
 
-		xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
-		xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
+		xfs_trans_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
+		xfs_trans_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
 	}
 
 	/*
@@ -1448,8 +1456,8 @@ xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
 	/*
 	 * Set up environment.
 	 */
-	leaf1 = blk1->bp->data;
-	leaf2 = blk2->bp->data;
+	leaf1 = blk1->bp->b_addr;
+	leaf2 = blk2->bp->b_addr;
 	hdr1 = &leaf1->hdr;
 	hdr2 = &leaf2->hdr;
 	foundit = 0;
@@ -1551,7 +1559,7 @@ xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
 	xfs_da_blkinfo_t *info;
 	int count, bytes, forward, error, retval, i;
 	xfs_dablk_t blkno;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 
 	/*
 	 * Check for the degenerate case of the block being over 50% full.
@@ -1559,7 +1567,7 @@ xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
 	 * to coalesce with a sibling.
 	 */
 	blk = &state->path.blk[ state->path.active-1 ];
-	info = blk->bp->data;
+	info = blk->bp->b_addr;
 	ASSERT(info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	leaf = (xfs_attr_leafblock_t *)info;
 	count = be16_to_cpu(leaf->hdr.count);
@@ -1622,13 +1630,13 @@ xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
 		count  = be16_to_cpu(leaf->hdr.count);
 		bytes  = state->blocksize - (state->blocksize>>2);
 		bytes -= be16_to_cpu(leaf->hdr.usedbytes);
-		leaf = bp->data;
+		leaf = bp->b_addr;
 		ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 		count += be16_to_cpu(leaf->hdr.count);
 		bytes -= be16_to_cpu(leaf->hdr.usedbytes);
 		bytes -= count * sizeof(xfs_attr_leaf_entry_t);
 		bytes -= sizeof(xfs_attr_leaf_hdr_t);
-		xfs_da_brelse(state->args->trans, bp);
+		xfs_trans_brelse(state->args->trans, bp);
 		if (bytes >= 0)
 			break;	/* fits with at least 25% to spare */
 	}
@@ -1666,7 +1674,9 @@ xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
  * If two leaves are 37% full, when combined they will leave 25% free.
  */
 int
-xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
+xfs_attr_leaf_remove(
+	struct xfs_buf	*bp,
+	xfs_da_args_t	*args)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_hdr_t *hdr;
@@ -1676,7 +1686,7 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
 	int tablesize, tmp, i;
 	xfs_mount_t *mp;
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	hdr = &leaf->hdr;
 	mp = args->trans->t_mountp;
@@ -1769,7 +1779,7 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
 	 */
 	memset(xfs_attr_leaf_name(leaf, args->index), 0, entsize);
 	be16_add_cpu(&hdr->usedbytes, -entsize);
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 	     XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
 				   entsize));
 
@@ -1777,7 +1787,7 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
 					* sizeof(xfs_attr_leaf_entry_t);
 	memmove((char *)entry, (char *)(entry+1), tmp);
 	be16_add_cpu(&hdr->count, -1);
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 	    XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
 	entry = &leaf->entries[be16_to_cpu(hdr->count)];
 	memset((char *)entry, 0, sizeof(xfs_attr_leaf_entry_t));
@@ -1807,7 +1817,7 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
 	} else {
 		hdr->holes = 1;		/* mark as needing compaction */
 	}
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 			  XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
 
 	/*
@@ -1840,8 +1850,8 @@ xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 	mp = state->mp;
 	ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC);
 	ASSERT(save_blk->magic == XFS_ATTR_LEAF_MAGIC);
-	drop_leaf = drop_blk->bp->data;
-	save_leaf = save_blk->bp->data;
+	drop_leaf = drop_blk->bp->b_addr;
+	save_leaf = save_blk->bp->b_addr;
 	ASSERT(drop_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(save_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	drop_hdr = &drop_leaf->hdr;
@@ -1906,7 +1916,7 @@ xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 		kmem_free(tmpbuffer);
 	}
 
-	xfs_da_log_buf(state->args->trans, save_blk->bp, 0,
+	xfs_trans_log_buf(state->args->trans, save_blk->bp, 0,
 					   state->blocksize - 1);
 
 	/*
@@ -1934,7 +1944,9 @@ xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
  * Don't change the args->value unless we find the attribute.
  */
 int
-xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
+xfs_attr_leaf_lookup_int(
+	struct xfs_buf	*bp,
+	xfs_da_args_t	*args)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_entry_t *entry;
@@ -1945,7 +1957,7 @@ xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
 
 	trace_xfs_attr_leaf_lookup(args);
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(be16_to_cpu(leaf->hdr.count)
 					< (XFS_LBSIZE(args->dp->i_mount)/8));
@@ -2041,7 +2053,9 @@ xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
  * list structure.
  */
 int
-xfs_attr_leaf_getvalue(xfs_dabuf_t *bp, xfs_da_args_t *args)
+xfs_attr_leaf_getvalue(
+	struct xfs_buf	*bp,
+	xfs_da_args_t	*args)
 {
 	int valuelen;
 	xfs_attr_leafblock_t *leaf;
@@ -2049,7 +2063,7 @@ xfs_attr_leaf_getvalue(xfs_dabuf_t *bp, xfs_da_args_t *args)
 	xfs_attr_leaf_name_local_t *name_loc;
 	xfs_attr_leaf_name_remote_t *name_rmt;
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(be16_to_cpu(leaf->hdr.count)
 					< (XFS_LBSIZE(args->dp->i_mount)/8));
@@ -2247,12 +2261,14 @@ xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s,
  * Return 0 unless leaf2 should go before leaf1.
  */
 int
-xfs_attr_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp)
+xfs_attr_leaf_order(
+	struct xfs_buf	*leaf1_bp,
+	struct xfs_buf	*leaf2_bp)
 {
 	xfs_attr_leafblock_t *leaf1, *leaf2;
 
-	leaf1 = leaf1_bp->data;
-	leaf2 = leaf2_bp->data;
+	leaf1 = leaf1_bp->b_addr;
+	leaf2 = leaf2_bp->b_addr;
 	ASSERT((leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) &&
 	       (leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)));
 	if ((be16_to_cpu(leaf1->hdr.count) > 0) &&
@@ -2272,11 +2288,13 @@ xfs_attr_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp)
  * Pick up the last hashvalue from a leaf block.
  */
 xfs_dahash_t
-xfs_attr_leaf_lasthash(xfs_dabuf_t *bp, int *count)
+xfs_attr_leaf_lasthash(
+	struct xfs_buf	*bp,
+	int		*count)
 {
 	xfs_attr_leafblock_t *leaf;
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	if (count)
 		*count = be16_to_cpu(leaf->hdr.count);
@@ -2337,7 +2355,9 @@ xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize, int *local)
  * Copy out attribute list entries for attr_list(), for leaf attribute lists.
  */
 int
-xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
+xfs_attr_leaf_list_int(
+	struct xfs_buf		*bp,
+	xfs_attr_list_context_t	*context)
 {
 	attrlist_cursor_kern_t *cursor;
 	xfs_attr_leafblock_t *leaf;
@@ -2345,7 +2365,7 @@ xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
 	int retval, i;
 
 	ASSERT(bp != NULL);
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	cursor = context->cursor;
 	cursor->initted = 1;
 
@@ -2463,7 +2483,7 @@ xfs_attr_leaf_clearflag(xfs_da_args_t *args)
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_entry_t *entry;
 	xfs_attr_leaf_name_remote_t *name_rmt;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 #ifdef DEBUG
 	xfs_attr_leaf_name_local_t *name_loc;
@@ -2482,7 +2502,7 @@ xfs_attr_leaf_clearflag(xfs_da_args_t *args)
 	}
 	ASSERT(bp != NULL);
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
 	ASSERT(args->index >= 0);
@@ -2505,7 +2525,7 @@ xfs_attr_leaf_clearflag(xfs_da_args_t *args)
 #endif /* DEBUG */
 
 	entry->flags &= ~XFS_ATTR_INCOMPLETE;
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 			 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
 
 	if (args->rmtblkno) {
@@ -2513,10 +2533,9 @@ xfs_attr_leaf_clearflag(xfs_da_args_t *args)
 		name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
 		name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
 		name_rmt->valuelen = cpu_to_be32(args->valuelen);
-		xfs_da_log_buf(args->trans, bp,
+		xfs_trans_log_buf(args->trans, bp,
 			 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
 	}
-	xfs_da_buf_done(bp);
 
 	/*
 	 * Commit the flag value change and start the next trans in series.
@@ -2533,7 +2552,7 @@ xfs_attr_leaf_setflag(xfs_da_args_t *args)
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_entry_t *entry;
 	xfs_attr_leaf_name_remote_t *name_rmt;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 
 	trace_xfs_attr_leaf_setflag(args);
@@ -2548,7 +2567,7 @@ xfs_attr_leaf_setflag(xfs_da_args_t *args)
 	}
 	ASSERT(bp != NULL);
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
 	ASSERT(args->index >= 0);
@@ -2556,16 +2575,15 @@ xfs_attr_leaf_setflag(xfs_da_args_t *args)
 
 	ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
 	entry->flags |= XFS_ATTR_INCOMPLETE;
-	xfs_da_log_buf(args->trans, bp,
+	xfs_trans_log_buf(args->trans, bp,
 			XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
 	if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
 		name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
 		name_rmt->valueblk = 0;
 		name_rmt->valuelen = 0;
-		xfs_da_log_buf(args->trans, bp,
+		xfs_trans_log_buf(args->trans, bp,
 			 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
 	}
-	xfs_da_buf_done(bp);
 
 	/*
 	 * Commit the flag value change and start the next trans in series.
@@ -2586,7 +2604,7 @@ xfs_attr_leaf_flipflags(xfs_da_args_t *args)
 	xfs_attr_leafblock_t *leaf1, *leaf2;
 	xfs_attr_leaf_entry_t *entry1, *entry2;
 	xfs_attr_leaf_name_remote_t *name_rmt;
-	xfs_dabuf_t *bp1, *bp2;
+	struct xfs_buf *bp1, *bp2;
 	int error;
 #ifdef DEBUG
 	xfs_attr_leaf_name_local_t *name_loc;
@@ -2620,13 +2638,13 @@ xfs_attr_leaf_flipflags(xfs_da_args_t *args)
 		bp2 = bp1;
 	}
 
-	leaf1 = bp1->data;
+	leaf1 = bp1->b_addr;
 	ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(args->index < be16_to_cpu(leaf1->hdr.count));
 	ASSERT(args->index >= 0);
 	entry1 = &leaf1->entries[ args->index ];
 
-	leaf2 = bp2->data;
+	leaf2 = bp2->b_addr;
 	ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 	ASSERT(args->index2 < be16_to_cpu(leaf2->hdr.count));
 	ASSERT(args->index2 >= 0);
@@ -2660,30 +2678,27 @@ xfs_attr_leaf_flipflags(xfs_da_args_t *args)
 	ASSERT((entry2->flags & XFS_ATTR_INCOMPLETE) == 0);
 
 	entry1->flags &= ~XFS_ATTR_INCOMPLETE;
-	xfs_da_log_buf(args->trans, bp1,
+	xfs_trans_log_buf(args->trans, bp1,
 			  XFS_DA_LOGRANGE(leaf1, entry1, sizeof(*entry1)));
 	if (args->rmtblkno) {
 		ASSERT((entry1->flags & XFS_ATTR_LOCAL) == 0);
 		name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
 		name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
 		name_rmt->valuelen = cpu_to_be32(args->valuelen);
-		xfs_da_log_buf(args->trans, bp1,
+		xfs_trans_log_buf(args->trans, bp1,
 			 XFS_DA_LOGRANGE(leaf1, name_rmt, sizeof(*name_rmt)));
 	}
 
 	entry2->flags |= XFS_ATTR_INCOMPLETE;
-	xfs_da_log_buf(args->trans, bp2,
+	xfs_trans_log_buf(args->trans, bp2,
 			  XFS_DA_LOGRANGE(leaf2, entry2, sizeof(*entry2)));
 	if ((entry2->flags & XFS_ATTR_LOCAL) == 0) {
 		name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
 		name_rmt->valueblk = 0;
 		name_rmt->valuelen = 0;
-		xfs_da_log_buf(args->trans, bp2,
+		xfs_trans_log_buf(args->trans, bp2,
 			 XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
 	}
-	xfs_da_buf_done(bp1);
-	if (bp1 != bp2)
-		xfs_da_buf_done(bp2);
 
 	/*
 	 * Commit the flag value change and start the next trans in series.
@@ -2706,7 +2721,7 @@ xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
 {
 	xfs_da_blkinfo_t *info;
 	xfs_daddr_t blkno;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 
 	/*
@@ -2718,20 +2733,20 @@ xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
 	error = xfs_da_read_buf(*trans, dp, 0, -1, &bp, XFS_ATTR_FORK);
 	if (error)
 		return(error);
-	blkno = xfs_da_blkno(bp);
+	blkno = XFS_BUF_ADDR(bp);
 
 	/*
 	 * Invalidate the tree, even if the "tree" is only a single leaf block.
 	 * This is a depth-first traversal!
 	 */
-	info = bp->data;
+	info = bp->b_addr;
 	if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
 		error = xfs_attr_node_inactive(trans, dp, bp, 1);
 	} else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
 		error = xfs_attr_leaf_inactive(trans, dp, bp);
 	} else {
 		error = XFS_ERROR(EIO);
-		xfs_da_brelse(*trans, bp);
+		xfs_trans_brelse(*trans, bp);
 	}
 	if (error)
 		return(error);
@@ -2742,7 +2757,7 @@ xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
 	error = xfs_da_get_buf(*trans, dp, 0, blkno, &bp, XFS_ATTR_FORK);
 	if (error)
 		return(error);
-	xfs_da_binval(*trans, bp);	/* remove from cache */
+	xfs_trans_binval(*trans, bp);	/* remove from cache */
 	/*
 	 * Commit the invalidate and start the next transaction.
 	 */
@@ -2756,34 +2771,37 @@ xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
  * We're doing a depth-first traversal in order to invalidate everything.
  */
 STATIC int
-xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
-				   int level)
+xfs_attr_node_inactive(
+	struct xfs_trans **trans,
+	struct xfs_inode *dp,
+	struct xfs_buf	*bp,
+	int		level)
 {
 	xfs_da_blkinfo_t *info;
 	xfs_da_intnode_t *node;
 	xfs_dablk_t child_fsb;
 	xfs_daddr_t parent_blkno, child_blkno;
 	int error, count, i;
-	xfs_dabuf_t *child_bp;
+	struct xfs_buf *child_bp;
 
 	/*
 	 * Since this code is recursive (gasp!) we must protect ourselves.
 	 */
 	if (level > XFS_DA_NODE_MAXDEPTH) {
-		xfs_da_brelse(*trans, bp);	/* no locks for later trans */
+		xfs_trans_brelse(*trans, bp);	/* no locks for later trans */
 		return(XFS_ERROR(EIO));
 	}
 
-	node = bp->data;
+	node = bp->b_addr;
 	ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
-	parent_blkno = xfs_da_blkno(bp);	/* save for re-read later */
+	parent_blkno = XFS_BUF_ADDR(bp);	/* save for re-read later */
 	count = be16_to_cpu(node->hdr.count);
 	if (!count) {
-		xfs_da_brelse(*trans, bp);
+		xfs_trans_brelse(*trans, bp);
 		return(0);
 	}
 	child_fsb = be32_to_cpu(node->btree[0].before);
-	xfs_da_brelse(*trans, bp);	/* no locks for later trans */
+	xfs_trans_brelse(*trans, bp);	/* no locks for later trans */
 
 	/*
 	 * If this is the node level just above the leaves, simply loop
@@ -2803,12 +2821,12 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
 			return(error);
 		if (child_bp) {
 						/* save for re-read later */
-			child_blkno = xfs_da_blkno(child_bp);
+			child_blkno = XFS_BUF_ADDR(child_bp);
 
 			/*
 			 * Invalidate the subtree, however we have to.
 			 */
-			info = child_bp->data;
+			info = child_bp->b_addr;
 			if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
 				error = xfs_attr_node_inactive(trans, dp,
 						child_bp, level+1);
@@ -2817,7 +2835,7 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
 						child_bp);
 			} else {
 				error = XFS_ERROR(EIO);
-				xfs_da_brelse(*trans, child_bp);
+				xfs_trans_brelse(*trans, child_bp);
 			}
 			if (error)
 				return(error);
@@ -2830,7 +2848,7 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
 				&child_bp, XFS_ATTR_FORK);
 			if (error)
 				return(error);
-			xfs_da_binval(*trans, child_bp);
+			xfs_trans_binval(*trans, child_bp);
 		}
 
 		/*
@@ -2843,7 +2861,7 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
 			if (error)
 				return(error);
 			child_fsb = be32_to_cpu(node->btree[i+1].before);
-			xfs_da_brelse(*trans, bp);
+			xfs_trans_brelse(*trans, bp);
 		}
 		/*
 		 * Atomically commit the whole invalidate stuff.
@@ -2863,7 +2881,10 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
  * caught holding something that the logging code wants to flush to disk.
  */
 STATIC int
-xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
+xfs_attr_leaf_inactive(
+	struct xfs_trans **trans,
+	struct xfs_inode *dp,
+	struct xfs_buf	*bp)
 {
 	xfs_attr_leafblock_t *leaf;
 	xfs_attr_leaf_entry_t *entry;
@@ -2871,7 +2892,7 @@ xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
 	xfs_attr_inactive_list_t *list, *lp;
 	int error, count, size, tmp, i;
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 
 	/*
@@ -2892,7 +2913,7 @@ xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
 	 * If there are no "remote" values, we're done.
 	 */
 	if (count == 0) {
-		xfs_da_brelse(*trans, bp);
+		xfs_trans_brelse(*trans, bp);
 		return(0);
 	}
 
@@ -2919,7 +2940,7 @@ xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
 			}
 		}
 	}
-	xfs_da_brelse(*trans, bp);	/* unlock for trans. in freextent() */
+	xfs_trans_brelse(*trans, bp);	/* unlock for trans. in freextent() */
 
 	/*
 	 * Invalidate each of the "remote" value extents.
diff --git a/fs/xfs/xfs_attr_leaf.h b/fs/xfs/xfs_attr_leaf.h
index 9c7d22f..dea1772 100644
--- a/fs/xfs/xfs_attr_leaf.h
+++ b/fs/xfs/xfs_attr_leaf.h
@@ -31,7 +31,6 @@
 struct attrlist;
 struct attrlist_cursor_kern;
 struct xfs_attr_list_context;
-struct xfs_dabuf;
 struct xfs_da_args;
 struct xfs_da_state;
 struct xfs_da_state_blk;
@@ -215,7 +214,7 @@ int	xfs_attr_shortform_getvalue(struct xfs_da_args *args);
 int	xfs_attr_shortform_to_leaf(struct xfs_da_args *args);
 int	xfs_attr_shortform_remove(struct xfs_da_args *args);
 int	xfs_attr_shortform_list(struct xfs_attr_list_context *context);
-int	xfs_attr_shortform_allfit(struct xfs_dabuf *bp, struct xfs_inode *dp);
+int	xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
 int	xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes);
 
 
@@ -223,7 +222,7 @@ int	xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes);
  * Internal routines when attribute fork size == XFS_LBSIZE(mp).
  */
 int	xfs_attr_leaf_to_node(struct xfs_da_args *args);
-int	xfs_attr_leaf_to_shortform(struct xfs_dabuf *bp,
+int	xfs_attr_leaf_to_shortform(struct xfs_buf *bp,
 				   struct xfs_da_args *args, int forkoff);
 int	xfs_attr_leaf_clearflag(struct xfs_da_args *args);
 int	xfs_attr_leaf_setflag(struct xfs_da_args *args);
@@ -235,14 +234,14 @@ int	xfs_attr_leaf_flipflags(xfs_da_args_t *args);
 int	xfs_attr_leaf_split(struct xfs_da_state *state,
 				   struct xfs_da_state_blk *oldblk,
 				   struct xfs_da_state_blk *newblk);
-int	xfs_attr_leaf_lookup_int(struct xfs_dabuf *leaf,
+int	xfs_attr_leaf_lookup_int(struct xfs_buf *leaf,
 					struct xfs_da_args *args);
-int	xfs_attr_leaf_getvalue(struct xfs_dabuf *bp, struct xfs_da_args *args);
-int	xfs_attr_leaf_add(struct xfs_dabuf *leaf_buffer,
+int	xfs_attr_leaf_getvalue(struct xfs_buf *bp, struct xfs_da_args *args);
+int	xfs_attr_leaf_add(struct xfs_buf *leaf_buffer,
 				 struct xfs_da_args *args);
-int	xfs_attr_leaf_remove(struct xfs_dabuf *leaf_buffer,
+int	xfs_attr_leaf_remove(struct xfs_buf *leaf_buffer,
 				    struct xfs_da_args *args);
-int	xfs_attr_leaf_list_int(struct xfs_dabuf *bp,
+int	xfs_attr_leaf_list_int(struct xfs_buf *bp,
 				      struct xfs_attr_list_context *context);
 
 /*
@@ -257,9 +256,9 @@ int	xfs_attr_root_inactive(struct xfs_trans **trans, struct xfs_inode *dp);
 /*
  * Utility routines.
  */
-xfs_dahash_t	xfs_attr_leaf_lasthash(struct xfs_dabuf *bp, int *count);
-int	xfs_attr_leaf_order(struct xfs_dabuf *leaf1_bp,
-				   struct xfs_dabuf *leaf2_bp);
+xfs_dahash_t	xfs_attr_leaf_lasthash(struct xfs_buf *bp, int *count);
+int	xfs_attr_leaf_order(struct xfs_buf *leaf1_bp,
+				   struct xfs_buf *leaf2_bp);
 int	xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize,
 					int *local);
 #endif	/* __XFS_ATTR_LEAF_H__ */
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 76e5dba..7bfb7dd 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -83,9 +83,9 @@ STATIC void xfs_da_node_unbalance(xfs_da_state_t *state,
 /*
  * Utility routines.
  */
-STATIC uint	xfs_da_node_lasthash(xfs_dabuf_t *bp, int *count);
-STATIC int	xfs_da_node_order(xfs_dabuf_t *node1_bp, xfs_dabuf_t *node2_bp);
-STATIC xfs_dabuf_t *xfs_da_buf_make(xfs_buf_t *bp);
+STATIC uint	xfs_da_node_lasthash(struct xfs_buf *bp, int *count);
+STATIC int	xfs_da_node_order(struct xfs_buf *node1_bp,
+				  struct xfs_buf *node2_bp);
 STATIC int	xfs_da_blk_unlink(xfs_da_state_t *state,
 				  xfs_da_state_blk_t *drop_blk,
 				  xfs_da_state_blk_t *save_blk);
@@ -100,10 +100,10 @@ STATIC void	xfs_da_state_kill_altpath(xfs_da_state_t *state);
  */
 int
 xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level,
-				 xfs_dabuf_t **bpp, int whichfork)
+				 struct xfs_buf **bpp, int whichfork)
 {
 	xfs_da_intnode_t *node;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 	xfs_trans_t *tp;
 
@@ -114,7 +114,7 @@ xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level,
 	if (error)
 		return(error);
 	ASSERT(bp != NULL);
-	node = bp->data;
+	node = bp->b_addr;
 	node->hdr.info.forw = 0;
 	node->hdr.info.back = 0;
 	node->hdr.info.magic = cpu_to_be16(XFS_DA_NODE_MAGIC);
@@ -122,7 +122,7 @@ xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level,
 	node->hdr.count = 0;
 	node->hdr.level = cpu_to_be16(level);
 
-	xfs_da_log_buf(tp, bp,
+	xfs_trans_log_buf(tp, bp,
 		XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr)));
 
 	*bpp = bp;
@@ -138,7 +138,7 @@ xfs_da_split(xfs_da_state_t *state)
 {
 	xfs_da_state_blk_t *oldblk, *newblk, *addblk;
 	xfs_da_intnode_t *node;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int max, action, error, i;
 
 	trace_xfs_da_split(state->args);
@@ -203,7 +203,6 @@ xfs_da_split(xfs_da_state_t *state)
 		case XFS_DA_NODE_MAGIC:
 			error = xfs_da_node_split(state, oldblk, newblk, addblk,
 							 max - i, &action);
-			xfs_da_buf_done(addblk->bp);
 			addblk->bp = NULL;
 			if (error)
 				return(error);	/* GROT: dir is inconsistent */
@@ -221,13 +220,6 @@ xfs_da_split(xfs_da_state_t *state)
 		 * Update the btree to show the new hashval for this child.
 		 */
 		xfs_da_fixhashpath(state, &state->path);
-		/*
-		 * If we won't need this block again, it's getting dropped
-		 * from the active path by the loop control, so we need
-		 * to mark it done now.
-		 */
-		if (i > 0 || !addblk)
-			xfs_da_buf_done(oldblk->bp);
 	}
 	if (!addblk)
 		return(0);
@@ -239,8 +231,6 @@ xfs_da_split(xfs_da_state_t *state)
 	oldblk = &state->path.blk[0];
 	error = xfs_da_root_split(state, oldblk, addblk);
 	if (error) {
-		xfs_da_buf_done(oldblk->bp);
-		xfs_da_buf_done(addblk->bp);
 		addblk->bp = NULL;
 		return(error);	/* GROT: dir is inconsistent */
 	}
@@ -252,7 +242,7 @@ xfs_da_split(xfs_da_state_t *state)
 	 * and the original block 0 could be at any position in the list.
 	 */
 
-	node = oldblk->bp->data;
+	node = oldblk->bp->b_addr;
 	if (node->hdr.info.forw) {
 		if (be32_to_cpu(node->hdr.info.forw) == addblk->blkno) {
 			bp = addblk->bp;
@@ -260,13 +250,13 @@ xfs_da_split(xfs_da_state_t *state)
 			ASSERT(state->extravalid);
 			bp = state->extrablk.bp;
 		}
-		node = bp->data;
+		node = bp->b_addr;
 		node->hdr.info.back = cpu_to_be32(oldblk->blkno);
-		xfs_da_log_buf(state->args->trans, bp,
+		xfs_trans_log_buf(state->args->trans, bp,
 		    XFS_DA_LOGRANGE(node, &node->hdr.info,
 		    sizeof(node->hdr.info)));
 	}
-	node = oldblk->bp->data;
+	node = oldblk->bp->b_addr;
 	if (node->hdr.info.back) {
 		if (be32_to_cpu(node->hdr.info.back) == addblk->blkno) {
 			bp = addblk->bp;
@@ -274,14 +264,12 @@ xfs_da_split(xfs_da_state_t *state)
 			ASSERT(state->extravalid);
 			bp = state->extrablk.bp;
 		}
-		node = bp->data;
+		node = bp->b_addr;
 		node->hdr.info.forw = cpu_to_be32(oldblk->blkno);
-		xfs_da_log_buf(state->args->trans, bp,
+		xfs_trans_log_buf(state->args->trans, bp,
 		    XFS_DA_LOGRANGE(node, &node->hdr.info,
 		    sizeof(node->hdr.info)));
 	}
-	xfs_da_buf_done(oldblk->bp);
-	xfs_da_buf_done(addblk->bp);
 	addblk->bp = NULL;
 	return(0);
 }
@@ -298,7 +286,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 	xfs_da_intnode_t *node, *oldroot;
 	xfs_da_args_t *args;
 	xfs_dablk_t blkno;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error, size;
 	xfs_inode_t *dp;
 	xfs_trans_t *tp;
@@ -323,8 +311,8 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 	if (error)
 		return(error);
 	ASSERT(bp != NULL);
-	node = bp->data;
-	oldroot = blk1->bp->data;
+	node = bp->b_addr;
+	oldroot = blk1->bp->b_addr;
 	if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
 		size = (int)((char *)&oldroot->btree[be16_to_cpu(oldroot->hdr.count)] -
 			     (char *)oldroot);
@@ -335,8 +323,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 			     (char *)leaf);
 	}
 	memcpy(node, oldroot, size);
-	xfs_da_log_buf(tp, bp, 0, size - 1);
-	xfs_da_buf_done(blk1->bp);
+	xfs_trans_log_buf(tp, bp, 0, size - 1);
 	blk1->bp = bp;
 	blk1->blkno = blkno;
 
@@ -348,7 +335,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 		be16_to_cpu(node->hdr.level) + 1, &bp, args->whichfork);
 	if (error)
 		return(error);
-	node = bp->data;
+	node = bp->b_addr;
 	node->btree[0].hashval = cpu_to_be32(blk1->hashval);
 	node->btree[0].before = cpu_to_be32(blk1->blkno);
 	node->btree[1].hashval = cpu_to_be32(blk2->hashval);
@@ -365,10 +352,9 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 #endif
 
 	/* Header is already logged by xfs_da_node_create */
-	xfs_da_log_buf(tp, bp,
+	xfs_trans_log_buf(tp, bp,
 		XFS_DA_LOGRANGE(node, node->btree,
 			sizeof(xfs_da_node_entry_t) * 2));
-	xfs_da_buf_done(bp);
 
 	return(0);
 }
@@ -389,7 +375,7 @@ xfs_da_node_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
 
 	trace_xfs_da_node_split(state->args);
 
-	node = oldblk->bp->data;
+	node = oldblk->bp->b_addr;
 	ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 
 	/*
@@ -436,7 +422,7 @@ xfs_da_node_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
 	 *
 	 * If we had double-split op below us, then add the extra block too.
 	 */
-	node = oldblk->bp->data;
+	node = oldblk->bp->b_addr;
 	if (oldblk->index <= be16_to_cpu(node->hdr.count)) {
 		oldblk->index++;
 		xfs_da_node_add(state, oldblk, addblk);
@@ -477,8 +463,8 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 
 	trace_xfs_da_node_rebalance(state->args);
 
-	node1 = blk1->bp->data;
-	node2 = blk2->bp->data;
+	node1 = blk1->bp->b_addr;
+	node2 = blk2->bp->b_addr;
 	/*
 	 * Figure out how many entries need to move, and in which direction.
 	 * Swap the nodes around if that makes it simpler.
@@ -532,7 +518,7 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 		btree_d = &node1->btree[be16_to_cpu(node1->hdr.count)];
 		memcpy(btree_d, btree_s, tmp);
 		be16_add_cpu(&node1->hdr.count, count);
-		xfs_da_log_buf(tp, blk1->bp,
+		xfs_trans_log_buf(tp, blk1->bp,
 			XFS_DA_LOGRANGE(node1, btree_d, tmp));
 
 		/*
@@ -549,9 +535,9 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 	/*
 	 * Log header of node 1 and all current bits of node 2.
 	 */
-	xfs_da_log_buf(tp, blk1->bp,
+	xfs_trans_log_buf(tp, blk1->bp,
 		XFS_DA_LOGRANGE(node1, &node1->hdr, sizeof(node1->hdr)));
-	xfs_da_log_buf(tp, blk2->bp,
+	xfs_trans_log_buf(tp, blk2->bp,
 		XFS_DA_LOGRANGE(node2, &node2->hdr,
 			sizeof(node2->hdr) +
 			sizeof(node2->btree[0]) * be16_to_cpu(node2->hdr.count)));
@@ -560,8 +546,8 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
 	 * Record the last hashval from each block for upward propagation.
 	 * (note: don't use the swapped node pointers)
 	 */
-	node1 = blk1->bp->data;
-	node2 = blk2->bp->data;
+	node1 = blk1->bp->b_addr;
+	node2 = blk2->bp->b_addr;
 	blk1->hashval = be32_to_cpu(node1->btree[be16_to_cpu(node1->hdr.count)-1].hashval);
 	blk2->hashval = be32_to_cpu(node2->btree[be16_to_cpu(node2->hdr.count)-1].hashval);
 
@@ -587,7 +573,7 @@ xfs_da_node_add(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
 
 	trace_xfs_da_node_add(state->args);
 
-	node = oldblk->bp->data;
+	node = oldblk->bp->b_addr;
 	ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 	ASSERT((oldblk->index >= 0) && (oldblk->index <= be16_to_cpu(node->hdr.count)));
 	ASSERT(newblk->blkno != 0);
@@ -606,10 +592,10 @@ xfs_da_node_add(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
 	}
 	btree->hashval = cpu_to_be32(newblk->hashval);
 	btree->before = cpu_to_be32(newblk->blkno);
-	xfs_da_log_buf(state->args->trans, oldblk->bp,
+	xfs_trans_log_buf(state->args->trans, oldblk->bp,
 		XFS_DA_LOGRANGE(node, btree, tmp + sizeof(*btree)));
 	be16_add_cpu(&node->hdr.count, 1);
-	xfs_da_log_buf(state->args->trans, oldblk->bp,
+	xfs_trans_log_buf(state->args->trans, oldblk->bp,
 		XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr)));
 
 	/*
@@ -735,7 +721,7 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
 	xfs_da_intnode_t *oldroot;
 	xfs_da_args_t *args;
 	xfs_dablk_t child;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 
 	trace_xfs_da_root_join(state->args);
@@ -743,7 +729,7 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
 	args = state->args;
 	ASSERT(args != NULL);
 	ASSERT(root_blk->magic == XFS_DA_NODE_MAGIC);
-	oldroot = root_blk->bp->data;
+	oldroot = root_blk->bp->b_addr;
 	ASSERT(oldroot->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 	ASSERT(!oldroot->hdr.info.forw);
 	ASSERT(!oldroot->hdr.info.back);
@@ -765,11 +751,11 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
 	if (error)
 		return(error);
 	ASSERT(bp != NULL);
-	xfs_da_blkinfo_onlychild_validate(bp->data,
+	xfs_da_blkinfo_onlychild_validate(bp->b_addr,
 					be16_to_cpu(oldroot->hdr.level));
 
-	memcpy(root_blk->bp->data, bp->data, state->blocksize);
-	xfs_da_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1);
+	memcpy(root_blk->bp->b_addr, bp->b_addr, state->blocksize);
+	xfs_trans_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1);
 	error = xfs_da_shrink_inode(args, child, bp);
 	return(error);
 }
@@ -791,7 +777,7 @@ xfs_da_node_toosmall(xfs_da_state_t *state, int *action)
 	xfs_da_blkinfo_t *info;
 	int count, forward, error, retval, i;
 	xfs_dablk_t blkno;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 
 	/*
 	 * Check for the degenerate case of the block being over 50% full.
@@ -799,7 +785,7 @@ xfs_da_node_toosmall(xfs_da_state_t *state, int *action)
 	 * to coalesce with a sibling.
 	 */
 	blk = &state->path.blk[ state->path.active-1 ];
-	info = blk->bp->data;
+	info = blk->bp->b_addr;
 	ASSERT(info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 	node = (xfs_da_intnode_t *)info;
 	count = be16_to_cpu(node->hdr.count);
@@ -859,10 +845,10 @@ xfs_da_node_toosmall(xfs_da_state_t *state, int *action)
 		count  = state->node_ents;
 		count -= state->node_ents >> 2;
 		count -= be16_to_cpu(node->hdr.count);
-		node = bp->data;
+		node = bp->b_addr;
 		ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 		count -= be16_to_cpu(node->hdr.count);
-		xfs_da_brelse(state->args->trans, bp);
+		xfs_trans_brelse(state->args->trans, bp);
 		if (count >= 0)
 			break;	/* fits with at least 25% to spare */
 	}
@@ -934,14 +920,14 @@ xfs_da_fixhashpath(xfs_da_state_t *state, xfs_da_state_path_t *path)
 		break;
 	}
 	for (blk--, level--; level >= 0; blk--, level--) {
-		node = blk->bp->data;
+		node = blk->bp->b_addr;
 		ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 		btree = &node->btree[ blk->index ];
 		if (be32_to_cpu(btree->hashval) == lasthash)
 			break;
 		blk->hashval = lasthash;
 		btree->hashval = cpu_to_be32(lasthash);
-		xfs_da_log_buf(state->args->trans, blk->bp,
+		xfs_trans_log_buf(state->args->trans, blk->bp,
 				  XFS_DA_LOGRANGE(node, btree, sizeof(*btree)));
 
 		lasthash = be32_to_cpu(node->btree[be16_to_cpu(node->hdr.count)-1].hashval);
@@ -960,7 +946,7 @@ xfs_da_node_remove(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk)
 
 	trace_xfs_da_node_remove(state->args);
 
-	node = drop_blk->bp->data;
+	node = drop_blk->bp->b_addr;
 	ASSERT(drop_blk->index < be16_to_cpu(node->hdr.count));
 	ASSERT(drop_blk->index >= 0);
 
@@ -972,15 +958,15 @@ xfs_da_node_remove(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk)
 		tmp  = be16_to_cpu(node->hdr.count) - drop_blk->index - 1;
 		tmp *= (uint)sizeof(xfs_da_node_entry_t);
 		memmove(btree, btree + 1, tmp);
-		xfs_da_log_buf(state->args->trans, drop_blk->bp,
+		xfs_trans_log_buf(state->args->trans, drop_blk->bp,
 		    XFS_DA_LOGRANGE(node, btree, tmp));
 		btree = &node->btree[be16_to_cpu(node->hdr.count)-1];
 	}
 	memset((char *)btree, 0, sizeof(xfs_da_node_entry_t));
-	xfs_da_log_buf(state->args->trans, drop_blk->bp,
+	xfs_trans_log_buf(state->args->trans, drop_blk->bp,
 	    XFS_DA_LOGRANGE(node, btree, sizeof(*btree)));
 	be16_add_cpu(&node->hdr.count, -1);
-	xfs_da_log_buf(state->args->trans, drop_blk->bp,
+	xfs_trans_log_buf(state->args->trans, drop_blk->bp,
 	    XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr)));
 
 	/*
@@ -1005,8 +991,8 @@ xfs_da_node_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 
 	trace_xfs_da_node_unbalance(state->args);
 
-	drop_node = drop_blk->bp->data;
-	save_node = save_blk->bp->data;
+	drop_node = drop_blk->bp->b_addr;
+	save_node = save_blk->bp->b_addr;
 	ASSERT(drop_node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 	ASSERT(save_node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 	tp = state->args->trans;
@@ -1023,13 +1009,13 @@ xfs_da_node_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 		tmp = be16_to_cpu(save_node->hdr.count) * (uint)sizeof(xfs_da_node_entry_t);
 		memmove(btree, &save_node->btree[0], tmp);
 		btree = &save_node->btree[0];
-		xfs_da_log_buf(tp, save_blk->bp,
+		xfs_trans_log_buf(tp, save_blk->bp,
 			XFS_DA_LOGRANGE(save_node, btree,
 				(be16_to_cpu(save_node->hdr.count) + be16_to_cpu(drop_node->hdr.count)) *
 				sizeof(xfs_da_node_entry_t)));
 	} else {
 		btree = &save_node->btree[be16_to_cpu(save_node->hdr.count)];
-		xfs_da_log_buf(tp, save_blk->bp,
+		xfs_trans_log_buf(tp, save_blk->bp,
 			XFS_DA_LOGRANGE(save_node, btree,
 				be16_to_cpu(drop_node->hdr.count) *
 				sizeof(xfs_da_node_entry_t)));
@@ -1042,7 +1028,7 @@ xfs_da_node_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 	memcpy(btree, &drop_node->btree[0], tmp);
 	be16_add_cpu(&save_node->hdr.count, be16_to_cpu(drop_node->hdr.count));
 
-	xfs_da_log_buf(tp, save_blk->bp,
+	xfs_trans_log_buf(tp, save_blk->bp,
 		XFS_DA_LOGRANGE(save_node, &save_node->hdr,
 			sizeof(save_node->hdr)));
 
@@ -1100,7 +1086,7 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
 			state->path.active--;
 			return(error);
 		}
-		curr = blk->bp->data;
+		curr = blk->bp->b_addr;
 		blk->magic = be16_to_cpu(curr->magic);
 		ASSERT(blk->magic == XFS_DA_NODE_MAGIC ||
 		       blk->magic == XFS_DIR2_LEAFN_MAGIC ||
@@ -1110,7 +1096,7 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
 		 * Search an intermediate node for a match.
 		 */
 		if (blk->magic == XFS_DA_NODE_MAGIC) {
-			node = blk->bp->data;
+			node = blk->bp->b_addr;
 			max = be16_to_cpu(node->hdr.count);
 			blk->hashval = be32_to_cpu(node->btree[max-1].hashval);
 
@@ -1216,15 +1202,15 @@ xfs_da_blk_link(xfs_da_state_t *state, xfs_da_state_blk_t *old_blk,
 	xfs_da_blkinfo_t *old_info, *new_info, *tmp_info;
 	xfs_da_args_t *args;
 	int before=0, error;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 
 	/*
 	 * Set up environment.
 	 */
 	args = state->args;
 	ASSERT(args != NULL);
-	old_info = old_blk->bp->data;
-	new_info = new_blk->bp->data;
+	old_info = old_blk->bp->b_addr;
+	new_info = new_blk->bp->b_addr;
 	ASSERT(old_blk->magic == XFS_DA_NODE_MAGIC ||
 	       old_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
 	       old_blk->magic == XFS_ATTR_LEAF_MAGIC);
@@ -1261,12 +1247,11 @@ xfs_da_blk_link(xfs_da_state_t *state, xfs_da_state_blk_t *old_blk,
 			if (error)
 				return(error);
 			ASSERT(bp != NULL);
-			tmp_info = bp->data;
+			tmp_info = bp->b_addr;
 			ASSERT(be16_to_cpu(tmp_info->magic) == be16_to_cpu(old_info->magic));
 			ASSERT(be32_to_cpu(tmp_info->forw) == old_blk->blkno);
 			tmp_info->forw = cpu_to_be32(new_blk->blkno);
-			xfs_da_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
-			xfs_da_buf_done(bp);
+			xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
 		}
 		old_info->back = cpu_to_be32(new_blk->blkno);
 	} else {
@@ -1283,18 +1268,17 @@ xfs_da_blk_link(xfs_da_state_t *state, xfs_da_state_blk_t *old_blk,
 			if (error)
 				return(error);
 			ASSERT(bp != NULL);
-			tmp_info = bp->data;
+			tmp_info = bp->b_addr;
 			ASSERT(tmp_info->magic == old_info->magic);
 			ASSERT(be32_to_cpu(tmp_info->back) == old_blk->blkno);
 			tmp_info->back = cpu_to_be32(new_blk->blkno);
-			xfs_da_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
-			xfs_da_buf_done(bp);
+			xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
 		}
 		old_info->forw = cpu_to_be32(new_blk->blkno);
 	}
 
-	xfs_da_log_buf(args->trans, old_blk->bp, 0, sizeof(*tmp_info) - 1);
-	xfs_da_log_buf(args->trans, new_blk->bp, 0, sizeof(*tmp_info) - 1);
+	xfs_trans_log_buf(args->trans, old_blk->bp, 0, sizeof(*tmp_info) - 1);
+	xfs_trans_log_buf(args->trans, new_blk->bp, 0, sizeof(*tmp_info) - 1);
 	return(0);
 }
 
@@ -1302,12 +1286,14 @@ xfs_da_blk_link(xfs_da_state_t *state, xfs_da_state_blk_t *old_blk,
  * Compare two intermediate nodes for "order".
  */
 STATIC int
-xfs_da_node_order(xfs_dabuf_t *node1_bp, xfs_dabuf_t *node2_bp)
+xfs_da_node_order(
+	struct xfs_buf	*node1_bp,
+	struct xfs_buf	*node2_bp)
 {
 	xfs_da_intnode_t *node1, *node2;
 
-	node1 = node1_bp->data;
-	node2 = node2_bp->data;
+	node1 = node1_bp->b_addr;
+	node2 = node2_bp->b_addr;
 	ASSERT(node1->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC) &&
 	       node2->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 	if ((be16_to_cpu(node1->hdr.count) > 0) && (be16_to_cpu(node2->hdr.count) > 0) &&
@@ -1324,11 +1310,13 @@ xfs_da_node_order(xfs_dabuf_t *node1_bp, xfs_dabuf_t *node2_bp)
  * Pick up the last hashvalue from an intermediate node.
  */
 STATIC uint
-xfs_da_node_lasthash(xfs_dabuf_t *bp, int *count)
+xfs_da_node_lasthash(
+	struct xfs_buf	*bp,
+	int		*count)
 {
 	xfs_da_intnode_t *node;
 
-	node = bp->data;
+	node = bp->b_addr;
 	ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 	if (count)
 		*count = be16_to_cpu(node->hdr.count);
@@ -1346,7 +1334,7 @@ xfs_da_blk_unlink(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 {
 	xfs_da_blkinfo_t *drop_info, *save_info, *tmp_info;
 	xfs_da_args_t *args;
-	xfs_dabuf_t *bp;
+	struct xfs_buf *bp;
 	int error;
 
 	/*
@@ -1354,8 +1342,8 @@ xfs_da_blk_unlink(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 	 */
 	args = state->args;
 	ASSERT(args != NULL);
-	save_info = save_blk->bp->data;
-	drop_info = drop_blk->bp->data;
+	save_info = save_blk->bp->b_addr;
+	drop_info = drop_blk->bp->b_addr;
 	ASSERT(save_blk->magic == XFS_DA_NODE_MAGIC ||
 	       save_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
 	       save_blk->magic == XFS_ATTR_LEAF_MAGIC);
@@ -1380,13 +1368,12 @@ xfs_da_blk_unlink(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 			if (error)
 				return(error);
 			ASSERT(bp != NULL);
-			tmp_info = bp->data;
+			tmp_info = bp->b_addr;
 			ASSERT(tmp_info->magic == save_info->magic);
 			ASSERT(be32_to_cpu(tmp_info->forw) == drop_blk->blkno);
 			tmp_info->forw = cpu_to_be32(save_blk->blkno);
-			xfs_da_log_buf(args->trans, bp, 0,
+			xfs_trans_log_buf(args->trans, bp, 0,
 						    sizeof(*tmp_info) - 1);
-			xfs_da_buf_done(bp);
 		}
 	} else {
 		trace_xfs_da_unlink_forward(args);
@@ -1398,17 +1385,16 @@ xfs_da_blk_unlink(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
 			if (error)
 				return(error);
 			ASSERT(bp != NULL);
-			tmp_info = bp->data;
+			tmp_info = bp->b_addr;
 			ASSERT(tmp_info->magic == save_info->magic);
 			ASSERT(be32_to_cpu(tmp_info->back) == drop_blk->blkno);
 			tmp_info->back = cpu_to_be32(save_blk->blkno);
-			xfs_da_log_buf(args->trans, bp, 0,
+			xfs_trans_log_buf(args->trans, bp, 0,
 						    sizeof(*tmp_info) - 1);
-			xfs_da_buf_done(bp);
 		}
 	}
 
-	xfs_da_log_buf(args->trans, save_blk->bp, 0, sizeof(*save_info) - 1);
+	xfs_trans_log_buf(args->trans, save_blk->bp, 0, sizeof(*save_info) - 1);
 	return(0);
 }
 
@@ -1443,7 +1429,7 @@ xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
 	level = (path->active-1) - 1;	/* skip bottom layer in path */
 	for (blk = &path->blk[level]; level >= 0; blk--, level--) {
 		ASSERT(blk->bp != NULL);
-		node = blk->bp->data;
+		node = blk->bp->b_addr;
 		ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
 		if (forward && (blk->index < be16_to_cpu(node->hdr.count)-1)) {
 			blk->index++;
@@ -1471,7 +1457,7 @@ xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
 		 * (if it's dirty, trans won't actually let go)
 		 */
 		if (release)
-			xfs_da_brelse(args->trans, blk->bp);
+			xfs_trans_brelse(args->trans, blk->bp);
 
 		/*
 		 * Read the next child block.
@@ -1482,7 +1468,7 @@ xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
 		if (error)
 			return(error);
 		ASSERT(blk->bp != NULL);
-		info = blk->bp->data;
+		info = blk->bp->b_addr;
 		ASSERT(info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
 		       info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
 		       info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
@@ -1702,11 +1688,13 @@ xfs_da_grow_inode(
  * a bmap btree split to do that.
  */
 STATIC int
-xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
-		      xfs_dabuf_t **dead_bufp)
+xfs_da_swap_lastblock(
+	xfs_da_args_t	*args,
+	xfs_dablk_t	*dead_blknop,
+	struct xfs_buf	**dead_bufp)
 {
 	xfs_dablk_t dead_blkno, last_blkno, sib_blkno, par_blkno;
-	xfs_dabuf_t *dead_buf, *last_buf, *sib_buf, *par_buf;
+	struct xfs_buf *dead_buf, *last_buf, *sib_buf, *par_buf;
 	xfs_fileoff_t lastoff;
 	xfs_inode_t *ip;
 	xfs_trans_t *tp;
@@ -1744,9 +1732,9 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 	/*
 	 * Copy the last block into the dead buffer and log it.
 	 */
-	memcpy(dead_buf->data, last_buf->data, mp->m_dirblksize);
-	xfs_da_log_buf(tp, dead_buf, 0, mp->m_dirblksize - 1);
-	dead_info = dead_buf->data;
+	memcpy(dead_buf->b_addr, last_buf->b_addr, mp->m_dirblksize);
+	xfs_trans_log_buf(tp, dead_buf, 0, mp->m_dirblksize - 1);
+	dead_info = dead_buf->b_addr;
 	/*
 	 * Get values from the moved block.
 	 */
@@ -1767,7 +1755,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 	if ((sib_blkno = be32_to_cpu(dead_info->back))) {
 		if ((error = xfs_da_read_buf(tp, ip, sib_blkno, -1, &sib_buf, w)))
 			goto done;
-		sib_info = sib_buf->data;
+		sib_info = sib_buf->b_addr;
 		if (unlikely(
 		    be32_to_cpu(sib_info->forw) != last_blkno ||
 		    sib_info->magic != dead_info->magic)) {
@@ -1777,10 +1765,9 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 			goto done;
 		}
 		sib_info->forw = cpu_to_be32(dead_blkno);
-		xfs_da_log_buf(tp, sib_buf,
+		xfs_trans_log_buf(tp, sib_buf,
 			XFS_DA_LOGRANGE(sib_info, &sib_info->forw,
 					sizeof(sib_info->forw)));
-		xfs_da_buf_done(sib_buf);
 		sib_buf = NULL;
 	}
 	/*
@@ -1789,7 +1776,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 	if ((sib_blkno = be32_to_cpu(dead_info->forw))) {
 		if ((error = xfs_da_read_buf(tp, ip, sib_blkno, -1, &sib_buf, w)))
 			goto done;
-		sib_info = sib_buf->data;
+		sib_info = sib_buf->b_addr;
 		if (unlikely(
 		       be32_to_cpu(sib_info->back) != last_blkno ||
 		       sib_info->magic != dead_info->magic)) {
@@ -1799,10 +1786,9 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 			goto done;
 		}
 		sib_info->back = cpu_to_be32(dead_blkno);
-		xfs_da_log_buf(tp, sib_buf,
+		xfs_trans_log_buf(tp, sib_buf,
 			XFS_DA_LOGRANGE(sib_info, &sib_info->back,
 					sizeof(sib_info->back)));
-		xfs_da_buf_done(sib_buf);
 		sib_buf = NULL;
 	}
 	par_blkno = mp->m_dirleafblk;
@@ -1813,7 +1799,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 	for (;;) {
 		if ((error = xfs_da_read_buf(tp, ip, par_blkno, -1, &par_buf, w)))
 			goto done;
-		par_node = par_buf->data;
+		par_node = par_buf->b_addr;
 		if (unlikely(par_node->hdr.info.magic !=
 		    cpu_to_be16(XFS_DA_NODE_MAGIC) ||
 		    (level >= 0 && level != be16_to_cpu(par_node->hdr.level) + 1))) {
@@ -1837,7 +1823,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 		par_blkno = be32_to_cpu(par_node->btree[entno].before);
 		if (level == dead_level + 1)
 			break;
-		xfs_da_brelse(tp, par_buf);
+		xfs_trans_brelse(tp, par_buf);
 		par_buf = NULL;
 	}
 	/*
@@ -1853,7 +1839,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 		if (entno < be16_to_cpu(par_node->hdr.count))
 			break;
 		par_blkno = be32_to_cpu(par_node->hdr.info.forw);
-		xfs_da_brelse(tp, par_buf);
+		xfs_trans_brelse(tp, par_buf);
 		par_buf = NULL;
 		if (unlikely(par_blkno == 0)) {
 			XFS_ERROR_REPORT("xfs_da_swap_lastblock(6)",
@@ -1863,7 +1849,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 		}
 		if ((error = xfs_da_read_buf(tp, ip, par_blkno, -1, &par_buf, w)))
 			goto done;
-		par_node = par_buf->data;
+		par_node = par_buf->b_addr;
 		if (unlikely(
 		    be16_to_cpu(par_node->hdr.level) != level ||
 		    par_node->hdr.info.magic != cpu_to_be16(XFS_DA_NODE_MAGIC))) {
@@ -1878,20 +1864,18 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
 	 * Update the parent entry pointing to the moved block.
 	 */
 	par_node->btree[entno].before = cpu_to_be32(dead_blkno);
-	xfs_da_log_buf(tp, par_buf,
+	xfs_trans_log_buf(tp, par_buf,
 		XFS_DA_LOGRANGE(par_node, &par_node->btree[entno].before,
 				sizeof(par_node->btree[entno].before)));
-	xfs_da_buf_done(par_buf);
-	xfs_da_buf_done(dead_buf);
 	*dead_blknop = last_blkno;
 	*dead_bufp = last_buf;
 	return 0;
 done:
 	if (par_buf)
-		xfs_da_brelse(tp, par_buf);
+		xfs_trans_brelse(tp, par_buf);
 	if (sib_buf)
-		xfs_da_brelse(tp, sib_buf);
-	xfs_da_brelse(tp, last_buf);
+		xfs_trans_brelse(tp, sib_buf);
+	xfs_trans_brelse(tp, last_buf);
 	return error;
 }
 
@@ -1899,8 +1883,10 @@ done:
  * Remove a btree block from a directory or attribute.
  */
 int
-xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
-		    xfs_dabuf_t *dead_buf)
+xfs_da_shrink_inode(
+	xfs_da_args_t	*args,
+	xfs_dablk_t	dead_blkno,
+	struct xfs_buf	*dead_buf)
 {
 	xfs_inode_t *dp;
 	int done, error, w, count;
@@ -1935,7 +1921,7 @@ xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
 			break;
 		}
 	}
-	xfs_da_binval(tp, dead_buf);
+	xfs_trans_binval(tp, dead_buf);
 	return error;
 }
 
@@ -2099,7 +2085,7 @@ xfs_da_get_buf(
 	struct xfs_inode	*dp,
 	xfs_dablk_t		bno,
 	xfs_daddr_t		mappedbno,
-	xfs_dabuf_t		**bpp,
+	struct xfs_buf		**bpp,
 	int			whichfork)
 {
 	struct xfs_buf		*bp;
@@ -2128,7 +2114,7 @@ xfs_da_get_buf(
 		goto out_free;
 	}
 
-	*bpp = xfs_da_buf_make(bp);
+	*bpp = bp;
 
 out_free:
 	if (mapp != &map)
@@ -2146,7 +2132,7 @@ xfs_da_read_buf(
 	struct xfs_inode	*dp,
 	xfs_dablk_t		bno,
 	xfs_daddr_t		mappedbno,
-	xfs_dabuf_t		**bpp,
+	struct xfs_buf		**bpp,
 	int			whichfork)
 {
 	struct xfs_buf		*bp;
@@ -2178,16 +2164,14 @@ xfs_da_read_buf(
 	else
 		xfs_buf_set_ref(bp, XFS_DIR_BTREE_REF);
 
-	*bpp = xfs_da_buf_make(bp);
-
 	/*
 	 * This verification code will be moved to a CRC verification callback
 	 * function so just leave it here unchanged until then.
 	 */
 	{
-		xfs_dir2_data_hdr_t	*hdr = (*bpp)->data;
-		xfs_dir2_free_t		*free = (*bpp)->data;
-		xfs_da_blkinfo_t	*info = (*bpp)->data;
+		xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
+		xfs_dir2_free_t		*free = bp->b_addr;
+		xfs_da_blkinfo_t	*info = bp->b_addr;
 		uint			magic, magic1;
 		struct xfs_mount	*mp = dp->i_mount;
 
@@ -2207,11 +2191,11 @@ xfs_da_read_buf(
 			XFS_CORRUPTION_ERROR("xfs_da_do_buf(2)",
 					     XFS_ERRLEVEL_LOW, mp, info);
 			error = XFS_ERROR(EFSCORRUPTED);
-			xfs_da_brelse(trans, *bpp);
+			xfs_trans_brelse(trans, bp);
 			goto out_free;
 		}
 	}
-
+	*bpp = bp;
 out_free:
 	if (mapp != &map)
 		kmem_free(mapp);
@@ -2259,7 +2243,6 @@ out_free:
 }
 
 kmem_zone_t *xfs_da_state_zone;	/* anchor for state struct zone */
-kmem_zone_t *xfs_dabuf_zone;		/* dabuf zone */
 
 /*
  * Allocate a dir-state structure.
@@ -2279,13 +2262,8 @@ xfs_da_state_kill_altpath(xfs_da_state_t *state)
 {
 	int	i;
 
-	for (i = 0; i < state->altpath.active; i++) {
-		if (state->altpath.blk[i].bp) {
-			if (state->altpath.blk[i].bp != state->path.blk[i].bp)
-				xfs_da_buf_done(state->altpath.blk[i].bp);
-			state->altpath.blk[i].bp = NULL;
-		}
-	}
+	for (i = 0; i < state->altpath.active; i++)
+		state->altpath.blk[i].bp = NULL;
 	state->altpath.active = 0;
 }
 
@@ -2295,88 +2273,9 @@ xfs_da_state_kill_altpath(xfs_da_state_t *state)
 void
 xfs_da_state_free(xfs_da_state_t *state)
 {
-	int	i;
-
 	xfs_da_state_kill_altpath(state);
-	for (i = 0; i < state->path.active; i++) {
-		if (state->path.blk[i].bp)
-			xfs_da_buf_done(state->path.blk[i].bp);
-	}
-	if (state->extravalid && state->extrablk.bp)
-		xfs_da_buf_done(state->extrablk.bp);
 #ifdef DEBUG
 	memset((char *)state, 0, sizeof(*state));
 #endif /* DEBUG */
 	kmem_zone_free(xfs_da_state_zone, state);
 }
-
-/*
- * Create a dabuf.
- */
-/* ARGSUSED */
-STATIC xfs_dabuf_t *
-xfs_da_buf_make(xfs_buf_t *bp)
-{
-	xfs_dabuf_t	*dabuf;
-
-	dabuf = kmem_zone_alloc(xfs_dabuf_zone, KM_NOFS);
-	dabuf->bbcount = bp->b_length;
-	dabuf->data = bp->b_addr;
-	dabuf->bp = bp;
-	return dabuf;
-}
-
-/*
- * Release a dabuf.
- */
-void
-xfs_da_buf_done(xfs_dabuf_t *dabuf)
-{
-	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
-	kmem_zone_free(xfs_dabuf_zone, dabuf);
-}
-
-/*
- * Log transaction from a dabuf.
- */
-void
-xfs_da_log_buf(xfs_trans_t *tp, xfs_dabuf_t *dabuf, uint first, uint last)
-{
-	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
-	ASSERT(dabuf->data == dabuf->bp->b_addr);
-	xfs_trans_log_buf(tp, dabuf->bp, first, last);
-}
-
-/*
- * Release dabuf from a transaction.
- * Have to free up the dabuf before the buffers are released,
- * since the synchronization on the dabuf is really the lock on the buffer.
- */
-void
-xfs_da_brelse(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
-{
-	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
-	xfs_trans_brelse(tp, dabuf->bp);
-	xfs_da_buf_done(dabuf);
-}
-
-/*
- * Invalidate dabuf from a transaction.
- */
-void
-xfs_da_binval(xfs_trans_t *tp, xfs_dabuf_t *dabuf)
-{
-	ASSERT(dabuf->data && dabuf->bbcount && dabuf->bp);
-	xfs_da_buf_done(dabuf);
-	xfs_trans_binval(tp, dabuf->bp);
-}
-
-/*
- * Get the first daddr from a dabuf.
- */
-xfs_daddr_t
-xfs_da_blkno(xfs_dabuf_t *dabuf)
-{
-	ASSERT(dabuf->data);
-	return XFS_BUF_ADDR(dabuf->bp);
-}
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h
index 0b64c4a..9f37aa0 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/xfs_da_btree.h
@@ -133,20 +133,6 @@ typedef struct xfs_da_args {
 	{ XFS_DA_OP_CILOOKUP,	"CILOOKUP" }
 
 /*
- * Structure to describe buffer(s) for a block.
- * This is needed in the directory version 2 format case, when
- * multiple non-contiguous fsblocks might be needed to cover one
- * logical directory block.
- * If the buffer count is 1 then the data pointer points to the
- * same place as the b_addr field for the buffer, else to kmem_alloced memory.
- */
-typedef struct xfs_dabuf {
-	short		bbcount;	/* how large is data in bbs */
-	void		*data;		/* pointer for buffers' data */
-	struct xfs_buf	*bp;		/* actually nbuf of these */
-} xfs_dabuf_t;
-
-/*
  * Storage for holding state during Btree searches and split/join ops.
  *
  * Only need space for 5 intermediate nodes.  With a minimum of 62-way
@@ -154,7 +140,7 @@ typedef struct xfs_dabuf {
  * which is slightly more than enough.
  */
 typedef struct xfs_da_state_blk {
-	xfs_dabuf_t	*bp;		/* buffer containing block */
+	struct xfs_buf	*bp;		/* buffer containing block */
 	xfs_dablk_t	blkno;		/* filesystem blkno of buffer */
 	xfs_daddr_t	disk_blkno;	/* on-disk blkno (in BBs) of buffer */
 	int		index;		/* relevant index into block */
@@ -207,7 +193,7 @@ struct xfs_nameops {
  * Routines used for growing the Btree.
  */
 int	xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level,
-					 xfs_dabuf_t **bpp, int whichfork);
+					 struct xfs_buf **bpp, int whichfork);
 int	xfs_da_split(xfs_da_state_t *state);
 
 /*
@@ -237,14 +223,14 @@ int	xfs_da_grow_inode_int(struct xfs_da_args *args, xfs_fileoff_t *bno,
 			      int count);
 int	xfs_da_get_buf(struct xfs_trans *trans, struct xfs_inode *dp,
 			      xfs_dablk_t bno, xfs_daddr_t mappedbno,
-			      xfs_dabuf_t **bp, int whichfork);
+			      struct xfs_buf **bp, int whichfork);
 int	xfs_da_read_buf(struct xfs_trans *trans, struct xfs_inode *dp,
 			       xfs_dablk_t bno, xfs_daddr_t mappedbno,
-			       xfs_dabuf_t **bpp, int whichfork);
+			       struct xfs_buf **bpp, int whichfork);
 xfs_daddr_t	xfs_da_reada_buf(struct xfs_trans *trans, struct xfs_inode *dp,
 			xfs_dablk_t bno, int whichfork);
 int	xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
-					  xfs_dabuf_t *dead_buf);
+					  struct xfs_buf *dead_buf);
 
 uint xfs_da_hashname(const __uint8_t *name_string, int name_length);
 enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args,
@@ -254,15 +240,7 @@ enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args,
 xfs_da_state_t *xfs_da_state_alloc(void);
 void xfs_da_state_free(xfs_da_state_t *state);
 
-void xfs_da_buf_done(xfs_dabuf_t *dabuf);
-void xfs_da_log_buf(struct xfs_trans *tp, xfs_dabuf_t *dabuf, uint first,
-			   uint last);
-void xfs_da_brelse(struct xfs_trans *tp, xfs_dabuf_t *dabuf);
-void xfs_da_binval(struct xfs_trans *tp, xfs_dabuf_t *dabuf);
-xfs_daddr_t xfs_da_blkno(xfs_dabuf_t *dabuf);
-
 extern struct kmem_zone *xfs_da_state_zone;
-extern struct kmem_zone *xfs_dabuf_zone;
 extern const struct xfs_nameops xfs_default_nameops;
 
 #endif	/* __XFS_DA_BTREE_H__ */
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 67a250c..b26a50f 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -592,7 +592,7 @@ int
 xfs_dir2_shrink_inode(
 	xfs_da_args_t	*args,
 	xfs_dir2_db_t	db,
-	xfs_dabuf_t	*bp)
+	struct xfs_buf	*bp)
 {
 	xfs_fileoff_t	bno;		/* directory file offset */
 	xfs_dablk_t	da;		/* directory file offset */
@@ -634,7 +634,7 @@ xfs_dir2_shrink_inode(
 	/*
 	 * Invalidate the buffer from the transaction.
 	 */
-	xfs_da_binval(tp, bp);
+	xfs_trans_binval(tp, bp);
 	/*
 	 * If it's not a data block, we're done.
 	 */
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 586732f..e93ca8f 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -37,10 +37,10 @@
 /*
  * Local function prototypes.
  */
-static void xfs_dir2_block_log_leaf(xfs_trans_t *tp, xfs_dabuf_t *bp, int first,
-				    int last);
-static void xfs_dir2_block_log_tail(xfs_trans_t *tp, xfs_dabuf_t *bp);
-static int xfs_dir2_block_lookup_int(xfs_da_args_t *args, xfs_dabuf_t **bpp,
+static void xfs_dir2_block_log_leaf(xfs_trans_t *tp, struct xfs_buf *bp,
+				    int first, int last);
+static void xfs_dir2_block_log_tail(xfs_trans_t *tp, struct xfs_buf *bp);
+static int xfs_dir2_block_lookup_int(xfs_da_args_t *args, struct xfs_buf **bpp,
 				     int *entno);
 static int xfs_dir2_block_sort(const void *a, const void *b);
 
@@ -66,7 +66,7 @@ xfs_dir2_block_addname(
 	xfs_dir2_data_free_t	*bf;		/* bestfree table in block */
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
 	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
-	xfs_dabuf_t		*bp;		/* buffer for block */
+	struct xfs_buf		*bp;		/* buffer for block */
 	xfs_dir2_block_tail_t	*btp;		/* block tail */
 	int			compact;	/* need to compact leaf ents */
 	xfs_dir2_data_entry_t	*dep;		/* block data entry */
@@ -102,14 +102,14 @@ xfs_dir2_block_addname(
 		return error;
 	}
 	ASSERT(bp != NULL);
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	/*
 	 * Check the magic number, corrupted if wrong.
 	 */
 	if (unlikely(hdr->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))) {
 		XFS_CORRUPTION_ERROR("xfs_dir2_block_addname",
 				     XFS_ERRLEVEL_LOW, mp, hdr);
-		xfs_da_brelse(tp, bp);
+		xfs_trans_brelse(tp, bp);
 		return XFS_ERROR(EFSCORRUPTED);
 	}
 	len = xfs_dir2_data_entsize(args->namelen);
@@ -212,7 +212,7 @@ xfs_dir2_block_addname(
 	 * If this isn't a real add, we're done with the buffer.
 	 */
 	if (args->op_flags & XFS_DA_OP_JUSTCHECK)
-		xfs_da_brelse(tp, bp);
+		xfs_trans_brelse(tp, bp);
 	/*
 	 * If we don't have space for the new entry & leaf ...
 	 */
@@ -228,7 +228,6 @@ xfs_dir2_block_addname(
 		 * Then add the new entry in that format.
 		 */
 		error = xfs_dir2_block_to_leaf(args, bp);
-		xfs_da_buf_done(bp);
 		if (error)
 			return error;
 		return xfs_dir2_leaf_addname(args);
@@ -422,7 +421,6 @@ xfs_dir2_block_addname(
 	xfs_dir2_block_log_tail(tp, bp);
 	xfs_dir2_data_log_entry(tp, bp, dep);
 	xfs_dir2_data_check(dp, bp);
-	xfs_da_buf_done(bp);
 	return 0;
 }
 
@@ -437,7 +435,7 @@ xfs_dir2_block_getdents(
 	filldir_t		filldir)
 {
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
-	xfs_dabuf_t		*bp;		/* buffer for block */
+	struct xfs_buf		*bp;		/* buffer for block */
 	xfs_dir2_block_tail_t	*btp;		/* block tail */
 	xfs_dir2_data_entry_t	*dep;		/* block data entry */
 	xfs_dir2_data_unused_t	*dup;		/* block unused entry */
@@ -469,7 +467,7 @@ xfs_dir2_block_getdents(
 	 * We'll skip entries before this.
 	 */
 	wantoff = xfs_dir2_dataptr_to_off(mp, *offset);
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	xfs_dir2_data_check(dp, bp);
 	/*
 	 * Set up values for the loop.
@@ -514,7 +512,7 @@ xfs_dir2_block_getdents(
 			    cook & 0x7fffffff, be64_to_cpu(dep->inumber),
 			    DT_UNKNOWN)) {
 			*offset = cook & 0x7fffffff;
-			xfs_da_brelse(NULL, bp);
+			xfs_trans_brelse(NULL, bp);
 			return 0;
 		}
 	}
@@ -525,7 +523,7 @@ xfs_dir2_block_getdents(
 	 */
 	*offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0) &
 			0x7fffffff;
-	xfs_da_brelse(NULL, bp);
+	xfs_trans_brelse(NULL, bp);
 	return 0;
 }
 
@@ -535,17 +533,17 @@ xfs_dir2_block_getdents(
 static void
 xfs_dir2_block_log_leaf(
 	xfs_trans_t		*tp,		/* transaction structure */
-	xfs_dabuf_t		*bp,		/* block buffer */
+	struct xfs_buf		*bp,		/* block buffer */
 	int			first,		/* index of first logged leaf */
 	int			last)		/* index of last logged leaf */
 {
-	xfs_dir2_data_hdr_t	*hdr = bp->data;
+	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
 	xfs_dir2_leaf_entry_t	*blp;
 	xfs_dir2_block_tail_t	*btp;
 
 	btp = xfs_dir2_block_tail_p(tp->t_mountp, hdr);
 	blp = xfs_dir2_block_leaf_p(btp);
-	xfs_da_log_buf(tp, bp, (uint)((char *)&blp[first] - (char *)hdr),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)&blp[first] - (char *)hdr),
 		(uint)((char *)&blp[last + 1] - (char *)hdr - 1));
 }
 
@@ -555,13 +553,13 @@ xfs_dir2_block_log_leaf(
 static void
 xfs_dir2_block_log_tail(
 	xfs_trans_t		*tp,		/* transaction structure */
-	xfs_dabuf_t		*bp)		/* block buffer */
+	struct xfs_buf		*bp)		/* block buffer */
 {
-	xfs_dir2_data_hdr_t	*hdr = bp->data;
+	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
 	xfs_dir2_block_tail_t	*btp;
 
 	btp = xfs_dir2_block_tail_p(tp->t_mountp, hdr);
-	xfs_da_log_buf(tp, bp, (uint)((char *)btp - (char *)hdr),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)btp - (char *)hdr),
 		(uint)((char *)(btp + 1) - (char *)hdr - 1));
 }
 
@@ -575,7 +573,7 @@ xfs_dir2_block_lookup(
 {
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
 	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
-	xfs_dabuf_t		*bp;		/* block buffer */
+	struct xfs_buf		*bp;		/* block buffer */
 	xfs_dir2_block_tail_t	*btp;		/* block tail */
 	xfs_dir2_data_entry_t	*dep;		/* block data entry */
 	xfs_inode_t		*dp;		/* incore inode */
@@ -593,7 +591,7 @@ xfs_dir2_block_lookup(
 		return error;
 	dp = args->dp;
 	mp = dp->i_mount;
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	xfs_dir2_data_check(dp, bp);
 	btp = xfs_dir2_block_tail_p(mp, hdr);
 	blp = xfs_dir2_block_leaf_p(btp);
@@ -607,7 +605,7 @@ xfs_dir2_block_lookup(
 	 */
 	args->inumber = be64_to_cpu(dep->inumber);
 	error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
-	xfs_da_brelse(args->trans, bp);
+	xfs_trans_brelse(args->trans, bp);
 	return XFS_ERROR(error);
 }
 
@@ -617,13 +615,13 @@ xfs_dir2_block_lookup(
 static int					/* error */
 xfs_dir2_block_lookup_int(
 	xfs_da_args_t		*args,		/* dir lookup arguments */
-	xfs_dabuf_t		**bpp,		/* returned block buffer */
+	struct xfs_buf		**bpp,		/* returned block buffer */
 	int			*entno)		/* returned entry number */
 {
 	xfs_dir2_dataptr_t	addr;		/* data entry address */
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
 	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
-	xfs_dabuf_t		*bp;		/* block buffer */
+	struct xfs_buf		*bp;		/* block buffer */
 	xfs_dir2_block_tail_t	*btp;		/* block tail */
 	xfs_dir2_data_entry_t	*dep;		/* block data entry */
 	xfs_inode_t		*dp;		/* incore inode */
@@ -647,7 +645,7 @@ xfs_dir2_block_lookup_int(
 		return error;
 	}
 	ASSERT(bp != NULL);
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	xfs_dir2_data_check(dp, bp);
 	btp = xfs_dir2_block_tail_p(mp, hdr);
 	blp = xfs_dir2_block_leaf_p(btp);
@@ -666,7 +664,7 @@ xfs_dir2_block_lookup_int(
 			high = mid - 1;
 		if (low > high) {
 			ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
-			xfs_da_brelse(tp, bp);
+			xfs_trans_brelse(tp, bp);
 			return XFS_ERROR(ENOENT);
 		}
 	}
@@ -714,7 +712,7 @@ xfs_dir2_block_lookup_int(
 	/*
 	 * No match, release the buffer and return ENOENT.
 	 */
-	xfs_da_brelse(tp, bp);
+	xfs_trans_brelse(tp, bp);
 	return XFS_ERROR(ENOENT);
 }
 
@@ -728,7 +726,7 @@ xfs_dir2_block_removename(
 {
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
 	xfs_dir2_leaf_entry_t	*blp;		/* block leaf pointer */
-	xfs_dabuf_t		*bp;		/* block buffer */
+	struct xfs_buf		*bp;		/* block buffer */
 	xfs_dir2_block_tail_t	*btp;		/* block tail */
 	xfs_dir2_data_entry_t	*dep;		/* block data entry */
 	xfs_inode_t		*dp;		/* incore inode */
@@ -753,7 +751,7 @@ xfs_dir2_block_removename(
 	dp = args->dp;
 	tp = args->trans;
 	mp = dp->i_mount;
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	btp = xfs_dir2_block_tail_p(mp, hdr);
 	blp = xfs_dir2_block_leaf_p(btp);
 	/*
@@ -790,10 +788,9 @@ xfs_dir2_block_removename(
 	 * See if the size as a shortform is good enough.
 	 */
 	size = xfs_dir2_block_sfsize(dp, hdr, &sfh);
-	if (size > XFS_IFORK_DSIZE(dp)) {
-		xfs_da_buf_done(bp);
+	if (size > XFS_IFORK_DSIZE(dp))
 		return 0;
-	}
+
 	/*
 	 * If it works, do the conversion.
 	 */
@@ -810,7 +807,7 @@ xfs_dir2_block_replace(
 {
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
 	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
-	xfs_dabuf_t		*bp;		/* block buffer */
+	struct xfs_buf		*bp;		/* block buffer */
 	xfs_dir2_block_tail_t	*btp;		/* block tail */
 	xfs_dir2_data_entry_t	*dep;		/* block data entry */
 	xfs_inode_t		*dp;		/* incore inode */
@@ -829,7 +826,7 @@ xfs_dir2_block_replace(
 	}
 	dp = args->dp;
 	mp = dp->i_mount;
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	btp = xfs_dir2_block_tail_p(mp, hdr);
 	blp = xfs_dir2_block_leaf_p(btp);
 	/*
@@ -844,7 +841,6 @@ xfs_dir2_block_replace(
 	dep->inumber = cpu_to_be64(args->inumber);
 	xfs_dir2_data_log_entry(args->trans, bp, dep);
 	xfs_dir2_data_check(dp, bp);
-	xfs_da_buf_done(bp);
 	return 0;
 }
 
@@ -871,8 +867,8 @@ xfs_dir2_block_sort(
 int						/* error */
 xfs_dir2_leaf_to_block(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		*lbp,		/* leaf buffer */
-	xfs_dabuf_t		*dbp)		/* data buffer */
+	struct xfs_buf		*lbp,		/* leaf buffer */
+	struct xfs_buf		*dbp)		/* data buffer */
 {
 	__be16			*bestsp;	/* leaf bests table */
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
@@ -898,7 +894,7 @@ xfs_dir2_leaf_to_block(
 	dp = args->dp;
 	tp = args->trans;
 	mp = dp->i_mount;
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC));
 	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 	/*
@@ -914,11 +910,9 @@ xfs_dir2_leaf_to_block(
 			if ((error =
 			    xfs_dir2_leaf_trim_data(args, lbp,
 				    (xfs_dir2_db_t)(be32_to_cpu(ltp->bestcount) - 1))))
-				goto out;
-		} else {
-			error = 0;
-			goto out;
-		}
+				return error;
+		} else
+			return 0;
 	}
 	/*
 	 * Read the data block if we don't already have it, give up if it fails.
@@ -926,9 +920,9 @@ xfs_dir2_leaf_to_block(
 	if (dbp == NULL &&
 	    (error = xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, &dbp,
 		    XFS_DATA_FORK))) {
-		goto out;
+		return error;
 	}
-	hdr = dbp->data;
+	hdr = dbp->b_addr;
 	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC));
 	/*
 	 * Size of the "leaf" area in the block.
@@ -944,10 +938,9 @@ xfs_dir2_leaf_to_block(
 	 * If it's not free or is too short we can't do it.
 	 */
 	if (be16_to_cpu(dup->freetag) != XFS_DIR2_DATA_FREE_TAG ||
-	    be16_to_cpu(dup->length) < size) {
-		error = 0;
-		goto out;
-	}
+	    be16_to_cpu(dup->length) < size)
+		return 0;
+
 	/*
 	 * Start converting it to block form.
 	 */
@@ -989,25 +982,17 @@ xfs_dir2_leaf_to_block(
 	 * Pitch the old leaf block.
 	 */
 	error = xfs_da_shrink_inode(args, mp->m_dirleafblk, lbp);
-	lbp = NULL;
-	if (error) {
-		goto out;
-	}
+	if (error)
+		return error;
+
 	/*
 	 * Now see if the resulting block can be shrunken to shortform.
 	 */
 	size = xfs_dir2_block_sfsize(dp, hdr, &sfh);
-	if (size > XFS_IFORK_DSIZE(dp)) {
-		error = 0;
-		goto out;
-	}
+	if (size > XFS_IFORK_DSIZE(dp))
+		return 0;
+
 	return xfs_dir2_block_to_sf(args, dbp, size, &sfh);
-out:
-	if (lbp)
-		xfs_da_buf_done(lbp);
-	if (dbp)
-		xfs_da_buf_done(dbp);
-	return error;
 }
 
 /*
@@ -1020,7 +1005,7 @@ xfs_dir2_sf_to_block(
 	xfs_dir2_db_t		blkno;		/* dir-relative block # (0) */
 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
 	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
-	xfs_dabuf_t		*bp;		/* block buffer */
+	struct xfs_buf		*bp;		/* block buffer */
 	xfs_dir2_block_tail_t	*btp;		/* block tail pointer */
 	xfs_dir2_data_entry_t	*dep;		/* data entry pointer */
 	xfs_inode_t		*dp;		/* incore directory inode */
@@ -1088,7 +1073,7 @@ xfs_dir2_sf_to_block(
 		kmem_free(sfp);
 		return error;
 	}
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	hdr->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
 	/*
 	 * Compute size of block "tail" area.
@@ -1217,6 +1202,5 @@ xfs_dir2_sf_to_block(
 	xfs_dir2_block_log_leaf(tp, bp, 0, be32_to_cpu(btp->count) - 1);
 	xfs_dir2_block_log_tail(tp, bp);
 	xfs_dir2_data_check(dp, bp);
-	xfs_da_buf_done(bp);
 	return 0;
 }
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index 2046988..44ffd4d 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -42,8 +42,8 @@ xfs_dir2_data_freefind(xfs_dir2_data_hdr_t *hdr, xfs_dir2_data_unused_t *dup);
  */
 void
 xfs_dir2_data_check(
-	xfs_inode_t		*dp,		/* incore inode pointer */
-	xfs_dabuf_t		*bp)		/* data block's buffer */
+	struct xfs_inode	*dp,		/* incore inode pointer */
+	struct xfs_buf		*bp)		/* data block's buffer */
 {
 	xfs_dir2_dataptr_t	addr;		/* addr for leaf lookup */
 	xfs_dir2_data_free_t	*bf;		/* bestfree table */
@@ -65,7 +65,7 @@ xfs_dir2_data_check(
 	struct xfs_name		name;
 
 	mp = dp->i_mount;
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	bf = hdr->bestfree;
 	p = (char *)(hdr + 1);
 
@@ -389,9 +389,9 @@ int						/* error */
 xfs_dir2_data_init(
 	xfs_da_args_t		*args,		/* directory operation args */
 	xfs_dir2_db_t		blkno,		/* logical dir block number */
-	xfs_dabuf_t		**bpp)		/* output block buffer */
+	struct xfs_buf		**bpp)		/* output block buffer */
 {
-	xfs_dabuf_t		*bp;		/* block buffer */
+	struct xfs_buf		*bp;		/* block buffer */
 	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	xfs_dir2_data_unused_t	*dup;		/* unused entry pointer */
@@ -417,7 +417,7 @@ xfs_dir2_data_init(
 	/*
 	 * Initialize the header.
 	 */
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
 	hdr->bestfree[0].offset = cpu_to_be16(sizeof(*hdr));
 	for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
@@ -449,16 +449,16 @@ xfs_dir2_data_init(
  */
 void
 xfs_dir2_data_log_entry(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp,		/* block buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp,
 	xfs_dir2_data_entry_t	*dep)		/* data entry pointer */
 {
-	xfs_dir2_data_hdr_t	*hdr = bp->data;
+	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
 
 	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC));
 
-	xfs_da_log_buf(tp, bp, (uint)((char *)dep - (char *)hdr),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)dep - (char *)hdr),
 		(uint)((char *)(xfs_dir2_data_entry_tag_p(dep) + 1) -
 		       (char *)hdr - 1));
 }
@@ -468,15 +468,15 @@ xfs_dir2_data_log_entry(
  */
 void
 xfs_dir2_data_log_header(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp)		/* block buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp)
 {
-	xfs_dir2_data_hdr_t	*hdr = bp->data;
+	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
 
 	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC));
 
-	xfs_da_log_buf(tp, bp, 0, sizeof(*hdr) - 1);
+	xfs_trans_log_buf(tp, bp, 0, sizeof(*hdr) - 1);
 }
 
 /*
@@ -484,11 +484,11 @@ xfs_dir2_data_log_header(
  */
 void
 xfs_dir2_data_log_unused(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp,		/* block buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp,
 	xfs_dir2_data_unused_t	*dup)		/* data unused pointer */
 {
-	xfs_dir2_data_hdr_t	*hdr = bp->data;
+	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
 
 	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC));
@@ -496,13 +496,13 @@ xfs_dir2_data_log_unused(
 	/*
 	 * Log the first part of the unused entry.
 	 */
-	xfs_da_log_buf(tp, bp, (uint)((char *)dup - (char *)hdr),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)dup - (char *)hdr),
 		(uint)((char *)&dup->length + sizeof(dup->length) -
 		       1 - (char *)hdr));
 	/*
 	 * Log the end (tag) of the unused entry.
 	 */
-	xfs_da_log_buf(tp, bp,
+	xfs_trans_log_buf(tp, bp,
 		(uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr),
 		(uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr +
 		       sizeof(xfs_dir2_data_off_t) - 1));
@@ -514,8 +514,8 @@ xfs_dir2_data_log_unused(
  */
 void
 xfs_dir2_data_make_free(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp,		/* block buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp,
 	xfs_dir2_data_aoff_t	offset,		/* starting byte offset */
 	xfs_dir2_data_aoff_t	len,		/* length in bytes */
 	int			*needlogp,	/* out: log header */
@@ -531,7 +531,7 @@ xfs_dir2_data_make_free(
 	xfs_dir2_data_unused_t	*prevdup;	/* unused entry before us */
 
 	mp = tp->t_mountp;
-	hdr = bp->data;
+	hdr = bp->b_addr;
 
 	/*
 	 * Figure out where the end of the data area is.
@@ -696,8 +696,8 @@ xfs_dir2_data_make_free(
  */
 void
 xfs_dir2_data_use_free(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp,		/* data block buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp,
 	xfs_dir2_data_unused_t	*dup,		/* unused entry */
 	xfs_dir2_data_aoff_t	offset,		/* starting offset to use */
 	xfs_dir2_data_aoff_t	len,		/* length to use */
@@ -713,7 +713,7 @@ xfs_dir2_data_use_free(
 	xfs_dir2_data_unused_t	*newdup2;	/* another new unused entry */
 	int			oldlen;		/* old unused entry's length */
 
-	hdr = bp->data;
+	hdr = bp->b_addr;
 	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC));
 	ASSERT(be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG);
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index 397ffbc..69accf6 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -38,15 +38,15 @@
  * Local function declarations.
  */
 #ifdef DEBUG
-static void xfs_dir2_leaf_check(xfs_inode_t *dp, xfs_dabuf_t *bp);
+static void xfs_dir2_leaf_check(struct xfs_inode *dp, struct xfs_buf *bp);
 #else
 #define	xfs_dir2_leaf_check(dp, bp)
 #endif
-static int xfs_dir2_leaf_lookup_int(xfs_da_args_t *args, xfs_dabuf_t **lbpp,
-				    int *indexp, xfs_dabuf_t **dbpp);
-static void xfs_dir2_leaf_log_bests(struct xfs_trans *tp, struct xfs_dabuf *bp,
+static int xfs_dir2_leaf_lookup_int(xfs_da_args_t *args, struct xfs_buf **lbpp,
+				    int *indexp, struct xfs_buf **dbpp);
+static void xfs_dir2_leaf_log_bests(struct xfs_trans *tp, struct xfs_buf *bp,
 				    int first, int last);
-static void xfs_dir2_leaf_log_tail(struct xfs_trans *tp, struct xfs_dabuf *bp);
+static void xfs_dir2_leaf_log_tail(struct xfs_trans *tp, struct xfs_buf *bp);
 
 
 /*
@@ -55,7 +55,7 @@ static void xfs_dir2_leaf_log_tail(struct xfs_trans *tp, struct xfs_dabuf *bp);
 int						/* error */
 xfs_dir2_block_to_leaf(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		*dbp)		/* input block's buffer */
+	struct xfs_buf		*dbp)		/* input block's buffer */
 {
 	__be16			*bestsp;	/* leaf's bestsp entries */
 	xfs_dablk_t		blkno;		/* leaf block's bno */
@@ -64,7 +64,7 @@ xfs_dir2_block_to_leaf(
 	xfs_dir2_block_tail_t	*btp;		/* block's tail */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
-	xfs_dabuf_t		*lbp;		/* leaf block's buffer */
+	struct xfs_buf		*lbp;		/* leaf block's buffer */
 	xfs_dir2_db_t		ldb;		/* leaf block's bno */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_dir2_leaf_tail_t	*ltp;		/* leaf's tail */
@@ -95,8 +95,8 @@ xfs_dir2_block_to_leaf(
 		return error;
 	}
 	ASSERT(lbp != NULL);
-	leaf = lbp->data;
-	hdr = dbp->data;
+	leaf = lbp->b_addr;
+	hdr = dbp->b_addr;
 	xfs_dir2_data_check(dp, dbp);
 	btp = xfs_dir2_block_tail_p(mp, hdr);
 	blp = xfs_dir2_block_leaf_p(btp);
@@ -143,7 +143,6 @@ xfs_dir2_block_to_leaf(
 	xfs_dir2_leaf_check(dp, lbp);
 	xfs_dir2_data_check(dp, dbp);
 	xfs_dir2_leaf_log_bests(tp, lbp, 0, 0);
-	xfs_da_buf_done(lbp);
 	return 0;
 }
 
@@ -282,7 +281,7 @@ xfs_dir2_leaf_addname(
 	__be16			*bestsp;	/* freespace table in leaf */
 	int			compact;	/* need to compact leaves */
 	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
-	xfs_dabuf_t		*dbp;		/* data block buffer */
+	struct xfs_buf		*dbp;		/* data block buffer */
 	xfs_dir2_data_entry_t	*dep;		/* data block entry */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	xfs_dir2_data_unused_t	*dup;		/* data unused entry */
@@ -291,7 +290,7 @@ xfs_dir2_leaf_addname(
 	int			highstale;	/* index of next stale leaf */
 	int			i;		/* temporary, index */
 	int			index;		/* leaf table position */
-	xfs_dabuf_t		*lbp;		/* leaf's buffer */
+	struct xfs_buf		*lbp;		/* leaf's buffer */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	int			length;		/* length of new entry */
 	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry table pointer */
@@ -328,7 +327,7 @@ xfs_dir2_leaf_addname(
 	 * But if there are dup hash values the index is of the first of those.
 	 */
 	index = xfs_dir2_leaf_search_hash(args, lbp);
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 	bestsp = xfs_dir2_leaf_bests_p(ltp);
 	length = xfs_dir2_data_entsize(args->namelen);
@@ -402,14 +401,13 @@ xfs_dir2_leaf_addname(
 		 */
 		if ((args->op_flags & XFS_DA_OP_JUSTCHECK) ||
 							args->total == 0) {
-			xfs_da_brelse(tp, lbp);
+			xfs_trans_brelse(tp, lbp);
 			return XFS_ERROR(ENOSPC);
 		}
 		/*
 		 * Convert to node form.
 		 */
 		error = xfs_dir2_leaf_to_node(args, lbp);
-		xfs_da_buf_done(lbp);
 		if (error)
 			return error;
 		/*
@@ -427,7 +425,7 @@ xfs_dir2_leaf_addname(
 	 * a new data block.
 	 */
 	if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
-		xfs_da_brelse(tp, lbp);
+		xfs_trans_brelse(tp, lbp);
 		return use_block == -1 ? XFS_ERROR(ENOSPC) : 0;
 	}
 	/*
@@ -435,7 +433,7 @@ xfs_dir2_leaf_addname(
 	 * changed anything.
 	 */
 	if (args->total == 0 && use_block == -1) {
-		xfs_da_brelse(tp, lbp);
+		xfs_trans_brelse(tp, lbp);
 		return XFS_ERROR(ENOSPC);
 	}
 	/*
@@ -466,14 +464,14 @@ xfs_dir2_leaf_addname(
 		 */
 		if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_DATA_SPACE,
 				&use_block))) {
-			xfs_da_brelse(tp, lbp);
+			xfs_trans_brelse(tp, lbp);
 			return error;
 		}
 		/*
 		 * Initialize the block.
 		 */
 		if ((error = xfs_dir2_data_init(args, use_block, &dbp))) {
-			xfs_da_brelse(tp, lbp);
+			xfs_trans_brelse(tp, lbp);
 			return error;
 		}
 		/*
@@ -493,7 +491,7 @@ xfs_dir2_leaf_addname(
 		 */
 		else
 			xfs_dir2_leaf_log_bests(tp, lbp, use_block, use_block);
-		hdr = dbp->data;
+		hdr = dbp->b_addr;
 		bestsp[use_block] = hdr->bestfree[0].length;
 		grown = 1;
 	}
@@ -505,10 +503,10 @@ xfs_dir2_leaf_addname(
 		if ((error =
 		    xfs_da_read_buf(tp, dp, xfs_dir2_db_to_da(mp, use_block),
 			    -1, &dbp, XFS_DATA_FORK))) {
-			xfs_da_brelse(tp, lbp);
+			xfs_trans_brelse(tp, lbp);
 			return error;
 		}
-		hdr = dbp->data;
+		hdr = dbp->b_addr;
 		grown = 0;
 	}
 	xfs_dir2_data_check(dp, dbp);
@@ -570,9 +568,7 @@ xfs_dir2_leaf_addname(
 	xfs_dir2_leaf_log_header(tp, lbp);
 	xfs_dir2_leaf_log_ents(tp, lbp, lfloglow, lfloghigh);
 	xfs_dir2_leaf_check(dp, lbp);
-	xfs_da_buf_done(lbp);
 	xfs_dir2_data_check(dp, dbp);
-	xfs_da_buf_done(dbp);
 	return 0;
 }
 
@@ -583,8 +579,8 @@ xfs_dir2_leaf_addname(
  */
 STATIC void
 xfs_dir2_leaf_check(
-	xfs_inode_t		*dp,		/* incore directory inode */
-	xfs_dabuf_t		*bp)		/* leaf's buffer */
+	struct xfs_inode	*dp,		/* incore directory inode */
+	struct xfs_buf		*bp)		/* leaf's buffer */
 {
 	int			i;		/* leaf index */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
@@ -592,7 +588,7 @@ xfs_dir2_leaf_check(
 	xfs_mount_t		*mp;		/* filesystem mount point */
 	int			stale;		/* count of stale leaves */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	mp = dp->i_mount;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC));
 	/*
@@ -628,14 +624,14 @@ xfs_dir2_leaf_check(
 void
 xfs_dir2_leaf_compact(
 	xfs_da_args_t	*args,		/* operation arguments */
-	xfs_dabuf_t	*bp)		/* leaf buffer */
+	struct xfs_buf	*bp)		/* leaf buffer */
 {
 	int		from;		/* source leaf index */
 	xfs_dir2_leaf_t	*leaf;		/* leaf structure */
 	int		loglow;		/* first leaf entry to log */
 	int		to;		/* target leaf index */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	if (!leaf->hdr.stale) {
 		return;
 	}
@@ -677,7 +673,7 @@ xfs_dir2_leaf_compact(
  */
 void
 xfs_dir2_leaf_compact_x1(
-	xfs_dabuf_t	*bp,		/* leaf buffer */
+	struct xfs_buf	*bp,		/* leaf buffer */
 	int		*indexp,	/* insertion index */
 	int		*lowstalep,	/* out: stale entry before us */
 	int		*highstalep,	/* out: stale entry after us */
@@ -693,7 +689,7 @@ xfs_dir2_leaf_compact_x1(
 	int		newindex=0;	/* new insertion index */
 	int		to;		/* destination copy index */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(be16_to_cpu(leaf->hdr.stale) > 1);
 	index = *indexp;
 
@@ -775,7 +771,7 @@ xfs_dir2_leaf_getdents(
 	xfs_off_t		*offset,
 	filldir_t		filldir)
 {
-	xfs_dabuf_t		*bp;		/* data block buffer */
+	struct xfs_buf		*bp;		/* data block buffer */
 	int			byteoff;	/* offset in current block */
 	xfs_dir2_db_t		curdb;		/* db for current block */
 	xfs_dir2_off_t		curoff;		/* current overall offset */
@@ -839,13 +835,13 @@ xfs_dir2_leaf_getdents(
 		 * If we have no buffer, or we're off the end of the
 		 * current buffer, need to get another one.
 		 */
-		if (!bp || ptr >= (char *)bp->data + mp->m_dirblksize) {
+		if (!bp || ptr >= (char *)bp->b_addr + mp->m_dirblksize) {
 			/*
 			 * If we have a buffer, we need to release it and
 			 * take it out of the mapping.
 			 */
 			if (bp) {
-				xfs_da_brelse(NULL, bp);
+				xfs_trans_brelse(NULL, bp);
 				bp = NULL;
 				map_blocks -= mp->m_dirblkfsbs;
 				/*
@@ -1035,7 +1031,7 @@ xfs_dir2_leaf_getdents(
 			else if (curoff > newoff)
 				ASSERT(xfs_dir2_byte_to_db(mp, curoff) ==
 				       curdb);
-			hdr = bp->data;
+			hdr = bp->b_addr;
 			xfs_dir2_data_check(dp, bp);
 			/*
 			 * Find our position in the block.
@@ -1119,7 +1115,7 @@ xfs_dir2_leaf_getdents(
 		*offset = xfs_dir2_byte_to_dataptr(mp, curoff) & 0x7fffffff;
 	kmem_free(map);
 	if (bp)
-		xfs_da_brelse(NULL, bp);
+		xfs_trans_brelse(NULL, bp);
 	return error;
 }
 
@@ -1130,10 +1126,10 @@ int
 xfs_dir2_leaf_init(
 	xfs_da_args_t		*args,		/* operation arguments */
 	xfs_dir2_db_t		bno,		/* directory block number */
-	xfs_dabuf_t		**bpp,		/* out: leaf buffer */
+	struct xfs_buf		**bpp,		/* out: leaf buffer */
 	int			magic)		/* magic number for block */
 {
-	xfs_dabuf_t		*bp;		/* leaf buffer */
+	struct xfs_buf		*bp;		/* leaf buffer */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
@@ -1156,7 +1152,7 @@ xfs_dir2_leaf_init(
 		return error;
 	}
 	ASSERT(bp != NULL);
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	/*
 	 * Initialize the header.
 	 */
@@ -1186,7 +1182,7 @@ xfs_dir2_leaf_init(
 static void
 xfs_dir2_leaf_log_bests(
 	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp,		/* leaf buffer */
+	struct xfs_buf		*bp,		/* leaf buffer */
 	int			first,		/* first entry to log */
 	int			last)		/* last entry to log */
 {
@@ -1195,12 +1191,12 @@ xfs_dir2_leaf_log_bests(
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC));
 	ltp = xfs_dir2_leaf_tail_p(tp->t_mountp, leaf);
 	firstb = xfs_dir2_leaf_bests_p(ltp) + first;
 	lastb = xfs_dir2_leaf_bests_p(ltp) + last;
-	xfs_da_log_buf(tp, bp, (uint)((char *)firstb - (char *)leaf),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)firstb - (char *)leaf),
 		(uint)((char *)lastb - (char *)leaf + sizeof(*lastb) - 1));
 }
 
@@ -1210,7 +1206,7 @@ xfs_dir2_leaf_log_bests(
 void
 xfs_dir2_leaf_log_ents(
 	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp,		/* leaf buffer */
+	struct xfs_buf		*bp,		/* leaf buffer */
 	int			first,		/* first entry to log */
 	int			last)		/* last entry to log */
 {
@@ -1218,12 +1214,12 @@ xfs_dir2_leaf_log_ents(
 	xfs_dir2_leaf_entry_t	*lastlep;	/* pointer to last entry */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
 	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	firstlep = &leaf->ents[first];
 	lastlep = &leaf->ents[last];
-	xfs_da_log_buf(tp, bp, (uint)((char *)firstlep - (char *)leaf),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)firstlep - (char *)leaf),
 		(uint)((char *)lastlep - (char *)leaf + sizeof(*lastlep) - 1));
 }
 
@@ -1232,15 +1228,15 @@ xfs_dir2_leaf_log_ents(
  */
 void
 xfs_dir2_leaf_log_header(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp)		/* leaf buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp)
 {
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
 	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
-	xfs_da_log_buf(tp, bp, (uint)((char *)&leaf->hdr - (char *)leaf),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)&leaf->hdr - (char *)leaf),
 		(uint)(sizeof(leaf->hdr) - 1));
 }
 
@@ -1249,18 +1245,18 @@ xfs_dir2_leaf_log_header(
  */
 STATIC void
 xfs_dir2_leaf_log_tail(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp)		/* leaf buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp)
 {
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
 	xfs_mount_t		*mp;		/* filesystem mount point */
 
 	mp = tp->t_mountp;
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC));
 	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
-	xfs_da_log_buf(tp, bp, (uint)((char *)ltp - (char *)leaf),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)ltp - (char *)leaf),
 		(uint)(mp->m_dirblksize - 1));
 }
 
@@ -1273,12 +1269,12 @@ int
 xfs_dir2_leaf_lookup(
 	xfs_da_args_t		*args)		/* operation arguments */
 {
-	xfs_dabuf_t		*dbp;		/* data block buffer */
+	struct xfs_buf		*dbp;		/* data block buffer */
 	xfs_dir2_data_entry_t	*dep;		/* data block entry */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
 	int			index;		/* found entry index */
-	xfs_dabuf_t		*lbp;		/* leaf buffer */
+	struct xfs_buf		*lbp;		/* leaf buffer */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
 	xfs_trans_t		*tp;		/* transaction pointer */
@@ -1294,7 +1290,7 @@ xfs_dir2_leaf_lookup(
 	tp = args->trans;
 	dp = args->dp;
 	xfs_dir2_leaf_check(dp, lbp);
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 	/*
 	 * Get to the leaf entry and contained data entry address.
 	 */
@@ -1303,15 +1299,15 @@ xfs_dir2_leaf_lookup(
 	 * Point to the data entry.
 	 */
 	dep = (xfs_dir2_data_entry_t *)
-	      ((char *)dbp->data +
+	      ((char *)dbp->b_addr +
 	       xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
 	/*
 	 * Return the found inode number & CI name if appropriate
 	 */
 	args->inumber = be64_to_cpu(dep->inumber);
 	error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
-	xfs_da_brelse(tp, dbp);
-	xfs_da_brelse(tp, lbp);
+	xfs_trans_brelse(tp, dbp);
+	xfs_trans_brelse(tp, lbp);
 	return XFS_ERROR(error);
 }
 
@@ -1324,17 +1320,17 @@ xfs_dir2_leaf_lookup(
 static int					/* error */
 xfs_dir2_leaf_lookup_int(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		**lbpp,		/* out: leaf buffer */
+	struct xfs_buf		**lbpp,		/* out: leaf buffer */
 	int			*indexp,	/* out: index in leaf block */
-	xfs_dabuf_t		**dbpp)		/* out: data buffer */
+	struct xfs_buf		**dbpp)		/* out: data buffer */
 {
 	xfs_dir2_db_t		curdb = -1;	/* current data block number */
-	xfs_dabuf_t		*dbp = NULL;	/* data buffer */
+	struct xfs_buf		*dbp = NULL;	/* data buffer */
 	xfs_dir2_data_entry_t	*dep;		/* data entry */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
 	int			index;		/* index in leaf block */
-	xfs_dabuf_t		*lbp;		/* leaf buffer */
+	struct xfs_buf		*lbp;		/* leaf buffer */
 	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_mount_t		*mp;		/* filesystem mount point */
@@ -1354,7 +1350,7 @@ xfs_dir2_leaf_lookup_int(
 	if (error)
 		return error;
 	*lbpp = lbp;
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 	xfs_dir2_leaf_check(dp, lbp);
 	/*
 	 * Look for the first leaf entry with our hash value.
@@ -1382,12 +1378,12 @@ xfs_dir2_leaf_lookup_int(
 		 */
 		if (newdb != curdb) {
 			if (dbp)
-				xfs_da_brelse(tp, dbp);
+				xfs_trans_brelse(tp, dbp);
 			error = xfs_da_read_buf(tp, dp,
 						xfs_dir2_db_to_da(mp, newdb),
 						-1, &dbp, XFS_DATA_FORK);
 			if (error) {
-				xfs_da_brelse(tp, lbp);
+				xfs_trans_brelse(tp, lbp);
 				return error;
 			}
 			xfs_dir2_data_check(dp, dbp);
@@ -1396,7 +1392,7 @@ xfs_dir2_leaf_lookup_int(
 		/*
 		 * Point to the data entry.
 		 */
-		dep = (xfs_dir2_data_entry_t *)((char *)dbp->data +
+		dep = (xfs_dir2_data_entry_t *)((char *)dbp->b_addr +
 			xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
 		/*
 		 * Compare name and if it's an exact match, return the index
@@ -1424,12 +1420,12 @@ xfs_dir2_leaf_lookup_int(
 	if (args->cmpresult == XFS_CMP_CASE) {
 		ASSERT(cidb != -1);
 		if (cidb != curdb) {
-			xfs_da_brelse(tp, dbp);
+			xfs_trans_brelse(tp, dbp);
 			error = xfs_da_read_buf(tp, dp,
 						xfs_dir2_db_to_da(mp, cidb),
 						-1, &dbp, XFS_DATA_FORK);
 			if (error) {
-				xfs_da_brelse(tp, lbp);
+				xfs_trans_brelse(tp, lbp);
 				return error;
 			}
 		}
@@ -1441,8 +1437,8 @@ xfs_dir2_leaf_lookup_int(
 	 */
 	ASSERT(cidb == -1);
 	if (dbp)
-		xfs_da_brelse(tp, dbp);
-	xfs_da_brelse(tp, lbp);
+		xfs_trans_brelse(tp, dbp);
+	xfs_trans_brelse(tp, lbp);
 	return XFS_ERROR(ENOENT);
 }
 
@@ -1456,13 +1452,13 @@ xfs_dir2_leaf_removename(
 	__be16			*bestsp;	/* leaf block best freespace */
 	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
 	xfs_dir2_db_t		db;		/* data block number */
-	xfs_dabuf_t		*dbp;		/* data block buffer */
+	struct xfs_buf		*dbp;		/* data block buffer */
 	xfs_dir2_data_entry_t	*dep;		/* data entry structure */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
 	xfs_dir2_db_t		i;		/* temporary data block # */
 	int			index;		/* index into leaf entries */
-	xfs_dabuf_t		*lbp;		/* leaf buffer */
+	struct xfs_buf		*lbp;		/* leaf buffer */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
 	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
@@ -1483,8 +1479,8 @@ xfs_dir2_leaf_removename(
 	dp = args->dp;
 	tp = args->trans;
 	mp = dp->i_mount;
-	leaf = lbp->data;
-	hdr = dbp->data;
+	leaf = lbp->b_addr;
+	hdr = dbp->b_addr;
 	xfs_dir2_data_check(dp, dbp);
 	/*
 	 * Point to the leaf entry, use that to point to the data entry.
@@ -1541,12 +1537,9 @@ xfs_dir2_leaf_removename(
 			 * Just go on, returning success, leaving the
 			 * empty block in place.
 			 */
-			if (error == ENOSPC && args->total == 0) {
-				xfs_da_buf_done(dbp);
+			if (error == ENOSPC && args->total == 0)
 				error = 0;
-			}
 			xfs_dir2_leaf_check(dp, lbp);
-			xfs_da_buf_done(lbp);
 			return error;
 		}
 		dbp = NULL;
@@ -1577,10 +1570,9 @@ xfs_dir2_leaf_removename(
 	/*
 	 * If the data block was not the first one, drop it.
 	 */
-	else if (db != mp->m_dirdatablk && dbp != NULL) {
-		xfs_da_buf_done(dbp);
+	else if (db != mp->m_dirdatablk)
 		dbp = NULL;
-	}
+
 	xfs_dir2_leaf_check(dp, lbp);
 	/*
 	 * See if we can convert to block form.
@@ -1595,12 +1587,12 @@ int						/* error */
 xfs_dir2_leaf_replace(
 	xfs_da_args_t		*args)		/* operation arguments */
 {
-	xfs_dabuf_t		*dbp;		/* data block buffer */
+	struct xfs_buf		*dbp;		/* data block buffer */
 	xfs_dir2_data_entry_t	*dep;		/* data block entry */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
 	int			index;		/* index of leaf entry */
-	xfs_dabuf_t		*lbp;		/* leaf buffer */
+	struct xfs_buf		*lbp;		/* leaf buffer */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
 	xfs_trans_t		*tp;		/* transaction pointer */
@@ -1614,7 +1606,7 @@ xfs_dir2_leaf_replace(
 		return error;
 	}
 	dp = args->dp;
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 	/*
 	 * Point to the leaf entry, get data address from it.
 	 */
@@ -1623,7 +1615,7 @@ xfs_dir2_leaf_replace(
 	 * Point to the data entry.
 	 */
 	dep = (xfs_dir2_data_entry_t *)
-	      ((char *)dbp->data +
+	      ((char *)dbp->b_addr +
 	       xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
 	ASSERT(args->inumber != be64_to_cpu(dep->inumber));
 	/*
@@ -1632,9 +1624,8 @@ xfs_dir2_leaf_replace(
 	dep->inumber = cpu_to_be64(args->inumber);
 	tp = args->trans;
 	xfs_dir2_data_log_entry(tp, dbp, dep);
-	xfs_da_buf_done(dbp);
 	xfs_dir2_leaf_check(dp, lbp);
-	xfs_da_brelse(tp, lbp);
+	xfs_trans_brelse(tp, lbp);
 	return 0;
 }
 
@@ -1646,7 +1637,7 @@ xfs_dir2_leaf_replace(
 int						/* index value */
 xfs_dir2_leaf_search_hash(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		*lbp)		/* leaf buffer */
+	struct xfs_buf		*lbp)		/* leaf buffer */
 {
 	xfs_dahash_t		hash=0;		/* hash from this entry */
 	xfs_dahash_t		hashwant;	/* hash value looking for */
@@ -1656,7 +1647,7 @@ xfs_dir2_leaf_search_hash(
 	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
 	int			mid=0;		/* current leaf index */
 
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 #ifndef __KERNEL__
 	if (!leaf->hdr.count)
 		return 0;
@@ -1699,11 +1690,11 @@ xfs_dir2_leaf_search_hash(
 int						/* error */
 xfs_dir2_leaf_trim_data(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		*lbp,		/* leaf buffer */
+	struct xfs_buf		*lbp,		/* leaf buffer */
 	xfs_dir2_db_t		db)		/* data block number */
 {
 	__be16			*bestsp;	/* leaf bests table */
-	xfs_dabuf_t		*dbp;		/* data block buffer */
+	struct xfs_buf		*dbp;		/* data block buffer */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return value */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
@@ -1722,12 +1713,12 @@ xfs_dir2_leaf_trim_data(
 		return error;
 	}
 
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 
 #ifdef DEBUG
 {
-	struct xfs_dir2_data_hdr *hdr = dbp->data;
+	struct xfs_dir2_data_hdr *hdr = dbp->b_addr;
 
 	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC));
 	ASSERT(be16_to_cpu(hdr->bestfree[0].length) ==
@@ -1741,7 +1732,7 @@ xfs_dir2_leaf_trim_data(
 	 */
 	if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
 		ASSERT(error != ENOSPC);
-		xfs_da_brelse(tp, dbp);
+		xfs_trans_brelse(tp, dbp);
 		return error;
 	}
 	/*
@@ -1781,10 +1772,10 @@ xfs_dir2_node_to_leaf(
 	xfs_da_args_t		*args;		/* operation arguments */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
-	xfs_dabuf_t		*fbp;		/* buffer for freespace block */
+	struct xfs_buf		*fbp;		/* buffer for freespace block */
 	xfs_fileoff_t		fo;		/* freespace file offset */
 	xfs_dir2_free_t		*free;		/* freespace structure */
-	xfs_dabuf_t		*lbp;		/* buffer for leaf block */
+	struct xfs_buf		*lbp;		/* buffer for leaf block */
 	xfs_dir2_leaf_tail_t	*ltp;		/* tail of leaf structure */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 	xfs_mount_t		*mp;		/* filesystem mount point */
@@ -1838,7 +1829,7 @@ xfs_dir2_node_to_leaf(
 	if (XFS_FSB_TO_B(mp, fo) > XFS_DIR2_LEAF_OFFSET + mp->m_dirblksize)
 		return 0;
 	lbp = state->path.blk[0].bp;
-	leaf = lbp->data;
+	leaf = lbp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	/*
 	 * Read the freespace block.
@@ -1847,7 +1838,7 @@ xfs_dir2_node_to_leaf(
 			XFS_DATA_FORK))) {
 		return error;
 	}
-	free = fbp->data;
+	free = fbp->b_addr;
 	ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
 	ASSERT(!free->hdr.firstdb);
 
@@ -1857,7 +1848,7 @@ xfs_dir2_node_to_leaf(
 	 */
 	if (xfs_dir2_leaf_size(&leaf->hdr, be32_to_cpu(free->hdr.nvalid)) >
 			mp->m_dirblksize) {
-		xfs_da_brelse(tp, fbp);
+		xfs_trans_brelse(tp, fbp);
 		return 0;
 	}
 
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index b0f2678..6c70524 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -36,20 +36,20 @@
 /*
  * Function declarations.
  */
-static void xfs_dir2_free_log_header(xfs_trans_t *tp, xfs_dabuf_t *bp);
-static int xfs_dir2_leafn_add(xfs_dabuf_t *bp, xfs_da_args_t *args, int index);
+static int xfs_dir2_leafn_add(struct xfs_buf *bp, xfs_da_args_t *args,
+			      int index);
 #ifdef DEBUG
-static void xfs_dir2_leafn_check(xfs_inode_t *dp, xfs_dabuf_t *bp);
+static void xfs_dir2_leafn_check(struct xfs_inode *dp, struct xfs_buf *bp);
 #else
 #define	xfs_dir2_leafn_check(dp, bp)
 #endif
-static void xfs_dir2_leafn_moveents(xfs_da_args_t *args, xfs_dabuf_t *bp_s,
-				    int start_s, xfs_dabuf_t *bp_d, int start_d,
-				    int count);
+static void xfs_dir2_leafn_moveents(xfs_da_args_t *args, struct xfs_buf *bp_s,
+				    int start_s, struct xfs_buf *bp_d,
+				    int start_d, int count);
 static void xfs_dir2_leafn_rebalance(xfs_da_state_t *state,
 				     xfs_da_state_blk_t *blk1,
 				     xfs_da_state_blk_t *blk2);
-static int xfs_dir2_leafn_remove(xfs_da_args_t *args, xfs_dabuf_t *bp,
+static int xfs_dir2_leafn_remove(xfs_da_args_t *args, struct xfs_buf *bp,
 				 int index, xfs_da_state_blk_t *dblk,
 				 int *rval);
 static int xfs_dir2_node_addname_int(xfs_da_args_t *args,
@@ -60,16 +60,16 @@ static int xfs_dir2_node_addname_int(xfs_da_args_t *args,
  */
 STATIC void
 xfs_dir2_free_log_bests(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp,		/* freespace buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp,
 	int			first,		/* first entry to log */
 	int			last)		/* last entry to log */
 {
 	xfs_dir2_free_t		*free;		/* freespace structure */
 
-	free = bp->data;
+	free = bp->b_addr;
 	ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
-	xfs_da_log_buf(tp, bp,
+	xfs_trans_log_buf(tp, bp,
 		(uint)((char *)&free->bests[first] - (char *)free),
 		(uint)((char *)&free->bests[last] - (char *)free +
 		       sizeof(free->bests[0]) - 1));
@@ -80,14 +80,14 @@ xfs_dir2_free_log_bests(
  */
 static void
 xfs_dir2_free_log_header(
-	xfs_trans_t		*tp,		/* transaction pointer */
-	xfs_dabuf_t		*bp)		/* freespace buffer */
+	struct xfs_trans	*tp,
+	struct xfs_buf		*bp)
 {
 	xfs_dir2_free_t		*free;		/* freespace structure */
 
-	free = bp->data;
+	free = bp->b_addr;
 	ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
-	xfs_da_log_buf(tp, bp, (uint)((char *)&free->hdr - (char *)free),
+	xfs_trans_log_buf(tp, bp, (uint)((char *)&free->hdr - (char *)free),
 		(uint)(sizeof(xfs_dir2_free_hdr_t) - 1));
 }
 
@@ -99,11 +99,11 @@ xfs_dir2_free_log_header(
 int						/* error */
 xfs_dir2_leaf_to_node(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		*lbp)		/* leaf buffer */
+	struct xfs_buf		*lbp)		/* leaf buffer */
 {
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return value */
-	xfs_dabuf_t		*fbp;		/* freespace buffer */
+	struct xfs_buf		*fbp;		/* freespace buffer */
 	xfs_dir2_db_t		fdb;		/* freespace block number */
 	xfs_dir2_free_t		*free;		/* freespace structure */
 	__be16			*from;		/* pointer to freespace entry */
@@ -136,8 +136,8 @@ xfs_dir2_leaf_to_node(
 		return error;
 	}
 	ASSERT(fbp != NULL);
-	free = fbp->data;
-	leaf = lbp->data;
+	free = fbp->b_addr;
+	leaf = lbp->b_addr;
 	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 	/*
 	 * Initialize the freespace block header.
@@ -164,7 +164,6 @@ xfs_dir2_leaf_to_node(
 	xfs_dir2_leaf_log_header(tp, lbp);
 	xfs_dir2_free_log_header(tp, fbp);
 	xfs_dir2_free_log_bests(tp, fbp, 0, be32_to_cpu(free->hdr.nvalid) - 1);
-	xfs_da_buf_done(fbp);
 	xfs_dir2_leafn_check(dp, lbp);
 	return 0;
 }
@@ -175,7 +174,7 @@ xfs_dir2_leaf_to_node(
  */
 static int					/* error */
 xfs_dir2_leafn_add(
-	xfs_dabuf_t		*bp,		/* leaf buffer */
+	struct xfs_buf		*bp,		/* leaf buffer */
 	xfs_da_args_t		*args,		/* operation arguments */
 	int			index)		/* insertion pt for new entry */
 {
@@ -195,7 +194,7 @@ xfs_dir2_leafn_add(
 	dp = args->dp;
 	mp = dp->i_mount;
 	tp = args->trans;
-	leaf = bp->data;
+	leaf = bp->b_addr;
 
 	/*
 	 * Quick check just to make sure we are not going to index
@@ -261,15 +260,15 @@ xfs_dir2_leafn_add(
  */
 void
 xfs_dir2_leafn_check(
-	xfs_inode_t	*dp,			/* incore directory inode */
-	xfs_dabuf_t	*bp)			/* leaf buffer */
+	struct xfs_inode *dp,
+	struct xfs_buf	*bp)
 {
 	int		i;			/* leaf index */
 	xfs_dir2_leaf_t	*leaf;			/* leaf structure */
 	xfs_mount_t	*mp;			/* filesystem mount point */
 	int		stale;			/* count of stale leaves */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	mp = dp->i_mount;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	ASSERT(be16_to_cpu(leaf->hdr.count) <= xfs_dir2_max_leaf_ents(mp));
@@ -291,12 +290,12 @@ xfs_dir2_leafn_check(
  */
 xfs_dahash_t					/* hash value */
 xfs_dir2_leafn_lasthash(
-	xfs_dabuf_t	*bp,			/* leaf buffer */
+	struct xfs_buf	*bp,			/* leaf buffer */
 	int		*count)			/* count of entries in leaf */
 {
 	xfs_dir2_leaf_t	*leaf;			/* leaf structure */
 
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	if (count)
 		*count = be16_to_cpu(leaf->hdr.count);
@@ -311,12 +310,12 @@ xfs_dir2_leafn_lasthash(
  */
 STATIC int
 xfs_dir2_leafn_lookup_for_addname(
-	xfs_dabuf_t		*bp,		/* leaf buffer */
+	struct xfs_buf		*bp,		/* leaf buffer */
 	xfs_da_args_t		*args,		/* operation arguments */
 	int			*indexp,	/* out: leaf entry index */
 	xfs_da_state_t		*state)		/* state to fill in */
 {
-	xfs_dabuf_t		*curbp = NULL;	/* current data/free buffer */
+	struct xfs_buf		*curbp = NULL;	/* current data/free buffer */
 	xfs_dir2_db_t		curdb = -1;	/* current data block number */
 	xfs_dir2_db_t		curfdb = -1;	/* current free block number */
 	xfs_inode_t		*dp;		/* incore directory inode */
@@ -335,7 +334,7 @@ xfs_dir2_leafn_lookup_for_addname(
 	dp = args->dp;
 	tp = args->trans;
 	mp = dp->i_mount;
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 #ifdef __KERNEL__
 	ASSERT(be16_to_cpu(leaf->hdr.count) > 0);
@@ -352,7 +351,7 @@ xfs_dir2_leafn_lookup_for_addname(
 		/* If so, it's a free block buffer, get the block number. */
 		curbp = state->extrablk.bp;
 		curfdb = state->extrablk.blkno;
-		free = curbp->data;
+		free = curbp->b_addr;
 		ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
 	}
 	length = xfs_dir2_data_entsize(args->namelen);
@@ -394,7 +393,7 @@ xfs_dir2_leafn_lookup_for_addname(
 				 * If we had one before, drop it.
 				 */
 				if (curbp)
-					xfs_da_brelse(tp, curbp);
+					xfs_trans_brelse(tp, curbp);
 				/*
 				 * Read the free block.
 				 */
@@ -403,7 +402,7 @@ xfs_dir2_leafn_lookup_for_addname(
 						-1, &curbp, XFS_DATA_FORK);
 				if (error)
 					return error;
-				free = curbp->data;
+				free = curbp->b_addr;
 				ASSERT(be32_to_cpu(free->hdr.magic) ==
 					XFS_DIR2_FREE_MAGIC);
 				ASSERT((be32_to_cpu(free->hdr.firstdb) %
@@ -424,7 +423,7 @@ xfs_dir2_leafn_lookup_for_addname(
 				XFS_ERROR_REPORT("xfs_dir2_leafn_lookup_int",
 							XFS_ERRLEVEL_LOW, mp);
 				if (curfdb != newfdb)
-					xfs_da_brelse(tp, curbp);
+					xfs_trans_brelse(tp, curbp);
 				return XFS_ERROR(EFSCORRUPTED);
 			}
 			curfdb = newfdb;
@@ -459,12 +458,12 @@ out:
  */
 STATIC int
 xfs_dir2_leafn_lookup_for_entry(
-	xfs_dabuf_t		*bp,		/* leaf buffer */
+	struct xfs_buf		*bp,		/* leaf buffer */
 	xfs_da_args_t		*args,		/* operation arguments */
 	int			*indexp,	/* out: leaf entry index */
 	xfs_da_state_t		*state)		/* state to fill in */
 {
-	xfs_dabuf_t		*curbp = NULL;	/* current data/free buffer */
+	struct xfs_buf		*curbp = NULL;	/* current data/free buffer */
 	xfs_dir2_db_t		curdb = -1;	/* current data block number */
 	xfs_dir2_data_entry_t	*dep;		/* data block entry */
 	xfs_inode_t		*dp;		/* incore directory inode */
@@ -480,7 +479,7 @@ xfs_dir2_leafn_lookup_for_entry(
 	dp = args->dp;
 	tp = args->trans;
 	mp = dp->i_mount;
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 #ifdef __KERNEL__
 	ASSERT(be16_to_cpu(leaf->hdr.count) > 0);
@@ -525,7 +524,7 @@ xfs_dir2_leafn_lookup_for_entry(
 			 */
 			if (curbp && (args->cmpresult == XFS_CMP_DIFFERENT ||
 						curdb != state->extrablk.blkno))
-				xfs_da_brelse(tp, curbp);
+				xfs_trans_brelse(tp, curbp);
 			/*
 			 * If needing the block that is saved with a CI match,
 			 * use it otherwise read in the new data block.
@@ -547,7 +546,7 @@ xfs_dir2_leafn_lookup_for_entry(
 		/*
 		 * Point to the data entry.
 		 */
-		dep = (xfs_dir2_data_entry_t *)((char *)curbp->data +
+		dep = (xfs_dir2_data_entry_t *)((char *)curbp->b_addr +
 			xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
 		/*
 		 * Compare the entry and if it's an exact match, return
@@ -559,7 +558,7 @@ xfs_dir2_leafn_lookup_for_entry(
 			/* If there is a CI match block, drop it */
 			if (args->cmpresult != XFS_CMP_DIFFERENT &&
 						curdb != state->extrablk.blkno)
-				xfs_da_brelse(tp, state->extrablk.bp);
+				xfs_trans_brelse(tp, state->extrablk.bp);
 			args->cmpresult = cmp;
 			args->inumber = be64_to_cpu(dep->inumber);
 			*indexp = index;
@@ -567,7 +566,7 @@ xfs_dir2_leafn_lookup_for_entry(
 			state->extrablk.bp = curbp;
 			state->extrablk.blkno = curdb;
 			state->extrablk.index = (int)((char *)dep -
-							(char *)curbp->data);
+							(char *)curbp->b_addr);
 			state->extrablk.magic = XFS_DIR2_DATA_MAGIC;
 			if (cmp == XFS_CMP_EXACT)
 				return XFS_ERROR(EEXIST);
@@ -586,7 +585,7 @@ xfs_dir2_leafn_lookup_for_entry(
 		} else {
 			/* If the curbp is not the CI match block, drop it */
 			if (state->extrablk.bp != curbp)
-				xfs_da_brelse(tp, curbp);
+				xfs_trans_brelse(tp, curbp);
 		}
 	} else {
 		state->extravalid = 0;
@@ -602,7 +601,7 @@ xfs_dir2_leafn_lookup_for_entry(
  */
 int
 xfs_dir2_leafn_lookup_int(
-	xfs_dabuf_t		*bp,		/* leaf buffer */
+	struct xfs_buf		*bp,		/* leaf buffer */
 	xfs_da_args_t		*args,		/* operation arguments */
 	int			*indexp,	/* out: leaf entry index */
 	xfs_da_state_t		*state)		/* state to fill in */
@@ -620,9 +619,9 @@ xfs_dir2_leafn_lookup_int(
 static void
 xfs_dir2_leafn_moveents(
 	xfs_da_args_t	*args,			/* operation arguments */
-	xfs_dabuf_t	*bp_s,			/* source leaf buffer */
+	struct xfs_buf	*bp_s,			/* source leaf buffer */
 	int		start_s,		/* source leaf index */
-	xfs_dabuf_t	*bp_d,			/* destination leaf buffer */
+	struct xfs_buf	*bp_d,			/* destination leaf buffer */
 	int		start_d,		/* destination leaf index */
 	int		count)			/* count of leaves to copy */
 {
@@ -640,8 +639,8 @@ xfs_dir2_leafn_moveents(
 		return;
 	}
 	tp = args->trans;
-	leaf_s = bp_s->data;
-	leaf_d = bp_d->data;
+	leaf_s = bp_s->b_addr;
+	leaf_d = bp_d->b_addr;
 	/*
 	 * If the destination index is not the end of the current
 	 * destination leaf entries, open up a hole in the destination
@@ -702,14 +701,14 @@ xfs_dir2_leafn_moveents(
  */
 int						/* sort order */
 xfs_dir2_leafn_order(
-	xfs_dabuf_t	*leaf1_bp,		/* leaf1 buffer */
-	xfs_dabuf_t	*leaf2_bp)		/* leaf2 buffer */
+	struct xfs_buf	*leaf1_bp,		/* leaf1 buffer */
+	struct xfs_buf	*leaf2_bp)		/* leaf2 buffer */
 {
 	xfs_dir2_leaf_t	*leaf1;			/* leaf1 structure */
 	xfs_dir2_leaf_t	*leaf2;			/* leaf2 structure */
 
-	leaf1 = leaf1_bp->data;
-	leaf2 = leaf2_bp->data;
+	leaf1 = leaf1_bp->b_addr;
+	leaf2 = leaf2_bp->b_addr;
 	ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	if (be16_to_cpu(leaf1->hdr.count) > 0 &&
@@ -757,8 +756,8 @@ xfs_dir2_leafn_rebalance(
 		blk1 = blk2;
 		blk2 = tmp;
 	}
-	leaf1 = blk1->bp->data;
-	leaf2 = blk2->bp->data;
+	leaf1 = blk1->bp->b_addr;
+	leaf2 = blk2->bp->b_addr;
 	oldsum = be16_to_cpu(leaf1->hdr.count) + be16_to_cpu(leaf2->hdr.count);
 #ifdef DEBUG
 	oldstale = be16_to_cpu(leaf1->hdr.stale) + be16_to_cpu(leaf2->hdr.stale);
@@ -834,14 +833,14 @@ xfs_dir2_leafn_rebalance(
 static int					/* error */
 xfs_dir2_leafn_remove(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		*bp,		/* leaf buffer */
+	struct xfs_buf		*bp,		/* leaf buffer */
 	int			index,		/* leaf entry index */
 	xfs_da_state_blk_t	*dblk,		/* data block */
 	int			*rval)		/* resulting block needs join */
 {
 	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
 	xfs_dir2_db_t		db;		/* data block number */
-	xfs_dabuf_t		*dbp;		/* data block buffer */
+	struct xfs_buf		*dbp;		/* data block buffer */
 	xfs_dir2_data_entry_t	*dep;		/* data block entry */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
@@ -858,7 +857,7 @@ xfs_dir2_leafn_remove(
 	dp = args->dp;
 	tp = args->trans;
 	mp = dp->i_mount;
-	leaf = bp->data;
+	leaf = bp->b_addr;
 	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	/*
 	 * Point to the entry we're removing.
@@ -884,7 +883,7 @@ xfs_dir2_leafn_remove(
 	 * in the data block in case it changes.
 	 */
 	dbp = dblk->bp;
-	hdr = dbp->data;
+	hdr = dbp->b_addr;
 	dep = (xfs_dir2_data_entry_t *)((char *)hdr + off);
 	longest = be16_to_cpu(hdr->bestfree[0].length);
 	needlog = needscan = 0;
@@ -905,7 +904,7 @@ xfs_dir2_leafn_remove(
 	 */
 	if (longest < be16_to_cpu(hdr->bestfree[0].length)) {
 		int		error;		/* error return value */
-		xfs_dabuf_t	*fbp;		/* freeblock buffer */
+		struct xfs_buf	*fbp;		/* freeblock buffer */
 		xfs_dir2_db_t	fdb;		/* freeblock block number */
 		int		findex;		/* index in freeblock entries */
 		xfs_dir2_free_t	*free;		/* freeblock structure */
@@ -920,7 +919,7 @@ xfs_dir2_leafn_remove(
 				-1, &fbp, XFS_DATA_FORK))) {
 			return error;
 		}
-		free = fbp->data;
+		free = fbp->b_addr;
 		ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
 		ASSERT(be32_to_cpu(free->hdr.firstdb) ==
 		       xfs_dir2_free_max_bests(mp) *
@@ -948,9 +947,7 @@ xfs_dir2_leafn_remove(
 			 * In this case just drop the buffer and some one else
 			 * will eventually get rid of the empty block.
 			 */
-			else if (error == ENOSPC && args->total == 0)
-				xfs_da_buf_done(dbp);
-			else
+			else if (!(error == ENOSPC && args->total == 0))
 				return error;
 		}
 		/*
@@ -1018,11 +1015,6 @@ xfs_dir2_leafn_remove(
 		 */
 		if (logfree)
 			xfs_dir2_free_log_bests(tp, fbp, findex, findex);
-		/*
-		 * Drop the buffer if we still have it.
-		 */
-		if (fbp)
-			xfs_da_buf_done(fbp);
 	}
 	xfs_dir2_leafn_check(dp, bp);
 	/*
@@ -1114,7 +1106,7 @@ xfs_dir2_leafn_toosmall(
 {
 	xfs_da_state_blk_t	*blk;		/* leaf block */
 	xfs_dablk_t		blkno;		/* leaf block number */
-	xfs_dabuf_t		*bp;		/* leaf buffer */
+	struct xfs_buf		*bp;		/* leaf buffer */
 	int			bytes;		/* bytes in use */
 	int			count;		/* leaf live entry count */
 	int			error;		/* error return value */
@@ -1130,7 +1122,7 @@ xfs_dir2_leafn_toosmall(
 	 * to coalesce with a sibling.
 	 */
 	blk = &state->path.blk[state->path.active - 1];
-	info = blk->bp->data;
+	info = blk->bp->b_addr;
 	ASSERT(info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	leaf = (xfs_dir2_leaf_t *)info;
 	count = be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale);
@@ -1189,7 +1181,7 @@ xfs_dir2_leafn_toosmall(
 		leaf = (xfs_dir2_leaf_t *)info;
 		count = be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale);
 		bytes = state->blocksize - (state->blocksize >> 2);
-		leaf = bp->data;
+		leaf = bp->b_addr;
 		ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 		count += be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale);
 		bytes -= count * (uint)sizeof(leaf->ents[0]);
@@ -1198,7 +1190,7 @@ xfs_dir2_leafn_toosmall(
 		 */
 		if (bytes >= 0)
 			break;
-		xfs_da_brelse(state->args->trans, bp);
+		xfs_trans_brelse(state->args->trans, bp);
 	}
 	/*
 	 * Didn't like either block, give up.
@@ -1207,11 +1199,7 @@ xfs_dir2_leafn_toosmall(
 		*action = 0;
 		return 0;
 	}
-	/*
-	 * Done with the sibling leaf block here, drop the dabuf
-	 * so path_shift can get it.
-	 */
-	xfs_da_buf_done(bp);
+
 	/*
 	 * Make altpath point to the block we want to keep (the lower
 	 * numbered block) and path point to the block we want to drop.
@@ -1247,8 +1235,8 @@ xfs_dir2_leafn_unbalance(
 	args = state->args;
 	ASSERT(drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
 	ASSERT(save_blk->magic == XFS_DIR2_LEAFN_MAGIC);
-	drop_leaf = drop_blk->bp->data;
-	save_leaf = save_blk->bp->data;
+	drop_leaf = drop_blk->bp->b_addr;
+	save_leaf = save_blk->bp->b_addr;
 	ASSERT(drop_leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	ASSERT(save_leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
 	/*
@@ -1356,13 +1344,13 @@ xfs_dir2_node_addname_int(
 {
 	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
 	xfs_dir2_db_t		dbno;		/* data block number */
-	xfs_dabuf_t		*dbp;		/* data block buffer */
+	struct xfs_buf		*dbp;		/* data block buffer */
 	xfs_dir2_data_entry_t	*dep;		/* data entry pointer */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	xfs_dir2_data_unused_t	*dup;		/* data unused entry pointer */
 	int			error;		/* error return value */
 	xfs_dir2_db_t		fbno;		/* freespace block number */
-	xfs_dabuf_t		*fbp;		/* freespace buffer */
+	struct xfs_buf		*fbp;		/* freespace buffer */
 	int			findex;		/* freespace entry index */
 	xfs_dir2_free_t		*free=NULL;	/* freespace block structure */
 	xfs_dir2_db_t		ifbno;		/* initial freespace block no */
@@ -1390,7 +1378,7 @@ xfs_dir2_node_addname_int(
 		 * Remember initial freespace block number.
 		 */
 		ifbno = fblk->blkno;
-		free = fbp->data;
+		free = fbp->b_addr;
 		ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
 		findex = fblk->index;
 		/*
@@ -1474,7 +1462,7 @@ xfs_dir2_node_addname_int(
 			if (unlikely(fbp == NULL)) {
 				continue;
 			}
-			free = fbp->data;
+			free = fbp->b_addr;
 			ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
 			findex = 0;
 		}
@@ -1492,7 +1480,7 @@ xfs_dir2_node_addname_int(
 				/*
 				 * Drop the block.
 				 */
-				xfs_da_brelse(tp, fbp);
+				xfs_trans_brelse(tp, fbp);
 				fbp = NULL;
 				if (fblk && fblk->bp)
 					fblk->bp = NULL;
@@ -1507,36 +1495,23 @@ xfs_dir2_node_addname_int(
 		/*
 		 * Not allowed to allocate, return failure.
 		 */
-		if ((args->op_flags & XFS_DA_OP_JUSTCHECK) ||
-							args->total == 0) {
-			/*
-			 * Drop the freespace buffer unless it came from our
-			 * caller.
-			 */
-			if ((fblk == NULL || fblk->bp == NULL) && fbp != NULL)
-				xfs_da_buf_done(fbp);
+		if ((args->op_flags & XFS_DA_OP_JUSTCHECK) || args->total == 0)
 			return XFS_ERROR(ENOSPC);
-		}
+
 		/*
 		 * Allocate and initialize the new data block.
 		 */
 		if (unlikely((error = xfs_dir2_grow_inode(args,
 							 XFS_DIR2_DATA_SPACE,
 							 &dbno)) ||
-		    (error = xfs_dir2_data_init(args, dbno, &dbp)))) {
-			/*
-			 * Drop the freespace buffer unless it came from our
-			 * caller.
-			 */
-			if ((fblk == NULL || fblk->bp == NULL) && fbp != NULL)
-				xfs_da_buf_done(fbp);
+		    (error = xfs_dir2_data_init(args, dbno, &dbp))))
 			return error;
-		}
+
 		/*
 		 * If (somehow) we have a freespace block, get rid of it.
 		 */
 		if (fbp)
-			xfs_da_brelse(tp, fbp);
+			xfs_trans_brelse(tp, fbp);
 		if (fblk && fblk->bp)
 			fblk->bp = NULL;
 
@@ -1547,10 +1522,9 @@ xfs_dir2_node_addname_int(
 		fbno = xfs_dir2_db_to_fdb(mp, dbno);
 		if (unlikely(error = xfs_da_read_buf(tp, dp,
 				xfs_dir2_db_to_da(mp, fbno), -2, &fbp,
-				XFS_DATA_FORK))) {
-			xfs_da_buf_done(dbp);
+				XFS_DATA_FORK)))
 			return error;
-  		}
+
 		/*
 		 * If there wasn't a freespace block, the read will
 		 * return a NULL fbp.  Allocate and initialize a new one.
@@ -1598,7 +1572,7 @@ xfs_dir2_node_addname_int(
 			 * Initialize the new block to be empty, and remember
 			 * its first slot as our empty slot.
 			 */
-			free = fbp->data;
+			free = fbp->b_addr;
 			free->hdr.magic = cpu_to_be32(XFS_DIR2_FREE_MAGIC);
 			free->hdr.firstdb = cpu_to_be32(
 				(fbno - XFS_DIR2_FREE_FIRSTDB(mp)) *
@@ -1606,7 +1580,7 @@ xfs_dir2_node_addname_int(
 			free->hdr.nvalid = 0;
 			free->hdr.nused = 0;
 		} else {
-			free = fbp->data;
+			free = fbp->b_addr;
 			ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
 		}
 
@@ -1639,7 +1613,7 @@ xfs_dir2_node_addname_int(
 		 * We haven't allocated the data entry yet so this will
 		 * change again.
 		 */
-		hdr = dbp->data;
+		hdr = dbp->b_addr;
 		free->bests[findex] = hdr->bestfree[0].length;
 		logfree = 1;
 	}
@@ -1650,22 +1624,17 @@ xfs_dir2_node_addname_int(
 		/*
 		 * If just checking, we succeeded.
 		 */
-		if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
-			if ((fblk == NULL || fblk->bp == NULL) && fbp != NULL)
-				xfs_da_buf_done(fbp);
+		if (args->op_flags & XFS_DA_OP_JUSTCHECK)
 			return 0;
-		}
+
 		/*
 		 * Read the data block in.
 		 */
-		if (unlikely(
-		    error = xfs_da_read_buf(tp, dp, xfs_dir2_db_to_da(mp, dbno),
-				-1, &dbp, XFS_DATA_FORK))) {
-			if ((fblk == NULL || fblk->bp == NULL) && fbp != NULL)
-				xfs_da_buf_done(fbp);
+		error = xfs_da_read_buf(tp, dp, xfs_dir2_db_to_da(mp, dbno),
+				-1, &dbp, XFS_DATA_FORK);
+		if (error)
 			return error;
-		}
-		hdr = dbp->data;
+		hdr = dbp->b_addr;
 		logfree = 0;
 	}
 	ASSERT(be16_to_cpu(hdr->bestfree[0].length) >= length);
@@ -1714,16 +1683,10 @@ xfs_dir2_node_addname_int(
 	if (logfree)
 		xfs_dir2_free_log_bests(tp, fbp, findex, findex);
 	/*
-	 * If the caller didn't hand us the freespace block, drop it.
-	 */
-	if ((fblk == NULL || fblk->bp == NULL) && fbp != NULL)
-		xfs_da_buf_done(fbp);
-	/*
 	 * Return the data block and offset in args, then drop the data block.
 	 */
 	args->blkno = (xfs_dablk_t)dbno;
 	args->index = be16_to_cpu(*tagp);
-	xfs_da_buf_done(dbp);
 	return 0;
 }
 
@@ -1761,22 +1724,23 @@ xfs_dir2_node_lookup(
 		/* If a CI match, dup the actual name and return EEXIST */
 		xfs_dir2_data_entry_t	*dep;
 
-		dep = (xfs_dir2_data_entry_t *)((char *)state->extrablk.bp->
-						data + state->extrablk.index);
+		dep = (xfs_dir2_data_entry_t *)
+			((char *)state->extrablk.bp->b_addr +
+						 state->extrablk.index);
 		rval = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
 	}
 	/*
 	 * Release the btree blocks and leaf block.
 	 */
 	for (i = 0; i < state->path.active; i++) {
-		xfs_da_brelse(args->trans, state->path.blk[i].bp);
+		xfs_trans_brelse(args->trans, state->path.blk[i].bp);
 		state->path.blk[i].bp = NULL;
 	}
 	/*
 	 * Release the data block if we have it.
 	 */
 	if (state->extravalid && state->extrablk.bp) {
-		xfs_da_brelse(args->trans, state->extrablk.bp);
+		xfs_trans_brelse(args->trans, state->extrablk.bp);
 		state->extrablk.bp = NULL;
 	}
 	xfs_da_state_free(state);
@@ -1893,13 +1857,13 @@ xfs_dir2_node_replace(
 		 */
 		blk = &state->path.blk[state->path.active - 1];
 		ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
-		leaf = blk->bp->data;
+		leaf = blk->bp->b_addr;
 		lep = &leaf->ents[blk->index];
 		ASSERT(state->extravalid);
 		/*
 		 * Point to the data entry.
 		 */
-		hdr = state->extrablk.bp->data;
+		hdr = state->extrablk.bp->b_addr;
 		ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC));
 		dep = (xfs_dir2_data_entry_t *)
 		      ((char *)hdr +
@@ -1916,14 +1880,14 @@ xfs_dir2_node_replace(
 	 * Didn't find it, and we're holding a data block.  Drop it.
 	 */
 	else if (state->extravalid) {
-		xfs_da_brelse(args->trans, state->extrablk.bp);
+		xfs_trans_brelse(args->trans, state->extrablk.bp);
 		state->extrablk.bp = NULL;
 	}
 	/*
 	 * Release all the buffers in the cursor.
 	 */
 	for (i = 0; i < state->path.active; i++) {
-		xfs_da_brelse(args->trans, state->path.blk[i].bp);
+		xfs_trans_brelse(args->trans, state->path.blk[i].bp);
 		state->path.blk[i].bp = NULL;
 	}
 	xfs_da_state_free(state);
@@ -1940,7 +1904,7 @@ xfs_dir2_node_trim_free(
 	xfs_fileoff_t		fo,		/* free block number */
 	int			*rvalp)		/* out: did something */
 {
-	xfs_dabuf_t		*bp;		/* freespace buffer */
+	struct xfs_buf		*bp;		/* freespace buffer */
 	xfs_inode_t		*dp;		/* incore directory inode */
 	int			error;		/* error return code */
 	xfs_dir2_free_t		*free;		/* freespace structure */
@@ -1965,13 +1929,13 @@ xfs_dir2_node_trim_free(
 	if (bp == NULL) {
 		return 0;
 	}
-	free = bp->data;
+	free = bp->b_addr;
 	ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC));
 	/*
 	 * If there are used entries, there's nothing to do.
 	 */
 	if (be32_to_cpu(free->hdr.nused) > 0) {
-		xfs_da_brelse(tp, bp);
+		xfs_trans_brelse(tp, bp);
 		*rvalp = 0;
 		return 0;
 	}
@@ -1987,7 +1951,7 @@ xfs_dir2_node_trim_free(
 		 * pieces.  This is the last block of an extent.
 		 */
 		ASSERT(error != ENOSPC);
-		xfs_da_brelse(tp, bp);
+		xfs_trans_brelse(tp, bp);
 		return error;
 	}
 	/*
diff --git a/fs/xfs/xfs_dir2_priv.h b/fs/xfs/xfs_dir2_priv.h
index 067f403..3523d3e 100644
--- a/fs/xfs/xfs_dir2_priv.h
+++ b/fs/xfs/xfs_dir2_priv.h
@@ -25,7 +25,7 @@ extern int xfs_dir2_isleaf(struct xfs_trans *tp, struct xfs_inode *dp, int *r);
 extern int xfs_dir2_grow_inode(struct xfs_da_args *args, int space,
 				xfs_dir2_db_t *dbp);
 extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db,
-				struct xfs_dabuf *bp);
+				struct xfs_buf *bp);
 extern int xfs_dir_cilookup_result(struct xfs_da_args *args,
 				const unsigned char *name, int len);
 
@@ -37,11 +37,11 @@ extern int xfs_dir2_block_lookup(struct xfs_da_args *args);
 extern int xfs_dir2_block_removename(struct xfs_da_args *args);
 extern int xfs_dir2_block_replace(struct xfs_da_args *args);
 extern int xfs_dir2_leaf_to_block(struct xfs_da_args *args,
-		struct xfs_dabuf *lbp, struct xfs_dabuf *dbp);
+		struct xfs_buf *lbp, struct xfs_buf *dbp);
 
 /* xfs_dir2_data.c */
 #ifdef DEBUG
-extern void xfs_dir2_data_check(struct xfs_inode *dp, struct xfs_dabuf *bp);
+extern void xfs_dir2_data_check(struct xfs_inode *dp, struct xfs_buf *bp);
 #else
 #define	xfs_dir2_data_check(dp,bp)
 #endif
@@ -51,43 +51,43 @@ xfs_dir2_data_freeinsert(struct xfs_dir2_data_hdr *hdr,
 extern void xfs_dir2_data_freescan(struct xfs_mount *mp,
 		struct xfs_dir2_data_hdr *hdr, int *loghead);
 extern int xfs_dir2_data_init(struct xfs_da_args *args, xfs_dir2_db_t blkno,
-		struct xfs_dabuf **bpp);
-extern void xfs_dir2_data_log_entry(struct xfs_trans *tp, struct xfs_dabuf *bp,
+		struct xfs_buf **bpp);
+extern void xfs_dir2_data_log_entry(struct xfs_trans *tp, struct xfs_buf *bp,
 		struct xfs_dir2_data_entry *dep);
 extern void xfs_dir2_data_log_header(struct xfs_trans *tp,
-		struct xfs_dabuf *bp);
-extern void xfs_dir2_data_log_unused(struct xfs_trans *tp, struct xfs_dabuf *bp,
+		struct xfs_buf *bp);
+extern void xfs_dir2_data_log_unused(struct xfs_trans *tp, struct xfs_buf *bp,
 		struct xfs_dir2_data_unused *dup);
-extern void xfs_dir2_data_make_free(struct xfs_trans *tp, struct xfs_dabuf *bp,
+extern void xfs_dir2_data_make_free(struct xfs_trans *tp, struct xfs_buf *bp,
 		xfs_dir2_data_aoff_t offset, xfs_dir2_data_aoff_t len,
 		int *needlogp, int *needscanp);
-extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_dabuf *bp,
+extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_buf *bp,
 		struct xfs_dir2_data_unused *dup, xfs_dir2_data_aoff_t offset,
 		xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);
 
 /* xfs_dir2_leaf.c */
 extern int xfs_dir2_block_to_leaf(struct xfs_da_args *args,
-		struct xfs_dabuf *dbp);
+		struct xfs_buf *dbp);
 extern int xfs_dir2_leaf_addname(struct xfs_da_args *args);
 extern void xfs_dir2_leaf_compact(struct xfs_da_args *args,
-		struct xfs_dabuf *bp);
-extern void xfs_dir2_leaf_compact_x1(struct xfs_dabuf *bp, int *indexp,
+		struct xfs_buf *bp);
+extern void xfs_dir2_leaf_compact_x1(struct xfs_buf *bp, int *indexp,
 		int *lowstalep, int *highstalep, int *lowlogp, int *highlogp);
 extern int xfs_dir2_leaf_getdents(struct xfs_inode *dp, void *dirent,
 		size_t bufsize, xfs_off_t *offset, filldir_t filldir);
 extern int xfs_dir2_leaf_init(struct xfs_da_args *args, xfs_dir2_db_t bno,
-		struct xfs_dabuf **bpp, int magic);
-extern void xfs_dir2_leaf_log_ents(struct xfs_trans *tp, struct xfs_dabuf *bp,
+		struct xfs_buf **bpp, int magic);
+extern void xfs_dir2_leaf_log_ents(struct xfs_trans *tp, struct xfs_buf *bp,
 		int first, int last);
 extern void xfs_dir2_leaf_log_header(struct xfs_trans *tp,
-		struct xfs_dabuf *bp);
+		struct xfs_buf *bp);
 extern int xfs_dir2_leaf_lookup(struct xfs_da_args *args);
 extern int xfs_dir2_leaf_removename(struct xfs_da_args *args);
 extern int xfs_dir2_leaf_replace(struct xfs_da_args *args);
 extern int xfs_dir2_leaf_search_hash(struct xfs_da_args *args,
-		struct xfs_dabuf *lbp);
+		struct xfs_buf *lbp);
 extern int xfs_dir2_leaf_trim_data(struct xfs_da_args *args,
-		struct xfs_dabuf *lbp, xfs_dir2_db_t db);
+		struct xfs_buf *lbp, xfs_dir2_db_t db);
 extern struct xfs_dir2_leaf_entry *
 xfs_dir2_leaf_find_entry(struct xfs_dir2_leaf *leaf, int index, int compact,
 		int lowstale, int highstale,
@@ -96,13 +96,13 @@ extern int xfs_dir2_node_to_leaf(struct xfs_da_state *state);
 
 /* xfs_dir2_node.c */
 extern int xfs_dir2_leaf_to_node(struct xfs_da_args *args,
-		struct xfs_dabuf *lbp);
-extern xfs_dahash_t xfs_dir2_leafn_lasthash(struct xfs_dabuf *bp, int *count);
-extern int xfs_dir2_leafn_lookup_int(struct xfs_dabuf *bp,
+		struct xfs_buf *lbp);
+extern xfs_dahash_t xfs_dir2_leafn_lasthash(struct xfs_buf *bp, int *count);
+extern int xfs_dir2_leafn_lookup_int(struct xfs_buf *bp,
 		struct xfs_da_args *args, int *indexp,
 		struct xfs_da_state *state);
-extern int xfs_dir2_leafn_order(struct xfs_dabuf *leaf1_bp,
-		struct xfs_dabuf *leaf2_bp);
+extern int xfs_dir2_leafn_order(struct xfs_buf *leaf1_bp,
+		struct xfs_buf *leaf2_bp);
 extern int xfs_dir2_leafn_split(struct xfs_da_state *state,
 	struct xfs_da_state_blk *oldblk, struct xfs_da_state_blk *newblk);
 extern int xfs_dir2_leafn_toosmall(struct xfs_da_state *state, int *action);
@@ -122,7 +122,7 @@ extern xfs_ino_t xfs_dir2_sfe_get_ino(struct xfs_dir2_sf_hdr *sfp,
 		struct xfs_dir2_sf_entry *sfep);
 extern int xfs_dir2_block_sfsize(struct xfs_inode *dp,
 		struct xfs_dir2_data_hdr *block, struct xfs_dir2_sf_hdr *sfhp);
-extern int xfs_dir2_block_to_sf(struct xfs_da_args *args, struct xfs_dabuf *bp,
+extern int xfs_dir2_block_to_sf(struct xfs_da_args *args, struct xfs_buf *bp,
 		int size, xfs_dir2_sf_hdr_t *sfhp);
 extern int xfs_dir2_sf_addname(struct xfs_da_args *args);
 extern int xfs_dir2_sf_create(struct xfs_da_args *args, xfs_ino_t pino);
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index 19bf0c5..1b9fc3e 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -222,7 +222,7 @@ xfs_dir2_block_sfsize(
 int						/* error */
 xfs_dir2_block_to_sf(
 	xfs_da_args_t		*args,		/* operation arguments */
-	xfs_dabuf_t		*bp,		/* block buffer */
+	struct xfs_buf		*bp,
 	int			size,		/* shortform directory size */
 	xfs_dir2_sf_hdr_t	*sfhp)		/* shortform directory hdr */
 {
@@ -249,7 +249,7 @@ xfs_dir2_block_to_sf(
 	 * and add local data.
 	 */
 	hdr = kmem_alloc(mp->m_dirblksize, KM_SLEEP);
-	memcpy(hdr, bp->data, mp->m_dirblksize);
+	memcpy(hdr, bp->b_addr, mp->m_dirblksize);
 	logflags = XFS_ILOG_CORE;
 	if ((error = xfs_dir2_shrink_inode(args, mp->m_dirdatablk, bp))) {
 		ASSERT(error != ENOSPC);
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 65b51d2..a199793 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1491,13 +1491,9 @@ xfs_init_zones(void)
 	if (!xfs_da_state_zone)
 		goto out_destroy_btree_cur_zone;
 
-	xfs_dabuf_zone = kmem_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf");
-	if (!xfs_dabuf_zone)
-		goto out_destroy_da_state_zone;
-
 	xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
 	if (!xfs_ifork_zone)
-		goto out_destroy_dabuf_zone;
+		goto out_destroy_da_state_zone;
 
 	xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
 	if (!xfs_trans_zone)
@@ -1560,8 +1556,6 @@ xfs_init_zones(void)
 	kmem_zone_destroy(xfs_trans_zone);
  out_destroy_ifork_zone:
 	kmem_zone_destroy(xfs_ifork_zone);
- out_destroy_dabuf_zone:
-	kmem_zone_destroy(xfs_dabuf_zone);
  out_destroy_da_state_zone:
 	kmem_zone_destroy(xfs_da_state_zone);
  out_destroy_btree_cur_zone:
@@ -1589,7 +1583,6 @@ xfs_destroy_zones(void)
 	kmem_zone_destroy(xfs_log_item_desc_zone);
 	kmem_zone_destroy(xfs_trans_zone);
 	kmem_zone_destroy(xfs_ifork_zone);
-	kmem_zone_destroy(xfs_dabuf_zone);
 	kmem_zone_destroy(xfs_da_state_zone);
 	kmem_zone_destroy(xfs_btree_cur_zone);
 	kmem_zone_destroy(xfs_bmap_free_item_zone);
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 09/10] xfs: remove struct xfs_dabuf and infrastructure

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> The struct xfs_dabuf now only tracks a single xfs_buf and all the
> information it holds can be gained directly from the xfs_buf. Hence
> we can remove the struct dabuf and pass the xfs_buf around
> everywhere.
>
> Kill the struct dabuf and the associated infrastructure.
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>
> ---

wow, that must have been fun...


Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 10/10] xfs: factor buffer reading from xfs_dir2_leaf_getdents

[Dave Chinner]

From: Dave Chinner <dchinner@redhat.com>

The buffer reading code in xfs_dir2_leaf_getdents is complex and difficult to
follow due to the readahead and all the context is carries. it is also badly
indented and so difficult to read. Factor it out into a separate function to
make it easier to understand and optimise in future patches.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_dir2_leaf.c |  436 ++++++++++++++++++++++++++----------------------
 1 file changed, 234 insertions(+), 202 deletions(-)

diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index 69accf6..dbe8845 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -759,6 +759,222 @@ xfs_dir2_leaf_compact_x1(
 	*highstalep = highstale;
 }
 
+struct _map_info {
+	xfs_bmbt_irec_t	*map;		/* map vector for blocks */
+	xfs_extlen_t	map_blocks;	/* number of fsbs in map */
+	xfs_dablk_t	map_off;	/* last mapped file offset */
+	int		map_size;	/* total entries in *map */
+	int		map_valid;	/* valid entries in *map */
+	int		nmap;		/* mappings to ask xfs_bmapi */
+	xfs_dir2_db_t	curdb;		/* db for current block */
+};
+
+struct _ra_info {
+	int		ra_current;	/* number of read-ahead blks */
+	int		ra_index;	/* *map index for read-ahead */
+	int		ra_offset;	/* map entry offset for ra */
+	int		ra_want;	/* readahead count wanted */
+};
+
+STATIC int
+xfs_dir2_leaf_readbuf(
+	struct xfs_inode	*dp,
+	size_t			bufsize,
+	struct _map_info	*mip,
+	struct _ra_info		*rap,
+	xfs_dir2_off_t		*curoff,
+	struct xfs_buf		**bpp)
+{
+	struct xfs_mount	*mp = dp->i_mount;
+	struct xfs_buf		*bp = *bpp;
+	struct xfs_bmbt_irec	*map = mip->map;
+	int			error = 0;
+	int			length;
+	int			i;
+	int			j;
+
+	/*
+	 * If we have a buffer, we need to release it and
+	 * take it out of the mapping.
+	 */
+
+	if (bp) {
+		xfs_trans_brelse(NULL, bp);
+		bp = NULL;
+		mip->map_blocks -= mp->m_dirblkfsbs;
+		/*
+		 * Loop to get rid of the extents for the
+		 * directory block.
+		 */
+		for (i = mp->m_dirblkfsbs; i > 0; ) {
+			j = min_t(int, map->br_blockcount, i);
+			map->br_blockcount -= j;
+			map->br_startblock += j;
+			map->br_startoff += j;
+			/*
+			 * If mapping is done, pitch it from
+			 * the table.
+			 */
+			if (!map->br_blockcount && --mip->map_valid)
+				memmove(&map[0], &map[1],
+					sizeof(map[0]) * mip->map_valid);
+			i -= j;
+		}
+	}
+
+	/*
+	 * Recalculate the readahead blocks wanted.
+	 */
+	rap->ra_want = howmany(bufsize + mp->m_dirblksize,
+			       mp->m_sb.sb_blocksize) - 1;
+	ASSERT(rap->ra_want >= 0);
+
+	/*
+	 * If we don't have as many as we want, and we haven't
+	 * run out of data blocks, get some more mappings.
+	 */
+	if (1 + rap->ra_want > mip->map_blocks &&
+	    mip->map_off < xfs_dir2_byte_to_da(mp, XFS_DIR2_LEAF_OFFSET)) {
+		/*
+		 * Get more bmaps, fill in after the ones
+		 * we already have in the table.
+		 */
+		mip->nmap = mip->map_size - mip->map_valid;
+		error = xfs_bmapi_read(dp, mip->map_off,
+				xfs_dir2_byte_to_da(mp, XFS_DIR2_LEAF_OFFSET) -
+								mip->map_off,
+				&map[mip->map_valid], &mip->nmap, 0);
+
+		/*
+		 * Don't know if we should ignore this or try to return an
+		 * error.  The trouble with returning errors is that readdir
+		 * will just stop without actually passing the error through.
+		 */
+		if (error)
+			goto out;	/* XXX */
+
+		/*
+		 * If we got all the mappings we asked for, set the final map
+		 * offset based on the last bmap value received.  Otherwise,
+		 * we've reached the end.
+		 */
+		if (mip->nmap == mip->map_size - mip->map_valid) {
+			i = mip->map_valid + mip->nmap - 1;
+			mip->map_off = map[i].br_startoff + map[i].br_blockcount;
+		} else
+			mip->map_off = xfs_dir2_byte_to_da(mp,
+							XFS_DIR2_LEAF_OFFSET);
+
+		/*
+		 * Look for holes in the mapping, and eliminate them.  Count up
+		 * the valid blocks.
+		 */
+		for (i = mip->map_valid; i < mip->map_valid + mip->nmap; ) {
+			if (map[i].br_startblock == HOLESTARTBLOCK) {
+				mip->nmap--;
+				length = mip->map_valid + mip->nmap - i;
+				if (length)
+					memmove(&map[i], &map[i + 1],
+						sizeof(map[i]) * length);
+			} else {
+				mip->map_blocks += map[i].br_blockcount;
+				i++;
+			}
+		}
+		mip->map_valid += mip->nmap;
+	}
+
+	/*
+	 * No valid mappings, so no more data blocks.
+	 */
+	if (!mip->map_valid) {
+		*curoff = xfs_dir2_da_to_byte(mp, mip->map_off);
+		goto out;
+	}
+
+	/*
+	 * Read the directory block starting at the first mapping.
+	 */
+	mip->curdb = xfs_dir2_da_to_db(mp, map->br_startoff);
+	error = xfs_da_read_buf(NULL, dp, map->br_startoff,
+			map->br_blockcount >= mp->m_dirblkfsbs ?
+			    XFS_FSB_TO_DADDR(mp, map->br_startblock) : -1,
+			&bp, XFS_DATA_FORK);
+
+	/*
+	 * Should just skip over the data block instead of giving up.
+	 */
+	if (error)
+		goto out;	/* XXX */
+
+	/*
+	 * Adjust the current amount of read-ahead: we just read a block that
+	 * was previously ra.
+	 */
+	if (rap->ra_current)
+		rap->ra_current -= mp->m_dirblkfsbs;
+
+	/*
+	 * Do we need more readahead?
+	 */
+	for (rap->ra_index = rap->ra_offset = i = 0;
+	     rap->ra_want > rap->ra_current && i < mip->map_blocks;
+	     i += mp->m_dirblkfsbs) {
+		ASSERT(rap->ra_index < mip->map_valid);
+		/*
+		 * Read-ahead a contiguous directory block.
+		 */
+		if (i > rap->ra_current &&
+		    map[rap->ra_index].br_blockcount >= mp->m_dirblkfsbs) {
+			xfs_buf_readahead(mp->m_ddev_targp,
+				XFS_FSB_TO_DADDR(mp,
+					map[rap->ra_index].br_startblock +
+							rap->ra_offset),
+				(int)BTOBB(mp->m_dirblksize));
+			rap->ra_current = i;
+		}
+
+		/*
+		 * Read-ahead a non-contiguous directory block.  This doesn't
+		 * use our mapping, but this is a very rare case.
+		 */
+		else if (i > rap->ra_current) {
+			xfs_da_reada_buf(NULL, dp,
+					map[rap->ra_index].br_startoff +
+							rap->ra_offset,
+					XFS_DATA_FORK);
+			rap->ra_current = i;
+		}
+
+		/*
+		 * Advance offset through the mapping table.
+		 */
+		for (j = 0; j < mp->m_dirblkfsbs; j++) {
+			/*
+			 * The rest of this extent but not more than a dir
+			 * block.
+			 */
+			length = min_t(int, mp->m_dirblkfsbs,
+					map[rap->ra_index].br_blockcount -
+							rap->ra_offset);
+			j += length;
+			rap->ra_offset += length;
+
+			/*
+			 * Advance to the next mapping if this one is used up.
+			 */
+			if (rap->ra_offset == map[rap->ra_index].br_blockcount) {
+				rap->ra_offset = 0;
+				rap->ra_index++;
+			}
+		}
+	}
+
+out:
+	*bpp = bp;
+	return error;
+}
+
 /*
  * Getdents (readdir) for leaf and node directories.
  * This reads the data blocks only, so is the same for both forms.
@@ -771,30 +987,19 @@ xfs_dir2_leaf_getdents(
 	xfs_off_t		*offset,
 	filldir_t		filldir)
 {
-	struct xfs_buf		*bp;		/* data block buffer */
-	int			byteoff;	/* offset in current block */
-	xfs_dir2_db_t		curdb;		/* db for current block */
-	xfs_dir2_off_t		curoff;		/* current overall offset */
+	struct xfs_buf		*bp = NULL;	/* data block buffer */
 	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
 	xfs_dir2_data_entry_t	*dep;		/* data entry */
 	xfs_dir2_data_unused_t	*dup;		/* unused entry */
 	int			error = 0;	/* error return value */
-	int			i;		/* temporary loop index */
-	int			j;		/* temporary loop index */
 	int			length;		/* temporary length value */
-	xfs_bmbt_irec_t		*map;		/* map vector for blocks */
-	xfs_extlen_t		map_blocks;	/* number of fsbs in map */
-	xfs_dablk_t		map_off;	/* last mapped file offset */
-	int			map_size;	/* total entries in *map */
-	int			map_valid;	/* valid entries in *map */
 	xfs_mount_t		*mp;		/* filesystem mount point */
+	int			byteoff;	/* offset in current block */
+	xfs_dir2_off_t		curoff;		/* current overall offset */
 	xfs_dir2_off_t		newoff;		/* new curoff after new blk */
-	int			nmap;		/* mappings to ask xfs_bmapi */
 	char			*ptr = NULL;	/* pointer to current data */
-	int			ra_current;	/* number of read-ahead blks */
-	int			ra_index;	/* *map index for read-ahead */
-	int			ra_offset;	/* map entry offset for ra */
-	int			ra_want;	/* readahead count wanted */
+	struct _map_info	map_info = {};
+	struct _ra_info		ra_info = {};
 
 	/*
 	 * If the offset is at or past the largest allowed value,
@@ -810,10 +1015,10 @@ xfs_dir2_leaf_getdents(
 	 * buffer size, the directory block size, and the filesystem
 	 * block size.
 	 */
-	map_size = howmany(bufsize + mp->m_dirblksize, mp->m_sb.sb_blocksize);
-	map = kmem_alloc(map_size * sizeof(*map), KM_SLEEP);
-	map_valid = ra_index = ra_offset = ra_current = map_blocks = 0;
-	bp = NULL;
+	map_info.map_size = howmany(bufsize + mp->m_dirblksize,
+				     mp->m_sb.sb_blocksize);
+	map_info.map = kmem_zalloc(map_info.map_size *
+					sizeof(struct xfs_bmbt_irec), KM_SLEEP);
 
 	/*
 	 * Inside the loop we keep the main offset value as a byte offset
@@ -825,7 +1030,8 @@ xfs_dir2_leaf_getdents(
 	 * Force this conversion through db so we truncate the offset
 	 * down to get the start of the data block.
 	 */
-	map_off = xfs_dir2_db_to_da(mp, xfs_dir2_byte_to_db(mp, curoff));
+	map_info.map_off = xfs_dir2_db_to_da(mp, xfs_dir2_byte_to_db(mp, curoff));
+
 	/*
 	 * Loop over directory entries until we reach the end offset.
 	 * Get more blocks and readahead as necessary.
@@ -836,190 +1042,16 @@ xfs_dir2_leaf_getdents(
 		 * current buffer, need to get another one.
 		 */
 		if (!bp || ptr >= (char *)bp->b_addr + mp->m_dirblksize) {
-			/*
-			 * If we have a buffer, we need to release it and
-			 * take it out of the mapping.
-			 */
-			if (bp) {
-				xfs_trans_brelse(NULL, bp);
-				bp = NULL;
-				map_blocks -= mp->m_dirblkfsbs;
-				/*
-				 * Loop to get rid of the extents for the
-				 * directory block.
-				 */
-				for (i = mp->m_dirblkfsbs; i > 0; ) {
-					j = MIN((int)map->br_blockcount, i);
-					map->br_blockcount -= j;
-					map->br_startblock += j;
-					map->br_startoff += j;
-					/*
-					 * If mapping is done, pitch it from
-					 * the table.
-					 */
-					if (!map->br_blockcount && --map_valid)
-						memmove(&map[0], &map[1],
-							sizeof(map[0]) *
-							map_valid);
-					i -= j;
-				}
-			}
-			/*
-			 * Recalculate the readahead blocks wanted.
-			 */
-			ra_want = howmany(bufsize + mp->m_dirblksize,
-					  mp->m_sb.sb_blocksize) - 1;
-			ASSERT(ra_want >= 0);
 
-			/*
-			 * If we don't have as many as we want, and we haven't
-			 * run out of data blocks, get some more mappings.
-			 */
-			if (1 + ra_want > map_blocks &&
-			    map_off <
-			    xfs_dir2_byte_to_da(mp, XFS_DIR2_LEAF_OFFSET)) {
-				/*
-				 * Get more bmaps, fill in after the ones
-				 * we already have in the table.
-				 */
-				nmap = map_size - map_valid;
-				error = xfs_bmapi_read(dp, map_off,
-					xfs_dir2_byte_to_da(mp,
-						XFS_DIR2_LEAF_OFFSET) - map_off,
-					&map[map_valid], &nmap, 0);
-				/*
-				 * Don't know if we should ignore this or
-				 * try to return an error.
-				 * The trouble with returning errors
-				 * is that readdir will just stop without
-				 * actually passing the error through.
-				 */
-				if (error)
-					break;	/* XXX */
-				/*
-				 * If we got all the mappings we asked for,
-				 * set the final map offset based on the
-				 * last bmap value received.
-				 * Otherwise, we've reached the end.
-				 */
-				if (nmap == map_size - map_valid)
-					map_off =
-					map[map_valid + nmap - 1].br_startoff +
-					map[map_valid + nmap - 1].br_blockcount;
-				else
-					map_off =
-						xfs_dir2_byte_to_da(mp,
-							XFS_DIR2_LEAF_OFFSET);
-				/*
-				 * Look for holes in the mapping, and
-				 * eliminate them.  Count up the valid blocks.
-				 */
-				for (i = map_valid; i < map_valid + nmap; ) {
-					if (map[i].br_startblock ==
-					    HOLESTARTBLOCK) {
-						nmap--;
-						length = map_valid + nmap - i;
-						if (length)
-							memmove(&map[i],
-								&map[i + 1],
-								sizeof(map[i]) *
-								length);
-					} else {
-						map_blocks +=
-							map[i].br_blockcount;
-						i++;
-					}
-				}
-				map_valid += nmap;
-			}
-			/*
-			 * No valid mappings, so no more data blocks.
-			 */
-			if (!map_valid) {
-				curoff = xfs_dir2_da_to_byte(mp, map_off);
+			error = xfs_dir2_leaf_readbuf(dp, bufsize, &map_info,
+						&ra_info, &curoff, &bp);
+			if (error || !map_info.map_valid)
 				break;
-			}
-			/*
-			 * Read the directory block starting at the first
-			 * mapping.
-			 */
-			curdb = xfs_dir2_da_to_db(mp, map->br_startoff);
-			error = xfs_da_read_buf(NULL, dp, map->br_startoff,
-				map->br_blockcount >= mp->m_dirblkfsbs ?
-				    XFS_FSB_TO_DADDR(mp, map->br_startblock) :
-				    -1,
-				&bp, XFS_DATA_FORK);
-			/*
-			 * Should just skip over the data block instead
-			 * of giving up.
-			 */
-			if (error)
-				break;	/* XXX */
-			/*
-			 * Adjust the current amount of read-ahead: we just
-			 * read a block that was previously ra.
-			 */
-			if (ra_current)
-				ra_current -= mp->m_dirblkfsbs;
-			/*
-			 * Do we need more readahead?
-			 */
-			for (ra_index = ra_offset = i = 0;
-			     ra_want > ra_current && i < map_blocks;
-			     i += mp->m_dirblkfsbs) {
-				ASSERT(ra_index < map_valid);
-				/*
-				 * Read-ahead a contiguous directory block.
-				 */
-				if (i > ra_current &&
-				    map[ra_index].br_blockcount >=
-				    mp->m_dirblkfsbs) {
-					xfs_buf_readahead(mp->m_ddev_targp,
-						XFS_FSB_TO_DADDR(mp,
-						   map[ra_index].br_startblock +
-						   ra_offset),
-						(int)BTOBB(mp->m_dirblksize));
-					ra_current = i;
-				}
-				/*
-				 * Read-ahead a non-contiguous directory block.
-				 * This doesn't use our mapping, but this
-				 * is a very rare case.
-				 */
-				else if (i > ra_current) {
-					(void)xfs_da_reada_buf(NULL, dp,
-						map[ra_index].br_startoff +
-						ra_offset, XFS_DATA_FORK);
-					ra_current = i;
-				}
-				/*
-				 * Advance offset through the mapping table.
-				 */
-				for (j = 0; j < mp->m_dirblkfsbs; j++) {
-					/*
-					 * The rest of this extent but not
-					 * more than a dir block.
-					 */
-					length = MIN(mp->m_dirblkfsbs,
-						(int)(map[ra_index].br_blockcount -
-						ra_offset));
-					j += length;
-					ra_offset += length;
-					/*
-					 * Advance to the next mapping if
-					 * this one is used up.
-					 */
-					if (ra_offset ==
-					    map[ra_index].br_blockcount) {
-						ra_offset = 0;
-						ra_index++;
-					}
-				}
-			}
+
 			/*
 			 * Having done a read, we need to set a new offset.
 			 */
-			newoff = xfs_dir2_db_off_to_byte(mp, curdb, 0);
+			newoff = xfs_dir2_db_off_to_byte(mp, map_info.curdb, 0);
 			/*
 			 * Start of the current block.
 			 */
@@ -1030,7 +1062,7 @@ xfs_dir2_leaf_getdents(
 			 */
 			else if (curoff > newoff)
 				ASSERT(xfs_dir2_byte_to_db(mp, curoff) ==
-				       curdb);
+				       map_info.curdb);
 			hdr = bp->b_addr;
 			xfs_dir2_data_check(dp, bp);
 			/*
@@ -1113,7 +1145,7 @@ xfs_dir2_leaf_getdents(
 		*offset = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
 	else
 		*offset = xfs_dir2_byte_to_dataptr(mp, curoff) & 0x7fffffff;
-	kmem_free(map);
+	kmem_free(map_info.map);
 	if (bp)
 		xfs_trans_brelse(NULL, bp);
 	return error;
-- 
1.7.9.5

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 10/10] xfs: factor buffer reading from xfs_dir2_leaf_getdents

[Mark Tinguely]

On 04/24/12 01:33, Dave Chinner wrote:
> From: Dave Chinner<dchinner@redhat.com>
>
> The buffer reading code in xfs_dir2_leaf_getdents is complex and difficult to
> follow due to the readahead and all the context is carries. it is also badly
> indented and so difficult to read. Factor it out into a separate function to
> make it easier to understand and optimise in future patches.
>
> Signed-off-by: Dave Chinner<dchinner@redhat.com>
> ---

Looks good.


Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 00/10] xfs: discontiguous buffer support a.k.a. die xfs_dabuf die

[Ben Myers]

Hey Dave,

Looks like there are some additional test failures due to this patchset.  Here
some output from a bisect I did yesterday, running only the tests which failed
on the machine where I noticed this.

# git describe
v3.4-rc2-54-g1307bbd

from patches/series:
# normal: (there's my baseline on this machine.  I noticed a larger number of test failures on another test box and brought that series over here)
#Failures: 030 178 230 231 232 233 250 274
#Failed 8 of 198 tests

xfs-fix-delalloc-quota-accounting-on-failure.patch
xfs-fix-memory-reclaim-deadlock-on-agi-buffer.patch
xfs-add-trace-points-for-log-forces.patch
xfs-separate-buffer-indexing-from-block-map.patch
xfs-convert-internal-buffer-functions-to-pass-maps.patch
xfs-add-discontiguous-buffer-map-interface.patch
xfs-add-discontiguous-buffer-support-to-transactions.patch

# ^^^ bisect 1, went ok.  
#    030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
#    Failures: 030 230 231 232 233
#    Failed 5 of 15 tests

# ^^^ bisect 4, making sure it's good
#Ran: 030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
#Failures: 030 230 231 232 233
#Failed 5 of 15 tests

xfs-struct-xfs_buf_log_format-isn-t-variable-sized.patch

# ^^^ bisect 5, crashed.  (consistently)

xfs-support-discontiguous-buffers-in-the.patch

# ^^^ bisect 6
#Ran: 030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
#Failures: 030 085 086 087 121 179 182 200 230 231 232 233
#Failed 12 of 15 tests

xfs-use-multiple-irec-xfs-buf-support-in-dabuf.patch

# ^^^ bisect 3, (still no good)
#Ran: 030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
#Failures: 030 085 086 087 121 179 182 200 230 231 232 233
#Failed 12 of 15 tests

#xfs-remove-struct-xfs_dabuf-and-infrastructure.patch
#xfs-factor-buffer-reading-from-xfs_dir2_leaf_getdents.patch
#fs-xfs-xfs_dinode.h-fix-comments-of-xfs_dinode_t.patch
#fix-wrong-flag-assert-in-xfs_attr_shortform_getvalue.patch

# ^^^ bisect 2, not good (I ran only the tests which failed on the other test box)
#    030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
#    Failures: 030 085 086 087 121 179 182 200 230 231 232 233
#    Failed 12 of 15 tests

Looks like there is a problem in
xfs-struct-xfs_buf_log_format-isn-t-variable-sized.patch,
and/or
xfs-support-discontiguous-buffers-in-the.patch.

Regards,
	Ben

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 00/10] xfs: discontiguous buffer support a.k.a. die xfs_dabuf die

[Dave Chinner]

On Wed, May 16, 2012 at 12:40:42PM -0500, Ben Myers wrote:
> Hey Dave,
> 
> Looks like there are some additional test failures due to this patchset.  Here
> some output from a bisect I did yesterday, running only the tests which failed
> on the machine where I noticed this.

So what the configuration you are testing on here?

....
> 
> # git describe
> v3.4-rc2-54-g1307bbd

That's mostly meaningless to me - you've got a 3.4-rc2 kernel with
54 local commits in it.

> from patches/series:
> # normal: (there's my baseline on this machine.  I noticed a larger number of test failures on another test box and brought that series over here)
> #Failures: 030 178 230 231 232 233 250 274
> #Failed 8 of 198 tests
......
> 
> xfs-fix-delalloc-quota-accounting-on-failure.patch
> xfs-fix-memory-reclaim-deadlock-on-agi-buffer.patch
> xfs-add-trace-points-for-log-forces.patch
> xfs-separate-buffer-indexing-from-block-map.patch
> xfs-convert-internal-buffer-functions-to-pass-maps.patch
> xfs-add-discontiguous-buffer-map-interface.patch
> xfs-add-discontiguous-buffer-support-to-transactions.patch
> 
> # ^^^ bisect 1, went ok.  
> #    030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
> #    Failures: 030 230 231 232 233
> #    Failed 5 of 15 tests


> # ^^^ bisect 4, making sure it's good
> #Ran: 030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
> #Failures: 030 230 231 232 233
> #Failed 5 of 15 tests
> 
> xfs-struct-xfs_buf_log_format-isn-t-variable-sized.patch
> 
> # ^^^ bisect 5, crashed.  (consistently)
> 
> xfs-support-discontiguous-buffers-in-the.patch
> 
> # ^^^ bisect 6
> #Ran: 030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
> #Failures: 030 085 086 087 121 179 182 200 230 231 232 233
> #Failed 12 of 15 tests

So, 085 086 087 121 179 182 200 are all log recovery tests.....

So what are the failures? This doesn't tell me anything about why
these have failed, and the last set of test runs I did before
posting this series showed:

Failures: 030 050 073 249 250 263
Failed 6 of 197 tests

Which is standard for my 4k filesystem block size testing.

> Looks like there is a problem in
> xfs-struct-xfs_buf_log_format-isn-t-variable-sized.patch,

Given the crashes, this is the likely cause of the problem.
Especially as the version of the patch in this series is missing a
critical hunk compared to the local patch I have been testing which
would cause memcpy() to fall off the end of allocated memory
buffers....

--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -240,15 +240,14 @@ xfs_buf_item_format(
               (bip->bli_flags & XFS_BLI_STALE));
 
        /*
-        * The size of the base structure is the size of the
-        * declared structure plus the space for the extra words
-        * of the bitmap.  We subtract one from the map size, because
-        * the first element of the bitmap is accounted for in the
-        * size of the base structure.
+        * Base size is the actual size of the ondisk structure - it reflects
+        * the actual size of the dirty bitmap rather than the size of the in
+        * memory structure. The xfs_buf_log_format size is the maximum,
+        * subtract the unused part of the bitmap from it.
         */
-       base_size =
-               (uint)(sizeof(xfs_buf_log_format_t) +
-                      ((bip->bli_format.blf_map_size - 1) * sizeof(uint)));
+       base_size = sizeof(struct xfs_buf_log_format) -
+                   ((XFS_BLF_DATAMAP_SIZE - bip->bli_format.blf_map_size) *
+                                                               sizeof(uint));
        vecp->i_addr = &bip->bli_format;
        vecp->i_len = base_size;
        vecp->i_type = XLOG_REG_TYPE_BFORMAT;


I'll retest the series and repost it.

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 00/10] xfs: discontiguous buffer support a.k.a. die xfs_dabuf die

[Ben Myers]

Hey Dave,

On Wed, May 23, 2012 at 07:27:46PM +1000, Dave Chinner wrote:
> On Wed, May 16, 2012 at 12:40:42PM -0500, Ben Myers wrote:
> > Hey Dave,
> > 
> > Looks like there are some additional test failures due to this patchset.  Here
> > some output from a bisect I did yesterday, running only the tests which failed
> > on the machine where I noticed this.
> 
> So what the configuration you are testing on here?

This is an x86_64 box, a pair of dual core xeon @ 3.6Ghz, a single internal
disk.

my config:
TEST_DIR=/mnt/test
TEST_DEV=/dev/sdb3
TEST_LOGDEV=/dev/sdb1

SCRATCH_MNT=/mnt/scratch
SCRATCH_DEV=/dev/sdb4
SCRATCH_LOGDEV=/dev/sdb2

80gig of memory

# df
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda2             68627996  15411112  49730780  24% /
devtmpfs               4032444        96   4032348   1% /dev
tmpfs                  4032444         0   4032444   0% /dev/shm
/dev/sdb3             36896036   4200608  32695428  12% /mnt/test
/dev/sdb4              2086912     67856   2019056   4% /mnt/scratch

> ....
> > 
> > # git describe
> > v3.4-rc2-54-g1307bbd
> 
> That's mostly meaningless to me - you've got a 3.4-rc2 kernel with
> 54 local commits in it.

My intention was that this refer to some publicly available repo.  The script
should probably say which one. ;)

In this case it refers to xfs master git tree on oss.  

> > from patches/series:
> > # normal: (there's my baseline on this machine.  I noticed a larger number of test failures on another test box and brought that series over here)
> > #Failures: 030 178 230 231 232 233 250 274
> > #Failed 8 of 198 tests
> ......
> > 
> > xfs-fix-delalloc-quota-accounting-on-failure.patch
> > xfs-fix-memory-reclaim-deadlock-on-agi-buffer.patch
> > xfs-add-trace-points-for-log-forces.patch
> > xfs-separate-buffer-indexing-from-block-map.patch
> > xfs-convert-internal-buffer-functions-to-pass-maps.patch
> > xfs-add-discontiguous-buffer-map-interface.patch
> > xfs-add-discontiguous-buffer-support-to-transactions.patch
> > 
> > # ^^^ bisect 1, went ok.  
> > #    030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
> > #    Failures: 030 230 231 232 233
> > #    Failed 5 of 15 tests
> 
> 
> > # ^^^ bisect 4, making sure it's good
> > #Ran: 030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
> > #Failures: 030 230 231 232 233
> > #Failed 5 of 15 tests
> > 
> > xfs-struct-xfs_buf_log_format-isn-t-variable-sized.patch
> > 
> > # ^^^ bisect 5, crashed.  (consistently)
> > 
> > xfs-support-discontiguous-buffers-in-the.patch
> > 
> > # ^^^ bisect 6
> > #Ran: 030 050 085 086 087 121 128 179 182 200 230 231 232 233 235
> > #Failures: 030 085 086 087 121 179 182 200 230 231 232 233
> > #Failed 12 of 15 tests
> 
> So, 085 086 087 121 179 182 200 are all log recovery tests.....
> 
> So what are the failures?

I'll have to do another run to gather those up.

> This doesn't tell me anything about why
> these have failed, and the last set of test runs I did before
> posting this series showed:
 
> Failures: 030 050 073 249 250 263
> Failed 6 of 197 tests
> 
> Which is standard for my 4k filesystem block size testing.
>
> > Looks like there is a problem in
> > xfs-struct-xfs_buf_log_format-isn-t-variable-sized.patch,
> 
> Given the crashes, this is the likely cause of the problem.
> Especially as the version of the patch in this series is missing a
> critical hunk compared to the local patch I have been testing which
> would cause memcpy() to fall off the end of allocated memory
> buffers....
> 
> --- a/fs/xfs/xfs_buf_item.c
> +++ b/fs/xfs/xfs_buf_item.c
> @@ -240,15 +240,14 @@ xfs_buf_item_format(
>                (bip->bli_flags & XFS_BLI_STALE));
>  
>         /*
> -        * The size of the base structure is the size of the
> -        * declared structure plus the space for the extra words
> -        * of the bitmap.  We subtract one from the map size, because
> -        * the first element of the bitmap is accounted for in the
> -        * size of the base structure.
> +        * Base size is the actual size of the ondisk structure - it reflects
> +        * the actual size of the dirty bitmap rather than the size of the in
> +        * memory structure. The xfs_buf_log_format size is the maximum,
> +        * subtract the unused part of the bitmap from it.
>          */
> -       base_size =
> -               (uint)(sizeof(xfs_buf_log_format_t) +
> -                      ((bip->bli_format.blf_map_size - 1) * sizeof(uint)));
> +       base_size = sizeof(struct xfs_buf_log_format) -
> +                   ((XFS_BLF_DATAMAP_SIZE - bip->bli_format.blf_map_size) *
> +                                                               sizeof(uint));
>         vecp->i_addr = &bip->bli_format;
>         vecp->i_len = base_size;
>         vecp->i_type = XLOG_REG_TYPE_BFORMAT;
> 
> 
> I'll retest the series and repost it.

Ok, looking forward to seeing it.

-Ben

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 00/10] xfs: discontiguous buffer support a.k.a. die xfs_dabuf die

[Ben Myers]

[-- Attachment #1: Type: text/plain, Size: 272 bytes --]

On Wed, May 30, 2012 at 09:48:01AM -0500, Ben Myers wrote:

> > So, 085 086 087 121 179 182 200 are all log recovery tests.....
> > 
> > So what are the failures?
> 
> I'll have to do another run to gather those up.

Failures: 085 086 087 121 179 182 200

Attached.

-Ben

[-- Attachment #2: 085.full --]
[-- Type: text/plain, Size: 14864 bytes --]

meta-data=/dev/sdb4              isize=256    agcount=4, agsize=2170232 blks
         =                       sectsz=512   attr=2, projid32bit=0
data     =                       bsize=4096   blocks=8680926, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0
log      =internal log           bsize=4096   blocks=4238, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
Opening "/mnt/scratch"
Calling XFS_IOC_GOINGDOWN
xfs_logprint:
    data device: 0xa0010300
    log device: 0xa0010300 daddr: 34723744 length: 33904

    log tail: 2 head: 54 state: <DIRTY>


LOG REC AT LSN cycle 1 block 2 (0x1, 0x2)
============================================================================
TRANS: tid:0xcfe397be  type:CHECKPOINT  #items:250  trans:0xcfe397be  q:0x667f20
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670010 len:96 
	INODE: #regs:2   ino:0x83  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x667fa0 len:56 a:0x6700e0 len:96 
	INODE: #regs:2   ino:0x84  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670150 len:56 a:0x6701f0 len:96 
	INODE: #regs:2   ino:0x85  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670260 len:56 a:0x670300 len:96 
	INODE: #regs:2   ino:0x86  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670370 len:56 a:0x670410 len:96 
	INODE: #regs:2   ino:0x87  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670480 len:56 a:0x670520 len:96 
	INODE: #regs:2   ino:0x88  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670590 len:56 a:0x670630 len:96 
	INODE: #regs:2   ino:0x89  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6706a0 len:56 a:0x670740 len:96 
	INODE: #regs:2   ino:0x8a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6707b0 len:56 a:0x670850 len:96 
	INODE: #regs:2   ino:0x8b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6708c0 len:56 a:0x670960 len:96 
	INODE: #regs:2   ino:0x8c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6709d0 len:56 a:0x670a70 len:96 
	INODE: #regs:2   ino:0x8d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670ae0 len:56 a:0x670b80 len:96 
	INODE: #regs:2   ino:0x8e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670bf0 len:56 a:0x670c90 len:96 
	INODE: #regs:2   ino:0x8f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670d00 len:56 a:0x670da0 len:96 
	INODE: #regs:2   ino:0x90  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670e10 len:56 a:0x670eb0 len:96 
	INODE: #regs:2   ino:0x91  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670f20 len:56 a:0x670fc0 len:96 
	INODE: #regs:2   ino:0x92  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671030 len:56 a:0x6710d0 len:96 
	INODE: #regs:2   ino:0x93  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671140 len:56 a:0x6711e0 len:96 
	INODE: #regs:2   ino:0x94  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671250 len:56 a:0x6712f0 len:96 
	INODE: #regs:2   ino:0x95  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671360 len:56 a:0x671400 len:96 
	INODE: #regs:2   ino:0x96  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671470 len:56 a:0x671510 len:96 
	INODE: #regs:2   ino:0x97  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671580 len:56 a:0x671620 len:96 
	INODE: #regs:2   ino:0x98  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671690 len:56 a:0x671730 len:96 
	INODE: #regs:2   ino:0x99  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6717a0 len:56 a:0x671840 len:96 
	INODE: #regs:2   ino:0x9a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6718b0 len:56 a:0x671950 len:96 
	INODE: #regs:2   ino:0x9b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6719c0 len:56 a:0x671a60 len:96 
	INODE: #regs:2   ino:0x9c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671ad0 len:56 a:0x671b70 len:96 
	INODE: #regs:2   ino:0x9d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671be0 len:56 a:0x671c80 len:96 
	INODE: #regs:2   ino:0x9e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671cf0 len:56 a:0x671d90 len:96 
	INODE: #regs:2   ino:0x9f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671e00 len:56 a:0x671ea0 len:96 
	INODE: #regs:2   ino:0xa0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671f10 len:56 a:0x671fb0 len:96 
	INODE: #regs:2   ino:0xa1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672020 len:56 a:0x6720c0 len:96 
	INODE: #regs:2   ino:0xa2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672130 len:56 a:0x6721d0 len:96 
	INODE: #regs:2   ino:0xa3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672240 len:56 a:0x6722e0 len:96 
	INODE: #regs:2   ino:0xa4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672350 len:56 a:0x6723f0 len:96 
	INODE: #regs:2   ino:0xa5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672460 len:56 a:0x672500 len:96 
	INODE: #regs:2   ino:0xa6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672570 len:56 a:0x672610 len:96 
	INODE: #regs:2   ino:0xa7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672680 len:56 a:0x672720 len:96 
	INODE: #regs:2   ino:0xa8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672790 len:56 a:0x672830 len:96 
	INODE: #regs:2   ino:0xa9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6728a0 len:56 a:0x672940 len:96 
	INODE: #regs:2   ino:0xaa  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6729b0 len:56 a:0x672a50 len:96 
	INODE: #regs:2   ino:0xab  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672ac0 len:56 a:0x672b60 len:96 
	INODE: #regs:2   ino:0xac  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672bd0 len:56 a:0x672c70 len:96 
	INODE: #regs:2   ino:0xad  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672ce0 len:56 a:0x672d80 len:96 
	INODE: #regs:2   ino:0xae  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672df0 len:56 a:0x672e90 len:96 
	INODE: #regs:2   ino:0xaf  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672f00 len:56 a:0x672fa0 len:96 
	INODE: #regs:2   ino:0xb0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673010 len:56 a:0x6730b0 len:96 
	INODE: #regs:2   ino:0xb1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673120 len:56 a:0x6731c0 len:96 
	INODE: #regs:2   ino:0xb2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673230 len:56 a:0x6732d0 len:96 
	INODE: #regs:2   ino:0xb3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673340 len:56 a:0x6733e0 len:96 
	INODE: #regs:2   ino:0xb4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673450 len:56 a:0x6734f0 len:96 
	INODE: #regs:2   ino:0xb5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673560 len:56 a:0x673600 len:96 
	INODE: #regs:2   ino:0xb6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673670 len:56 a:0x673710 len:96 
	INODE: #regs:2   ino:0xb7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673780 len:56 a:0x673820 len:96 
	INODE: #regs:2   ino:0xb8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673890 len:56 a:0x673930 len:96 
	INODE: #regs:2   ino:0xb9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6739a0 len:56 a:0x673a40 len:96 
	INODE: #regs:2   ino:0xba  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673ab0 len:56 a:0x673b50 len:96 
	INODE: #regs:2   ino:0xbb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673bc0 len:56 a:0x673c60 len:96 
	INODE: #regs:2   ino:0xbc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673cd0 len:56 a:0x673d70 len:96 
	INODE: #regs:2   ino:0xbd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673de0 len:56 a:0x673e80 len:96 
	INODE: #regs:2   ino:0xbe  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673ef0 len:56 a:0x673f90 len:96 
	INODE: #regs:2   ino:0xbf  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:2 total:2 a:0x674000 len:28 a:0x674090 len:128 
	BUF:  #regs:2   start blkno:0x1   len:1   bmap size:1   flags:0x0
	AGF Buffer: (XAGF)
BUF: cnt:2 total:2 a:0x674120 len:28 a:0x6741b0 len:128 
	BUF:  #regs:2   start blkno:0x10   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:2 total:2 a:0x674240 len:28 a:0x6742d0 len:128 
	BUF:  #regs:2   start blkno:0x8   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:17 total:17 a:0x674360 len:28 a:0x6744e0 len:128 a:0x674570 len:128 a:0x674600 len:128 a:0x674690 len:128 a:0x674720 len:128 a:0x6747b0 len:128 a:0x674840 len:128 a:0x6748d0 len:128 a:0x674960 len:128 a:0x6749f0 len:128 a:0x674a80 len:128 a:0x674b10 len:128 a:0x674ba0 len:128 a:0x674c30 len:128 a:0x674cc0 len:128 a:0x674d50 len:128 
	BUF:  #regs:17   start blkno:0x70   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
BUF: cnt:17 total:17 a:0x674de0 len:28 a:0x674f60 len:128 a:0x674ff0 len:128 a:0x675080 len:128 a:0x675110 len:128 a:0x6751a0 len:128 a:0x675230 len:128 a:0x6752c0 len:128 a:0x675350 len:128 a:0x6753e0 len:128 a:0x675470 len:128 a:0x675500 len:128 a:0x675590 len:128 a:0x675620 len:128 a:0x6756b0 len:128 a:0x675740 len:128 a:0x6757d0 len:128 
	BUF:  #regs:17   start blkno:0x80   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x675860 len:56 a:0x675900 len:96 
	INODE: #regs:2   ino:0xe0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675970 len:56 a:0x675a10 len:96 
	INODE: #regs:2   ino:0xe1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675a80 len:56 a:0x675b20 len:96 
	INODE: #regs:2   ino:0xe2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675b90 len:56 a:0x675c30 len:96 
	INODE: #regs:2   ino:0xe3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675ca0 len:56 a:0x675d40 len:96 
	INODE: #regs:2   ino:0xe4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675db0 len:56 a:0x675e50 len:96 
	INODE: #regs:2   ino:0xe5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675ec0 len:56 a:0x675f60 len:96 
	INODE: #regs:2   ino:0xe6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675fd0 len:56 a:0x676070 len:96 
	INODE: #regs:2   ino:0xe7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6760e0 len:56 a:0x676180 len:96 
	INODE: #regs:2   ino:0xe8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6761f0 len:56 a:0x676290 len:96 
	INODE: #regs:2   ino:0xe9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676300 len:56 a:0x6763a0 len:96 
	INODE: #regs:2   ino:0xea  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676410 len:56 a:0x6764b0 len:96 
	INODE: #regs:2   ino:0xeb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676520 len:56 a:0x6765c0 len:96 
	INODE: #regs:2   ino:0xec  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676630 len:56 a:0x6766d0 len:96 
	INODE: #regs:2   ino:0xed  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676740 len:56 a:0x6767e0 len:96 
	INODE: #regs:2   ino:0xee  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676850 len:56 a:0x6768f0 len:96 
	INODE: #regs:2   ino:0xef  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676960 len:56 a:0x676a00 len:96 
	INODE: #regs:2   ino:0xf0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676a70 len:56 a:0x676b10 len:96 
	INODE: #regs:2   ino:0xf1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676b80 len:56 a:0x676c20 len:96 
	INODE: #regs:2   ino:0xf2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676c90 len:56 a:0x676d30 len:96 
	INODE: #regs:2   ino:0xf3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676da0 len:56 a:0x676e40 len:96 
	INODE: #regs:2   ino:0xf4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676eb0 len:56 a:0x676f50 len:96 
	INODE: #regs:2   ino:0xf5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676fc0 len:56 a:0x677060 len:96 
	INODE: #regs:2   ino:0xf6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6770d0 len:56 a:0x677170 len:96 
	INODE: #regs:2   ino:0xf7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6771e0 len:56 a:0x677280 len:96 
	INODE: #regs:2   ino:0xf8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6772f0 len:56 a:0x677390 len:96 
	INODE: #regs:2   ino:0xf9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677400 len:56 a:0x6774a0 len:96 
	INODE: #regs:2   ino:0xfa  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677510 len:56 a:0x6775b0 len:96 
	INODE: #regs:2   ino:0xfb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677620 len:56 a:0x6776c0 len:96 
	INODE: #regs:2   ino:0xfc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677730 len:56 a:0x6777d0 len:96 
	INODE: #regs:2   ino:0xfd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677840 len:56 a:0x6778e0 len:96 
	INODE: #regs:2   ino:0xfe  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677950 len:56 a:0x6779f0 len:96 
	INODE: #regs:2   ino:0xff  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677a60 len:56 a:0x677b00 len:96 
	INODE: #regs:2   ino:0x100  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677b70 len:56 a:0x677c10 len:96 
	INODE: #regs:2   ino:0x101  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677c80 len:56 a:0x677d20 len:96 
	INODE: #regs:2   ino:0x102  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677d90 len:56 a:0x677e30 len:96 
	INODE: #regs:2   ino:0x103  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677ea0 len:56 a:0x677f40 len:96 
	INODE: #regs:2   ino:0x104  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677fb0 len:56 a:0x678050 len:96 
	INODE: #regs:2   ino:0x105  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:2 total:2 a:0x6780c0 len:28 a:0x678150 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6781e0 len:28 a:0x678270 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x678300 len:56 a:0x6783b0 len:96 a:0x667fe0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x678420 len:28 a:0x6784c0 len:1664 a:0x678b50 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x678ee0 len:56 a:0x678f80 len:96 
	INODE: #regs:2   ino:0x106  flags:0x1   dsize:0
	CORE inode:
mount: Structure needs cleaning
mount failed:  

[-- Attachment #3: 086.full --]
[-- Type: text/plain, Size: 144265 bytes --]

meta-data=/dev/sdb4              isize=256    agcount=4, agsize=2170232 blks
         =                       sectsz=512   attr=2, projid32bit=0
data     =                       bsize=4096   blocks=8680926, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0
log      =internal log           bsize=4096   blocks=4238, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
xfs_logprint:
    data device: 0xa0010300
    log device: 0xa0010300 daddr: 34723744 length: 33904

    log tail: 11 head: 11 state: <CLEAN>


*** mkfs ***

meta-data=/dev/sdb4              isize=256    agcount=4, agsize=2170232 blks
         =                       sectsz=512   attr=2, projid32bit=0
data     =                       bsize=4096   blocks=8680926, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0
log      =internal log           bsize=4096   blocks=4238, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

*** mount ***


*** ls SCRATCH_MNT ***


*** godown ***

Opening "/mnt/scratch"
Calling XFS_IOC_GOINGDOWN

*** unmount ***


*** logprint after going down... ***

xfs_logprint:
    data device: 0xa0010300
    log device: 0xa0010300 daddr: 34723744 length: 33904

    log tail: 2 head: 791 state: <DIRTY>


LOG REC AT LSN cycle 1 block 2 (0x1, 0x2)
============================================================================
TRANS: tid:0x95226d02  type:CHECKPOINT  #items:9  trans:0x95226d02  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670160 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:16
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670340 len:96 
	INODE: #regs:2   ino:0x83  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 5 (0x1, 0x5)
============================================================================
TRANS: tid:0x3cd500f8  type:CHECKPOINT  #items:2  trans:0x3cd500f8  q:0x667f20
BUF: cnt:2 total:2 a:0x670310 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 7 (0x1, 0x7)
============================================================================
TRANS: tid:0xa36aecf7  type:CHECKPOINT  #items:9  trans:0xa36aecf7  q:0x667f20
BUF: cnt:2 total:2 a:0x6701a0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6700a0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670340 len:96 a:0x670280 len:24 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:24
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x670160 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x84  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 10 (0x1, 0xa)
============================================================================
TRANS: tid:0x40ebefab  type:CHECKPOINT  #items:2  trans:0x40ebefab  q:0x667f20
BUF: cnt:2 total:2 a:0x6703b0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 12 (0x1, 0xc)
============================================================================
TRANS: tid:0xff0d7c9e  type:CHECKPOINT  #items:9  trans:0xff0d7c9e  q:0x667f20
BUF: cnt:2 total:2 a:0x667fa0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670160 len:56 a:0x670210 len:96 a:0x670310 len:36 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:36
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670340 len:96 
	INODE: #regs:2   ino:0x85  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 15 (0x1, 0xf)
============================================================================
TRANS: tid:0x4f7ee2d5  type:CHECKPOINT  #items:2  trans:0x4f7ee2d5  q:0x667f20
BUF: cnt:2 total:2 a:0x6703e0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 17 (0x1, 0x11)
============================================================================
TRANS: tid:0x51c63c86  type:CHECKPOINT  #items:9  trans:0x51c63c86  q:0x667f20
BUF: cnt:2 total:2 a:0x6702e0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670310 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670340 len:96 a:0x670160 len:44 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:44
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x86  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 20 (0x1, 0x14)
============================================================================
TRANS: tid:0xb902ebec  type:CHECKPOINT  #items:2  trans:0xb902ebec  q:0x667f20
BUF: cnt:2 total:2 a:0x6703b0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 22 (0x1, 0x16)
============================================================================
TRANS: tid:0x876da9fc  type:CHECKPOINT  #items:9  trans:0x876da9fc  q:0x667f20
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670160 len:52 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:52
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670340 len:96 
	INODE: #regs:2   ino:0x87  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 25 (0x1, 0x19)
============================================================================
TRANS: tid:0xaa2c45dd  type:CHECKPOINT  #items:2  trans:0xaa2c45dd  q:0x667f20
BUF: cnt:2 total:2 a:0x6702e0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 27 (0x1, 0x1b)
============================================================================
TRANS: tid:0x7091a886  type:CHECKPOINT  #items:9  trans:0x7091a886  q:0x667f20
BUF: cnt:2 total:2 a:0x6701a0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6700a0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670340 len:96 a:0x670410 len:60 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:60
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x670160 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x88  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 30 (0x1, 0x1e)
============================================================================
TRANS: tid:0xd5fdc690  type:CHECKPOINT  #items:2  trans:0xd5fdc690  q:0x667f20
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 32 (0x1, 0x20)
============================================================================
TRANS: tid:0x6fb9376e  type:CHECKPOINT  #items:9  trans:0x6fb9376e  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670310 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670160 len:56 a:0x670210 len:96 a:0x670410 len:72 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:72
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670340 len:96 
	INODE: #regs:2   ino:0x89  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 35 (0x1, 0x23)
============================================================================
TRANS: tid:0x290782a1  type:CHECKPOINT  #items:2  trans:0x290782a1  q:0x667f20
BUF: cnt:2 total:2 a:0x6701a0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 37 (0x1, 0x25)
============================================================================
TRANS: tid:0xa5e855a5  type:CHECKPOINT  #items:9  trans:0xa5e855a5  q:0x667f20
BUF: cnt:2 total:2 a:0x6703e0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670340 len:96 a:0x670460 len:80 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:80
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x670160 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x8a  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 40 (0x1, 0x28)
============================================================================
TRANS: tid:0x4db5527a  type:CHECKPOINT  #items:2  trans:0x4db5527a  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 42 (0x1, 0x2a)
============================================================================
TRANS: tid:0x312eb822  type:CHECKPOINT  #items:9  trans:0x312eb822  q:0x667f20
BUF: cnt:2 total:2 a:0x6703b0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6700a0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670160 len:56 a:0x670210 len:96 a:0x670460 len:88 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:88
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670340 len:96 
	INODE: #regs:2   ino:0x8b  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 45 (0x1, 0x2d)
============================================================================
TRANS: tid:0x79d07201  type:CHECKPOINT  #items:2  trans:0x79d07201  q:0x667f20
BUF: cnt:2 total:2 a:0x6703e0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 47 (0x1, 0x2f)
============================================================================
TRANS: tid:0x200f6c5e  type:CHECKPOINT  #items:9  trans:0x200f6c5e  q:0x667f20
BUF: cnt:2 total:2 a:0x6702e0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670310 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670340 len:96 a:0x670210 len:96 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:96
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x670160 len:56 a:0x6704c0 len:96 
	INODE: #regs:2   ino:0x8c  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 50 (0x1, 0x32)
============================================================================
TRANS: tid:0x4506f09a  type:CHECKPOINT  #items:2  trans:0x4506f09a  q:0x667f20
BUF: cnt:2 total:2 a:0x6703b0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 52 (0x1, 0x34)
============================================================================
TRANS: tid:0x94dd4caa  type:CHECKPOINT  #items:9  trans:0x94dd4caa  q:0x667f20
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670160 len:56 a:0x6704c0 len:96 a:0x670530 len:108 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:108
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x8d  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 55 (0x1, 0x37)
============================================================================
TRANS: tid:0xb545b948  type:CHECKPOINT  #items:2  trans:0xb545b948  q:0x667f20
BUF: cnt:2 total:2 a:0x6702e0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 57 (0x1, 0x39)
============================================================================
TRANS: tid:0x6c1ed8ca  type:CHECKPOINT  #items:9  trans:0x6c1ed8ca  q:0x667f20
BUF: cnt:2 total:2 a:0x6701a0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6700a0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670210 len:96 a:0x670530 len:116 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:116
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x670160 len:56 a:0x6704c0 len:96 
	INODE: #regs:2   ino:0x8e  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 60 (0x1, 0x3c)
============================================================================
TRANS: tid:0xde7fe788  type:CHECKPOINT  #items:2  trans:0xde7fe788  q:0x667f20
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 62 (0x1, 0x3e)
============================================================================
TRANS: tid:0x171336ad  type:CHECKPOINT  #items:9  trans:0x171336ad  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670310 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670160 len:56 a:0x6704c0 len:96 a:0x6705b0 len:124 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:124
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x8f  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 65 (0x1, 0x41)
============================================================================
TRANS: tid:0x55fd8fbb  type:CHECKPOINT  #items:2  trans:0x55fd8fbb  q:0x667f20
BUF: cnt:2 total:2 a:0x6701a0 len:28 a:0x6705b0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 67 (0x1, 0x43)
============================================================================
TRANS: tid:0x10989c06  type:CHECKPOINT  #items:9  trans:0x10989c06  q:0x667f20
BUF: cnt:2 total:2 a:0x6703e0 len:28 a:0x6705b0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670210 len:96 a:0x670010 len:132 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:132
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x670160 len:56 a:0x6704c0 len:96 
	INODE: #regs:2   ino:0x90  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 70 (0x1, 0x46)
============================================================================
TRANS: tid:0x22394ba0  type:CHECKPOINT  #items:2  trans:0x22394ba0  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 72 (0x1, 0x48)
============================================================================
TRANS: tid:0x193dc5d0  type:CHECKPOINT  #items:9  trans:0x193dc5d0  q:0x667f20
BUF: cnt:2 total:2 a:0x6703b0 len:28 a:0x670010 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6700a0 len:28 a:0x6700d0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670160 len:56 a:0x6704c0 len:96 a:0x670640 len:144 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:144
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6702a0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x91  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 75 (0x1, 0x4b)
============================================================================
TRANS: tid:0x646a27dd  type:CHECKPOINT  #items:2  trans:0x646a27dd  q:0x667f20
BUF: cnt:2 total:2 a:0x6703e0 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 77 (0x1, 0x4d)
============================================================================
TRANS: tid:0x290239c5  type:CHECKPOINT  #items:9  trans:0x290239c5  q:0x667f20
BUF: cnt:2 total:2 a:0x6702e0 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670340 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6702a0 len:56 a:0x670210 len:96 a:0x670040 len:152 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:152
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x6700e0 len:56 a:0x670410 len:96 
	INODE: #regs:2   ino:0x92  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 80 (0x1, 0x50)
============================================================================
TRANS: tid:0xe5a0df14  type:CHECKPOINT  #items:2  trans:0xe5a0df14  q:0x667f20
BUF: cnt:2 total:2 a:0x670150 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 82 (0x1, 0x52)
============================================================================
TRANS: tid:0xa40bb689  type:CHECKPOINT  #items:18  trans:0xa40bb689  q:0x667f20
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670310 len:28 a:0x670340 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6700e0 len:56 a:0x670410 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:2 total:2 a:0x6702e0 len:28 a:0x670480 len:128 
	BUF:  #regs:2   start blkno:0x1   len:1   bmap size:1   flags:0x0
	AGF Buffer: (XAGF)
BUF: cnt:2 total:2 a:0x6700a0 len:28 a:0x670570 len:128 
	BUF:  #regs:2   start blkno:0x10   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:2 total:2 a:0x670600 len:28 a:0x670690 len:128 
	BUF:  #regs:2   start blkno:0x8   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:3 total:3 a:0x670720 len:28 a:0x670780 len:384 a:0x670910 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x93  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 87 (0x1, 0x57)
============================================================================
TRANS: tid:0xcee7fe1d  type:CHECKPOINT  #items:2  trans:0xcee7fe1d  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x670690 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 89 (0x1, 0x59)
============================================================================
TRANS: tid:0xfc866d3f  type:CHECKPOINT  #items:12  trans:0xfc866d3f  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x670690 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670720 len:28 a:0x670570 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670510 len:28 a:0x670780 len:384 a:0x670910 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670410 len:96 
	INODE: #regs:2   ino:0x94  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 93 (0x1, 0x5d)
============================================================================
TRANS: tid:0x764fa6fd  type:CHECKPOINT  #items:2  trans:0x764fa6fd  q:0x667f20
BUF: cnt:2 total:2 a:0x670070 len:28 a:0x670570 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 95 (0x1, 0x5f)
============================================================================
TRANS: tid:0xca68714b  type:CHECKPOINT  #items:12  trans:0xca68714b  q:0x667f20
BUF: cnt:2 total:2 a:0x670540 len:28 a:0x670570 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670510 len:28 a:0x670690 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670410 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670720 len:28 a:0x670780 len:384 a:0x670910 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x95  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 99 (0x1, 0x63)
============================================================================
TRANS: tid:0x91ee2a41  type:CHECKPOINT  #items:2  trans:0x91ee2a41  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x670690 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 101 (0x1, 0x65)
============================================================================
TRANS: tid:0x6c3994e2  type:CHECKPOINT  #items:12  trans:0x6c3994e2  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x670690 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670720 len:28 a:0x670570 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670510 len:28 a:0x670780 len:384 a:0x670910 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670410 len:96 
	INODE: #regs:2   ino:0x96  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 105 (0x1, 0x69)
============================================================================
TRANS: tid:0x88c87875  type:CHECKPOINT  #items:2  trans:0x88c87875  q:0x667f20
BUF: cnt:2 total:2 a:0x670540 len:28 a:0x670570 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 107 (0x1, 0x6b)
============================================================================
TRANS: tid:0x9b56ec13  type:CHECKPOINT  #items:12  trans:0x9b56ec13  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x670570 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670510 len:28 a:0x670690 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670410 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670720 len:28 a:0x670780 len:512 a:0x670a80 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x97  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 112 (0x1, 0x70)
============================================================================
TRANS: tid:0x7fd34d80  type:CHECKPOINT  #items:2  trans:0x7fd34d80  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 114 (0x1, 0x72)
============================================================================
TRANS: tid:0x26776465  type:CHECKPOINT  #items:12  trans:0x26776465  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x670780 len:512 a:0x6702e0 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0x98  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 119 (0x1, 0x77)
============================================================================
TRANS: tid:0xa2149fd8  type:CHECKPOINT  #items:2  trans:0xa2149fd8  q:0x667f20
BUF: cnt:2 total:2 a:0x670420 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 121 (0x1, 0x79)
============================================================================
TRANS: tid:0xd60faff5  type:CHECKPOINT  #items:12  trans:0xd60faff5  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6704c0 len:512 a:0x6702e0 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x99  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 126 (0x1, 0x7e)
============================================================================
TRANS: tid:0x57fe9708  type:CHECKPOINT  #items:2  trans:0x57fe9708  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 128 (0x1, 0x80)
============================================================================
TRANS: tid:0xd867952b  type:CHECKPOINT  #items:12  trans:0xd867952b  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6704c0 len:512 a:0x6702e0 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0x9a  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 133 (0x1, 0x85)
============================================================================
TRANS: tid:0xba91038d  type:CHECKPOINT  #items:2  trans:0xba91038d  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 135 (0x1, 0x87)
============================================================================
TRANS: tid:0xf1b58a06  type:CHECKPOINT  #items:12  trans:0xf1b58a06  q:0x667f20
BUF: cnt:2 total:2 a:0x6703f0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6704c0 len:512 a:0x6702e0 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x9b  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 140 (0x1, 0x8c)
============================================================================
TRANS: tid:0xd301e349  type:CHECKPOINT  #items:2  trans:0xd301e349  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 142 (0x1, 0x8e)
============================================================================
TRANS: tid:0xac2eb10c  type:CHECKPOINT  #items:12  trans:0xac2eb10c  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6704c0 len:512 a:0x6702e0 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0x9c  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 147 (0x1, 0x93)
============================================================================
TRANS: tid:0x76fe85b4  type:CHECKPOINT  #items:2  trans:0x76fe85b4  q:0x667f20
BUF: cnt:2 total:2 a:0x6703f0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 149 (0x1, 0x95)
============================================================================
TRANS: tid:0x4d37df9b  type:CHECKPOINT  #items:12  trans:0x4d37df9b  q:0x667f20
BUF: cnt:2 total:2 a:0x670420 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6704c0 len:512 a:0x6702e0 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x9d  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 154 (0x1, 0x9a)
============================================================================
TRANS: tid:0xde9c9762  type:CHECKPOINT  #items:2  trans:0xde9c9762  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 156 (0x1, 0x9c)
============================================================================
TRANS: tid:0xfa301dad  type:CHECKPOINT  #items:12  trans:0xfa301dad  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6704c0 len:512 a:0x6702e0 len:256 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0x9e  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 161 (0x1, 0xa1)
============================================================================
TRANS: tid:0xc7a23551  type:CHECKPOINT  #items:2  trans:0xc7a23551  q:0x667f20
BUF: cnt:2 total:2 a:0x670420 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 163 (0x1, 0xa3)
============================================================================
TRANS: tid:0xf7c40e42  type:CHECKPOINT  #items:12  trans:0xf7c40e42  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0x9f  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 168 (0x1, 0xa8)
============================================================================
TRANS: tid:0xea8e4e20  type:CHECKPOINT  #items:2  trans:0xea8e4e20  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 170 (0x1, 0xaa)
============================================================================
TRANS: tid:0x6c61c21e  type:CHECKPOINT  #items:12  trans:0x6c61c21e  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0xa0  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 175 (0x1, 0xaf)
============================================================================
TRANS: tid:0x637e0192  type:CHECKPOINT  #items:2  trans:0x637e0192  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 177 (0x1, 0xb1)
============================================================================
TRANS: tid:0x8447ce60  type:CHECKPOINT  #items:12  trans:0x8447ce60  q:0x667f20
BUF: cnt:2 total:2 a:0x6703f0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xa1  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 182 (0x1, 0xb6)
============================================================================
TRANS: tid:0xbe737298  type:CHECKPOINT  #items:2  trans:0xbe737298  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 184 (0x1, 0xb8)
============================================================================
TRANS: tid:0xb279a62a  type:CHECKPOINT  #items:12  trans:0xb279a62a  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0xa2  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 189 (0x1, 0xbd)
============================================================================
TRANS: tid:0x7db132b8  type:CHECKPOINT  #items:2  trans:0x7db132b8  q:0x667f20
BUF: cnt:2 total:2 a:0x6703f0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 191 (0x1, 0xbf)
============================================================================
TRANS: tid:0x6ce260d3  type:CHECKPOINT  #items:12  trans:0x6ce260d3  q:0x667f20
BUF: cnt:2 total:2 a:0x670420 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xa3  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 196 (0x1, 0xc4)
============================================================================
TRANS: tid:0xea500ebb  type:CHECKPOINT  #items:2  trans:0xea500ebb  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 198 (0x1, 0xc6)
============================================================================
TRANS: tid:0x6a5c08af  type:CHECKPOINT  #items:12  trans:0x6a5c08af  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0xa4  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 203 (0x1, 0xcb)
============================================================================
TRANS: tid:0xa6e8b580  type:CHECKPOINT  #items:2  trans:0xa6e8b580  q:0x667f20
BUF: cnt:2 total:2 a:0x670420 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 205 (0x1, 0xcd)
============================================================================
TRANS: tid:0x99293501  type:CHECKPOINT  #items:12  trans:0x99293501  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xa5  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 210 (0x1, 0xd2)
============================================================================
TRANS: tid:0xf1d93fdb  type:CHECKPOINT  #items:2  trans:0xf1d93fdb  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 212 (0x1, 0xd4)
============================================================================
TRANS: tid:0x37649c3  type:CHECKPOINT  #items:12  trans:0x37649c3  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6704c0 len:640 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670450 len:96 
	INODE: #regs:2   ino:0xa6  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 217 (0x1, 0xd9)
============================================================================
TRANS: tid:0x21c8b24c  type:CHECKPOINT  #items:2  trans:0x21c8b24c  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 219 (0x1, 0xdb)
============================================================================
TRANS: tid:0x2d10ac18  type:CHECKPOINT  #items:12  trans:0x2d10ac18  q:0x667f20
BUF: cnt:2 total:2 a:0x6703f0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670450 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x670a80 len:768 a:0x6704c0 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xa7  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 224 (0x1, 0xe0)
============================================================================
TRANS: tid:0x8286162b  type:CHECKPOINT  #items:2  trans:0x8286162b  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 226 (0x1, 0xe2)
============================================================================
TRANS: tid:0xb5ed1429  type:CHECKPOINT  #items:12  trans:0xb5ed1429  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:768 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670970 len:96 
	INODE: #regs:2   ino:0xa8  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 231 (0x1, 0xe7)
============================================================================
TRANS: tid:0x1fbf54e4  type:CHECKPOINT  #items:2  trans:0x1fbf54e4  q:0x667f20
BUF: cnt:2 total:2 a:0x670940 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 233 (0x1, 0xe9)
============================================================================
TRANS: tid:0x88d4921  type:CHECKPOINT  #items:12  trans:0x88d4921  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670970 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6702e0 len:768 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xa9  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 238 (0x1, 0xee)
============================================================================
TRANS: tid:0xab40c749  type:CHECKPOINT  #items:2  trans:0xab40c749  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 240 (0x1, 0xf0)
============================================================================
TRANS: tid:0x64d91940  type:CHECKPOINT  #items:12  trans:0x64d91940  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:768 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670970 len:96 
	INODE: #regs:2   ino:0xaa  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 245 (0x1, 0xf5)
============================================================================
TRANS: tid:0x5f98adfc  type:CHECKPOINT  #items:2  trans:0x5f98adfc  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 247 (0x1, 0xf7)
============================================================================
TRANS: tid:0x478a7bce  type:CHECKPOINT  #items:12  trans:0x478a7bce  q:0x667f20
BUF: cnt:2 total:2 a:0x670910 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670970 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6702e0 len:768 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xab  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 252 (0x1, 0xfc)
============================================================================
TRANS: tid:0x1c3ceb3e  type:CHECKPOINT  #items:2  trans:0x1c3ceb3e  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 254 (0x1, 0xfe)
============================================================================
TRANS: tid:0xbd7a9a14  type:CHECKPOINT  #items:12  trans:0xbd7a9a14  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:768 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670970 len:96 
	INODE: #regs:2   ino:0xac  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 259 (0x1, 0x103)
============================================================================
TRANS: tid:0xf16506f1  type:CHECKPOINT  #items:2  trans:0xf16506f1  q:0x667f20
BUF: cnt:2 total:2 a:0x670910 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 261 (0x1, 0x105)
============================================================================
TRANS: tid:0x458ff52  type:CHECKPOINT  #items:12  trans:0x458ff52  q:0x667f20
BUF: cnt:2 total:2 a:0x670940 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670970 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6702e0 len:768 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xad  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 266 (0x1, 0x10a)
============================================================================
TRANS: tid:0x9049fea2  type:CHECKPOINT  #items:2  trans:0x9049fea2  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 268 (0x1, 0x10c)
============================================================================
TRANS: tid:0x8630665  type:CHECKPOINT  #items:12  trans:0x8630665  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:768 a:0x670780 len:384 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670970 len:96 
	INODE: #regs:2   ino:0xae  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 273 (0x1, 0x111)
============================================================================
TRANS: tid:0x1931d3af  type:CHECKPOINT  #items:2  trans:0x1931d3af  q:0x667f20
BUF: cnt:2 total:2 a:0x670940 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 275 (0x1, 0x113)
============================================================================
TRANS: tid:0xe7e15169  type:CHECKPOINT  #items:12  trans:0xe7e15169  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670970 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6702e0 len:896 a:0x670a80 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xaf  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 281 (0x1, 0x119)
============================================================================
TRANS: tid:0xba4ae5ce  type:CHECKPOINT  #items:2  trans:0xba4ae5ce  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 283 (0x1, 0x11b)
============================================================================
TRANS: tid:0x1a169348  type:CHECKPOINT  #items:12  trans:0x1a169348  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:896 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670670 len:96 
	INODE: #regs:2   ino:0xb0  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 289 (0x1, 0x121)
============================================================================
TRANS: tid:0xc71a6e7b  type:CHECKPOINT  #items:2  trans:0xc71a6e7b  q:0x667f20
BUF: cnt:2 total:2 a:0x6709c0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 291 (0x1, 0x123)
============================================================================
TRANS: tid:0xae42e1f4  type:CHECKPOINT  #items:12  trans:0xae42e1f4  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670670 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6702e0 len:896 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xb1  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 297 (0x1, 0x129)
============================================================================
TRANS: tid:0x81410f4d  type:CHECKPOINT  #items:2  trans:0x81410f4d  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 299 (0x1, 0x12b)
============================================================================
TRANS: tid:0x1f610c44  type:CHECKPOINT  #items:12  trans:0x1f610c44  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:896 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670670 len:96 
	INODE: #regs:2   ino:0xb2  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 305 (0x1, 0x131)
============================================================================
TRANS: tid:0xbc50d1a5  type:CHECKPOINT  #items:2  trans:0xbc50d1a5  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 307 (0x1, 0x133)
============================================================================
TRANS: tid:0xe38264d8  type:CHECKPOINT  #items:12  trans:0xe38264d8  q:0x667f20
BUF: cnt:2 total:2 a:0x670990 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670670 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6702e0 len:896 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xb3  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 313 (0x1, 0x139)
============================================================================
TRANS: tid:0x2dbdd921  type:CHECKPOINT  #items:2  trans:0x2dbdd921  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 315 (0x1, 0x13b)
============================================================================
TRANS: tid:0x2bdfb337  type:CHECKPOINT  #items:12  trans:0x2bdfb337  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:896 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670670 len:96 
	INODE: #regs:2   ino:0xb4  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 321 (0x1, 0x141)
============================================================================
TRANS: tid:0x201c9944  type:CHECKPOINT  #items:2  trans:0x201c9944  q:0x667f20
BUF: cnt:2 total:2 a:0x670990 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 323 (0x1, 0x143)
============================================================================
TRANS: tid:0xa1dd679e  type:CHECKPOINT  #items:12  trans:0xa1dd679e  q:0x667f20
BUF: cnt:2 total:2 a:0x6709c0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670670 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6702e0 len:896 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xb5  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 329 (0x1, 0x149)
============================================================================
TRANS: tid:0x3a7504a1  type:CHECKPOINT  #items:2  trans:0x3a7504a1  q:0x667f20
BUF: cnt:2 total:2 a:0x670a20 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 331 (0x1, 0x14b)
============================================================================
TRANS: tid:0x11a57df1  type:CHECKPOINT  #items:12  trans:0x11a57df1  q:0x667f20
BUF: cnt:2 total:2 a:0x670a50 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670130 len:28 a:0x6702e0 len:896 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6701d0 len:56 a:0x670670 len:96 
	INODE: #regs:2   ino:0xb6  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 337 (0x1, 0x151)
============================================================================
TRANS: tid:0x55d022f1  type:CHECKPOINT  #items:2  trans:0x55d022f1  q:0x667f20
BUF: cnt:2 total:2 a:0x6709c0 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 339 (0x1, 0x153)
============================================================================
TRANS: tid:0xa54b194d  type:CHECKPOINT  #items:12  trans:0xa54b194d  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x670070 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670130 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6701d0 len:56 a:0x670670 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x667fd0 len:28 a:0x6709f0 len:1024 a:0x670780 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670210 len:96 
	INODE: #regs:2   ino:0xb7  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 345 (0x1, 0x159)
============================================================================
TRANS: tid:0x2c6fd2e0  type:CHECKPOINT  #items:2  trans:0x2c6fd2e0  q:0x667f20
BUF: cnt:2 total:2 a:0x670750 len:28 a:0x667f70 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 347 (0x1, 0x15b)
============================================================================
TRANS: tid:0x774a59cf  type:CHECKPOINT  #items:12  trans:0x774a59cf  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x667f70 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x6700a0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670710 len:56 a:0x670210 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670160 len:28 a:0x670780 len:1024 a:0x6702e0 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6704f0 len:56 a:0x670590 len:96 
	INODE: #regs:2   ino:0xb8  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 353 (0x1, 0x161)
============================================================================
TRANS: tid:0x6b004ead  type:CHECKPOINT  #items:2  trans:0x6b004ead  q:0x667f20
BUF: cnt:2 total:2 a:0x670560 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 355 (0x1, 0x163)
============================================================================
TRANS: tid:0xd2336ea  type:CHECKPOINT  #items:12  trans:0xd2336ea  q:0x667f20
BUF: cnt:2 total:2 a:0x670190 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x667fd0 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6704f0 len:56 a:0x670590 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670040 len:28 a:0x670600 len:1024 a:0x6702e0 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6700e0 len:56 a:0x670a10 len:96 
	INODE: #regs:2   ino:0xb9  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 361 (0x1, 0x169)
============================================================================
TRANS: tid:0xbe52277b  type:CHECKPOINT  #items:2  trans:0xbe52277b  q:0x667f20
BUF: cnt:2 total:2 a:0x670070 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 363 (0x1, 0x16b)
============================================================================
TRANS: tid:0x34979131  type:CHECKPOINT  #items:12  trans:0x34979131  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670150 len:56 a:0x670a10 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670560 len:28 a:0x670590 len:1024 a:0x6702a0 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x6709a0 len:96 
	INODE: #regs:2   ino:0xba  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 369 (0x1, 0x171)
============================================================================
TRANS: tid:0x7fbf6b5a  type:CHECKPOINT  #items:2  trans:0x7fbf6b5a  q:0x667f20
BUF: cnt:2 total:2 a:0x6704e0 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 371 (0x1, 0x173)
============================================================================
TRANS: tid:0x8d88bc95  type:CHECKPOINT  #items:12  trans:0x8d88bc95  q:0x667f20
BUF: cnt:2 total:2 a:0x670190 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670560 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x6709a0 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x670590 len:1024 a:0x6702a0 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670150 len:56 a:0x670a10 len:96 
	INODE: #regs:2   ino:0xbb  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 377 (0x1, 0x179)
============================================================================
TRANS: tid:0xd6d97427  type:CHECKPOINT  #items:2  trans:0xd6d97427  q:0x667f20
BUF: cnt:2 total:2 a:0x670070 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 379 (0x1, 0x17b)
============================================================================
TRANS: tid:0xdb57e1db  type:CHECKPOINT  #items:12  trans:0xdb57e1db  q:0x667f20
BUF: cnt:2 total:2 a:0x670120 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670150 len:56 a:0x670a10 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670560 len:28 a:0x670590 len:1024 a:0x6702a0 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x6709a0 len:96 
	INODE: #regs:2   ino:0xbc  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 385 (0x1, 0x181)
============================================================================
TRANS: tid:0x544718d3  type:CHECKPOINT  #items:2  trans:0x544718d3  q:0x667f20
BUF: cnt:2 total:2 a:0x6704e0 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 387 (0x1, 0x183)
============================================================================
TRANS: tid:0x1bedd1b0  type:CHECKPOINT  #items:12  trans:0x1bedd1b0  q:0x667f20
BUF: cnt:2 total:2 a:0x6704b0 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670560 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x6709a0 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x670590 len:1024 a:0x6702a0 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670120 len:56 a:0x670a10 len:96 
	INODE: #regs:2   ino:0xbd  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 393 (0x1, 0x189)
============================================================================
TRANS: tid:0x5fb0d2bc  type:CHECKPOINT  #items:2  trans:0x5fb0d2bc  q:0x667f20
BUF: cnt:2 total:2 a:0x670160 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 395 (0x1, 0x18b)
============================================================================
TRANS: tid:0xf72a40f1  type:CHECKPOINT  #items:12  trans:0xf72a40f1  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670120 len:56 a:0x670a10 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670560 len:28 a:0x670590 len:1024 a:0x6702a0 len:512 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x6709a0 len:96 
	INODE: #regs:2   ino:0xbe  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 401 (0x1, 0x191)
============================================================================
TRANS: tid:0x48cb323b  type:CHECKPOINT  #items:2  trans:0x48cb323b  q:0x667f20
BUF: cnt:2 total:2 a:0x6704e0 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 403 (0x1, 0x193)
============================================================================
TRANS: tid:0x7c49d3f1  type:CHECKPOINT  #items:12  trans:0x7c49d3f1  q:0x667f20
BUF: cnt:2 total:2 a:0x670190 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670560 len:28 a:0x6701f0 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x6709a0 len:96 a:0x670280 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x670a10 len:1152 a:0x670590 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670820 len:56 a:0x670120 len:96 
	INODE: #regs:2   ino:0xbf  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 410 (0x1, 0x19a)
============================================================================
TRANS: tid:0x86028200  type:CHECKPOINT  #items:2  trans:0x86028200  q:0x667f20
BUF: cnt:2 total:2 a:0x670860 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 412 (0x1, 0x19c)
============================================================================
TRANS: tid:0xfe3fc7b0  type:CHECKPOINT  #items:52  trans:0xfe3fc7b0  q:0x667f20
BUF: cnt:2 total:2 a:0x670070 len:28 a:0x667f40 len:128 
	BUF:  #regs:2   start blkno:0x1   len:1   bmap size:1   flags:0x0
	AGF Buffer: (XAGF)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x670190 len:128 
	BUF:  #regs:2   start blkno:0x10   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:2 total:2 a:0x670220 len:28 a:0x6702b0 len:128 
	BUF:  #regs:2   start blkno:0x8   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:17 total:17 a:0x670340 len:28 a:0x6704c0 len:128 a:0x670550 len:128 a:0x6705e0 len:128 a:0x670670 len:128 a:0x670700 len:128 a:0x670790 len:128 a:0x670890 len:128 a:0x670920 len:128 a:0x6709b0 len:128 a:0x670a40 len:128 a:0x670ad0 len:128 a:0x670b60 len:128 a:0x670bf0 len:128 a:0x670c80 len:128 a:0x670d10 len:128 a:0x670da0 len:128 
	BUF:  #regs:17   start blkno:0x70   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
BUF: cnt:17 total:17 a:0x667bc0 len:28 a:0x670f80 len:128 a:0x671010 len:128 a:0x6710a0 len:128 a:0x671130 len:128 a:0x6711c0 len:128 a:0x671250 len:128 a:0x6712e0 len:128 a:0x671370 len:128 a:0x671400 len:128 a:0x671490 len:128 a:0x671520 len:128 a:0x6715b0 len:128 a:0x671640 len:128 a:0x6716d0 len:128 a:0x671760 len:128 a:0x6717f0 len:128 
	BUF:  #regs:17   start blkno:0x80   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
BUF: cnt:2 total:2 a:0x671880 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6719a0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670820 len:56 a:0x670120 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671b10 len:28 a:0x671bb0 len:1152 a:0x672040 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6722d0 len:56 a:0x672370 len:96 
	INODE: #regs:2   ino:0xe0  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 429 (0x1, 0x1ad)
============================================================================
TRANS: tid:0xf44528c9  type:CHECKPOINT  #items:2  trans:0xf44528c9  q:0x667f20
BUF: cnt:2 total:2 a:0x672340 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 431 (0x1, 0x1af)
============================================================================
TRANS: tid:0x31e2ac8  type:CHECKPOINT  #items:12  trans:0x31e2ac8  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6722d0 len:56 a:0x672370 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x6719a0 len:28 a:0x671bb0 len:1152 a:0x672040 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x667f70 len:96 
	INODE: #regs:2   ino:0xe1  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 438 (0x1, 0x1b6)
============================================================================
TRANS: tid:0xe445d090  type:CHECKPOINT  #items:2  trans:0xe445d090  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 440 (0x1, 0x1b8)
============================================================================
TRANS: tid:0x6c02f365  type:CHECKPOINT  #items:12  trans:0x6c02f365  q:0x667f20
BUF: cnt:2 total:2 a:0x6718b0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6719a0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x667f70 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671b10 len:28 a:0x671bb0 len:1152 a:0x672040 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6722d0 len:56 a:0x670040 len:96 
	INODE: #regs:2   ino:0xe2  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 447 (0x1, 0x1bf)
============================================================================
TRANS: tid:0xfcf4d619  type:CHECKPOINT  #items:2  trans:0xfcf4d619  q:0x667f20
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 449 (0x1, 0x1c1)
============================================================================
TRANS: tid:0xebb8c162  type:CHECKPOINT  #items:12  trans:0xebb8c162  q:0x667f20
BUF: cnt:2 total:2 a:0x672310 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x6722d0 len:56 a:0x670040 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x6719a0 len:28 a:0x671bb0 len:1152 a:0x672040 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x667f70 len:96 
	INODE: #regs:2   ino:0xe3  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 456 (0x1, 0x1c8)
============================================================================
TRANS: tid:0xdaa1103e  type:CHECKPOINT  #items:2  trans:0xdaa1103e  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 458 (0x1, 0x1ca)
============================================================================
TRANS: tid:0x72fe32c3  type:CHECKPOINT  #items:12  trans:0x72fe32c3  q:0x667f20
BUF: cnt:2 total:2 a:0x6718e0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6719a0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x667f70 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671b10 len:28 a:0x670120 len:1152 a:0x6705b0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670840 len:56 a:0x6708e0 len:96 
	INODE: #regs:2   ino:0xe4  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 465 (0x1, 0x1d1)
============================================================================
TRANS: tid:0x374229de  type:CHECKPOINT  #items:2  trans:0x374229de  q:0x667f20
BUF: cnt:2 total:2 a:0x6708b0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 467 (0x1, 0x1d3)
============================================================================
TRANS: tid:0x3497256f  type:CHECKPOINT  #items:12  trans:0x3497256f  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670840 len:56 a:0x6708e0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x6719a0 len:28 a:0x670120 len:1152 a:0x6705b0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x667f40 len:96 
	INODE: #regs:2   ino:0xe5  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 474 (0x1, 0x1da)
============================================================================
TRANS: tid:0x116145b7  type:CHECKPOINT  #items:2  trans:0x116145b7  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 476 (0x1, 0x1dc)
============================================================================
TRANS: tid:0xc35ec04b  type:CHECKPOINT  #items:12  trans:0xc35ec04b  q:0x667f20
BUF: cnt:2 total:2 a:0x6700b0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6719a0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x667f40 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671b10 len:28 a:0x670120 len:1152 a:0x6705b0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670070 len:56 a:0x6708b0 len:96 
	INODE: #regs:2   ino:0xe6  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 483 (0x1, 0x1e3)
============================================================================
TRANS: tid:0xf719722f  type:CHECKPOINT  #items:2  trans:0xf719722f  q:0x667f20
BUF: cnt:2 total:2 a:0x670880 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 485 (0x1, 0x1e5)
============================================================================
TRANS: tid:0x6acc0ccf  type:CHECKPOINT  #items:12  trans:0x6acc0ccf  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670840 len:56 a:0x6708b0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1280 a:0x670920 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670c10 len:96 
	INODE: #regs:2   ino:0xe7  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 492 (0x1, 0x1ec)
============================================================================
TRANS: tid:0x4f6cd33f  type:CHECKPOINT  #items:2  trans:0x4f6cd33f  q:0x667f20
BUF: cnt:2 total:2 a:0x670be0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 494 (0x1, 0x1ee)
============================================================================
TRANS: tid:0x772693d  type:CHECKPOINT  #items:12  trans:0x772693d  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670c10 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1280 a:0x6705c0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670850 len:56 a:0x6708c0 len:96 
	INODE: #regs:2   ino:0xe8  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 501 (0x1, 0x1f5)
============================================================================
TRANS: tid:0x2010bdbe  type:CHECKPOINT  #items:2  trans:0x2010bdbe  q:0x667f20
BUF: cnt:2 total:2 a:0x670890 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 503 (0x1, 0x1f7)
============================================================================
TRANS: tid:0xbbebb8d  type:CHECKPOINT  #items:12  trans:0xbbebb8d  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670850 len:56 a:0x6708c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1280 a:0x6705c0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x667f70 len:96 
	INODE: #regs:2   ino:0xe9  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 510 (0x1, 0x1fe)
============================================================================
TRANS: tid:0x25287c26  type:CHECKPOINT  #items:2  trans:0x25287c26  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 512 (0x1, 0x200)
============================================================================
TRANS: tid:0x2399754  type:CHECKPOINT  #items:12  trans:0x2399754  q:0x667f20
BUF: cnt:2 total:2 a:0x670bb0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x667f70 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1280 a:0x6705c0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670850 len:56 a:0x6708c0 len:96 
	INODE: #regs:2   ino:0xea  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 519 (0x1, 0x207)
============================================================================
TRANS: tid:0x53ab3dc  type:CHECKPOINT  #items:2  trans:0x53ab3dc  q:0x667f20
BUF: cnt:2 total:2 a:0x670890 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 521 (0x1, 0x209)
============================================================================
TRANS: tid:0xf97e3f2e  type:CHECKPOINT  #items:12  trans:0xf97e3f2e  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670850 len:56 a:0x6708c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1280 a:0x6705c0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670930 len:96 
	INODE: #regs:2   ino:0xeb  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 528 (0x1, 0x210)
============================================================================
TRANS: tid:0x24e627d8  type:CHECKPOINT  #items:2  trans:0x24e627d8  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 530 (0x1, 0x212)
============================================================================
TRANS: tid:0xaf3bbd09  type:CHECKPOINT  #items:12  trans:0xaf3bbd09  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670930 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1280 a:0x6705c0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670850 len:56 a:0x6708c0 len:96 
	INODE: #regs:2   ino:0xec  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 537 (0x1, 0x219)
============================================================================
TRANS: tid:0xf61a2f10  type:CHECKPOINT  #items:2  trans:0xf61a2f10  q:0x667f20
BUF: cnt:2 total:2 a:0x670890 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 539 (0x1, 0x21b)
============================================================================
TRANS: tid:0x3874f869  type:CHECKPOINT  #items:12  trans:0x3874f869  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670850 len:56 a:0x6708c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1280 a:0x6705c0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670930 len:96 
	INODE: #regs:2   ino:0xed  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 546 (0x1, 0x222)
============================================================================
TRANS: tid:0x570bd784  type:CHECKPOINT  #items:2  trans:0x570bd784  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 548 (0x1, 0x224)
============================================================================
TRANS: tid:0x53685838  type:CHECKPOINT  #items:12  trans:0x53685838  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670930 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1280 a:0x6705c0 len:640 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670850 len:56 a:0x6708c0 len:96 
	INODE: #regs:2   ino:0xee  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 555 (0x1, 0x22b)
============================================================================
TRANS: tid:0xc248c703  type:CHECKPOINT  #items:2  trans:0xc248c703  q:0x667f20
BUF: cnt:2 total:2 a:0x670890 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 557 (0x1, 0x22d)
============================================================================
TRANS: tid:0x8167f4e5  type:CHECKPOINT  #items:12  trans:0x8167f4e5  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670850 len:56 a:0x6708c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1408 a:0x670930 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670ca0 len:96 
	INODE: #regs:2   ino:0xef  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 564 (0x1, 0x234)
============================================================================
TRANS: tid:0x6803faa5  type:CHECKPOINT  #items:2  trans:0x6803faa5  q:0x667f20
BUF: cnt:2 total:2 a:0x670c70 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 566 (0x1, 0x236)
============================================================================
TRANS: tid:0xbfa5bd28  type:CHECKPOINT  #items:12  trans:0xbfa5bd28  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670ca0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1408 a:0x670640 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670950 len:56 a:0x6709c0 len:96 
	INODE: #regs:2   ino:0xf0  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 573 (0x1, 0x23d)
============================================================================
TRANS: tid:0x5201b1d9  type:CHECKPOINT  #items:2  trans:0x5201b1d9  q:0x667f20
BUF: cnt:2 total:2 a:0x670990 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 575 (0x1, 0x23f)
============================================================================
TRANS: tid:0x177ce549  type:CHECKPOINT  #items:12  trans:0x177ce549  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670950 len:56 a:0x6709c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1408 a:0x670640 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x667f70 len:96 
	INODE: #regs:2   ino:0xf1  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 582 (0x1, 0x246)
============================================================================
TRANS: tid:0xa437f433  type:CHECKPOINT  #items:2  trans:0xa437f433  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 584 (0x1, 0x248)
============================================================================
TRANS: tid:0x3e88388a  type:CHECKPOINT  #items:12  trans:0x3e88388a  q:0x667f20
BUF: cnt:2 total:2 a:0x670c40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x667f70 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1408 a:0x670640 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670950 len:56 a:0x6709c0 len:96 
	INODE: #regs:2   ino:0xf2  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 591 (0x1, 0x24f)
============================================================================
TRANS: tid:0xdc5ca3a4  type:CHECKPOINT  #items:2  trans:0xdc5ca3a4  q:0x667f20
BUF: cnt:2 total:2 a:0x670990 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 593 (0x1, 0x251)
============================================================================
TRANS: tid:0xd96276b  type:CHECKPOINT  #items:12  trans:0xd96276b  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670950 len:56 a:0x6709c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1408 a:0x670640 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670a30 len:96 
	INODE: #regs:2   ino:0xf3  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 600 (0x1, 0x258)
============================================================================
TRANS: tid:0x721d3ba0  type:CHECKPOINT  #items:2  trans:0x721d3ba0  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 602 (0x1, 0x25a)
============================================================================
TRANS: tid:0x4e36fae5  type:CHECKPOINT  #items:12  trans:0x4e36fae5  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670a30 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1408 a:0x670640 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670950 len:56 a:0x6709c0 len:96 
	INODE: #regs:2   ino:0xf4  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 609 (0x1, 0x261)
============================================================================
TRANS: tid:0x25303f42  type:CHECKPOINT  #items:2  trans:0x25303f42  q:0x667f20
BUF: cnt:2 total:2 a:0x670990 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 611 (0x1, 0x263)
============================================================================
TRANS: tid:0xd6814cc8  type:CHECKPOINT  #items:12  trans:0xd6814cc8  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670950 len:56 a:0x6709c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1408 a:0x670640 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670a30 len:96 
	INODE: #regs:2   ino:0xf5  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 618 (0x1, 0x26a)
============================================================================
TRANS: tid:0x10eae5da  type:CHECKPOINT  #items:2  trans:0x10eae5da  q:0x667f20
BUF: cnt:2 total:2 a:0x667f70 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 620 (0x1, 0x26c)
============================================================================
TRANS: tid:0x1d5725dd  type:CHECKPOINT  #items:12  trans:0x1d5725dd  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670a30 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1408 a:0x670640 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670950 len:56 a:0x6709c0 len:96 
	INODE: #regs:2   ino:0xf6  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 627 (0x1, 0x273)
============================================================================
TRANS: tid:0x2eff2418  type:CHECKPOINT  #items:2  trans:0x2eff2418  q:0x667f20
BUF: cnt:2 total:2 a:0x670990 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 629 (0x1, 0x275)
============================================================================
TRANS: tid:0xd14502cf  type:CHECKPOINT  #items:12  trans:0xd14502cf  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670950 len:56 a:0x6709c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1536 a:0x670a30 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670da0 len:96 
	INODE: #regs:2   ino:0xf7  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 637 (0x1, 0x27d)
============================================================================
TRANS: tid:0x5affa6b5  type:CHECKPOINT  #items:2  trans:0x5affa6b5  q:0x667f20
BUF: cnt:2 total:2 a:0x670d70 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 639 (0x1, 0x27f)
============================================================================
TRANS: tid:0x70e72167  type:CHECKPOINT  #items:12  trans:0x70e72167  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670da0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x670e10 len:1536 a:0x671420 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x671730 len:56 a:0x6717a0 len:96 
	INODE: #regs:2   ino:0xf8  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 647 (0x1, 0x287)
============================================================================
TRANS: tid:0xec59def4  type:CHECKPOINT  #items:2  trans:0xec59def4  q:0x667f20
BUF: cnt:2 total:2 a:0x671770 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 649 (0x1, 0x289)
============================================================================
TRANS: tid:0x7c1aa6df  type:CHECKPOINT  #items:12  trans:0x7c1aa6df  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x671730 len:56 a:0x6717a0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x670d70 len:1536 a:0x671380 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x6716c0 len:96 
	INODE: #regs:2   ino:0xf9  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 657 (0x1, 0x291)
============================================================================
TRANS: tid:0x4ba52118  type:CHECKPOINT  #items:2  trans:0x4ba52118  q:0x667f20
BUF: cnt:2 total:2 a:0x671690 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 659 (0x1, 0x293)
============================================================================
TRANS: tid:0x321bc0fe  type:CHECKPOINT  #items:12  trans:0x321bc0fe  q:0x667f20
BUF: cnt:2 total:2 a:0x670d40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x6716c0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x670d70 len:1536 a:0x671380 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667f40 len:56 a:0x671730 len:96 
	INODE: #regs:2   ino:0xfa  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 667 (0x1, 0x29b)
============================================================================
TRANS: tid:0x2e3a1278  type:CHECKPOINT  #items:2  trans:0x2e3a1278  q:0x667f20
BUF: cnt:2 total:2 a:0x667f80 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 669 (0x1, 0x29d)
============================================================================
TRANS: tid:0x9898732e  type:CHECKPOINT  #items:12  trans:0x9898732e  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667f40 len:56 a:0x671730 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1536 a:0x6706c0 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670a30 len:96 
	INODE: #regs:2   ino:0xfb  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 677 (0x1, 0x2a5)
============================================================================
TRANS: tid:0xc7313f85  type:CHECKPOINT  #items:2  trans:0xc7313f85  q:0x667f20
BUF: cnt:2 total:2 a:0x670a00 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 679 (0x1, 0x2a7)
============================================================================
TRANS: tid:0xa002626e  type:CHECKPOINT  #items:12  trans:0xa002626e  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670a30 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1536 a:0x6706c0 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667f40 len:56 a:0x670aa0 len:96 
	INODE: #regs:2   ino:0xfc  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 687 (0x1, 0x2af)
============================================================================
TRANS: tid:0xcd01533d  type:CHECKPOINT  #items:2  trans:0xcd01533d  q:0x667f20
BUF: cnt:2 total:2 a:0x667f80 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 689 (0x1, 0x2b1)
============================================================================
TRANS: tid:0xb72d4d98  type:CHECKPOINT  #items:12  trans:0xb72d4d98  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667f40 len:56 a:0x670aa0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1536 a:0x6706c0 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670a00 len:96 
	INODE: #regs:2   ino:0xfd  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 697 (0x1, 0x2b9)
============================================================================
TRANS: tid:0x94d728ef  type:CHECKPOINT  #items:2  trans:0x94d728ef  q:0x667f20
BUF: cnt:2 total:2 a:0x667fb0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 699 (0x1, 0x2bb)
============================================================================
TRANS: tid:0x106c9575  type:CHECKPOINT  #items:12  trans:0x106c9575  q:0x667f20
BUF: cnt:2 total:2 a:0x6709d0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670a00 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x6700b0 len:1536 a:0x6706c0 len:768 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667f40 len:56 a:0x670a70 len:96 
	INODE: #regs:2   ino:0xfe  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 707 (0x1, 0x2c3)
============================================================================
TRANS: tid:0xe4a774be  type:CHECKPOINT  #items:2  trans:0xe4a774be  q:0x667f20
BUF: cnt:2 total:2 a:0x667f80 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 709 (0x1, 0x2c5)
============================================================================
TRANS: tid:0x588a81f3  type:CHECKPOINT  #items:12  trans:0x588a81f3  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667f40 len:56 a:0x670a70 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x6700b0 len:1664 a:0x670ae0 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670ed0 len:96 
	INODE: #regs:2   ino:0xff  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 717 (0x1, 0x2cd)
============================================================================
TRANS: tid:0x5abb2ab0  type:CHECKPOINT  #items:2  trans:0x5abb2ab0  q:0x667f20
BUF: cnt:2 total:2 a:0x670ea0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 719 (0x1, 0x2cf)
============================================================================
TRANS: tid:0xc1c3f70a  type:CHECKPOINT  #items:12  trans:0xc1c3f70a  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x670ed0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x670f40 len:1664 a:0x6700b0 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670440 len:56 a:0x6704b0 len:96 
	INODE: #regs:2   ino:0x100  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 727 (0x1, 0x2d7)
============================================================================
TRANS: tid:0x282f668b  type:CHECKPOINT  #items:2  trans:0x282f668b  q:0x667f20
BUF: cnt:2 total:2 a:0x670480 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 729 (0x1, 0x2d9)
============================================================================
TRANS: tid:0xa82af053  type:CHECKPOINT  #items:12  trans:0xa82af053  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670440 len:56 a:0x6704b0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x670520 len:1664 a:0x6700b0 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x667f70 len:96 
	INODE: #regs:2   ino:0x101  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 737 (0x1, 0x2e1)
============================================================================
TRANS: tid:0xed846bca  type:CHECKPOINT  #items:2  trans:0xed846bca  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 739 (0x1, 0x2e3)
============================================================================
TRANS: tid:0x6ca4f13c  type:CHECKPOINT  #items:12  trans:0x6ca4f13c  q:0x667f20
BUF: cnt:2 total:2 a:0x670e70 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x667bc0 len:56 a:0x667f70 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x670ea0 len:1664 a:0x671530 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x6718c0 len:56 a:0x6700e0 len:96 
	INODE: #regs:2   ino:0x102  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 747 (0x1, 0x2eb)
============================================================================
TRANS: tid:0x22592010  type:CHECKPOINT  #items:2  trans:0x22592010  q:0x667f20
BUF: cnt:2 total:2 a:0x6700b0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 749 (0x1, 0x2ed)
============================================================================
TRANS: tid:0xb6eeb8b  type:CHECKPOINT  #items:12  trans:0xb6eeb8b  q:0x667f20
BUF: cnt:2 total:2 a:0x671b10 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670070 len:56 a:0x6700e0 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x670150 len:1664 a:0x6707e0 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670b70 len:56 a:0x670c10 len:96 
	INODE: #regs:2   ino:0x103  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 757 (0x1, 0x2f5)
============================================================================
TRANS: tid:0xabb39a21  type:CHECKPOINT  #items:2  trans:0xabb39a21  q:0x667f20
BUF: cnt:2 total:2 a:0x670be0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 759 (0x1, 0x2f7)
============================================================================
TRANS: tid:0xc7ba7744  type:CHECKPOINT  #items:12  trans:0xc7ba7744  q:0x667f20
BUF: cnt:2 total:2 a:0x670040 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670b70 len:56 a:0x670c10 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x670070 len:1664 a:0x670700 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670a90 len:56 a:0x670b00 len:96 
	INODE: #regs:2   ino:0x104  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 767 (0x1, 0x2ff)
============================================================================
TRANS: tid:0xc5132b90  type:CHECKPOINT  #items:2  trans:0xc5132b90  q:0x667f20
BUF: cnt:2 total:2 a:0x670ad0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 769 (0x1, 0x301)
============================================================================
TRANS: tid:0x913519e6  type:CHECKPOINT  #items:12  trans:0x913519e6  q:0x667f20
BUF: cnt:2 total:2 a:0x671b40 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x671ac0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670a90 len:56 a:0x670b00 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x670010 len:28 a:0x670040 len:1664 a:0x6706d0 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670b70 len:56 a:0x667f70 len:96 
	INODE: #regs:2   ino:0x105  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 777 (0x1, 0x309)
============================================================================
TRANS: tid:0xf0faaaa6  type:CHECKPOINT  #items:2  trans:0xf0faaaa6  q:0x667f20
BUF: cnt:2 total:2 a:0x667f40 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 779 (0x1, 0x30b)
============================================================================
TRANS: tid:0x2c2462fc  type:CHECKPOINT  #items:12  trans:0x2c2462fc  q:0x667f20
BUF: cnt:2 total:2 a:0x670bb0 len:28 a:0x671910 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x670010 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x670b70 len:56 a:0x667f70 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:
BUF: cnt:3 total:3 a:0x671ac0 len:28 a:0x670040 len:1664 a:0x6706d0 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x670a90 len:56 a:0x670b00 len:96 
	INODE: #regs:2   ino:0x106  flags:0x1   dsize:0
	CORE inode:

LOG REC AT LSN cycle 1 block 787 (0x1, 0x313)
============================================================================
TRANS: tid:0xc2f49e3a  type:CHECKPOINT  #items:2  trans:0xc2f49e3a  q:0x667f20
BUF: cnt:2 total:2 a:0x670ad0 len:28 a:0x671a30 len:128 
	BUF:  #regs:2   start blkno:0x0   len:1   bmap size:1   flags:0x0
	SUPER Block Buffer:

LOG REC AT LSN cycle 1 block 789 (0x1, 0x315)
============================================================================
TRANS: tid:0x1d0da17d  type:CHECKPOINT  #items:3  trans:0x1d0da17d  q:0x667f20
INO: cnt:3 total:3 a:0x670a90 len:56 a:0x670b00 len:96 a:0x671af0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:

*** mount with replay ***

mount: Structure needs cleaning
mount failed: -o logbsize=32k

*** mkfs ***

meta-data=/dev/sdb4              isize=256    agcount=4, agsize=2170232 blks
         =                       sectsz=512   attr=2, projid32bit=0
data     =                       bsize=4096   blocks=8680926, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0
log      =internal log           bsize=4096   blocks=4238, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

*** mount ***


*** ls SCRATCH_MNT ***


*** godown ***

Opening "/mnt/scratch"
Calling XFS_IOC_GOINGDOWN

*** unmount ***


*** logprint after going down... ***

xfs_logprint:
    data device: 0xa0010300
    log device: 0xa0010300 daddr: 34723744 length: 33904

    log tail: 2 head: 54 state: <DIRTY>


LOG REC AT LSN cycle 1 block 2 (0x1, 0x2)
============================================================================
TRANS: tid:0x99dde0c5  type:CHECKPOINT  #items:250  trans:0x99dde0c5  q:0x667f20
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670010 len:96 
	INODE: #regs:2   ino:0x83  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x667fa0 len:56 a:0x6700e0 len:96 
	INODE: #regs:2   ino:0x84  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670150 len:56 a:0x6701f0 len:96 
	INODE: #regs:2   ino:0x85  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670260 len:56 a:0x670300 len:96 
	INODE: #regs:2   ino:0x86  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670370 len:56 a:0x670410 len:96 
	INODE: #regs:2   ino:0x87  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670480 len:56 a:0x670520 len:96 
	INODE: #regs:2   ino:0x88  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670590 len:56 a:0x670630 len:96 
	INODE: #regs:2   ino:0x89  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6706a0 len:56 a:0x670740 len:96 
	INODE: #regs:2   ino:0x8a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6707b0 len:56 a:0x670850 len:96 
	INODE: #regs:2   ino:0x8b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6708c0 len:56 a:0x670960 len:96 
	INODE: #regs:2   ino:0x8c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6709d0 len:56 a:0x670a70 len:96 
	INODE: #regs:2   ino:0x8d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670ae0 len:56 a:0x670b80 len:96 
	INODE: #regs:2   ino:0x8e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670bf0 len:56 a:0x670c90 len:96 
	INODE: #regs:2   ino:0x8f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670d00 len:56 a:0x670da0 len:96 
	INODE: #regs:2   ino:0x90  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670e10 len:56 a:0x670eb0 len:96 
	INODE: #regs:2   ino:0x91  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670f20 len:56 a:0x670fc0 len:96 
	INODE: #regs:2   ino:0x92  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671030 len:56 a:0x6710d0 len:96 
	INODE: #regs:2   ino:0x93  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671140 len:56 a:0x6711e0 len:96 
	INODE: #regs:2   ino:0x94  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671250 len:56 a:0x6712f0 len:96 
	INODE: #regs:2   ino:0x95  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671360 len:56 a:0x671400 len:96 
	INODE: #regs:2   ino:0x96  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671470 len:56 a:0x671510 len:96 
	INODE: #regs:2   ino:0x97  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671580 len:56 a:0x671620 len:96 
	INODE: #regs:2   ino:0x98  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671690 len:56 a:0x671730 len:96 
	INODE: #regs:2   ino:0x99  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6717a0 len:56 a:0x671840 len:96 
	INODE: #regs:2   ino:0x9a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6718b0 len:56 a:0x671950 len:96 
	INODE: #regs:2   ino:0x9b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6719c0 len:56 a:0x671a60 len:96 
	INODE: #regs:2   ino:0x9c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671ad0 len:56 a:0x671b70 len:96 
	INODE: #regs:2   ino:0x9d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671be0 len:56 a:0x671c80 len:96 
	INODE: #regs:2   ino:0x9e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671cf0 len:56 a:0x671d90 len:96 
	INODE: #regs:2   ino:0x9f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671e00 len:56 a:0x671ea0 len:96 
	INODE: #regs:2   ino:0xa0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671f10 len:56 a:0x671fb0 len:96 
	INODE: #regs:2   ino:0xa1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672020 len:56 a:0x6720c0 len:96 
	INODE: #regs:2   ino:0xa2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672130 len:56 a:0x6721d0 len:96 
	INODE: #regs:2   ino:0xa3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672240 len:56 a:0x6722e0 len:96 
	INODE: #regs:2   ino:0xa4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672350 len:56 a:0x6723f0 len:96 
	INODE: #regs:2   ino:0xa5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672460 len:56 a:0x672500 len:96 
	INODE: #regs:2   ino:0xa6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672570 len:56 a:0x672610 len:96 
	INODE: #regs:2   ino:0xa7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672680 len:56 a:0x672720 len:96 
	INODE: #regs:2   ino:0xa8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672790 len:56 a:0x672830 len:96 
	INODE: #regs:2   ino:0xa9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6728a0 len:56 a:0x672940 len:96 
	INODE: #regs:2   ino:0xaa  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6729b0 len:56 a:0x672a50 len:96 
	INODE: #regs:2   ino:0xab  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672ac0 len:56 a:0x672b60 len:96 
	INODE: #regs:2   ino:0xac  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672bd0 len:56 a:0x672c70 len:96 
	INODE: #regs:2   ino:0xad  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672ce0 len:56 a:0x672d80 len:96 
	INODE: #regs:2   ino:0xae  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672df0 len:56 a:0x672e90 len:96 
	INODE: #regs:2   ino:0xaf  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672f00 len:56 a:0x672fa0 len:96 
	INODE: #regs:2   ino:0xb0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673010 len:56 a:0x6730b0 len:96 
	INODE: #regs:2   ino:0xb1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673120 len:56 a:0x6731c0 len:96 
	INODE: #regs:2   ino:0xb2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673230 len:56 a:0x6732d0 len:96 
	INODE: #regs:2   ino:0xb3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673340 len:56 a:0x6733e0 len:96 
	INODE: #regs:2   ino:0xb4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673450 len:56 a:0x6734f0 len:96 
	INODE: #regs:2   ino:0xb5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673560 len:56 a:0x673600 len:96 
	INODE: #regs:2   ino:0xb6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673670 len:56 a:0x673710 len:96 
	INODE: #regs:2   ino:0xb7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673780 len:56 a:0x673820 len:96 
	INODE: #regs:2   ino:0xb8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673890 len:56 a:0x673930 len:96 
	INODE: #regs:2   ino:0xb9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6739a0 len:56 a:0x673a40 len:96 
	INODE: #regs:2   ino:0xba  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673ab0 len:56 a:0x673b50 len:96 
	INODE: #regs:2   ino:0xbb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673bc0 len:56 a:0x673c60 len:96 
	INODE: #regs:2   ino:0xbc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673cd0 len:56 a:0x673d70 len:96 
	INODE: #regs:2   ino:0xbd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673de0 len:56 a:0x673e80 len:96 
	INODE: #regs:2   ino:0xbe  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673ef0 len:56 a:0x673f90 len:96 
	INODE: #regs:2   ino:0xbf  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:2 total:2 a:0x674000 len:28 a:0x674090 len:128 
	BUF:  #regs:2   start blkno:0x1   len:1   bmap size:1   flags:0x0
	AGF Buffer: (XAGF)
BUF: cnt:2 total:2 a:0x674120 len:28 a:0x6741b0 len:128 
	BUF:  #regs:2   start blkno:0x10   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:2 total:2 a:0x674240 len:28 a:0x6742d0 len:128 
	BUF:  #regs:2   start blkno:0x8   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:17 total:17 a:0x674360 len:28 a:0x6744e0 len:128 a:0x674570 len:128 a:0x674600 len:128 a:0x674690 len:128 a:0x674720 len:128 a:0x6747b0 len:128 a:0x674840 len:128 a:0x6748d0 len:128 a:0x674960 len:128 a:0x6749f0 len:128 a:0x674a80 len:128 a:0x674b10 len:128 a:0x674ba0 len:128 a:0x674c30 len:128 a:0x674cc0 len:128 a:0x674d50 len:128 
	BUF:  #regs:17   start blkno:0x70   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
BUF: cnt:17 total:17 a:0x674de0 len:28 a:0x674f60 len:128 a:0x674ff0 len:128 a:0x675080 len:128 a:0x675110 len:128 a:0x6751a0 len:128 a:0x675230 len:128 a:0x6752c0 len:128 a:0x675350 len:128 a:0x6753e0 len:128 a:0x675470 len:128 a:0x675500 len:128 a:0x675590 len:128 a:0x675620 len:128 a:0x6756b0 len:128 a:0x675740 len:128 a:0x6757d0 len:128 
	BUF:  #regs:17   start blkno:0x80   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x675860 len:56 a:0x675900 len:96 
	INODE: #regs:2   ino:0xe0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675970 len:56 a:0x675a10 len:96 
	INODE: #regs:2   ino:0xe1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675a80 len:56 a:0x675b20 len:96 
	INODE: #regs:2   ino:0xe2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675b90 len:56 a:0x675c30 len:96 
	INODE: #regs:2   ino:0xe3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675ca0 len:56 a:0x675d40 len:96 
	INODE: #regs:2   ino:0xe4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675db0 len:56 a:0x675e50 len:96 
	INODE: #regs:2   ino:0xe5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675ec0 len:56 a:0x675f60 len:96 
	INODE: #regs:2   ino:0xe6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675fd0 len:56 a:0x676070 len:96 
	INODE: #regs:2   ino:0xe7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6760e0 len:56 a:0x676180 len:96 
	INODE: #regs:2   ino:0xe8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6761f0 len:56 a:0x676290 len:96 
	INODE: #regs:2   ino:0xe9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676300 len:56 a:0x6763a0 len:96 
	INODE: #regs:2   ino:0xea  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676410 len:56 a:0x6764b0 len:96 
	INODE: #regs:2   ino:0xeb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676520 len:56 a:0x6765c0 len:96 
	INODE: #regs:2   ino:0xec  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676630 len:56 a:0x6766d0 len:96 
	INODE: #regs:2   ino:0xed  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676740 len:56 a:0x6767e0 len:96 
	INODE: #regs:2   ino:0xee  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676850 len:56 a:0x6768f0 len:96 
	INODE: #regs:2   ino:0xef  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676960 len:56 a:0x676a00 len:96 
	INODE: #regs:2   ino:0xf0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676a70 len:56 a:0x676b10 len:96 
	INODE: #regs:2   ino:0xf1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676b80 len:56 a:0x676c20 len:96 
	INODE: #regs:2   ino:0xf2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676c90 len:56 a:0x676d30 len:96 
	INODE: #regs:2   ino:0xf3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676da0 len:56 a:0x676e40 len:96 
	INODE: #regs:2   ino:0xf4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676eb0 len:56 a:0x676f50 len:96 
	INODE: #regs:2   ino:0xf5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676fc0 len:56 a:0x677060 len:96 
	INODE: #regs:2   ino:0xf6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6770d0 len:56 a:0x677170 len:96 
	INODE: #regs:2   ino:0xf7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6771e0 len:56 a:0x677280 len:96 
	INODE: #regs:2   ino:0xf8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6772f0 len:56 a:0x677390 len:96 
	INODE: #regs:2   ino:0xf9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677400 len:56 a:0x6774a0 len:96 
	INODE: #regs:2   ino:0xfa  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677510 len:56 a:0x6775b0 len:96 
	INODE: #regs:2   ino:0xfb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677620 len:56 a:0x6776c0 len:96 
	INODE: #regs:2   ino:0xfc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677730 len:56 a:0x6777d0 len:96 
	INODE: #regs:2   ino:0xfd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677840 len:56 a:0x6778e0 len:96 
	INODE: #regs:2   ino:0xfe  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677950 len:56 a:0x6779f0 len:96 
	INODE: #regs:2   ino:0xff  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677a60 len:56 a:0x677b00 len:96 
	INODE: #regs:2   ino:0x100  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677b70 len:56 a:0x677c10 len:96 
	INODE: #regs:2   ino:0x101  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677c80 len:56 a:0x677d20 len:96 
	INODE: #regs:2   ino:0x102  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677d90 len:56 a:0x677e30 len:96 
	INODE: #regs:2   ino:0x103  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677ea0 len:56 a:0x677f40 len:96 
	INODE: #regs:2   ino:0x104  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677fb0 len:56 a:0x678050 len:96 
	INODE: #regs:2   ino:0x105  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:2 total:2 a:0x6780c0 len:28 a:0x678150 len:128 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:2 total:2 a:0x6781e0 len:28 a:0x678270 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:3 total:3 a:0x678300 len:28 a:0x6783a0 len:1664 a:0x678a30 len:896 
	BUF:  #regs:3   start blkno:0x60   len:8   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x678dc0 len:56 a:0x678e60 len:96 
	INODE: #regs:2   ino:0x106  flags:0x1   dsize:0
	CORE inode:
INO: cnt:3 total:3 a:0x678ed0 len:56 a:0x678f80 len:96 a:0x667fe0 len:16 
	INODE: #regs:3   ino:0x80  flags:0x5   dsize:16
	CORE inode:
		DATA FORK EXTENTS inode data:

*** mount with replay ***

mount: Structure needs cleaning
mount failed: -o logbsize=32k

[-- Attachment #4: 087.full --]
[-- Type: application/octet-stream, Size: 1630394 bytes --]

[-- Attachment #5: 121.full --]
[-- Type: text/plain, Size: 28805 bytes --]

meta-data=/dev/sdb4              isize=256    agcount=4, agsize=2170232 blks
         =                       sectsz=512   attr=2, projid32bit=0
data     =                       bsize=4096   blocks=8680926, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0
log      =internal log           bsize=4096   blocks=4238, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
Opening "/mnt/scratch"
Calling XFS_IOC_GOINGDOWN
xfs_logprint:
    data device: 0xa0010300
    log device: 0xa0010300 daddr: 34723744 length: 33904

    log tail: 2 head: 103 state: <DIRTY>


LOG REC AT LSN cycle 1 block 2 (0x1, 0x2)

LOG REC AT LSN cycle 1 block 66 (0x1, 0x42)
============================================================================
TRANS: tid:0xf4957a5f  type:CHECKPOINT  #items:515  trans:0xf4957a5f  q:0x667f20
INO: cnt:2 total:2 a:0x667bc0 len:56 a:0x670010 len:96 
	INODE: #regs:2   ino:0x83  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x667fa0 len:56 a:0x6700e0 len:96 
	INODE: #regs:2   ino:0x84  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670150 len:56 a:0x6701f0 len:96 
	INODE: #regs:2   ino:0x85  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670260 len:56 a:0x670300 len:96 
	INODE: #regs:2   ino:0x86  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670370 len:56 a:0x670410 len:96 
	INODE: #regs:2   ino:0x87  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670480 len:56 a:0x670520 len:96 
	INODE: #regs:2   ino:0x88  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670590 len:56 a:0x670630 len:96 
	INODE: #regs:2   ino:0x89  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6706a0 len:56 a:0x670740 len:96 
	INODE: #regs:2   ino:0x8a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6707b0 len:56 a:0x670850 len:96 
	INODE: #regs:2   ino:0x8b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6708c0 len:56 a:0x670960 len:96 
	INODE: #regs:2   ino:0x8c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6709d0 len:56 a:0x670a70 len:96 
	INODE: #regs:2   ino:0x8d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670ae0 len:56 a:0x670b80 len:96 
	INODE: #regs:2   ino:0x8e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670bf0 len:56 a:0x670c90 len:96 
	INODE: #regs:2   ino:0x8f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670d00 len:56 a:0x670da0 len:96 
	INODE: #regs:2   ino:0x90  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670e10 len:56 a:0x670eb0 len:96 
	INODE: #regs:2   ino:0x91  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x670f20 len:56 a:0x670fc0 len:96 
	INODE: #regs:2   ino:0x92  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671030 len:56 a:0x6710d0 len:96 
	INODE: #regs:2   ino:0x93  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671140 len:56 a:0x6711e0 len:96 
	INODE: #regs:2   ino:0x94  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671250 len:56 a:0x6712f0 len:96 
	INODE: #regs:2   ino:0x95  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671360 len:56 a:0x671400 len:96 
	INODE: #regs:2   ino:0x96  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671470 len:56 a:0x671510 len:96 
	INODE: #regs:2   ino:0x97  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671580 len:56 a:0x671620 len:96 
	INODE: #regs:2   ino:0x98  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671690 len:56 a:0x671730 len:96 
	INODE: #regs:2   ino:0x99  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6717a0 len:56 a:0x671840 len:96 
	INODE: #regs:2   ino:0x9a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6718b0 len:56 a:0x671950 len:96 
	INODE: #regs:2   ino:0x9b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6719c0 len:56 a:0x671a60 len:96 
	INODE: #regs:2   ino:0x9c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671ad0 len:56 a:0x671b70 len:96 
	INODE: #regs:2   ino:0x9d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671be0 len:56 a:0x671c80 len:96 
	INODE: #regs:2   ino:0x9e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671cf0 len:56 a:0x671d90 len:96 
	INODE: #regs:2   ino:0x9f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671e00 len:56 a:0x671ea0 len:96 
	INODE: #regs:2   ino:0xa0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x671f10 len:56 a:0x671fb0 len:96 
	INODE: #regs:2   ino:0xa1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672020 len:56 a:0x6720c0 len:96 
	INODE: #regs:2   ino:0xa2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672130 len:56 a:0x6721d0 len:96 
	INODE: #regs:2   ino:0xa3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672240 len:56 a:0x6722e0 len:96 
	INODE: #regs:2   ino:0xa4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672350 len:56 a:0x6723f0 len:96 
	INODE: #regs:2   ino:0xa5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672460 len:56 a:0x672500 len:96 
	INODE: #regs:2   ino:0xa6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672570 len:56 a:0x672610 len:96 
	INODE: #regs:2   ino:0xa7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672680 len:56 a:0x672720 len:96 
	INODE: #regs:2   ino:0xa8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672790 len:56 a:0x672830 len:96 
	INODE: #regs:2   ino:0xa9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6728a0 len:56 a:0x672940 len:96 
	INODE: #regs:2   ino:0xaa  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6729b0 len:56 a:0x672a50 len:96 
	INODE: #regs:2   ino:0xab  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672ac0 len:56 a:0x672b60 len:96 
	INODE: #regs:2   ino:0xac  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672bd0 len:56 a:0x672c70 len:96 
	INODE: #regs:2   ino:0xad  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672ce0 len:56 a:0x672d80 len:96 
	INODE: #regs:2   ino:0xae  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672df0 len:56 a:0x672e90 len:96 
	INODE: #regs:2   ino:0xaf  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x672f00 len:56 a:0x672fa0 len:96 
	INODE: #regs:2   ino:0xb0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673010 len:56 a:0x6730b0 len:96 
	INODE: #regs:2   ino:0xb1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673120 len:56 a:0x6731c0 len:96 
	INODE: #regs:2   ino:0xb2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673230 len:56 a:0x6732d0 len:96 
	INODE: #regs:2   ino:0xb3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673340 len:56 a:0x6733e0 len:96 
	INODE: #regs:2   ino:0xb4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673450 len:56 a:0x6734f0 len:96 
	INODE: #regs:2   ino:0xb5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673560 len:56 a:0x673600 len:96 
	INODE: #regs:2   ino:0xb6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673670 len:56 a:0x673710 len:96 
	INODE: #regs:2   ino:0xb7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673780 len:56 a:0x673820 len:96 
	INODE: #regs:2   ino:0xb8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673890 len:56 a:0x673930 len:96 
	INODE: #regs:2   ino:0xb9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6739a0 len:56 a:0x673a40 len:96 
	INODE: #regs:2   ino:0xba  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673ab0 len:56 a:0x673b50 len:96 
	INODE: #regs:2   ino:0xbb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673bc0 len:56 a:0x673c60 len:96 
	INODE: #regs:2   ino:0xbc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673cd0 len:56 a:0x673d70 len:96 
	INODE: #regs:2   ino:0xbd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673de0 len:56 a:0x673e80 len:96 
	INODE: #regs:2   ino:0xbe  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x673ef0 len:56 a:0x673f90 len:96 
	INODE: #regs:2   ino:0xbf  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674000 len:56 a:0x6740a0 len:96 
	INODE: #regs:2   ino:0xc0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674110 len:56 a:0x6741b0 len:96 
	INODE: #regs:2   ino:0xc1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674220 len:56 a:0x6742c0 len:96 
	INODE: #regs:2   ino:0xc2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674330 len:56 a:0x6743d0 len:96 
	INODE: #regs:2   ino:0xc3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674440 len:56 a:0x6744e0 len:96 
	INODE: #regs:2   ino:0xc4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674550 len:56 a:0x6745f0 len:96 
	INODE: #regs:2   ino:0xc5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674660 len:56 a:0x674700 len:96 
	INODE: #regs:2   ino:0xc6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674770 len:56 a:0x674810 len:96 
	INODE: #regs:2   ino:0xc7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674880 len:56 a:0x674920 len:96 
	INODE: #regs:2   ino:0xc8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674990 len:56 a:0x674a30 len:96 
	INODE: #regs:2   ino:0xc9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674aa0 len:56 a:0x674b40 len:96 
	INODE: #regs:2   ino:0xca  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674bb0 len:56 a:0x674c50 len:96 
	INODE: #regs:2   ino:0xcb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674cc0 len:56 a:0x674d60 len:96 
	INODE: #regs:2   ino:0xcc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674dd0 len:56 a:0x674e70 len:96 
	INODE: #regs:2   ino:0xcd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674ee0 len:56 a:0x674f80 len:96 
	INODE: #regs:2   ino:0xce  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x674ff0 len:56 a:0x675090 len:96 
	INODE: #regs:2   ino:0xcf  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675100 len:56 a:0x6751a0 len:96 
	INODE: #regs:2   ino:0xd0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675210 len:56 a:0x6752b0 len:96 
	INODE: #regs:2   ino:0xd1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675320 len:56 a:0x6753c0 len:96 
	INODE: #regs:2   ino:0xd2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675430 len:56 a:0x6754d0 len:96 
	INODE: #regs:2   ino:0xd3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675540 len:56 a:0x6755e0 len:96 
	INODE: #regs:2   ino:0xd4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675650 len:56 a:0x6756f0 len:96 
	INODE: #regs:2   ino:0xd5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675760 len:56 a:0x675800 len:96 
	INODE: #regs:2   ino:0xd6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675870 len:56 a:0x675910 len:96 
	INODE: #regs:2   ino:0xd7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675980 len:56 a:0x675a20 len:96 
	INODE: #regs:2   ino:0xd8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675a90 len:56 a:0x675b30 len:96 
	INODE: #regs:2   ino:0xd9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675ba0 len:56 a:0x675c40 len:96 
	INODE: #regs:2   ino:0xda  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675cb0 len:56 a:0x675d50 len:96 
	INODE: #regs:2   ino:0xdb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675dc0 len:56 a:0x675e60 len:96 
	INODE: #regs:2   ino:0xdc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675ed0 len:56 a:0x675f70 len:96 
	INODE: #regs:2   ino:0xdd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x675fe0 len:56 a:0x676080 len:96 
	INODE: #regs:2   ino:0xde  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6760f0 len:56 a:0x676190 len:96 
	INODE: #regs:2   ino:0xdf  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:17 total:17 a:0x676200 len:28 a:0x676380 len:128 a:0x676410 len:128 a:0x6764a0 len:128 a:0x676530 len:128 a:0x6765c0 len:128 a:0x676650 len:128 a:0x6766e0 len:128 a:0x676770 len:128 a:0x676800 len:128 a:0x676890 len:128 a:0x676920 len:128 a:0x6769b0 len:128 a:0x676a40 len:128 a:0x676ad0 len:128 a:0x676b60 len:128 a:0x676bf0 len:128 
	BUF:  #regs:17   start blkno:0x60   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x676c80 len:56 a:0x676d20 len:96 
	INODE: #regs:2   ino:0xe0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676d90 len:56 a:0x676e30 len:96 
	INODE: #regs:2   ino:0xe1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676ea0 len:56 a:0x676f40 len:96 
	INODE: #regs:2   ino:0xe2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x676fb0 len:56 a:0x677050 len:96 
	INODE: #regs:2   ino:0xe3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6770c0 len:56 a:0x677160 len:96 
	INODE: #regs:2   ino:0xe4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6771d0 len:56 a:0x677270 len:96 
	INODE: #regs:2   ino:0xe5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6772e0 len:56 a:0x677380 len:96 
	INODE: #regs:2   ino:0xe6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6773f0 len:56 a:0x677490 len:96 
	INODE: #regs:2   ino:0xe7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677500 len:56 a:0x6775a0 len:96 
	INODE: #regs:2   ino:0xe8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677610 len:56 a:0x6776b0 len:96 
	INODE: #regs:2   ino:0xe9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677720 len:56 a:0x6777c0 len:96 
	INODE: #regs:2   ino:0xea  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677830 len:56 a:0x6778d0 len:96 
	INODE: #regs:2   ino:0xeb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677940 len:56 a:0x6779e0 len:96 
	INODE: #regs:2   ino:0xec  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677a50 len:56 a:0x677af0 len:96 
	INODE: #regs:2   ino:0xed  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677b60 len:56 a:0x677c00 len:96 
	INODE: #regs:2   ino:0xee  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677c70 len:56 a:0x677d10 len:96 
	INODE: #regs:2   ino:0xef  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677d80 len:56 a:0x677e20 len:96 
	INODE: #regs:2   ino:0xf0  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677e90 len:56 a:0x677f30 len:96 
	INODE: #regs:2   ino:0xf1  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x677fa0 len:56 a:0x678040 len:96 
	INODE: #regs:2   ino:0xf2  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6780b0 len:56 a:0x678150 len:96 
	INODE: #regs:2   ino:0xf3  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6781c0 len:56 a:0x678260 len:96 
	INODE: #regs:2   ino:0xf4  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6782d0 len:56 a:0x678370 len:96 
	INODE: #regs:2   ino:0xf5  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6783e0 len:56 a:0x678480 len:96 
	INODE: #regs:2   ino:0xf6  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6784f0 len:56 a:0x678590 len:96 
	INODE: #regs:2   ino:0xf7  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678600 len:56 a:0x6786a0 len:96 
	INODE: #regs:2   ino:0xf8  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678710 len:56 a:0x6787b0 len:96 
	INODE: #regs:2   ino:0xf9  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678820 len:56 a:0x6788c0 len:96 
	INODE: #regs:2   ino:0xfa  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678930 len:56 a:0x6789d0 len:96 
	INODE: #regs:2   ino:0xfb  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678a40 len:56 a:0x678ae0 len:96 
	INODE: #regs:2   ino:0xfc  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678b50 len:56 a:0x678bf0 len:96 
	INODE: #regs:2   ino:0xfd  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678c60 len:56 a:0x678d00 len:96 
	INODE: #regs:2   ino:0xfe  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x678d70 len:56 a:0x678e10 len:96 
	INODE: #regs:2   ino:0xff  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:17 total:17 a:0x678e80 len:28 a:0x679000 len:128 a:0x679090 len:128 a:0x679120 len:128 a:0x6791b0 len:128 a:0x679240 len:128 a:0x6792d0 len:128 a:0x679360 len:128 a:0x6793f0 len:128 a:0x679480 len:128 a:0x679510 len:128 a:0x6795a0 len:128 a:0x679630 len:128 a:0x6796c0 len:128 a:0x679750 len:128 a:0x6797e0 len:128 a:0x679870 len:128 
	BUF:  #regs:17   start blkno:0x70   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x679900 len:56 a:0x6799a0 len:96 
	INODE: #regs:2   ino:0x100  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x679a10 len:56 a:0x679ab0 len:96 
	INODE: #regs:2   ino:0x101  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x679b20 len:56 a:0x679bc0 len:96 
	INODE: #regs:2   ino:0x102  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x679c30 len:56 a:0x679cd0 len:96 
	INODE: #regs:2   ino:0x103  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x679d40 len:56 a:0x679de0 len:96 
	INODE: #regs:2   ino:0x104  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x679e50 len:56 a:0x679ef0 len:96 
	INODE: #regs:2   ino:0x105  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x679f60 len:56 a:0x67a000 len:96 
	INODE: #regs:2   ino:0x106  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a070 len:56 a:0x67a110 len:96 
	INODE: #regs:2   ino:0x107  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a180 len:56 a:0x67a220 len:96 
	INODE: #regs:2   ino:0x108  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a290 len:56 a:0x67a330 len:96 
	INODE: #regs:2   ino:0x109  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a3a0 len:56 a:0x67a440 len:96 
	INODE: #regs:2   ino:0x10a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a4b0 len:56 a:0x67a550 len:96 
	INODE: #regs:2   ino:0x10b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a5c0 len:56 a:0x67a660 len:96 
	INODE: #regs:2   ino:0x10c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a6d0 len:56 a:0x67a770 len:96 
	INODE: #regs:2   ino:0x10d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a7e0 len:56 a:0x67a880 len:96 
	INODE: #regs:2   ino:0x10e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67a8f0 len:56 a:0x67a990 len:96 
	INODE: #regs:2   ino:0x10f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67aa00 len:56 a:0x67aaa0 len:96 
	INODE: #regs:2   ino:0x110  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67ab10 len:56 a:0x67abb0 len:96 
	INODE: #regs:2   ino:0x111  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67ac20 len:56 a:0x67acc0 len:96 
	INODE: #regs:2   ino:0x112  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67ad30 len:56 a:0x67add0 len:96 
	INODE: #regs:2   ino:0x113  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67ae40 len:56 a:0x67aee0 len:96 
	INODE: #regs:2   ino:0x114  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67af50 len:56 a:0x67aff0 len:96 
	INODE: #regs:2   ino:0x115  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b060 len:56 a:0x67b100 len:96 
	INODE: #regs:2   ino:0x116  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b170 len:56 a:0x67b210 len:96 
	INODE: #regs:2   ino:0x117  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b280 len:56 a:0x67b320 len:96 
	INODE: #regs:2   ino:0x118  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b390 len:56 a:0x67b430 len:96 
	INODE: #regs:2   ino:0x119  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b4a0 len:56 a:0x67b540 len:96 
	INODE: #regs:2   ino:0x11a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b5b0 len:56 a:0x67b650 len:96 
	INODE: #regs:2   ino:0x11b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b6c0 len:56 a:0x67b760 len:96 
	INODE: #regs:2   ino:0x11c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b7d0 len:56 a:0x67b870 len:96 
	INODE: #regs:2   ino:0x11d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b8e0 len:56 a:0x67b980 len:96 
	INODE: #regs:2   ino:0x11e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67b9f0 len:56 a:0x67ba90 len:96 
	INODE: #regs:2   ino:0x11f  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:17 total:17 a:0x67bc50 len:28 a:0x67bc80 len:128 a:0x67bd10 len:128 a:0x67bda0 len:128 a:0x67be30 len:128 a:0x67bec0 len:128 a:0x67bf50 len:128 a:0x67bfe0 len:128 a:0x67c070 len:128 a:0x67c100 len:128 a:0x67c190 len:128 a:0x67c220 len:128 a:0x67c2b0 len:128 a:0x67c340 len:128 a:0x67c3d0 len:128 a:0x67c460 len:128 a:0x67c4f0 len:128 
	BUF:  #regs:17   start blkno:0x80   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x67c580 len:56 a:0x67c620 len:96 
	INODE: #regs:2   ino:0x120  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67c690 len:56 a:0x67c730 len:96 
	INODE: #regs:2   ino:0x121  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67c7a0 len:56 a:0x67c840 len:96 
	INODE: #regs:2   ino:0x122  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67c8b0 len:56 a:0x67c950 len:96 
	INODE: #regs:2   ino:0x123  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67c9c0 len:56 a:0x67ca60 len:96 
	INODE: #regs:2   ino:0x124  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67cad0 len:56 a:0x67cb70 len:96 
	INODE: #regs:2   ino:0x125  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67cbe0 len:56 a:0x67cc80 len:96 
	INODE: #regs:2   ino:0x126  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67ccf0 len:56 a:0x67cd90 len:96 
	INODE: #regs:2   ino:0x127  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67ce00 len:56 a:0x67cea0 len:96 
	INODE: #regs:2   ino:0x128  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67cf10 len:56 a:0x67cfb0 len:96 
	INODE: #regs:2   ino:0x129  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d020 len:56 a:0x67d0c0 len:96 
	INODE: #regs:2   ino:0x12a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d130 len:56 a:0x67d1d0 len:96 
	INODE: #regs:2   ino:0x12b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d240 len:56 a:0x67d2e0 len:96 
	INODE: #regs:2   ino:0x12c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d350 len:56 a:0x67d3f0 len:96 
	INODE: #regs:2   ino:0x12d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d460 len:56 a:0x67d500 len:96 
	INODE: #regs:2   ino:0x12e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d570 len:56 a:0x67d610 len:96 
	INODE: #regs:2   ino:0x12f  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d680 len:56 a:0x67d720 len:96 
	INODE: #regs:2   ino:0x130  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d790 len:56 a:0x67d830 len:96 
	INODE: #regs:2   ino:0x131  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d8a0 len:56 a:0x67d940 len:96 
	INODE: #regs:2   ino:0x132  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67d9b0 len:56 a:0x67da50 len:96 
	INODE: #regs:2   ino:0x133  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67dac0 len:56 a:0x67db60 len:96 
	INODE: #regs:2   ino:0x134  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67dbd0 len:56 a:0x67dc70 len:96 
	INODE: #regs:2   ino:0x135  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67dce0 len:56 a:0x67dd80 len:96 
	INODE: #regs:2   ino:0x136  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67ddf0 len:56 a:0x67de90 len:96 
	INODE: #regs:2   ino:0x137  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67df00 len:56 a:0x67dfa0 len:96 
	INODE: #regs:2   ino:0x138  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67e010 len:56 a:0x67e0b0 len:96 
	INODE: #regs:2   ino:0x139  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67e120 len:56 a:0x67e1c0 len:96 
	INODE: #regs:2   ino:0x13a  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67e230 len:56 a:0x67e2d0 len:96 
	INODE: #regs:2   ino:0x13b  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67e340 len:56 a:0x67e3e0 len:96 
	INODE: #regs:2   ino:0x13c  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67e450 len:56 a:0x67e4f0 len:96 
	INODE: #regs:2   ino:0x13d  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67e560 len:56 a:0x67e600 len:96 
	INODE: #regs:2   ino:0x13e  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x67e670 len:56 a:0x67e710 len:96 
	INODE: #regs:2   ino:0x13f  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:17 total:17 a:0x67e780 len:28 a:0x67e900 len:128 a:0x67e990 len:128 a:0x67ea20 len:128 a:0x67eab0 len:128 a:0x67eb40 len:128 a:0x67ebd0 len:128 a:0x67ec60 len:128 a:0x67ecf0 len:128 a:0x67ed80 len:128 a:0x67ee10 len:128 a:0x67eea0 len:128 a:0x67ef30 len:128 a:0x67efc0 len:128 a:0x67f050 len:128 a:0x67f0e0 len:128 a:0x67f170 len:128 
	BUF:  #regs:17   start blkno:0x90   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
BUF: cnt:2 total:2 a:0x67f200 len:28 a:0x67f290 len:128 
	BUF:  #regs:2   start blkno:0x1   len:1   bmap size:1   flags:0x0
	AGF Buffer: (XAGF)
BUF: cnt:2 total:2 a:0x67f320 len:28 a:0x67f3b0 len:128 
	BUF:  #regs:2   start blkno:0x8   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:2 total:2 a:0x67f440 len:28 a:0x67f4d0 len:128 
	BUF:  #regs:2   start blkno:0x10   len:8   bmap size:1   flags:0x0
	BUF DATA
BUF: cnt:17 total:17 a:0x67f560 len:28 a:0x67f6e0 len:128 a:0x67f770 len:128 a:0x67f800 len:128 a:0x67f890 len:128 a:0x67f920 len:128 a:0x67f9b0 len:128 a:0x67fa40 len:128 a:0x67fad0 len:128 a:0x67fb60 len:128 a:0x67fbf0 len:128 a:0x67fc80 len:128 a:0x67fd10 len:128 a:0x67fda0 len:128 a:0x67fe30 len:128 a:0x67fec0 len:128 a:0x67ff50 len:128 
	BUF:  #regs:17   start blkno:0xb0   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
INO: cnt:2 total:2 a:0x67ffe0 len:56 a:0x680080 len:96 
	INODE: #regs:2   ino:0x140  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x6800f0 len:56 a:0x680190 len:96 
	INODE: #regs:2   ino:0x141  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680200 len:56 a:0x6802a0 len:96 
	INODE: #regs:2   ino:0x142  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680310 len:56 a:0x6803b0 len:96 
	INODE: #regs:2   ino:0x143  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680420 len:56 a:0x6804c0 len:96 
	INODE: #regs:2   ino:0x144  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680530 len:56 a:0x6805d0 len:96 
	INODE: #regs:2   ino:0x145  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680640 len:56 a:0x6806e0 len:96 
	INODE: #regs:2   ino:0x146  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680750 len:56 a:0x6807f0 len:96 
	INODE: #regs:2   ino:0x147  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680860 len:56 a:0x680900 len:96 
	INODE: #regs:2   ino:0x148  flags:0x1   dsize:0
	CORE inode:
INO: cnt:2 total:2 a:0x680970 len:56 a:0x680a10 len:96 
	INODE: #regs:2   ino:0x149  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:2 total:2 a:0x680a80 len:28 a:0x680b10 len:128 
	BUF:  #regs:2   start blkno:0x18   len:8   bmap size:1   flags:0x0
	BUF DATA
INO: cnt:3 total:3 a:0x680ba0 len:56 a:0x680c50 len:96 a:0x667fe0 len:8 
	INODE: #regs:3   ino:0x80  flags:0x3   dsize:8
	CORE inode:
		DATA FORK LOCAL inode data:
INO: cnt:2 total:2 a:0x680cc0 len:56 a:0x680d60 len:96 
	INODE: #regs:2   ino:0x14a  flags:0x1   dsize:0
	CORE inode:
BUF: cnt:2 total:2 a:0x680dd0 len:28 a:0x680e60 len:384 
	BUF:  #regs:2   start blkno:0x2   len:1   bmap size:1   flags:0x0
	AGI Buffer: (XAGI)
BUF: cnt:17 total:17 a:0x680ff0 len:28 a:0x681170 len:128 a:0x681200 len:128 a:0x681290 len:128 a:0x681320 len:128 a:0x6813b0 len:128 a:0x681440 len:128 a:0x6814d0 len:128 a:0x681560 len:128 a:0x6815f0 len:128 a:0x681680 len:128 a:0x681710 len:128 a:0x6817a0 len:128 a:0x681830 len:128 a:0x6818c0 len:128 a:0x681950 len:128 a:0x6819e0 len:128 
	BUF:  #regs:17   start blkno:0xa0   len:16   bmap size:1   flags:0x0
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
	BUF DATA
mount: Structure needs cleaning
mount failed:  

[-- Attachment #6: 179.out.bad --]
[-- Type: text/plain, Size: 44970 bytes --]

QA output created by 179
mount: Structure needs cleaning
umount: /mnt/scratch: not mounted
mount: Structure needs cleaning
file /mnt/scratch/1 missing - fsync failed
file /mnt/scratch/2 missing - fsync failed
file /mnt/scratch/3 missing - fsync failed
file /mnt/scratch/4 missing - fsync failed
file /mnt/scratch/5 missing - fsync failed
file /mnt/scratch/6 missing - fsync failed
file /mnt/scratch/7 missing - fsync failed
file /mnt/scratch/8 missing - fsync failed
file /mnt/scratch/9 missing - fsync failed
file /mnt/scratch/10 missing - fsync failed
file /mnt/scratch/11 missing - fsync failed
file /mnt/scratch/12 missing - fsync failed
file /mnt/scratch/13 missing - fsync failed
file /mnt/scratch/14 missing - fsync failed
file /mnt/scratch/15 missing - fsync failed
file /mnt/scratch/16 missing - fsync failed
file /mnt/scratch/17 missing - fsync failed
file /mnt/scratch/18 missing - fsync failed
file /mnt/scratch/19 missing - fsync failed
file /mnt/scratch/20 missing - fsync failed
file /mnt/scratch/21 missing - fsync failed
file /mnt/scratch/22 missing - fsync failed
file /mnt/scratch/23 missing - fsync failed
file /mnt/scratch/24 missing - fsync failed
file /mnt/scratch/25 missing - fsync failed
file /mnt/scratch/26 missing - fsync failed
file /mnt/scratch/27 missing - fsync failed
file /mnt/scratch/28 missing - fsync failed
file /mnt/scratch/29 missing - fsync failed
file /mnt/scratch/30 missing - fsync failed
file /mnt/scratch/31 missing - fsync failed
file /mnt/scratch/32 missing - fsync failed
file /mnt/scratch/33 missing - fsync failed
file /mnt/scratch/34 missing - fsync failed
file /mnt/scratch/35 missing - fsync failed
file /mnt/scratch/36 missing - fsync failed
file /mnt/scratch/37 missing - fsync failed
file /mnt/scratch/38 missing - fsync failed
file /mnt/scratch/39 missing - fsync failed
file /mnt/scratch/40 missing - fsync failed
file /mnt/scratch/41 missing - fsync failed
file /mnt/scratch/42 missing - fsync failed
file /mnt/scratch/43 missing - fsync failed
file /mnt/scratch/44 missing - fsync failed
file /mnt/scratch/45 missing - fsync failed
file /mnt/scratch/46 missing - fsync failed
file /mnt/scratch/47 missing - fsync failed
file /mnt/scratch/48 missing - fsync failed
file /mnt/scratch/49 missing - fsync failed
file /mnt/scratch/50 missing - fsync failed
file /mnt/scratch/51 missing - fsync failed
file /mnt/scratch/52 missing - fsync failed
file /mnt/scratch/53 missing - fsync failed
file /mnt/scratch/54 missing - fsync failed
file /mnt/scratch/55 missing - fsync failed
file /mnt/scratch/56 missing - fsync failed
file /mnt/scratch/57 missing - fsync failed
file /mnt/scratch/58 missing - fsync failed
file /mnt/scratch/59 missing - fsync failed
file /mnt/scratch/60 missing - fsync failed
file /mnt/scratch/61 missing - fsync failed
file /mnt/scratch/62 missing - fsync failed
file /mnt/scratch/63 missing - fsync failed
file /mnt/scratch/64 missing - fsync failed
file /mnt/scratch/65 missing - fsync failed
file /mnt/scratch/66 missing - fsync failed
file /mnt/scratch/67 missing - fsync failed
file /mnt/scratch/68 missing - fsync failed
file /mnt/scratch/69 missing - fsync failed
file /mnt/scratch/70 missing - fsync failed
file /mnt/scratch/71 missing - fsync failed
file /mnt/scratch/72 missing - fsync failed
file /mnt/scratch/73 missing - fsync failed
file /mnt/scratch/74 missing - fsync failed
file /mnt/scratch/75 missing - fsync failed
file /mnt/scratch/76 missing - fsync failed
file /mnt/scratch/77 missing - fsync failed
file /mnt/scratch/78 missing - fsync failed
file /mnt/scratch/79 missing - fsync failed
file /mnt/scratch/80 missing - fsync failed
file /mnt/scratch/81 missing - fsync failed
file /mnt/scratch/82 missing - fsync failed
file /mnt/scratch/83 missing - fsync failed
file /mnt/scratch/84 missing - fsync failed
file /mnt/scratch/85 missing - fsync failed
file /mnt/scratch/86 missing - fsync failed
file /mnt/scratch/87 missing - fsync failed
file /mnt/scratch/88 missing - fsync failed
file /mnt/scratch/89 missing - fsync failed
file /mnt/scratch/90 missing - fsync failed
file /mnt/scratch/91 missing - fsync failed
file /mnt/scratch/92 missing - fsync failed
file /mnt/scratch/93 missing - fsync failed
file /mnt/scratch/94 missing - fsync failed
file /mnt/scratch/95 missing - fsync failed
file /mnt/scratch/96 missing - fsync failed
file /mnt/scratch/97 missing - fsync failed
file /mnt/scratch/98 missing - fsync failed
file /mnt/scratch/99 missing - fsync failed
file /mnt/scratch/100 missing - fsync failed
file /mnt/scratch/101 missing - fsync failed
file /mnt/scratch/102 missing - fsync failed
file /mnt/scratch/103 missing - fsync failed
file /mnt/scratch/104 missing - fsync failed
file /mnt/scratch/105 missing - fsync failed
file /mnt/scratch/106 missing - fsync failed
file /mnt/scratch/107 missing - fsync failed
file /mnt/scratch/108 missing - fsync failed
file /mnt/scratch/109 missing - fsync failed
file /mnt/scratch/110 missing - fsync failed
file /mnt/scratch/111 missing - fsync failed
file /mnt/scratch/112 missing - fsync failed
file /mnt/scratch/113 missing - fsync failed
file /mnt/scratch/114 missing - fsync failed
file /mnt/scratch/115 missing - fsync failed
file /mnt/scratch/116 missing - fsync failed
file /mnt/scratch/117 missing - fsync failed
file /mnt/scratch/118 missing - fsync failed
file /mnt/scratch/119 missing - fsync failed
file /mnt/scratch/120 missing - fsync failed
file /mnt/scratch/121 missing - fsync failed
file /mnt/scratch/122 missing - fsync failed
file /mnt/scratch/123 missing - fsync failed
file /mnt/scratch/124 missing - fsync failed
file /mnt/scratch/125 missing - fsync failed
file /mnt/scratch/126 missing - fsync failed
file /mnt/scratch/127 missing - fsync failed
file /mnt/scratch/128 missing - fsync failed
file /mnt/scratch/129 missing - fsync failed
file /mnt/scratch/130 missing - fsync failed
file /mnt/scratch/131 missing - fsync failed
file /mnt/scratch/132 missing - fsync failed
file /mnt/scratch/133 missing - fsync failed
file /mnt/scratch/134 missing - fsync failed
file /mnt/scratch/135 missing - fsync failed
file /mnt/scratch/136 missing - fsync failed
file /mnt/scratch/137 missing - fsync failed
file /mnt/scratch/138 missing - fsync failed
file /mnt/scratch/139 missing - fsync failed
file /mnt/scratch/140 missing - fsync failed
file /mnt/scratch/141 missing - fsync failed
file /mnt/scratch/142 missing - fsync failed
file /mnt/scratch/143 missing - fsync failed
file /mnt/scratch/144 missing - fsync failed
file /mnt/scratch/145 missing - fsync failed
file /mnt/scratch/146 missing - fsync failed
file /mnt/scratch/147 missing - fsync failed
file /mnt/scratch/148 missing - fsync failed
file /mnt/scratch/149 missing - fsync failed
file /mnt/scratch/150 missing - fsync failed
file /mnt/scratch/151 missing - fsync failed
file /mnt/scratch/152 missing - fsync failed
file /mnt/scratch/153 missing - fsync failed
file /mnt/scratch/154 missing - fsync failed
file /mnt/scratch/155 missing - fsync failed
file /mnt/scratch/156 missing - fsync failed
file /mnt/scratch/157 missing - fsync failed
file /mnt/scratch/158 missing - fsync failed
file /mnt/scratch/159 missing - fsync failed
file /mnt/scratch/160 missing - fsync failed
file /mnt/scratch/161 missing - fsync failed
file /mnt/scratch/162 missing - fsync failed
file /mnt/scratch/163 missing - fsync failed
file /mnt/scratch/164 missing - fsync failed
file /mnt/scratch/165 missing - fsync failed
file /mnt/scratch/166 missing - fsync failed
file /mnt/scratch/167 missing - fsync failed
file /mnt/scratch/168 missing - fsync failed
file /mnt/scratch/169 missing - fsync failed
file /mnt/scratch/170 missing - fsync failed
file /mnt/scratch/171 missing - fsync failed
file /mnt/scratch/172 missing - fsync failed
file /mnt/scratch/173 missing - fsync failed
file /mnt/scratch/174 missing - fsync failed
file /mnt/scratch/175 missing - fsync failed
file /mnt/scratch/176 missing - fsync failed
file /mnt/scratch/177 missing - fsync failed
file /mnt/scratch/178 missing - fsync failed
file /mnt/scratch/179 missing - fsync failed
file /mnt/scratch/180 missing - fsync failed
file /mnt/scratch/181 missing - fsync failed
file /mnt/scratch/182 missing - fsync failed
file /mnt/scratch/183 missing - fsync failed
file /mnt/scratch/184 missing - fsync failed
file /mnt/scratch/185 missing - fsync failed
file /mnt/scratch/186 missing - fsync failed
file /mnt/scratch/187 missing - fsync failed
file /mnt/scratch/188 missing - fsync failed
file /mnt/scratch/189 missing - fsync failed
file /mnt/scratch/190 missing - fsync failed
file /mnt/scratch/191 missing - fsync failed
file /mnt/scratch/192 missing - fsync failed
file /mnt/scratch/193 missing - fsync failed
file /mnt/scratch/194 missing - fsync failed
file /mnt/scratch/195 missing - fsync failed
file /mnt/scratch/196 missing - fsync failed
file /mnt/scratch/197 missing - fsync failed
file /mnt/scratch/198 missing - fsync failed
file /mnt/scratch/199 missing - fsync failed
file /mnt/scratch/200 missing - fsync failed
file /mnt/scratch/201 missing - fsync failed
file /mnt/scratch/202 missing - fsync failed
file /mnt/scratch/203 missing - fsync failed
file /mnt/scratch/204 missing - fsync failed
file /mnt/scratch/205 missing - fsync failed
file /mnt/scratch/206 missing - fsync failed
file /mnt/scratch/207 missing - fsync failed
file /mnt/scratch/208 missing - fsync failed
file /mnt/scratch/209 missing - fsync failed
file /mnt/scratch/210 missing - fsync failed
file /mnt/scratch/211 missing - fsync failed
file /mnt/scratch/212 missing - fsync failed
file /mnt/scratch/213 missing - fsync failed
file /mnt/scratch/214 missing - fsync failed
file /mnt/scratch/215 missing - fsync failed
file /mnt/scratch/216 missing - fsync failed
file /mnt/scratch/217 missing - fsync failed
file /mnt/scratch/218 missing - fsync failed
file /mnt/scratch/219 missing - fsync failed
file /mnt/scratch/220 missing - fsync failed
file /mnt/scratch/221 missing - fsync failed
file /mnt/scratch/222 missing - fsync failed
file /mnt/scratch/223 missing - fsync failed
file /mnt/scratch/224 missing - fsync failed
file /mnt/scratch/225 missing - fsync failed
file /mnt/scratch/226 missing - fsync failed
file /mnt/scratch/227 missing - fsync failed
file /mnt/scratch/228 missing - fsync failed
file /mnt/scratch/229 missing - fsync failed
file /mnt/scratch/230 missing - fsync failed
file /mnt/scratch/231 missing - fsync failed
file /mnt/scratch/232 missing - fsync failed
file /mnt/scratch/233 missing - fsync failed
file /mnt/scratch/234 missing - fsync failed
file /mnt/scratch/235 missing - fsync failed
file /mnt/scratch/236 missing - fsync failed
file /mnt/scratch/237 missing - fsync failed
file /mnt/scratch/238 missing - fsync failed
file /mnt/scratch/239 missing - fsync failed
file /mnt/scratch/240 missing - fsync failed
file /mnt/scratch/241 missing - fsync failed
file /mnt/scratch/242 missing - fsync failed
file /mnt/scratch/243 missing - fsync failed
file /mnt/scratch/244 missing - fsync failed
file /mnt/scratch/245 missing - fsync failed
file /mnt/scratch/246 missing - fsync failed
file /mnt/scratch/247 missing - fsync failed
file /mnt/scratch/248 missing - fsync failed
file /mnt/scratch/249 missing - fsync failed
file /mnt/scratch/250 missing - fsync failed
file /mnt/scratch/251 missing - fsync failed
file /mnt/scratch/252 missing - fsync failed
file /mnt/scratch/253 missing - fsync failed
file /mnt/scratch/254 missing - fsync failed
file /mnt/scratch/255 missing - fsync failed
file /mnt/scratch/256 missing - fsync failed
file /mnt/scratch/257 missing - fsync failed
file /mnt/scratch/258 missing - fsync failed
file /mnt/scratch/259 missing - fsync failed
file /mnt/scratch/260 missing - fsync failed
file /mnt/scratch/261 missing - fsync failed
file /mnt/scratch/262 missing - fsync failed
file /mnt/scratch/263 missing - fsync failed
file /mnt/scratch/264 missing - fsync failed
file /mnt/scratch/265 missing - fsync failed
file /mnt/scratch/266 missing - fsync failed
file /mnt/scratch/267 missing - fsync failed
file /mnt/scratch/268 missing - fsync failed
file /mnt/scratch/269 missing - fsync failed
file /mnt/scratch/270 missing - fsync failed
file /mnt/scratch/271 missing - fsync failed
file /mnt/scratch/272 missing - fsync failed
file /mnt/scratch/273 missing - fsync failed
file /mnt/scratch/274 missing - fsync failed
file /mnt/scratch/275 missing - fsync failed
file /mnt/scratch/276 missing - fsync failed
file /mnt/scratch/277 missing - fsync failed
file /mnt/scratch/278 missing - fsync failed
file /mnt/scratch/279 missing - fsync failed
file /mnt/scratch/280 missing - fsync failed
file /mnt/scratch/281 missing - fsync failed
file /mnt/scratch/282 missing - fsync failed
file /mnt/scratch/283 missing - fsync failed
file /mnt/scratch/284 missing - fsync failed
file /mnt/scratch/285 missing - fsync failed
file /mnt/scratch/286 missing - fsync failed
file /mnt/scratch/287 missing - fsync failed
file /mnt/scratch/288 missing - fsync failed
file /mnt/scratch/289 missing - fsync failed
file /mnt/scratch/290 missing - fsync failed
file /mnt/scratch/291 missing - fsync failed
file /mnt/scratch/292 missing - fsync failed
file /mnt/scratch/293 missing - fsync failed
file /mnt/scratch/294 missing - fsync failed
file /mnt/scratch/295 missing - fsync failed
file /mnt/scratch/296 missing - fsync failed
file /mnt/scratch/297 missing - fsync failed
file /mnt/scratch/298 missing - fsync failed
file /mnt/scratch/299 missing - fsync failed
file /mnt/scratch/300 missing - fsync failed
file /mnt/scratch/301 missing - fsync failed
file /mnt/scratch/302 missing - fsync failed
file /mnt/scratch/303 missing - fsync failed
file /mnt/scratch/304 missing - fsync failed
file /mnt/scratch/305 missing - fsync failed
file /mnt/scratch/306 missing - fsync failed
file /mnt/scratch/307 missing - fsync failed
file /mnt/scratch/308 missing - fsync failed
file /mnt/scratch/309 missing - fsync failed
file /mnt/scratch/310 missing - fsync failed
file /mnt/scratch/311 missing - fsync failed
file /mnt/scratch/312 missing - fsync failed
file /mnt/scratch/313 missing - fsync failed
file /mnt/scratch/314 missing - fsync failed
file /mnt/scratch/315 missing - fsync failed
file /mnt/scratch/316 missing - fsync failed
file /mnt/scratch/317 missing - fsync failed
file /mnt/scratch/318 missing - fsync failed
file /mnt/scratch/319 missing - fsync failed
file /mnt/scratch/320 missing - fsync failed
file /mnt/scratch/321 missing - fsync failed
file /mnt/scratch/322 missing - fsync failed
file /mnt/scratch/323 missing - fsync failed
file /mnt/scratch/324 missing - fsync failed
file /mnt/scratch/325 missing - fsync failed
file /mnt/scratch/326 missing - fsync failed
file /mnt/scratch/327 missing - fsync failed
file /mnt/scratch/328 missing - fsync failed
file /mnt/scratch/329 missing - fsync failed
file /mnt/scratch/330 missing - fsync failed
file /mnt/scratch/331 missing - fsync failed
file /mnt/scratch/332 missing - fsync failed
file /mnt/scratch/333 missing - fsync failed
file /mnt/scratch/334 missing - fsync failed
file /mnt/scratch/335 missing - fsync failed
file /mnt/scratch/336 missing - fsync failed
file /mnt/scratch/337 missing - fsync failed
file /mnt/scratch/338 missing - fsync failed
file /mnt/scratch/339 missing - fsync failed
file /mnt/scratch/340 missing - fsync failed
file /mnt/scratch/341 missing - fsync failed
file /mnt/scratch/342 missing - fsync failed
file /mnt/scratch/343 missing - fsync failed
file /mnt/scratch/344 missing - fsync failed
file /mnt/scratch/345 missing - fsync failed
file /mnt/scratch/346 missing - fsync failed
file /mnt/scratch/347 missing - fsync failed
file /mnt/scratch/348 missing - fsync failed
file /mnt/scratch/349 missing - fsync failed
file /mnt/scratch/350 missing - fsync failed
file /mnt/scratch/351 missing - fsync failed
file /mnt/scratch/352 missing - fsync failed
file /mnt/scratch/353 missing - fsync failed
file /mnt/scratch/354 missing - fsync failed
file /mnt/scratch/355 missing - fsync failed
file /mnt/scratch/356 missing - fsync failed
file /mnt/scratch/357 missing - fsync failed
file /mnt/scratch/358 missing - fsync failed
file /mnt/scratch/359 missing - fsync failed
file /mnt/scratch/360 missing - fsync failed
file /mnt/scratch/361 missing - fsync failed
file /mnt/scratch/362 missing - fsync failed
file /mnt/scratch/363 missing - fsync failed
file /mnt/scratch/364 missing - fsync failed
file /mnt/scratch/365 missing - fsync failed
file /mnt/scratch/366 missing - fsync failed
file /mnt/scratch/367 missing - fsync failed
file /mnt/scratch/368 missing - fsync failed
file /mnt/scratch/369 missing - fsync failed
file /mnt/scratch/370 missing - fsync failed
file /mnt/scratch/371 missing - fsync failed
file /mnt/scratch/372 missing - fsync failed
file /mnt/scratch/373 missing - fsync failed
file /mnt/scratch/374 missing - fsync failed
file /mnt/scratch/375 missing - fsync failed
file /mnt/scratch/376 missing - fsync failed
file /mnt/scratch/377 missing - fsync failed
file /mnt/scratch/378 missing - fsync failed
file /mnt/scratch/379 missing - fsync failed
file /mnt/scratch/380 missing - fsync failed
file /mnt/scratch/381 missing - fsync failed
file /mnt/scratch/382 missing - fsync failed
file /mnt/scratch/383 missing - fsync failed
file /mnt/scratch/384 missing - fsync failed
file /mnt/scratch/385 missing - fsync failed
file /mnt/scratch/386 missing - fsync failed
file /mnt/scratch/387 missing - fsync failed
file /mnt/scratch/388 missing - fsync failed
file /mnt/scratch/389 missing - fsync failed
file /mnt/scratch/390 missing - fsync failed
file /mnt/scratch/391 missing - fsync failed
file /mnt/scratch/392 missing - fsync failed
file /mnt/scratch/393 missing - fsync failed
file /mnt/scratch/394 missing - fsync failed
file /mnt/scratch/395 missing - fsync failed
file /mnt/scratch/396 missing - fsync failed
file /mnt/scratch/397 missing - fsync failed
file /mnt/scratch/398 missing - fsync failed
file /mnt/scratch/399 missing - fsync failed
file /mnt/scratch/400 missing - fsync failed
file /mnt/scratch/401 missing - fsync failed
file /mnt/scratch/402 missing - fsync failed
file /mnt/scratch/403 missing - fsync failed
file /mnt/scratch/404 missing - fsync failed
file /mnt/scratch/405 missing - fsync failed
file /mnt/scratch/406 missing - fsync failed
file /mnt/scratch/407 missing - fsync failed
file /mnt/scratch/408 missing - fsync failed
file /mnt/scratch/409 missing - fsync failed
file /mnt/scratch/410 missing - fsync failed
file /mnt/scratch/411 missing - fsync failed
file /mnt/scratch/412 missing - fsync failed
file /mnt/scratch/413 missing - fsync failed
file /mnt/scratch/414 missing - fsync failed
file /mnt/scratch/415 missing - fsync failed
file /mnt/scratch/416 missing - fsync failed
file /mnt/scratch/417 missing - fsync failed
file /mnt/scratch/418 missing - fsync failed
file /mnt/scratch/419 missing - fsync failed
file /mnt/scratch/420 missing - fsync failed
file /mnt/scratch/421 missing - fsync failed
file /mnt/scratch/422 missing - fsync failed
file /mnt/scratch/423 missing - fsync failed
file /mnt/scratch/424 missing - fsync failed
file /mnt/scratch/425 missing - fsync failed
file /mnt/scratch/426 missing - fsync failed
file /mnt/scratch/427 missing - fsync failed
file /mnt/scratch/428 missing - fsync failed
file /mnt/scratch/429 missing - fsync failed
file /mnt/scratch/430 missing - fsync failed
file /mnt/scratch/431 missing - fsync failed
file /mnt/scratch/432 missing - fsync failed
file /mnt/scratch/433 missing - fsync failed
file /mnt/scratch/434 missing - fsync failed
file /mnt/scratch/435 missing - fsync failed
file /mnt/scratch/436 missing - fsync failed
file /mnt/scratch/437 missing - fsync failed
file /mnt/scratch/438 missing - fsync failed
file /mnt/scratch/439 missing - fsync failed
file /mnt/scratch/440 missing - fsync failed
file /mnt/scratch/441 missing - fsync failed
file /mnt/scratch/442 missing - fsync failed
file /mnt/scratch/443 missing - fsync failed
file /mnt/scratch/444 missing - fsync failed
file /mnt/scratch/445 missing - fsync failed
file /mnt/scratch/446 missing - fsync failed
file /mnt/scratch/447 missing - fsync failed
file /mnt/scratch/448 missing - fsync failed
file /mnt/scratch/449 missing - fsync failed
file /mnt/scratch/450 missing - fsync failed
file /mnt/scratch/451 missing - fsync failed
file /mnt/scratch/452 missing - fsync failed
file /mnt/scratch/453 missing - fsync failed
file /mnt/scratch/454 missing - fsync failed
file /mnt/scratch/455 missing - fsync failed
file /mnt/scratch/456 missing - fsync failed
file /mnt/scratch/457 missing - fsync failed
file /mnt/scratch/458 missing - fsync failed
file /mnt/scratch/459 missing - fsync failed
file /mnt/scratch/460 missing - fsync failed
file /mnt/scratch/461 missing - fsync failed
file /mnt/scratch/462 missing - fsync failed
file /mnt/scratch/463 missing - fsync failed
file /mnt/scratch/464 missing - fsync failed
file /mnt/scratch/465 missing - fsync failed
file /mnt/scratch/466 missing - fsync failed
file /mnt/scratch/467 missing - fsync failed
file /mnt/scratch/468 missing - fsync failed
file /mnt/scratch/469 missing - fsync failed
file /mnt/scratch/470 missing - fsync failed
file /mnt/scratch/471 missing - fsync failed
file /mnt/scratch/472 missing - fsync failed
file /mnt/scratch/473 missing - fsync failed
file /mnt/scratch/474 missing - fsync failed
file /mnt/scratch/475 missing - fsync failed
file /mnt/scratch/476 missing - fsync failed
file /mnt/scratch/477 missing - fsync failed
file /mnt/scratch/478 missing - fsync failed
file /mnt/scratch/479 missing - fsync failed
file /mnt/scratch/480 missing - fsync failed
file /mnt/scratch/481 missing - fsync failed
file /mnt/scratch/482 missing - fsync failed
file /mnt/scratch/483 missing - fsync failed
file /mnt/scratch/484 missing - fsync failed
file /mnt/scratch/485 missing - fsync failed
file /mnt/scratch/486 missing - fsync failed
file /mnt/scratch/487 missing - fsync failed
file /mnt/scratch/488 missing - fsync failed
file /mnt/scratch/489 missing - fsync failed
file /mnt/scratch/490 missing - fsync failed
file /mnt/scratch/491 missing - fsync failed
file /mnt/scratch/492 missing - fsync failed
file /mnt/scratch/493 missing - fsync failed
file /mnt/scratch/494 missing - fsync failed
file /mnt/scratch/495 missing - fsync failed
file /mnt/scratch/496 missing - fsync failed
file /mnt/scratch/497 missing - fsync failed
file /mnt/scratch/498 missing - fsync failed
file /mnt/scratch/499 missing - fsync failed
file /mnt/scratch/500 missing - fsync failed
file /mnt/scratch/501 missing - fsync failed
file /mnt/scratch/502 missing - fsync failed
file /mnt/scratch/503 missing - fsync failed
file /mnt/scratch/504 missing - fsync failed
file /mnt/scratch/505 missing - fsync failed
file /mnt/scratch/506 missing - fsync failed
file /mnt/scratch/507 missing - fsync failed
file /mnt/scratch/508 missing - fsync failed
file /mnt/scratch/509 missing - fsync failed
file /mnt/scratch/510 missing - fsync failed
file /mnt/scratch/511 missing - fsync failed
file /mnt/scratch/512 missing - fsync failed
file /mnt/scratch/513 missing - fsync failed
file /mnt/scratch/514 missing - fsync failed
file /mnt/scratch/515 missing - fsync failed
file /mnt/scratch/516 missing - fsync failed
file /mnt/scratch/517 missing - fsync failed
file /mnt/scratch/518 missing - fsync failed
file /mnt/scratch/519 missing - fsync failed
file /mnt/scratch/520 missing - fsync failed
file /mnt/scratch/521 missing - fsync failed
file /mnt/scratch/522 missing - fsync failed
file /mnt/scratch/523 missing - fsync failed
file /mnt/scratch/524 missing - fsync failed
file /mnt/scratch/525 missing - fsync failed
file /mnt/scratch/526 missing - fsync failed
file /mnt/scratch/527 missing - fsync failed
file /mnt/scratch/528 missing - fsync failed
file /mnt/scratch/529 missing - fsync failed
file /mnt/scratch/530 missing - fsync failed
file /mnt/scratch/531 missing - fsync failed
file /mnt/scratch/532 missing - fsync failed
file /mnt/scratch/533 missing - fsync failed
file /mnt/scratch/534 missing - fsync failed
file /mnt/scratch/535 missing - fsync failed
file /mnt/scratch/536 missing - fsync failed
file /mnt/scratch/537 missing - fsync failed
file /mnt/scratch/538 missing - fsync failed
file /mnt/scratch/539 missing - fsync failed
file /mnt/scratch/540 missing - fsync failed
file /mnt/scratch/541 missing - fsync failed
file /mnt/scratch/542 missing - fsync failed
file /mnt/scratch/543 missing - fsync failed
file /mnt/scratch/544 missing - fsync failed
file /mnt/scratch/545 missing - fsync failed
file /mnt/scratch/546 missing - fsync failed
file /mnt/scratch/547 missing - fsync failed
file /mnt/scratch/548 missing - fsync failed
file /mnt/scratch/549 missing - fsync failed
file /mnt/scratch/550 missing - fsync failed
file /mnt/scratch/551 missing - fsync failed
file /mnt/scratch/552 missing - fsync failed
file /mnt/scratch/553 missing - fsync failed
file /mnt/scratch/554 missing - fsync failed
file /mnt/scratch/555 missing - fsync failed
file /mnt/scratch/556 missing - fsync failed
file /mnt/scratch/557 missing - fsync failed
file /mnt/scratch/558 missing - fsync failed
file /mnt/scratch/559 missing - fsync failed
file /mnt/scratch/560 missing - fsync failed
file /mnt/scratch/561 missing - fsync failed
file /mnt/scratch/562 missing - fsync failed
file /mnt/scratch/563 missing - fsync failed
file /mnt/scratch/564 missing - fsync failed
file /mnt/scratch/565 missing - fsync failed
file /mnt/scratch/566 missing - fsync failed
file /mnt/scratch/567 missing - fsync failed
file /mnt/scratch/568 missing - fsync failed
file /mnt/scratch/569 missing - fsync failed
file /mnt/scratch/570 missing - fsync failed
file /mnt/scratch/571 missing - fsync failed
file /mnt/scratch/572 missing - fsync failed
file /mnt/scratch/573 missing - fsync failed
file /mnt/scratch/574 missing - fsync failed
file /mnt/scratch/575 missing - fsync failed
file /mnt/scratch/576 missing - fsync failed
file /mnt/scratch/577 missing - fsync failed
file /mnt/scratch/578 missing - fsync failed
file /mnt/scratch/579 missing - fsync failed
file /mnt/scratch/580 missing - fsync failed
file /mnt/scratch/581 missing - fsync failed
file /mnt/scratch/582 missing - fsync failed
file /mnt/scratch/583 missing - fsync failed
file /mnt/scratch/584 missing - fsync failed
file /mnt/scratch/585 missing - fsync failed
file /mnt/scratch/586 missing - fsync failed
file /mnt/scratch/587 missing - fsync failed
file /mnt/scratch/588 missing - fsync failed
file /mnt/scratch/589 missing - fsync failed
file /mnt/scratch/590 missing - fsync failed
file /mnt/scratch/591 missing - fsync failed
file /mnt/scratch/592 missing - fsync failed
file /mnt/scratch/593 missing - fsync failed
file /mnt/scratch/594 missing - fsync failed
file /mnt/scratch/595 missing - fsync failed
file /mnt/scratch/596 missing - fsync failed
file /mnt/scratch/597 missing - fsync failed
file /mnt/scratch/598 missing - fsync failed
file /mnt/scratch/599 missing - fsync failed
file /mnt/scratch/600 missing - fsync failed
file /mnt/scratch/601 missing - fsync failed
file /mnt/scratch/602 missing - fsync failed
file /mnt/scratch/603 missing - fsync failed
file /mnt/scratch/604 missing - fsync failed
file /mnt/scratch/605 missing - fsync failed
file /mnt/scratch/606 missing - fsync failed
file /mnt/scratch/607 missing - fsync failed
file /mnt/scratch/608 missing - fsync failed
file /mnt/scratch/609 missing - fsync failed
file /mnt/scratch/610 missing - fsync failed
file /mnt/scratch/611 missing - fsync failed
file /mnt/scratch/612 missing - fsync failed
file /mnt/scratch/613 missing - fsync failed
file /mnt/scratch/614 missing - fsync failed
file /mnt/scratch/615 missing - fsync failed
file /mnt/scratch/616 missing - fsync failed
file /mnt/scratch/617 missing - fsync failed
file /mnt/scratch/618 missing - fsync failed
file /mnt/scratch/619 missing - fsync failed
file /mnt/scratch/620 missing - fsync failed
file /mnt/scratch/621 missing - fsync failed
file /mnt/scratch/622 missing - fsync failed
file /mnt/scratch/623 missing - fsync failed
file /mnt/scratch/624 missing - fsync failed
file /mnt/scratch/625 missing - fsync failed
file /mnt/scratch/626 missing - fsync failed
file /mnt/scratch/627 missing - fsync failed
file /mnt/scratch/628 missing - fsync failed
file /mnt/scratch/629 missing - fsync failed
file /mnt/scratch/630 missing - fsync failed
file /mnt/scratch/631 missing - fsync failed
file /mnt/scratch/632 missing - fsync failed
file /mnt/scratch/633 missing - fsync failed
file /mnt/scratch/634 missing - fsync failed
file /mnt/scratch/635 missing - fsync failed
file /mnt/scratch/636 missing - fsync failed
file /mnt/scratch/637 missing - fsync failed
file /mnt/scratch/638 missing - fsync failed
file /mnt/scratch/639 missing - fsync failed
file /mnt/scratch/640 missing - fsync failed
file /mnt/scratch/641 missing - fsync failed
file /mnt/scratch/642 missing - fsync failed
file /mnt/scratch/643 missing - fsync failed
file /mnt/scratch/644 missing - fsync failed
file /mnt/scratch/645 missing - fsync failed
file /mnt/scratch/646 missing - fsync failed
file /mnt/scratch/647 missing - fsync failed
file /mnt/scratch/648 missing - fsync failed
file /mnt/scratch/649 missing - fsync failed
file /mnt/scratch/650 missing - fsync failed
file /mnt/scratch/651 missing - fsync failed
file /mnt/scratch/652 missing - fsync failed
file /mnt/scratch/653 missing - fsync failed
file /mnt/scratch/654 missing - fsync failed
file /mnt/scratch/655 missing - fsync failed
file /mnt/scratch/656 missing - fsync failed
file /mnt/scratch/657 missing - fsync failed
file /mnt/scratch/658 missing - fsync failed
file /mnt/scratch/659 missing - fsync failed
file /mnt/scratch/660 missing - fsync failed
file /mnt/scratch/661 missing - fsync failed
file /mnt/scratch/662 missing - fsync failed
file /mnt/scratch/663 missing - fsync failed
file /mnt/scratch/664 missing - fsync failed
file /mnt/scratch/665 missing - fsync failed
file /mnt/scratch/666 missing - fsync failed
file /mnt/scratch/667 missing - fsync failed
file /mnt/scratch/668 missing - fsync failed
file /mnt/scratch/669 missing - fsync failed
file /mnt/scratch/670 missing - fsync failed
file /mnt/scratch/671 missing - fsync failed
file /mnt/scratch/672 missing - fsync failed
file /mnt/scratch/673 missing - fsync failed
file /mnt/scratch/674 missing - fsync failed
file /mnt/scratch/675 missing - fsync failed
file /mnt/scratch/676 missing - fsync failed
file /mnt/scratch/677 missing - fsync failed
file /mnt/scratch/678 missing - fsync failed
file /mnt/scratch/679 missing - fsync failed
file /mnt/scratch/680 missing - fsync failed
file /mnt/scratch/681 missing - fsync failed
file /mnt/scratch/682 missing - fsync failed
file /mnt/scratch/683 missing - fsync failed
file /mnt/scratch/684 missing - fsync failed
file /mnt/scratch/685 missing - fsync failed
file /mnt/scratch/686 missing - fsync failed
file /mnt/scratch/687 missing - fsync failed
file /mnt/scratch/688 missing - fsync failed
file /mnt/scratch/689 missing - fsync failed
file /mnt/scratch/690 missing - fsync failed
file /mnt/scratch/691 missing - fsync failed
file /mnt/scratch/692 missing - fsync failed
file /mnt/scratch/693 missing - fsync failed
file /mnt/scratch/694 missing - fsync failed
file /mnt/scratch/695 missing - fsync failed
file /mnt/scratch/696 missing - fsync failed
file /mnt/scratch/697 missing - fsync failed
file /mnt/scratch/698 missing - fsync failed
file /mnt/scratch/699 missing - fsync failed
file /mnt/scratch/700 missing - fsync failed
file /mnt/scratch/701 missing - fsync failed
file /mnt/scratch/702 missing - fsync failed
file /mnt/scratch/703 missing - fsync failed
file /mnt/scratch/704 missing - fsync failed
file /mnt/scratch/705 missing - fsync failed
file /mnt/scratch/706 missing - fsync failed
file /mnt/scratch/707 missing - fsync failed
file /mnt/scratch/708 missing - fsync failed
file /mnt/scratch/709 missing - fsync failed
file /mnt/scratch/710 missing - fsync failed
file /mnt/scratch/711 missing - fsync failed
file /mnt/scratch/712 missing - fsync failed
file /mnt/scratch/713 missing - fsync failed
file /mnt/scratch/714 missing - fsync failed
file /mnt/scratch/715 missing - fsync failed
file /mnt/scratch/716 missing - fsync failed
file /mnt/scratch/717 missing - fsync failed
file /mnt/scratch/718 missing - fsync failed
file /mnt/scratch/719 missing - fsync failed
file /mnt/scratch/720 missing - fsync failed
file /mnt/scratch/721 missing - fsync failed
file /mnt/scratch/722 missing - fsync failed
file /mnt/scratch/723 missing - fsync failed
file /mnt/scratch/724 missing - fsync failed
file /mnt/scratch/725 missing - fsync failed
file /mnt/scratch/726 missing - fsync failed
file /mnt/scratch/727 missing - fsync failed
file /mnt/scratch/728 missing - fsync failed
file /mnt/scratch/729 missing - fsync failed
file /mnt/scratch/730 missing - fsync failed
file /mnt/scratch/731 missing - fsync failed
file /mnt/scratch/732 missing - fsync failed
file /mnt/scratch/733 missing - fsync failed
file /mnt/scratch/734 missing - fsync failed
file /mnt/scratch/735 missing - fsync failed
file /mnt/scratch/736 missing - fsync failed
file /mnt/scratch/737 missing - fsync failed
file /mnt/scratch/738 missing - fsync failed
file /mnt/scratch/739 missing - fsync failed
file /mnt/scratch/740 missing - fsync failed
file /mnt/scratch/741 missing - fsync failed
file /mnt/scratch/742 missing - fsync failed
file /mnt/scratch/743 missing - fsync failed
file /mnt/scratch/744 missing - fsync failed
file /mnt/scratch/745 missing - fsync failed
file /mnt/scratch/746 missing - fsync failed
file /mnt/scratch/747 missing - fsync failed
file /mnt/scratch/748 missing - fsync failed
file /mnt/scratch/749 missing - fsync failed
file /mnt/scratch/750 missing - fsync failed
file /mnt/scratch/751 missing - fsync failed
file /mnt/scratch/752 missing - fsync failed
file /mnt/scratch/753 missing - fsync failed
file /mnt/scratch/754 missing - fsync failed
file /mnt/scratch/755 missing - fsync failed
file /mnt/scratch/756 missing - fsync failed
file /mnt/scratch/757 missing - fsync failed
file /mnt/scratch/758 missing - fsync failed
file /mnt/scratch/759 missing - fsync failed
file /mnt/scratch/760 missing - fsync failed
file /mnt/scratch/761 missing - fsync failed
file /mnt/scratch/762 missing - fsync failed
file /mnt/scratch/763 missing - fsync failed
file /mnt/scratch/764 missing - fsync failed
file /mnt/scratch/765 missing - fsync failed
file /mnt/scratch/766 missing - fsync failed
file /mnt/scratch/767 missing - fsync failed
file /mnt/scratch/768 missing - fsync failed
file /mnt/scratch/769 missing - fsync failed
file /mnt/scratch/770 missing - fsync failed
file /mnt/scratch/771 missing - fsync failed
file /mnt/scratch/772 missing - fsync failed
file /mnt/scratch/773 missing - fsync failed
file /mnt/scratch/774 missing - fsync failed
file /mnt/scratch/775 missing - fsync failed
file /mnt/scratch/776 missing - fsync failed
file /mnt/scratch/777 missing - fsync failed
file /mnt/scratch/778 missing - fsync failed
file /mnt/scratch/779 missing - fsync failed
file /mnt/scratch/780 missing - fsync failed
file /mnt/scratch/781 missing - fsync failed
file /mnt/scratch/782 missing - fsync failed
file /mnt/scratch/783 missing - fsync failed
file /mnt/scratch/784 missing - fsync failed
file /mnt/scratch/785 missing - fsync failed
file /mnt/scratch/786 missing - fsync failed
file /mnt/scratch/787 missing - fsync failed
file /mnt/scratch/788 missing - fsync failed
file /mnt/scratch/789 missing - fsync failed
file /mnt/scratch/790 missing - fsync failed
file /mnt/scratch/791 missing - fsync failed
file /mnt/scratch/792 missing - fsync failed
file /mnt/scratch/793 missing - fsync failed
file /mnt/scratch/794 missing - fsync failed
file /mnt/scratch/795 missing - fsync failed
file /mnt/scratch/796 missing - fsync failed
file /mnt/scratch/797 missing - fsync failed
file /mnt/scratch/798 missing - fsync failed
file /mnt/scratch/799 missing - fsync failed
file /mnt/scratch/800 missing - fsync failed
file /mnt/scratch/801 missing - fsync failed
file /mnt/scratch/802 missing - fsync failed
file /mnt/scratch/803 missing - fsync failed
file /mnt/scratch/804 missing - fsync failed
file /mnt/scratch/805 missing - fsync failed
file /mnt/scratch/806 missing - fsync failed
file /mnt/scratch/807 missing - fsync failed
file /mnt/scratch/808 missing - fsync failed
file /mnt/scratch/809 missing - fsync failed
file /mnt/scratch/810 missing - fsync failed
file /mnt/scratch/811 missing - fsync failed
file /mnt/scratch/812 missing - fsync failed
file /mnt/scratch/813 missing - fsync failed
file /mnt/scratch/814 missing - fsync failed
file /mnt/scratch/815 missing - fsync failed
file /mnt/scratch/816 missing - fsync failed
file /mnt/scratch/817 missing - fsync failed
file /mnt/scratch/818 missing - fsync failed
file /mnt/scratch/819 missing - fsync failed
file /mnt/scratch/820 missing - fsync failed
file /mnt/scratch/821 missing - fsync failed
file /mnt/scratch/822 missing - fsync failed
file /mnt/scratch/823 missing - fsync failed
file /mnt/scratch/824 missing - fsync failed
file /mnt/scratch/825 missing - fsync failed
file /mnt/scratch/826 missing - fsync failed
file /mnt/scratch/827 missing - fsync failed
file /mnt/scratch/828 missing - fsync failed
file /mnt/scratch/829 missing - fsync failed
file /mnt/scratch/830 missing - fsync failed
file /mnt/scratch/831 missing - fsync failed
file /mnt/scratch/832 missing - fsync failed
file /mnt/scratch/833 missing - fsync failed
file /mnt/scratch/834 missing - fsync failed
file /mnt/scratch/835 missing - fsync failed
file /mnt/scratch/836 missing - fsync failed
file /mnt/scratch/837 missing - fsync failed
file /mnt/scratch/838 missing - fsync failed
file /mnt/scratch/839 missing - fsync failed
file /mnt/scratch/840 missing - fsync failed
file /mnt/scratch/841 missing - fsync failed
file /mnt/scratch/842 missing - fsync failed
file /mnt/scratch/843 missing - fsync failed
file /mnt/scratch/844 missing - fsync failed
file /mnt/scratch/845 missing - fsync failed
file /mnt/scratch/846 missing - fsync failed
file /mnt/scratch/847 missing - fsync failed
file /mnt/scratch/848 missing - fsync failed
file /mnt/scratch/849 missing - fsync failed
file /mnt/scratch/850 missing - fsync failed
file /mnt/scratch/851 missing - fsync failed
file /mnt/scratch/852 missing - fsync failed
file /mnt/scratch/853 missing - fsync failed
file /mnt/scratch/854 missing - fsync failed
file /mnt/scratch/855 missing - fsync failed
file /mnt/scratch/856 missing - fsync failed
file /mnt/scratch/857 missing - fsync failed
file /mnt/scratch/858 missing - fsync failed
file /mnt/scratch/859 missing - fsync failed
file /mnt/scratch/860 missing - fsync failed
file /mnt/scratch/861 missing - fsync failed
file /mnt/scratch/862 missing - fsync failed
file /mnt/scratch/863 missing - fsync failed
file /mnt/scratch/864 missing - fsync failed
file /mnt/scratch/865 missing - fsync failed
file /mnt/scratch/866 missing - fsync failed
file /mnt/scratch/867 missing - fsync failed
file /mnt/scratch/868 missing - fsync failed
file /mnt/scratch/869 missing - fsync failed
file /mnt/scratch/870 missing - fsync failed
file /mnt/scratch/871 missing - fsync failed
file /mnt/scratch/872 missing - fsync failed
file /mnt/scratch/873 missing - fsync failed
file /mnt/scratch/874 missing - fsync failed
file /mnt/scratch/875 missing - fsync failed
file /mnt/scratch/876 missing - fsync failed
file /mnt/scratch/877 missing - fsync failed
file /mnt/scratch/878 missing - fsync failed
file /mnt/scratch/879 missing - fsync failed
file /mnt/scratch/880 missing - fsync failed
file /mnt/scratch/881 missing - fsync failed
file /mnt/scratch/882 missing - fsync failed
file /mnt/scratch/883 missing - fsync failed
file /mnt/scratch/884 missing - fsync failed
file /mnt/scratch/885 missing - fsync failed
file /mnt/scratch/886 missing - fsync failed
file /mnt/scratch/887 missing - fsync failed
file /mnt/scratch/888 missing - fsync failed
file /mnt/scratch/889 missing - fsync failed
file /mnt/scratch/890 missing - fsync failed
file /mnt/scratch/891 missing - fsync failed
file /mnt/scratch/892 missing - fsync failed
file /mnt/scratch/893 missing - fsync failed
file /mnt/scratch/894 missing - fsync failed
file /mnt/scratch/895 missing - fsync failed
file /mnt/scratch/896 missing - fsync failed
file /mnt/scratch/897 missing - fsync failed
file /mnt/scratch/898 missing - fsync failed
file /mnt/scratch/899 missing - fsync failed
file /mnt/scratch/900 missing - fsync failed
file /mnt/scratch/901 missing - fsync failed
file /mnt/scratch/902 missing - fsync failed
file /mnt/scratch/903 missing - fsync failed
file /mnt/scratch/904 missing - fsync failed
file /mnt/scratch/905 missing - fsync failed
file /mnt/scratch/906 missing - fsync failed
file /mnt/scratch/907 missing - fsync failed
file /mnt/scratch/908 missing - fsync failed
file /mnt/scratch/909 missing - fsync failed
file /mnt/scratch/910 missing - fsync failed
file /mnt/scratch/911 missing - fsync failed
file /mnt/scratch/912 missing - fsync failed
file /mnt/scratch/913 missing - fsync failed
file /mnt/scratch/914 missing - fsync failed
file /mnt/scratch/915 missing - fsync failed
file /mnt/scratch/916 missing - fsync failed
file /mnt/scratch/917 missing - fsync failed
file /mnt/scratch/918 missing - fsync failed
file /mnt/scratch/919 missing - fsync failed
file /mnt/scratch/920 missing - fsync failed
file /mnt/scratch/921 missing - fsync failed
file /mnt/scratch/922 missing - fsync failed
file /mnt/scratch/923 missing - fsync failed
file /mnt/scratch/924 missing - fsync failed
file /mnt/scratch/925 missing - fsync failed
file /mnt/scratch/926 missing - fsync failed
file /mnt/scratch/927 missing - fsync failed
file /mnt/scratch/928 missing - fsync failed
file /mnt/scratch/929 missing - fsync failed
file /mnt/scratch/930 missing - fsync failed
file /mnt/scratch/931 missing - fsync failed
file /mnt/scratch/932 missing - fsync failed
file /mnt/scratch/933 missing - fsync failed
file /mnt/scratch/934 missing - fsync failed
file /mnt/scratch/935 missing - fsync failed
file /mnt/scratch/936 missing - fsync failed
file /mnt/scratch/937 missing - fsync failed
file /mnt/scratch/938 missing - fsync failed
file /mnt/scratch/939 missing - fsync failed
file /mnt/scratch/940 missing - fsync failed
file /mnt/scratch/941 missing - fsync failed
file /mnt/scratch/942 missing - fsync failed
file /mnt/scratch/943 missing - fsync failed
file /mnt/scratch/944 missing - fsync failed
file /mnt/scratch/945 missing - fsync failed
file /mnt/scratch/946 missing - fsync failed
file /mnt/scratch/947 missing - fsync failed
file /mnt/scratch/948 missing - fsync failed
file /mnt/scratch/949 missing - fsync failed
file /mnt/scratch/950 missing - fsync failed
file /mnt/scratch/951 missing - fsync failed
file /mnt/scratch/952 missing - fsync failed
file /mnt/scratch/953 missing - fsync failed
file /mnt/scratch/954 missing - fsync failed
file /mnt/scratch/955 missing - fsync failed
file /mnt/scratch/956 missing - fsync failed
file /mnt/scratch/957 missing - fsync failed
file /mnt/scratch/958 missing - fsync failed
file /mnt/scratch/959 missing - fsync failed
file /mnt/scratch/960 missing - fsync failed
file /mnt/scratch/961 missing - fsync failed
file /mnt/scratch/962 missing - fsync failed
file /mnt/scratch/963 missing - fsync failed
file /mnt/scratch/964 missing - fsync failed
file /mnt/scratch/965 missing - fsync failed
file /mnt/scratch/966 missing - fsync failed
file /mnt/scratch/967 missing - fsync failed
file /mnt/scratch/968 missing - fsync failed
file /mnt/scratch/969 missing - fsync failed
file /mnt/scratch/970 missing - fsync failed
file /mnt/scratch/971 missing - fsync failed
file /mnt/scratch/972 missing - fsync failed
file /mnt/scratch/973 missing - fsync failed
file /mnt/scratch/974 missing - fsync failed
file /mnt/scratch/975 missing - fsync failed
file /mnt/scratch/976 missing - fsync failed
file /mnt/scratch/977 missing - fsync failed
file /mnt/scratch/978 missing - fsync failed
file /mnt/scratch/979 missing - fsync failed
file /mnt/scratch/980 missing - fsync failed
file /mnt/scratch/981 missing - fsync failed
file /mnt/scratch/982 missing - fsync failed
file /mnt/scratch/983 missing - fsync failed
file /mnt/scratch/984 missing - fsync failed
file /mnt/scratch/985 missing - fsync failed
file /mnt/scratch/986 missing - fsync failed
file /mnt/scratch/987 missing - fsync failed
file /mnt/scratch/988 missing - fsync failed
file /mnt/scratch/989 missing - fsync failed
file /mnt/scratch/990 missing - fsync failed
file /mnt/scratch/991 missing - fsync failed
file /mnt/scratch/992 missing - fsync failed
file /mnt/scratch/993 missing - fsync failed
file /mnt/scratch/994 missing - fsync failed
file /mnt/scratch/995 missing - fsync failed
file /mnt/scratch/996 missing - fsync failed
file /mnt/scratch/997 missing - fsync failed
file /mnt/scratch/998 missing - fsync failed
file /mnt/scratch/999 missing - fsync failed

[-- Attachment #7: 182.out.bad --]
[-- Type: text/plain, Size: 43971 bytes --]

QA output created by 182
mount: Structure needs cleaning
umount: /mnt/scratch: not mounted
mount: Structure needs cleaning
file /mnt/scratch/1 missing - sync failed
file /mnt/scratch/2 missing - sync failed
file /mnt/scratch/3 missing - sync failed
file /mnt/scratch/4 missing - sync failed
file /mnt/scratch/5 missing - sync failed
file /mnt/scratch/6 missing - sync failed
file /mnt/scratch/7 missing - sync failed
file /mnt/scratch/8 missing - sync failed
file /mnt/scratch/9 missing - sync failed
file /mnt/scratch/10 missing - sync failed
file /mnt/scratch/11 missing - sync failed
file /mnt/scratch/12 missing - sync failed
file /mnt/scratch/13 missing - sync failed
file /mnt/scratch/14 missing - sync failed
file /mnt/scratch/15 missing - sync failed
file /mnt/scratch/16 missing - sync failed
file /mnt/scratch/17 missing - sync failed
file /mnt/scratch/18 missing - sync failed
file /mnt/scratch/19 missing - sync failed
file /mnt/scratch/20 missing - sync failed
file /mnt/scratch/21 missing - sync failed
file /mnt/scratch/22 missing - sync failed
file /mnt/scratch/23 missing - sync failed
file /mnt/scratch/24 missing - sync failed
file /mnt/scratch/25 missing - sync failed
file /mnt/scratch/26 missing - sync failed
file /mnt/scratch/27 missing - sync failed
file /mnt/scratch/28 missing - sync failed
file /mnt/scratch/29 missing - sync failed
file /mnt/scratch/30 missing - sync failed
file /mnt/scratch/31 missing - sync failed
file /mnt/scratch/32 missing - sync failed
file /mnt/scratch/33 missing - sync failed
file /mnt/scratch/34 missing - sync failed
file /mnt/scratch/35 missing - sync failed
file /mnt/scratch/36 missing - sync failed
file /mnt/scratch/37 missing - sync failed
file /mnt/scratch/38 missing - sync failed
file /mnt/scratch/39 missing - sync failed
file /mnt/scratch/40 missing - sync failed
file /mnt/scratch/41 missing - sync failed
file /mnt/scratch/42 missing - sync failed
file /mnt/scratch/43 missing - sync failed
file /mnt/scratch/44 missing - sync failed
file /mnt/scratch/45 missing - sync failed
file /mnt/scratch/46 missing - sync failed
file /mnt/scratch/47 missing - sync failed
file /mnt/scratch/48 missing - sync failed
file /mnt/scratch/49 missing - sync failed
file /mnt/scratch/50 missing - sync failed
file /mnt/scratch/51 missing - sync failed
file /mnt/scratch/52 missing - sync failed
file /mnt/scratch/53 missing - sync failed
file /mnt/scratch/54 missing - sync failed
file /mnt/scratch/55 missing - sync failed
file /mnt/scratch/56 missing - sync failed
file /mnt/scratch/57 missing - sync failed
file /mnt/scratch/58 missing - sync failed
file /mnt/scratch/59 missing - sync failed
file /mnt/scratch/60 missing - sync failed
file /mnt/scratch/61 missing - sync failed
file /mnt/scratch/62 missing - sync failed
file /mnt/scratch/63 missing - sync failed
file /mnt/scratch/64 missing - sync failed
file /mnt/scratch/65 missing - sync failed
file /mnt/scratch/66 missing - sync failed
file /mnt/scratch/67 missing - sync failed
file /mnt/scratch/68 missing - sync failed
file /mnt/scratch/69 missing - sync failed
file /mnt/scratch/70 missing - sync failed
file /mnt/scratch/71 missing - sync failed
file /mnt/scratch/72 missing - sync failed
file /mnt/scratch/73 missing - sync failed
file /mnt/scratch/74 missing - sync failed
file /mnt/scratch/75 missing - sync failed
file /mnt/scratch/76 missing - sync failed
file /mnt/scratch/77 missing - sync failed
file /mnt/scratch/78 missing - sync failed
file /mnt/scratch/79 missing - sync failed
file /mnt/scratch/80 missing - sync failed
file /mnt/scratch/81 missing - sync failed
file /mnt/scratch/82 missing - sync failed
file /mnt/scratch/83 missing - sync failed
file /mnt/scratch/84 missing - sync failed
file /mnt/scratch/85 missing - sync failed
file /mnt/scratch/86 missing - sync failed
file /mnt/scratch/87 missing - sync failed
file /mnt/scratch/88 missing - sync failed
file /mnt/scratch/89 missing - sync failed
file /mnt/scratch/90 missing - sync failed
file /mnt/scratch/91 missing - sync failed
file /mnt/scratch/92 missing - sync failed
file /mnt/scratch/93 missing - sync failed
file /mnt/scratch/94 missing - sync failed
file /mnt/scratch/95 missing - sync failed
file /mnt/scratch/96 missing - sync failed
file /mnt/scratch/97 missing - sync failed
file /mnt/scratch/98 missing - sync failed
file /mnt/scratch/99 missing - sync failed
file /mnt/scratch/100 missing - sync failed
file /mnt/scratch/101 missing - sync failed
file /mnt/scratch/102 missing - sync failed
file /mnt/scratch/103 missing - sync failed
file /mnt/scratch/104 missing - sync failed
file /mnt/scratch/105 missing - sync failed
file /mnt/scratch/106 missing - sync failed
file /mnt/scratch/107 missing - sync failed
file /mnt/scratch/108 missing - sync failed
file /mnt/scratch/109 missing - sync failed
file /mnt/scratch/110 missing - sync failed
file /mnt/scratch/111 missing - sync failed
file /mnt/scratch/112 missing - sync failed
file /mnt/scratch/113 missing - sync failed
file /mnt/scratch/114 missing - sync failed
file /mnt/scratch/115 missing - sync failed
file /mnt/scratch/116 missing - sync failed
file /mnt/scratch/117 missing - sync failed
file /mnt/scratch/118 missing - sync failed
file /mnt/scratch/119 missing - sync failed
file /mnt/scratch/120 missing - sync failed
file /mnt/scratch/121 missing - sync failed
file /mnt/scratch/122 missing - sync failed
file /mnt/scratch/123 missing - sync failed
file /mnt/scratch/124 missing - sync failed
file /mnt/scratch/125 missing - sync failed
file /mnt/scratch/126 missing - sync failed
file /mnt/scratch/127 missing - sync failed
file /mnt/scratch/128 missing - sync failed
file /mnt/scratch/129 missing - sync failed
file /mnt/scratch/130 missing - sync failed
file /mnt/scratch/131 missing - sync failed
file /mnt/scratch/132 missing - sync failed
file /mnt/scratch/133 missing - sync failed
file /mnt/scratch/134 missing - sync failed
file /mnt/scratch/135 missing - sync failed
file /mnt/scratch/136 missing - sync failed
file /mnt/scratch/137 missing - sync failed
file /mnt/scratch/138 missing - sync failed
file /mnt/scratch/139 missing - sync failed
file /mnt/scratch/140 missing - sync failed
file /mnt/scratch/141 missing - sync failed
file /mnt/scratch/142 missing - sync failed
file /mnt/scratch/143 missing - sync failed
file /mnt/scratch/144 missing - sync failed
file /mnt/scratch/145 missing - sync failed
file /mnt/scratch/146 missing - sync failed
file /mnt/scratch/147 missing - sync failed
file /mnt/scratch/148 missing - sync failed
file /mnt/scratch/149 missing - sync failed
file /mnt/scratch/150 missing - sync failed
file /mnt/scratch/151 missing - sync failed
file /mnt/scratch/152 missing - sync failed
file /mnt/scratch/153 missing - sync failed
file /mnt/scratch/154 missing - sync failed
file /mnt/scratch/155 missing - sync failed
file /mnt/scratch/156 missing - sync failed
file /mnt/scratch/157 missing - sync failed
file /mnt/scratch/158 missing - sync failed
file /mnt/scratch/159 missing - sync failed
file /mnt/scratch/160 missing - sync failed
file /mnt/scratch/161 missing - sync failed
file /mnt/scratch/162 missing - sync failed
file /mnt/scratch/163 missing - sync failed
file /mnt/scratch/164 missing - sync failed
file /mnt/scratch/165 missing - sync failed
file /mnt/scratch/166 missing - sync failed
file /mnt/scratch/167 missing - sync failed
file /mnt/scratch/168 missing - sync failed
file /mnt/scratch/169 missing - sync failed
file /mnt/scratch/170 missing - sync failed
file /mnt/scratch/171 missing - sync failed
file /mnt/scratch/172 missing - sync failed
file /mnt/scratch/173 missing - sync failed
file /mnt/scratch/174 missing - sync failed
file /mnt/scratch/175 missing - sync failed
file /mnt/scratch/176 missing - sync failed
file /mnt/scratch/177 missing - sync failed
file /mnt/scratch/178 missing - sync failed
file /mnt/scratch/179 missing - sync failed
file /mnt/scratch/180 missing - sync failed
file /mnt/scratch/181 missing - sync failed
file /mnt/scratch/182 missing - sync failed
file /mnt/scratch/183 missing - sync failed
file /mnt/scratch/184 missing - sync failed
file /mnt/scratch/185 missing - sync failed
file /mnt/scratch/186 missing - sync failed
file /mnt/scratch/187 missing - sync failed
file /mnt/scratch/188 missing - sync failed
file /mnt/scratch/189 missing - sync failed
file /mnt/scratch/190 missing - sync failed
file /mnt/scratch/191 missing - sync failed
file /mnt/scratch/192 missing - sync failed
file /mnt/scratch/193 missing - sync failed
file /mnt/scratch/194 missing - sync failed
file /mnt/scratch/195 missing - sync failed
file /mnt/scratch/196 missing - sync failed
file /mnt/scratch/197 missing - sync failed
file /mnt/scratch/198 missing - sync failed
file /mnt/scratch/199 missing - sync failed
file /mnt/scratch/200 missing - sync failed
file /mnt/scratch/201 missing - sync failed
file /mnt/scratch/202 missing - sync failed
file /mnt/scratch/203 missing - sync failed
file /mnt/scratch/204 missing - sync failed
file /mnt/scratch/205 missing - sync failed
file /mnt/scratch/206 missing - sync failed
file /mnt/scratch/207 missing - sync failed
file /mnt/scratch/208 missing - sync failed
file /mnt/scratch/209 missing - sync failed
file /mnt/scratch/210 missing - sync failed
file /mnt/scratch/211 missing - sync failed
file /mnt/scratch/212 missing - sync failed
file /mnt/scratch/213 missing - sync failed
file /mnt/scratch/214 missing - sync failed
file /mnt/scratch/215 missing - sync failed
file /mnt/scratch/216 missing - sync failed
file /mnt/scratch/217 missing - sync failed
file /mnt/scratch/218 missing - sync failed
file /mnt/scratch/219 missing - sync failed
file /mnt/scratch/220 missing - sync failed
file /mnt/scratch/221 missing - sync failed
file /mnt/scratch/222 missing - sync failed
file /mnt/scratch/223 missing - sync failed
file /mnt/scratch/224 missing - sync failed
file /mnt/scratch/225 missing - sync failed
file /mnt/scratch/226 missing - sync failed
file /mnt/scratch/227 missing - sync failed
file /mnt/scratch/228 missing - sync failed
file /mnt/scratch/229 missing - sync failed
file /mnt/scratch/230 missing - sync failed
file /mnt/scratch/231 missing - sync failed
file /mnt/scratch/232 missing - sync failed
file /mnt/scratch/233 missing - sync failed
file /mnt/scratch/234 missing - sync failed
file /mnt/scratch/235 missing - sync failed
file /mnt/scratch/236 missing - sync failed
file /mnt/scratch/237 missing - sync failed
file /mnt/scratch/238 missing - sync failed
file /mnt/scratch/239 missing - sync failed
file /mnt/scratch/240 missing - sync failed
file /mnt/scratch/241 missing - sync failed
file /mnt/scratch/242 missing - sync failed
file /mnt/scratch/243 missing - sync failed
file /mnt/scratch/244 missing - sync failed
file /mnt/scratch/245 missing - sync failed
file /mnt/scratch/246 missing - sync failed
file /mnt/scratch/247 missing - sync failed
file /mnt/scratch/248 missing - sync failed
file /mnt/scratch/249 missing - sync failed
file /mnt/scratch/250 missing - sync failed
file /mnt/scratch/251 missing - sync failed
file /mnt/scratch/252 missing - sync failed
file /mnt/scratch/253 missing - sync failed
file /mnt/scratch/254 missing - sync failed
file /mnt/scratch/255 missing - sync failed
file /mnt/scratch/256 missing - sync failed
file /mnt/scratch/257 missing - sync failed
file /mnt/scratch/258 missing - sync failed
file /mnt/scratch/259 missing - sync failed
file /mnt/scratch/260 missing - sync failed
file /mnt/scratch/261 missing - sync failed
file /mnt/scratch/262 missing - sync failed
file /mnt/scratch/263 missing - sync failed
file /mnt/scratch/264 missing - sync failed
file /mnt/scratch/265 missing - sync failed
file /mnt/scratch/266 missing - sync failed
file /mnt/scratch/267 missing - sync failed
file /mnt/scratch/268 missing - sync failed
file /mnt/scratch/269 missing - sync failed
file /mnt/scratch/270 missing - sync failed
file /mnt/scratch/271 missing - sync failed
file /mnt/scratch/272 missing - sync failed
file /mnt/scratch/273 missing - sync failed
file /mnt/scratch/274 missing - sync failed
file /mnt/scratch/275 missing - sync failed
file /mnt/scratch/276 missing - sync failed
file /mnt/scratch/277 missing - sync failed
file /mnt/scratch/278 missing - sync failed
file /mnt/scratch/279 missing - sync failed
file /mnt/scratch/280 missing - sync failed
file /mnt/scratch/281 missing - sync failed
file /mnt/scratch/282 missing - sync failed
file /mnt/scratch/283 missing - sync failed
file /mnt/scratch/284 missing - sync failed
file /mnt/scratch/285 missing - sync failed
file /mnt/scratch/286 missing - sync failed
file /mnt/scratch/287 missing - sync failed
file /mnt/scratch/288 missing - sync failed
file /mnt/scratch/289 missing - sync failed
file /mnt/scratch/290 missing - sync failed
file /mnt/scratch/291 missing - sync failed
file /mnt/scratch/292 missing - sync failed
file /mnt/scratch/293 missing - sync failed
file /mnt/scratch/294 missing - sync failed
file /mnt/scratch/295 missing - sync failed
file /mnt/scratch/296 missing - sync failed
file /mnt/scratch/297 missing - sync failed
file /mnt/scratch/298 missing - sync failed
file /mnt/scratch/299 missing - sync failed
file /mnt/scratch/300 missing - sync failed
file /mnt/scratch/301 missing - sync failed
file /mnt/scratch/302 missing - sync failed
file /mnt/scratch/303 missing - sync failed
file /mnt/scratch/304 missing - sync failed
file /mnt/scratch/305 missing - sync failed
file /mnt/scratch/306 missing - sync failed
file /mnt/scratch/307 missing - sync failed
file /mnt/scratch/308 missing - sync failed
file /mnt/scratch/309 missing - sync failed
file /mnt/scratch/310 missing - sync failed
file /mnt/scratch/311 missing - sync failed
file /mnt/scratch/312 missing - sync failed
file /mnt/scratch/313 missing - sync failed
file /mnt/scratch/314 missing - sync failed
file /mnt/scratch/315 missing - sync failed
file /mnt/scratch/316 missing - sync failed
file /mnt/scratch/317 missing - sync failed
file /mnt/scratch/318 missing - sync failed
file /mnt/scratch/319 missing - sync failed
file /mnt/scratch/320 missing - sync failed
file /mnt/scratch/321 missing - sync failed
file /mnt/scratch/322 missing - sync failed
file /mnt/scratch/323 missing - sync failed
file /mnt/scratch/324 missing - sync failed
file /mnt/scratch/325 missing - sync failed
file /mnt/scratch/326 missing - sync failed
file /mnt/scratch/327 missing - sync failed
file /mnt/scratch/328 missing - sync failed
file /mnt/scratch/329 missing - sync failed
file /mnt/scratch/330 missing - sync failed
file /mnt/scratch/331 missing - sync failed
file /mnt/scratch/332 missing - sync failed
file /mnt/scratch/333 missing - sync failed
file /mnt/scratch/334 missing - sync failed
file /mnt/scratch/335 missing - sync failed
file /mnt/scratch/336 missing - sync failed
file /mnt/scratch/337 missing - sync failed
file /mnt/scratch/338 missing - sync failed
file /mnt/scratch/339 missing - sync failed
file /mnt/scratch/340 missing - sync failed
file /mnt/scratch/341 missing - sync failed
file /mnt/scratch/342 missing - sync failed
file /mnt/scratch/343 missing - sync failed
file /mnt/scratch/344 missing - sync failed
file /mnt/scratch/345 missing - sync failed
file /mnt/scratch/346 missing - sync failed
file /mnt/scratch/347 missing - sync failed
file /mnt/scratch/348 missing - sync failed
file /mnt/scratch/349 missing - sync failed
file /mnt/scratch/350 missing - sync failed
file /mnt/scratch/351 missing - sync failed
file /mnt/scratch/352 missing - sync failed
file /mnt/scratch/353 missing - sync failed
file /mnt/scratch/354 missing - sync failed
file /mnt/scratch/355 missing - sync failed
file /mnt/scratch/356 missing - sync failed
file /mnt/scratch/357 missing - sync failed
file /mnt/scratch/358 missing - sync failed
file /mnt/scratch/359 missing - sync failed
file /mnt/scratch/360 missing - sync failed
file /mnt/scratch/361 missing - sync failed
file /mnt/scratch/362 missing - sync failed
file /mnt/scratch/363 missing - sync failed
file /mnt/scratch/364 missing - sync failed
file /mnt/scratch/365 missing - sync failed
file /mnt/scratch/366 missing - sync failed
file /mnt/scratch/367 missing - sync failed
file /mnt/scratch/368 missing - sync failed
file /mnt/scratch/369 missing - sync failed
file /mnt/scratch/370 missing - sync failed
file /mnt/scratch/371 missing - sync failed
file /mnt/scratch/372 missing - sync failed
file /mnt/scratch/373 missing - sync failed
file /mnt/scratch/374 missing - sync failed
file /mnt/scratch/375 missing - sync failed
file /mnt/scratch/376 missing - sync failed
file /mnt/scratch/377 missing - sync failed
file /mnt/scratch/378 missing - sync failed
file /mnt/scratch/379 missing - sync failed
file /mnt/scratch/380 missing - sync failed
file /mnt/scratch/381 missing - sync failed
file /mnt/scratch/382 missing - sync failed
file /mnt/scratch/383 missing - sync failed
file /mnt/scratch/384 missing - sync failed
file /mnt/scratch/385 missing - sync failed
file /mnt/scratch/386 missing - sync failed
file /mnt/scratch/387 missing - sync failed
file /mnt/scratch/388 missing - sync failed
file /mnt/scratch/389 missing - sync failed
file /mnt/scratch/390 missing - sync failed
file /mnt/scratch/391 missing - sync failed
file /mnt/scratch/392 missing - sync failed
file /mnt/scratch/393 missing - sync failed
file /mnt/scratch/394 missing - sync failed
file /mnt/scratch/395 missing - sync failed
file /mnt/scratch/396 missing - sync failed
file /mnt/scratch/397 missing - sync failed
file /mnt/scratch/398 missing - sync failed
file /mnt/scratch/399 missing - sync failed
file /mnt/scratch/400 missing - sync failed
file /mnt/scratch/401 missing - sync failed
file /mnt/scratch/402 missing - sync failed
file /mnt/scratch/403 missing - sync failed
file /mnt/scratch/404 missing - sync failed
file /mnt/scratch/405 missing - sync failed
file /mnt/scratch/406 missing - sync failed
file /mnt/scratch/407 missing - sync failed
file /mnt/scratch/408 missing - sync failed
file /mnt/scratch/409 missing - sync failed
file /mnt/scratch/410 missing - sync failed
file /mnt/scratch/411 missing - sync failed
file /mnt/scratch/412 missing - sync failed
file /mnt/scratch/413 missing - sync failed
file /mnt/scratch/414 missing - sync failed
file /mnt/scratch/415 missing - sync failed
file /mnt/scratch/416 missing - sync failed
file /mnt/scratch/417 missing - sync failed
file /mnt/scratch/418 missing - sync failed
file /mnt/scratch/419 missing - sync failed
file /mnt/scratch/420 missing - sync failed
file /mnt/scratch/421 missing - sync failed
file /mnt/scratch/422 missing - sync failed
file /mnt/scratch/423 missing - sync failed
file /mnt/scratch/424 missing - sync failed
file /mnt/scratch/425 missing - sync failed
file /mnt/scratch/426 missing - sync failed
file /mnt/scratch/427 missing - sync failed
file /mnt/scratch/428 missing - sync failed
file /mnt/scratch/429 missing - sync failed
file /mnt/scratch/430 missing - sync failed
file /mnt/scratch/431 missing - sync failed
file /mnt/scratch/432 missing - sync failed
file /mnt/scratch/433 missing - sync failed
file /mnt/scratch/434 missing - sync failed
file /mnt/scratch/435 missing - sync failed
file /mnt/scratch/436 missing - sync failed
file /mnt/scratch/437 missing - sync failed
file /mnt/scratch/438 missing - sync failed
file /mnt/scratch/439 missing - sync failed
file /mnt/scratch/440 missing - sync failed
file /mnt/scratch/441 missing - sync failed
file /mnt/scratch/442 missing - sync failed
file /mnt/scratch/443 missing - sync failed
file /mnt/scratch/444 missing - sync failed
file /mnt/scratch/445 missing - sync failed
file /mnt/scratch/446 missing - sync failed
file /mnt/scratch/447 missing - sync failed
file /mnt/scratch/448 missing - sync failed
file /mnt/scratch/449 missing - sync failed
file /mnt/scratch/450 missing - sync failed
file /mnt/scratch/451 missing - sync failed
file /mnt/scratch/452 missing - sync failed
file /mnt/scratch/453 missing - sync failed
file /mnt/scratch/454 missing - sync failed
file /mnt/scratch/455 missing - sync failed
file /mnt/scratch/456 missing - sync failed
file /mnt/scratch/457 missing - sync failed
file /mnt/scratch/458 missing - sync failed
file /mnt/scratch/459 missing - sync failed
file /mnt/scratch/460 missing - sync failed
file /mnt/scratch/461 missing - sync failed
file /mnt/scratch/462 missing - sync failed
file /mnt/scratch/463 missing - sync failed
file /mnt/scratch/464 missing - sync failed
file /mnt/scratch/465 missing - sync failed
file /mnt/scratch/466 missing - sync failed
file /mnt/scratch/467 missing - sync failed
file /mnt/scratch/468 missing - sync failed
file /mnt/scratch/469 missing - sync failed
file /mnt/scratch/470 missing - sync failed
file /mnt/scratch/471 missing - sync failed
file /mnt/scratch/472 missing - sync failed
file /mnt/scratch/473 missing - sync failed
file /mnt/scratch/474 missing - sync failed
file /mnt/scratch/475 missing - sync failed
file /mnt/scratch/476 missing - sync failed
file /mnt/scratch/477 missing - sync failed
file /mnt/scratch/478 missing - sync failed
file /mnt/scratch/479 missing - sync failed
file /mnt/scratch/480 missing - sync failed
file /mnt/scratch/481 missing - sync failed
file /mnt/scratch/482 missing - sync failed
file /mnt/scratch/483 missing - sync failed
file /mnt/scratch/484 missing - sync failed
file /mnt/scratch/485 missing - sync failed
file /mnt/scratch/486 missing - sync failed
file /mnt/scratch/487 missing - sync failed
file /mnt/scratch/488 missing - sync failed
file /mnt/scratch/489 missing - sync failed
file /mnt/scratch/490 missing - sync failed
file /mnt/scratch/491 missing - sync failed
file /mnt/scratch/492 missing - sync failed
file /mnt/scratch/493 missing - sync failed
file /mnt/scratch/494 missing - sync failed
file /mnt/scratch/495 missing - sync failed
file /mnt/scratch/496 missing - sync failed
file /mnt/scratch/497 missing - sync failed
file /mnt/scratch/498 missing - sync failed
file /mnt/scratch/499 missing - sync failed
file /mnt/scratch/500 missing - sync failed
file /mnt/scratch/501 missing - sync failed
file /mnt/scratch/502 missing - sync failed
file /mnt/scratch/503 missing - sync failed
file /mnt/scratch/504 missing - sync failed
file /mnt/scratch/505 missing - sync failed
file /mnt/scratch/506 missing - sync failed
file /mnt/scratch/507 missing - sync failed
file /mnt/scratch/508 missing - sync failed
file /mnt/scratch/509 missing - sync failed
file /mnt/scratch/510 missing - sync failed
file /mnt/scratch/511 missing - sync failed
file /mnt/scratch/512 missing - sync failed
file /mnt/scratch/513 missing - sync failed
file /mnt/scratch/514 missing - sync failed
file /mnt/scratch/515 missing - sync failed
file /mnt/scratch/516 missing - sync failed
file /mnt/scratch/517 missing - sync failed
file /mnt/scratch/518 missing - sync failed
file /mnt/scratch/519 missing - sync failed
file /mnt/scratch/520 missing - sync failed
file /mnt/scratch/521 missing - sync failed
file /mnt/scratch/522 missing - sync failed
file /mnt/scratch/523 missing - sync failed
file /mnt/scratch/524 missing - sync failed
file /mnt/scratch/525 missing - sync failed
file /mnt/scratch/526 missing - sync failed
file /mnt/scratch/527 missing - sync failed
file /mnt/scratch/528 missing - sync failed
file /mnt/scratch/529 missing - sync failed
file /mnt/scratch/530 missing - sync failed
file /mnt/scratch/531 missing - sync failed
file /mnt/scratch/532 missing - sync failed
file /mnt/scratch/533 missing - sync failed
file /mnt/scratch/534 missing - sync failed
file /mnt/scratch/535 missing - sync failed
file /mnt/scratch/536 missing - sync failed
file /mnt/scratch/537 missing - sync failed
file /mnt/scratch/538 missing - sync failed
file /mnt/scratch/539 missing - sync failed
file /mnt/scratch/540 missing - sync failed
file /mnt/scratch/541 missing - sync failed
file /mnt/scratch/542 missing - sync failed
file /mnt/scratch/543 missing - sync failed
file /mnt/scratch/544 missing - sync failed
file /mnt/scratch/545 missing - sync failed
file /mnt/scratch/546 missing - sync failed
file /mnt/scratch/547 missing - sync failed
file /mnt/scratch/548 missing - sync failed
file /mnt/scratch/549 missing - sync failed
file /mnt/scratch/550 missing - sync failed
file /mnt/scratch/551 missing - sync failed
file /mnt/scratch/552 missing - sync failed
file /mnt/scratch/553 missing - sync failed
file /mnt/scratch/554 missing - sync failed
file /mnt/scratch/555 missing - sync failed
file /mnt/scratch/556 missing - sync failed
file /mnt/scratch/557 missing - sync failed
file /mnt/scratch/558 missing - sync failed
file /mnt/scratch/559 missing - sync failed
file /mnt/scratch/560 missing - sync failed
file /mnt/scratch/561 missing - sync failed
file /mnt/scratch/562 missing - sync failed
file /mnt/scratch/563 missing - sync failed
file /mnt/scratch/564 missing - sync failed
file /mnt/scratch/565 missing - sync failed
file /mnt/scratch/566 missing - sync failed
file /mnt/scratch/567 missing - sync failed
file /mnt/scratch/568 missing - sync failed
file /mnt/scratch/569 missing - sync failed
file /mnt/scratch/570 missing - sync failed
file /mnt/scratch/571 missing - sync failed
file /mnt/scratch/572 missing - sync failed
file /mnt/scratch/573 missing - sync failed
file /mnt/scratch/574 missing - sync failed
file /mnt/scratch/575 missing - sync failed
file /mnt/scratch/576 missing - sync failed
file /mnt/scratch/577 missing - sync failed
file /mnt/scratch/578 missing - sync failed
file /mnt/scratch/579 missing - sync failed
file /mnt/scratch/580 missing - sync failed
file /mnt/scratch/581 missing - sync failed
file /mnt/scratch/582 missing - sync failed
file /mnt/scratch/583 missing - sync failed
file /mnt/scratch/584 missing - sync failed
file /mnt/scratch/585 missing - sync failed
file /mnt/scratch/586 missing - sync failed
file /mnt/scratch/587 missing - sync failed
file /mnt/scratch/588 missing - sync failed
file /mnt/scratch/589 missing - sync failed
file /mnt/scratch/590 missing - sync failed
file /mnt/scratch/591 missing - sync failed
file /mnt/scratch/592 missing - sync failed
file /mnt/scratch/593 missing - sync failed
file /mnt/scratch/594 missing - sync failed
file /mnt/scratch/595 missing - sync failed
file /mnt/scratch/596 missing - sync failed
file /mnt/scratch/597 missing - sync failed
file /mnt/scratch/598 missing - sync failed
file /mnt/scratch/599 missing - sync failed
file /mnt/scratch/600 missing - sync failed
file /mnt/scratch/601 missing - sync failed
file /mnt/scratch/602 missing - sync failed
file /mnt/scratch/603 missing - sync failed
file /mnt/scratch/604 missing - sync failed
file /mnt/scratch/605 missing - sync failed
file /mnt/scratch/606 missing - sync failed
file /mnt/scratch/607 missing - sync failed
file /mnt/scratch/608 missing - sync failed
file /mnt/scratch/609 missing - sync failed
file /mnt/scratch/610 missing - sync failed
file /mnt/scratch/611 missing - sync failed
file /mnt/scratch/612 missing - sync failed
file /mnt/scratch/613 missing - sync failed
file /mnt/scratch/614 missing - sync failed
file /mnt/scratch/615 missing - sync failed
file /mnt/scratch/616 missing - sync failed
file /mnt/scratch/617 missing - sync failed
file /mnt/scratch/618 missing - sync failed
file /mnt/scratch/619 missing - sync failed
file /mnt/scratch/620 missing - sync failed
file /mnt/scratch/621 missing - sync failed
file /mnt/scratch/622 missing - sync failed
file /mnt/scratch/623 missing - sync failed
file /mnt/scratch/624 missing - sync failed
file /mnt/scratch/625 missing - sync failed
file /mnt/scratch/626 missing - sync failed
file /mnt/scratch/627 missing - sync failed
file /mnt/scratch/628 missing - sync failed
file /mnt/scratch/629 missing - sync failed
file /mnt/scratch/630 missing - sync failed
file /mnt/scratch/631 missing - sync failed
file /mnt/scratch/632 missing - sync failed
file /mnt/scratch/633 missing - sync failed
file /mnt/scratch/634 missing - sync failed
file /mnt/scratch/635 missing - sync failed
file /mnt/scratch/636 missing - sync failed
file /mnt/scratch/637 missing - sync failed
file /mnt/scratch/638 missing - sync failed
file /mnt/scratch/639 missing - sync failed
file /mnt/scratch/640 missing - sync failed
file /mnt/scratch/641 missing - sync failed
file /mnt/scratch/642 missing - sync failed
file /mnt/scratch/643 missing - sync failed
file /mnt/scratch/644 missing - sync failed
file /mnt/scratch/645 missing - sync failed
file /mnt/scratch/646 missing - sync failed
file /mnt/scratch/647 missing - sync failed
file /mnt/scratch/648 missing - sync failed
file /mnt/scratch/649 missing - sync failed
file /mnt/scratch/650 missing - sync failed
file /mnt/scratch/651 missing - sync failed
file /mnt/scratch/652 missing - sync failed
file /mnt/scratch/653 missing - sync failed
file /mnt/scratch/654 missing - sync failed
file /mnt/scratch/655 missing - sync failed
file /mnt/scratch/656 missing - sync failed
file /mnt/scratch/657 missing - sync failed
file /mnt/scratch/658 missing - sync failed
file /mnt/scratch/659 missing - sync failed
file /mnt/scratch/660 missing - sync failed
file /mnt/scratch/661 missing - sync failed
file /mnt/scratch/662 missing - sync failed
file /mnt/scratch/663 missing - sync failed
file /mnt/scratch/664 missing - sync failed
file /mnt/scratch/665 missing - sync failed
file /mnt/scratch/666 missing - sync failed
file /mnt/scratch/667 missing - sync failed
file /mnt/scratch/668 missing - sync failed
file /mnt/scratch/669 missing - sync failed
file /mnt/scratch/670 missing - sync failed
file /mnt/scratch/671 missing - sync failed
file /mnt/scratch/672 missing - sync failed
file /mnt/scratch/673 missing - sync failed
file /mnt/scratch/674 missing - sync failed
file /mnt/scratch/675 missing - sync failed
file /mnt/scratch/676 missing - sync failed
file /mnt/scratch/677 missing - sync failed
file /mnt/scratch/678 missing - sync failed
file /mnt/scratch/679 missing - sync failed
file /mnt/scratch/680 missing - sync failed
file /mnt/scratch/681 missing - sync failed
file /mnt/scratch/682 missing - sync failed
file /mnt/scratch/683 missing - sync failed
file /mnt/scratch/684 missing - sync failed
file /mnt/scratch/685 missing - sync failed
file /mnt/scratch/686 missing - sync failed
file /mnt/scratch/687 missing - sync failed
file /mnt/scratch/688 missing - sync failed
file /mnt/scratch/689 missing - sync failed
file /mnt/scratch/690 missing - sync failed
file /mnt/scratch/691 missing - sync failed
file /mnt/scratch/692 missing - sync failed
file /mnt/scratch/693 missing - sync failed
file /mnt/scratch/694 missing - sync failed
file /mnt/scratch/695 missing - sync failed
file /mnt/scratch/696 missing - sync failed
file /mnt/scratch/697 missing - sync failed
file /mnt/scratch/698 missing - sync failed
file /mnt/scratch/699 missing - sync failed
file /mnt/scratch/700 missing - sync failed
file /mnt/scratch/701 missing - sync failed
file /mnt/scratch/702 missing - sync failed
file /mnt/scratch/703 missing - sync failed
file /mnt/scratch/704 missing - sync failed
file /mnt/scratch/705 missing - sync failed
file /mnt/scratch/706 missing - sync failed
file /mnt/scratch/707 missing - sync failed
file /mnt/scratch/708 missing - sync failed
file /mnt/scratch/709 missing - sync failed
file /mnt/scratch/710 missing - sync failed
file /mnt/scratch/711 missing - sync failed
file /mnt/scratch/712 missing - sync failed
file /mnt/scratch/713 missing - sync failed
file /mnt/scratch/714 missing - sync failed
file /mnt/scratch/715 missing - sync failed
file /mnt/scratch/716 missing - sync failed
file /mnt/scratch/717 missing - sync failed
file /mnt/scratch/718 missing - sync failed
file /mnt/scratch/719 missing - sync failed
file /mnt/scratch/720 missing - sync failed
file /mnt/scratch/721 missing - sync failed
file /mnt/scratch/722 missing - sync failed
file /mnt/scratch/723 missing - sync failed
file /mnt/scratch/724 missing - sync failed
file /mnt/scratch/725 missing - sync failed
file /mnt/scratch/726 missing - sync failed
file /mnt/scratch/727 missing - sync failed
file /mnt/scratch/728 missing - sync failed
file /mnt/scratch/729 missing - sync failed
file /mnt/scratch/730 missing - sync failed
file /mnt/scratch/731 missing - sync failed
file /mnt/scratch/732 missing - sync failed
file /mnt/scratch/733 missing - sync failed
file /mnt/scratch/734 missing - sync failed
file /mnt/scratch/735 missing - sync failed
file /mnt/scratch/736 missing - sync failed
file /mnt/scratch/737 missing - sync failed
file /mnt/scratch/738 missing - sync failed
file /mnt/scratch/739 missing - sync failed
file /mnt/scratch/740 missing - sync failed
file /mnt/scratch/741 missing - sync failed
file /mnt/scratch/742 missing - sync failed
file /mnt/scratch/743 missing - sync failed
file /mnt/scratch/744 missing - sync failed
file /mnt/scratch/745 missing - sync failed
file /mnt/scratch/746 missing - sync failed
file /mnt/scratch/747 missing - sync failed
file /mnt/scratch/748 missing - sync failed
file /mnt/scratch/749 missing - sync failed
file /mnt/scratch/750 missing - sync failed
file /mnt/scratch/751 missing - sync failed
file /mnt/scratch/752 missing - sync failed
file /mnt/scratch/753 missing - sync failed
file /mnt/scratch/754 missing - sync failed
file /mnt/scratch/755 missing - sync failed
file /mnt/scratch/756 missing - sync failed
file /mnt/scratch/757 missing - sync failed
file /mnt/scratch/758 missing - sync failed
file /mnt/scratch/759 missing - sync failed
file /mnt/scratch/760 missing - sync failed
file /mnt/scratch/761 missing - sync failed
file /mnt/scratch/762 missing - sync failed
file /mnt/scratch/763 missing - sync failed
file /mnt/scratch/764 missing - sync failed
file /mnt/scratch/765 missing - sync failed
file /mnt/scratch/766 missing - sync failed
file /mnt/scratch/767 missing - sync failed
file /mnt/scratch/768 missing - sync failed
file /mnt/scratch/769 missing - sync failed
file /mnt/scratch/770 missing - sync failed
file /mnt/scratch/771 missing - sync failed
file /mnt/scratch/772 missing - sync failed
file /mnt/scratch/773 missing - sync failed
file /mnt/scratch/774 missing - sync failed
file /mnt/scratch/775 missing - sync failed
file /mnt/scratch/776 missing - sync failed
file /mnt/scratch/777 missing - sync failed
file /mnt/scratch/778 missing - sync failed
file /mnt/scratch/779 missing - sync failed
file /mnt/scratch/780 missing - sync failed
file /mnt/scratch/781 missing - sync failed
file /mnt/scratch/782 missing - sync failed
file /mnt/scratch/783 missing - sync failed
file /mnt/scratch/784 missing - sync failed
file /mnt/scratch/785 missing - sync failed
file /mnt/scratch/786 missing - sync failed
file /mnt/scratch/787 missing - sync failed
file /mnt/scratch/788 missing - sync failed
file /mnt/scratch/789 missing - sync failed
file /mnt/scratch/790 missing - sync failed
file /mnt/scratch/791 missing - sync failed
file /mnt/scratch/792 missing - sync failed
file /mnt/scratch/793 missing - sync failed
file /mnt/scratch/794 missing - sync failed
file /mnt/scratch/795 missing - sync failed
file /mnt/scratch/796 missing - sync failed
file /mnt/scratch/797 missing - sync failed
file /mnt/scratch/798 missing - sync failed
file /mnt/scratch/799 missing - sync failed
file /mnt/scratch/800 missing - sync failed
file /mnt/scratch/801 missing - sync failed
file /mnt/scratch/802 missing - sync failed
file /mnt/scratch/803 missing - sync failed
file /mnt/scratch/804 missing - sync failed
file /mnt/scratch/805 missing - sync failed
file /mnt/scratch/806 missing - sync failed
file /mnt/scratch/807 missing - sync failed
file /mnt/scratch/808 missing - sync failed
file /mnt/scratch/809 missing - sync failed
file /mnt/scratch/810 missing - sync failed
file /mnt/scratch/811 missing - sync failed
file /mnt/scratch/812 missing - sync failed
file /mnt/scratch/813 missing - sync failed
file /mnt/scratch/814 missing - sync failed
file /mnt/scratch/815 missing - sync failed
file /mnt/scratch/816 missing - sync failed
file /mnt/scratch/817 missing - sync failed
file /mnt/scratch/818 missing - sync failed
file /mnt/scratch/819 missing - sync failed
file /mnt/scratch/820 missing - sync failed
file /mnt/scratch/821 missing - sync failed
file /mnt/scratch/822 missing - sync failed
file /mnt/scratch/823 missing - sync failed
file /mnt/scratch/824 missing - sync failed
file /mnt/scratch/825 missing - sync failed
file /mnt/scratch/826 missing - sync failed
file /mnt/scratch/827 missing - sync failed
file /mnt/scratch/828 missing - sync failed
file /mnt/scratch/829 missing - sync failed
file /mnt/scratch/830 missing - sync failed
file /mnt/scratch/831 missing - sync failed
file /mnt/scratch/832 missing - sync failed
file /mnt/scratch/833 missing - sync failed
file /mnt/scratch/834 missing - sync failed
file /mnt/scratch/835 missing - sync failed
file /mnt/scratch/836 missing - sync failed
file /mnt/scratch/837 missing - sync failed
file /mnt/scratch/838 missing - sync failed
file /mnt/scratch/839 missing - sync failed
file /mnt/scratch/840 missing - sync failed
file /mnt/scratch/841 missing - sync failed
file /mnt/scratch/842 missing - sync failed
file /mnt/scratch/843 missing - sync failed
file /mnt/scratch/844 missing - sync failed
file /mnt/scratch/845 missing - sync failed
file /mnt/scratch/846 missing - sync failed
file /mnt/scratch/847 missing - sync failed
file /mnt/scratch/848 missing - sync failed
file /mnt/scratch/849 missing - sync failed
file /mnt/scratch/850 missing - sync failed
file /mnt/scratch/851 missing - sync failed
file /mnt/scratch/852 missing - sync failed
file /mnt/scratch/853 missing - sync failed
file /mnt/scratch/854 missing - sync failed
file /mnt/scratch/855 missing - sync failed
file /mnt/scratch/856 missing - sync failed
file /mnt/scratch/857 missing - sync failed
file /mnt/scratch/858 missing - sync failed
file /mnt/scratch/859 missing - sync failed
file /mnt/scratch/860 missing - sync failed
file /mnt/scratch/861 missing - sync failed
file /mnt/scratch/862 missing - sync failed
file /mnt/scratch/863 missing - sync failed
file /mnt/scratch/864 missing - sync failed
file /mnt/scratch/865 missing - sync failed
file /mnt/scratch/866 missing - sync failed
file /mnt/scratch/867 missing - sync failed
file /mnt/scratch/868 missing - sync failed
file /mnt/scratch/869 missing - sync failed
file /mnt/scratch/870 missing - sync failed
file /mnt/scratch/871 missing - sync failed
file /mnt/scratch/872 missing - sync failed
file /mnt/scratch/873 missing - sync failed
file /mnt/scratch/874 missing - sync failed
file /mnt/scratch/875 missing - sync failed
file /mnt/scratch/876 missing - sync failed
file /mnt/scratch/877 missing - sync failed
file /mnt/scratch/878 missing - sync failed
file /mnt/scratch/879 missing - sync failed
file /mnt/scratch/880 missing - sync failed
file /mnt/scratch/881 missing - sync failed
file /mnt/scratch/882 missing - sync failed
file /mnt/scratch/883 missing - sync failed
file /mnt/scratch/884 missing - sync failed
file /mnt/scratch/885 missing - sync failed
file /mnt/scratch/886 missing - sync failed
file /mnt/scratch/887 missing - sync failed
file /mnt/scratch/888 missing - sync failed
file /mnt/scratch/889 missing - sync failed
file /mnt/scratch/890 missing - sync failed
file /mnt/scratch/891 missing - sync failed
file /mnt/scratch/892 missing - sync failed
file /mnt/scratch/893 missing - sync failed
file /mnt/scratch/894 missing - sync failed
file /mnt/scratch/895 missing - sync failed
file /mnt/scratch/896 missing - sync failed
file /mnt/scratch/897 missing - sync failed
file /mnt/scratch/898 missing - sync failed
file /mnt/scratch/899 missing - sync failed
file /mnt/scratch/900 missing - sync failed
file /mnt/scratch/901 missing - sync failed
file /mnt/scratch/902 missing - sync failed
file /mnt/scratch/903 missing - sync failed
file /mnt/scratch/904 missing - sync failed
file /mnt/scratch/905 missing - sync failed
file /mnt/scratch/906 missing - sync failed
file /mnt/scratch/907 missing - sync failed
file /mnt/scratch/908 missing - sync failed
file /mnt/scratch/909 missing - sync failed
file /mnt/scratch/910 missing - sync failed
file /mnt/scratch/911 missing - sync failed
file /mnt/scratch/912 missing - sync failed
file /mnt/scratch/913 missing - sync failed
file /mnt/scratch/914 missing - sync failed
file /mnt/scratch/915 missing - sync failed
file /mnt/scratch/916 missing - sync failed
file /mnt/scratch/917 missing - sync failed
file /mnt/scratch/918 missing - sync failed
file /mnt/scratch/919 missing - sync failed
file /mnt/scratch/920 missing - sync failed
file /mnt/scratch/921 missing - sync failed
file /mnt/scratch/922 missing - sync failed
file /mnt/scratch/923 missing - sync failed
file /mnt/scratch/924 missing - sync failed
file /mnt/scratch/925 missing - sync failed
file /mnt/scratch/926 missing - sync failed
file /mnt/scratch/927 missing - sync failed
file /mnt/scratch/928 missing - sync failed
file /mnt/scratch/929 missing - sync failed
file /mnt/scratch/930 missing - sync failed
file /mnt/scratch/931 missing - sync failed
file /mnt/scratch/932 missing - sync failed
file /mnt/scratch/933 missing - sync failed
file /mnt/scratch/934 missing - sync failed
file /mnt/scratch/935 missing - sync failed
file /mnt/scratch/936 missing - sync failed
file /mnt/scratch/937 missing - sync failed
file /mnt/scratch/938 missing - sync failed
file /mnt/scratch/939 missing - sync failed
file /mnt/scratch/940 missing - sync failed
file /mnt/scratch/941 missing - sync failed
file /mnt/scratch/942 missing - sync failed
file /mnt/scratch/943 missing - sync failed
file /mnt/scratch/944 missing - sync failed
file /mnt/scratch/945 missing - sync failed
file /mnt/scratch/946 missing - sync failed
file /mnt/scratch/947 missing - sync failed
file /mnt/scratch/948 missing - sync failed
file /mnt/scratch/949 missing - sync failed
file /mnt/scratch/950 missing - sync failed
file /mnt/scratch/951 missing - sync failed
file /mnt/scratch/952 missing - sync failed
file /mnt/scratch/953 missing - sync failed
file /mnt/scratch/954 missing - sync failed
file /mnt/scratch/955 missing - sync failed
file /mnt/scratch/956 missing - sync failed
file /mnt/scratch/957 missing - sync failed
file /mnt/scratch/958 missing - sync failed
file /mnt/scratch/959 missing - sync failed
file /mnt/scratch/960 missing - sync failed
file /mnt/scratch/961 missing - sync failed
file /mnt/scratch/962 missing - sync failed
file /mnt/scratch/963 missing - sync failed
file /mnt/scratch/964 missing - sync failed
file /mnt/scratch/965 missing - sync failed
file /mnt/scratch/966 missing - sync failed
file /mnt/scratch/967 missing - sync failed
file /mnt/scratch/968 missing - sync failed
file /mnt/scratch/969 missing - sync failed
file /mnt/scratch/970 missing - sync failed
file /mnt/scratch/971 missing - sync failed
file /mnt/scratch/972 missing - sync failed
file /mnt/scratch/973 missing - sync failed
file /mnt/scratch/974 missing - sync failed
file /mnt/scratch/975 missing - sync failed
file /mnt/scratch/976 missing - sync failed
file /mnt/scratch/977 missing - sync failed
file /mnt/scratch/978 missing - sync failed
file /mnt/scratch/979 missing - sync failed
file /mnt/scratch/980 missing - sync failed
file /mnt/scratch/981 missing - sync failed
file /mnt/scratch/982 missing - sync failed
file /mnt/scratch/983 missing - sync failed
file /mnt/scratch/984 missing - sync failed
file /mnt/scratch/985 missing - sync failed
file /mnt/scratch/986 missing - sync failed
file /mnt/scratch/987 missing - sync failed
file /mnt/scratch/988 missing - sync failed
file /mnt/scratch/989 missing - sync failed
file /mnt/scratch/990 missing - sync failed
file /mnt/scratch/991 missing - sync failed
file /mnt/scratch/992 missing - sync failed
file /mnt/scratch/993 missing - sync failed
file /mnt/scratch/994 missing - sync failed
file /mnt/scratch/995 missing - sync failed
file /mnt/scratch/996 missing - sync failed
file /mnt/scratch/997 missing - sync failed
file /mnt/scratch/998 missing - sync failed
file /mnt/scratch/999 missing - sync failed

[-- Attachment #8: 200.out.bad --]
[-- Type: text/plain, Size: 978 bytes --]

QA output created by 200
setting device read-only
mounting read-only block device:
mount: block device SCRATCH_DEV is write-protected, mounting read-only
touching file on read-only filesystem (should fail)
touch: cannot touch `SCRATCH_MNT/foo': Read-only file system
unmounting read-only filesystem
setting device read-write
mounting read-write block device:
touch files
going down:
unmounting shutdown filesystem:
setting device read-only
mounting filesystem that needs recovery on a read-only device:
mount: block device SCRATCH_DEV is write-protected, mounting read-only
mount: cannot mount block device SCRATCH_DEV read-only
unmounting read-only filesystem
umount: SCRATCH_MNT: not mounted
mounting filesystem with -o norecovery on a read-only device:
mount: block device SCRATCH_DEV is write-protected, mounting read-only
unmounting read-only filesystem
setting device read-write
mounting filesystem that needs recovery with -o ro:
mount: Structure needs cleaning
*** done

[-- Attachment #9: Type: text/plain, Size: 121 bytes --]

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs