Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 612cfbfe174a89d565363fff7f3961a2dda5fb71

Authored by Dave Chinner
Committed by Ben Myers
1 parent cfb0285222
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

xfs: add pre-write metadata buffer verifier callbacks 

These verifiers are essentially the same code as the read verifiers,
but do not require ioend processing. Hence factor the read verifier
functions and add a new write verifier wrapper that is used as the
callback.

This is done as one large patch for all verifiers rather than one
patch per verifier as the change is largely mechanical. This
includes hooking up the write verifier via the read verifier
function.

Hooking up the write verifier for buffers obtained via
xfs_trans_get_buf() will be done in a separate patch as that touches
code in many different places rather than just the verifier
functions.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

Showing 20 changed files with 273 additions and 56 deletions Side-by-side Diff

... ... @@ -430,8 +430,8 @@
430 430 return 0;
431 431 }
432 432  
433   -void
434   -xfs_agfl_read_verify(
  433 +static void
  434 +xfs_agfl_verify(
435 435 struct xfs_buf *bp)
436 436 {
437 437 #ifdef WHEN_CRCS_COME_ALONG
... ... @@ -463,6 +463,21 @@
463 463 xfs_buf_ioerror(bp, EFSCORRUPTED);
464 464 }
465 465 #endif
  466 +}
  467 +
  468 +static void
  469 +xfs_agfl_write_verify(
  470 + struct xfs_buf *bp)
  471 +{
  472 + xfs_agfl_verify(bp);
  473 +}
  474 +
  475 +void
  476 +xfs_agfl_read_verify(
  477 + struct xfs_buf *bp)
  478 +{
  479 + xfs_agfl_verify(bp);
  480 + bp->b_pre_io = xfs_agfl_write_verify;
466 481 bp->b_iodone = NULL;
467 482 xfs_buf_ioend(bp, 0);
468 483 }
... ... @@ -2129,7 +2144,7 @@
2129 2144 }
2130 2145  
2131 2146 static void
2132   -xfs_agf_read_verify(
  2147 +xfs_agf_verify(
2133 2148 struct xfs_buf *bp)
2134 2149 {
2135 2150 struct xfs_mount *mp = bp->b_target->bt_mount;
2136 2151  
... ... @@ -2164,7 +2179,21 @@
2164 2179 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, agf);
2165 2180 xfs_buf_ioerror(bp, EFSCORRUPTED);
2166 2181 }
  2182 +}
2167 2183  
  2184 +static void
  2185 +xfs_agf_write_verify(
  2186 + struct xfs_buf *bp)
  2187 +{
  2188 + xfs_agf_verify(bp);
  2189 +}
  2190 +
  2191 +void
  2192 +xfs_agf_read_verify(
  2193 + struct xfs_buf *bp)
  2194 +{
  2195 + xfs_agf_verify(bp);
  2196 + bp->b_pre_io = xfs_agf_write_verify;
2168 2197 bp->b_iodone = NULL;
2169 2198 xfs_buf_ioend(bp, 0);
2170 2199 }
fs/xfs/xfs_alloc_btree.c
Diff comments   View file @ 612cfbf
... ... @@ -272,8 +272,8 @@
272 272 return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
273 273 }
274 274  
275   -void
276   -xfs_allocbt_read_verify(
  275 +static void
  276 +xfs_allocbt_verify(
277 277 struct xfs_buf *bp)
278 278 {
279 279 struct xfs_mount *mp = bp->b_target->bt_mount;
280 280  
281 281  
... ... @@ -323,11 +323,24 @@
323 323  
324 324 if (!sblock_ok) {
325 325 trace_xfs_btree_corrupt(bp, _RET_IP_);
326   - XFS_CORRUPTION_ERROR("xfs_allocbt_read_verify",
327   - XFS_ERRLEVEL_LOW, mp, block);
  326 + XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, block);
328 327 xfs_buf_ioerror(bp, EFSCORRUPTED);
329 328 }
  329 +}
