xfs: cleanup xlog_bread

Most callers of xlog_bread need to call xlog_align to get the actual offset. Consolidate that call into the main xlog_bread and provide a _xlog_bread for those few that don't want the actual offset. Signed-off-by: Christoph Hellwig <hch@lst.de> Reviewed-by: Dave Chinner <david@fromorbit.com>
author: Christoph Hellwig <hch@lst.de> 2009-03-16 03:24:13 -0400
committer: Christoph Hellwig <hch@brick.lst.de> 2009-03-16 03:24:13 -0400
commit: 076e6acb8f0d9532ee6c50512c1927c0a8e34f2f (patch)
tree: ba841b159780ad10e69c1a42ff0832f908cdd5f3
parent: ff0205e032b9733bb634ad5dadc79a0f6d30c721 (diff)
2 files changed, 138 insertions, 88 deletions
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 3670d48fd774..bcad5f4c1fd1 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -455,7 +455,6 @@ extern void	 xlog_recover_process_iunlinks(xlog_t *log);
 extern struct xfs_buf *xlog_get_bp(xlog_t *, int);
 extern void      xlog_put_bp(struct xfs_buf *);
-extern int       xlog_bread(xlog_t *, xfs_daddr_t, int, struct xfs_buf *);
 extern kmem_zone_t      *xfs_log_ticket_zone;
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 73584444c194..7ba450116d4f 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -94,12 +94,30 @@ xlog_put_bp(
        xfs_buf_free(bp);
 }
