diff options
author | Eric Sandeen <sandeen@sandeen.net> | 2014-02-26 23:23:10 -0500 |
---|---|---|
committer | Dave Chinner <david@fromorbit.com> | 2014-02-26 23:23:10 -0500 |
commit | ce5028cfe3ca48695b6a128638fe224426d37ebe (patch) | |
tree | e6b62cc91ec0fb74343a3e231d11dd16b55be2b5 /fs | |
parent | db9355c296eb71271bb3807ad4a9d43f6b3c35d3 (diff) |
xfs: modify verifiers to differentiate CRC from other errors
Modify all read & write verifiers to differentiate
between CRC errors and other inconsistencies.
This sets the appropriate error number on bp->b_error,
and then calls xfs_verifier_error() if something went
wrong. That function will issue the appropriate message
to the user.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
Diffstat (limited to 'fs')
-rw-r--r-- | fs/xfs/xfs_alloc.c | 37 | ||||
-rw-r--r-- | fs/xfs/xfs_alloc_btree.c | 15 | ||||
-rw-r--r-- | fs/xfs/xfs_attr_leaf.c | 14 | ||||
-rw-r--r-- | fs/xfs/xfs_attr_remote.c | 15 | ||||
-rw-r--r-- | fs/xfs/xfs_bmap_btree.c | 16 | ||||
-rw-r--r-- | fs/xfs/xfs_da_btree.c | 14 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_block.c | 14 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_data.c | 17 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_leaf.c | 14 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_node.c | 14 | ||||
-rw-r--r-- | fs/xfs/xfs_dquot_buf.c | 11 | ||||
-rw-r--r-- | fs/xfs/xfs_ialloc.c | 21 | ||||
-rw-r--r-- | fs/xfs/xfs_ialloc_btree.c | 15 | ||||
-rw-r--r-- | fs/xfs/xfs_inode_buf.c | 3 | ||||
-rw-r--r-- | fs/xfs/xfs_sb.c | 10 | ||||
-rw-r--r-- | fs/xfs/xfs_symlink_remote.c | 12 |
16 files changed, 125 insertions, 117 deletions
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c index 9c7cf3d060a6..c1cf6a336a72 100644 --- a/fs/xfs/xfs_alloc.c +++ b/fs/xfs/xfs_alloc.c | |||
@@ -474,7 +474,6 @@ xfs_agfl_read_verify( | |||
474 | struct xfs_buf *bp) | 474 | struct xfs_buf *bp) |
475 | { | 475 | { |
476 | struct xfs_mount *mp = bp->b_target->bt_mount; | 476 | struct xfs_mount *mp = bp->b_target->bt_mount; |
477 | int agfl_ok = 1; | ||
478 | 477 | ||
479 | /* | 478 | /* |
480 | * There is no verification of non-crc AGFLs because mkfs does not | 479 | * There is no verification of non-crc AGFLs because mkfs does not |
@@ -485,14 +484,13 @@ xfs_agfl_read_verify( | |||
485 | if (!xfs_sb_version_hascrc(&mp->m_sb)) | 484 | if (!xfs_sb_version_hascrc(&mp->m_sb)) |
486 | return; | 485 | return; |
487 | 486 | ||
488 | agfl_ok = xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF); | 487 | if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF)) |
489 | 488 | xfs_buf_ioerror(bp, EFSBADCRC); | |
490 | agfl_ok = agfl_ok && xfs_agfl_verify(bp); | 489 | else if (!xfs_agfl_verify(bp)) |
491 | |||
492 | if (!agfl_ok) { | ||
493 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
494 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 490 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
495 | } | 491 | |
492 | if (bp->b_error) | ||
493 | xfs_verifier_error(bp); | ||
496 | } | 494 | } |
497 | 495 | ||
498 | static void | 496 | static void |
@@ -507,8 +505,8 @@ xfs_agfl_write_verify( | |||
507 | return; | 505 | return; |
508 | 506 | ||
509 | if (!xfs_agfl_verify(bp)) { | 507 | if (!xfs_agfl_verify(bp)) { |
510 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
511 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 508 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
509 | xfs_verifier_error(bp); | ||
512 | return; | 510 | return; |
513 | } | 511 | } |
514 | 512 | ||
@@ -2236,18 +2234,17 @@ xfs_agf_read_verify( | |||
2236 | struct xfs_buf *bp) | 2234 | struct xfs_buf *bp) |
2237 | { | 2235 | { |
2238 | struct xfs_mount *mp = bp->b_target->bt_mount; | 2236 | struct xfs_mount *mp = bp->b_target->bt_mount; |
2239 | int agf_ok = 1; | ||
2240 | |||
2241 | if (xfs_sb_version_hascrc(&mp->m_sb)) | ||
2242 | agf_ok = xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF); | ||
2243 | 2237 | ||
2244 | agf_ok = agf_ok && xfs_agf_verify(mp, bp); | 2238 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
2245 | 2239 | !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF)) | |
2246 | if (unlikely(XFS_TEST_ERROR(!agf_ok, mp, XFS_ERRTAG_ALLOC_READ_AGF, | 2240 | xfs_buf_ioerror(bp, EFSBADCRC); |
2247 | XFS_RANDOM_ALLOC_READ_AGF))) { | 2241 | else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp, |
2248 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 2242 | XFS_ERRTAG_ALLOC_READ_AGF, |
2243 | XFS_RANDOM_ALLOC_READ_AGF)) | ||
2249 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 2244 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
2250 | } | 2245 | |
2246 | if (bp->b_error) | ||
2247 | xfs_verifier_error(bp); | ||
2251 | } | 2248 | } |
2252 | 2249 | ||
2253 | static void | 2250 | static void |
@@ -2258,8 +2255,8 @@ xfs_agf_write_verify( | |||
2258 | struct xfs_buf_log_item *bip = bp->b_fspriv; | 2255 | struct xfs_buf_log_item *bip = bp->b_fspriv; |
2259 | 2256 | ||
2260 | if (!xfs_agf_verify(mp, bp)) { | 2257 | if (!xfs_agf_verify(mp, bp)) { |
2261 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
2262 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 2258 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
2259 | xfs_verifier_error(bp); | ||
2263 | return; | 2260 | return; |
2264 | } | 2261 | } |
2265 | 2262 | ||
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c index 144d3b0855fb..cc1eadcbb049 100644 --- a/fs/xfs/xfs_alloc_btree.c +++ b/fs/xfs/xfs_alloc_btree.c | |||
@@ -355,12 +355,14 @@ static void | |||
355 | xfs_allocbt_read_verify( | 355 | xfs_allocbt_read_verify( |
356 | struct xfs_buf *bp) | 356 | struct xfs_buf *bp) |
357 | { | 357 | { |
358 | if (!(xfs_btree_sblock_verify_crc(bp) && | 358 | if (!xfs_btree_sblock_verify_crc(bp)) |
359 | xfs_allocbt_verify(bp))) { | 359 | xfs_buf_ioerror(bp, EFSBADCRC); |
360 | trace_xfs_btree_corrupt(bp, _RET_IP_); | 360 | else if (!xfs_allocbt_verify(bp)) |
361 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
362 | bp->b_target->bt_mount, bp->b_addr); | ||
363 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 361 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
362 | |||
363 | if (bp->b_error) { | ||
364 | trace_xfs_btree_corrupt(bp, _RET_IP_); | ||
365 | xfs_verifier_error(bp); | ||
364 | } | 366 | } |
365 | } | 367 | } |
366 | 368 | ||
@@ -370,9 +372,8 @@ xfs_allocbt_write_verify( | |||
370 | { | 372 | { |
371 | if (!xfs_allocbt_verify(bp)) { | 373 | if (!xfs_allocbt_verify(bp)) { |
372 | trace_xfs_btree_corrupt(bp, _RET_IP_); | 374 | trace_xfs_btree_corrupt(bp, _RET_IP_); |
373 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
374 | bp->b_target->bt_mount, bp->b_addr); | ||
375 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 375 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
376 | xfs_verifier_error(bp); | ||
376 | return; | 377 | return; |
377 | } | 378 | } |
378 | xfs_btree_sblock_calc_crc(bp); | 379 | xfs_btree_sblock_calc_crc(bp); |
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c index b5523783f44c..fe9587fab17a 100644 --- a/fs/xfs/xfs_attr_leaf.c +++ b/fs/xfs/xfs_attr_leaf.c | |||
@@ -213,8 +213,8 @@ xfs_attr3_leaf_write_verify( | |||
213 | struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr; | 213 | struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr; |
214 | 214 | ||
215 | if (!xfs_attr3_leaf_verify(bp)) { | 215 | if (!xfs_attr3_leaf_verify(bp)) { |
216 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
217 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 216 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
217 | xfs_verifier_error(bp); | ||
218 | return; | 218 | return; |
219 | } | 219 | } |
220 | 220 | ||
@@ -239,12 +239,14 @@ xfs_attr3_leaf_read_verify( | |||
239 | { | 239 | { |
240 | struct xfs_mount *mp = bp->b_target->bt_mount; | 240 | struct xfs_mount *mp = bp->b_target->bt_mount; |
241 | 241 | ||
242 | if ((xfs_sb_version_hascrc(&mp->m_sb) && | 242 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
243 | !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF)) || | 243 | !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF)) |
244 | !xfs_attr3_leaf_verify(bp)) { | 244 | xfs_buf_ioerror(bp, EFSBADCRC); |
245 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 245 | else if (!xfs_attr3_leaf_verify(bp)) |
246 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 246 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
247 | } | 247 | |
248 | if (bp->b_error) | ||
249 | xfs_verifier_error(bp); | ||
248 | } | 250 | } |
249 | 251 | ||
250 | const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = { | 252 | const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = { |
diff --git a/fs/xfs/xfs_attr_remote.c b/fs/xfs/xfs_attr_remote.c index 5549d69ddb45..6e37823e2932 100644 --- a/fs/xfs/xfs_attr_remote.c +++ b/fs/xfs/xfs_attr_remote.c | |||
@@ -125,7 +125,6 @@ xfs_attr3_rmt_read_verify( | |||
125 | struct xfs_mount *mp = bp->b_target->bt_mount; | 125 | struct xfs_mount *mp = bp->b_target->bt_mount; |
126 | char *ptr; | 126 | char *ptr; |
127 | int len; | 127 | int len; |
128 | bool corrupt = false; | ||
129 | xfs_daddr_t bno; | 128 | xfs_daddr_t bno; |
130 | 129 | ||
131 | /* no verification of non-crc buffers */ | 130 | /* no verification of non-crc buffers */ |
@@ -140,11 +139,11 @@ xfs_attr3_rmt_read_verify( | |||
140 | while (len > 0) { | 139 | while (len > 0) { |
141 | if (!xfs_verify_cksum(ptr, XFS_LBSIZE(mp), | 140 | if (!xfs_verify_cksum(ptr, XFS_LBSIZE(mp), |
142 | XFS_ATTR3_RMT_CRC_OFF)) { | 141 | XFS_ATTR3_RMT_CRC_OFF)) { |
143 | corrupt = true; | 142 | xfs_buf_ioerror(bp, EFSBADCRC); |
144 | break; | 143 | break; |
145 | } | 144 | } |
146 | if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) { | 145 | if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) { |
147 | corrupt = true; | 146 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
148 | break; | 147 | break; |
149 | } | 148 | } |
150 | len -= XFS_LBSIZE(mp); | 149 | len -= XFS_LBSIZE(mp); |
@@ -152,10 +151,9 @@ xfs_attr3_rmt_read_verify( | |||
152 | bno += mp->m_bsize; | 151 | bno += mp->m_bsize; |
153 | } | 152 | } |
154 | 153 | ||
155 | if (corrupt) { | 154 | if (bp->b_error) |
156 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 155 | xfs_verifier_error(bp); |
157 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 156 | else |
158 | } else | ||
159 | ASSERT(len == 0); | 157 | ASSERT(len == 0); |
160 | } | 158 | } |
161 | 159 | ||
@@ -180,9 +178,8 @@ xfs_attr3_rmt_write_verify( | |||
180 | 178 | ||
181 | while (len > 0) { | 179 | while (len > 0) { |
182 | if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) { | 180 | if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) { |
183 | XFS_CORRUPTION_ERROR(__func__, | ||
184 | XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
185 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 181 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
182 | xfs_verifier_error(bp); | ||
186 | return; | 183 | return; |
187 | } | 184 | } |
188 | if (bip) { | 185 | if (bip) { |
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/xfs_bmap_btree.c index 706bc3f777cb..818d546664e7 100644 --- a/fs/xfs/xfs_bmap_btree.c +++ b/fs/xfs/xfs_bmap_btree.c | |||
@@ -780,12 +780,14 @@ static void | |||
780 | xfs_bmbt_read_verify( | 780 | xfs_bmbt_read_verify( |
781 | struct xfs_buf *bp) | 781 | struct xfs_buf *bp) |
782 | { | 782 | { |
783 | if (!(xfs_btree_lblock_verify_crc(bp) && | 783 | if (!xfs_btree_lblock_verify_crc(bp)) |
784 | xfs_bmbt_verify(bp))) { | 784 | xfs_buf_ioerror(bp, EFSBADCRC); |
785 | trace_xfs_btree_corrupt(bp, _RET_IP_); | 785 | else if (!xfs_bmbt_verify(bp)) |
786 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
787 | bp->b_target->bt_mount, bp->b_addr); | ||
788 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 786 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
787 | |||
788 | if (bp->b_error) { | ||
789 | trace_xfs_btree_corrupt(bp, _RET_IP_); | ||
790 | xfs_verifier_error(bp); | ||
789 | } | 791 | } |
790 | } | 792 | } |
791 | 793 | ||
@@ -794,11 +796,9 @@ xfs_bmbt_write_verify( | |||
794 | struct xfs_buf *bp) | 796 | struct xfs_buf *bp) |
795 | { | 797 | { |
796 | if (!xfs_bmbt_verify(bp)) { | 798 | if (!xfs_bmbt_verify(bp)) { |
797 | xfs_warn(bp->b_target->bt_mount, "bmbt daddr 0x%llx failed", bp->b_bn); | ||
798 | trace_xfs_btree_corrupt(bp, _RET_IP_); | 799 | trace_xfs_btree_corrupt(bp, _RET_IP_); |
799 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
800 | bp->b_target->bt_mount, bp->b_addr); | ||
801 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 800 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
801 | xfs_verifier_error(bp); | ||
802 | return; | 802 | return; |
803 | } | 803 | } |
804 | xfs_btree_lblock_calc_crc(bp); | 804 | xfs_btree_lblock_calc_crc(bp); |
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c index 75ef9903551c..1f5af79c0568 100644 --- a/fs/xfs/xfs_da_btree.c +++ b/fs/xfs/xfs_da_btree.c | |||
@@ -185,8 +185,8 @@ xfs_da3_node_write_verify( | |||
185 | struct xfs_da3_node_hdr *hdr3 = bp->b_addr; | 185 | struct xfs_da3_node_hdr *hdr3 = bp->b_addr; |
186 | 186 | ||
187 | if (!xfs_da3_node_verify(bp)) { | 187 | if (!xfs_da3_node_verify(bp)) { |
188 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
189 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 188 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
189 | xfs_verifier_error(bp); | ||
190 | return; | 190 | return; |
191 | } | 191 | } |
192 | 192 | ||
@@ -209,17 +209,20 @@ static void | |||
209 | xfs_da3_node_read_verify( | 209 | xfs_da3_node_read_verify( |
210 | struct xfs_buf *bp) | 210 | struct xfs_buf *bp) |
211 | { | 211 | { |
212 | struct xfs_mount *mp = bp->b_target->bt_mount; | ||
213 | struct xfs_da_blkinfo *info = bp->b_addr; | 212 | struct xfs_da_blkinfo *info = bp->b_addr; |
214 | 213 | ||
215 | switch (be16_to_cpu(info->magic)) { | 214 | switch (be16_to_cpu(info->magic)) { |
216 | case XFS_DA3_NODE_MAGIC: | 215 | case XFS_DA3_NODE_MAGIC: |
217 | if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) | 216 | if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) { |
217 | xfs_buf_ioerror(bp, EFSBADCRC); | ||
218 | break; | 218 | break; |
219 | } | ||
219 | /* fall through */ | 220 | /* fall through */ |
220 | case XFS_DA_NODE_MAGIC: | 221 | case XFS_DA_NODE_MAGIC: |
221 | if (!xfs_da3_node_verify(bp)) | 222 | if (!xfs_da3_node_verify(bp)) { |
223 | xfs_buf_ioerror(bp, EFSCORRUPTED); | ||
222 | break; | 224 | break; |
225 | } | ||
223 | return; | 226 | return; |
224 | case XFS_ATTR_LEAF_MAGIC: | 227 | case XFS_ATTR_LEAF_MAGIC: |
225 | case XFS_ATTR3_LEAF_MAGIC: | 228 | case XFS_ATTR3_LEAF_MAGIC: |
@@ -236,8 +239,7 @@ xfs_da3_node_read_verify( | |||
236 | } | 239 | } |
237 | 240 | ||
238 | /* corrupt block */ | 241 | /* corrupt block */ |
239 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 242 | xfs_verifier_error(bp); |
240 | xfs_buf_ioerror(bp, EFSCORRUPTED); | ||
241 | } | 243 | } |
242 | 244 | ||
243 | const struct xfs_buf_ops xfs_da3_node_buf_ops = { | 245 | const struct xfs_buf_ops xfs_da3_node_buf_ops = { |
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c index 724377eba25a..4f6a38cb83a4 100644 --- a/fs/xfs/xfs_dir2_block.c +++ b/fs/xfs/xfs_dir2_block.c | |||
@@ -89,12 +89,14 @@ xfs_dir3_block_read_verify( | |||
89 | { | 89 | { |
90 | struct xfs_mount *mp = bp->b_target->bt_mount; | 90 | struct xfs_mount *mp = bp->b_target->bt_mount; |
91 | 91 | ||
92 | if ((xfs_sb_version_hascrc(&mp->m_sb) && | 92 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
93 | !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF)) || | 93 | !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF)) |
94 | !xfs_dir3_block_verify(bp)) { | 94 | xfs_buf_ioerror(bp, EFSBADCRC); |
95 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 95 | else if (!xfs_dir3_block_verify(bp)) |
96 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 96 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
97 | } | 97 | |
98 | if (bp->b_error) | ||
99 | xfs_verifier_error(bp); | ||
98 | } | 100 | } |
99 | 101 | ||
100 | static void | 102 | static void |
@@ -106,8 +108,8 @@ xfs_dir3_block_write_verify( | |||
106 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; | 108 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; |
107 | 109 | ||
108 | if (!xfs_dir3_block_verify(bp)) { | 110 | if (!xfs_dir3_block_verify(bp)) { |
109 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
110 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 111 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
112 | xfs_verifier_error(bp); | ||
111 | return; | 113 | return; |
112 | } | 114 | } |
113 | 115 | ||
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c index 74ae85e2556c..afa4ad523f3f 100644 --- a/fs/xfs/xfs_dir2_data.c +++ b/fs/xfs/xfs_dir2_data.c | |||
@@ -241,7 +241,6 @@ static void | |||
241 | xfs_dir3_data_reada_verify( | 241 | xfs_dir3_data_reada_verify( |
242 | struct xfs_buf *bp) | 242 | struct xfs_buf *bp) |
243 | { | 243 | { |
244 | struct xfs_mount *mp = bp->b_target->bt_mount; | ||
245 | struct xfs_dir2_data_hdr *hdr = bp->b_addr; | 244 | struct xfs_dir2_data_hdr *hdr = bp->b_addr; |
246 | 245 | ||
247 | switch (hdr->magic) { | 246 | switch (hdr->magic) { |
@@ -255,8 +254,8 @@ xfs_dir3_data_reada_verify( | |||
255 | xfs_dir3_data_verify(bp); | 254 | xfs_dir3_data_verify(bp); |
256 | return; | 255 | return; |
257 | default: | 256 | default: |
258 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, hdr); | ||
259 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 257 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
258 | xfs_verifier_error(bp); | ||
260 | break; | 259 | break; |
261 | } | 260 | } |
262 | } | 261 | } |
@@ -267,12 +266,14 @@ xfs_dir3_data_read_verify( | |||
267 | { | 266 | { |
268 | struct xfs_mount *mp = bp->b_target->bt_mount; | 267 | struct xfs_mount *mp = bp->b_target->bt_mount; |
269 | 268 | ||
270 | if ((xfs_sb_version_hascrc(&mp->m_sb) && | 269 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
271 | !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF)) || | 270 | !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF)) |
272 | !xfs_dir3_data_verify(bp)) { | 271 | xfs_buf_ioerror(bp, EFSBADCRC); |
273 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 272 | else if (!xfs_dir3_data_verify(bp)) |
274 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 273 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
275 | } | 274 | |
275 | if (bp->b_error) | ||
276 | xfs_verifier_error(bp); | ||
276 | } | 277 | } |
277 | 278 | ||
278 | static void | 279 | static void |
@@ -284,8 +285,8 @@ xfs_dir3_data_write_verify( | |||
284 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; | 285 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; |
285 | 286 | ||
286 | if (!xfs_dir3_data_verify(bp)) { | 287 | if (!xfs_dir3_data_verify(bp)) { |
287 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
288 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 288 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
289 | xfs_verifier_error(bp); | ||
289 | return; | 290 | return; |
290 | } | 291 | } |
291 | 292 | ||
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c index dffb61bd0bc5..d36e97df1187 100644 --- a/fs/xfs/xfs_dir2_leaf.c +++ b/fs/xfs/xfs_dir2_leaf.c | |||
@@ -179,12 +179,14 @@ __read_verify( | |||
179 | { | 179 | { |
180 | struct xfs_mount *mp = bp->b_target->bt_mount; | 180 | struct xfs_mount *mp = bp->b_target->bt_mount; |
181 | 181 | ||
182 | if ((xfs_sb_version_hascrc(&mp->m_sb) && | 182 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
183 | !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF)) || | 183 | !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF)) |
184 | !xfs_dir3_leaf_verify(bp, magic)) { | 184 | xfs_buf_ioerror(bp, EFSBADCRC); |
185 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 185 | else if (!xfs_dir3_leaf_verify(bp, magic)) |
186 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 186 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
187 | } | 187 | |
188 | if (bp->b_error) | ||
189 | xfs_verifier_error(bp); | ||
188 | } | 190 | } |
189 | 191 | ||
190 | static void | 192 | static void |
@@ -197,8 +199,8 @@ __write_verify( | |||
197 | struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr; | 199 | struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr; |
198 | 200 | ||
199 | if (!xfs_dir3_leaf_verify(bp, magic)) { | 201 | if (!xfs_dir3_leaf_verify(bp, magic)) { |
200 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
201 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 202 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
203 | xfs_verifier_error(bp); | ||
202 | return; | 204 | return; |
203 | } | 205 | } |
204 | 206 | ||
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c index 0904b2027cd6..cb434d732681 100644 --- a/fs/xfs/xfs_dir2_node.c +++ b/fs/xfs/xfs_dir2_node.c | |||
@@ -115,12 +115,14 @@ xfs_dir3_free_read_verify( | |||
115 | { | 115 | { |
116 | struct xfs_mount *mp = bp->b_target->bt_mount; | 116 | struct xfs_mount *mp = bp->b_target->bt_mount; |
117 | 117 | ||
118 | if ((xfs_sb_version_hascrc(&mp->m_sb) && | 118 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
119 | !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF)) || | 119 | !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF)) |
120 | !xfs_dir3_free_verify(bp)) { | 120 | xfs_buf_ioerror(bp, EFSBADCRC); |
121 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 121 | else if (!xfs_dir3_free_verify(bp)) |
122 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 122 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
123 | } | 123 | |
124 | if (bp->b_error) | ||
125 | xfs_verifier_error(bp); | ||
124 | } | 126 | } |
125 | 127 | ||
126 | static void | 128 | static void |
@@ -132,8 +134,8 @@ xfs_dir3_free_write_verify( | |||
132 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; | 134 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; |
133 | 135 | ||
134 | if (!xfs_dir3_free_verify(bp)) { | 136 | if (!xfs_dir3_free_verify(bp)) { |
135 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
136 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 137 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
138 | xfs_verifier_error(bp); | ||
137 | return; | 139 | return; |
138 | } | 140 | } |
139 | 141 | ||
diff --git a/fs/xfs/xfs_dquot_buf.c b/fs/xfs/xfs_dquot_buf.c index d401457d2f25..610da8177737 100644 --- a/fs/xfs/xfs_dquot_buf.c +++ b/fs/xfs/xfs_dquot_buf.c | |||
@@ -257,10 +257,13 @@ xfs_dquot_buf_read_verify( | |||
257 | { | 257 | { |
258 | struct xfs_mount *mp = bp->b_target->bt_mount; | 258 | struct xfs_mount *mp = bp->b_target->bt_mount; |
259 | 259 | ||
260 | if (!xfs_dquot_buf_verify_crc(mp, bp) || !xfs_dquot_buf_verify(mp, bp)) { | 260 | if (!xfs_dquot_buf_verify_crc(mp, bp)) |
261 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 261 | xfs_buf_ioerror(bp, EFSBADCRC); |
262 | else if (!xfs_dquot_buf_verify(mp, bp)) | ||
262 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 263 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
263 | } | 264 | |
265 | if (bp->b_error) | ||
266 | xfs_verifier_error(bp); | ||
264 | } | 267 | } |
265 | 268 | ||
266 | /* | 269 | /* |
@@ -275,8 +278,8 @@ xfs_dquot_buf_write_verify( | |||
275 | struct xfs_mount *mp = bp->b_target->bt_mount; | 278 | struct xfs_mount *mp = bp->b_target->bt_mount; |
276 | 279 | ||
277 | if (!xfs_dquot_buf_verify(mp, bp)) { | 280 | if (!xfs_dquot_buf_verify(mp, bp)) { |
278 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
279 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 281 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
282 | xfs_verifier_error(bp); | ||
280 | return; | 283 | return; |
281 | } | 284 | } |
282 | } | 285 | } |
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c index 46575860769b..5959b3b4c7c9 100644 --- a/fs/xfs/xfs_ialloc.c +++ b/fs/xfs/xfs_ialloc.c | |||
@@ -1568,18 +1568,17 @@ xfs_agi_read_verify( | |||
1568 | struct xfs_buf *bp) | 1568 | struct xfs_buf *bp) |
1569 | { | 1569 | { |
1570 | struct xfs_mount *mp = bp->b_target->bt_mount; | 1570 | struct xfs_mount *mp = bp->b_target->bt_mount; |
1571 | int agi_ok = 1; | ||
1572 | 1571 | ||
1573 | if (xfs_sb_version_hascrc(&mp->m_sb)) | 1572 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
1574 | agi_ok = xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF); | 1573 | !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF)) |
1575 | 1574 | xfs_buf_ioerror(bp, EFSBADCRC); | |
1576 | agi_ok = agi_ok && xfs_agi_verify(bp); | 1575 | else if (XFS_TEST_ERROR(!xfs_agi_verify(bp), mp, |
1577 | 1576 | XFS_ERRTAG_IALLOC_READ_AGI, | |
1578 | if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IALLOC_READ_AGI, | 1577 | XFS_RANDOM_IALLOC_READ_AGI)) |
1579 | XFS_RANDOM_IALLOC_READ_AGI))) { | ||
1580 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
1581 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 1578 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
1582 | } | 1579 | |
1580 | if (bp->b_error) | ||
1581 | xfs_verifier_error(bp); | ||
1583 | } | 1582 | } |
1584 | 1583 | ||
1585 | static void | 1584 | static void |
@@ -1590,8 +1589,8 @@ xfs_agi_write_verify( | |||
1590 | struct xfs_buf_log_item *bip = bp->b_fspriv; | 1589 | struct xfs_buf_log_item *bip = bp->b_fspriv; |
1591 | 1590 | ||
1592 | if (!xfs_agi_verify(bp)) { | 1591 | if (!xfs_agi_verify(bp)) { |
1593 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
1594 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 1592 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
1593 | xfs_verifier_error(bp); | ||
1595 | return; | 1594 | return; |
1596 | } | 1595 | } |
1597 | 1596 | ||
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/xfs_ialloc_btree.c index 0028c50c1e2b..7e309b11e87d 100644 --- a/fs/xfs/xfs_ialloc_btree.c +++ b/fs/xfs/xfs_ialloc_btree.c | |||
@@ -243,12 +243,14 @@ static void | |||
243 | xfs_inobt_read_verify( | 243 | xfs_inobt_read_verify( |
244 | struct xfs_buf *bp) | 244 | struct xfs_buf *bp) |
245 | { | 245 | { |
246 | if (!(xfs_btree_sblock_verify_crc(bp) && | 246 | if (!xfs_btree_sblock_verify_crc(bp)) |
247 | xfs_inobt_verify(bp))) { | 247 | xfs_buf_ioerror(bp, EFSBADCRC); |
248 | trace_xfs_btree_corrupt(bp, _RET_IP_); | 248 | else if (!xfs_inobt_verify(bp)) |
249 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
250 | bp->b_target->bt_mount, bp->b_addr); | ||
251 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 249 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
250 | |||
251 | if (bp->b_error) { | ||
252 | trace_xfs_btree_corrupt(bp, _RET_IP_); | ||
253 | xfs_verifier_error(bp); | ||
252 | } | 254 | } |
253 | } | 255 | } |
254 | 256 | ||
@@ -258,9 +260,8 @@ xfs_inobt_write_verify( | |||
258 | { | 260 | { |
259 | if (!xfs_inobt_verify(bp)) { | 261 | if (!xfs_inobt_verify(bp)) { |
260 | trace_xfs_btree_corrupt(bp, _RET_IP_); | 262 | trace_xfs_btree_corrupt(bp, _RET_IP_); |
261 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
262 | bp->b_target->bt_mount, bp->b_addr); | ||
263 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 263 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
264 | xfs_verifier_error(bp); | ||
264 | return; | 265 | return; |
265 | } | 266 | } |
266 | xfs_btree_sblock_calc_crc(bp); | 267 | xfs_btree_sblock_calc_crc(bp); |
diff --git a/fs/xfs/xfs_inode_buf.c b/fs/xfs/xfs_inode_buf.c index 606b43a48724..24e993996bdc 100644 --- a/fs/xfs/xfs_inode_buf.c +++ b/fs/xfs/xfs_inode_buf.c | |||
@@ -102,8 +102,7 @@ xfs_inode_buf_verify( | |||
102 | } | 102 | } |
103 | 103 | ||
104 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 104 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
105 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_HIGH, | 105 | xfs_verifier_error(bp); |
106 | mp, dip); | ||
107 | #ifdef DEBUG | 106 | #ifdef DEBUG |
108 | xfs_alert(mp, | 107 | xfs_alert(mp, |
109 | "bad inode magic/vsn daddr %lld #%d (magic=%x)", | 108 | "bad inode magic/vsn daddr %lld #%d (magic=%x)", |
diff --git a/fs/xfs/xfs_sb.c b/fs/xfs/xfs_sb.c index 818359f340a8..b134aa88297d 100644 --- a/fs/xfs/xfs_sb.c +++ b/fs/xfs/xfs_sb.c | |||
@@ -614,7 +614,7 @@ xfs_sb_read_verify( | |||
614 | /* Only fail bad secondaries on a known V5 filesystem */ | 614 | /* Only fail bad secondaries on a known V5 filesystem */ |
615 | if (bp->b_bn == XFS_SB_DADDR || | 615 | if (bp->b_bn == XFS_SB_DADDR || |
616 | xfs_sb_version_hascrc(&mp->m_sb)) { | 616 | xfs_sb_version_hascrc(&mp->m_sb)) { |
617 | error = EFSCORRUPTED; | 617 | error = EFSBADCRC; |
618 | goto out_error; | 618 | goto out_error; |
619 | } | 619 | } |
620 | } | 620 | } |
@@ -623,10 +623,9 @@ xfs_sb_read_verify( | |||
623 | 623 | ||
624 | out_error: | 624 | out_error: |
625 | if (error) { | 625 | if (error) { |
626 | if (error == EFSCORRUPTED) | ||
627 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
628 | mp, bp->b_addr); | ||
629 | xfs_buf_ioerror(bp, error); | 626 | xfs_buf_ioerror(bp, error); |
627 | if (error == EFSCORRUPTED || error == EFSBADCRC) | ||
628 | xfs_verifier_error(bp); | ||
630 | } | 629 | } |
631 | } | 630 | } |
632 | 631 | ||
@@ -661,9 +660,8 @@ xfs_sb_write_verify( | |||
661 | 660 | ||
662 | error = xfs_sb_verify(bp, false); | 661 | error = xfs_sb_verify(bp, false); |
663 | if (error) { | 662 | if (error) { |
664 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
665 | mp, bp->b_addr); | ||
666 | xfs_buf_ioerror(bp, error); | 663 | xfs_buf_ioerror(bp, error); |
664 | xfs_verifier_error(bp); | ||
667 | return; | 665 | return; |
668 | } | 666 | } |
669 | 667 | ||
diff --git a/fs/xfs/xfs_symlink_remote.c b/fs/xfs/xfs_symlink_remote.c index defa09ff4076..9b32052ff65e 100644 --- a/fs/xfs/xfs_symlink_remote.c +++ b/fs/xfs/xfs_symlink_remote.c | |||
@@ -133,11 +133,13 @@ xfs_symlink_read_verify( | |||
133 | if (!xfs_sb_version_hascrc(&mp->m_sb)) | 133 | if (!xfs_sb_version_hascrc(&mp->m_sb)) |
134 | return; | 134 | return; |
135 | 135 | ||
136 | if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF) || | 136 | if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF)) |
137 | !xfs_symlink_verify(bp)) { | 137 | xfs_buf_ioerror(bp, EFSBADCRC); |
138 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 138 | else if (!xfs_symlink_verify(bp)) |
139 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 139 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
140 | } | 140 | |
141 | if (bp->b_error) | ||
142 | xfs_verifier_error(bp); | ||
141 | } | 143 | } |
142 | 144 | ||
143 | static void | 145 | static void |
@@ -152,8 +154,8 @@ xfs_symlink_write_verify( | |||
152 | return; | 154 | return; |
153 | 155 | ||
154 | if (!xfs_symlink_verify(bp)) { | 156 | if (!xfs_symlink_verify(bp)) { |
155 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
156 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 157 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
158 | xfs_verifier_error(bp); | ||
157 | return; | 159 | return; |
158 | } | 160 | } |
159 | 161 | ||