330 330  
  331 +static void
  332 +xfs_allocbt_write_verify(
  333 + struct xfs_buf *bp)
  334 +{
  335 + xfs_allocbt_verify(bp);
  336 +}
  337 +
  338 +void
  339 +xfs_allocbt_read_verify(
  340 + struct xfs_buf *bp)
  341 +{
  342 + xfs_allocbt_verify(bp);
  343 + bp->b_pre_io = xfs_allocbt_write_verify;
331 344 bp->b_iodone = NULL;
332 345 xfs_buf_ioend(bp, 0);
333 346 }
fs/xfs/xfs_attr_leaf.c
Diff comments   View file @ 612cfbf
... ... @@ -88,7 +88,7 @@
88 88 xfs_mount_t *mp);
89 89 STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);
90 90  
91   -void
  91 +static void
92 92 xfs_attr_leaf_verify(
93 93 struct xfs_buf *bp)
94 94 {
95 95  
96 96  
... ... @@ -101,11 +101,26 @@
101 101 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, hdr);
102 102 xfs_buf_ioerror(bp, EFSCORRUPTED);
103 103 }
  104 +}
104 105  
  106 +static void
  107 +xfs_attr_leaf_write_verify(
  108 + struct xfs_buf *bp)
  109 +{
  110 + xfs_attr_leaf_verify(bp);
  111 +}
  112 +
  113 +void
  114 +xfs_attr_leaf_read_verify(
  115 + struct xfs_buf *bp)
  116 +{
  117 + xfs_attr_leaf_verify(bp);
  118 + bp->b_pre_io = xfs_attr_leaf_write_verify;
105 119 bp->b_iodone = NULL;
106 120 xfs_buf_ioend(bp, 0);
107 121 }
108 122  
  123 +
109 124 int
110 125 xfs_attr_leaf_read(
111 126 struct xfs_trans *tp,
... ... @@ -115,7 +130,7 @@
115 130 struct xfs_buf **bpp)
116 131 {
117 132 return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
118   - XFS_ATTR_FORK, xfs_attr_leaf_verify);
  133 + XFS_ATTR_FORK, xfs_attr_leaf_read_verify);
119 134 }
120 135  
121 136 /*========================================================================
fs/xfs/xfs_attr_leaf.h
Diff comments   View file @ 612cfbf
... ... @@ -264,7 +264,7 @@
264 264 int xfs_attr_leaf_read(struct xfs_trans *tp, struct xfs_inode *dp,
265 265 xfs_dablk_t bno, xfs_daddr_t mappedbno,
266 266 struct xfs_buf **bpp);
267   -void xfs_attr_leaf_verify(struct xfs_buf *bp);
  267 +void xfs_attr_leaf_read_verify(struct xfs_buf *bp);
268 268  
269 269 #endif /* __XFS_ATTR_LEAF_H__ */
fs/xfs/xfs_bmap_btree.c
Diff comments   View file @ 612cfbf
... ... @@ -708,8 +708,8 @@
708 708 cur->bc_rec.b.br_startoff;
709 709 }
710 710  
711   -void
712   -xfs_bmbt_read_verify(
  711 +static void
  712 +xfs_bmbt_verify(
713 713 struct xfs_buf *bp)
714 714 {
715 715 struct xfs_mount *mp = bp->b_target->bt_mount;
716 716  
717 717  
... ... @@ -744,11 +744,24 @@
744 744  
745 745 if (!lblock_ok) {
746 746 trace_xfs_btree_corrupt(bp, _RET_IP_);
747   - XFS_CORRUPTION_ERROR("xfs_bmbt_read_verify",
748   - XFS_ERRLEVEL_LOW, mp, block);
  747 + XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, block);
749 748 xfs_buf_ioerror(bp, EFSCORRUPTED);
750 749 }
  750 +}
