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 http://www.opensolaris.org/os/licensing. 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 (c) 2013, Joyent, Inc. All rights reserved. 25 * Copyright 2013 Saso Kiselkov. All rights reserved. 26 */ 27 28 #include <sys/zfs_context.h> 29 #include <sys/spa.h> 30 #include <sys/spa_impl.h> 31 #include <sys/zio.h> 32 #include <sys/zio_checksum.h> 33 #include <sys/zil.h> 34 #include <sys/abd.h> 35 #include <zfs_fletcher.h> 36 37 /* 38 * Checksum vectors. 39 * 40 * In the SPA, everything is checksummed. We support checksum vectors 41 * for three distinct reasons: 42 * 43 * 1. Different kinds of data need different levels of protection. 44 * For SPA metadata, we always want a very strong checksum. 45 * For user data, we let users make the trade-off between speed 46 * and checksum strength. 47 * 48 * 2. Cryptographic hash and MAC algorithms are an area of active research. 49 * It is likely that in future hash functions will be at least as strong 50 * as current best-of-breed, and may be substantially faster as well. 51 * We want the ability to take advantage of these new hashes as soon as 52 * they become available. 53 * 54 * 3. If someone develops hardware that can compute a strong hash quickly, 55 * we want the ability to take advantage of that hardware. 56 * 57 * Of course, we don't want a checksum upgrade to invalidate existing 58 * data, so we store the checksum *function* in eight bits of the bp. 59 * This gives us room for up to 256 different checksum functions. 60 * 61 * When writing a block, we always checksum it with the latest-and-greatest 62 * checksum function of the appropriate strength. When reading a block, 63 * we compare the expected checksum against the actual checksum, which we 64 * compute via the checksum function specified by BP_GET_CHECKSUM(bp). 65 * 66 * SALTED CHECKSUMS 67 * 68 * To enable the use of less secure hash algorithms with dedup, we 69 * introduce the notion of salted checksums (MACs, really). A salted 70 * checksum is fed both a random 256-bit value (the salt) and the data 71 * to be checksummed. This salt is kept secret (stored on the pool, but 72 * never shown to the user). Thus even if an attacker knew of collision 73 * weaknesses in the hash algorithm, they won't be able to mount a known 74 * plaintext attack on the DDT, since the actual hash value cannot be 75 * known ahead of time. How the salt is used is algorithm-specific 76 * (some might simply prefix it to the data block, others might need to 77 * utilize a full-blown HMAC). On disk the salt is stored in a ZAP 78 * object in the MOS (DMU_POOL_CHECKSUM_SALT). 79 * 80 * CONTEXT TEMPLATES 81 * 82 * Some hashing algorithms need to perform a substantial amount of 83 * initialization work (e.g. salted checksums above may need to pre-hash 84 * the salt) before being able to process data. Performing this 85 * redundant work for each block would be wasteful, so we instead allow 86 * a checksum algorithm to do the work once (the first time it's used) 87 * and then keep this pre-initialized context as a template inside the 88 * spa_t (spa_cksum_tmpls). If the zio_checksum_info_t contains 89 * non-NULL ci_tmpl_init and ci_tmpl_free callbacks, they are used to 90 * construct and destruct the pre-initialized checksum context. The 91 * pre-initialized context is then reused during each checksum 92 * invocation and passed to the checksum function. 93 */ 94 95 /*ARGSUSED*/ 96 static void 97 abd_checksum_off(abd_t *abd, uint64_t size, 98 const void *ctx_template, zio_cksum_t *zcp) 99 { 100 ZIO_SET_CHECKSUM(zcp, 0, 0, 0, 0); 101 } 102 103 /*ARGSUSED*/ 104 void 105 abd_fletcher_2_native(abd_t *abd, uint64_t size, 106 const void *ctx_template, zio_cksum_t *zcp) 107 { 108 fletcher_init(zcp); 109 (void) abd_iterate_func(abd, 0, size, 110 fletcher_2_incremental_native, zcp); 111 } 112 113 /*ARGSUSED*/ 114 void 115 abd_fletcher_2_byteswap(abd_t *abd, uint64_t size, 116 const void *ctx_template, zio_cksum_t *zcp) 117 { 118 fletcher_init(zcp); 119 (void) abd_iterate_func(abd, 0, size, 120 fletcher_2_incremental_byteswap, zcp); 121 } 122 123 /*ARGSUSED*/ 124 void 125 abd_fletcher_4_native(abd_t *abd, uint64_t size, 126 const void *ctx_template, zio_cksum_t *zcp) 127 { 128 fletcher_init(zcp); 129 (void) abd_iterate_func(abd, 0, size, 130 fletcher_4_incremental_native, zcp); 131 } 132 133 /*ARGSUSED*/ 134 void 135 abd_fletcher_4_byteswap(abd_t *abd, uint64_t size, 136 const void *ctx_template, zio_cksum_t *zcp) 137 { 138 fletcher_init(zcp); 139 (void) abd_iterate_func(abd, 0, size, 140 fletcher_4_incremental_byteswap, zcp); 141 } 142 143 zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS] = { 144 {{NULL, NULL}, NULL, NULL, 0, "inherit"}, 145 {{NULL, NULL}, NULL, NULL, 0, "on"}, 146 {{abd_checksum_off, abd_checksum_off}, 147 NULL, NULL, 0, "off"}, 148 {{abd_checksum_SHA256, abd_checksum_SHA256}, 149 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_EMBEDDED, 150 "label"}, 151 {{abd_checksum_SHA256, abd_checksum_SHA256}, 152 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_EMBEDDED, 153 "gang_header"}, 154 {{abd_fletcher_2_native, abd_fletcher_2_byteswap}, 155 NULL, NULL, ZCHECKSUM_FLAG_EMBEDDED, "zilog"}, 156 {{abd_fletcher_2_native, abd_fletcher_2_byteswap}, 157 NULL, NULL, 0, "fletcher2"}, 158 {{abd_fletcher_4_native, abd_fletcher_4_byteswap}, 159 NULL, NULL, ZCHECKSUM_FLAG_METADATA, "fletcher4"}, 160 {{abd_checksum_SHA256, abd_checksum_SHA256}, 161 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_DEDUP | 162 ZCHECKSUM_FLAG_NOPWRITE, "sha256"}, 163 {{abd_fletcher_4_native, abd_fletcher_4_byteswap}, 164 NULL, NULL, ZCHECKSUM_FLAG_EMBEDDED, "zilog2"}, 165 {{abd_checksum_off, abd_checksum_off}, 166 NULL, NULL, 0, "noparity"}, 167 {{abd_checksum_SHA512_native, abd_checksum_SHA512_byteswap}, 168 NULL, NULL, ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_DEDUP | 169 ZCHECKSUM_FLAG_NOPWRITE, "sha512"}, 170 {{abd_checksum_skein_native, abd_checksum_skein_byteswap}, 171 abd_checksum_skein_tmpl_init, abd_checksum_skein_tmpl_free, 172 ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_DEDUP | 173 ZCHECKSUM_FLAG_SALTED | ZCHECKSUM_FLAG_NOPWRITE, "skein"}, 174 {{abd_checksum_edonr_native, abd_checksum_edonr_byteswap}, 175 abd_checksum_edonr_tmpl_init, abd_checksum_edonr_tmpl_free, 176 ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_SALTED | 177 ZCHECKSUM_FLAG_NOPWRITE, "edonr"}, 178 }; 179 180 /* 181 * The flag corresponding to the "verify" in dedup=[checksum,]verify 182 * must be cleared first, so callers should use ZIO_CHECKSUM_MASK. 183 */ 184 spa_feature_t 185 zio_checksum_to_feature(enum zio_checksum cksum) 186 { 187 VERIFY((cksum & ~ZIO_CHECKSUM_MASK) == 0); 188 189 switch (cksum) { 190 case ZIO_CHECKSUM_SHA512: 191 return (SPA_FEATURE_SHA512); 192 case ZIO_CHECKSUM_SKEIN: 193 return (SPA_FEATURE_SKEIN); 194 case ZIO_CHECKSUM_EDONR: 195 return (SPA_FEATURE_EDONR); 196 } 197 return (SPA_FEATURE_NONE); 198 } 199 200 enum zio_checksum 201 zio_checksum_select(enum zio_checksum child, enum zio_checksum parent) 202 { 203 ASSERT(child < ZIO_CHECKSUM_FUNCTIONS); 204 ASSERT(parent < ZIO_CHECKSUM_FUNCTIONS); 205 ASSERT(parent != ZIO_CHECKSUM_INHERIT && parent != ZIO_CHECKSUM_ON); 206 207 if (child == ZIO_CHECKSUM_INHERIT) 208 return (parent); 209 210 if (child == ZIO_CHECKSUM_ON) 211 return (ZIO_CHECKSUM_ON_VALUE); 212 213 return (child); 214 } 215 216 enum zio_checksum 217 zio_checksum_dedup_select(spa_t *spa, enum zio_checksum child, 218 enum zio_checksum parent) 219 { 220 ASSERT((child & ZIO_CHECKSUM_MASK) < ZIO_CHECKSUM_FUNCTIONS); 221 ASSERT((parent & ZIO_CHECKSUM_MASK) < ZIO_CHECKSUM_FUNCTIONS); 222 ASSERT(parent != ZIO_CHECKSUM_INHERIT && parent != ZIO_CHECKSUM_ON); 223 224 if (child == ZIO_CHECKSUM_INHERIT) 225 return (parent); 226 227 if (child == ZIO_CHECKSUM_ON) 228 return (spa_dedup_checksum(spa)); 229 230 if (child == (ZIO_CHECKSUM_ON | ZIO_CHECKSUM_VERIFY)) 231 return (spa_dedup_checksum(spa) | ZIO_CHECKSUM_VERIFY); 232 233 ASSERT((zio_checksum_table[child & ZIO_CHECKSUM_MASK].ci_flags & 234 ZCHECKSUM_FLAG_DEDUP) || 235 (child & ZIO_CHECKSUM_VERIFY) || child == ZIO_CHECKSUM_OFF); 236 237 return (child); 238 } 239 240 /* 241 * Set the external verifier for a gang block based on <vdev, offset, txg>, 242 * a tuple which is guaranteed to be unique for the life of the pool. 243 */ 244 static void 245 zio_checksum_gang_verifier(zio_cksum_t *zcp, blkptr_t *bp) 246 { 247 dva_t *dva = BP_IDENTITY(bp); 248 uint64_t txg = BP_PHYSICAL_BIRTH(bp); 249 250 ASSERT(BP_IS_GANG(bp)); 251 252 ZIO_SET_CHECKSUM(zcp, DVA_GET_VDEV(dva), DVA_GET_OFFSET(dva), txg, 0); 253 } 254 255 /* 256 * Set the external verifier for a label block based on its offset. 257 * The vdev is implicit, and the txg is unknowable at pool open time -- 258 * hence the logic in vdev_uberblock_load() to find the most recent copy. 259 */ 260 static void 261 zio_checksum_label_verifier(zio_cksum_t *zcp, uint64_t offset) 262 { 263 ZIO_SET_CHECKSUM(zcp, offset, 0, 0, 0); 264 } 265 266 /* 267 * Calls the template init function of a checksum which supports context 268 * templates and installs the template into the spa_t. 269 */ 270 static void 271 zio_checksum_template_init(enum zio_checksum checksum, spa_t *spa) 272 { 273 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 274 275 if (ci->ci_tmpl_init == NULL) 276 return; 277 if (spa->spa_cksum_tmpls[checksum] != NULL) 278 return; 279 280 VERIFY(ci->ci_tmpl_free != NULL); 281 mutex_enter(&spa->spa_cksum_tmpls_lock); 282 if (spa->spa_cksum_tmpls[checksum] == NULL) { 283 spa->spa_cksum_tmpls[checksum] = 284 ci->ci_tmpl_init(&spa->spa_cksum_salt); 285 VERIFY(spa->spa_cksum_tmpls[checksum] != NULL); 286 } 287 mutex_exit(&spa->spa_cksum_tmpls_lock); 288 } 289 290 /* 291 * Generate the checksum. 292 */ 293 void 294 zio_checksum_compute(zio_t *zio, enum zio_checksum checksum, 295 abd_t *abd, uint64_t size) 296 { 297 blkptr_t *bp = zio->io_bp; 298 uint64_t offset = zio->io_offset; 299 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 300 zio_cksum_t cksum; 301 spa_t *spa = zio->io_spa; 302 303 ASSERT((uint_t)checksum < ZIO_CHECKSUM_FUNCTIONS); 304 ASSERT(ci->ci_func[0] != NULL); 305 306 zio_checksum_template_init(checksum, spa); 307 308 if (ci->ci_flags & ZCHECKSUM_FLAG_EMBEDDED) { 309 zio_eck_t *eck; 310 void *data = abd_to_buf(abd); 311 312 if (checksum == ZIO_CHECKSUM_ZILOG2) { 313 zil_chain_t *zilc = data; 314 315 size = P2ROUNDUP_TYPED(zilc->zc_nused, ZIL_MIN_BLKSZ, 316 uint64_t); 317 eck = &zilc->zc_eck; 318 } else { 319 eck = (zio_eck_t *)((char *)data + size) - 1; 320 } 321 if (checksum == ZIO_CHECKSUM_GANG_HEADER) 322 zio_checksum_gang_verifier(&eck->zec_cksum, bp); 323 else if (checksum == ZIO_CHECKSUM_LABEL) 324 zio_checksum_label_verifier(&eck->zec_cksum, offset); 325 else 326 bp->blk_cksum = eck->zec_cksum; 327 eck->zec_magic = ZEC_MAGIC; 328 ci->ci_func[0](abd, size, spa->spa_cksum_tmpls[checksum], 329 &cksum); 330 eck->zec_cksum = cksum; 331 } else { 332 ci->ci_func[0](abd, size, spa->spa_cksum_tmpls[checksum], 333 &bp->blk_cksum); 334 } 335 } 336 337 int 338 zio_checksum_error_impl(spa_t *spa, blkptr_t *bp, enum zio_checksum checksum, 339 abd_t *abd, uint64_t size, uint64_t offset, zio_bad_cksum_t *info) 340 { 341 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 342 zio_cksum_t actual_cksum, expected_cksum; 343 int byteswap; 344 345 if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func[0] == NULL) 346 return (SET_ERROR(EINVAL)); 347 348 zio_checksum_template_init(checksum, spa); 349 350 if (ci->ci_flags & ZCHECKSUM_FLAG_EMBEDDED) { 351 zio_eck_t *eck; 352 zio_cksum_t verifier; 353 uint64_t data_size = size; 354 void *data = abd_borrow_buf_copy(abd, data_size); 355 356 if (checksum == ZIO_CHECKSUM_ZILOG2) { 357 zil_chain_t *zilc = data; 358 uint64_t nused; 359 360 eck = &zilc->zc_eck; 361 if (eck->zec_magic == ZEC_MAGIC) { 362 nused = zilc->zc_nused; 363 } else if (eck->zec_magic == BSWAP_64(ZEC_MAGIC)) { 364 nused = BSWAP_64(zilc->zc_nused); 365 } else { 366 abd_return_buf(abd, data, data_size); 367 return (SET_ERROR(ECKSUM)); 368 } 369 370 if (nused > data_size) { 371 abd_return_buf(abd, data, data_size); 372 return (SET_ERROR(ECKSUM)); 373 } 374 375 size = P2ROUNDUP_TYPED(nused, ZIL_MIN_BLKSZ, uint64_t); 376 } else { 377 eck = (zio_eck_t *)((char *)data + data_size) - 1; 378 } 379 380 if (checksum == ZIO_CHECKSUM_GANG_HEADER) 381 zio_checksum_gang_verifier(&verifier, bp); 382 else if (checksum == ZIO_CHECKSUM_LABEL) 383 zio_checksum_label_verifier(&verifier, offset); 384 else 385 verifier = bp->blk_cksum; 386 387 byteswap = (eck->zec_magic == BSWAP_64(ZEC_MAGIC)); 388 389 if (byteswap) 390 byteswap_uint64_array(&verifier, sizeof (zio_cksum_t)); 391 392 size_t eck_offset = (size_t)(&eck->zec_cksum) - (size_t)data; 393 expected_cksum = eck->zec_cksum; 394 eck->zec_cksum = verifier; 395 abd_return_buf_copy(abd, data, data_size); 396 397 ci->ci_func[byteswap](abd, size, 398 spa->spa_cksum_tmpls[checksum], &actual_cksum); 399 abd_copy_from_buf_off(abd, &expected_cksum, 400 eck_offset, sizeof (zio_cksum_t)); 401 402 if (byteswap) { 403 byteswap_uint64_array(&expected_cksum, 404 sizeof (zio_cksum_t)); 405 } 406 } else { 407 byteswap = BP_SHOULD_BYTESWAP(bp); 408 expected_cksum = bp->blk_cksum; 409 ci->ci_func[byteswap](abd, size, 410 spa->spa_cksum_tmpls[checksum], &actual_cksum); 411 } 412 413 if (info != NULL) { 414 info->zbc_expected = expected_cksum; 415 info->zbc_actual = actual_cksum; 416 info->zbc_checksum_name = ci->ci_name; 417 info->zbc_byteswapped = byteswap; 418 info->zbc_injected = 0; 419 info->zbc_has_cksum = 1; 420 } 421 422 if (!ZIO_CHECKSUM_EQUAL(actual_cksum, expected_cksum)) 423 return (SET_ERROR(ECKSUM)); 424 425 return (0); 426 } 427 428 int 429 zio_checksum_error(zio_t *zio, zio_bad_cksum_t *info) 430 { 431 blkptr_t *bp = zio->io_bp; 432 uint_t checksum = (bp == NULL ? zio->io_prop.zp_checksum : 433 (BP_IS_GANG(bp) ? ZIO_CHECKSUM_GANG_HEADER : BP_GET_CHECKSUM(bp))); 434 int error; 435 uint64_t size = (bp == NULL ? zio->io_size : 436 (BP_IS_GANG(bp) ? SPA_GANGBLOCKSIZE : BP_GET_PSIZE(bp))); 437 uint64_t offset = zio->io_offset; 438 abd_t *data = zio->io_abd; 439 spa_t *spa = zio->io_spa; 440 441 error = zio_checksum_error_impl(spa, bp, checksum, data, size, 442 offset, info); 443 444 if (zio_injection_enabled && error == 0 && zio->io_error == 0) { 445 error = zio_handle_fault_injection(zio, ECKSUM); 446 if (error != 0) 447 info->zbc_injected = 1; 448 } 449 450 return (error); 451 } 452 453 /* 454 * Called by a spa_t that's about to be deallocated. This steps through 455 * all of the checksum context templates and deallocates any that were 456 * initialized using the algorithm-specific template init function. 457 */ 458 void 459 zio_checksum_templates_free(spa_t *spa) 460 { 461 for (enum zio_checksum checksum = 0; 462 checksum < ZIO_CHECKSUM_FUNCTIONS; checksum++) { 463 if (spa->spa_cksum_tmpls[checksum] != NULL) { 464 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 465 466 VERIFY(ci->ci_tmpl_free != NULL); 467 ci->ci_tmpl_free(spa->spa_cksum_tmpls[checksum]); 468 spa->spa_cksum_tmpls[checksum] = NULL; 469 } 470 } 471 } 472