1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or https://opensource.org/licenses/CDDL-1.0. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2013, 2016 by Delphix. All rights reserved. 24 * Copyright 2013 Saso Kiselkov. All rights reserved. 25 */ 26 27 #include <sys/zfs_context.h> 28 #include <sys/spa.h> 29 #include <sys/spa_impl.h> 30 #include <sys/zio.h> 31 #include <sys/zio_checksum.h> 32 #include <sys/zil.h> 33 #include <sys/abd.h> 34 #include <zfs_fletcher.h> 35 36 /* 37 * Checksum vectors. 38 * 39 * In the SPA, everything is checksummed. We support checksum vectors 40 * for three distinct reasons: 41 * 42 * 1. Different kinds of data need different levels of protection. 43 * For SPA metadata, we always want a very strong checksum. 44 * For user data, we let users make the trade-off between speed 45 * and checksum strength. 46 * 47 * 2. Cryptographic hash and MAC algorithms are an area of active research. 48 * It is likely that in future hash functions will be at least as strong 49 * as current best-of-breed, and may be substantially faster as well. 50 * We want the ability to take advantage of these new hashes as soon as 51 * they become available. 52 * 53 * 3. If someone develops hardware that can compute a strong hash quickly, 54 * we want the ability to take advantage of that hardware. 55 * 56 * Of course, we don't want a checksum upgrade to invalidate existing 57 * data, so we store the checksum *function* in eight bits of the bp. 58 * This gives us room for up to 256 different checksum functions. 59 * 60 * When writing a block, we always checksum it with the latest-and-greatest 61 * checksum function of the appropriate strength. When reading a block, 62 * we compare the expected checksum against the actual checksum, which we 63 * compute via the checksum function specified by BP_GET_CHECKSUM(bp). 64 * 65 * SALTED CHECKSUMS 66 * 67 * To enable the use of less secure hash algorithms with dedup, we 68 * introduce the notion of salted checksums (MACs, really). A salted 69 * checksum is fed both a random 256-bit value (the salt) and the data 70 * to be checksummed. This salt is kept secret (stored on the pool, but 71 * never shown to the user). Thus even if an attacker knew of collision 72 * weaknesses in the hash algorithm, they won't be able to mount a known 73 * plaintext attack on the DDT, since the actual hash value cannot be 74 * known ahead of time. How the salt is used is algorithm-specific 75 * (some might simply prefix it to the data block, others might need to 76 * utilize a full-blown HMAC). On disk the salt is stored in a ZAP 77 * object in the MOS (DMU_POOL_CHECKSUM_SALT). 78 * 79 * CONTEXT TEMPLATES 80 * 81 * Some hashing algorithms need to perform a substantial amount of 82 * initialization work (e.g. salted checksums above may need to pre-hash 83 * the salt) before being able to process data. Performing this 84 * redundant work for each block would be wasteful, so we instead allow 85 * a checksum algorithm to do the work once (the first time it's used) 86 * and then keep this pre-initialized context as a template inside the 87 * spa_t (spa_cksum_tmpls). If the zio_checksum_info_t contains 88 * non-NULL ci_tmpl_init and ci_tmpl_free callbacks, they are used to 89 * construct and destruct the pre-initialized checksum context. The 90 * pre-initialized context is then reused during each checksum 91 * invocation and passed to the checksum function. 92 */ 93 94 static void 95 abd_checksum_off(abd_t *abd, uint64_t size, 96 const void *ctx_template, zio_cksum_t *zcp) 97 { 98 (void) abd, (void) size, (void) ctx_template; 99 ZIO_SET_CHECKSUM(zcp, 0, 0, 0, 0); 100 } 101 102 static void 103 abd_fletcher_2_native(abd_t *abd, uint64_t size, 104 const void *ctx_template, zio_cksum_t *zcp) 105 { 106 (void) ctx_template; 107 fletcher_init(zcp); 108 (void) abd_iterate_func(abd, 0, size, 109 fletcher_2_incremental_native, zcp); 110 } 111 112 static void 113 abd_fletcher_2_byteswap(abd_t *abd, uint64_t size, 114 const void *ctx_template, zio_cksum_t *zcp) 115 { 116 (void) ctx_template; 117 fletcher_init(zcp); 118 (void) abd_iterate_func(abd, 0, size, 119 fletcher_2_incremental_byteswap, zcp); 120 } 121 122 static inline void 123 abd_fletcher_4_impl(abd_t *abd, uint64_t size, zio_abd_checksum_data_t *acdp) 124 { 125 fletcher_4_abd_ops.acf_init(acdp); 126 abd_iterate_func(abd, 0, size, fletcher_4_abd_ops.acf_iter, acdp); 127 fletcher_4_abd_ops.acf_fini(acdp); 128 } 129 130 void 131 abd_fletcher_4_native(abd_t *abd, uint64_t size, 132 const void *ctx_template, zio_cksum_t *zcp) 133 { 134 (void) ctx_template; 135 fletcher_4_ctx_t ctx; 136 137 zio_abd_checksum_data_t acd = { 138 .acd_byteorder = ZIO_CHECKSUM_NATIVE, 139 .acd_zcp = zcp, 140 .acd_ctx = &ctx 141 }; 142 143 abd_fletcher_4_impl(abd, size, &acd); 144 145 } 146 147 void 148 abd_fletcher_4_byteswap(abd_t *abd, uint64_t size, 149 const void *ctx_template, zio_cksum_t *zcp) 150 { 151 (void) ctx_template; 152 fletcher_4_ctx_t ctx; 153 154 zio_abd_checksum_data_t acd = { 155 .acd_byteorder = ZIO_CHECKSUM_BYTESWAP, 156 .acd_zcp = zcp, 157 .acd_ctx = &ctx 158 }; 159 160 abd_fletcher_4_impl(abd, size, &acd); 161 } 162 163 zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS] = { 164 {{NULL, NULL}, NULL, NULL, 0, "inherit"}, 165 {{NULL, NULL}, NULL, NULL, 0, "on"}, 166 {{abd_checksum_off, abd_checksum_off}, 167 NULL, NULL, 0, "off"}, 168 {{abd_checksum_sha256, abd_checksum_sha256}, 169 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_EMBEDDED, 170 "label"}, 171 {{abd_checksum_sha256, abd_checksum_sha256}, 172 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_EMBEDDED, 173 "gang_header"}, 174 {{abd_fletcher_2_native, abd_fletcher_2_byteswap}, 175 NULL, NULL, ZCHECKSUM_FLAG_EMBEDDED, "zilog"}, 176 {{abd_fletcher_2_native, abd_fletcher_2_byteswap}, 177 NULL, NULL, 0, "fletcher2"}, 178 {{abd_fletcher_4_native, abd_fletcher_4_byteswap}, 179 NULL, NULL, ZCHECKSUM_FLAG_METADATA, "fletcher4"}, 180 {{abd_checksum_sha256, abd_checksum_sha256}, 181 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_DEDUP | 182 ZCHECKSUM_FLAG_NOPWRITE, "sha256"}, 183 {{abd_fletcher_4_native, abd_fletcher_4_byteswap}, 184 NULL, NULL, ZCHECKSUM_FLAG_EMBEDDED, "zilog2"}, 185 {{abd_checksum_off, abd_checksum_off}, 186 NULL, NULL, 0, "noparity"}, 187 {{abd_checksum_sha512_native, abd_checksum_sha512_byteswap}, 188 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_DEDUP | 189 ZCHECKSUM_FLAG_NOPWRITE, "sha512"}, 190 {{abd_checksum_skein_native, abd_checksum_skein_byteswap}, 191 abd_checksum_skein_tmpl_init, abd_checksum_skein_tmpl_free, 192 ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_DEDUP | 193 ZCHECKSUM_FLAG_SALTED | ZCHECKSUM_FLAG_NOPWRITE, "skein"}, 194 {{abd_checksum_edonr_native, abd_checksum_edonr_byteswap}, 195 abd_checksum_edonr_tmpl_init, abd_checksum_edonr_tmpl_free, 196 ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_SALTED | 197 ZCHECKSUM_FLAG_NOPWRITE, "edonr"}, 198 {{abd_checksum_blake3_native, abd_checksum_blake3_byteswap}, 199 abd_checksum_blake3_tmpl_init, abd_checksum_blake3_tmpl_free, 200 ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_DEDUP | 201 ZCHECKSUM_FLAG_SALTED | ZCHECKSUM_FLAG_NOPWRITE, "blake3"}, 202 }; 203 204 /* 205 * The flag corresponding to the "verify" in dedup=[checksum,]verify 206 * must be cleared first, so callers should use ZIO_CHECKSUM_MASK. 207 */ 208 spa_feature_t 209 zio_checksum_to_feature(enum zio_checksum cksum) 210 { 211 VERIFY((cksum & ~ZIO_CHECKSUM_MASK) == 0); 212 213 switch (cksum) { 214 case ZIO_CHECKSUM_BLAKE3: 215 return (SPA_FEATURE_BLAKE3); 216 case ZIO_CHECKSUM_SHA512: 217 return (SPA_FEATURE_SHA512); 218 case ZIO_CHECKSUM_SKEIN: 219 return (SPA_FEATURE_SKEIN); 220 case ZIO_CHECKSUM_EDONR: 221 return (SPA_FEATURE_EDONR); 222 default: 223 return (SPA_FEATURE_NONE); 224 } 225 } 226 227 enum zio_checksum 228 zio_checksum_select(enum zio_checksum child, enum zio_checksum parent) 229 { 230 ASSERT(child < ZIO_CHECKSUM_FUNCTIONS); 231 ASSERT(parent < ZIO_CHECKSUM_FUNCTIONS); 232 ASSERT(parent != ZIO_CHECKSUM_INHERIT && parent != ZIO_CHECKSUM_ON); 233 234 if (child == ZIO_CHECKSUM_INHERIT) 235 return (parent); 236 237 if (child == ZIO_CHECKSUM_ON) 238 return (ZIO_CHECKSUM_ON_VALUE); 239 240 return (child); 241 } 242 243 enum zio_checksum 244 zio_checksum_dedup_select(spa_t *spa, enum zio_checksum child, 245 enum zio_checksum parent) 246 { 247 ASSERT((child & ZIO_CHECKSUM_MASK) < ZIO_CHECKSUM_FUNCTIONS); 248 ASSERT((parent & ZIO_CHECKSUM_MASK) < ZIO_CHECKSUM_FUNCTIONS); 249 ASSERT(parent != ZIO_CHECKSUM_INHERIT && parent != ZIO_CHECKSUM_ON); 250 251 if (child == ZIO_CHECKSUM_INHERIT) 252 return (parent); 253 254 if (child == ZIO_CHECKSUM_ON) 255 return (spa_dedup_checksum(spa)); 256 257 if (child == (ZIO_CHECKSUM_ON | ZIO_CHECKSUM_VERIFY)) 258 return (spa_dedup_checksum(spa) | ZIO_CHECKSUM_VERIFY); 259 260 ASSERT((zio_checksum_table[child & ZIO_CHECKSUM_MASK].ci_flags & 261 ZCHECKSUM_FLAG_DEDUP) || 262 (child & ZIO_CHECKSUM_VERIFY) || child == ZIO_CHECKSUM_OFF); 263 264 return (child); 265 } 266 267 /* 268 * Set the external verifier for a gang block based on <vdev, offset, txg>, 269 * a tuple which is guaranteed to be unique for the life of the pool. 270 */ 271 static void 272 zio_checksum_gang_verifier(zio_cksum_t *zcp, const blkptr_t *bp) 273 { 274 const dva_t *dva = BP_IDENTITY(bp); 275 uint64_t txg = BP_PHYSICAL_BIRTH(bp); 276 277 ASSERT(BP_IS_GANG(bp)); 278 279 ZIO_SET_CHECKSUM(zcp, DVA_GET_VDEV(dva), DVA_GET_OFFSET(dva), txg, 0); 280 } 281 282 /* 283 * Set the external verifier for a label block based on its offset. 284 * The vdev is implicit, and the txg is unknowable at pool open time -- 285 * hence the logic in vdev_uberblock_load() to find the most recent copy. 286 */ 287 static void 288 zio_checksum_label_verifier(zio_cksum_t *zcp, uint64_t offset) 289 { 290 ZIO_SET_CHECKSUM(zcp, offset, 0, 0, 0); 291 } 292 293 /* 294 * Calls the template init function of a checksum which supports context 295 * templates and installs the template into the spa_t. 296 */ 297 static void 298 zio_checksum_template_init(enum zio_checksum checksum, spa_t *spa) 299 { 300 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 301 302 if (ci->ci_tmpl_init == NULL) 303 return; 304 if (spa->spa_cksum_tmpls[checksum] != NULL) 305 return; 306 307 VERIFY(ci->ci_tmpl_free != NULL); 308 mutex_enter(&spa->spa_cksum_tmpls_lock); 309 if (spa->spa_cksum_tmpls[checksum] == NULL) { 310 spa->spa_cksum_tmpls[checksum] = 311 ci->ci_tmpl_init(&spa->spa_cksum_salt); 312 VERIFY(spa->spa_cksum_tmpls[checksum] != NULL); 313 } 314 mutex_exit(&spa->spa_cksum_tmpls_lock); 315 } 316 317 /* convenience function to update a checksum to accommodate an encryption MAC */ 318 static void 319 zio_checksum_handle_crypt(zio_cksum_t *cksum, zio_cksum_t *saved, boolean_t xor) 320 { 321 /* 322 * Weak checksums do not have their entropy spread evenly 323 * across the bits of the checksum. Therefore, when truncating 324 * a weak checksum we XOR the first 2 words with the last 2 so 325 * that we don't "lose" any entropy unnecessarily. 326 */ 327 if (xor) { 328 cksum->zc_word[0] ^= cksum->zc_word[2]; 329 cksum->zc_word[1] ^= cksum->zc_word[3]; 330 } 331 332 cksum->zc_word[2] = saved->zc_word[2]; 333 cksum->zc_word[3] = saved->zc_word[3]; 334 } 335 336 /* 337 * Generate the checksum. 338 */ 339 void 340 zio_checksum_compute(zio_t *zio, enum zio_checksum checksum, 341 abd_t *abd, uint64_t size) 342 { 343 static const uint64_t zec_magic = ZEC_MAGIC; 344 blkptr_t *bp = zio->io_bp; 345 uint64_t offset = zio->io_offset; 346 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 347 zio_cksum_t cksum, saved; 348 spa_t *spa = zio->io_spa; 349 boolean_t insecure = (ci->ci_flags & ZCHECKSUM_FLAG_DEDUP) == 0; 350 351 ASSERT((uint_t)checksum < ZIO_CHECKSUM_FUNCTIONS); 352 ASSERT(ci->ci_func[0] != NULL); 353 354 zio_checksum_template_init(checksum, spa); 355 356 if (ci->ci_flags & ZCHECKSUM_FLAG_EMBEDDED) { 357 zio_eck_t eck; 358 size_t eck_offset; 359 360 memset(&saved, 0, sizeof (zio_cksum_t)); 361 362 if (checksum == ZIO_CHECKSUM_ZILOG2) { 363 zil_chain_t zilc; 364 abd_copy_to_buf(&zilc, abd, sizeof (zil_chain_t)); 365 366 size = P2ROUNDUP_TYPED(zilc.zc_nused, ZIL_MIN_BLKSZ, 367 uint64_t); 368 eck = zilc.zc_eck; 369 eck_offset = offsetof(zil_chain_t, zc_eck); 370 } else { 371 eck_offset = size - sizeof (zio_eck_t); 372 abd_copy_to_buf_off(&eck, abd, eck_offset, 373 sizeof (zio_eck_t)); 374 } 375 376 if (checksum == ZIO_CHECKSUM_GANG_HEADER) { 377 zio_checksum_gang_verifier(&eck.zec_cksum, bp); 378 } else if (checksum == ZIO_CHECKSUM_LABEL) { 379 zio_checksum_label_verifier(&eck.zec_cksum, offset); 380 } else { 381 saved = eck.zec_cksum; 382 eck.zec_cksum = bp->blk_cksum; 383 } 384 385 abd_copy_from_buf_off(abd, &zec_magic, 386 eck_offset + offsetof(zio_eck_t, zec_magic), 387 sizeof (zec_magic)); 388 abd_copy_from_buf_off(abd, &eck.zec_cksum, 389 eck_offset + offsetof(zio_eck_t, zec_cksum), 390 sizeof (zio_cksum_t)); 391 392 ci->ci_func[0](abd, size, spa->spa_cksum_tmpls[checksum], 393 &cksum); 394 if (bp != NULL && BP_USES_CRYPT(bp) && 395 BP_GET_TYPE(bp) != DMU_OT_OBJSET) 396 zio_checksum_handle_crypt(&cksum, &saved, insecure); 397 398 abd_copy_from_buf_off(abd, &cksum, 399 eck_offset + offsetof(zio_eck_t, zec_cksum), 400 sizeof (zio_cksum_t)); 401 } else { 402 saved = bp->blk_cksum; 403 ci->ci_func[0](abd, size, spa->spa_cksum_tmpls[checksum], 404 &cksum); 405 if (BP_USES_CRYPT(bp) && BP_GET_TYPE(bp) != DMU_OT_OBJSET) 406 zio_checksum_handle_crypt(&cksum, &saved, insecure); 407 bp->blk_cksum = cksum; 408 } 409 } 410 411 int 412 zio_checksum_error_impl(spa_t *spa, const blkptr_t *bp, 413 enum zio_checksum checksum, abd_t *abd, uint64_t size, uint64_t offset, 414 zio_bad_cksum_t *info) 415 { 416 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 417 zio_cksum_t actual_cksum, expected_cksum; 418 zio_eck_t eck; 419 int byteswap; 420 421 if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func[0] == NULL) 422 return (SET_ERROR(EINVAL)); 423 424 zio_checksum_template_init(checksum, spa); 425 426 IMPLY(bp == NULL, ci->ci_flags & ZCHECKSUM_FLAG_EMBEDDED); 427 IMPLY(bp == NULL, checksum == ZIO_CHECKSUM_LABEL); 428 429 if (ci->ci_flags & ZCHECKSUM_FLAG_EMBEDDED) { 430 zio_cksum_t verifier; 431 size_t eck_offset; 432 433 if (checksum == ZIO_CHECKSUM_ZILOG2) { 434 zil_chain_t zilc; 435 uint64_t nused; 436 437 abd_copy_to_buf(&zilc, abd, sizeof (zil_chain_t)); 438 439 eck = zilc.zc_eck; 440 eck_offset = offsetof(zil_chain_t, zc_eck) + 441 offsetof(zio_eck_t, zec_cksum); 442 443 if (eck.zec_magic == ZEC_MAGIC) { 444 nused = zilc.zc_nused; 445 } else if (eck.zec_magic == BSWAP_64(ZEC_MAGIC)) { 446 nused = BSWAP_64(zilc.zc_nused); 447 } else { 448 return (SET_ERROR(ECKSUM)); 449 } 450 451 if (nused > size) { 452 return (SET_ERROR(ECKSUM)); 453 } 454 455 size = P2ROUNDUP_TYPED(nused, ZIL_MIN_BLKSZ, uint64_t); 456 } else { 457 eck_offset = size - sizeof (zio_eck_t); 458 abd_copy_to_buf_off(&eck, abd, eck_offset, 459 sizeof (zio_eck_t)); 460 eck_offset += offsetof(zio_eck_t, zec_cksum); 461 } 462 463 if (checksum == ZIO_CHECKSUM_GANG_HEADER) 464 zio_checksum_gang_verifier(&verifier, bp); 465 else if (checksum == ZIO_CHECKSUM_LABEL) 466 zio_checksum_label_verifier(&verifier, offset); 467 else 468 verifier = bp->blk_cksum; 469 470 byteswap = (eck.zec_magic == BSWAP_64(ZEC_MAGIC)); 471 472 if (byteswap) 473 byteswap_uint64_array(&verifier, sizeof (zio_cksum_t)); 474 475 expected_cksum = eck.zec_cksum; 476 477 abd_copy_from_buf_off(abd, &verifier, eck_offset, 478 sizeof (zio_cksum_t)); 479 480 ci->ci_func[byteswap](abd, size, 481 spa->spa_cksum_tmpls[checksum], &actual_cksum); 482 483 abd_copy_from_buf_off(abd, &expected_cksum, eck_offset, 484 sizeof (zio_cksum_t)); 485 486 if (byteswap) { 487 byteswap_uint64_array(&expected_cksum, 488 sizeof (zio_cksum_t)); 489 } 490 } else { 491 byteswap = BP_SHOULD_BYTESWAP(bp); 492 expected_cksum = bp->blk_cksum; 493 ci->ci_func[byteswap](abd, size, 494 spa->spa_cksum_tmpls[checksum], &actual_cksum); 495 } 496 497 /* 498 * MAC checksums are a special case since half of this checksum will 499 * actually be the encryption MAC. This will be verified by the 500 * decryption process, so we just check the truncated checksum now. 501 * Objset blocks use embedded MACs so we don't truncate the checksum 502 * for them. 503 */ 504 if (bp != NULL && BP_USES_CRYPT(bp) && 505 BP_GET_TYPE(bp) != DMU_OT_OBJSET) { 506 if (!(ci->ci_flags & ZCHECKSUM_FLAG_DEDUP)) { 507 actual_cksum.zc_word[0] ^= actual_cksum.zc_word[2]; 508 actual_cksum.zc_word[1] ^= actual_cksum.zc_word[3]; 509 } 510 511 actual_cksum.zc_word[2] = 0; 512 actual_cksum.zc_word[3] = 0; 513 expected_cksum.zc_word[2] = 0; 514 expected_cksum.zc_word[3] = 0; 515 } 516 517 if (info != NULL) { 518 info->zbc_expected = expected_cksum; 519 info->zbc_actual = actual_cksum; 520 info->zbc_checksum_name = ci->ci_name; 521 info->zbc_byteswapped = byteswap; 522 info->zbc_injected = 0; 523 info->zbc_has_cksum = 1; 524 } 525 526 if (!ZIO_CHECKSUM_EQUAL(actual_cksum, expected_cksum)) 527 return (SET_ERROR(ECKSUM)); 528 529 return (0); 530 } 531 532 int 533 zio_checksum_error(zio_t *zio, zio_bad_cksum_t *info) 534 { 535 blkptr_t *bp = zio->io_bp; 536 uint_t checksum = (bp == NULL ? zio->io_prop.zp_checksum : 537 (BP_IS_GANG(bp) ? ZIO_CHECKSUM_GANG_HEADER : BP_GET_CHECKSUM(bp))); 538 int error; 539 uint64_t size = (bp == NULL ? zio->io_size : 540 (BP_IS_GANG(bp) ? SPA_GANGBLOCKSIZE : BP_GET_PSIZE(bp))); 541 uint64_t offset = zio->io_offset; 542 abd_t *data = zio->io_abd; 543 spa_t *spa = zio->io_spa; 544 545 error = zio_checksum_error_impl(spa, bp, checksum, data, size, 546 offset, info); 547 548 if (zio_injection_enabled && error == 0 && zio->io_error == 0) { 549 error = zio_handle_fault_injection(zio, ECKSUM); 550 if (error != 0) 551 info->zbc_injected = 1; 552 } 553 554 return (error); 555 } 556 557 /* 558 * Called by a spa_t that's about to be deallocated. This steps through 559 * all of the checksum context templates and deallocates any that were 560 * initialized using the algorithm-specific template init function. 561 */ 562 void 563 zio_checksum_templates_free(spa_t *spa) 564 { 565 for (enum zio_checksum checksum = 0; 566 checksum < ZIO_CHECKSUM_FUNCTIONS; checksum++) { 567 if (spa->spa_cksum_tmpls[checksum] != NULL) { 568 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 569 570 VERIFY(ci->ci_tmpl_free != NULL); 571 ci->ci_tmpl_free(spa->spa_cksum_tmpls[checksum]); 572 spa->spa_cksum_tmpls[checksum] = NULL; 573 } 574 } 575 } 576