diff options
author | Dave Chinner <david@fromorbit.com> | 2014-03-13 04:12:33 -0400 |
---|---|---|
committer | Dave Chinner <david@fromorbit.com> | 2014-03-13 04:12:33 -0400 |
commit | 49ae4b97d760d2e63394b96a7e14cbb43b9dc942 (patch) | |
tree | 628ea715021b8adce4f120965b40b47ff15d7b8c /fs/xfs | |
parent | 730357a5cb72d9754a396a350653ff98a9e44783 (diff) | |
parent | ce5028cfe3ca48695b6a128638fe224426d37ebe (diff) |
Merge branch 'xfs-verifier-cleanup' into for-next
Diffstat (limited to 'fs/xfs')
-rw-r--r-- | fs/xfs/xfs_ag.h | 6 | ||||
-rw-r--r-- | fs/xfs/xfs_alloc.c | 45 | ||||
-rw-r--r-- | fs/xfs/xfs_alloc_btree.c | 16 | ||||
-rw-r--r-- | fs/xfs/xfs_attr_leaf.c | 17 | ||||
-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_btree.c | 14 | ||||
-rw-r--r-- | fs/xfs/xfs_buf.h | 14 | ||||
-rw-r--r-- | fs/xfs/xfs_da_btree.c | 17 | ||||
-rw-r--r-- | fs/xfs/xfs_dinode.h | 2 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_block.c | 17 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_data.c | 20 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_leaf.c | 17 | ||||
-rw-r--r-- | fs/xfs/xfs_dir2_node.c | 17 | ||||
-rw-r--r-- | fs/xfs/xfs_dquot_buf.c | 11 | ||||
-rw-r--r-- | fs/xfs/xfs_error.c | 27 | ||||
-rw-r--r-- | fs/xfs/xfs_error.h | 1 | ||||
-rw-r--r-- | fs/xfs/xfs_format.h | 2 | ||||
-rw-r--r-- | fs/xfs/xfs_ialloc.c | 24 | ||||
-rw-r--r-- | fs/xfs/xfs_ialloc_btree.c | 16 | ||||
-rw-r--r-- | fs/xfs/xfs_inode_buf.c | 7 | ||||
-rw-r--r-- | fs/xfs/xfs_linux.h | 2 | ||||
-rw-r--r-- | fs/xfs/xfs_sb.c | 16 | ||||
-rw-r--r-- | fs/xfs/xfs_sb.h | 2 | ||||
-rw-r--r-- | fs/xfs/xfs_symlink_remote.c | 16 |
25 files changed, 202 insertions, 155 deletions
diff --git a/fs/xfs/xfs_ag.h b/fs/xfs/xfs_ag.h index 3fc109819c34..0fdd4109c624 100644 --- a/fs/xfs/xfs_ag.h +++ b/fs/xfs/xfs_ag.h | |||
@@ -89,6 +89,8 @@ typedef struct xfs_agf { | |||
89 | /* structure must be padded to 64 bit alignment */ | 89 | /* structure must be padded to 64 bit alignment */ |
90 | } xfs_agf_t; | 90 | } xfs_agf_t; |
91 | 91 | ||
92 | #define XFS_AGF_CRC_OFF offsetof(struct xfs_agf, agf_crc) | ||
93 | |||
92 | #define XFS_AGF_MAGICNUM 0x00000001 | 94 | #define XFS_AGF_MAGICNUM 0x00000001 |
93 | #define XFS_AGF_VERSIONNUM 0x00000002 | 95 | #define XFS_AGF_VERSIONNUM 0x00000002 |
94 | #define XFS_AGF_SEQNO 0x00000004 | 96 | #define XFS_AGF_SEQNO 0x00000004 |
@@ -167,6 +169,8 @@ typedef struct xfs_agi { | |||
167 | /* structure must be padded to 64 bit alignment */ | 169 | /* structure must be padded to 64 bit alignment */ |
168 | } xfs_agi_t; | 170 | } xfs_agi_t; |
169 | 171 | ||
172 | #define XFS_AGI_CRC_OFF offsetof(struct xfs_agi, agi_crc) | ||
173 | |||
170 | #define XFS_AGI_MAGICNUM 0x00000001 | 174 | #define XFS_AGI_MAGICNUM 0x00000001 |
171 | #define XFS_AGI_VERSIONNUM 0x00000002 | 175 | #define XFS_AGI_VERSIONNUM 0x00000002 |
172 | #define XFS_AGI_SEQNO 0x00000004 | 176 | #define XFS_AGI_SEQNO 0x00000004 |
@@ -222,6 +226,8 @@ typedef struct xfs_agfl { | |||
222 | __be32 agfl_bno[]; /* actually XFS_AGFL_SIZE(mp) */ | 226 | __be32 agfl_bno[]; /* actually XFS_AGFL_SIZE(mp) */ |
223 | } xfs_agfl_t; | 227 | } xfs_agfl_t; |
224 | 228 | ||
229 | #define XFS_AGFL_CRC_OFF offsetof(struct xfs_agfl, agfl_crc) | ||
230 | |||
225 | /* | 231 | /* |
226 | * tags for inode radix tree | 232 | * tags for inode radix tree |
227 | */ | 233 | */ |
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c index 9eab2dfdcbb5..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,15 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 487 | if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF)) |
489 | offsetof(struct xfs_agfl, agfl_crc)); | 488 | xfs_buf_ioerror(bp, EFSBADCRC); |
490 | 489 | else if (!xfs_agfl_verify(bp)) | |
491 | agfl_ok = agfl_ok && xfs_agfl_verify(bp); | ||
492 | |||
493 | if (!agfl_ok) { | ||
494 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
495 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 490 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
496 | } | 491 | |
492 | if (bp->b_error) | ||
493 | xfs_verifier_error(bp); | ||
497 | } | 494 | } |
498 | 495 | ||
499 | static void | 496 | static void |
@@ -508,16 +505,15 @@ xfs_agfl_write_verify( | |||
508 | return; | 505 | return; |
509 | 506 | ||
510 | if (!xfs_agfl_verify(bp)) { | 507 | if (!xfs_agfl_verify(bp)) { |
511 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
512 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 508 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
509 | xfs_verifier_error(bp); | ||
513 | return; | 510 | return; |
514 | } | 511 | } |
515 | 512 | ||
516 | if (bip) | 513 | if (bip) |
517 | XFS_BUF_TO_AGFL(bp)->agfl_lsn = cpu_to_be64(bip->bli_item.li_lsn); | 514 | XFS_BUF_TO_AGFL(bp)->agfl_lsn = cpu_to_be64(bip->bli_item.li_lsn); |
518 | 515 | ||
519 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | 516 | xfs_buf_update_cksum(bp, XFS_AGFL_CRC_OFF); |
520 | offsetof(struct xfs_agfl, agfl_crc)); | ||
521 | } | 517 | } |
522 | 518 | ||
523 | const struct xfs_buf_ops xfs_agfl_buf_ops = { | 519 | const struct xfs_buf_ops xfs_agfl_buf_ops = { |
@@ -2238,19 +2234,17 @@ xfs_agf_read_verify( | |||
2238 | struct xfs_buf *bp) | 2234 | struct xfs_buf *bp) |
2239 | { | 2235 | { |
2240 | struct xfs_mount *mp = bp->b_target->bt_mount; | 2236 | struct xfs_mount *mp = bp->b_target->bt_mount; |
2241 | int agf_ok = 1; | ||
2242 | |||
2243 | if (xfs_sb_version_hascrc(&mp->m_sb)) | ||
2244 | agf_ok = xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | ||
2245 | offsetof(struct xfs_agf, agf_crc)); | ||
2246 | 2237 | ||
2247 | agf_ok = agf_ok && xfs_agf_verify(mp, bp); | 2238 | if (xfs_sb_version_hascrc(&mp->m_sb) && |
2248 | 2239 | !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF)) | |
2249 | if (unlikely(XFS_TEST_ERROR(!agf_ok, mp, XFS_ERRTAG_ALLOC_READ_AGF, | 2240 | xfs_buf_ioerror(bp, EFSBADCRC); |
2250 | XFS_RANDOM_ALLOC_READ_AGF))) { | 2241 | else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp, |
2251 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 2242 | XFS_ERRTAG_ALLOC_READ_AGF, |
2243 | XFS_RANDOM_ALLOC_READ_AGF)) | ||
2252 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 2244 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
2253 | } | 2245 | |
2246 | if (bp->b_error) | ||
2247 | xfs_verifier_error(bp); | ||
2254 | } | 2248 | } |
2255 | 2249 | ||
2256 | static void | 2250 | static void |
@@ -2261,8 +2255,8 @@ xfs_agf_write_verify( | |||
2261 | struct xfs_buf_log_item *bip = bp->b_fspriv; | 2255 | struct xfs_buf_log_item *bip = bp->b_fspriv; |
2262 | 2256 | ||
2263 | if (!xfs_agf_verify(mp, bp)) { | 2257 | if (!xfs_agf_verify(mp, bp)) { |
2264 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
2265 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 2258 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
2259 | xfs_verifier_error(bp); | ||
2266 | return; | 2260 | return; |
2267 | } | 2261 | } |
2268 | 2262 | ||
@@ -2272,8 +2266,7 @@ xfs_agf_write_verify( | |||
2272 | if (bip) | 2266 | if (bip) |
2273 | XFS_BUF_TO_AGF(bp)->agf_lsn = cpu_to_be64(bip->bli_item.li_lsn); | 2267 | XFS_BUF_TO_AGF(bp)->agf_lsn = cpu_to_be64(bip->bli_item.li_lsn); |
2274 | 2268 | ||
2275 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | 2269 | xfs_buf_update_cksum(bp, XFS_AGF_CRC_OFF); |
2276 | offsetof(struct xfs_agf, agf_crc)); | ||
2277 | } | 2270 | } |
2278 | 2271 | ||
2279 | const struct xfs_buf_ops xfs_agf_buf_ops = { | 2272 | const struct xfs_buf_ops xfs_agf_buf_ops = { |
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c index 13085429e523..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,9 @@ 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); | ||
377 | return; | ||
376 | } | 378 | } |
377 | xfs_btree_sblock_calc_crc(bp); | 379 | xfs_btree_sblock_calc_crc(bp); |
378 | 380 | ||
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c index 7b126f46a2f9..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 | ||
@@ -224,7 +224,7 @@ xfs_attr3_leaf_write_verify( | |||
224 | if (bip) | 224 | if (bip) |
225 | hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn); | 225 | hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn); |
226 | 226 | ||
227 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_ATTR3_LEAF_CRC_OFF); | 227 | xfs_buf_update_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF); |
228 | } | 228 | } |
229 | 229 | ||
230 | /* | 230 | /* |
@@ -239,13 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 243 | !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF)) |
244 | XFS_ATTR3_LEAF_CRC_OFF)) || | 244 | xfs_buf_ioerror(bp, EFSBADCRC); |
245 | !xfs_attr3_leaf_verify(bp)) { | 245 | else if (!xfs_attr3_leaf_verify(bp)) |
246 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
247 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 246 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
248 | } | 247 | |
248 | if (bp->b_error) | ||
249 | xfs_verifier_error(bp); | ||
249 | } | 250 | } |
250 | 251 | ||
251 | 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_btree.c b/fs/xfs/xfs_btree.c index 9adaae4f3e2f..e80d59fdf89a 100644 --- a/fs/xfs/xfs_btree.c +++ b/fs/xfs/xfs_btree.c | |||
@@ -234,8 +234,7 @@ xfs_btree_lblock_calc_crc( | |||
234 | return; | 234 | return; |
235 | if (bip) | 235 | if (bip) |
236 | block->bb_u.l.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn); | 236 | block->bb_u.l.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn); |
237 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | 237 | xfs_buf_update_cksum(bp, XFS_BTREE_LBLOCK_CRC_OFF); |
238 | XFS_BTREE_LBLOCK_CRC_OFF); | ||
239 | } | 238 | } |
240 | 239 | ||
241 | bool | 240 | bool |
@@ -243,8 +242,8 @@ xfs_btree_lblock_verify_crc( | |||
243 | struct xfs_buf *bp) | 242 | struct xfs_buf *bp) |
244 | { | 243 | { |
245 | if (xfs_sb_version_hascrc(&bp->b_target->bt_mount->m_sb)) | 244 | if (xfs_sb_version_hascrc(&bp->b_target->bt_mount->m_sb)) |
246 | return xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 245 | return xfs_buf_verify_cksum(bp, XFS_BTREE_LBLOCK_CRC_OFF); |
247 | XFS_BTREE_LBLOCK_CRC_OFF); | 246 | |
248 | return true; | 247 | return true; |
249 | } | 248 | } |
250 | 249 | ||
@@ -267,8 +266,7 @@ xfs_btree_sblock_calc_crc( | |||
267 | return; | 266 | return; |
268 | if (bip) | 267 | if (bip) |
269 | block->bb_u.s.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn); | 268 | block->bb_u.s.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn); |
270 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | 269 | xfs_buf_update_cksum(bp, XFS_BTREE_SBLOCK_CRC_OFF); |
271 | XFS_BTREE_SBLOCK_CRC_OFF); | ||
272 | } | 270 | } |
273 | 271 | ||
274 | bool | 272 | bool |
@@ -276,8 +274,8 @@ xfs_btree_sblock_verify_crc( | |||
276 | struct xfs_buf *bp) | 274 | struct xfs_buf *bp) |
277 | { | 275 | { |
278 | if (xfs_sb_version_hascrc(&bp->b_target->bt_mount->m_sb)) | 276 | if (xfs_sb_version_hascrc(&bp->b_target->bt_mount->m_sb)) |
279 | return xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 277 | return xfs_buf_verify_cksum(bp, XFS_BTREE_SBLOCK_CRC_OFF); |
280 | XFS_BTREE_SBLOCK_CRC_OFF); | 278 | |
281 | return true; | 279 | return true; |
282 | } | 280 | } |
283 | 281 | ||
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h index 995339534db6..b8a3abf6cf47 100644 --- a/fs/xfs/xfs_buf.h +++ b/fs/xfs/xfs_buf.h | |||
@@ -369,6 +369,20 @@ static inline void xfs_buf_relse(xfs_buf_t *bp) | |||
369 | xfs_buf_rele(bp); | 369 | xfs_buf_rele(bp); |
370 | } | 370 | } |
371 | 371 | ||
372 | static inline int | ||
373 | xfs_buf_verify_cksum(struct xfs_buf *bp, unsigned long cksum_offset) | ||
374 | { | ||
375 | return xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | ||
376 | cksum_offset); | ||
377 | } | ||
378 | |||
379 | static inline void | ||
380 | xfs_buf_update_cksum(struct xfs_buf *bp, unsigned long cksum_offset) | ||
381 | { | ||
382 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | ||
383 | cksum_offset); | ||
384 | } | ||
385 | |||
372 | /* | 386 | /* |
373 | * Handling of buftargs. | 387 | * Handling of buftargs. |
374 | */ | 388 | */ |
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c index 796272a2e129..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 | ||
@@ -196,7 +196,7 @@ xfs_da3_node_write_verify( | |||
196 | if (bip) | 196 | if (bip) |
197 | hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn); | 197 | hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn); |
198 | 198 | ||
199 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DA3_NODE_CRC_OFF); | 199 | xfs_buf_update_cksum(bp, XFS_DA3_NODE_CRC_OFF); |
200 | } | 200 | } |
201 | 201 | ||
202 | /* | 202 | /* |
@@ -209,18 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 216 | if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) { |
218 | XFS_DA3_NODE_CRC_OFF)) | 217 | xfs_buf_ioerror(bp, EFSBADCRC); |
219 | break; | 218 | break; |
219 | } | ||
220 | /* fall through */ | 220 | /* fall through */ |
221 | case XFS_DA_NODE_MAGIC: | 221 | case XFS_DA_NODE_MAGIC: |
222 | if (!xfs_da3_node_verify(bp)) | 222 | if (!xfs_da3_node_verify(bp)) { |
223 | xfs_buf_ioerror(bp, EFSCORRUPTED); | ||
223 | break; | 224 | break; |
225 | } | ||
224 | return; | 226 | return; |
225 | case XFS_ATTR_LEAF_MAGIC: | 227 | case XFS_ATTR_LEAF_MAGIC: |
226 | case XFS_ATTR3_LEAF_MAGIC: | 228 | case XFS_ATTR3_LEAF_MAGIC: |
@@ -237,8 +239,7 @@ xfs_da3_node_read_verify( | |||
237 | } | 239 | } |
238 | 240 | ||
239 | /* corrupt block */ | 241 | /* corrupt block */ |
240 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | 242 | xfs_verifier_error(bp); |
241 | xfs_buf_ioerror(bp, EFSCORRUPTED); | ||
242 | } | 243 | } |
243 | 244 | ||
244 | 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_dinode.h b/fs/xfs/xfs_dinode.h index e5869b50dc41..623bbe8fd921 100644 --- a/fs/xfs/xfs_dinode.h +++ b/fs/xfs/xfs_dinode.h | |||
@@ -89,6 +89,8 @@ typedef struct xfs_dinode { | |||
89 | /* structure must be padded to 64 bit alignment */ | 89 | /* structure must be padded to 64 bit alignment */ |
90 | } xfs_dinode_t; | 90 | } xfs_dinode_t; |
91 | 91 | ||
92 | #define XFS_DINODE_CRC_OFF offsetof(struct xfs_dinode, di_crc) | ||
93 | |||
92 | #define DI_MAX_FLUSH 0xffff | 94 | #define DI_MAX_FLUSH 0xffff |
93 | 95 | ||
94 | /* | 96 | /* |
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c index 90cdbf4b5f19..4f6a38cb83a4 100644 --- a/fs/xfs/xfs_dir2_block.c +++ b/fs/xfs/xfs_dir2_block.c | |||
@@ -89,13 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 93 | !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF)) |
94 | XFS_DIR3_DATA_CRC_OFF)) || | 94 | xfs_buf_ioerror(bp, EFSBADCRC); |
95 | !xfs_dir3_block_verify(bp)) { | 95 | else if (!xfs_dir3_block_verify(bp)) |
96 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
97 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 96 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
98 | } | 97 | |
98 | if (bp->b_error) | ||
99 | xfs_verifier_error(bp); | ||
99 | } | 100 | } |
100 | 101 | ||
101 | static void | 102 | static void |
@@ -107,8 +108,8 @@ xfs_dir3_block_write_verify( | |||
107 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; | 108 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; |
108 | 109 | ||
109 | if (!xfs_dir3_block_verify(bp)) { | 110 | if (!xfs_dir3_block_verify(bp)) { |
110 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
111 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 111 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
112 | xfs_verifier_error(bp); | ||
112 | return; | 113 | return; |
113 | } | 114 | } |
114 | 115 | ||
@@ -118,7 +119,7 @@ xfs_dir3_block_write_verify( | |||
118 | if (bip) | 119 | if (bip) |
119 | hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn); | 120 | hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn); |
120 | 121 | ||
121 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_DATA_CRC_OFF); | 122 | xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF); |
122 | } | 123 | } |
123 | 124 | ||
124 | const struct xfs_buf_ops xfs_dir3_block_buf_ops = { | 125 | const struct xfs_buf_ops xfs_dir3_block_buf_ops = { |
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c index 70acff4ee173..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,13 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 270 | !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF)) |
272 | XFS_DIR3_DATA_CRC_OFF)) || | 271 | xfs_buf_ioerror(bp, EFSBADCRC); |
273 | !xfs_dir3_data_verify(bp)) { | 272 | else if (!xfs_dir3_data_verify(bp)) |
274 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
275 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 273 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
276 | } | 274 | |
275 | if (bp->b_error) | ||
276 | xfs_verifier_error(bp); | ||
277 | } | 277 | } |
278 | 278 | ||
279 | static void | 279 | static void |
@@ -285,8 +285,8 @@ xfs_dir3_data_write_verify( | |||
285 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; | 285 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; |
286 | 286 | ||
287 | if (!xfs_dir3_data_verify(bp)) { | 287 | if (!xfs_dir3_data_verify(bp)) { |
288 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
289 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 288 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
289 | xfs_verifier_error(bp); | ||
290 | return; | 290 | return; |
291 | } | 291 | } |
292 | 292 | ||
@@ -296,7 +296,7 @@ xfs_dir3_data_write_verify( | |||
296 | if (bip) | 296 | if (bip) |
297 | hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn); | 297 | hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn); |
298 | 298 | ||
299 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_DATA_CRC_OFF); | 299 | xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF); |
300 | } | 300 | } |
301 | 301 | ||
302 | const struct xfs_buf_ops xfs_dir3_data_buf_ops = { | 302 | const struct xfs_buf_ops xfs_dir3_data_buf_ops = { |
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c index ae47ec6e16c4..d36e97df1187 100644 --- a/fs/xfs/xfs_dir2_leaf.c +++ b/fs/xfs/xfs_dir2_leaf.c | |||
@@ -179,13 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 183 | !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF)) |
184 | XFS_DIR3_LEAF_CRC_OFF)) || | 184 | xfs_buf_ioerror(bp, EFSBADCRC); |
185 | !xfs_dir3_leaf_verify(bp, magic)) { | 185 | else if (!xfs_dir3_leaf_verify(bp, magic)) |
186 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
187 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 186 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
188 | } | 187 | |
188 | if (bp->b_error) | ||
189 | xfs_verifier_error(bp); | ||
189 | } | 190 | } |
190 | 191 | ||
191 | static void | 192 | static void |
@@ -198,8 +199,8 @@ __write_verify( | |||
198 | struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr; | 199 | struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr; |
199 | 200 | ||
200 | if (!xfs_dir3_leaf_verify(bp, magic)) { | 201 | if (!xfs_dir3_leaf_verify(bp, magic)) { |
201 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
202 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 202 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
203 | xfs_verifier_error(bp); | ||
203 | return; | 204 | return; |
204 | } | 205 | } |
205 | 206 | ||
@@ -209,7 +210,7 @@ __write_verify( | |||
209 | if (bip) | 210 | if (bip) |
210 | hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn); | 211 | hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn); |
211 | 212 | ||
212 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_LEAF_CRC_OFF); | 213 | xfs_buf_update_cksum(bp, XFS_DIR3_LEAF_CRC_OFF); |
213 | } | 214 | } |
214 | 215 | ||
215 | static void | 216 | static void |
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c index 48c7d18f68c3..cb434d732681 100644 --- a/fs/xfs/xfs_dir2_node.c +++ b/fs/xfs/xfs_dir2_node.c | |||
@@ -115,13 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 119 | !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF)) |
120 | XFS_DIR3_FREE_CRC_OFF)) || | 120 | xfs_buf_ioerror(bp, EFSBADCRC); |
121 | !xfs_dir3_free_verify(bp)) { | 121 | else if (!xfs_dir3_free_verify(bp)) |
122 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
123 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 122 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
124 | } | 123 | |
124 | if (bp->b_error) | ||
125 | xfs_verifier_error(bp); | ||
125 | } | 126 | } |
126 | 127 | ||
127 | static void | 128 | static void |
@@ -133,8 +134,8 @@ xfs_dir3_free_write_verify( | |||
133 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; | 134 | struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; |
134 | 135 | ||
135 | if (!xfs_dir3_free_verify(bp)) { | 136 | if (!xfs_dir3_free_verify(bp)) { |
136 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
137 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 137 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
138 | xfs_verifier_error(bp); | ||
138 | return; | 139 | return; |
139 | } | 140 | } |
140 | 141 | ||
@@ -144,7 +145,7 @@ xfs_dir3_free_write_verify( | |||
144 | if (bip) | 145 | if (bip) |
145 | hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn); | 146 | hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn); |
146 | 147 | ||
147 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_FREE_CRC_OFF); | 148 | xfs_buf_update_cksum(bp, XFS_DIR3_FREE_CRC_OFF); |
148 | } | 149 | } |
149 | 150 | ||
150 | const struct xfs_buf_ops xfs_dir3_free_buf_ops = { | 151 | const struct xfs_buf_ops xfs_dir3_free_buf_ops = { |
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_error.c b/fs/xfs/xfs_error.c index 9995b807d627..edac5b057d28 100644 --- a/fs/xfs/xfs_error.c +++ b/fs/xfs/xfs_error.c | |||
@@ -156,7 +156,7 @@ xfs_error_report( | |||
156 | { | 156 | { |
157 | if (level <= xfs_error_level) { | 157 | if (level <= xfs_error_level) { |
158 | xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT, | 158 | xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT, |
159 | "Internal error %s at line %d of file %s. Caller 0x%p", | 159 | "Internal error %s at line %d of file %s. Caller %pF", |
160 | tag, linenum, filename, ra); | 160 | tag, linenum, filename, ra); |
161 | 161 | ||
162 | xfs_stack_trace(); | 162 | xfs_stack_trace(); |
@@ -178,3 +178,28 @@ xfs_corruption_error( | |||
178 | xfs_error_report(tag, level, mp, filename, linenum, ra); | 178 | xfs_error_report(tag, level, mp, filename, linenum, ra); |
179 | xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair"); | 179 | xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair"); |
180 | } | 180 | } |
181 | |||
182 | /* | ||
183 | * Warnings specifically for verifier errors. Differentiate CRC vs. invalid | ||
184 | * values, and omit the stack trace unless the error level is tuned high. | ||
185 | */ | ||
186 | void | ||
187 | xfs_verifier_error( | ||
188 | struct xfs_buf *bp) | ||
189 | { | ||
190 | struct xfs_mount *mp = bp->b_target->bt_mount; | ||
191 | |||
192 | xfs_alert(mp, "Metadata %s detected at %pF, block 0x%llx", | ||
193 | bp->b_error == EFSBADCRC ? "CRC error" : "corruption", | ||
194 | __return_address, bp->b_bn); | ||
195 | |||
196 | xfs_alert(mp, "Unmount and run xfs_repair"); | ||
197 | |||
198 | if (xfs_error_level >= XFS_ERRLEVEL_LOW) { | ||
199 | xfs_alert(mp, "First 64 bytes of corrupted metadata buffer:"); | ||
200 | xfs_hex_dump(xfs_buf_offset(bp, 0), 64); | ||
201 | } | ||
202 | |||
203 | if (xfs_error_level >= XFS_ERRLEVEL_HIGH) | ||
204 | xfs_stack_trace(); | ||
205 | } | ||
diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h index 079a367f44ee..c1c57d4a4b5d 100644 --- a/fs/xfs/xfs_error.h +++ b/fs/xfs/xfs_error.h | |||
@@ -34,6 +34,7 @@ extern void xfs_error_report(const char *tag, int level, struct xfs_mount *mp, | |||
34 | extern void xfs_corruption_error(const char *tag, int level, | 34 | extern void xfs_corruption_error(const char *tag, int level, |
35 | struct xfs_mount *mp, void *p, const char *filename, | 35 | struct xfs_mount *mp, void *p, const char *filename, |
36 | int linenum, inst_t *ra); | 36 | int linenum, inst_t *ra); |
37 | extern void xfs_verifier_error(struct xfs_buf *bp); | ||
37 | 38 | ||
38 | #define XFS_ERROR_REPORT(e, lvl, mp) \ | 39 | #define XFS_ERROR_REPORT(e, lvl, mp) \ |
39 | xfs_error_report(e, lvl, mp, __FILE__, __LINE__, __return_address) | 40 | xfs_error_report(e, lvl, mp, __FILE__, __LINE__, __return_address) |
diff --git a/fs/xfs/xfs_format.h b/fs/xfs/xfs_format.h index b6ab5a3cfa12..9898f31d05d8 100644 --- a/fs/xfs/xfs_format.h +++ b/fs/xfs/xfs_format.h | |||
@@ -145,6 +145,8 @@ struct xfs_dsymlink_hdr { | |||
145 | __be64 sl_lsn; | 145 | __be64 sl_lsn; |
146 | }; | 146 | }; |
147 | 147 | ||
148 | #define XFS_SYMLINK_CRC_OFF offsetof(struct xfs_dsymlink_hdr, sl_crc) | ||
149 | |||
148 | /* | 150 | /* |
149 | * The maximum pathlen is 1024 bytes. Since the minimum file system | 151 | * The maximum pathlen is 1024 bytes. Since the minimum file system |
150 | * blocksize is 512 bytes, we can get a max of 3 extents back from | 152 | * blocksize is 512 bytes, we can get a max of 3 extents back from |
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c index 5d7f105a1c82..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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 1573 | !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF)) |
1575 | offsetof(struct xfs_agi, agi_crc)); | 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 | ||
@@ -1600,8 +1599,7 @@ xfs_agi_write_verify( | |||
1600 | 1599 | ||
1601 | if (bip) | 1600 | if (bip) |
1602 | XFS_BUF_TO_AGI(bp)->agi_lsn = cpu_to_be64(bip->bli_item.li_lsn); | 1601 | XFS_BUF_TO_AGI(bp)->agi_lsn = cpu_to_be64(bip->bli_item.li_lsn); |
1603 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | 1602 | xfs_buf_update_cksum(bp, XFS_AGI_CRC_OFF); |
1604 | offsetof(struct xfs_agi, agi_crc)); | ||
1605 | } | 1603 | } |
1606 | 1604 | ||
1607 | const struct xfs_buf_ops xfs_agi_buf_ops = { | 1605 | const struct xfs_buf_ops xfs_agi_buf_ops = { |
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/xfs_ialloc_btree.c index c8fa5bbb36de..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,9 @@ 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); | ||
265 | return; | ||
264 | } | 266 | } |
265 | xfs_btree_sblock_calc_crc(bp); | 267 | xfs_btree_sblock_calc_crc(bp); |
266 | 268 | ||
diff --git a/fs/xfs/xfs_inode_buf.c b/fs/xfs/xfs_inode_buf.c index 4fc9f39dd89e..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)", |
@@ -306,7 +305,7 @@ xfs_dinode_verify( | |||
306 | if (!xfs_sb_version_hascrc(&mp->m_sb)) | 305 | if (!xfs_sb_version_hascrc(&mp->m_sb)) |
307 | return false; | 306 | return false; |
308 | if (!xfs_verify_cksum((char *)dip, mp->m_sb.sb_inodesize, | 307 | if (!xfs_verify_cksum((char *)dip, mp->m_sb.sb_inodesize, |
309 | offsetof(struct xfs_dinode, di_crc))) | 308 | XFS_DINODE_CRC_OFF)) |
310 | return false; | 309 | return false; |
311 | if (be64_to_cpu(dip->di_ino) != ip->i_ino) | 310 | if (be64_to_cpu(dip->di_ino) != ip->i_ino) |
312 | return false; | 311 | return false; |
@@ -327,7 +326,7 @@ xfs_dinode_calc_crc( | |||
327 | 326 | ||
328 | ASSERT(xfs_sb_version_hascrc(&mp->m_sb)); | 327 | ASSERT(xfs_sb_version_hascrc(&mp->m_sb)); |
329 | crc = xfs_start_cksum((char *)dip, mp->m_sb.sb_inodesize, | 328 | crc = xfs_start_cksum((char *)dip, mp->m_sb.sb_inodesize, |
330 | offsetof(struct xfs_dinode, di_crc)); | 329 | XFS_DINODE_CRC_OFF); |
331 | dip->di_crc = xfs_end_cksum(crc); | 330 | dip->di_crc = xfs_end_cksum(crc); |
332 | } | 331 | } |
333 | 332 | ||
diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h index f9bb590acc0e..825249d2dfc1 100644 --- a/fs/xfs/xfs_linux.h +++ b/fs/xfs/xfs_linux.h | |||
@@ -119,6 +119,7 @@ typedef __uint64_t __psunsigned_t; | |||
119 | #include "xfs_iops.h" | 119 | #include "xfs_iops.h" |
120 | #include "xfs_aops.h" | 120 | #include "xfs_aops.h" |
121 | #include "xfs_super.h" | 121 | #include "xfs_super.h" |
122 | #include "xfs_cksum.h" | ||
122 | #include "xfs_buf.h" | 123 | #include "xfs_buf.h" |
123 | #include "xfs_message.h" | 124 | #include "xfs_message.h" |
124 | 125 | ||
@@ -178,6 +179,7 @@ typedef __uint64_t __psunsigned_t; | |||
178 | #define ENOATTR ENODATA /* Attribute not found */ | 179 | #define ENOATTR ENODATA /* Attribute not found */ |
179 | #define EWRONGFS EINVAL /* Mount with wrong filesystem type */ | 180 | #define EWRONGFS EINVAL /* Mount with wrong filesystem type */ |
180 | #define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */ | 181 | #define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */ |
182 | #define EFSBADCRC EBADMSG /* Bad CRC detected */ | ||
181 | 183 | ||
182 | #define SYNCHRONIZE() barrier() | 184 | #define SYNCHRONIZE() barrier() |
183 | #define __return_address __builtin_return_address(0) | 185 | #define __return_address __builtin_return_address(0) |
diff --git a/fs/xfs/xfs_sb.c b/fs/xfs/xfs_sb.c index 75161a2060fb..0c0e41bbe4e3 100644 --- a/fs/xfs/xfs_sb.c +++ b/fs/xfs/xfs_sb.c | |||
@@ -611,12 +611,11 @@ xfs_sb_read_verify( | |||
611 | XFS_SB_VERSION_5) || | 611 | XFS_SB_VERSION_5) || |
612 | dsb->sb_crc != 0)) { | 612 | dsb->sb_crc != 0)) { |
613 | 613 | ||
614 | if (!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 614 | if (!xfs_buf_verify_cksum(bp, XFS_SB_CRC_OFF)) { |
615 | offsetof(struct xfs_sb, sb_crc))) { | ||
616 | /* Only fail bad secondaries on a known V5 filesystem */ | 615 | /* Only fail bad secondaries on a known V5 filesystem */ |
617 | if (bp->b_bn == XFS_SB_DADDR || | 616 | if (bp->b_bn == XFS_SB_DADDR || |
618 | xfs_sb_version_hascrc(&mp->m_sb)) { | 617 | xfs_sb_version_hascrc(&mp->m_sb)) { |
619 | error = EFSCORRUPTED; | 618 | error = EFSBADCRC; |
620 | goto out_error; | 619 | goto out_error; |
621 | } | 620 | } |
622 | } | 621 | } |
@@ -625,10 +624,9 @@ xfs_sb_read_verify( | |||
625 | 624 | ||
626 | out_error: | 625 | out_error: |
627 | if (error) { | 626 | if (error) { |
628 | if (error == EFSCORRUPTED) | ||
629 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
630 | mp, bp->b_addr); | ||
631 | xfs_buf_ioerror(bp, error); | 627 | xfs_buf_ioerror(bp, error); |
628 | if (error == EFSCORRUPTED || error == EFSBADCRC) | ||
629 | xfs_verifier_error(bp); | ||
632 | } | 630 | } |
633 | } | 631 | } |
634 | 632 | ||
@@ -663,9 +661,8 @@ xfs_sb_write_verify( | |||
663 | 661 | ||
664 | error = xfs_sb_verify(bp, false); | 662 | error = xfs_sb_verify(bp, false); |
665 | if (error) { | 663 | if (error) { |
666 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, | ||
667 | mp, bp->b_addr); | ||
668 | xfs_buf_ioerror(bp, error); | 664 | xfs_buf_ioerror(bp, error); |
665 | xfs_verifier_error(bp); | ||
669 | return; | 666 | return; |
670 | } | 667 | } |
671 | 668 | ||
@@ -675,8 +672,7 @@ xfs_sb_write_verify( | |||
675 | if (bip) | 672 | if (bip) |
676 | XFS_BUF_TO_SBP(bp)->sb_lsn = cpu_to_be64(bip->bli_item.li_lsn); | 673 | XFS_BUF_TO_SBP(bp)->sb_lsn = cpu_to_be64(bip->bli_item.li_lsn); |
677 | 674 | ||
678 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | 675 | xfs_buf_update_cksum(bp, XFS_SB_CRC_OFF); |
679 | offsetof(struct xfs_sb, sb_crc)); | ||
680 | } | 676 | } |
681 | 677 | ||
682 | const struct xfs_buf_ops xfs_sb_buf_ops = { | 678 | const struct xfs_buf_ops xfs_sb_buf_ops = { |
diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h index 35061d4b614c..f7b2fe77c5a5 100644 --- a/fs/xfs/xfs_sb.h +++ b/fs/xfs/xfs_sb.h | |||
@@ -182,6 +182,8 @@ typedef struct xfs_sb { | |||
182 | /* must be padded to 64 bit alignment */ | 182 | /* must be padded to 64 bit alignment */ |
183 | } xfs_sb_t; | 183 | } xfs_sb_t; |
184 | 184 | ||
185 | #define XFS_SB_CRC_OFF offsetof(struct xfs_sb, sb_crc) | ||
186 | |||
185 | /* | 187 | /* |
186 | * Superblock - on disk version. Must match the in core version above. | 188 | * Superblock - on disk version. Must match the in core version above. |
187 | * Must be padded to 64 bit alignment. | 189 | * Must be padded to 64 bit alignment. |
diff --git a/fs/xfs/xfs_symlink_remote.c b/fs/xfs/xfs_symlink_remote.c index bf59a2b45f8c..9b32052ff65e 100644 --- a/fs/xfs/xfs_symlink_remote.c +++ b/fs/xfs/xfs_symlink_remote.c | |||
@@ -133,12 +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_verify_cksum(bp->b_addr, BBTOB(bp->b_length), | 136 | if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF)) |
137 | offsetof(struct xfs_dsymlink_hdr, sl_crc)) || | 137 | xfs_buf_ioerror(bp, EFSBADCRC); |
138 | !xfs_symlink_verify(bp)) { | 138 | else if (!xfs_symlink_verify(bp)) |
139 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
140 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 139 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
141 | } | 140 | |
141 | if (bp->b_error) | ||
142 | xfs_verifier_error(bp); | ||
142 | } | 143 | } |
143 | 144 | ||
144 | static void | 145 | static void |
@@ -153,8 +154,8 @@ xfs_symlink_write_verify( | |||
153 | return; | 154 | return; |
154 | 155 | ||
155 | if (!xfs_symlink_verify(bp)) { | 156 | if (!xfs_symlink_verify(bp)) { |
156 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); | ||
157 | xfs_buf_ioerror(bp, EFSCORRUPTED); | 157 | xfs_buf_ioerror(bp, EFSCORRUPTED); |
158 | xfs_verifier_error(bp); | ||
158 | return; | 159 | return; |
159 | } | 160 | } |
160 | 161 | ||
@@ -162,8 +163,7 @@ xfs_symlink_write_verify( | |||
162 | struct xfs_dsymlink_hdr *dsl = bp->b_addr; | 163 | struct xfs_dsymlink_hdr *dsl = bp->b_addr; |
163 | dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn); | 164 | dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn); |
164 | } | 165 | } |
165 | xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), | 166 | xfs_buf_update_cksum(bp, XFS_SYMLINK_CRC_OFF); |
166 | offsetof(struct xfs_dsymlink_hdr, sl_crc)); | ||
167 | } | 167 | } |
168 | 168 | ||
169 | const struct xfs_buf_ops xfs_symlink_buf_ops = { | 169 | const struct xfs_buf_ops xfs_symlink_buf_ops = { |