751 751  
  752 +static void
  753 +xfs_bmbt_write_verify(
  754 + struct xfs_buf *bp)
  755 +{
  756 + xfs_bmbt_verify(bp);
  757 +}
  758 +
  759 +void
  760 +xfs_bmbt_read_verify(
  761 + struct xfs_buf *bp)
  762 +{
  763 + xfs_bmbt_verify(bp);
  764 + bp->b_pre_io = xfs_bmbt_write_verify;
752 765 bp->b_iodone = NULL;
753 766 xfs_buf_ioend(bp, 0);
754 767 }
fs/xfs/xfs_da_btree.c
Diff comments   View file @ 612cfbf
... ... @@ -92,7 +92,7 @@
92 92 STATIC void xfs_da_state_kill_altpath(xfs_da_state_t *state);
93 93  
94 94 static void
95   -__xfs_da_node_verify(
  95 +xfs_da_node_verify(
96 96 struct xfs_buf *bp)
97 97 {
98 98 struct xfs_mount *mp = bp->b_target->bt_mount;
99 99  
... ... @@ -108,12 +108,17 @@
108 108 xfs_buf_ioerror(bp, EFSCORRUPTED);
109 109 }
110 110  
111   - bp->b_iodone = NULL;
112   - xfs_buf_ioend(bp, 0);
113 111 }
114 112  
115 113 static void
116   -xfs_da_node_verify(
  114 +xfs_da_node_write_verify(
  115 + struct xfs_buf *bp)
  116 +{
  117 + xfs_da_node_verify(bp);
  118 +}
  119 +
  120 +static void
  121 +xfs_da_node_read_verify(
117 122 struct xfs_buf *bp)
118 123 {
119 124 struct xfs_mount *mp = bp->b_target->bt_mount;
120 125  
121 126  
122 127  
123 128  
... ... @@ -121,21 +126,22 @@
121 126  
122 127 switch (be16_to_cpu(info->magic)) {
123 128 case XFS_DA_NODE_MAGIC:
124   - __xfs_da_node_verify(bp);
125   - return;
  129 + xfs_da_node_verify(bp);
  130 + break;
126 131 case XFS_ATTR_LEAF_MAGIC:
127   - xfs_attr_leaf_verify(bp);
  132 + xfs_attr_leaf_read_verify(bp);
128 133 return;
129 134 case XFS_DIR2_LEAFN_MAGIC:
130   - xfs_dir2_leafn_verify(bp);
  135 + xfs_dir2_leafn_read_verify(bp);
131 136 return;
132 137 default:
  138 + XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW,
  139 + mp, info);
  140 + xfs_buf_ioerror(bp, EFSCORRUPTED);
133 141 break;
134 142 }
135 143  
136   - XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, info);
137   - xfs_buf_ioerror(bp, EFSCORRUPTED);
138   -
  144 + bp->b_pre_io = xfs_da_node_write_verify;
139 145 bp->b_iodone = NULL;
140 146 xfs_buf_ioend(bp, 0);
141 147 }
... ... @@ -150,7 +156,7 @@
150 156 int which_fork)
151 157 {
152 158 return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
153   - which_fork, xfs_da_node_verify);
  159 + which_fork, xfs_da_node_read_verify);
154 160 }
155 161  
156 162 /*========================================================================
157 163  
... ... @@ -816,7 +822,14 @@
816 822 xfs_da_blkinfo_onlychild_validate(bp->b_addr,
817 823 be16_to_cpu(oldroot->hdr.level));
818 824  
  825 + /*
  826 + * This could be copying a leaf back into the root block in the case of
  827 + * there only being a single leaf block left in the tree. Hence we have
  828 + * to update the pre_io pointer as well to match the buffer type change
  829 + * that could occur.
  830 + */
819 831 memcpy(root_blk->bp->b_addr, bp->b_addr, state->blocksize);
  832 + root_blk->bp->b_pre_io = bp->b_pre_io;
820 833 xfs_trans_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1);
821 834 error = xfs_da_shrink_inode(args, child, bp);
822 835 return(error);
fs/xfs/xfs_dir2_block.c
Diff comments   View file @ 612cfbf
... ... @@ -71,7 +71,21 @@
71 71 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, hdr);
72 72 xfs_buf_ioerror(bp, EFSCORRUPTED);
73 73 }
  74 +}