+STATIC xfs_caddr_t
+xlog_align(
+        xlog_t          *log,
+        xfs_daddr_t     blk_no,
+        int             nbblks,
+        xfs_buf_t       *bp)
+{
+        xfs_caddr_t     ptr;
+        if (!log->l_sectbb_log)
+                return XFS_BUF_PTR(bp);
+        ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
+        ASSERT(XFS_BUF_SIZE(bp) >=
+                BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
+        return ptr;
+}
 /*
 * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
 */
-int
+STATIC int
-xlog_bread(
+xlog_bread_noalign(
        xlog_t          *log,
        xfs_daddr_t     blk_no,
        int             nbblks,
@@ -137,6 +155,24 @@ xlog_bread(
        return error;
 }
+STATIC int
+xlog_bread(
+        xlog_t          *log,
+        xfs_daddr_t     blk_no,
+        int             nbblks,
+        xfs_buf_t       *bp,
+        xfs_caddr_t     *offset)
+{
+        int             error;
+        error = xlog_bread_noalign(log, blk_no, nbblks, bp);
+        if (error)
+                return error;
+        *offset = xlog_align(log, blk_no, nbblks, bp);
+        return 0;
+}
 /*
 * Write out the buffer at the given block for the given number of blocks.
 * The buffer is kept locked across the write and is returned locked.
@@ -180,24 +216,6 @@ xlog_bwrite(
        return error;
 }
-STATIC xfs_caddr_t
-xlog_align(
-        xlog_t          *log,
-        xfs_daddr_t     blk_no,
-        int             nbblks,
-        xfs_buf_t       *bp)
-{
-        xfs_caddr_t     ptr;
-        if (!log->l_sectbb_log)
-                return XFS_BUF_PTR(bp);
-        ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
-        ASSERT(XFS_BUF_SIZE(bp) >=
-                BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
-        return ptr;
-}
 #ifdef DEBUG
 /*
 * dump debug superblock and log record information
@@ -321,9 +339,9 @@ xlog_find_cycle_start(
        mid_blk = BLK_AVG(first_blk, *last_blk);
        while (mid_blk != first_blk && mid_blk != *last_blk) {
-                if ((error = xlog_bread(log, mid_blk, 1, bp)))
+                error = xlog_bread(log, mid_blk, 1, bp, &offset);
+                if (error)
                        return error;
-                offset = xlog_align(log, mid_blk, 1, bp);
                mid_cycle = xlog_get_cycle(offset);
                if (mid_cycle == cycle) {
                        *last_blk = mid_blk;
@@ -379,10 +397,10 @@ xlog_find_verify_cycle(
                bcount = min(bufblks, (start_blk + nbblks - i));
-                if ((error = xlog_bread(log, i, bcount, bp)))
+                error = xlog_bread(log, i, bcount, bp, &buf);
+                if (error)
                        goto out;
-                buf = xlog_align(log, i, bcount, bp);
                for (j = 0; j < bcount; j++) {
                        cycle = xlog_get_cycle(buf);
                        if (cycle == stop_on_cycle_no) {
@@ -436,9 +454,9 @@ xlog_find_verify_log_record(
                        return ENOMEM;
                smallmem = 1;
        } else {
-                if ((error = xlog_bread(log, start_blk, num_blks, bp)))
+                error = xlog_bread(log, start_blk, num_blks, bp, &offset);
+                if (error)
                        goto out;
-                offset = xlog_align(log, start_blk, num_blks, bp);
                offset += ((num_blks - 1) << BBSHIFT);
        }
@@ -453,9 +471,9 @@ xlog_find_verify_log_record(
                }
                if (smallmem) {
-                        if ((error = xlog_bread(log, i, 1, bp)))
+                        error = xlog_bread(log, i, 1, bp, &offset);
+                        if (error)
                                goto out;
-                        offset = xlog_align(log, i, 1, bp);
                }
                head = (xlog_rec_header_t *)offset;
@@ -559,15 +577,18 @@ xlog_find_head(
        bp = xlog_get_bp(log, 1);
        if (!bp)
                return ENOMEM;
-        if ((error = xlog_bread(log, 0, 1, bp)))
+        error = xlog_bread(log, 0, 1, bp, &offset);
+        if (error)
                goto bp_err;
-        offset = xlog_align(log, 0, 1, bp);
        first_half_cycle = xlog_get_cycle(offset);
        last_blk = head_blk = log_bbnum - 1;    /* get cycle # of last block */
-        if ((error = xlog_bread(log, last_blk, 1, bp)))
+        error = xlog_bread(log, last_blk, 1, bp, &offset);
+        if (error)
                goto bp_err;
-        offset = xlog_align(log, last_blk, 1, bp);
        last_half_cycle = xlog_get_cycle(offset);
        ASSERT(last_half_cycle != 0);
@@ -817,9 +838,10 @@ xlog_find_tail(
        if (!bp)
                return ENOMEM;
        if (*head_blk == 0) {                           /* special case */
-                if ((error = xlog_bread(log, 0, 1, bp)))
+                error = xlog_bread(log, 0, 1, bp, &offset);
+                if (error)
                        goto bread_err;
-                offset = xlog_align(log, 0, 1, bp);
                if (xlog_get_cycle(offset) == 0) {
                        *tail_blk = 0;
                        /* leave all other log inited values alone */
@@ -832,9 +854,10 @@ xlog_find_tail(
         */
        ASSERT(*head_blk < INT_MAX);
        for (i = (int)(*head_blk) - 1; i >= 0; i--) {
-                if ((error = xlog_bread(log, i, 1, bp)))
+                error = xlog_bread(log, i, 1, bp, &offset);
+                if (error)
                        goto bread_err;
-                offset = xlog_align(log, i, 1, bp);
                if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(*(__be32 *)offset)) {
                        found = 1;
                        break;
@@ -848,9 +871,10 @@ xlog_find_tail(
         */
        if (!found) {
                for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
-                        if ((error = xlog_bread(log, i, 1, bp)))
+                        error = xlog_bread(log, i, 1, bp, &offset);
+                        if (error)
                                goto bread_err;
-                        offset = xlog_align(log, i, 1, bp);
                        if (XLOG_HEADER_MAGIC_NUM ==
                            be32_to_cpu(*(__be32 *)offset)) {
                                found = 2;
@@ -922,10 +946,10 @@ xlog_find_tail(
        if (*head_blk == after_umount_blk &&
            be32_to_cpu(rhead->h_num_logops) == 1) {
                umount_data_blk = (i + hblks) % log->l_logBBsize;
-                if ((error = xlog_bread(log, umount_data_blk, 1, bp))) {
+                error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
+                if (error)
                        goto bread_err;
-                }
-                offset = xlog_align(log, umount_data_blk, 1, bp);
                op_head = (xlog_op_header_t *)offset;
                if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
                        /*
@@ -1017,9 +1041,10 @@ xlog_find_zeroed(
        bp = xlog_get_bp(log, 1);
        if (!bp)
                return ENOMEM;
-        if ((error = xlog_bread(log, 0, 1, bp)))
+        error = xlog_bread(log, 0, 1, bp, &offset);
+        if (error)
                goto bp_err;
-        offset = xlog_align(log, 0, 1, bp);
        first_cycle = xlog_get_cycle(offset);
        if (first_cycle == 0) {         /* completely zeroed log */
                *blk_no = 0;
@@ -1028,9 +1053,10 @@ xlog_find_zeroed(
        }
        /* check partially zeroed log */
-        if ((error = xlog_bread(log, log_bbnum-1, 1, bp)))
+        error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
+        if (error)
                goto bp_err;
-        offset = xlog_align(log, log_bbnum-1, 1, bp);
        last_cycle = xlog_get_cycle(offset);
        if (last_cycle != 0) {          /* log completely written to */
                xlog_put_bp(bp);
@@ -1152,10 +1178,10 @@ xlog_write_log_records(
         */
        balign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, start_block);
        if (balign != start_block) {
-                if ((error = xlog_bread(log, start_block, 1, bp))) {
+                error = xlog_bread_noalign(log, start_block, 1, bp);
-                        xlog_put_bp(bp);
+                if (error)
-                        return error;
+                        goto out_put_bp;
-                }
                j = start_block - balign;
        }
@@ -1175,10 +1201,14 @@ xlog_write_log_records(
                        balign = BBTOB(ealign - start_block);
                        error = XFS_BUF_SET_PTR(bp, offset + balign,
                                                BBTOB(sectbb));
-                        if (!error)
+                        if (error)
-                                error = xlog_bread(log, ealign, sectbb, bp);
+                                break;
-                        if (!error)
-                                error = XFS_BUF_SET_PTR(bp, offset, bufblks);
+                        error = xlog_bread_noalign(log, ealign, sectbb, bp);
+                        if (error)
+                                break;
+                        error = XFS_BUF_SET_PTR(bp, offset, bufblks);
                        if (error)
                                break;
                }
@@ -1195,6 +1225,8 @@ xlog_write_log_records(
                start_block += endcount;
                j = 0;
        }
+ out_put_bp:
        xlog_put_bp(bp);
        return error;
 }
@@ -3481,9 +3513,11 @@ xlog_do_recovery_pass(
                hbp = xlog_get_bp(log, 1);
                if (!hbp)
                        return ENOMEM;
-                if ((error = xlog_bread(log, tail_blk, 1, hbp)))
+                error = xlog_bread(log, tail_blk, 1, hbp, &offset);
+                if (error)
                        goto bread_err1;
-                offset = xlog_align(log, tail_blk, 1, hbp);
                rhead = (xlog_rec_header_t *)offset;
                error = xlog_valid_rec_header(log, rhead, tail_blk);
                if (error)
@@ -3517,9 +3551,10 @@ xlog_do_recovery_pass(
        memset(rhash, 0, sizeof(rhash));
        if (tail_blk <= head_blk) {
                for (blk_no = tail_blk; blk_no < head_blk; ) {
-                        if ((error = xlog_bread(log, blk_no, hblks, hbp)))
+                        error = xlog_bread(log, blk_no, hblks, hbp, &offset);
+                        if (error)
                                goto bread_err2;
-                        offset = xlog_align(log, blk_no, hblks, hbp);
                        rhead = (xlog_rec_header_t *)offset;
                        error = xlog_valid_rec_header(log, rhead, blk_no);
                        if (error)
@@ -3527,10 +3562,11 @@ xlog_do_recovery_pass(
                        /* blocks in data section */
                        bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
-                        error = xlog_bread(log, blk_no + hblks, bblks, dbp);
+                        error = xlog_bread(log, blk_no + hblks, bblks, dbp,
+                                           &offset);
                        if (error)
                                goto bread_err2;
-                        offset = xlog_align(log, blk_no + hblks, bblks, dbp);
                        xlog_unpack_data(rhead, offset, log);
                        if ((error = xlog_recover_process_data(log,
                                                rhash, rhead, offset, pass)))
@@ -3553,10 +3589,10 @@ xlog_do_recovery_pass(
                        wrapped_hblks = 0;
                        if (blk_no + hblks <= log->l_logBBsize) {
                                /* Read header in one read */
-                                error = xlog_bread(log, blk_no, hblks, hbp);
+                                error = xlog_bread(log, blk_no, hblks, hbp,
+                                                   &offset);
                                if (error)
                                        goto bread_err2;
-                                offset = xlog_align(log, blk_no, hblks, hbp);
                        } else {
                                /* This LR is split across physical log end */
                                if (blk_no != log->l_logBBsize) {
@@ -3564,12 +3600,13 @@ xlog_do_recovery_pass(
                                        ASSERT(blk_no <= INT_MAX);
                                        split_hblks = log->l_logBBsize - (int)blk_no;
                                        ASSERT(split_hblks > 0);
-                                        if ((error = xlog_bread(log, blk_no,
+                                        error = xlog_bread(log, blk_no,
-                                                        split_hblks, hbp)))
+                                                           split_hblks, hbp,
+                                                           &offset);
+                                        if (error)
                                                goto bread_err2;
-                                        offset = xlog_align(log, blk_no,
-                                                        split_hblks, hbp);
                                }
                                /*
                                 * Note: this black magic still works with
                                 * large sector sizes (non-512) only because:
@@ -3587,14 +3624,19 @@ xlog_do_recovery_pass(
                                error = XFS_BUF_SET_PTR(hbp,
                                                bufaddr + BBTOB(split_hblks),
                                                BBTOB(hblks - split_hblks));
-                                if (!error)
+                                if (error)
-                                        error = xlog_bread(log, 0,
+                                        goto bread_err2;
-                                                        wrapped_hblks, hbp);
-                                if (!error)
+                                error = xlog_bread_noalign(log, 0,
-                                        error = XFS_BUF_SET_PTR(hbp, bufaddr,
+                                                           wrapped_hblks, hbp);
+                                if (error)
+                                        goto bread_err2;
+                                error = XFS_BUF_SET_PTR(hbp, bufaddr,
                                                        BBTOB(hblks));
                                if (error)
                                        goto bread_err2;
                                if (!offset)
                                        offset = xlog_align(log, 0,
                                                        wrapped_hblks, hbp);
@@ -3610,10 +3652,10 @@ xlog_do_recovery_pass(
                        /* Read in data for log record */
                        if (blk_no + bblks <= log->l_logBBsize) {
-                                error = xlog_bread(log, blk_no, bblks, dbp);
+                                error = xlog_bread(log, blk_no, bblks, dbp,
+                                                   &offset);
                                if (error)
                                        goto bread_err2;
-                                offset = xlog_align(log, blk_no, bblks, dbp);
                        } else {
                                /* This log record is split across the
                                 * physical end of log */
@@ -3627,12 +3669,13 @@ xlog_do_recovery_pass(
                                        split_bblks =
                                                log->l_logBBsize - (int)blk_no;
                                        ASSERT(split_bblks > 0);
-                                        if ((error = xlog_bread(log, blk_no,
+                                        error = xlog_bread(log, blk_no,
-                                                        split_bblks, dbp)))
+                                                        split_bblks, dbp,
+                                                        &offset);
+                                        if (error)
                                                goto bread_err2;
-                                        offset = xlog_align(log, blk_no,
-                                                        split_bblks, dbp);
                                }
                                /*
                                 * Note: this black magic still works with
                                 * large sector sizes (non-512) only because:
@@ -3649,15 +3692,19 @@ xlog_do_recovery_pass(
                                error = XFS_BUF_SET_PTR(dbp,
                                                bufaddr + BBTOB(split_bblks),
                                                BBTOB(bblks - split_bblks));
-                                if (!error)
-                                        error = xlog_bread(log, wrapped_hblks,
-                                                        bblks - split_bblks,
-                                                        dbp);
-                                if (!error)
-                                        error = XFS_BUF_SET_PTR(dbp, bufaddr,
-                                                        h_size);
                                if (error)
                                        goto bread_err2;
+                                error = xlog_bread_noalign(log, wrapped_hblks,
+                                                bblks - split_bblks,
+                                                dbp);
+                                if (error)
+                                        goto bread_err2;
+                                error = XFS_BUF_SET_PTR(dbp, bufaddr, h_size);
+                                if (error)
+                                        goto bread_err2;
                                if (!offset)
                                        offset = xlog_align(log, wrapped_hblks,
                                                bblks - split_bblks, dbp);
@@ -3674,17 +3721,21 @@ xlog_do_recovery_pass(
                /* read first part of physical log */
                while (blk_no < head_blk) {
-                        if ((error = xlog_bread(log, blk_no, hblks, hbp)))
+                        error = xlog_bread(log, blk_no, hblks, hbp, &offset);
+                        if (error)
                                goto bread_err2;
-                        offset = xlog_align(log, blk_no, hblks, hbp);
                        rhead = (xlog_rec_header_t *)offset;
                        error = xlog_valid_rec_header(log, rhead, blk_no);
                        if (error)
                                goto bread_err2;
                        bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
-                        if ((error = xlog_bread(log, blk_no+hblks, bblks, dbp)))
+                        error = xlog_bread(log, blk_no+hblks, bblks, dbp,
+                                           &offset);
+                        if (error)
                                goto bread_err2;
-                        offset = xlog_align(log, blk_no+hblks, bblks, dbp);
                        xlog_unpack_data(rhead, offset, log);
                        if ((error = xlog_recover_process_data(log, rhash,
                                                        rhead, offset, pass)))
author	Christoph Hellwig <hch@lst.de>	2009-03-16 03:24:13 -0400
committer	Christoph Hellwig <hch@brick.lst.de>	2009-03-16 03:24:13 -0400
commit	076e6acb8f0d9532ee6c50512c1927c0a8e34f2f (patch)
tree	ba841b159780ad10e69c1a42ff0832f908cdd5f3
parent	ff0205e032b9733bb634ad5dadc79a0f6d30c721 (diff)

diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h index 3670d48fd774..bcad5f4c1fd1 100644 --- a/fs/xfs/xfs_log_priv.h +++ b/fs/xfs/xfs_log_priv.h
@@ -455,7 +455,6 @@ extern void xlog_recover_process_iunlinks(xlog_t *log);
455		455
456	extern struct xfs_buf xlog_get_bp(xlog_t , int);	456	extern struct xfs_buf xlog_get_bp(xlog_t , int);
457	extern void xlog_put_bp(struct xfs_buf *);	457	extern void xlog_put_bp(struct xfs_buf *);
458	extern int xlog_bread(xlog_t , xfs_daddr_t, int, struct xfs_buf );
459		458
460	extern kmem_zone_t *xfs_log_ticket_zone;	459	extern kmem_zone_t *xfs_log_ticket_zone;
461		460


diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c index 73584444c194..7ba450116d4f 100644 --- a/fs/xfs/xfs_log_recover.c +++ b/fs/xfs/xfs_log_recover.c
@@ -94,12 +94,30 @@ xlog_put_bp(
94	xfs_buf_free(bp);	94	xfs_buf_free(bp);
95	}	95	}
96		96
		97	STATIC xfs_caddr_t
		98	xlog_align(
		99	xlog_t *log,
		100	xfs_daddr_t blk_no,
		101	int nbblks,
		102	xfs_buf_t *bp)
		103	{
		104	xfs_caddr_t ptr;
		105
		106	if (!log->l_sectbb_log)
		107	return XFS_BUF_PTR(bp);
		108
		109	ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
		110	ASSERT(XFS_BUF_SIZE(bp) >=
		111	BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
		112	return ptr;
		113	}
		114
97		115
98	/*	116	/*
99	* nbblks should be uint, but oh well. Just want to catch that 32-bit length.	117	* nbblks should be uint, but oh well. Just want to catch that 32-bit length.
100	*/	118	*/
101	int	119	STATIC int
102	xlog_bread(	120	xlog_bread_noalign(
103	xlog_t *log,	121	xlog_t *log,
104	xfs_daddr_t blk_no,	122	xfs_daddr_t blk_no,
105	int nbblks,	123	int nbblks,
@@ -137,6 +155,24 @@ xlog_bread(
137	return error;	155	return error;
138	}	156	}
139		157
		158	STATIC int
		159	xlog_bread(
		160	xlog_t *log,
		161	xfs_daddr_t blk_no,
		162	int nbblks,
		163	xfs_buf_t *bp,
		164	xfs_caddr_t *offset)
		165	{
		166	int error;
		167
		168	error = xlog_bread_noalign(log, blk_no, nbblks, bp);
		169	if (error)
		170	return error;
		171
		172	*offset = xlog_align(log, blk_no, nbblks, bp);
		173	return 0;
		174	}
		175
140	/*	176	/*
141	* Write out the buffer at the given block for the given number of blocks.	177	* Write out the buffer at the given block for the given number of blocks.
142	* The buffer is kept locked across the write and is returned locked.	178	* The buffer is kept locked across the write and is returned locked.
@@ -180,24 +216,6 @@ xlog_bwrite(
180	return error;	216	return error;
181	}	217	}
182		218
183	STATIC xfs_caddr_t
184	xlog_align(
185	xlog_t *log,
186	xfs_daddr_t blk_no,
187	int nbblks,
188	xfs_buf_t *bp)
189	{
190	xfs_caddr_t ptr;
191
192	if (!log->l_sectbb_log)
193	return XFS_BUF_PTR(bp);
194
195	ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
196	ASSERT(XFS_BUF_SIZE(bp) >=
197	BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
198	return ptr;
199	}
200
201	#ifdef DEBUG	219	#ifdef DEBUG
202	/*	220	/*
203	* dump debug superblock and log record information	221	* dump debug superblock and log record information
@@ -321,9 +339,9 @@ xlog_find_cycle_start(
321		339
322	mid_blk = BLK_AVG(first_blk, *last_blk);	340	mid_blk = BLK_AVG(first_blk, *last_blk);
323	while (mid_blk != first_blk && mid_blk != *last_blk) {	341	while (mid_blk != first_blk && mid_blk != *last_blk) {
324	if ((error = xlog_bread(log, mid_blk, 1, bp)))	342	error = xlog_bread(log, mid_blk, 1, bp, &offset);
		343	if (error)
325	return error;	344	return error;
326	offset = xlog_align(log, mid_blk, 1, bp);
327	mid_cycle = xlog_get_cycle(offset);	345	mid_cycle = xlog_get_cycle(offset);
328	if (mid_cycle == cycle) {	346	if (mid_cycle == cycle) {
329	*last_blk = mid_blk;	347	*last_blk = mid_blk;
@@ -379,10 +397,10 @@ xlog_find_verify_cycle(
379		397
380	bcount = min(bufblks, (start_blk + nbblks - i));	398	bcount = min(bufblks, (start_blk + nbblks - i));
381		399
382	if ((error = xlog_bread(log, i, bcount, bp)))	400	error = xlog_bread(log, i, bcount, bp, &buf);
		401	if (error)
383	goto out;	402	goto out;
384		403
385	buf = xlog_align(log, i, bcount, bp);
386	for (j = 0; j < bcount; j++) {	404	for (j = 0; j < bcount; j++) {
387	cycle = xlog_get_cycle(buf);	405	cycle = xlog_get_cycle(buf);
388	if (cycle == stop_on_cycle_no) {	406	if (cycle == stop_on_cycle_no) {
@@ -436,9 +454,9 @@ xlog_find_verify_log_record(
436	return ENOMEM;	454	return ENOMEM;
437	smallmem = 1;	455	smallmem = 1;
438	} else {	456	} else {
439	if ((error = xlog_bread(log, start_blk, num_blks, bp)))	457	error = xlog_bread(log, start_blk, num_blks, bp, &offset);
		458	if (error)
440	goto out;	459	goto out;
441	offset = xlog_align(log, start_blk, num_blks, bp);
442	offset += ((num_blks - 1) << BBSHIFT);	460	offset += ((num_blks - 1) << BBSHIFT);
443	}	461	}
444		462
@@ -453,9 +471,9 @@ xlog_find_verify_log_record(
453	}	471	}
454		472
455	if (smallmem) {	473	if (smallmem) {
456	if ((error = xlog_bread(log, i, 1, bp)))	474	error = xlog_bread(log, i, 1, bp, &offset);
		475	if (error)
457	goto out;	476	goto out;
458	offset = xlog_align(log, i, 1, bp);
459	}	477	}
460		478
461	head = (xlog_rec_header_t *)offset;	479	head = (xlog_rec_header_t *)offset;
@@ -559,15 +577,18 @@ xlog_find_head(
559	bp = xlog_get_bp(log, 1);	577	bp = xlog_get_bp(log, 1);
560	if (!bp)	578	if (!bp)
561	return ENOMEM;	579	return ENOMEM;
562	if ((error = xlog_bread(log, 0, 1, bp)))	580
		581	error = xlog_bread(log, 0, 1, bp, &offset);
		582	if (error)
563	goto bp_err;	583	goto bp_err;
564	offset = xlog_align(log, 0, 1, bp);	584
565	first_half_cycle = xlog_get_cycle(offset);	585	first_half_cycle = xlog_get_cycle(offset);
566		586
567	last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */	587	last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */
568	if ((error = xlog_bread(log, last_blk, 1, bp)))	588	error = xlog_bread(log, last_blk, 1, bp, &offset);
		589	if (error)
569	goto bp_err;	590	goto bp_err;
570	offset = xlog_align(log, last_blk, 1, bp);	591
571	last_half_cycle = xlog_get_cycle(offset);	592	last_half_cycle = xlog_get_cycle(offset);
572	ASSERT(last_half_cycle != 0);	593	ASSERT(last_half_cycle != 0);
573		594
@@ -817,9 +838,10 @@ xlog_find_tail(
817	if (!bp)	838	if (!bp)
818	return ENOMEM;	839	return ENOMEM;
819	if (head_blk == 0) { / special case */	840	if (head_blk == 0) { / special case */
820	if ((error = xlog_bread(log, 0, 1, bp)))	841	error = xlog_bread(log, 0, 1, bp, &offset);
		842	if (error)
821	goto bread_err;	843	goto bread_err;
822	offset = xlog_align(log, 0, 1, bp);	844
823	if (xlog_get_cycle(offset) == 0) {	845	if (xlog_get_cycle(offset) == 0) {
824	*tail_blk = 0;	846	*tail_blk = 0;
825	/* leave all other log inited values alone */	847	/* leave all other log inited values alone */
@@ -832,9 +854,10 @@ xlog_find_tail(
832	*/	854	*/
833	ASSERT(*head_blk < INT_MAX);	855	ASSERT(*head_blk < INT_MAX);
834	for (i = (int)(*head_blk) - 1; i >= 0; i--) {	856	for (i = (int)(*head_blk) - 1; i >= 0; i--) {
835	if ((error = xlog_bread(log, i, 1, bp)))	857	error = xlog_bread(log, i, 1, bp, &offset);
		858	if (error)
836	goto bread_err;	859	goto bread_err;
837	offset = xlog_align(log, i, 1, bp);	860
838	if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu((__be32 )offset)) {	861	if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu((__be32 )offset)) {
839	found = 1;	862	found = 1;
840	break;	863	break;
@@ -848,9 +871,10 @@ xlog_find_tail(
848	*/	871	*/
849	if (!found) {	872	if (!found) {
850	for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {	873	for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
851	if ((error = xlog_bread(log, i, 1, bp)))	874	error = xlog_bread(log, i, 1, bp, &offset);
		875	if (error)
852	goto bread_err;	876	goto bread_err;
853	offset = xlog_align(log, i, 1, bp);	877
854	if (XLOG_HEADER_MAGIC_NUM ==	878	if (XLOG_HEADER_MAGIC_NUM ==
855	be32_to_cpu((__be32 )offset)) {	879	be32_to_cpu((__be32 )offset)) {
856	found = 2;	880	found = 2;
@@ -922,10 +946,10 @@ xlog_find_tail(
922	if (*head_blk == after_umount_blk &&	946	if (*head_blk == after_umount_blk &&
923	be32_to_cpu(rhead->h_num_logops) == 1) {	947	be32_to_cpu(rhead->h_num_logops) == 1) {
924	umount_data_blk = (i + hblks) % log->l_logBBsize;	948	umount_data_blk = (i + hblks) % log->l_logBBsize;
925	if ((error = xlog_bread(log, umount_data_blk, 1, bp))) {	949	error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
		950	if (error)
926	goto bread_err;	951	goto bread_err;
927	}	952
928	offset = xlog_align(log, umount_data_blk, 1, bp);
929	op_head = (xlog_op_header_t *)offset;	953	op_head = (xlog_op_header_t *)offset;
930	if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {	954	if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
931	/*	955	/*
@@ -1017,9 +1041,10 @@ xlog_find_zeroed(
1017	bp = xlog_get_bp(log, 1);	1041	bp = xlog_get_bp(log, 1);
1018	if (!bp)	1042	if (!bp)
1019	return ENOMEM;	1043	return ENOMEM;
1020	if ((error = xlog_bread(log, 0, 1, bp)))	1044	error = xlog_bread(log, 0, 1, bp, &offset);
		1045	if (error)
1021	goto bp_err;	1046	goto bp_err;
1022	offset = xlog_align(log, 0, 1, bp);	1047
1023	first_cycle = xlog_get_cycle(offset);	1048	first_cycle = xlog_get_cycle(offset);
1024	if (first_cycle == 0) { /* completely zeroed log */	1049	if (first_cycle == 0) { /* completely zeroed log */
1025	*blk_no = 0;	1050	*blk_no = 0;
@@ -1028,9 +1053,10 @@ xlog_find_zeroed(
1028	}	1053	}
1029		1054
1030	/* check partially zeroed log */	1055	/* check partially zeroed log */
1031	if ((error = xlog_bread(log, log_bbnum-1, 1, bp)))	1056	error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
		1057	if (error)
1032	goto bp_err;	1058	goto bp_err;
1033	offset = xlog_align(log, log_bbnum-1, 1, bp);	1059
1034	last_cycle = xlog_get_cycle(offset);	1060	last_cycle = xlog_get_cycle(offset);
1035	if (last_cycle != 0) { /* log completely written to */	1061	if (last_cycle != 0) { /* log completely written to */
1036	xlog_put_bp(bp);	1062	xlog_put_bp(bp);
@@ -1152,10 +1178,10 @@ xlog_write_log_records(
1152	*/	1178	*/
1153	balign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, start_block);	1179	balign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, start_block);
1154	if (balign != start_block) {	1180	if (balign != start_block) {
1155	if ((error = xlog_bread(log, start_block, 1, bp))) {	1181	error = xlog_bread_noalign(log, start_block, 1, bp);
1156	xlog_put_bp(bp);	1182	if (error)
1157	return error;	1183	goto out_put_bp;
1158	}	1184
1159	j = start_block - balign;	1185	j = start_block - balign;
1160	}	1186	}
1161		1187
@@ -1175,10 +1201,14 @@ xlog_write_log_records(
1175	balign = BBTOB(ealign - start_block);	1201	balign = BBTOB(ealign - start_block);
1176	error = XFS_BUF_SET_PTR(bp, offset + balign,	1202	error = XFS_BUF_SET_PTR(bp, offset + balign,
1177	BBTOB(sectbb));	1203	BBTOB(sectbb));
1178	if (!error)	1204	if (error)
1179	error = xlog_bread(log, ealign, sectbb, bp);	1205	break;
1180	if (!error)	1206
1181	error = XFS_BUF_SET_PTR(bp, offset, bufblks);	1207	error = xlog_bread_noalign(log, ealign, sectbb, bp);
		1208	if (error)
		1209	break;
		1210
		1211	error = XFS_BUF_SET_PTR(bp, offset, bufblks);
1182	if (error)	1212	if (error)
1183	break;	1213	break;
1184	}	1214	}
@@ -1195,6 +1225,8 @@ xlog_write_log_records(
1195	start_block += endcount;	1225	start_block += endcount;
1196	j = 0;	1226	j = 0;
1197	}	1227	}
		1228
		1229	out_put_bp:
1198	xlog_put_bp(bp);	1230	xlog_put_bp(bp);
1199	return error;	1231	return error;
1200	}	1232	}
@@ -3481,9 +3513,11 @@ xlog_do_recovery_pass(
3481	hbp = xlog_get_bp(log, 1);	3513	hbp = xlog_get_bp(log, 1);
3482	if (!hbp)	3514	if (!hbp)
3483	return ENOMEM;	3515	return ENOMEM;
3484	if ((error = xlog_bread(log, tail_blk, 1, hbp)))	3516
		3517	error = xlog_bread(log, tail_blk, 1, hbp, &offset);
		3518	if (error)
3485	goto bread_err1;	3519	goto bread_err1;
3486	offset = xlog_align(log, tail_blk, 1, hbp);	3520
3487	rhead = (xlog_rec_header_t *)offset;	3521	rhead = (xlog_rec_header_t *)offset;
3488	error = xlog_valid_rec_header(log, rhead, tail_blk);	3522	error = xlog_valid_rec_header(log, rhead, tail_blk);
3489	if (error)	3523	if (error)
@@ -3517,9 +3551,10 @@ xlog_do_recovery_pass(
3517	memset(rhash, 0, sizeof(rhash));	3551	memset(rhash, 0, sizeof(rhash));
3518	if (tail_blk <= head_blk) {	3552	if (tail_blk <= head_blk) {
3519	for (blk_no = tail_blk; blk_no < head_blk; ) {	3553	for (blk_no = tail_blk; blk_no < head_blk; ) {
3520	if ((error = xlog_bread(log, blk_no, hblks, hbp)))	3554	error = xlog_bread(log, blk_no, hblks, hbp, &offset);
		3555	if (error)
3521	goto bread_err2;	3556	goto bread_err2;
3522	offset = xlog_align(log, blk_no, hblks, hbp);	3557
3523	rhead = (xlog_rec_header_t *)offset;	3558	rhead = (xlog_rec_header_t *)offset;
3524	error = xlog_valid_rec_header(log, rhead, blk_no);	3559	error = xlog_valid_rec_header(log, rhead, blk_no);
3525	if (error)	3560	if (error)
@@ -3527,10 +3562,11 @@ xlog_do_recovery_pass(
3527		3562
3528	/* blocks in data section */	3563	/* blocks in data section */
3529	bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));	3564	bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
3530	error = xlog_bread(log, blk_no + hblks, bblks, dbp);	3565	error = xlog_bread(log, blk_no + hblks, bblks, dbp,
		3566	&offset);
3531	if (error)	3567	if (error)
3532	goto bread_err2;	3568	goto bread_err2;
3533	offset = xlog_align(log, blk_no + hblks, bblks, dbp);	3569
3534	xlog_unpack_data(rhead, offset, log);	3570	xlog_unpack_data(rhead, offset, log);
3535	if ((error = xlog_recover_process_data(log,	3571	if ((error = xlog_recover_process_data(log,
3536	rhash, rhead, offset, pass)))	3572	rhash, rhead, offset, pass)))
@@ -3553,10 +3589,10 @@ xlog_do_recovery_pass(
3553	wrapped_hblks = 0;	3589	wrapped_hblks = 0;
3554	if (blk_no + hblks <= log->l_logBBsize) {	3590	if (blk_no + hblks <= log->l_logBBsize) {
3555	/* Read header in one read */	3591	/* Read header in one read */
3556	error = xlog_bread(log, blk_no, hblks, hbp);	3592	error = xlog_bread(log, blk_no, hblks, hbp,
		3593	&offset);
3557	if (error)	3594	if (error)
3558	goto bread_err2;	3595	goto bread_err2;
3559	offset = xlog_align(log, blk_no, hblks, hbp);
3560	} else {	3596	} else {
3561	/* This LR is split across physical log end */	3597	/* This LR is split across physical log end */
3562	if (blk_no != log->l_logBBsize) {	3598	if (blk_no != log->l_logBBsize) {
@@ -3564,12 +3600,13 @@ xlog_do_recovery_pass(
3564	ASSERT(blk_no <= INT_MAX);	3600	ASSERT(blk_no <= INT_MAX);
3565	split_hblks = log->l_logBBsize - (int)blk_no;	3601	split_hblks = log->l_logBBsize - (int)blk_no;
3566	ASSERT(split_hblks > 0);	3602	ASSERT(split_hblks > 0);
3567	if ((error = xlog_bread(log, blk_no,	3603	error = xlog_bread(log, blk_no,
3568	split_hblks, hbp)))	3604	split_hblks, hbp,
		3605	&offset);
		3606	if (error)
3569	goto bread_err2;	3607	goto bread_err2;
3570	offset = xlog_align(log, blk_no,
3571	split_hblks, hbp);
3572	}	3608	}
		3609
3573	/*	3610	/*
3574	* Note: this black magic still works with	3611	* Note: this black magic still works with
3575	* large sector sizes (non-512) only because:	3612	* large sector sizes (non-512) only because:
@@ -3587,14 +3624,19 @@ xlog_do_recovery_pass(
3587	error = XFS_BUF_SET_PTR(hbp,	3624	error = XFS_BUF_SET_PTR(hbp,
3588	bufaddr + BBTOB(split_hblks),	3625	bufaddr + BBTOB(split_hblks),
3589	BBTOB(hblks - split_hblks));	3626	BBTOB(hblks - split_hblks));
3590	if (!error)	3627	if (error)
3591	error = xlog_bread(log, 0,	3628	goto bread_err2;
3592	wrapped_hblks, hbp);	3629
3593	if (!error)	3630	error = xlog_bread_noalign(log, 0,
3594	error = XFS_BUF_SET_PTR(hbp, bufaddr,	3631	wrapped_hblks, hbp);
		3632	if (error)
		3633	goto bread_err2;
		3634
		3635	error = XFS_BUF_SET_PTR(hbp, bufaddr,
3595	BBTOB(hblks));	3636	BBTOB(hblks));
3596	if (error)	3637	if (error)
3597	goto bread_err2;	3638	goto bread_err2;
		3639
3598	if (!offset)	3640	if (!offset)
3599	offset = xlog_align(log, 0,	3641	offset = xlog_align(log, 0,
3600	wrapped_hblks, hbp);	3642	wrapped_hblks, hbp);
@@ -3610,10 +3652,10 @@ xlog_do_recovery_pass(
3610		3652
3611	/* Read in data for log record */	3653	/* Read in data for log record */
3612	if (blk_no + bblks <= log->l_logBBsize) {	3654	if (blk_no + bblks <= log->l_logBBsize) {
3613	error = xlog_bread(log, blk_no, bblks, dbp);	3655	error = xlog_bread(log, blk_no, bblks, dbp,
		3656	&offset);
3614	if (error)	3657	if (error)
3615	goto bread_err2;	3658	goto bread_err2;
3616	offset = xlog_align(log, blk_no, bblks, dbp);
3617	} else {	3659	} else {
3618	/* This log record is split across the	3660	/* This log record is split across the
3619	* physical end of log */	3661	* physical end of log */
@@ -3627,12 +3669,13 @@ xlog_do_recovery_pass(
3627	split_bblks =	3669	split_bblks =
3628	log->l_logBBsize - (int)blk_no;	3670	log->l_logBBsize - (int)blk_no;
3629	ASSERT(split_bblks > 0);	3671	ASSERT(split_bblks > 0);
3630	if ((error = xlog_bread(log, blk_no,	3672	error = xlog_bread(log, blk_no,
3631	split_bblks, dbp)))	3673	split_bblks, dbp,
		3674	&offset);
		3675	if (error)
3632	goto bread_err2;	3676	goto bread_err2;
3633	offset = xlog_align(log, blk_no,
3634	split_bblks, dbp);
3635	}	3677	}
		3678
3636	/*	3679	/*
3637	* Note: this black magic still works with	3680	* Note: this black magic still works with
3638	* large sector sizes (non-512) only because:	3681	* large sector sizes (non-512) only because:
@@ -3649,15 +3692,19 @@ xlog_do_recovery_pass(
3649	error = XFS_BUF_SET_PTR(dbp,	3692	error = XFS_BUF_SET_PTR(dbp,
3650	bufaddr + BBTOB(split_bblks),	3693	bufaddr + BBTOB(split_bblks),
3651	BBTOB(bblks - split_bblks));	3694	BBTOB(bblks - split_bblks));
3652	if (!error)
3653	error = xlog_bread(log, wrapped_hblks,
3654	bblks - split_bblks,
3655	dbp);
3656	if (!error)
3657	error = XFS_BUF_SET_PTR(dbp, bufaddr,
3658	h_size);
3659	if (error)	3695	if (error)
3660	goto bread_err2;	3696	goto bread_err2;
		3697
		3698	error = xlog_bread_noalign(log, wrapped_hblks,
		3699	bblks - split_bblks,
		3700	dbp);
		3701	if (error)
		3702	goto bread_err2;
		3703
		3704	error = XFS_BUF_SET_PTR(dbp, bufaddr, h_size);
		3705	if (error)
		3706	goto bread_err2;
		3707
3661	if (!offset)	3708	if (!offset)
3662	offset = xlog_align(log, wrapped_hblks,	3709	offset = xlog_align(log, wrapped_hblks,
3663	bblks - split_bblks, dbp);	3710	bblks - split_bblks, dbp);
@@ -3674,17 +3721,21 @@ xlog_do_recovery_pass(
3674		3721
3675	/* read first part of physical log */	3722	/* read first part of physical log */
3676	while (blk_no < head_blk) {	3723	while (blk_no < head_blk) {
3677	if ((error = xlog_bread(log, blk_no, hblks, hbp)))	3724	error = xlog_bread(log, blk_no, hblks, hbp, &offset);
		3725	if (error)
3678	goto bread_err2;	3726	goto bread_err2;
3679	offset = xlog_align(log, blk_no, hblks, hbp);	3727
3680	rhead = (xlog_rec_header_t *)offset;	3728	rhead = (xlog_rec_header_t *)offset;
3681	error = xlog_valid_rec_header(log, rhead, blk_no);	3729	error = xlog_valid_rec_header(log, rhead, blk_no);
3682	if (error)	3730	if (error)
3683	goto bread_err2;	3731	goto bread_err2;
		3732
3684	bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));	3733	bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
3685	if ((error = xlog_bread(log, blk_no+hblks, bblks, dbp)))	3734	error = xlog_bread(log, blk_no+hblks, bblks, dbp,
		3735	&offset);
		3736	if (error)
3686	goto bread_err2;	3737	goto bread_err2;
3687	offset = xlog_align(log, blk_no+hblks, bblks, dbp);	3738
3688	xlog_unpack_data(rhead, offset, log);	3739	xlog_unpack_data(rhead, offset, log);
3689	if ((error = xlog_recover_process_data(log, rhash,	3740	if ((error = xlog_recover_process_data(log, rhash,
3690	rhead, offset, pass)))	3741	rhead, offset, pass)))