sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zio_checksum.c

   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 #ifdef illumos
 175         {{abd_checksum_edonr_native,    abd_checksum_edonr_byteswap},
 176             abd_checksum_edonr_tmpl_init, abd_checksum_edonr_tmpl_free,
 177             ZCHECKSUM_FLAG_METADATA | ZCHECKSUM_FLAG_SALTED |
 178             ZCHECKSUM_FLAG_NOPWRITE, "edonr"},
 179 #endif
 180 };
 181
 182 /*
 183  * The flag corresponding to the "verify" in dedup=[checksum,]verify
 184  * must be cleared first, so callers should use ZIO_CHECKSUM_MASK.
 185  */
 186 spa_feature_t
 187 zio_checksum_to_feature(enum zio_checksum cksum)
 188 {
 189         VERIFY((cksum & ~ZIO_CHECKSUM_MASK) == 0);
 190
 191         switch (cksum) {
 192         case ZIO_CHECKSUM_SHA512:
 193                 return (SPA_FEATURE_SHA512);
 194         case ZIO_CHECKSUM_SKEIN:
 195                 return (SPA_FEATURE_SKEIN);
 196 #ifdef illumos
 197         case ZIO_CHECKSUM_EDONR:
 198                 return (SPA_FEATURE_EDONR);
 199 #endif
 200         }
 201         return (SPA_FEATURE_NONE);
 202 }
 203
 204 enum zio_checksum
 205 zio_checksum_select(enum zio_checksum child, enum zio_checksum parent)
 206 {
 207         ASSERT(child < ZIO_CHECKSUM_FUNCTIONS);
 208         ASSERT(parent < ZIO_CHECKSUM_FUNCTIONS);
 209         ASSERT(parent != ZIO_CHECKSUM_INHERIT && parent != ZIO_CHECKSUM_ON);
 210
 211         if (child == ZIO_CHECKSUM_INHERIT)
 212                 return (parent);
 213
 214         if (child == ZIO_CHECKSUM_ON)
 215                 return (ZIO_CHECKSUM_ON_VALUE);
 216
 217         return (child);
 218 }
 219
 220 enum zio_checksum
 221 zio_checksum_dedup_select(spa_t *spa, enum zio_checksum child,
 222     enum zio_checksum parent)
 223 {
 224         ASSERT((child & ZIO_CHECKSUM_MASK) < ZIO_CHECKSUM_FUNCTIONS);
 225         ASSERT((parent & ZIO_CHECKSUM_MASK) < ZIO_CHECKSUM_FUNCTIONS);
 226         ASSERT(parent != ZIO_CHECKSUM_INHERIT && parent != ZIO_CHECKSUM_ON);
 227
 228         if (child == ZIO_CHECKSUM_INHERIT)
 229                 return (parent);
 230
 231         if (child == ZIO_CHECKSUM_ON)
 232                 return (spa_dedup_checksum(spa));
 233
 234         if (child == (ZIO_CHECKSUM_ON | ZIO_CHECKSUM_VERIFY))
 235                 return (spa_dedup_checksum(spa) | ZIO_CHECKSUM_VERIFY);
 236
 237         ASSERT((zio_checksum_table[child & ZIO_CHECKSUM_MASK].ci_flags &
 238             ZCHECKSUM_FLAG_DEDUP) ||
 239             (child & ZIO_CHECKSUM_VERIFY) || child == ZIO_CHECKSUM_OFF);
 240
 241         return (child);
 242 }
 243
 244 /*
 245  * Set the external verifier for a gang block based on <vdev, offset, txg>,
 246  * a tuple which is guaranteed to be unique for the life of the pool.
 247  */
 248 static void
 249 zio_checksum_gang_verifier(zio_cksum_t *zcp, blkptr_t *bp)
 250 {
 251         dva_t *dva = BP_IDENTITY(bp);
 252         uint64_t txg = BP_PHYSICAL_BIRTH(bp);
 253
 254         ASSERT(BP_IS_GANG(bp));
 255
 256         ZIO_SET_CHECKSUM(zcp, DVA_GET_VDEV(dva), DVA_GET_OFFSET(dva), txg, 0);
 257 }
 258
 259 /*
 260  * Set the external verifier for a label block based on its offset.
 261  * The vdev is implicit, and the txg is unknowable at pool open time --
 262  * hence the logic in vdev_uberblock_load() to find the most recent copy.
 263  */
 264 static void
 265 zio_checksum_label_verifier(zio_cksum_t *zcp, uint64_t offset)
 266 {
 267         ZIO_SET_CHECKSUM(zcp, offset, 0, 0, 0);
 268 }
 269
 270 /*
 271  * Calls the template init function of a checksum which supports context
 272  * templates and installs the template into the spa_t.
 273  */
 274 static void
 275 zio_checksum_template_init(enum zio_checksum checksum, spa_t *spa)
 276 {
 277         zio_checksum_info_t *ci = &zio_checksum_table[checksum];
 278
 279         if (ci->ci_tmpl_init == NULL)
 280                 return;
 281         if (spa->spa_cksum_tmpls[checksum] != NULL)
 282                 return;
 283
 284         VERIFY(ci->ci_tmpl_free != NULL);
 285         mutex_enter(&spa->spa_cksum_tmpls_lock);
 286         if (spa->spa_cksum_tmpls[checksum] == NULL) {
 287                 spa->spa_cksum_tmpls[checksum] =
 288                     ci->ci_tmpl_init(&spa->spa_cksum_salt);
 289                 VERIFY(spa->spa_cksum_tmpls[checksum] != NULL);
 290         }
 291         mutex_exit(&spa->spa_cksum_tmpls_lock);
 292 }
 293
 294 /*
 295  * Generate the checksum.
 296  */
 297 void
 298 zio_checksum_compute(zio_t *zio, enum zio_checksum checksum,
 299     abd_t *abd, uint64_t size)
 300 {
 301         blkptr_t *bp = zio->io_bp;
 302         uint64_t offset = zio->io_offset;
 303         zio_checksum_info_t *ci = &zio_checksum_table[checksum];
 304         zio_cksum_t cksum;
 305         spa_t *spa = zio->io_spa;
 306
 307         ASSERT((uint_t)checksum < ZIO_CHECKSUM_FUNCTIONS);
 308         ASSERT(ci->ci_func[0] != NULL);
 309
 310         zio_checksum_template_init(checksum, spa);
 311
 312         if (ci->ci_flags & ZCHECKSUM_FLAG_EMBEDDED) {
 313                 zio_eck_t *eck;
 314                 void *data = abd_to_buf(abd);
 315
 316                 if (checksum == ZIO_CHECKSUM_ZILOG2) {
 317                         zil_chain_t *zilc = data;
 318
 319                         size = P2ROUNDUP_TYPED(zilc->zc_nused, ZIL_MIN_BLKSZ,
 320                             uint64_t);
 321                         eck = &zilc->zc_eck;
 322                 } else {
 323                         eck = (zio_eck_t *)((char *)data + size) - 1;
 324                 }
 325                 if (checksum == ZIO_CHECKSUM_GANG_HEADER)
 326                         zio_checksum_gang_verifier(&eck->zec_cksum, bp);
 327                 else if (checksum == ZIO_CHECKSUM_LABEL)
 328                         zio_checksum_label_verifier(&eck->zec_cksum, offset);
 329                 else
 330                         bp->blk_cksum = eck->zec_cksum;
 331                 eck->zec_magic = ZEC_MAGIC;
 332                 ci->ci_func[0](abd, size, spa->spa_cksum_tmpls[checksum],
 333                     &cksum);
 334                 eck->zec_cksum = cksum;
 335         } else {
 336                 ci->ci_func[0](abd, size, spa->spa_cksum_tmpls[checksum],
 337                     &bp->blk_cksum);
 338         }
 339 }
 340
 341 int
 342 zio_checksum_error_impl(spa_t *spa, blkptr_t *bp, enum zio_checksum checksum,
 343     abd_t *abd, uint64_t size, uint64_t offset, zio_bad_cksum_t *info)
 344 {
 345         zio_checksum_info_t *ci = &zio_checksum_table[checksum];
 346         zio_cksum_t actual_cksum, expected_cksum;
 347         int byteswap;
 348
 349         if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func[0] == NULL)
 350                 return (SET_ERROR(EINVAL));
 351
 352         zio_checksum_template_init(checksum, spa);
 353
 354         if (ci->ci_flags & ZCHECKSUM_FLAG_EMBEDDED) {
 355                 zio_eck_t *eck;
 356                 zio_cksum_t verifier;
 357                 uint64_t data_size = size;
 358                 void *data = abd_borrow_buf_copy(abd, data_size);
 359
 360                 if (checksum == ZIO_CHECKSUM_ZILOG2) {
 361                         zil_chain_t *zilc = data;
 362                         uint64_t nused;
 363
 364                         eck = &zilc->zc_eck;
 365                         if (eck->zec_magic == ZEC_MAGIC) {
 366                                 nused = zilc->zc_nused;
 367                         } else if (eck->zec_magic == BSWAP_64(ZEC_MAGIC)) {
 368                                 nused = BSWAP_64(zilc->zc_nused);
 369                         } else {
 370                                 abd_return_buf(abd, data, data_size);
 371                                 return (SET_ERROR(ECKSUM));
 372                         }
 373
 374                         if (nused > data_size) {
 375                                 abd_return_buf(abd, data, data_size);
 376                                 return (SET_ERROR(ECKSUM));
 377                         }
 378
 379                         size = P2ROUNDUP_TYPED(nused, ZIL_MIN_BLKSZ, uint64_t);
 380                 } else {
 381                         eck = (zio_eck_t *)((char *)data + data_size) - 1;
 382                 }
 383
 384                 if (checksum == ZIO_CHECKSUM_GANG_HEADER)
 385                         zio_checksum_gang_verifier(&verifier, bp);
 386                 else if (checksum == ZIO_CHECKSUM_LABEL)
 387                         zio_checksum_label_verifier(&verifier, offset);
 388                 else
 389                         verifier = bp->blk_cksum;
 390
 391                 byteswap = (eck->zec_magic == BSWAP_64(ZEC_MAGIC));
 392
 393                 if (byteswap)
 394                         byteswap_uint64_array(&verifier, sizeof (zio_cksum_t));
 395
 396                 size_t eck_offset = (size_t)(&eck->zec_cksum) - (size_t)data;
 397                 expected_cksum = eck->zec_cksum;
 398                 eck->zec_cksum = verifier;
 399                 abd_return_buf_copy(abd, data, data_size);
 400
 401                 ci->ci_func[byteswap](abd, size,
 402                     spa->spa_cksum_tmpls[checksum], &actual_cksum);
 403                 abd_copy_from_buf_off(abd, &expected_cksum,
 404                     eck_offset, sizeof (zio_cksum_t));
 405
 406                 if (byteswap) {
 407                         byteswap_uint64_array(&expected_cksum,
 408                             sizeof (zio_cksum_t));
 409                 }
 410         } else {
 411                 byteswap = BP_SHOULD_BYTESWAP(bp);
 412                 expected_cksum = bp->blk_cksum;
 413                 ci->ci_func[byteswap](abd, size,
 414                     spa->spa_cksum_tmpls[checksum], &actual_cksum);
 415         }
 416
 417         if (info != NULL) {
 418                 info->zbc_expected = expected_cksum;
 419                 info->zbc_actual = actual_cksum;
 420                 info->zbc_checksum_name = ci->ci_name;
 421                 info->zbc_byteswapped = byteswap;
 422                 info->zbc_injected = 0;
 423                 info->zbc_has_cksum = 1;
 424         }
 425
 426         if (!ZIO_CHECKSUM_EQUAL(actual_cksum, expected_cksum))
 427                 return (SET_ERROR(ECKSUM));
 428
 429         return (0);
 430 }
 431
 432 int
 433 zio_checksum_error(zio_t *zio, zio_bad_cksum_t *info)
 434 {
 435         blkptr_t *bp = zio->io_bp;
 436         uint_t checksum = (bp == NULL ? zio->io_prop.zp_checksum :
 437             (BP_IS_GANG(bp) ? ZIO_CHECKSUM_GANG_HEADER : BP_GET_CHECKSUM(bp)));
 438         int error;
 439         uint64_t size = (bp == NULL ? zio->io_size :
 440             (BP_IS_GANG(bp) ? SPA_GANGBLOCKSIZE : BP_GET_PSIZE(bp)));
 441         uint64_t offset = zio->io_offset;
 442         abd_t *data = zio->io_abd;
 443         spa_t *spa = zio->io_spa;
 444
 445         error = zio_checksum_error_impl(spa, bp, checksum, data, size,
 446             offset, info);
 447
 448         if (zio_injection_enabled && error == 0 && zio->io_error == 0) {
 449                 error = zio_handle_fault_injection(zio, ECKSUM);
 450                 if (error != 0)
 451                         info->zbc_injected = 1;
 452         }
 453
 454         return (error);
 455 }
 456
 457 /*
 458  * Called by a spa_t that's about to be deallocated. This steps through
 459  * all of the checksum context templates and deallocates any that were
 460  * initialized using the algorithm-specific template init function.
 461  */
 462 void
 463 zio_checksum_templates_free(spa_t *spa)
 464 {
 465         for (enum zio_checksum checksum = 0;
 466             checksum < ZIO_CHECKSUM_FUNCTIONS; checksum++) {
 467                 if (spa->spa_cksum_tmpls[checksum] != NULL) {
 468                         zio_checksum_info_t *ci = &zio_checksum_table[checksum];
 469
 470                         VERIFY(ci->ci_tmpl_free != NULL);
 471                         ci->ci_tmpl_free(spa->spa_cksum_tmpls[checksum]);
 472                         spa->spa_cksum_tmpls[checksum] = NULL;
 473                 }
 474         }
 475 }