74 75  
  76 +static void
  77 +xfs_dir2_block_write_verify(
  78 + struct xfs_buf *bp)
  79 +{
  80 + xfs_dir2_block_verify(bp);
  81 +}
  82 +
  83 +void
  84 +xfs_dir2_block_read_verify(
  85 + struct xfs_buf *bp)
  86 +{
  87 + xfs_dir2_block_verify(bp);
  88 + bp->b_pre_io = xfs_dir2_block_write_verify;
75 89 bp->b_iodone = NULL;
76 90 xfs_buf_ioend(bp, 0);
77 91 }
... ... @@ -85,7 +99,7 @@
85 99 struct xfs_mount *mp = dp->i_mount;
86 100  
87 101 return xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, bpp,
88   - XFS_DATA_FORK, xfs_dir2_block_verify);
  102 + XFS_DATA_FORK, xfs_dir2_block_read_verify);
89 103 }
90 104  
91 105 static void
fs/xfs/xfs_dir2_data.c
Diff comments   View file @ 612cfbf
... ... @@ -200,11 +200,26 @@
200 200 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, hdr);
201 201 xfs_buf_ioerror(bp, EFSCORRUPTED);
202 202 }
  203 +}
203 204  
  205 +static void
  206 +xfs_dir2_data_write_verify(
  207 + struct xfs_buf *bp)
  208 +{
  209 + xfs_dir2_data_verify(bp);
  210 +}
  211 +
  212 +void
  213 +xfs_dir2_data_read_verify(
  214 + struct xfs_buf *bp)
  215 +{
  216 + xfs_dir2_data_verify(bp);
  217 + bp->b_pre_io = xfs_dir2_data_write_verify;
204 218 bp->b_iodone = NULL;
205 219 xfs_buf_ioend(bp, 0);
206 220 }
207 221  
  222 +
208 223 int
209 224 xfs_dir2_data_read(
210 225 struct xfs_trans *tp,
... ... @@ -214,7 +229,7 @@
214 229 struct xfs_buf **bpp)
215 230 {
216 231 return xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp,
217   - XFS_DATA_FORK, xfs_dir2_data_verify);
  232 + XFS_DATA_FORK, xfs_dir2_data_read_verify);
218 233 }
219 234  
220 235 int
... ... @@ -225,7 +240,7 @@
225 240 xfs_daddr_t mapped_bno)
226 241 {
227 242 return xfs_da_reada_buf(tp, dp, bno, mapped_bno,
228   - XFS_DATA_FORK, xfs_dir2_data_verify);
  243 + XFS_DATA_FORK, xfs_dir2_data_read_verify);
