diff options
37 files changed, 357 insertions, 249 deletions
diff --git a/fs/xfs/xfs_ag.h b/fs/xfs/xfs_ag.h index 22bd4db011c8..f2aeedb6a579 100644 --- a/fs/xfs/xfs_ag.h +++ b/fs/xfs/xfs_ag.h | |||
@@ -108,6 +108,8 @@ typedef struct xfs_agf { | |||
108 | extern int xfs_read_agf(struct xfs_mount *mp, struct xfs_trans *tp, | 108 | extern int xfs_read_agf(struct xfs_mount *mp, struct xfs_trans *tp, |
109 | xfs_agnumber_t agno, int flags, struct xfs_buf **bpp); | 109 | xfs_agnumber_t agno, int flags, struct xfs_buf **bpp); |
110 | 110 | ||
111 | extern const struct xfs_buf_ops xfs_agf_buf_ops; | ||
112 | |||
111 | /* | 113 | /* |
112 | * Size of the unlinked inode hash table in the agi. | 114 | * Size of the unlinked inode hash table in the agi. |
113 | */ | 115 | */ |
@@ -161,6 +163,8 @@ typedef struct xfs_agi { | |||
161 | extern int xfs_read_agi(struct xfs_mount *mp, struct xfs_trans *tp, | 163 | extern int xfs_read_agi(struct xfs_mount *mp, struct xfs_trans *tp, |
162 | xfs_agnumber_t agno, struct xfs_buf **bpp); | 164 | xfs_agnumber_t agno, struct xfs_buf **bpp); |
163 | 165 | ||
166 | extern const struct xfs_buf_ops xfs_agi_buf_ops; | ||
167 | |||
164 | /* | 168 | /* |
165 | * The third a.g. block contains the a.g. freelist, an array | 169 | * The third a.g. block contains the a.g. freelist, an array |
166 | * of block pointers to blocks owned by the allocation btree code. | 170 | * of block pointers to blocks owned by the allocation btree code. |
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c index 545a6c4c2366..393055fe3aef 100644 --- a/fs/xfs/xfs_alloc.c +++ b/fs/xfs/xfs_alloc.c | |||
@@ -465,7 +465,7 @@ xfs_agfl_verify( | |||
465 | #endif | 465 | #endif |
466 | } | 466 | } |
467 | 467 | ||
468 | void | 468 | static void |
469 | xfs_agfl_write_verify( | 469 | xfs_agfl_write_verify( |
470 | struct xfs_buf *bp) | 470 | struct xfs_buf *bp) |
471 | { | 471 | { |
@@ -477,11 +477,13 @@ xfs_agfl_read_verify( | |||
477 | struct xfs_buf *bp) | 477 | struct xfs_buf *bp) |
478 | { | 478 | { |
479 | xfs_agfl_verify(bp); | 479 | xfs_agfl_verify(bp); |
480 | bp->b_pre_io = xfs_agfl_write_verify; | ||
481 | bp->b_iodone = NULL; | ||
482 | xfs_buf_ioend(bp, 0); | ||
483 | } | 480 | } |
484 | 481 | ||
482 | const struct xfs_buf_ops xfs_agfl_buf_ops = { | ||
483 | .verify_read = xfs_agfl_read_verify, | ||
484 | .verify_write = xfs_agfl_write_verify, | ||
485 | }; | ||
486 | |||
485 | /* | 487 | /* |
486 | * Read in the allocation group free block array. | 488 | * Read in the allocation group free block array. |
487 | */ | 489 | */ |
@@ -499,7 +501,7 @@ xfs_alloc_read_agfl( | |||
499 | error = xfs_trans_read_buf( | 501 | error = xfs_trans_read_buf( |
500 | mp, tp, mp->m_ddev_targp, | 502 | mp, tp, mp->m_ddev_targp, |
501 | XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)), | 503 | XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)), |
502 | XFS_FSS_TO_BB(mp, 1), 0, &bp, xfs_agfl_read_verify); | 504 | XFS_FSS_TO_BB(mp, 1), 0, &bp, &xfs_agfl_buf_ops); |
503 | if (error) | 505 | if (error) |
504 | return error; | 506 | return error; |
505 | ASSERT(!xfs_buf_geterror(bp)); | 507 | ASSERT(!xfs_buf_geterror(bp)); |
@@ -2181,23 +2183,25 @@ xfs_agf_verify( | |||
2181 | } | 2183 | } |
2182 | } | 2184 | } |
2183 | 2185 | ||
2184 | void | 2186 | static void |
2185 | xfs_agf_write_verify( | 2187 | xfs_agf_read_verify( |
2186 | struct xfs_buf *bp) | 2188 | struct xfs_buf *bp) |
2187 | { | 2189 | { |
2188 | xfs_agf_verify(bp); | 2190 | xfs_agf_verify(bp); |
2189 | } | 2191 | } |
2190 | 2192 | ||
2191 | static void | 2193 | static void |
2192 | xfs_agf_read_verify( | 2194 | xfs_agf_write_verify( |
2193 | struct xfs_buf *bp) | 2195 | struct xfs_buf *bp) |
2194 | { | 2196 | { |
2195 | xfs_agf_verify(bp); | 2197 | xfs_agf_verify(bp); |
2196 | bp->b_pre_io = xfs_agf_write_verify; | ||
2197 | bp->b_iodone = NULL; | ||
2198 | xfs_buf_ioend(bp, 0); | ||
2199 | } | 2198 | } |
2200 | 2199 | ||
2200 | const struct xfs_buf_ops xfs_agf_buf_ops = { | ||
2201 | .verify_read = xfs_agf_read_verify, | ||
2202 | .verify_write = xfs_agf_write_verify, | ||
2203 | }; | ||
2204 | |||
2201 | /* | 2205 | /* |
2202 | * Read in the allocation group header (free/alloc section). | 2206 | * Read in the allocation group header (free/alloc section). |
2203 | */ | 2207 | */ |
@@ -2215,7 +2219,7 @@ xfs_read_agf( | |||
2215 | error = xfs_trans_read_buf( | 2219 | error = xfs_trans_read_buf( |
2216 | mp, tp, mp->m_ddev_targp, | 2220 | mp, tp, mp->m_ddev_targp, |
2217 | XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)), | 2221 | XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)), |
2218 | XFS_FSS_TO_BB(mp, 1), flags, bpp, xfs_agf_read_verify); | 2222 | XFS_FSS_TO_BB(mp, 1), flags, bpp, &xfs_agf_buf_ops); |
2219 | if (error) | 2223 | if (error) |
2220 | return error; | 2224 | return error; |
2221 | if (!*bpp) | 2225 | if (!*bpp) |
diff --git a/fs/xfs/xfs_alloc.h b/fs/xfs/xfs_alloc.h index f32811f50f43..99d0a6101558 100644 --- a/fs/xfs/xfs_alloc.h +++ b/fs/xfs/xfs_alloc.h | |||
@@ -231,7 +231,7 @@ xfs_alloc_get_rec( | |||
231 | xfs_extlen_t *len, /* output: length of extent */ | 231 | xfs_extlen_t *len, /* output: length of extent */ |
232 | int *stat); /* output: success/failure */ | 232 | int *stat); /* output: success/failure */ |
233 | 233 | ||
234 | void xfs_agf_write_verify(struct xfs_buf *bp); | 234 | extern const struct xfs_buf_ops xfs_agf_buf_ops; |
235 | void xfs_agfl_write_verify(struct xfs_buf *bp); | 235 | extern const struct xfs_buf_ops xfs_agfl_buf_ops; |
236 | 236 | ||
237 | #endif /* __XFS_ALLOC_H__ */ | 237 | #endif /* __XFS_ALLOC_H__ */ |
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c index b83396524913..b1ddef6b2689 100644 --- a/fs/xfs/xfs_alloc_btree.c +++ b/fs/xfs/xfs_alloc_btree.c | |||
@@ -329,22 +329,25 @@ xfs_allocbt_verify( | |||
329 | } | 329 | } |
330 | 330 | ||
331 | static void | 331 | static void |
332 | xfs_allocbt_write_verify( | 332 | xfs_allocbt_read_verify( |
333 | struct xfs_buf *bp) | 333 | struct xfs_buf *bp) |
334 | { | 334 | { |
335 | xfs_allocbt_verify(bp); | 335 | xfs_allocbt_verify(bp); |
336 | } | 336 | } |
337 | 337 | ||
338 | void | 338 | static void |
339 | xfs_allocbt_read_verify( | 339 | xfs_allocbt_write_verify( |
340 | struct xfs_buf *bp) | 340 | struct xfs_buf *bp) |
341 | { | 341 | { |
342 | xfs_allocbt_verify(bp); | 342 | xfs_allocbt_verify(bp); |
343 | bp->b_pre_io = xfs_allocbt_write_verify; | ||
344 | bp->b_iodone = NULL; | ||
345 | xfs_buf_ioend(bp, 0); | ||
346 | } | 343 | } |
347 | 344 | ||
345 | const struct xfs_buf_ops xfs_allocbt_buf_ops = { | ||
346 | .verify_read = xfs_allocbt_read_verify, | ||
347 | .verify_write = xfs_allocbt_write_verify, | ||
348 | }; | ||
349 | |||
350 | |||
348 | #ifdef DEBUG | 351 | #ifdef DEBUG |
349 | STATIC int | 352 | STATIC int |
350 | xfs_allocbt_keys_inorder( | 353 | xfs_allocbt_keys_inorder( |
@@ -400,8 +403,7 @@ static const struct xfs_btree_ops xfs_allocbt_ops = { | |||
400 | .init_rec_from_cur = xfs_allocbt_init_rec_from_cur, | 403 | .init_rec_from_cur = xfs_allocbt_init_rec_from_cur, |
401 | .init_ptr_from_cur = xfs_allocbt_init_ptr_from_cur, | 404 | .init_ptr_from_cur = xfs_allocbt_init_ptr_from_cur, |
402 | .key_diff = xfs_allocbt_key_diff, | 405 | .key_diff = xfs_allocbt_key_diff, |
403 | .read_verify = xfs_allocbt_read_verify, | 406 | .buf_ops = &xfs_allocbt_buf_ops, |
404 | .write_verify = xfs_allocbt_write_verify, | ||
405 | #ifdef DEBUG | 407 | #ifdef DEBUG |
406 | .keys_inorder = xfs_allocbt_keys_inorder, | 408 | .keys_inorder = xfs_allocbt_keys_inorder, |
407 | .recs_inorder = xfs_allocbt_recs_inorder, | 409 | .recs_inorder = xfs_allocbt_recs_inorder, |
diff --git a/fs/xfs/xfs_alloc_btree.h b/fs/xfs/xfs_alloc_btree.h index 359fb86ed876..7e89a2b429dd 100644 --- a/fs/xfs/xfs_alloc_btree.h +++ b/fs/xfs/xfs_alloc_btree.h | |||
@@ -93,4 +93,6 @@ extern struct xfs_btree_cur *xfs_allocbt_init_cursor(struct xfs_mount *, | |||
93 | xfs_agnumber_t, xfs_btnum_t); | 93 | xfs_agnumber_t, xfs_btnum_t); |
94 | extern int xfs_allocbt_maxrecs(struct xfs_mount *, int, int); | 94 | extern int xfs_allocbt_maxrecs(struct xfs_mount *, int, int); |
95 | 95 | ||
96 | extern const struct xfs_buf_ops xfs_allocbt_buf_ops; | ||
97 | |||
96 | #endif /* __XFS_ALLOC_BTREE_H__ */ | 98 | #endif /* __XFS_ALLOC_BTREE_H__ */ |
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c index 5cd5b0c1d17a..ee24993c7d12 100644 --- a/fs/xfs/xfs_attr_leaf.c +++ b/fs/xfs/xfs_attr_leaf.c | |||
@@ -104,22 +104,23 @@ xfs_attr_leaf_verify( | |||
104 | } | 104 | } |
105 | 105 | ||
106 | static void | 106 | static void |
107 | xfs_attr_leaf_write_verify( | 107 | xfs_attr_leaf_read_verify( |
108 | struct xfs_buf *bp) | 108 | struct xfs_buf *bp) |
109 | { | 109 | { |
110 | xfs_attr_leaf_verify(bp); | 110 | xfs_attr_leaf_verify(bp); |
111 | } | 111 | } |
112 | 112 | ||
113 | void | 113 | static void |
114 | xfs_attr_leaf_read_verify( | 114 | xfs_attr_leaf_write_verify( |
115 | struct xfs_buf *bp) | 115 | struct xfs_buf *bp) |
116 | { | 116 | { |
117 | xfs_attr_leaf_verify(bp); | 117 | xfs_attr_leaf_verify(bp); |
118 | bp->b_pre_io = xfs_attr_leaf_write_verify; | ||
119 | bp->b_iodone = NULL; | ||
120 | xfs_buf_ioend(bp, 0); | ||
121 | } | 118 | } |
122 | 119 | ||
120 | const struct xfs_buf_ops xfs_attr_leaf_buf_ops = { | ||
121 | .verify_read = xfs_attr_leaf_read_verify, | ||
122 | .verify_write = xfs_attr_leaf_write_verify, | ||
123 | }; | ||
123 | 124 | ||
124 | int | 125 | int |
125 | xfs_attr_leaf_read( | 126 | xfs_attr_leaf_read( |
@@ -130,7 +131,7 @@ xfs_attr_leaf_read( | |||
130 | struct xfs_buf **bpp) | 131 | struct xfs_buf **bpp) |
131 | { | 132 | { |
132 | return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp, | 133 | return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp, |
133 | XFS_ATTR_FORK, xfs_attr_leaf_read_verify); | 134 | XFS_ATTR_FORK, &xfs_attr_leaf_buf_ops); |
134 | } | 135 | } |
135 | 136 | ||
136 | /*======================================================================== | 137 | /*======================================================================== |
@@ -924,7 +925,7 @@ xfs_attr_leaf_to_node(xfs_da_args_t *args) | |||
924 | XFS_ATTR_FORK); | 925 | XFS_ATTR_FORK); |
925 | if (error) | 926 | if (error) |
926 | goto out; | 927 | goto out; |
927 | bp2->b_pre_io = bp1->b_pre_io; | 928 | bp2->b_ops = bp1->b_ops; |
928 | memcpy(bp2->b_addr, bp1->b_addr, XFS_LBSIZE(dp->i_mount)); | 929 | memcpy(bp2->b_addr, bp1->b_addr, XFS_LBSIZE(dp->i_mount)); |
929 | bp1 = NULL; | 930 | bp1 = NULL; |
930 | xfs_trans_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1); | 931 | xfs_trans_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1); |
@@ -978,7 +979,7 @@ xfs_attr_leaf_create( | |||
978 | XFS_ATTR_FORK); | 979 | XFS_ATTR_FORK); |
979 | if (error) | 980 | if (error) |
980 | return(error); | 981 | return(error); |
981 | bp->b_pre_io = xfs_attr_leaf_write_verify; | 982 | bp->b_ops = &xfs_attr_leaf_buf_ops; |
982 | leaf = bp->b_addr; | 983 | leaf = bp->b_addr; |
983 | memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount)); | 984 | memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount)); |
984 | hdr = &leaf->hdr; | 985 | hdr = &leaf->hdr; |
diff --git a/fs/xfs/xfs_attr_leaf.h b/fs/xfs/xfs_attr_leaf.h index 3bbf6277e43c..77de139a58f0 100644 --- a/fs/xfs/xfs_attr_leaf.h +++ b/fs/xfs/xfs_attr_leaf.h | |||
@@ -264,6 +264,7 @@ int xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize, | |||
264 | int xfs_attr_leaf_read(struct xfs_trans *tp, struct xfs_inode *dp, | 264 | int xfs_attr_leaf_read(struct xfs_trans *tp, struct xfs_inode *dp, |
265 | xfs_dablk_t bno, xfs_daddr_t mappedbno, | 265 | xfs_dablk_t bno, xfs_daddr_t mappedbno, |
266 | struct xfs_buf **bpp); | 266 | struct xfs_buf **bpp); |
267 | void xfs_attr_leaf_read_verify(struct xfs_buf *bp); | 267 | |
268 | extern const struct xfs_buf_ops xfs_attr_leaf_buf_ops; | ||
268 | 269 | ||
269 | #endif /* __XFS_ATTR_LEAF_H__ */ | 270 | #endif /* __XFS_ATTR_LEAF_H__ */ |
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c index 6a0f3f9f39d3..0e92d12765d2 100644 --- a/fs/xfs/xfs_bmap.c +++ b/fs/xfs/xfs_bmap.c | |||
@@ -2663,7 +2663,7 @@ xfs_bmap_btree_to_extents( | |||
2663 | return error; | 2663 | return error; |
2664 | #endif | 2664 | #endif |
2665 | error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF, | 2665 | error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF, |
2666 | xfs_bmbt_read_verify); | 2666 | &xfs_bmbt_buf_ops); |
2667 | if (error) | 2667 | if (error) |
2668 | return error; | 2668 | return error; |
2669 | cblock = XFS_BUF_TO_BLOCK(cbp); | 2669 | cblock = XFS_BUF_TO_BLOCK(cbp); |
@@ -3124,7 +3124,7 @@ xfs_bmap_extents_to_btree( | |||
3124 | /* | 3124 | /* |
3125 | * Fill in the child block. | 3125 | * Fill in the child block. |
3126 | */ | 3126 | */ |
3127 | abp->b_pre_io = xfs_bmbt_write_verify; | 3127 | abp->b_ops = &xfs_bmbt_buf_ops; |
3128 | ablock = XFS_BUF_TO_BLOCK(abp); | 3128 | ablock = XFS_BUF_TO_BLOCK(abp); |
3129 | ablock->bb_magic = cpu_to_be32(XFS_BMAP_MAGIC); | 3129 | ablock->bb_magic = cpu_to_be32(XFS_BMAP_MAGIC); |
3130 | ablock->bb_level = 0; | 3130 | ablock->bb_level = 0; |
@@ -3271,7 +3271,7 @@ xfs_bmap_local_to_extents( | |||
3271 | ASSERT(args.len == 1); | 3271 | ASSERT(args.len == 1); |
3272 | *firstblock = args.fsbno; | 3272 | *firstblock = args.fsbno; |
3273 | bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0); | 3273 | bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0); |
3274 | bp->b_pre_io = xfs_bmbt_write_verify; | 3274 | bp->b_ops = &xfs_bmbt_buf_ops; |
3275 | memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); | 3275 | memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); |
3276 | xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1); | 3276 | xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1); |
3277 | xfs_bmap_forkoff_reset(args.mp, ip, whichfork); | 3277 | xfs_bmap_forkoff_reset(args.mp, ip, whichfork); |
@@ -4082,7 +4082,7 @@ xfs_bmap_read_extents( | |||
4082 | */ | 4082 | */ |
4083 | while (level-- > 0) { | 4083 | while (level-- > 0) { |
4084 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, | 4084 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, |
4085 | XFS_BMAP_BTREE_REF, xfs_bmbt_read_verify); | 4085 | XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); |
4086 | if (error) | 4086 | if (error) |
4087 | return error; | 4087 | return error; |
4088 | block = XFS_BUF_TO_BLOCK(bp); | 4088 | block = XFS_BUF_TO_BLOCK(bp); |
@@ -4129,7 +4129,7 @@ xfs_bmap_read_extents( | |||
4129 | nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); | 4129 | nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); |
4130 | if (nextbno != NULLFSBLOCK) | 4130 | if (nextbno != NULLFSBLOCK) |
4131 | xfs_btree_reada_bufl(mp, nextbno, 1, | 4131 | xfs_btree_reada_bufl(mp, nextbno, 1, |
4132 | xfs_bmbt_read_verify); | 4132 | &xfs_bmbt_buf_ops); |
4133 | /* | 4133 | /* |
4134 | * Copy records into the extent records. | 4134 | * Copy records into the extent records. |
4135 | */ | 4135 | */ |
@@ -4162,7 +4162,7 @@ xfs_bmap_read_extents( | |||
4162 | if (bno == NULLFSBLOCK) | 4162 | if (bno == NULLFSBLOCK) |
4163 | break; | 4163 | break; |
4164 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, | 4164 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, |
4165 | XFS_BMAP_BTREE_REF, xfs_bmbt_read_verify); | 4165 | XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); |
4166 | if (error) | 4166 | if (error) |
4167 | return error; | 4167 | return error; |
4168 | block = XFS_BUF_TO_BLOCK(bp); | 4168 | block = XFS_BUF_TO_BLOCK(bp); |
@@ -5880,7 +5880,7 @@ xfs_bmap_check_leaf_extents( | |||
5880 | bp_release = 1; | 5880 | bp_release = 1; |
5881 | error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, | 5881 | error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, |
5882 | XFS_BMAP_BTREE_REF, | 5882 | XFS_BMAP_BTREE_REF, |
5883 | xfs_bmbt_read_verify); | 5883 | &xfs_bmbt_buf_ops); |
5884 | if (error) | 5884 | if (error) |
5885 | goto error_norelse; | 5885 | goto error_norelse; |
5886 | } | 5886 | } |
@@ -5966,7 +5966,7 @@ xfs_bmap_check_leaf_extents( | |||
5966 | bp_release = 1; | 5966 | bp_release = 1; |
5967 | error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, | 5967 | error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, |
5968 | XFS_BMAP_BTREE_REF, | 5968 | XFS_BMAP_BTREE_REF, |
5969 | xfs_bmbt_read_verify); | 5969 | &xfs_bmbt_buf_ops); |
5970 | if (error) | 5970 | if (error) |
5971 | goto error_norelse; | 5971 | goto error_norelse; |
5972 | } | 5972 | } |
@@ -6061,7 +6061,7 @@ xfs_bmap_count_tree( | |||
6061 | int numrecs; | 6061 | int numrecs; |
6062 | 6062 | ||
6063 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, XFS_BMAP_BTREE_REF, | 6063 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, XFS_BMAP_BTREE_REF, |
6064 | xfs_bmbt_read_verify); | 6064 | &xfs_bmbt_buf_ops); |
6065 | if (error) | 6065 | if (error) |
6066 | return error; | 6066 | return error; |
6067 | *count += 1; | 6067 | *count += 1; |
@@ -6073,7 +6073,7 @@ xfs_bmap_count_tree( | |||
6073 | while (nextbno != NULLFSBLOCK) { | 6073 | while (nextbno != NULLFSBLOCK) { |
6074 | error = xfs_btree_read_bufl(mp, tp, nextbno, 0, &nbp, | 6074 | error = xfs_btree_read_bufl(mp, tp, nextbno, 0, &nbp, |
6075 | XFS_BMAP_BTREE_REF, | 6075 | XFS_BMAP_BTREE_REF, |
6076 | xfs_bmbt_read_verify); | 6076 | &xfs_bmbt_buf_ops); |
6077 | if (error) | 6077 | if (error) |
6078 | return error; | 6078 | return error; |
6079 | *count += 1; | 6079 | *count += 1; |
@@ -6105,7 +6105,7 @@ xfs_bmap_count_tree( | |||
6105 | bno = nextbno; | 6105 | bno = nextbno; |
6106 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, | 6106 | error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, |
6107 | XFS_BMAP_BTREE_REF, | 6107 | XFS_BMAP_BTREE_REF, |
6108 | xfs_bmbt_read_verify); | 6108 | &xfs_bmbt_buf_ops); |
6109 | if (error) | 6109 | if (error) |
6110 | return error; | 6110 | return error; |
6111 | *count += 1; | 6111 | *count += 1; |
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/xfs_bmap_btree.c index 79758e1e4f74..061b45cbe614 100644 --- a/fs/xfs/xfs_bmap_btree.c +++ b/fs/xfs/xfs_bmap_btree.c | |||
@@ -749,23 +749,26 @@ xfs_bmbt_verify( | |||
749 | } | 749 | } |
750 | } | 750 | } |
751 | 751 | ||
752 | void | 752 | static void |
753 | xfs_bmbt_write_verify( | 753 | xfs_bmbt_read_verify( |
754 | struct xfs_buf *bp) | 754 | struct xfs_buf *bp) |
755 | { | 755 | { |
756 | xfs_bmbt_verify(bp); | 756 | xfs_bmbt_verify(bp); |
757 | } | 757 | } |
758 | 758 | ||
759 | void | 759 | static void |
760 | xfs_bmbt_read_verify( | 760 | xfs_bmbt_write_verify( |
761 | struct xfs_buf *bp) | 761 | struct xfs_buf *bp) |
762 | { | 762 | { |
763 | xfs_bmbt_verify(bp); | 763 | xfs_bmbt_verify(bp); |
764 | bp->b_pre_io = xfs_bmbt_write_verify; | ||
765 | bp->b_iodone = NULL; | ||
766 | xfs_buf_ioend(bp, 0); | ||
767 | } | 764 | } |
768 | 765 | ||
766 | const struct xfs_buf_ops xfs_bmbt_buf_ops = { | ||
767 | .verify_read = xfs_bmbt_read_verify, | ||
768 | .verify_write = xfs_bmbt_write_verify, | ||
769 | }; | ||
770 | |||
771 | |||
769 | #ifdef DEBUG | 772 | #ifdef DEBUG |
770 | STATIC int | 773 | STATIC int |
771 | xfs_bmbt_keys_inorder( | 774 | xfs_bmbt_keys_inorder( |
@@ -805,8 +808,7 @@ static const struct xfs_btree_ops xfs_bmbt_ops = { | |||
805 | .init_rec_from_cur = xfs_bmbt_init_rec_from_cur, | 808 | .init_rec_from_cur = xfs_bmbt_init_rec_from_cur, |
806 | .init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur, | 809 | .init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur, |
807 | .key_diff = xfs_bmbt_key_diff, | 810 | .key_diff = xfs_bmbt_key_diff, |
808 | .read_verify = xfs_bmbt_read_verify, | 811 | .buf_ops = &xfs_bmbt_buf_ops, |
809 | .write_verify = xfs_bmbt_write_verify, | ||
810 | #ifdef DEBUG | 812 | #ifdef DEBUG |
811 | .keys_inorder = xfs_bmbt_keys_inorder, | 813 | .keys_inorder = xfs_bmbt_keys_inorder, |
812 | .recs_inorder = xfs_bmbt_recs_inorder, | 814 | .recs_inorder = xfs_bmbt_recs_inorder, |
diff --git a/fs/xfs/xfs_bmap_btree.h b/fs/xfs/xfs_bmap_btree.h index 938c85986549..88469ca08696 100644 --- a/fs/xfs/xfs_bmap_btree.h +++ b/fs/xfs/xfs_bmap_btree.h | |||
@@ -232,11 +232,10 @@ extern void xfs_bmbt_to_bmdr(struct xfs_mount *, struct xfs_btree_block *, int, | |||
232 | extern int xfs_bmbt_get_maxrecs(struct xfs_btree_cur *, int level); | 232 | extern int xfs_bmbt_get_maxrecs(struct xfs_btree_cur *, int level); |
233 | extern int xfs_bmdr_maxrecs(struct xfs_mount *, int blocklen, int leaf); | 233 | extern int xfs_bmdr_maxrecs(struct xfs_mount *, int blocklen, int leaf); |
234 | extern int xfs_bmbt_maxrecs(struct xfs_mount *, int blocklen, int leaf); | 234 | extern int xfs_bmbt_maxrecs(struct xfs_mount *, int blocklen, int leaf); |
235 | extern void xfs_bmbt_read_verify(struct xfs_buf *bp); | ||
236 | extern void xfs_bmbt_write_verify(struct xfs_buf *bp); | ||
237 | 235 | ||
238 | extern struct xfs_btree_cur *xfs_bmbt_init_cursor(struct xfs_mount *, | 236 | extern struct xfs_btree_cur *xfs_bmbt_init_cursor(struct xfs_mount *, |
239 | struct xfs_trans *, struct xfs_inode *, int); | 237 | struct xfs_trans *, struct xfs_inode *, int); |
240 | 238 | ||
239 | extern const struct xfs_buf_ops xfs_bmbt_buf_ops; | ||
241 | 240 | ||
242 | #endif /* __XFS_BMAP_BTREE_H__ */ | 241 | #endif /* __XFS_BMAP_BTREE_H__ */ |
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/xfs_btree.c index 1e2d89eed2a4..db010408d701 100644 --- a/fs/xfs/xfs_btree.c +++ b/fs/xfs/xfs_btree.c | |||
@@ -271,7 +271,7 @@ xfs_btree_dup_cursor( | |||
271 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, | 271 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, |
272 | XFS_BUF_ADDR(bp), mp->m_bsize, | 272 | XFS_BUF_ADDR(bp), mp->m_bsize, |
273 | 0, &bp, | 273 | 0, &bp, |
274 | cur->bc_ops->read_verify); | 274 | cur->bc_ops->buf_ops); |
275 | if (error) { | 275 | if (error) { |
276 | xfs_btree_del_cursor(new, error); | 276 | xfs_btree_del_cursor(new, error); |
277 | *ncur = NULL; | 277 | *ncur = NULL; |
@@ -621,7 +621,7 @@ xfs_btree_read_bufl( | |||
621 | uint lock, /* lock flags for read_buf */ | 621 | uint lock, /* lock flags for read_buf */ |
622 | struct xfs_buf **bpp, /* buffer for fsbno */ | 622 | struct xfs_buf **bpp, /* buffer for fsbno */ |
623 | int refval, /* ref count value for buffer */ | 623 | int refval, /* ref count value for buffer */ |
624 | xfs_buf_iodone_t verify) | 624 | const struct xfs_buf_ops *ops) |
625 | { | 625 | { |
626 | struct xfs_buf *bp; /* return value */ | 626 | struct xfs_buf *bp; /* return value */ |
627 | xfs_daddr_t d; /* real disk block address */ | 627 | xfs_daddr_t d; /* real disk block address */ |
@@ -630,7 +630,7 @@ xfs_btree_read_bufl( | |||
630 | ASSERT(fsbno != NULLFSBLOCK); | 630 | ASSERT(fsbno != NULLFSBLOCK); |
631 | d = XFS_FSB_TO_DADDR(mp, fsbno); | 631 | d = XFS_FSB_TO_DADDR(mp, fsbno); |
632 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d, | 632 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d, |
633 | mp->m_bsize, lock, &bp, verify); | 633 | mp->m_bsize, lock, &bp, ops); |
634 | if (error) | 634 | if (error) |
635 | return error; | 635 | return error; |
636 | ASSERT(!xfs_buf_geterror(bp)); | 636 | ASSERT(!xfs_buf_geterror(bp)); |
@@ -650,13 +650,13 @@ xfs_btree_reada_bufl( | |||
650 | struct xfs_mount *mp, /* file system mount point */ | 650 | struct xfs_mount *mp, /* file system mount point */ |
651 | xfs_fsblock_t fsbno, /* file system block number */ | 651 | xfs_fsblock_t fsbno, /* file system block number */ |
652 | xfs_extlen_t count, /* count of filesystem blocks */ | 652 | xfs_extlen_t count, /* count of filesystem blocks */ |
653 | xfs_buf_iodone_t verify) | 653 | const struct xfs_buf_ops *ops) |
654 | { | 654 | { |
655 | xfs_daddr_t d; | 655 | xfs_daddr_t d; |
656 | 656 | ||
657 | ASSERT(fsbno != NULLFSBLOCK); | 657 | ASSERT(fsbno != NULLFSBLOCK); |
658 | d = XFS_FSB_TO_DADDR(mp, fsbno); | 658 | d = XFS_FSB_TO_DADDR(mp, fsbno); |
659 | xfs_buf_readahead(mp->m_ddev_targp, d, mp->m_bsize * count, verify); | 659 | xfs_buf_readahead(mp->m_ddev_targp, d, mp->m_bsize * count, ops); |
660 | } | 660 | } |
661 | 661 | ||
662 | /* | 662 | /* |
@@ -670,14 +670,14 @@ xfs_btree_reada_bufs( | |||
670 | xfs_agnumber_t agno, /* allocation group number */ | 670 | xfs_agnumber_t agno, /* allocation group number */ |
671 | xfs_agblock_t agbno, /* allocation group block number */ | 671 | xfs_agblock_t agbno, /* allocation group block number */ |
672 | xfs_extlen_t count, /* count of filesystem blocks */ | 672 | xfs_extlen_t count, /* count of filesystem blocks */ |
673 | xfs_buf_iodone_t verify) | 673 | const struct xfs_buf_ops *ops) |
674 | { | 674 | { |
675 | xfs_daddr_t d; | 675 | xfs_daddr_t d; |
676 | 676 | ||
677 | ASSERT(agno != NULLAGNUMBER); | 677 | ASSERT(agno != NULLAGNUMBER); |
678 | ASSERT(agbno != NULLAGBLOCK); | 678 | ASSERT(agbno != NULLAGBLOCK); |
679 | d = XFS_AGB_TO_DADDR(mp, agno, agbno); | 679 | d = XFS_AGB_TO_DADDR(mp, agno, agbno); |
680 | xfs_buf_readahead(mp->m_ddev_targp, d, mp->m_bsize * count, verify); | 680 | xfs_buf_readahead(mp->m_ddev_targp, d, mp->m_bsize * count, ops); |
681 | } | 681 | } |
682 | 682 | ||
683 | STATIC int | 683 | STATIC int |
@@ -692,13 +692,13 @@ xfs_btree_readahead_lblock( | |||
692 | 692 | ||
693 | if ((lr & XFS_BTCUR_LEFTRA) && left != NULLDFSBNO) { | 693 | if ((lr & XFS_BTCUR_LEFTRA) && left != NULLDFSBNO) { |
694 | xfs_btree_reada_bufl(cur->bc_mp, left, 1, | 694 | xfs_btree_reada_bufl(cur->bc_mp, left, 1, |
695 | cur->bc_ops->read_verify); | 695 | cur->bc_ops->buf_ops); |
696 | rval++; | 696 | rval++; |
697 | } | 697 | } |
698 | 698 | ||
699 | if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLDFSBNO) { | 699 | if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLDFSBNO) { |
700 | xfs_btree_reada_bufl(cur->bc_mp, right, 1, | 700 | xfs_btree_reada_bufl(cur->bc_mp, right, 1, |
701 | cur->bc_ops->read_verify); | 701 | cur->bc_ops->buf_ops); |
702 | rval++; | 702 | rval++; |
703 | } | 703 | } |
704 | 704 | ||
@@ -718,13 +718,13 @@ xfs_btree_readahead_sblock( | |||
718 | 718 | ||
719 | if ((lr & XFS_BTCUR_LEFTRA) && left != NULLAGBLOCK) { | 719 | if ((lr & XFS_BTCUR_LEFTRA) && left != NULLAGBLOCK) { |
720 | xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno, | 720 | xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno, |
721 | left, 1, cur->bc_ops->read_verify); | 721 | left, 1, cur->bc_ops->buf_ops); |
722 | rval++; | 722 | rval++; |
723 | } | 723 | } |
724 | 724 | ||
725 | if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLAGBLOCK) { | 725 | if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLAGBLOCK) { |
726 | xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno, | 726 | xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno, |
727 | right, 1, cur->bc_ops->read_verify); | 727 | right, 1, cur->bc_ops->buf_ops); |
728 | rval++; | 728 | rval++; |
729 | } | 729 | } |
730 | 730 | ||
@@ -996,7 +996,7 @@ xfs_btree_get_buf_block( | |||
996 | if (!*bpp) | 996 | if (!*bpp) |
997 | return ENOMEM; | 997 | return ENOMEM; |
998 | 998 | ||
999 | (*bpp)->b_pre_io = cur->bc_ops->write_verify; | 999 | (*bpp)->b_ops = cur->bc_ops->buf_ops; |
1000 | *block = XFS_BUF_TO_BLOCK(*bpp); | 1000 | *block = XFS_BUF_TO_BLOCK(*bpp); |
1001 | return 0; | 1001 | return 0; |
1002 | } | 1002 | } |
@@ -1024,7 +1024,7 @@ xfs_btree_read_buf_block( | |||
1024 | d = xfs_btree_ptr_to_daddr(cur, ptr); | 1024 | d = xfs_btree_ptr_to_daddr(cur, ptr); |
1025 | error = xfs_trans_read_buf(mp, cur->bc_tp, mp->m_ddev_targp, d, | 1025 | error = xfs_trans_read_buf(mp, cur->bc_tp, mp->m_ddev_targp, d, |
1026 | mp->m_bsize, flags, bpp, | 1026 | mp->m_bsize, flags, bpp, |
1027 | cur->bc_ops->read_verify); | 1027 | cur->bc_ops->buf_ops); |
1028 | if (error) | 1028 | if (error) |
1029 | return error; | 1029 | return error; |
1030 | 1030 | ||
diff --git a/fs/xfs/xfs_btree.h b/fs/xfs/xfs_btree.h index 458ab3550898..f932897194eb 100644 --- a/fs/xfs/xfs_btree.h +++ b/fs/xfs/xfs_btree.h | |||
@@ -188,8 +188,7 @@ struct xfs_btree_ops { | |||
188 | __int64_t (*key_diff)(struct xfs_btree_cur *cur, | 188 | __int64_t (*key_diff)(struct xfs_btree_cur *cur, |
189 | union xfs_btree_key *key); | 189 | union xfs_btree_key *key); |
190 | 190 | ||
191 | void (*read_verify)(struct xfs_buf *bp); | 191 | const struct xfs_buf_ops *buf_ops; |
192 | void (*write_verify)(struct xfs_buf *bp); | ||
193 | 192 | ||
194 | #ifdef DEBUG | 193 | #ifdef DEBUG |
195 | /* check that k1 is lower than k2 */ | 194 | /* check that k1 is lower than k2 */ |
@@ -359,7 +358,7 @@ xfs_btree_read_bufl( | |||
359 | uint lock, /* lock flags for read_buf */ | 358 | uint lock, /* lock flags for read_buf */ |
360 | struct xfs_buf **bpp, /* buffer for fsbno */ | 359 | struct xfs_buf **bpp, /* buffer for fsbno */ |
361 | int refval, /* ref count value for buffer */ | 360 | int refval, /* ref count value for buffer */ |
362 | xfs_buf_iodone_t verify); | 361 | const struct xfs_buf_ops *ops); |
363 | 362 | ||
364 | /* | 363 | /* |
365 | * Read-ahead the block, don't wait for it, don't return a buffer. | 364 | * Read-ahead the block, don't wait for it, don't return a buffer. |
@@ -370,7 +369,7 @@ xfs_btree_reada_bufl( | |||
370 | struct xfs_mount *mp, /* file system mount point */ | 369 | struct xfs_mount *mp, /* file system mount point */ |
371 | xfs_fsblock_t fsbno, /* file system block number */ | 370 | xfs_fsblock_t fsbno, /* file system block number */ |
372 | xfs_extlen_t count, /* count of filesystem blocks */ | 371 | xfs_extlen_t count, /* count of filesystem blocks */ |
373 | xfs_buf_iodone_t verify); | 372 | const struct xfs_buf_ops *ops); |
374 | 373 | ||
375 | /* | 374 | /* |
376 | * Read-ahead the block, don't wait for it, don't return a buffer. | 375 | * Read-ahead the block, don't wait for it, don't return a buffer. |
@@ -382,7 +381,7 @@ xfs_btree_reada_bufs( | |||
382 | xfs_agnumber_t agno, /* allocation group number */ | 381 | xfs_agnumber_t agno, /* allocation group number */ |
383 | xfs_agblock_t agbno, /* allocation group block number */ | 382 | xfs_agblock_t agbno, /* allocation group block number */ |
384 | xfs_extlen_t count, /* count of filesystem blocks */ | 383 | xfs_extlen_t count, /* count of filesystem blocks */ |
385 | xfs_buf_iodone_t verify); | 384 | const struct xfs_buf_ops *ops); |
386 | 385 | ||
387 | /* | 386 | /* |
388 | * Initialise a new btree block header | 387 | * Initialise a new btree block header |
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c index bd1a948ee39c..26673a0b20e7 100644 --- a/fs/xfs/xfs_buf.c +++ b/fs/xfs/xfs_buf.c | |||
@@ -571,7 +571,7 @@ found: | |||
571 | ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0); | 571 | ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0); |
572 | ASSERT(bp->b_iodone == NULL); | 572 | ASSERT(bp->b_iodone == NULL); |
573 | bp->b_flags &= _XBF_KMEM | _XBF_PAGES; | 573 | bp->b_flags &= _XBF_KMEM | _XBF_PAGES; |
574 | bp->b_pre_io = NULL; | 574 | bp->b_ops = NULL; |
575 | } | 575 | } |
576 | 576 | ||
577 | trace_xfs_buf_find(bp, flags, _RET_IP_); | 577 | trace_xfs_buf_find(bp, flags, _RET_IP_); |
@@ -657,7 +657,7 @@ xfs_buf_read_map( | |||
657 | struct xfs_buf_map *map, | 657 | struct xfs_buf_map *map, |
658 | int nmaps, | 658 | int nmaps, |
659 | xfs_buf_flags_t flags, | 659 | xfs_buf_flags_t flags, |
660 | xfs_buf_iodone_t verify) | 660 | const struct xfs_buf_ops *ops) |
661 | { | 661 | { |
662 | struct xfs_buf *bp; | 662 | struct xfs_buf *bp; |
663 | 663 | ||
@@ -669,7 +669,7 @@ xfs_buf_read_map( | |||
669 | 669 | ||
670 | if (!XFS_BUF_ISDONE(bp)) { | 670 | if (!XFS_BUF_ISDONE(bp)) { |
671 | XFS_STATS_INC(xb_get_read); | 671 | XFS_STATS_INC(xb_get_read); |
672 | bp->b_iodone = verify; | 672 | bp->b_ops = ops; |
673 | _xfs_buf_read(bp, flags); | 673 | _xfs_buf_read(bp, flags); |
674 | } else if (flags & XBF_ASYNC) { | 674 | } else if (flags & XBF_ASYNC) { |
675 | /* | 675 | /* |
@@ -696,13 +696,13 @@ xfs_buf_readahead_map( | |||
696 | struct xfs_buftarg *target, | 696 | struct xfs_buftarg *target, |
697 | struct xfs_buf_map *map, | 697 | struct xfs_buf_map *map, |
698 | int nmaps, | 698 | int nmaps, |
699 | xfs_buf_iodone_t verify) | 699 | const struct xfs_buf_ops *ops) |
700 | { | 700 | { |
701 | if (bdi_read_congested(target->bt_bdi)) | 701 | if (bdi_read_congested(target->bt_bdi)) |
702 | return; | 702 | return; |
703 | 703 | ||
704 | xfs_buf_read_map(target, map, nmaps, | 704 | xfs_buf_read_map(target, map, nmaps, |
705 | XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, verify); | 705 | XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops); |
706 | } | 706 | } |
707 | 707 | ||
708 | /* | 708 | /* |
@@ -715,7 +715,7 @@ xfs_buf_read_uncached( | |||
715 | xfs_daddr_t daddr, | 715 | xfs_daddr_t daddr, |
716 | size_t numblks, | 716 | size_t numblks, |
717 | int flags, | 717 | int flags, |
718 | xfs_buf_iodone_t verify) | 718 | const struct xfs_buf_ops *ops) |
719 | { | 719 | { |
720 | struct xfs_buf *bp; | 720 | struct xfs_buf *bp; |
721 | 721 | ||
@@ -728,7 +728,7 @@ xfs_buf_read_uncached( | |||
728 | bp->b_bn = daddr; | 728 | bp->b_bn = daddr; |
729 | bp->b_maps[0].bm_bn = daddr; | 729 | bp->b_maps[0].bm_bn = daddr; |
730 | bp->b_flags |= XBF_READ; | 730 | bp->b_flags |= XBF_READ; |
731 | bp->b_iodone = verify; | 731 | bp->b_ops = ops; |
732 | 732 | ||
733 | xfsbdstrat(target->bt_mount, bp); | 733 | xfsbdstrat(target->bt_mount, bp); |
734 | xfs_buf_iowait(bp); | 734 | xfs_buf_iowait(bp); |
@@ -1001,27 +1001,37 @@ STATIC void | |||
1001 | xfs_buf_iodone_work( | 1001 | xfs_buf_iodone_work( |
1002 | struct work_struct *work) | 1002 | struct work_struct *work) |
1003 | { | 1003 | { |
1004 | xfs_buf_t *bp = | 1004 | struct xfs_buf *bp = |
1005 | container_of(work, xfs_buf_t, b_iodone_work); | 1005 | container_of(work, xfs_buf_t, b_iodone_work); |
1006 | bool read = !!(bp->b_flags & XBF_READ); | ||
1007 | |||
1008 | bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD); | ||
1009 | if (read && bp->b_ops) | ||
1010 | bp->b_ops->verify_read(bp); | ||
1006 | 1011 | ||
1007 | if (bp->b_iodone) | 1012 | if (bp->b_iodone) |
1008 | (*(bp->b_iodone))(bp); | 1013 | (*(bp->b_iodone))(bp); |
1009 | else if (bp->b_flags & XBF_ASYNC) | 1014 | else if (bp->b_flags & XBF_ASYNC) |
1010 | xfs_buf_relse(bp); | 1015 | xfs_buf_relse(bp); |
1016 | else { | ||
1017 | ASSERT(read && bp->b_ops); | ||
1018 | complete(&bp->b_iowait); | ||
1019 | } | ||
1011 | } | 1020 | } |
1012 | 1021 | ||
1013 | void | 1022 | void |
1014 | xfs_buf_ioend( | 1023 | xfs_buf_ioend( |
1015 | xfs_buf_t *bp, | 1024 | struct xfs_buf *bp, |
1016 | int schedule) | 1025 | int schedule) |
1017 | { | 1026 | { |
1027 | bool read = !!(bp->b_flags & XBF_READ); | ||
1028 | |||
1018 | trace_xfs_buf_iodone(bp, _RET_IP_); | 1029 | trace_xfs_buf_iodone(bp, _RET_IP_); |
1019 | 1030 | ||
1020 | bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD); | ||
1021 | if (bp->b_error == 0) | 1031 | if (bp->b_error == 0) |
1022 | bp->b_flags |= XBF_DONE; | 1032 | bp->b_flags |= XBF_DONE; |
1023 | 1033 | ||
1024 | if ((bp->b_iodone) || (bp->b_flags & XBF_ASYNC)) { | 1034 | if (bp->b_iodone || (read && bp->b_ops) || (bp->b_flags & XBF_ASYNC)) { |
1025 | if (schedule) { | 1035 | if (schedule) { |
1026 | INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work); | 1036 | INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work); |
1027 | queue_work(xfslogd_workqueue, &bp->b_iodone_work); | 1037 | queue_work(xfslogd_workqueue, &bp->b_iodone_work); |
@@ -1029,6 +1039,7 @@ xfs_buf_ioend( | |||
1029 | xfs_buf_iodone_work(&bp->b_iodone_work); | 1039 | xfs_buf_iodone_work(&bp->b_iodone_work); |
1030 | } | 1040 | } |
1031 | } else { | 1041 | } else { |
1042 | bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD); | ||
1032 | complete(&bp->b_iowait); | 1043 | complete(&bp->b_iowait); |
1033 | } | 1044 | } |
1034 | } | 1045 | } |
@@ -1316,6 +1327,20 @@ _xfs_buf_ioapply( | |||
1316 | rw |= REQ_FUA; | 1327 | rw |= REQ_FUA; |
1317 | if (bp->b_flags & XBF_FLUSH) | 1328 | if (bp->b_flags & XBF_FLUSH) |
1318 | rw |= REQ_FLUSH; | 1329 | rw |= REQ_FLUSH; |
1330 | |||
1331 | /* | ||
1332 | * Run the write verifier callback function if it exists. If | ||
1333 | * this function fails it will mark the buffer with an error and | ||
1334 | * the IO should not be dispatched. | ||
1335 | */ | ||
1336 | if (bp->b_ops) { | ||
1337 | bp->b_ops->verify_write(bp); | ||
1338 | if (bp->b_error) { | ||
1339 | xfs_force_shutdown(bp->b_target->bt_mount, | ||
1340 | SHUTDOWN_CORRUPT_INCORE); | ||
1341 | return; | ||
1342 | } | ||
1343 | } | ||
1319 | } else if (bp->b_flags & XBF_READ_AHEAD) { | 1344 | } else if (bp->b_flags & XBF_READ_AHEAD) { |
1320 | rw = READA; | 1345 | rw = READA; |
1321 | } else { | 1346 | } else { |
@@ -1326,20 +1351,6 @@ _xfs_buf_ioapply( | |||
1326 | rw |= REQ_META; | 1351 | rw |= REQ_META; |
1327 | 1352 | ||
1328 | /* | 1353 | /* |
1329 | * run the pre-io callback function if it exists. If this function | ||
1330 | * fails it will mark the buffer with an error and the IO should | ||
1331 | * not be dispatched. | ||
1332 | */ | ||
1333 | if (bp->b_pre_io) { | ||
1334 | bp->b_pre_io(bp); | ||
1335 | if (bp->b_error) { | ||
1336 | xfs_force_shutdown(bp->b_target->bt_mount, | ||
1337 | SHUTDOWN_CORRUPT_INCORE); | ||
1338 | return; | ||
1339 | } | ||
1340 | } | ||
1341 | |||
1342 | /* | ||
1343 | * Walk all the vectors issuing IO on them. Set up the initial offset | 1354 | * Walk all the vectors issuing IO on them. Set up the initial offset |
1344 | * into the buffer and the desired IO size before we start - | 1355 | * into the buffer and the desired IO size before we start - |
1345 | * _xfs_buf_ioapply_vec() will modify them appropriately for each | 1356 | * _xfs_buf_ioapply_vec() will modify them appropriately for each |
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h index 51bc16a1cd9c..23f5642480bb 100644 --- a/fs/xfs/xfs_buf.h +++ b/fs/xfs/xfs_buf.h | |||
@@ -111,6 +111,11 @@ struct xfs_buf_map { | |||
111 | #define DEFINE_SINGLE_BUF_MAP(map, blkno, numblk) \ | 111 | #define DEFINE_SINGLE_BUF_MAP(map, blkno, numblk) \ |
112 | struct xfs_buf_map (map) = { .bm_bn = (blkno), .bm_len = (numblk) }; | 112 | struct xfs_buf_map (map) = { .bm_bn = (blkno), .bm_len = (numblk) }; |
113 | 113 | ||
114 | struct xfs_buf_ops { | ||
115 | void (*verify_read)(struct xfs_buf *); | ||
116 | void (*verify_write)(struct xfs_buf *); | ||
117 | }; | ||
118 | |||
114 | typedef struct xfs_buf { | 119 | typedef struct xfs_buf { |
115 | /* | 120 | /* |
116 | * first cacheline holds all the fields needed for an uncontended cache | 121 | * first cacheline holds all the fields needed for an uncontended cache |
@@ -154,9 +159,7 @@ typedef struct xfs_buf { | |||
154 | unsigned int b_page_count; /* size of page array */ | 159 | unsigned int b_page_count; /* size of page array */ |
155 | unsigned int b_offset; /* page offset in first page */ | 160 | unsigned int b_offset; /* page offset in first page */ |
156 | unsigned short b_error; /* error code on I/O */ | 161 | unsigned short b_error; /* error code on I/O */ |
157 | 162 | const struct xfs_buf_ops *b_ops; | |
158 | void (*b_pre_io)(struct xfs_buf *); | ||
159 | /* pre-io callback function */ | ||
160 | 163 | ||
161 | #ifdef XFS_BUF_LOCK_TRACKING | 164 | #ifdef XFS_BUF_LOCK_TRACKING |
162 | int b_last_holder; | 165 | int b_last_holder; |
@@ -199,10 +202,11 @@ struct xfs_buf *xfs_buf_get_map(struct xfs_buftarg *target, | |||
199 | xfs_buf_flags_t flags); | 202 | xfs_buf_flags_t flags); |
200 | struct xfs_buf *xfs_buf_read_map(struct xfs_buftarg *target, | 203 | struct xfs_buf *xfs_buf_read_map(struct xfs_buftarg *target, |
201 | struct xfs_buf_map *map, int nmaps, | 204 | struct xfs_buf_map *map, int nmaps, |
202 | xfs_buf_flags_t flags, xfs_buf_iodone_t verify); | 205 | xfs_buf_flags_t flags, |
206 | const struct xfs_buf_ops *ops); | ||
203 | void xfs_buf_readahead_map(struct xfs_buftarg *target, | 207 | void xfs_buf_readahead_map(struct xfs_buftarg *target, |
204 | struct xfs_buf_map *map, int nmaps, | 208 | struct xfs_buf_map *map, int nmaps, |
205 | xfs_buf_iodone_t verify); | 209 | const struct xfs_buf_ops *ops); |
206 | 210 | ||
207 | static inline struct xfs_buf * | 211 | static inline struct xfs_buf * |
208 | xfs_buf_get( | 212 | xfs_buf_get( |
@@ -221,10 +225,10 @@ xfs_buf_read( | |||
221 | xfs_daddr_t blkno, | 225 | xfs_daddr_t blkno, |
222 | size_t numblks, | 226 | size_t numblks, |
223 | xfs_buf_flags_t flags, | 227 | xfs_buf_flags_t flags, |
224 | xfs_buf_iodone_t verify) | 228 | const struct xfs_buf_ops *ops) |
225 | { | 229 | { |
226 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); | 230 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); |
227 | return xfs_buf_read_map(target, &map, 1, flags, verify); | 231 | return xfs_buf_read_map(target, &map, 1, flags, ops); |
228 | } | 232 | } |
229 | 233 | ||
230 | static inline void | 234 | static inline void |
@@ -232,10 +236,10 @@ xfs_buf_readahead( | |||
232 | struct xfs_buftarg *target, | 236 | struct xfs_buftarg *target, |
233 | xfs_daddr_t blkno, | 237 | xfs_daddr_t blkno, |
234 | size_t numblks, | 238 | size_t numblks, |
235 | xfs_buf_iodone_t verify) | 239 | const struct xfs_buf_ops *ops) |
236 | { | 240 | { |
237 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); | 241 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); |
238 | return xfs_buf_readahead_map(target, &map, 1, verify); | 242 | return xfs_buf_readahead_map(target, &map, 1, ops); |
239 | } | 243 | } |
240 | 244 | ||
241 | struct xfs_buf *xfs_buf_get_empty(struct xfs_buftarg *target, size_t numblks); | 245 | struct xfs_buf *xfs_buf_get_empty(struct xfs_buftarg *target, size_t numblks); |
@@ -246,7 +250,7 @@ struct xfs_buf *xfs_buf_get_uncached(struct xfs_buftarg *target, size_t numblks, | |||
246 | int flags); | 250 | int flags); |
247 | struct xfs_buf *xfs_buf_read_uncached(struct xfs_buftarg *target, | 251 | struct xfs_buf *xfs_buf_read_uncached(struct xfs_buftarg *target, |
248 | xfs_daddr_t daddr, size_t numblks, int flags, | 252 | xfs_daddr_t daddr, size_t numblks, int flags, |
249 | xfs_buf_iodone_t verify); | 253 | const struct xfs_buf_ops *ops); |
250 | void xfs_buf_hold(struct xfs_buf *bp); | 254 | void xfs_buf_hold(struct xfs_buf *bp); |
251 | 255 | ||
252 | /* Releasing Buffers */ | 256 | /* Releasing Buffers */ |
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c index 087950fc2eb7..4d7696a02418 100644 --- a/fs/xfs/xfs_da_btree.c +++ b/fs/xfs/xfs_da_btree.c | |||
@@ -117,6 +117,12 @@ xfs_da_node_write_verify( | |||
117 | xfs_da_node_verify(bp); | 117 | xfs_da_node_verify(bp); |
118 | } | 118 | } |
119 | 119 | ||
120 | /* | ||
121 | * leaf/node format detection on trees is sketchy, so a node read can be done on | ||
122 | * leaf level blocks when detection identifies the tree as a node format tree | ||
123 | * incorrectly. In this case, we need to swap the verifier to match the correct | ||
124 | * format of the block being read. | ||
125 | */ | ||
120 | static void | 126 | static void |
121 | xfs_da_node_read_verify( | 127 | xfs_da_node_read_verify( |
122 | struct xfs_buf *bp) | 128 | struct xfs_buf *bp) |
@@ -129,10 +135,12 @@ xfs_da_node_read_verify( | |||
129 | xfs_da_node_verify(bp); | 135 | xfs_da_node_verify(bp); |
130 | break; | 136 | break; |
131 | case XFS_ATTR_LEAF_MAGIC: | 137 | case XFS_ATTR_LEAF_MAGIC: |
132 | xfs_attr_leaf_read_verify(bp); | 138 | bp->b_ops = &xfs_attr_leaf_buf_ops; |
139 | bp->b_ops->verify_read(bp); | ||
133 | return; | 140 | return; |
134 | case XFS_DIR2_LEAFN_MAGIC: | 141 | case XFS_DIR2_LEAFN_MAGIC: |
135 | xfs_dir2_leafn_read_verify(bp); | 142 | bp->b_ops = &xfs_dir2_leafn_buf_ops; |
143 | bp->b_ops->verify_read(bp); | ||
136 | return; | 144 | return; |
137 | default: | 145 | default: |
138 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | 146 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, |
@@ -140,12 +148,14 @@ xfs_da_node_read_verify( | |||
140 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 148 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
141 | break; | 149 | break; |
142 | } | 150 | } |
143 | |||
144 | bp->b_pre_io = xfs_da_node_write_verify; | ||
145 | bp->b_iodone = NULL; | ||
146 | xfs_buf_ioend(bp, 0); | ||
147 | } | 151 | } |
148 | 152 | ||
153 | const struct xfs_buf_ops xfs_da_node_buf_ops = { | ||
154 | .verify_read = xfs_da_node_read_verify, | ||
155 | .verify_write = xfs_da_node_write_verify, | ||
156 | }; | ||
157 | |||
158 | |||
149 | int | 159 | int |
150 | xfs_da_node_read( | 160 | xfs_da_node_read( |
151 | struct xfs_trans *tp, | 161 | struct xfs_trans *tp, |
@@ -156,7 +166,7 @@ xfs_da_node_read( | |||
156 | int which_fork) | 166 | int which_fork) |
157 | { | 167 | { |
158 | return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp, | 168 | return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp, |
159 | which_fork, xfs_da_node_read_verify); | 169 | which_fork, &xfs_da_node_buf_ops); |
160 | } | 170 | } |
161 | 171 | ||
162 | /*======================================================================== | 172 | /*======================================================================== |
@@ -193,7 +203,7 @@ xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level, | |||
193 | xfs_trans_log_buf(tp, bp, | 203 | xfs_trans_log_buf(tp, bp, |
194 | XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr))); | 204 | XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr))); |
195 | 205 | ||
196 | bp->b_pre_io = xfs_da_node_write_verify; | 206 | bp->b_ops = &xfs_da_node_buf_ops; |
197 | *bpp = bp; | 207 | *bpp = bp; |
198 | return(0); | 208 | return(0); |
199 | } | 209 | } |
@@ -394,7 +404,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1, | |||
394 | memcpy(node, oldroot, size); | 404 | memcpy(node, oldroot, size); |
395 | xfs_trans_log_buf(tp, bp, 0, size - 1); | 405 | xfs_trans_log_buf(tp, bp, 0, size - 1); |
396 | 406 | ||
397 | bp->b_pre_io = blk1->bp->b_pre_io; | 407 | bp->b_ops = blk1->bp->b_ops; |
398 | blk1->bp = bp; | 408 | blk1->bp = bp; |
399 | blk1->blkno = blkno; | 409 | blk1->blkno = blkno; |
400 | 410 | ||
@@ -828,11 +838,11 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk) | |||
828 | /* | 838 | /* |
829 | * This could be copying a leaf back into the root block in the case of | 839 | * This could be copying a leaf back into the root block in the case of |
830 | * there only being a single leaf block left in the tree. Hence we have | 840 | * there only being a single leaf block left in the tree. Hence we have |
831 | * to update the pre_io pointer as well to match the buffer type change | 841 | * to update the b_ops pointer as well to match the buffer type change |
832 | * that could occur. | 842 | * that could occur. |
833 | */ | 843 | */ |
834 | memcpy(root_blk->bp->b_addr, bp->b_addr, state->blocksize); | 844 | memcpy(root_blk->bp->b_addr, bp->b_addr, state->blocksize); |
835 | root_blk->bp->b_pre_io = bp->b_pre_io; | 845 | root_blk->bp->b_ops = bp->b_ops; |
836 | xfs_trans_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1); | 846 | xfs_trans_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1); |
837 | error = xfs_da_shrink_inode(args, child, bp); | 847 | error = xfs_da_shrink_inode(args, child, bp); |
838 | return(error); | 848 | return(error); |
@@ -2223,7 +2233,7 @@ xfs_da_read_buf( | |||
2223 | xfs_daddr_t mappedbno, | 2233 | xfs_daddr_t mappedbno, |
2224 | struct xfs_buf **bpp, | 2234 | struct xfs_buf **bpp, |
2225 | int whichfork, | 2235 | int whichfork, |
2226 | xfs_buf_iodone_t verifier) | 2236 | const struct xfs_buf_ops *ops) |
2227 | { | 2237 | { |
2228 | struct xfs_buf *bp; | 2238 | struct xfs_buf *bp; |
2229 | struct xfs_buf_map map; | 2239 | struct xfs_buf_map map; |
@@ -2245,7 +2255,7 @@ xfs_da_read_buf( | |||
2245 | 2255 | ||
2246 | error = xfs_trans_read_buf_map(dp->i_mount, trans, | 2256 | error = xfs_trans_read_buf_map(dp->i_mount, trans, |
2247 | dp->i_mount->m_ddev_targp, | 2257 | dp->i_mount->m_ddev_targp, |
2248 | mapp, nmap, 0, &bp, verifier); | 2258 | mapp, nmap, 0, &bp, ops); |
2249 | if (error) | 2259 | if (error) |
2250 | goto out_free; | 2260 | goto out_free; |
2251 | 2261 | ||
@@ -2303,7 +2313,7 @@ xfs_da_reada_buf( | |||
2303 | xfs_dablk_t bno, | 2313 | xfs_dablk_t bno, |
2304 | xfs_daddr_t mappedbno, | 2314 | xfs_daddr_t mappedbno, |
2305 | int whichfork, | 2315 | int whichfork, |
2306 | xfs_buf_iodone_t verifier) | 2316 | const struct xfs_buf_ops *ops) |
2307 | { | 2317 | { |
2308 | struct xfs_buf_map map; | 2318 | struct xfs_buf_map map; |
2309 | struct xfs_buf_map *mapp; | 2319 | struct xfs_buf_map *mapp; |
@@ -2322,7 +2332,7 @@ xfs_da_reada_buf( | |||
2322 | } | 2332 | } |
2323 | 2333 | ||
2324 | mappedbno = mapp[0].bm_bn; | 2334 | mappedbno = mapp[0].bm_bn; |
2325 | xfs_buf_readahead_map(dp->i_mount->m_ddev_targp, mapp, nmap, NULL); | 2335 | xfs_buf_readahead_map(dp->i_mount->m_ddev_targp, mapp, nmap, ops); |
2326 | 2336 | ||
2327 | out_free: | 2337 | out_free: |
2328 | if (mapp != &map) | 2338 | if (mapp != &map) |
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h index 521b008445ab..ee5170c46ae1 100644 --- a/fs/xfs/xfs_da_btree.h +++ b/fs/xfs/xfs_da_btree.h | |||
@@ -229,10 +229,10 @@ int xfs_da_get_buf(struct xfs_trans *trans, struct xfs_inode *dp, | |||
229 | int xfs_da_read_buf(struct xfs_trans *trans, struct xfs_inode *dp, | 229 | int xfs_da_read_buf(struct xfs_trans *trans, struct xfs_inode *dp, |
230 | xfs_dablk_t bno, xfs_daddr_t mappedbno, | 230 | xfs_dablk_t bno, xfs_daddr_t mappedbno, |
231 | struct xfs_buf **bpp, int whichfork, | 231 | struct xfs_buf **bpp, int whichfork, |
232 | xfs_buf_iodone_t verifier); | 232 | const struct xfs_buf_ops *ops); |
233 | xfs_daddr_t xfs_da_reada_buf(struct xfs_trans *trans, struct xfs_inode *dp, | 233 | xfs_daddr_t xfs_da_reada_buf(struct xfs_trans *trans, struct xfs_inode *dp, |
234 | xfs_dablk_t bno, xfs_daddr_t mapped_bno, | 234 | xfs_dablk_t bno, xfs_daddr_t mapped_bno, |
235 | int whichfork, xfs_buf_iodone_t verifier); | 235 | int whichfork, const struct xfs_buf_ops *ops); |
236 | int xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno, | 236 | int xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno, |
237 | struct xfs_buf *dead_buf); | 237 | struct xfs_buf *dead_buf); |
238 | 238 | ||
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c index e2fdc6f03d8a..7536faaa61e7 100644 --- a/fs/xfs/xfs_dir2_block.c +++ b/fs/xfs/xfs_dir2_block.c | |||
@@ -74,22 +74,24 @@ xfs_dir2_block_verify( | |||
74 | } | 74 | } |
75 | 75 | ||
76 | static void | 76 | static void |
77 | xfs_dir2_block_write_verify( | 77 | xfs_dir2_block_read_verify( |
78 | struct xfs_buf *bp) | 78 | struct xfs_buf *bp) |
79 | { | 79 | { |
80 | xfs_dir2_block_verify(bp); | 80 | xfs_dir2_block_verify(bp); |
81 | } | 81 | } |
82 | 82 | ||
83 | void | 83 | static void |
84 | xfs_dir2_block_read_verify( | 84 | xfs_dir2_block_write_verify( |
85 | struct xfs_buf *bp) | 85 | struct xfs_buf *bp) |
86 | { | 86 | { |
87 | xfs_dir2_block_verify(bp); | 87 | xfs_dir2_block_verify(bp); |
88 | bp->b_pre_io = xfs_dir2_block_write_verify; | ||
89 | bp->b_iodone = NULL; | ||
90 | xfs_buf_ioend(bp, 0); | ||
91 | } | 88 | } |
92 | 89 | ||
90 | const struct xfs_buf_ops xfs_dir2_block_buf_ops = { | ||
91 | .verify_read = xfs_dir2_block_read_verify, | ||
92 | .verify_write = xfs_dir2_block_write_verify, | ||
93 | }; | ||
94 | |||
93 | static int | 95 | static int |
94 | xfs_dir2_block_read( | 96 | xfs_dir2_block_read( |
95 | struct xfs_trans *tp, | 97 | struct xfs_trans *tp, |
@@ -99,7 +101,7 @@ xfs_dir2_block_read( | |||
99 | struct xfs_mount *mp = dp->i_mount; | 101 | struct xfs_mount *mp = dp->i_mount; |
100 | 102 | ||
101 | return xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, bpp, | 103 | return xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, bpp, |
102 | XFS_DATA_FORK, xfs_dir2_block_read_verify); | 104 | XFS_DATA_FORK, &xfs_dir2_block_buf_ops); |
103 | } | 105 | } |
104 | 106 | ||
105 | static void | 107 | static void |
@@ -1010,7 +1012,7 @@ xfs_dir2_leaf_to_block( | |||
1010 | /* | 1012 | /* |
1011 | * Start converting it to block form. | 1013 | * Start converting it to block form. |
1012 | */ | 1014 | */ |
1013 | dbp->b_pre_io = xfs_dir2_block_write_verify; | 1015 | dbp->b_ops = &xfs_dir2_block_buf_ops; |
1014 | hdr->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC); | 1016 | hdr->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC); |
1015 | needlog = 1; | 1017 | needlog = 1; |
1016 | needscan = 0; | 1018 | needscan = 0; |
@@ -1140,7 +1142,7 @@ xfs_dir2_sf_to_block( | |||
1140 | kmem_free(sfp); | 1142 | kmem_free(sfp); |
1141 | return error; | 1143 | return error; |
1142 | } | 1144 | } |
1143 | bp->b_pre_io = xfs_dir2_block_write_verify; | 1145 | bp->b_ops = &xfs_dir2_block_buf_ops; |
1144 | hdr = bp->b_addr; | 1146 | hdr = bp->b_addr; |
1145 | hdr->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC); | 1147 | hdr->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC); |
1146 | /* | 1148 | /* |
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c index dcb8a873ab92..ffcf1774152e 100644 --- a/fs/xfs/xfs_dir2_data.c +++ b/fs/xfs/xfs_dir2_data.c | |||
@@ -202,23 +202,57 @@ xfs_dir2_data_verify( | |||
202 | } | 202 | } |
203 | } | 203 | } |
204 | 204 | ||
205 | void | 205 | /* |
206 | xfs_dir2_data_write_verify( | 206 | * Readahead of the first block of the directory when it is opened is completely |
207 | * oblivious to the format of the directory. Hence we can either get a block | ||
208 | * format buffer or a data format buffer on readahead. | ||
209 | */ | ||
210 | static void | ||
211 | xfs_dir2_data_reada_verify( | ||
212 | struct xfs_buf *bp) | ||
213 | { | ||
214 | struct xfs_mount *mp = bp->b_target->bt_mount; | ||
215 | struct xfs_dir2_data_hdr *hdr = bp->b_addr; | ||
216 | |||
217 | switch (hdr->magic) { | ||
218 | case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC): | ||
219 | bp->b_ops = &xfs_dir2_block_buf_ops; | ||
220 | bp->b_ops->verify_read(bp); | ||
221 | return; | ||
222 | case cpu_to_be32(XFS_DIR2_DATA_MAGIC): | ||
223 | xfs_dir2_data_verify(bp); | ||
224 | return; | ||
225 | default: | ||
226 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, hdr); | ||
227 | xfs_buf_ioerror(bp, EFSCORRUPTED); | ||
228 | break; | ||
229 | } | ||
230 | } | ||
231 | |||
232 | static void | ||
233 | xfs_dir2_data_read_verify( | ||
207 | struct xfs_buf *bp) | 234 | struct xfs_buf *bp) |
208 | { | 235 | { |
209 | xfs_dir2_data_verify(bp); | 236 | xfs_dir2_data_verify(bp); |
210 | } | 237 | } |
211 | 238 | ||
212 | static void | 239 | static void |
213 | xfs_dir2_data_read_verify( | 240 | xfs_dir2_data_write_verify( |
214 | struct xfs_buf *bp) | 241 | struct xfs_buf *bp) |
215 | { | 242 | { |
216 | xfs_dir2_data_verify(bp); | 243 | xfs_dir2_data_verify(bp); |
217 | bp->b_pre_io = xfs_dir2_data_write_verify; | ||
218 | bp->b_iodone = NULL; | ||
219 | xfs_buf_ioend(bp, 0); | ||
220 | } | 244 | } |
221 | 245 | ||
246 | const struct xfs_buf_ops xfs_dir2_data_buf_ops = { | ||
247 | .verify_read = xfs_dir2_data_read_verify, | ||
248 | .verify_write = xfs_dir2_data_write_verify, | ||
249 | }; | ||
250 | |||
251 | static const struct xfs_buf_ops xfs_dir2_data_reada_buf_ops = { | ||
252 | .verify_read = xfs_dir2_data_reada_verify, | ||
253 | .verify_write = xfs_dir2_data_write_verify, | ||
254 | }; | ||
255 | |||
222 | 256 | ||
223 | int | 257 | int |
224 | xfs_dir2_data_read( | 258 | xfs_dir2_data_read( |
@@ -229,7 +263,7 @@ xfs_dir2_data_read( | |||
229 | struct xfs_buf **bpp) | 263 | struct xfs_buf **bpp) |
230 | { | 264 | { |
231 | return xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp, | 265 | return xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp, |
232 | XFS_DATA_FORK, xfs_dir2_data_read_verify); | 266 | XFS_DATA_FORK, &xfs_dir2_data_buf_ops); |
233 | } | 267 | } |
234 | 268 | ||
235 | int | 269 | int |
@@ -240,7 +274,7 @@ xfs_dir2_data_readahead( | |||
240 | xfs_daddr_t mapped_bno) | 274 | xfs_daddr_t mapped_bno) |
241 | { | 275 | { |
242 | return xfs_da_reada_buf(tp, dp, bno, mapped_bno, | 276 | return xfs_da_reada_buf(tp, dp, bno, mapped_bno, |
243 | XFS_DATA_FORK, xfs_dir2_data_read_verify); | 277 | XFS_DATA_FORK, &xfs_dir2_data_reada_buf_ops); |
244 | } | 278 | } |
245 | 279 | ||
246 | /* | 280 | /* |
@@ -484,7 +518,7 @@ xfs_dir2_data_init( | |||
484 | XFS_DATA_FORK); | 518 | XFS_DATA_FORK); |
485 | if (error) | 519 | if (error) |
486 | return error; | 520 | return error; |
487 | bp->b_pre_io = xfs_dir2_data_write_verify; | 521 | bp->b_ops = &xfs_dir2_data_buf_ops; |
488 | 522 | ||
489 | /* | 523 | /* |
490 | * Initialize the header. | 524 | * Initialize the header. |
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c index 3002ab7d54c3..60cd2fa4e047 100644 --- a/fs/xfs/xfs_dir2_leaf.c +++ b/fs/xfs/xfs_dir2_leaf.c | |||
@@ -65,39 +65,43 @@ xfs_dir2_leaf_verify( | |||
65 | } | 65 | } |
66 | 66 | ||
67 | static void | 67 | static void |
68 | xfs_dir2_leaf1_write_verify( | 68 | xfs_dir2_leaf1_read_verify( |
69 | struct xfs_buf *bp) | 69 | struct xfs_buf *bp) |
70 | { | 70 | { |
71 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAF1_MAGIC)); | 71 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAF1_MAGIC)); |
72 | } | 72 | } |
73 | 73 | ||
74 | static void | 74 | static void |
75 | xfs_dir2_leaf1_read_verify( | 75 | xfs_dir2_leaf1_write_verify( |
76 | struct xfs_buf *bp) | 76 | struct xfs_buf *bp) |
77 | { | 77 | { |
78 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAF1_MAGIC)); | 78 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAF1_MAGIC)); |
79 | bp->b_pre_io = xfs_dir2_leaf1_write_verify; | ||
80 | bp->b_iodone = NULL; | ||
81 | xfs_buf_ioend(bp, 0); | ||
82 | } | 79 | } |
83 | 80 | ||
84 | void | 81 | void |
85 | xfs_dir2_leafn_write_verify( | 82 | xfs_dir2_leafn_read_verify( |
86 | struct xfs_buf *bp) | 83 | struct xfs_buf *bp) |
87 | { | 84 | { |
88 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAFN_MAGIC)); | 85 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAFN_MAGIC)); |
89 | } | 86 | } |
90 | 87 | ||
91 | void | 88 | void |
92 | xfs_dir2_leafn_read_verify( | 89 | xfs_dir2_leafn_write_verify( |
93 | struct xfs_buf *bp) | 90 | struct xfs_buf *bp) |
94 | { | 91 | { |
95 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAFN_MAGIC)); | 92 | xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAFN_MAGIC)); |
96 | bp->b_pre_io = xfs_dir2_leafn_write_verify; | ||
97 | bp->b_iodone = NULL; | ||
98 | xfs_buf_ioend(bp, 0); | ||
99 | } | 93 | } |
100 | 94 | ||
95 | static const struct xfs_buf_ops xfs_dir2_leaf1_buf_ops = { | ||
96 | .verify_read = xfs_dir2_leaf1_read_verify, | ||
97 | .verify_write = xfs_dir2_leaf1_write_verify, | ||
98 | }; | ||
99 | |||
100 | const struct xfs_buf_ops xfs_dir2_leafn_buf_ops = { | ||
101 | .verify_read = xfs_dir2_leafn_read_verify, | ||
102 | .verify_write = xfs_dir2_leafn_write_verify, | ||
103 | }; | ||
104 | |||
101 | static int | 105 | static int |
102 | xfs_dir2_leaf_read( | 106 | xfs_dir2_leaf_read( |
103 | struct xfs_trans *tp, | 107 | struct xfs_trans *tp, |
@@ -107,7 +111,7 @@ xfs_dir2_leaf_read( | |||
107 | struct xfs_buf **bpp) | 111 | struct xfs_buf **bpp) |
108 | { | 112 | { |
109 | return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, | 113 | return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, |
110 | XFS_DATA_FORK, xfs_dir2_leaf1_read_verify); | 114 | XFS_DATA_FORK, &xfs_dir2_leaf1_buf_ops); |
111 | } | 115 | } |
112 | 116 | ||
113 | int | 117 | int |
@@ -119,7 +123,7 @@ xfs_dir2_leafn_read( | |||
119 | struct xfs_buf **bpp) | 123 | struct xfs_buf **bpp) |
120 | { | 124 | { |
121 | return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, | 125 | return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, |
122 | XFS_DATA_FORK, xfs_dir2_leafn_read_verify); | 126 | XFS_DATA_FORK, &xfs_dir2_leafn_buf_ops); |
123 | } | 127 | } |
124 | 128 | ||
125 | /* | 129 | /* |
@@ -198,7 +202,7 @@ xfs_dir2_block_to_leaf( | |||
198 | /* | 202 | /* |
199 | * Fix up the block header, make it a data block. | 203 | * Fix up the block header, make it a data block. |
200 | */ | 204 | */ |
201 | dbp->b_pre_io = xfs_dir2_data_write_verify; | 205 | dbp->b_ops = &xfs_dir2_data_buf_ops; |
202 | hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC); | 206 | hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC); |
203 | if (needscan) | 207 | if (needscan) |
204 | xfs_dir2_data_freescan(mp, hdr, &needlog); | 208 | xfs_dir2_data_freescan(mp, hdr, &needlog); |
@@ -1264,12 +1268,12 @@ xfs_dir2_leaf_init( | |||
1264 | * the block. | 1268 | * the block. |
1265 | */ | 1269 | */ |
1266 | if (magic == XFS_DIR2_LEAF1_MAGIC) { | 1270 | if (magic == XFS_DIR2_LEAF1_MAGIC) { |
1267 | bp->b_pre_io = xfs_dir2_leaf1_write_verify; | 1271 | bp->b_ops = &xfs_dir2_leaf1_buf_ops; |
1268 | ltp = xfs_dir2_leaf_tail_p(mp, leaf); | 1272 | ltp = xfs_dir2_leaf_tail_p(mp, leaf); |
1269 | ltp->bestcount = 0; | 1273 | ltp->bestcount = 0; |
1270 | xfs_dir2_leaf_log_tail(tp, bp); | 1274 | xfs_dir2_leaf_log_tail(tp, bp); |
1271 | } else | 1275 | } else |
1272 | bp->b_pre_io = xfs_dir2_leafn_write_verify; | 1276 | bp->b_ops = &xfs_dir2_leafn_buf_ops; |
1273 | *bpp = bp; | 1277 | *bpp = bp; |
1274 | return 0; | 1278 | return 0; |
1275 | } | 1279 | } |
@@ -1954,7 +1958,7 @@ xfs_dir2_node_to_leaf( | |||
1954 | else | 1958 | else |
1955 | xfs_dir2_leaf_log_header(tp, lbp); | 1959 | xfs_dir2_leaf_log_header(tp, lbp); |
1956 | 1960 | ||
1957 | lbp->b_pre_io = xfs_dir2_leaf1_write_verify; | 1961 | lbp->b_ops = &xfs_dir2_leaf1_buf_ops; |
1958 | leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAF1_MAGIC); | 1962 | leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAF1_MAGIC); |
1959 | 1963 | ||
1960 | /* | 1964 | /* |
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c index da90a91f4420..5980f9b7fa9b 100644 --- a/fs/xfs/xfs_dir2_node.c +++ b/fs/xfs/xfs_dir2_node.c | |||
@@ -72,22 +72,24 @@ xfs_dir2_free_verify( | |||
72 | } | 72 | } |
73 | 73 | ||
74 | static void | 74 | static void |
75 | xfs_dir2_free_write_verify( | 75 | xfs_dir2_free_read_verify( |
76 | struct xfs_buf *bp) | 76 | struct xfs_buf *bp) |
77 | { | 77 | { |
78 | xfs_dir2_free_verify(bp); | 78 | xfs_dir2_free_verify(bp); |
79 | } | 79 | } |
80 | 80 | ||
81 | void | 81 | static void |
82 | xfs_dir2_free_read_verify( | 82 | xfs_dir2_free_write_verify( |
83 | struct xfs_buf *bp) | 83 | struct xfs_buf *bp) |
84 | { | 84 | { |
85 | xfs_dir2_free_verify(bp); | 85 | xfs_dir2_free_verify(bp); |
86 | bp->b_pre_io = xfs_dir2_free_write_verify; | ||
87 | bp->b_iodone = NULL; | ||
88 | xfs_buf_ioend(bp, 0); | ||
89 | } | 86 | } |
90 | 87 | ||
88 | static const struct xfs_buf_ops xfs_dir2_free_buf_ops = { | ||
89 | .verify_read = xfs_dir2_free_read_verify, | ||
90 | .verify_write = xfs_dir2_free_write_verify, | ||
91 | }; | ||
92 | |||
91 | 93 | ||
92 | static int | 94 | static int |
93 | __xfs_dir2_free_read( | 95 | __xfs_dir2_free_read( |
@@ -98,7 +100,7 @@ __xfs_dir2_free_read( | |||
98 | struct xfs_buf **bpp) | 100 | struct xfs_buf **bpp) |
99 | { | 101 | { |
100 | return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, | 102 | return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, |
101 | XFS_DATA_FORK, xfs_dir2_free_read_verify); | 103 | XFS_DATA_FORK, &xfs_dir2_free_buf_ops); |
102 | } | 104 | } |
103 | 105 | ||
104 | int | 106 | int |
@@ -201,7 +203,7 @@ xfs_dir2_leaf_to_node( | |||
201 | XFS_DATA_FORK); | 203 | XFS_DATA_FORK); |
202 | if (error) | 204 | if (error) |
203 | return error; | 205 | return error; |
204 | fbp->b_pre_io = xfs_dir2_free_write_verify; | 206 | fbp->b_ops = &xfs_dir2_free_buf_ops; |
205 | 207 | ||
206 | free = fbp->b_addr; | 208 | free = fbp->b_addr; |
207 | leaf = lbp->b_addr; | 209 | leaf = lbp->b_addr; |
@@ -225,7 +227,7 @@ xfs_dir2_leaf_to_node( | |||
225 | } | 227 | } |
226 | free->hdr.nused = cpu_to_be32(n); | 228 | free->hdr.nused = cpu_to_be32(n); |
227 | 229 | ||
228 | lbp->b_pre_io = xfs_dir2_leafn_write_verify; | 230 | lbp->b_ops = &xfs_dir2_leafn_buf_ops; |
229 | leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAFN_MAGIC); | 231 | leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAFN_MAGIC); |
230 | 232 | ||
231 | /* | 233 | /* |
@@ -636,7 +638,7 @@ xfs_dir2_leafn_lookup_for_entry( | |||
636 | state->extrablk.index = (int)((char *)dep - | 638 | state->extrablk.index = (int)((char *)dep - |
637 | (char *)curbp->b_addr); | 639 | (char *)curbp->b_addr); |
638 | state->extrablk.magic = XFS_DIR2_DATA_MAGIC; | 640 | state->extrablk.magic = XFS_DIR2_DATA_MAGIC; |
639 | curbp->b_pre_io = xfs_dir2_data_write_verify; | 641 | curbp->b_ops = &xfs_dir2_data_buf_ops; |
640 | if (cmp == XFS_CMP_EXACT) | 642 | if (cmp == XFS_CMP_EXACT) |
641 | return XFS_ERROR(EEXIST); | 643 | return XFS_ERROR(EEXIST); |
642 | } | 644 | } |
@@ -651,7 +653,7 @@ xfs_dir2_leafn_lookup_for_entry( | |||
651 | state->extrablk.index = -1; | 653 | state->extrablk.index = -1; |
652 | state->extrablk.blkno = curdb; | 654 | state->extrablk.blkno = curdb; |
653 | state->extrablk.magic = XFS_DIR2_DATA_MAGIC; | 655 | state->extrablk.magic = XFS_DIR2_DATA_MAGIC; |
654 | curbp->b_pre_io = xfs_dir2_data_write_verify; | 656 | curbp->b_ops = &xfs_dir2_data_buf_ops; |
655 | } else { | 657 | } else { |
656 | /* If the curbp is not the CI match block, drop it */ | 658 | /* If the curbp is not the CI match block, drop it */ |
657 | if (state->extrablk.bp != curbp) | 659 | if (state->extrablk.bp != curbp) |
@@ -1649,7 +1651,7 @@ xfs_dir2_node_addname_int( | |||
1649 | -1, &fbp, XFS_DATA_FORK); | 1651 | -1, &fbp, XFS_DATA_FORK); |
1650 | if (error) | 1652 | if (error) |
1651 | return error; | 1653 | return error; |
1652 | fbp->b_pre_io = xfs_dir2_free_write_verify; | 1654 | fbp->b_ops = &xfs_dir2_free_buf_ops; |
1653 | 1655 | ||
1654 | /* | 1656 | /* |
1655 | * Initialize the new block to be empty, and remember | 1657 | * Initialize the new block to be empty, and remember |
diff --git a/fs/xfs/xfs_dir2_priv.h b/fs/xfs/xfs_dir2_priv.h index 01b82dcddc3e..7da79f6515fd 100644 --- a/fs/xfs/xfs_dir2_priv.h +++ b/fs/xfs/xfs_dir2_priv.h | |||
@@ -30,6 +30,8 @@ extern int xfs_dir_cilookup_result(struct xfs_da_args *args, | |||
30 | const unsigned char *name, int len); | 30 | const unsigned char *name, int len); |
31 | 31 | ||
32 | /* xfs_dir2_block.c */ | 32 | /* xfs_dir2_block.c */ |
33 | extern const struct xfs_buf_ops xfs_dir2_block_buf_ops; | ||
34 | |||
33 | extern int xfs_dir2_block_addname(struct xfs_da_args *args); | 35 | extern int xfs_dir2_block_addname(struct xfs_da_args *args); |
34 | extern int xfs_dir2_block_getdents(struct xfs_inode *dp, void *dirent, | 36 | extern int xfs_dir2_block_getdents(struct xfs_inode *dp, void *dirent, |
35 | xfs_off_t *offset, filldir_t filldir); | 37 | xfs_off_t *offset, filldir_t filldir); |
@@ -45,7 +47,9 @@ extern int xfs_dir2_leaf_to_block(struct xfs_da_args *args, | |||
45 | #else | 47 | #else |
46 | #define xfs_dir2_data_check(dp,bp) | 48 | #define xfs_dir2_data_check(dp,bp) |
47 | #endif | 49 | #endif |
48 | extern void xfs_dir2_data_write_verify(struct xfs_buf *bp); | 50 | |
51 | extern const struct xfs_buf_ops xfs_dir2_data_buf_ops; | ||
52 | |||
49 | extern int __xfs_dir2_data_check(struct xfs_inode *dp, struct xfs_buf *bp); | 53 | extern int __xfs_dir2_data_check(struct xfs_inode *dp, struct xfs_buf *bp); |
50 | extern int xfs_dir2_data_read(struct xfs_trans *tp, struct xfs_inode *dp, | 54 | extern int xfs_dir2_data_read(struct xfs_trans *tp, struct xfs_inode *dp, |
51 | xfs_dablk_t bno, xfs_daddr_t mapped_bno, struct xfs_buf **bpp); | 55 | xfs_dablk_t bno, xfs_daddr_t mapped_bno, struct xfs_buf **bpp); |
@@ -73,8 +77,8 @@ extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_buf *bp, | |||
73 | xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp); | 77 | xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp); |
74 | 78 | ||
75 | /* xfs_dir2_leaf.c */ | 79 | /* xfs_dir2_leaf.c */ |
76 | extern void xfs_dir2_leafn_read_verify(struct xfs_buf *bp); | 80 | extern const struct xfs_buf_ops xfs_dir2_leafn_buf_ops; |
77 | extern void xfs_dir2_leafn_write_verify(struct xfs_buf *bp); | 81 | |
78 | extern int xfs_dir2_leafn_read(struct xfs_trans *tp, struct xfs_inode *dp, | 82 | extern int xfs_dir2_leafn_read(struct xfs_trans *tp, struct xfs_inode *dp, |
79 | xfs_dablk_t fbno, xfs_daddr_t mappedbno, struct xfs_buf **bpp); | 83 | xfs_dablk_t fbno, xfs_daddr_t mappedbno, struct xfs_buf **bpp); |
80 | extern int xfs_dir2_block_to_leaf(struct xfs_da_args *args, | 84 | extern int xfs_dir2_block_to_leaf(struct xfs_da_args *args, |
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c index 1b06aa051074..9e1bf5294c91 100644 --- a/fs/xfs/xfs_dquot.c +++ b/fs/xfs/xfs_dquot.c | |||
@@ -284,22 +284,24 @@ xfs_dquot_buf_verify( | |||
284 | } | 284 | } |
285 | 285 | ||
286 | static void | 286 | static void |
287 | xfs_dquot_buf_write_verify( | 287 | xfs_dquot_buf_read_verify( |
288 | struct xfs_buf *bp) | 288 | struct xfs_buf *bp) |
289 | { | 289 | { |
290 | xfs_dquot_buf_verify(bp); | 290 | xfs_dquot_buf_verify(bp); |
291 | } | 291 | } |
292 | 292 | ||
293 | void | 293 | void |
294 | xfs_dquot_buf_read_verify( | 294 | xfs_dquot_buf_write_verify( |
295 | struct xfs_buf *bp) | 295 | struct xfs_buf *bp) |
296 | { | 296 | { |
297 | xfs_dquot_buf_verify(bp); | 297 | xfs_dquot_buf_verify(bp); |
298 | bp->b_pre_io = xfs_dquot_buf_write_verify; | ||
299 | bp->b_iodone = NULL; | ||
300 | xfs_buf_ioend(bp, 0); | ||
301 | } | 298 | } |
302 | 299 | ||
300 | const struct xfs_buf_ops xfs_dquot_buf_ops = { | ||
301 | .verify_read = xfs_dquot_buf_read_verify, | ||
302 | .verify_write = xfs_dquot_buf_write_verify, | ||
303 | }; | ||
304 | |||
303 | /* | 305 | /* |
304 | * Allocate a block and fill it with dquots. | 306 | * Allocate a block and fill it with dquots. |
305 | * This is called when the bmapi finds a hole. | 307 | * This is called when the bmapi finds a hole. |
@@ -365,7 +367,7 @@ xfs_qm_dqalloc( | |||
365 | error = xfs_buf_geterror(bp); | 367 | error = xfs_buf_geterror(bp); |
366 | if (error) | 368 | if (error) |
367 | goto error1; | 369 | goto error1; |
368 | bp->b_pre_io = xfs_dquot_buf_write_verify; | 370 | bp->b_ops = &xfs_dquot_buf_ops; |
369 | 371 | ||
370 | /* | 372 | /* |
371 | * Make a chunk of dquots out of this buffer and log | 373 | * Make a chunk of dquots out of this buffer and log |
@@ -435,7 +437,7 @@ xfs_qm_dqrepair( | |||
435 | ASSERT(*bpp == NULL); | 437 | ASSERT(*bpp == NULL); |
436 | return XFS_ERROR(error); | 438 | return XFS_ERROR(error); |
437 | } | 439 | } |
438 | (*bpp)->b_pre_io = xfs_dquot_buf_write_verify; | 440 | (*bpp)->b_ops = &xfs_dquot_buf_ops; |
439 | 441 | ||
440 | ASSERT(xfs_buf_islocked(*bpp)); | 442 | ASSERT(xfs_buf_islocked(*bpp)); |
441 | d = (struct xfs_dqblk *)(*bpp)->b_addr; | 443 | d = (struct xfs_dqblk *)(*bpp)->b_addr; |
@@ -534,7 +536,7 @@ xfs_qm_dqtobp( | |||
534 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, | 536 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, |
535 | dqp->q_blkno, | 537 | dqp->q_blkno, |
536 | mp->m_quotainfo->qi_dqchunklen, | 538 | mp->m_quotainfo->qi_dqchunklen, |
537 | 0, &bp, xfs_dquot_buf_read_verify); | 539 | 0, &bp, &xfs_dquot_buf_ops); |
538 | 540 | ||
539 | if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) { | 541 | if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) { |
540 | xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff * | 542 | xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff * |
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h index 5438d883b628..c694a8469c4a 100644 --- a/fs/xfs/xfs_dquot.h +++ b/fs/xfs/xfs_dquot.h | |||
@@ -140,7 +140,6 @@ static inline xfs_dquot_t *xfs_inode_dquot(struct xfs_inode *ip, int type) | |||
140 | 140 | ||
141 | extern int xfs_qm_dqread(struct xfs_mount *, xfs_dqid_t, uint, | 141 | extern int xfs_qm_dqread(struct xfs_mount *, xfs_dqid_t, uint, |
142 | uint, struct xfs_dquot **); | 142 | uint, struct xfs_dquot **); |
143 | extern void xfs_dquot_buf_read_verify(struct xfs_buf *bp); | ||
144 | extern void xfs_qm_dqdestroy(xfs_dquot_t *); | 143 | extern void xfs_qm_dqdestroy(xfs_dquot_t *); |
145 | extern int xfs_qm_dqflush(struct xfs_dquot *, struct xfs_buf **); | 144 | extern int xfs_qm_dqflush(struct xfs_dquot *, struct xfs_buf **); |
146 | extern void xfs_qm_dqunpin_wait(xfs_dquot_t *); | 145 | extern void xfs_qm_dqunpin_wait(xfs_dquot_t *); |
@@ -162,4 +161,6 @@ static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp) | |||
162 | return dqp; | 161 | return dqp; |
163 | } | 162 | } |
164 | 163 | ||
164 | extern const struct xfs_buf_ops xfs_dquot_buf_ops; | ||
165 | |||
165 | #endif /* __XFS_DQUOT_H__ */ | 166 | #endif /* __XFS_DQUOT_H__ */ |
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c index 5d6d6b9d369d..94eaeedc5498 100644 --- a/fs/xfs/xfs_fsops.c +++ b/fs/xfs/xfs_fsops.c | |||
@@ -119,7 +119,8 @@ xfs_growfs_get_hdr_buf( | |||
119 | struct xfs_mount *mp, | 119 | struct xfs_mount *mp, |
120 | xfs_daddr_t blkno, | 120 | xfs_daddr_t blkno, |
121 | size_t numblks, | 121 | size_t numblks, |
122 | int flags) | 122 | int flags, |
123 | const struct xfs_buf_ops *ops) | ||
123 | { | 124 | { |
124 | struct xfs_buf *bp; | 125 | struct xfs_buf *bp; |
125 | 126 | ||
@@ -130,6 +131,7 @@ xfs_growfs_get_hdr_buf( | |||
130 | xfs_buf_zero(bp, 0, BBTOB(bp->b_length)); | 131 | xfs_buf_zero(bp, 0, BBTOB(bp->b_length)); |
131 | bp->b_bn = blkno; | 132 | bp->b_bn = blkno; |
132 | bp->b_maps[0].bm_bn = blkno; | 133 | bp->b_maps[0].bm_bn = blkno; |
134 | bp->b_ops = ops; | ||
133 | 135 | ||
134 | return bp; | 136 | return bp; |
135 | } | 137 | } |
@@ -217,12 +219,12 @@ xfs_growfs_data_private( | |||
217 | */ | 219 | */ |
218 | bp = xfs_growfs_get_hdr_buf(mp, | 220 | bp = xfs_growfs_get_hdr_buf(mp, |
219 | XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)), | 221 | XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)), |
220 | XFS_FSS_TO_BB(mp, 1), 0); | 222 | XFS_FSS_TO_BB(mp, 1), 0, |
223 | &xfs_agf_buf_ops); | ||
221 | if (!bp) { | 224 | if (!bp) { |
222 | error = ENOMEM; | 225 | error = ENOMEM; |
223 | goto error0; | 226 | goto error0; |
224 | } | 227 | } |
225 | bp->b_pre_io = xfs_agf_write_verify; | ||
226 | 228 | ||
227 | agf = XFS_BUF_TO_AGF(bp); | 229 | agf = XFS_BUF_TO_AGF(bp); |
228 | agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC); | 230 | agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC); |
@@ -255,12 +257,12 @@ xfs_growfs_data_private( | |||
255 | */ | 257 | */ |
256 | bp = xfs_growfs_get_hdr_buf(mp, | 258 | bp = xfs_growfs_get_hdr_buf(mp, |
257 | XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)), | 259 | XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)), |
258 | XFS_FSS_TO_BB(mp, 1), 0); | 260 | XFS_FSS_TO_BB(mp, 1), 0, |
261 | &xfs_agfl_buf_ops); | ||
259 | if (!bp) { | 262 | if (!bp) { |
260 | error = ENOMEM; | 263 | error = ENOMEM; |
261 | goto error0; | 264 | goto error0; |
262 | } | 265 | } |
263 | bp->b_pre_io = xfs_agfl_write_verify; | ||
264 | 266 | ||
265 | agfl = XFS_BUF_TO_AGFL(bp); | 267 | agfl = XFS_BUF_TO_AGFL(bp); |
266 | for (bucket = 0; bucket < XFS_AGFL_SIZE(mp); bucket++) | 268 | for (bucket = 0; bucket < XFS_AGFL_SIZE(mp); bucket++) |
@@ -276,12 +278,12 @@ xfs_growfs_data_private( | |||
276 | */ | 278 | */ |
277 | bp = xfs_growfs_get_hdr_buf(mp, | 279 | bp = xfs_growfs_get_hdr_buf(mp, |
278 | XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)), | 280 | XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)), |
279 | XFS_FSS_TO_BB(mp, 1), 0); | 281 | XFS_FSS_TO_BB(mp, 1), 0, |
282 | &xfs_agi_buf_ops); | ||
280 | if (!bp) { | 283 | if (!bp) { |
281 | error = ENOMEM; | 284 | error = ENOMEM; |
282 | goto error0; | 285 | goto error0; |
283 | } | 286 | } |
284 | bp->b_pre_io = xfs_agi_write_verify; | ||
285 | 287 | ||
286 | agi = XFS_BUF_TO_AGI(bp); | 288 | agi = XFS_BUF_TO_AGI(bp); |
287 | agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC); | 289 | agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC); |
@@ -306,7 +308,8 @@ xfs_growfs_data_private( | |||
306 | */ | 308 | */ |
307 | bp = xfs_growfs_get_hdr_buf(mp, | 309 | bp = xfs_growfs_get_hdr_buf(mp, |
308 | XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)), | 310 | XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)), |
309 | BTOBB(mp->m_sb.sb_blocksize), 0); | 311 | BTOBB(mp->m_sb.sb_blocksize), 0, |
312 | &xfs_allocbt_buf_ops); | ||
310 | 313 | ||
311 | if (!bp) { | 314 | if (!bp) { |
312 | error = ENOMEM; | 315 | error = ENOMEM; |
@@ -329,7 +332,8 @@ xfs_growfs_data_private( | |||
329 | */ | 332 | */ |
330 | bp = xfs_growfs_get_hdr_buf(mp, | 333 | bp = xfs_growfs_get_hdr_buf(mp, |
331 | XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)), | 334 | XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)), |
332 | BTOBB(mp->m_sb.sb_blocksize), 0); | 335 | BTOBB(mp->m_sb.sb_blocksize), 0, |
336 | &xfs_allocbt_buf_ops); | ||
333 | if (!bp) { | 337 | if (!bp) { |
334 | error = ENOMEM; | 338 | error = ENOMEM; |
335 | goto error0; | 339 | goto error0; |
@@ -352,7 +356,8 @@ xfs_growfs_data_private( | |||
352 | */ | 356 | */ |
353 | bp = xfs_growfs_get_hdr_buf(mp, | 357 | bp = xfs_growfs_get_hdr_buf(mp, |
354 | XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)), | 358 | XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)), |
355 | BTOBB(mp->m_sb.sb_blocksize), 0); | 359 | BTOBB(mp->m_sb.sb_blocksize), 0, |
360 | &xfs_inobt_buf_ops); | ||
356 | if (!bp) { | 361 | if (!bp) { |
357 | error = ENOMEM; | 362 | error = ENOMEM; |
358 | goto error0; | 363 | goto error0; |
@@ -448,14 +453,14 @@ xfs_growfs_data_private( | |||
448 | error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, | 453 | error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, |
449 | XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)), | 454 | XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)), |
450 | XFS_FSS_TO_BB(mp, 1), 0, &bp, | 455 | XFS_FSS_TO_BB(mp, 1), 0, &bp, |
451 | xfs_sb_read_verify); | 456 | &xfs_sb_buf_ops); |
452 | } else { | 457 | } else { |
453 | bp = xfs_trans_get_buf(NULL, mp->m_ddev_targp, | 458 | bp = xfs_trans_get_buf(NULL, mp->m_ddev_targp, |
454 | XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)), | 459 | XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)), |
455 | XFS_FSS_TO_BB(mp, 1), 0); | 460 | XFS_FSS_TO_BB(mp, 1), 0); |
456 | if (bp) { | 461 | if (bp) { |
462 | bp->b_ops = &xfs_sb_buf_ops; | ||
457 | xfs_buf_zero(bp, 0, BBTOB(bp->b_length)); | 463 | xfs_buf_zero(bp, 0, BBTOB(bp->b_length)); |
458 | bp->b_pre_io = xfs_sb_write_verify; | ||
459 | } else | 464 | } else |
460 | error = ENOMEM; | 465 | error = ENOMEM; |
461 | } | 466 | } |
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c index faf68600d3a6..2d6495eaaa34 100644 --- a/fs/xfs/xfs_ialloc.c +++ b/fs/xfs/xfs_ialloc.c | |||
@@ -210,7 +210,7 @@ xfs_ialloc_inode_init( | |||
210 | * to log a whole cluster of inodes instead of all the | 210 | * to log a whole cluster of inodes instead of all the |
211 | * individual transactions causing a lot of log traffic. | 211 | * individual transactions causing a lot of log traffic. |
212 | */ | 212 | */ |
213 | fbuf->b_pre_io = xfs_inode_buf_write_verify; | 213 | fbuf->b_ops = &xfs_inode_buf_ops; |
214 | xfs_buf_zero(fbuf, 0, ninodes << mp->m_sb.sb_inodelog); | 214 | xfs_buf_zero(fbuf, 0, ninodes << mp->m_sb.sb_inodelog); |
215 | for (i = 0; i < ninodes; i++) { | 215 | for (i = 0; i < ninodes; i++) { |
216 | int ioffset = i << mp->m_sb.sb_inodelog; | 216 | int ioffset = i << mp->m_sb.sb_inodelog; |
@@ -1505,23 +1505,25 @@ xfs_agi_verify( | |||
1505 | xfs_check_agi_unlinked(agi); | 1505 | xfs_check_agi_unlinked(agi); |
1506 | } | 1506 | } |
1507 | 1507 | ||
1508 | void | 1508 | static void |
1509 | xfs_agi_write_verify( | 1509 | xfs_agi_read_verify( |
1510 | struct xfs_buf *bp) | 1510 | struct xfs_buf *bp) |
1511 | { | 1511 | { |
1512 | xfs_agi_verify(bp); | 1512 | xfs_agi_verify(bp); |
1513 | } | 1513 | } |
1514 | 1514 | ||
1515 | static void | 1515 | static void |
1516 | xfs_agi_read_verify( | 1516 | xfs_agi_write_verify( |
1517 | struct xfs_buf *bp) | 1517 | struct xfs_buf *bp) |
1518 | { | 1518 | { |
1519 | xfs_agi_verify(bp); | 1519 | xfs_agi_verify(bp); |
1520 | bp->b_pre_io = xfs_agi_write_verify; | ||
1521 | bp->b_iodone = NULL; | ||
1522 | xfs_buf_ioend(bp, 0); | ||
1523 | } | 1520 | } |
1524 | 1521 | ||
1522 | const struct xfs_buf_ops xfs_agi_buf_ops = { | ||
1523 | .verify_read = xfs_agi_read_verify, | ||
1524 | .verify_write = xfs_agi_write_verify, | ||
1525 | }; | ||
1526 | |||
1525 | /* | 1527 | /* |
1526 | * Read in the allocation group header (inode allocation section) | 1528 | * Read in the allocation group header (inode allocation section) |
1527 | */ | 1529 | */ |
@@ -1538,7 +1540,7 @@ xfs_read_agi( | |||
1538 | 1540 | ||
1539 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, | 1541 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, |
1540 | XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)), | 1542 | XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)), |
1541 | XFS_FSS_TO_BB(mp, 1), 0, bpp, xfs_agi_read_verify); | 1543 | XFS_FSS_TO_BB(mp, 1), 0, bpp, &xfs_agi_buf_ops); |
1542 | if (error) | 1544 | if (error) |
1543 | return error; | 1545 | return error; |
1544 | 1546 | ||
diff --git a/fs/xfs/xfs_ialloc.h b/fs/xfs/xfs_ialloc.h index 7a169e34e30e..c8da3df271e6 100644 --- a/fs/xfs/xfs_ialloc.h +++ b/fs/xfs/xfs_ialloc.h | |||
@@ -150,6 +150,6 @@ int xfs_inobt_lookup(struct xfs_btree_cur *cur, xfs_agino_t ino, | |||
150 | int xfs_inobt_get_rec(struct xfs_btree_cur *cur, | 150 | int xfs_inobt_get_rec(struct xfs_btree_cur *cur, |
151 | xfs_inobt_rec_incore_t *rec, int *stat); | 151 | xfs_inobt_rec_incore_t *rec, int *stat); |
152 | 152 | ||
153 | void xfs_agi_write_verify(struct xfs_buf *bp); | 153 | extern const struct xfs_buf_ops xfs_agi_buf_ops; |
154 | 154 | ||
155 | #endif /* __XFS_IALLOC_H__ */ | 155 | #endif /* __XFS_IALLOC_H__ */ |
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/xfs_ialloc_btree.c index 7761e1ebeff7..bec344b36507 100644 --- a/fs/xfs/xfs_ialloc_btree.c +++ b/fs/xfs/xfs_ialloc_btree.c | |||
@@ -217,22 +217,24 @@ xfs_inobt_verify( | |||
217 | } | 217 | } |
218 | 218 | ||
219 | static void | 219 | static void |
220 | xfs_inobt_write_verify( | 220 | xfs_inobt_read_verify( |
221 | struct xfs_buf *bp) | 221 | struct xfs_buf *bp) |
222 | { | 222 | { |
223 | xfs_inobt_verify(bp); | 223 | xfs_inobt_verify(bp); |
224 | } | 224 | } |
225 | 225 | ||
226 | void | 226 | static void |
227 | xfs_inobt_read_verify( | 227 | xfs_inobt_write_verify( |
228 | struct xfs_buf *bp) | 228 | struct xfs_buf *bp) |
229 | { | 229 | { |
230 | xfs_inobt_verify(bp); | 230 | xfs_inobt_verify(bp); |
231 | bp->b_pre_io = xfs_inobt_write_verify; | ||
232 | bp->b_iodone = NULL; | ||
233 | xfs_buf_ioend(bp, 0); | ||
234 | } | 231 | } |
235 | 232 | ||
233 | const struct xfs_buf_ops xfs_inobt_buf_ops = { | ||
234 | .verify_read = xfs_inobt_read_verify, | ||
235 | .verify_write = xfs_inobt_write_verify, | ||
236 | }; | ||
237 | |||
236 | #ifdef DEBUG | 238 | #ifdef DEBUG |
237 | STATIC int | 239 | STATIC int |
238 | xfs_inobt_keys_inorder( | 240 | xfs_inobt_keys_inorder( |
@@ -270,8 +272,7 @@ static const struct xfs_btree_ops xfs_inobt_ops = { | |||
270 | .init_rec_from_cur = xfs_inobt_init_rec_from_cur, | 272 | .init_rec_from_cur = xfs_inobt_init_rec_from_cur, |
271 | .init_ptr_from_cur = xfs_inobt_init_ptr_from_cur, | 273 | .init_ptr_from_cur = xfs_inobt_init_ptr_from_cur, |
272 | .key_diff = xfs_inobt_key_diff, | 274 | .key_diff = xfs_inobt_key_diff, |
273 | .read_verify = xfs_inobt_read_verify, | 275 | .buf_ops = &xfs_inobt_buf_ops, |
274 | .write_verify = xfs_inobt_write_verify, | ||
275 | #ifdef DEBUG | 276 | #ifdef DEBUG |
276 | .keys_inorder = xfs_inobt_keys_inorder, | 277 | .keys_inorder = xfs_inobt_keys_inorder, |
277 | .recs_inorder = xfs_inobt_recs_inorder, | 278 | .recs_inorder = xfs_inobt_recs_inorder, |
diff --git a/fs/xfs/xfs_ialloc_btree.h b/fs/xfs/xfs_ialloc_btree.h index f782ad0c4769..25c0239a8eab 100644 --- a/fs/xfs/xfs_ialloc_btree.h +++ b/fs/xfs/xfs_ialloc_btree.h | |||
@@ -109,4 +109,6 @@ extern struct xfs_btree_cur *xfs_inobt_init_cursor(struct xfs_mount *, | |||
109 | struct xfs_trans *, struct xfs_buf *, xfs_agnumber_t); | 109 | struct xfs_trans *, struct xfs_buf *, xfs_agnumber_t); |
110 | extern int xfs_inobt_maxrecs(struct xfs_mount *, int, int); | 110 | extern int xfs_inobt_maxrecs(struct xfs_mount *, int, int); |
111 | 111 | ||
112 | extern const struct xfs_buf_ops xfs_inobt_buf_ops; | ||
113 | |||
112 | #endif /* __XFS_IALLOC_BTREE_H__ */ | 114 | #endif /* __XFS_IALLOC_BTREE_H__ */ |
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c index dfcbe73f1db4..66282dcb821b 100644 --- a/fs/xfs/xfs_inode.c +++ b/fs/xfs/xfs_inode.c | |||
@@ -420,23 +420,27 @@ xfs_inode_buf_verify( | |||
420 | xfs_inobp_check(mp, bp); | 420 | xfs_inobp_check(mp, bp); |
421 | } | 421 | } |
422 | 422 | ||
423 | void | 423 | |
424 | xfs_inode_buf_write_verify( | 424 | static void |
425 | xfs_inode_buf_read_verify( | ||
425 | struct xfs_buf *bp) | 426 | struct xfs_buf *bp) |
426 | { | 427 | { |
427 | xfs_inode_buf_verify(bp); | 428 | xfs_inode_buf_verify(bp); |
428 | } | 429 | } |
429 | 430 | ||
430 | void | 431 | static void |
431 | xfs_inode_buf_read_verify( | 432 | xfs_inode_buf_write_verify( |
432 | struct xfs_buf *bp) | 433 | struct xfs_buf *bp) |
433 | { | 434 | { |
434 | xfs_inode_buf_verify(bp); | 435 | xfs_inode_buf_verify(bp); |
435 | bp->b_pre_io = xfs_inode_buf_write_verify; | ||
436 | bp->b_iodone = NULL; | ||
437 | xfs_buf_ioend(bp, 0); | ||
438 | } | 436 | } |
439 | 437 | ||
438 | const struct xfs_buf_ops xfs_inode_buf_ops = { | ||
439 | .verify_read = xfs_inode_buf_read_verify, | ||
440 | .verify_write = xfs_inode_buf_write_verify, | ||
441 | }; | ||
442 | |||
443 | |||
440 | /* | 444 | /* |
441 | * This routine is called to map an inode to the buffer containing the on-disk | 445 | * This routine is called to map an inode to the buffer containing the on-disk |
442 | * version of the inode. It returns a pointer to the buffer containing the | 446 | * version of the inode. It returns a pointer to the buffer containing the |
@@ -462,7 +466,7 @@ xfs_imap_to_bp( | |||
462 | buf_flags |= XBF_UNMAPPED; | 466 | buf_flags |= XBF_UNMAPPED; |
463 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno, | 467 | error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno, |
464 | (int)imap->im_len, buf_flags, &bp, | 468 | (int)imap->im_len, buf_flags, &bp, |
465 | xfs_inode_buf_read_verify); | 469 | &xfs_inode_buf_ops); |
466 | if (error) { | 470 | if (error) { |
467 | if (error == EAGAIN) { | 471 | if (error == EAGAIN) { |
468 | ASSERT(buf_flags & XBF_TRYLOCK); | 472 | ASSERT(buf_flags & XBF_TRYLOCK); |
@@ -1792,7 +1796,7 @@ xfs_ifree_cluster( | |||
1792 | * want it to fail. We can acheive this by adding a write | 1796 | * want it to fail. We can acheive this by adding a write |
1793 | * verifier to the buffer. | 1797 | * verifier to the buffer. |
1794 | */ | 1798 | */ |
1795 | bp->b_pre_io = xfs_inode_buf_write_verify; | 1799 | bp->b_ops = &xfs_inode_buf_ops; |
1796 | 1800 | ||
1797 | /* | 1801 | /* |
1798 | * Walk the inodes already attached to the buffer and mark them | 1802 | * Walk the inodes already attached to the buffer and mark them |
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h index 482214d120a7..22baf6ea4fac 100644 --- a/fs/xfs/xfs_inode.h +++ b/fs/xfs/xfs_inode.h | |||
@@ -554,8 +554,6 @@ int xfs_imap_to_bp(struct xfs_mount *, struct xfs_trans *, | |||
554 | struct xfs_buf **, uint, uint); | 554 | struct xfs_buf **, uint, uint); |
555 | int xfs_iread(struct xfs_mount *, struct xfs_trans *, | 555 | int xfs_iread(struct xfs_mount *, struct xfs_trans *, |
556 | struct xfs_inode *, uint); | 556 | struct xfs_inode *, uint); |
557 | void xfs_inode_buf_read_verify(struct xfs_buf *); | ||
558 | void xfs_inode_buf_write_verify(struct xfs_buf *); | ||
559 | void xfs_dinode_to_disk(struct xfs_dinode *, | 557 | void xfs_dinode_to_disk(struct xfs_dinode *, |
560 | struct xfs_icdinode *); | 558 | struct xfs_icdinode *); |
561 | void xfs_idestroy_fork(struct xfs_inode *, int); | 559 | void xfs_idestroy_fork(struct xfs_inode *, int); |
@@ -600,5 +598,6 @@ void xfs_inobp_check(struct xfs_mount *, struct xfs_buf *); | |||
600 | extern struct kmem_zone *xfs_ifork_zone; | 598 | extern struct kmem_zone *xfs_ifork_zone; |
601 | extern struct kmem_zone *xfs_inode_zone; | 599 | extern struct kmem_zone *xfs_inode_zone; |
602 | extern struct kmem_zone *xfs_ili_zone; | 600 | extern struct kmem_zone *xfs_ili_zone; |
601 | extern const struct xfs_buf_ops xfs_inode_buf_ops; | ||
603 | 602 | ||
604 | #endif /* __XFS_INODE_H__ */ | 603 | #endif /* __XFS_INODE_H__ */ |
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c index 7f86fdaab7ae..2ea7d402188d 100644 --- a/fs/xfs/xfs_itable.c +++ b/fs/xfs/xfs_itable.c | |||
@@ -397,7 +397,7 @@ xfs_bulkstat( | |||
397 | & ~r.ir_free) | 397 | & ~r.ir_free) |
398 | xfs_btree_reada_bufs(mp, agno, | 398 | xfs_btree_reada_bufs(mp, agno, |
399 | agbno, nbcluster, | 399 | agbno, nbcluster, |
400 | xfs_inode_buf_read_verify); | 400 | &xfs_inode_buf_ops); |
401 | } | 401 | } |
402 | irbp->ir_startino = r.ir_startino; | 402 | irbp->ir_startino = r.ir_startino; |
403 | irbp->ir_freecount = r.ir_freecount; | 403 | irbp->ir_freecount = r.ir_freecount; |
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c index 924a4bc3d49a..931e8e23f192 100644 --- a/fs/xfs/xfs_log_recover.c +++ b/fs/xfs/xfs_log_recover.c | |||
@@ -3699,7 +3699,7 @@ xlog_do_recover( | |||
3699 | ASSERT(!(XFS_BUF_ISWRITE(bp))); | 3699 | ASSERT(!(XFS_BUF_ISWRITE(bp))); |
3700 | XFS_BUF_READ(bp); | 3700 | XFS_BUF_READ(bp); |
3701 | XFS_BUF_UNASYNC(bp); | 3701 | XFS_BUF_UNASYNC(bp); |
3702 | bp->b_iodone = xfs_sb_read_verify; | 3702 | bp->b_ops = &xfs_sb_buf_ops; |
3703 | xfsbdstrat(log->l_mp, bp); | 3703 | xfsbdstrat(log->l_mp, bp); |
3704 | error = xfs_buf_iowait(bp); | 3704 | error = xfs_buf_iowait(bp); |
3705 | if (error) { | 3705 | if (error) { |
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c index 152a7fc843f9..da508463ff10 100644 --- a/fs/xfs/xfs_mount.c +++ b/fs/xfs/xfs_mount.c | |||
@@ -631,21 +631,11 @@ xfs_sb_verify( | |||
631 | xfs_buf_ioerror(bp, error); | 631 | xfs_buf_ioerror(bp, error); |
632 | } | 632 | } |
633 | 633 | ||
634 | void | 634 | static void |
635 | xfs_sb_write_verify( | ||
636 | struct xfs_buf *bp) | ||
637 | { | ||
638 | xfs_sb_verify(bp); | ||
639 | } | ||
640 | |||
641 | void | ||
642 | xfs_sb_read_verify( | 635 | xfs_sb_read_verify( |
643 | struct xfs_buf *bp) | 636 | struct xfs_buf *bp) |
644 | { | 637 | { |
645 | xfs_sb_verify(bp); | 638 | xfs_sb_verify(bp); |
646 | bp->b_pre_io = xfs_sb_write_verify; | ||
647 | bp->b_iodone = NULL; | ||
648 | xfs_buf_ioend(bp, 0); | ||
649 | } | 639 | } |
650 | 640 | ||
651 | /* | 641 | /* |
@@ -654,7 +644,7 @@ xfs_sb_read_verify( | |||
654 | * If we find an XFS superblock, the run a normal, noisy mount because we are | 644 | * If we find an XFS superblock, the run a normal, noisy mount because we are |
655 | * really going to mount it and want to know about errors. | 645 | * really going to mount it and want to know about errors. |
656 | */ | 646 | */ |
657 | void | 647 | static void |
658 | xfs_sb_quiet_read_verify( | 648 | xfs_sb_quiet_read_verify( |
659 | struct xfs_buf *bp) | 649 | struct xfs_buf *bp) |
660 | { | 650 | { |
@@ -671,6 +661,23 @@ xfs_sb_quiet_read_verify( | |||
671 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 661 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
672 | } | 662 | } |
673 | 663 | ||
664 | static void | ||
665 | xfs_sb_write_verify( | ||
666 | struct xfs_buf *bp) | ||
667 | { | ||
668 | xfs_sb_verify(bp); | ||
669 | } | ||
670 | |||
671 | const struct xfs_buf_ops xfs_sb_buf_ops = { | ||
672 | .verify_read = xfs_sb_read_verify, | ||
673 | .verify_write = xfs_sb_write_verify, | ||
674 | }; | ||
675 | |||
676 | static const struct xfs_buf_ops xfs_sb_quiet_buf_ops = { | ||
677 | .verify_read = xfs_sb_quiet_read_verify, | ||
678 | .verify_write = xfs_sb_write_verify, | ||
679 | }; | ||
680 | |||
674 | /* | 681 | /* |
675 | * xfs_readsb | 682 | * xfs_readsb |
676 | * | 683 | * |
@@ -697,8 +704,8 @@ xfs_readsb(xfs_mount_t *mp, int flags) | |||
697 | reread: | 704 | reread: |
698 | bp = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR, | 705 | bp = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR, |
699 | BTOBB(sector_size), 0, | 706 | BTOBB(sector_size), 0, |
700 | loud ? xfs_sb_read_verify | 707 | loud ? &xfs_sb_buf_ops |
701 | : xfs_sb_quiet_read_verify); | 708 | : &xfs_sb_quiet_buf_ops); |
702 | if (!bp) { | 709 | if (!bp) { |
703 | if (loud) | 710 | if (loud) |
704 | xfs_warn(mp, "SB buffer read failed"); | 711 | xfs_warn(mp, "SB buffer read failed"); |
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h index 29c1b3ac920e..bab8314507e4 100644 --- a/fs/xfs/xfs_mount.h +++ b/fs/xfs/xfs_mount.h | |||
@@ -385,12 +385,12 @@ extern void xfs_set_low_space_thresholds(struct xfs_mount *); | |||
385 | 385 | ||
386 | #endif /* __KERNEL__ */ | 386 | #endif /* __KERNEL__ */ |
387 | 387 | ||
388 | extern void xfs_sb_read_verify(struct xfs_buf *); | ||
389 | extern void xfs_sb_write_verify(struct xfs_buf *bp); | ||
390 | extern void xfs_mod_sb(struct xfs_trans *, __int64_t); | 388 | extern void xfs_mod_sb(struct xfs_trans *, __int64_t); |
391 | extern int xfs_initialize_perag(struct xfs_mount *, xfs_agnumber_t, | 389 | extern int xfs_initialize_perag(struct xfs_mount *, xfs_agnumber_t, |
392 | xfs_agnumber_t *); | 390 | xfs_agnumber_t *); |
393 | extern void xfs_sb_from_disk(struct xfs_sb *, struct xfs_dsb *); | 391 | extern void xfs_sb_from_disk(struct xfs_sb *, struct xfs_dsb *); |
394 | extern void xfs_sb_to_disk(struct xfs_dsb *, struct xfs_sb *, __int64_t); | 392 | extern void xfs_sb_to_disk(struct xfs_dsb *, struct xfs_sb *, __int64_t); |
395 | 393 | ||
394 | extern const struct xfs_buf_ops xfs_sb_buf_ops; | ||
395 | |||
396 | #endif /* __XFS_MOUNT_H__ */ | 396 | #endif /* __XFS_MOUNT_H__ */ |
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c index bd40ae9624e5..e6a0af0ba007 100644 --- a/fs/xfs/xfs_qm.c +++ b/fs/xfs/xfs_qm.c | |||
@@ -893,7 +893,7 @@ xfs_qm_dqiter_bufs( | |||
893 | error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, | 893 | error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, |
894 | XFS_FSB_TO_DADDR(mp, bno), | 894 | XFS_FSB_TO_DADDR(mp, bno), |
895 | mp->m_quotainfo->qi_dqchunklen, 0, &bp, | 895 | mp->m_quotainfo->qi_dqchunklen, 0, &bp, |
896 | xfs_dquot_buf_read_verify); | 896 | &xfs_dquot_buf_ops); |
897 | if (error) | 897 | if (error) |
898 | break; | 898 | break; |
899 | 899 | ||
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h index f02d40296506..c6c0601abd7a 100644 --- a/fs/xfs/xfs_trans.h +++ b/fs/xfs/xfs_trans.h | |||
@@ -474,7 +474,7 @@ int xfs_trans_read_buf_map(struct xfs_mount *mp, | |||
474 | struct xfs_buf_map *map, int nmaps, | 474 | struct xfs_buf_map *map, int nmaps, |
475 | xfs_buf_flags_t flags, | 475 | xfs_buf_flags_t flags, |
476 | struct xfs_buf **bpp, | 476 | struct xfs_buf **bpp, |
477 | xfs_buf_iodone_t verify); | 477 | const struct xfs_buf_ops *ops); |
478 | 478 | ||
479 | static inline int | 479 | static inline int |
480 | xfs_trans_read_buf( | 480 | xfs_trans_read_buf( |
@@ -485,11 +485,11 @@ xfs_trans_read_buf( | |||
485 | int numblks, | 485 | int numblks, |
486 | xfs_buf_flags_t flags, | 486 | xfs_buf_flags_t flags, |
487 | struct xfs_buf **bpp, | 487 | struct xfs_buf **bpp, |
488 | xfs_buf_iodone_t verify) | 488 | const struct xfs_buf_ops *ops) |
489 | { | 489 | { |
490 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); | 490 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); |
491 | return xfs_trans_read_buf_map(mp, tp, target, &map, 1, | 491 | return xfs_trans_read_buf_map(mp, tp, target, &map, 1, |
492 | flags, bpp, verify); | 492 | flags, bpp, ops); |
493 | } | 493 | } |
494 | 494 | ||
495 | struct xfs_buf *xfs_trans_getsb(xfs_trans_t *, struct xfs_mount *, int); | 495 | struct xfs_buf *xfs_trans_getsb(xfs_trans_t *, struct xfs_mount *, int); |
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c index 977628207b45..4fc17d479d42 100644 --- a/fs/xfs/xfs_trans_buf.c +++ b/fs/xfs/xfs_trans_buf.c | |||
@@ -258,7 +258,7 @@ xfs_trans_read_buf_map( | |||
258 | int nmaps, | 258 | int nmaps, |
259 | xfs_buf_flags_t flags, | 259 | xfs_buf_flags_t flags, |
260 | struct xfs_buf **bpp, | 260 | struct xfs_buf **bpp, |
261 | xfs_buf_iodone_t verify) | 261 | const struct xfs_buf_ops *ops) |
262 | { | 262 | { |
263 | xfs_buf_t *bp; | 263 | xfs_buf_t *bp; |
264 | xfs_buf_log_item_t *bip; | 264 | xfs_buf_log_item_t *bip; |
@@ -266,7 +266,7 @@ xfs_trans_read_buf_map( | |||
266 | 266 | ||
267 | *bpp = NULL; | 267 | *bpp = NULL; |
268 | if (!tp) { | 268 | if (!tp) { |
269 | bp = xfs_buf_read_map(target, map, nmaps, flags, verify); | 269 | bp = xfs_buf_read_map(target, map, nmaps, flags, ops); |
270 | if (!bp) | 270 | if (!bp) |
271 | return (flags & XBF_TRYLOCK) ? | 271 | return (flags & XBF_TRYLOCK) ? |
272 | EAGAIN : XFS_ERROR(ENOMEM); | 272 | EAGAIN : XFS_ERROR(ENOMEM); |
@@ -315,7 +315,7 @@ xfs_trans_read_buf_map( | |||
315 | ASSERT(!XFS_BUF_ISASYNC(bp)); | 315 | ASSERT(!XFS_BUF_ISASYNC(bp)); |
316 | ASSERT(bp->b_iodone == NULL); | 316 | ASSERT(bp->b_iodone == NULL); |
317 | XFS_BUF_READ(bp); | 317 | XFS_BUF_READ(bp); |
318 | bp->b_iodone = verify; | 318 | bp->b_ops = ops; |
319 | xfsbdstrat(tp->t_mountp, bp); | 319 | xfsbdstrat(tp->t_mountp, bp); |
320 | error = xfs_buf_iowait(bp); | 320 | error = xfs_buf_iowait(bp); |
321 | if (error) { | 321 | if (error) { |
@@ -352,7 +352,7 @@ xfs_trans_read_buf_map( | |||
352 | return 0; | 352 | return 0; |
353 | } | 353 | } |
354 | 354 | ||
355 | bp = xfs_buf_read_map(target, map, nmaps, flags, verify); | 355 | bp = xfs_buf_read_map(target, map, nmaps, flags, ops); |
356 | if (bp == NULL) { | 356 | if (bp == NULL) { |
357 | *bpp = NULL; | 357 | *bpp = NULL; |
358 | return (flags & XBF_TRYLOCK) ? | 358 | return (flags & XBF_TRYLOCK) ? |