229 244 }
230 245  
231 246 /*
fs/xfs/xfs_dir2_leaf.c
Diff comments   View file @ 612cfbf
... ... @@ -62,23 +62,40 @@
62 62 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, hdr);
63 63 xfs_buf_ioerror(bp, EFSCORRUPTED);
64 64 }
  65 +}
65 66  
  67 +static void
  68 +xfs_dir2_leaf1_write_verify(
  69 + struct xfs_buf *bp)
  70 +{
  71 + xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAF1_MAGIC));
  72 +}
  73 +
  74 +static void
  75 +xfs_dir2_leaf1_read_verify(
  76 + struct xfs_buf *bp)
  77 +{
  78 + xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAF1_MAGIC));
  79 + bp->b_pre_io = xfs_dir2_leaf1_write_verify;
66 80 bp->b_iodone = NULL;
67 81 xfs_buf_ioend(bp, 0);
68 82 }
69 83  
70 84 static void
71   -xfs_dir2_leaf1_verify(
72   - struct xfs_buf *bp)
  85 +xfs_dir2_leafn_write_verify(
  86 + struct xfs_buf *bp)
73 87 {
74   - xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAF1_MAGIC));
  88 + xfs_dir2_leaf_verify(bp, cpu_to_be16(XFS_DIR2_LEAFN_MAGIC));
75 89 }
76 90  
77 91 void
78   -xfs_dir2_leafn_verify(
79   - struct xfs_buf *bp)
  92 +xfs_dir2_leafn_read_verify(
  93 + struct xfs_buf *bp)
80 94 {
81 95 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);
82 99 }
83 100  
84 101 static int
... ... @@ -90,7 +107,7 @@
90 107 struct xfs_buf **bpp)
91 108 {
92 109 return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
93   - XFS_DATA_FORK, xfs_dir2_leaf1_verify);
  110 + XFS_DATA_FORK, xfs_dir2_leaf1_read_verify);
94 111 }
95 112  
96 113 int
... ... @@ -102,7 +119,7 @@
102 119 struct xfs_buf **bpp)
103 120 {
104 121 return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
105   - XFS_DATA_FORK, xfs_dir2_leafn_verify);
  122 + XFS_DATA_FORK, xfs_dir2_leafn_read_verify);
106 123 }
107 124  
108 125 /*
fs/xfs/xfs_dir2_node.c
Diff comments   View file @ 612cfbf
... ... @@ -69,11 +69,26 @@
69 69 XFS_ERRLEVEL_LOW, mp, hdr);
70 70 xfs_buf_ioerror(bp, EFSCORRUPTED);
71 71 }
  72 +}
72 73  
  74 +static void
  75 +xfs_dir2_free_write_verify(
  76 + struct xfs_buf *bp)
  77 +{
  78 + xfs_dir2_free_verify(bp);
  79 +}
  80 +
  81 +void
  82 +xfs_dir2_free_read_verify(
  83 + struct xfs_buf *bp)
  84 +{
  85 + xfs_dir2_free_verify(bp);
  86 + bp->b_pre_io = xfs_dir2_free_write_verify;
73 87 bp->b_iodone = NULL;
74 88 xfs_buf_ioend(bp, 0);
75 89 }
76 90  
  91 +
77 92 static int
78 93 __xfs_dir2_free_read(
79 94 struct xfs_trans *tp,
... ... @@ -83,7 +98,7 @@
83 98 struct xfs_buf **bpp)
84 99 {
85 100 return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
86   - XFS_DATA_FORK, xfs_dir2_free_verify);
  101 + XFS_DATA_FORK, xfs_dir2_free_read_verify);
87 102 }
88 103  
89 104 int
fs/xfs/xfs_dir2_priv.h
Diff comments   View file @ 612cfbf
... ... @@ -72,7 +72,7 @@
72 72 xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);
73 73  
74 74 /* xfs_dir2_leaf.c */
75   -extern void xfs_dir2_leafn_verify(struct xfs_buf *bp);
  75 +extern void xfs_dir2_leafn_read_verify(struct xfs_buf *bp);
76 76 extern int xfs_dir2_leafn_read(struct xfs_trans *tp, struct xfs_inode *dp,
77 77 xfs_dablk_t fbno, xfs_daddr_t mappedbno, struct xfs_buf **bpp);
78 78 extern int xfs_dir2_block_to_leaf(struct xfs_da_args *args,
... ... @@ -360,8 +360,8 @@
360 360 return (error);
361 361 }
362 362  
363   -void
364   -xfs_dquot_read_verify(
  363 +static void
  364 +xfs_dquot_buf_verify(
365 365 struct xfs_buf *bp)
366 366 {
367 367 struct xfs_mount *mp = bp->b_target->bt_mount;
368 368  
... ... @@ -388,12 +388,26 @@
388 388 error = xfs_qm_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
389 389 "xfs_dquot_read_verify");
390 390 if (error) {
391   - XFS_CORRUPTION_ERROR("xfs_dquot_read_verify",
392   - XFS_ERRLEVEL_LOW, mp, d);
  391 + XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, d);
393 392 xfs_buf_ioerror(bp, EFSCORRUPTED);
394 393 break;
395 394 }
396 395 }
  396 +}
  397 +
  398 +static void
  399 +xfs_dquot_buf_write_verify(
  400 + struct xfs_buf *bp)
  401 +{
  402 + xfs_dquot_buf_verify(bp);
  403 +}
  404 +
  405 +void
  406 +xfs_dquot_buf_read_verify(
  407 + struct xfs_buf *bp)
  408 +{
  409 + xfs_dquot_buf_verify(bp);
  410 + bp->b_pre_io = xfs_dquot_buf_write_verify;
397 411 bp->b_iodone = NULL;
398 412 xfs_buf_ioend(bp, 0);
399 413 }
... ... @@ -413,7 +427,7 @@
413 427  
414 428 /*
415 429 * Read the buffer without verification so we get the corrupted
416   - * buffer returned to us.
  430 + * buffer returned to us. make sure we verify it on write, though.
417 431 */
418 432 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, dqp->q_blkno,
419 433 mp->m_quotainfo->qi_dqchunklen,
... ... @@ -423,6 +437,7 @@
423 437 ASSERT(*bpp == NULL);
424 438 return XFS_ERROR(error);
425 439 }
  440 + (*bpp)->b_pre_io = xfs_dquot_buf_write_verify;
426 441  
427 442 ASSERT(xfs_buf_islocked(*bpp));
428 443 d = (struct xfs_dqblk *)(*bpp)->b_addr;
... ... @@ -521,7 +536,7 @@
521 536 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
522 537 dqp->q_blkno,
523 538 mp->m_quotainfo->qi_dqchunklen,
524   - 0, &bp, xfs_dquot_read_verify);
  539 + 0, &bp, xfs_dquot_buf_read_verify);
525 540  
526 541 if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
527 542 xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff *
... ... @@ -140,7 +140,7 @@
140 140  
141 141 extern int xfs_qm_dqread(struct xfs_mount *, xfs_dqid_t, uint,
142 142 uint, struct xfs_dquot **);
143   -extern void xfs_dquot_read_verify(struct xfs_buf *bp);
  143 +extern void xfs_dquot_buf_read_verify(struct xfs_buf *bp);
144 144 extern void xfs_qm_dqdestroy(xfs_dquot_t *);
145 145 extern int xfs_qm_dqflush(struct xfs_dquot *, struct xfs_buf **);
146 146 extern void xfs_qm_dqunpin_wait(xfs_dquot_t *);
... ... @@ -1473,7 +1473,7 @@
1473 1473 #endif
1474 1474  
1475 1475 static void
1476   -xfs_agi_read_verify(
  1476 +xfs_agi_verify(
1477 1477 struct xfs_buf *bp)
1478 1478 {
1479 1479 struct xfs_mount *mp = bp->b_target->bt_mount;
... ... @@ -1502,6 +1502,21 @@
1502 1502 xfs_buf_ioerror(bp, EFSCORRUPTED);
1503 1503 }
1504 1504 xfs_check_agi_unlinked(agi);
  1505 +}
  1506 +
  1507 +static void
  1508 +xfs_agi_write_verify(
  1509 + struct xfs_buf *bp)
  1510 +{
  1511 + xfs_agi_verify(bp);
  1512 +}
  1513 +
  1514 +void
  1515 +xfs_agi_read_verify(
  1516 + struct xfs_buf *bp)
  1517 +{
  1518 + xfs_agi_verify(bp);
  1519 + bp->b_pre_io = xfs_agi_write_verify;
1505 1520 bp->b_iodone = NULL;
1506 1521 xfs_buf_ioend(bp, 0);
1507 1522 }
fs/xfs/xfs_ialloc_btree.c
Diff comments   View file @ 612cfbf
... ... @@ -183,7 +183,7 @@
183 183 }
184 184  
185 185 void
186   -xfs_inobt_read_verify(
  186 +xfs_inobt_verify(
187 187 struct xfs_buf *bp)
188 188 {
189 189 struct xfs_mount *mp = bp->b_target->bt_mount;
190 190  
191 191  
... ... @@ -211,11 +211,24 @@
211 211  
212 212 if (!sblock_ok) {
213 213 trace_xfs_btree_corrupt(bp, _RET_IP_);
214   - XFS_CORRUPTION_ERROR("xfs_inobt_read_verify",
215   - XFS_ERRLEVEL_LOW, mp, block);
  214 + XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, block);
216 215 xfs_buf_ioerror(bp, EFSCORRUPTED);
217 216 }
  217 +}
218 218  
  219 +static void
  220 +xfs_inobt_write_verify(
  221 + struct xfs_buf *bp)
  222 +{
  223 + xfs_inobt_verify(bp);
  224 +}
  225 +
  226 +void
  227 +xfs_inobt_read_verify(
  228 + struct xfs_buf *bp)
  229 +{
  230 + xfs_inobt_verify(bp);
  231 + bp->b_pre_io = xfs_inobt_write_verify;
219 232 bp->b_iodone = NULL;
220 233 xfs_buf_ioend(bp, 0);
221 234 }
... ... @@ -382,7 +382,7 @@
382 382 }
383 383 #endif
384 384  
385   -void
  385 +static void
386 386 xfs_inode_buf_verify(
387 387 struct xfs_buf *bp)
388 388 {
... ... @@ -418,6 +418,21 @@
418 418 }
419 419 }
420 420 xfs_inobp_check(mp, bp);
  421 +}
  422 +
  423 +static void
  424 +xfs_inode_buf_write_verify(
  425 + struct xfs_buf *bp)
  426 +{
  427 + xfs_inode_buf_verify(bp);
  428 +}
  429 +
  430 +void
  431 +xfs_inode_buf_read_verify(
  432 + struct xfs_buf *bp)
  433 +{
  434 + xfs_inode_buf_verify(bp);
  435 + bp->b_pre_io = xfs_inode_buf_write_verify;
421 436 bp->b_iodone = NULL;
422 437 xfs_buf_ioend(bp, 0);
423 438 }
... ... @@ -447,7 +462,7 @@
447 462 buf_flags |= XBF_UNMAPPED;
448 463 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno,
449 464 (int)imap->im_len, buf_flags, &bp,
450   - xfs_inode_buf_verify);
  465 + xfs_inode_buf_read_verify);
451 466 if (error) {
452 467 if (error == EAGAIN) {
453 468 ASSERT(buf_flags & XBF_TRYLOCK);
... ... @@ -554,7 +554,7 @@
554 554 struct xfs_buf **, uint, uint);
555 555 int xfs_iread(struct xfs_mount *, struct xfs_trans *,
556 556 struct xfs_inode *, uint);
557   -void xfs_inode_buf_verify(struct xfs_buf *);
  557 +void xfs_inode_buf_read_verify(struct xfs_buf *);
558 558 void xfs_dinode_to_disk(struct xfs_dinode *,
559 559 struct xfs_icdinode *);
560 560 void xfs_idestroy_fork(struct xfs_inode *, int);
... ... @@ -397,7 +397,7 @@
397 397 & ~r.ir_free)
398 398 xfs_btree_reada_bufs(mp, agno,
399 399 agbno, nbcluster,
400   - xfs_inode_buf_verify);
  400 + xfs_inode_buf_read_verify);
401 401 }
402 402 irbp->ir_startino = r.ir_startino;
403 403 irbp->ir_freecount = r.ir_freecount;
... ... @@ -612,8 +612,8 @@
612 612 }
613 613 }
614 614  
615   -void
616   -xfs_sb_read_verify(
  615 +static void
  616 +xfs_sb_verify(
617 617 struct xfs_buf *bp)
618 618 {
619 619 struct xfs_mount *mp = bp->b_target->bt_mount;
... ... @@ -629,6 +629,21 @@
629 629 error = xfs_mount_validate_sb(mp, &sb, bp->b_bn == XFS_SB_DADDR);
630 630 if (error)
631 631 xfs_buf_ioerror(bp, error);
  632 +}
  633 +
  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(
  643 + struct xfs_buf *bp)
  644 +{
  645 + xfs_sb_verify(bp);
  646 + bp->b_pre_io = xfs_sb_write_verify;
632 647 bp->b_iodone = NULL;
633 648 xfs_buf_ioend(bp, 0);
634 649 }
... ... @@ -893,7 +893,7 @@
893 893 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
894 894 XFS_FSB_TO_DADDR(mp, bno),
895 895 mp->m_quotainfo->qi_dqchunklen, 0, &bp,
896   - xfs_dquot_read_verify);
  896 + xfs_dquot_buf_read_verify);
897 897 if (error)
898 898 break;
899 899