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 /* 23 * Copyright (c) 2011, 2015 by Delphix. All rights reserved. 24 * Copyright (c) 2013 Steven Hartland. All rights reserved. 25 */ 26 27 /* 28 * zhack is a debugging tool that can write changes to ZFS pool using libzpool 29 * for testing purposes. Altering pools with zhack is unsupported and may 30 * result in corrupted pools. 31 */ 32 33 #include <zfs_prop.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <ctype.h> 37 #include <sys/stat.h> 38 #include <sys/zfs_context.h> 39 #include <sys/spa.h> 40 #include <sys/spa_impl.h> 41 #include <sys/dmu.h> 42 #include <sys/zap.h> 43 #include <sys/zfs_znode.h> 44 #include <sys/dsl_synctask.h> 45 #include <sys/vdev.h> 46 #include <sys/vdev_impl.h> 47 #include <sys/fs/zfs.h> 48 #include <sys/dmu_objset.h> 49 #include <sys/dsl_pool.h> 50 #include <sys/zio_checksum.h> 51 #include <sys/zio_compress.h> 52 #include <sys/zfeature.h> 53 #include <sys/dmu_tx.h> 54 #include <zfeature_common.h> 55 #include <libzutil.h> 56 57 static importargs_t g_importargs; 58 static char *g_pool; 59 static boolean_t g_readonly; 60 61 typedef enum { 62 ZHACK_REPAIR_OP_UNKNOWN = 0, 63 ZHACK_REPAIR_OP_CKSUM = (1 << 0), 64 ZHACK_REPAIR_OP_UNDETACH = (1 << 1) 65 } zhack_repair_op_t; 66 67 static __attribute__((noreturn)) void 68 usage(void) 69 { 70 (void) fprintf(stderr, 71 "Usage: zhack [-c cachefile] [-d dir] <subcommand> <args> ...\n" 72 "where <subcommand> <args> is one of the following:\n" 73 "\n"); 74 75 (void) fprintf(stderr, 76 " feature stat <pool>\n" 77 " print information about enabled features\n" 78 " feature enable [-r] [-d desc] <pool> <feature>\n" 79 " add a new enabled feature to the pool\n" 80 " -d <desc> sets the feature's description\n" 81 " -r set read-only compatible flag for feature\n" 82 " feature ref [-md] <pool> <feature>\n" 83 " change the refcount on the given feature\n" 84 " -d decrease instead of increase the refcount\n" 85 " -m add the feature to the label if increasing refcount\n" 86 "\n" 87 " <feature> : should be a feature guid\n" 88 "\n" 89 " label repair <device>\n" 90 " repair labels of a specified device according to options\n" 91 " which may be combined to do their functions in one call\n" 92 " -c repair corrupted label checksums\n" 93 " -u restore the label on a detached device\n" 94 "\n" 95 " <device> : path to vdev\n"); 96 exit(1); 97 } 98 99 100 static __attribute__((format(printf, 3, 4))) __attribute__((noreturn)) void 101 fatal(spa_t *spa, const void *tag, const char *fmt, ...) 102 { 103 va_list ap; 104 105 if (spa != NULL) { 106 spa_close(spa, tag); 107 (void) spa_export(g_pool, NULL, B_TRUE, B_FALSE); 108 } 109 110 va_start(ap, fmt); 111 (void) fputs("zhack: ", stderr); 112 (void) vfprintf(stderr, fmt, ap); 113 va_end(ap); 114 (void) fputc('\n', stderr); 115 116 exit(1); 117 } 118 119 static int 120 space_delta_cb(dmu_object_type_t bonustype, const void *data, 121 zfs_file_info_t *zoi) 122 { 123 (void) data, (void) zoi; 124 125 /* 126 * Is it a valid type of object to track? 127 */ 128 if (bonustype != DMU_OT_ZNODE && bonustype != DMU_OT_SA) 129 return (ENOENT); 130 (void) fprintf(stderr, "modifying object that needs user accounting"); 131 abort(); 132 } 133 134 /* 135 * Target is the dataset whose pool we want to open. 136 */ 137 static void 138 zhack_import(char *target, boolean_t readonly) 139 { 140 nvlist_t *config; 141 nvlist_t *props; 142 int error; 143 144 kernel_init(readonly ? SPA_MODE_READ : 145 (SPA_MODE_READ | SPA_MODE_WRITE)); 146 147 dmu_objset_register_type(DMU_OST_ZFS, space_delta_cb); 148 149 g_readonly = readonly; 150 g_importargs.can_be_active = readonly; 151 g_pool = strdup(target); 152 153 libpc_handle_t lpch = { 154 .lpc_lib_handle = NULL, 155 .lpc_ops = &libzpool_config_ops, 156 .lpc_printerr = B_TRUE 157 }; 158 error = zpool_find_config(&lpch, target, &config, &g_importargs); 159 if (error) 160 fatal(NULL, FTAG, "cannot import '%s'", target); 161 162 props = NULL; 163 if (readonly) { 164 VERIFY(nvlist_alloc(&props, NV_UNIQUE_NAME, 0) == 0); 165 VERIFY(nvlist_add_uint64(props, 166 zpool_prop_to_name(ZPOOL_PROP_READONLY), 1) == 0); 167 } 168 169 zfeature_checks_disable = B_TRUE; 170 error = spa_import(target, config, props, 171 (readonly ? ZFS_IMPORT_SKIP_MMP : ZFS_IMPORT_NORMAL)); 172 fnvlist_free(config); 173 zfeature_checks_disable = B_FALSE; 174 if (error == EEXIST) 175 error = 0; 176 177 if (error) 178 fatal(NULL, FTAG, "can't import '%s': %s", target, 179 strerror(error)); 180 } 181 182 static void 183 zhack_spa_open(char *target, boolean_t readonly, const void *tag, spa_t **spa) 184 { 185 int err; 186 187 zhack_import(target, readonly); 188 189 zfeature_checks_disable = B_TRUE; 190 err = spa_open(target, spa, tag); 191 zfeature_checks_disable = B_FALSE; 192 193 if (err != 0) 194 fatal(*spa, FTAG, "cannot open '%s': %s", target, 195 strerror(err)); 196 if (spa_version(*spa) < SPA_VERSION_FEATURES) { 197 fatal(*spa, FTAG, "'%s' has version %d, features not enabled", 198 target, (int)spa_version(*spa)); 199 } 200 } 201 202 static void 203 dump_obj(objset_t *os, uint64_t obj, const char *name) 204 { 205 zap_cursor_t zc; 206 zap_attribute_t *za = zap_attribute_long_alloc(); 207 208 (void) printf("%s_obj:\n", name); 209 210 for (zap_cursor_init(&zc, os, obj); 211 zap_cursor_retrieve(&zc, za) == 0; 212 zap_cursor_advance(&zc)) { 213 if (za->za_integer_length == 8) { 214 ASSERT(za->za_num_integers == 1); 215 (void) printf("\t%s = %llu\n", 216 za->za_name, (u_longlong_t)za->za_first_integer); 217 } else { 218 ASSERT(za->za_integer_length == 1); 219 char val[1024]; 220 VERIFY(zap_lookup(os, obj, za->za_name, 221 1, sizeof (val), val) == 0); 222 (void) printf("\t%s = %s\n", za->za_name, val); 223 } 224 } 225 zap_cursor_fini(&zc); 226 zap_attribute_free(za); 227 } 228 229 static void 230 dump_mos(spa_t *spa) 231 { 232 nvlist_t *nv = spa->spa_label_features; 233 nvpair_t *pair; 234 235 (void) printf("label config:\n"); 236 for (pair = nvlist_next_nvpair(nv, NULL); 237 pair != NULL; 238 pair = nvlist_next_nvpair(nv, pair)) { 239 (void) printf("\t%s\n", nvpair_name(pair)); 240 } 241 } 242 243 static void 244 zhack_do_feature_stat(int argc, char **argv) 245 { 246 spa_t *spa; 247 objset_t *os; 248 char *target; 249 250 argc--; 251 argv++; 252 253 if (argc < 1) { 254 (void) fprintf(stderr, "error: missing pool name\n"); 255 usage(); 256 } 257 target = argv[0]; 258 259 zhack_spa_open(target, B_TRUE, FTAG, &spa); 260 os = spa->spa_meta_objset; 261 262 dump_obj(os, spa->spa_feat_for_read_obj, "for_read"); 263 dump_obj(os, spa->spa_feat_for_write_obj, "for_write"); 264 dump_obj(os, spa->spa_feat_desc_obj, "descriptions"); 265 if (spa_feature_is_active(spa, SPA_FEATURE_ENABLED_TXG)) { 266 dump_obj(os, spa->spa_feat_enabled_txg_obj, "enabled_txg"); 267 } 268 dump_mos(spa); 269 270 spa_close(spa, FTAG); 271 } 272 273 static void 274 zhack_feature_enable_sync(void *arg, dmu_tx_t *tx) 275 { 276 spa_t *spa = dmu_tx_pool(tx)->dp_spa; 277 zfeature_info_t *feature = arg; 278 279 feature_enable_sync(spa, feature, tx); 280 281 spa_history_log_internal(spa, "zhack enable feature", tx, 282 "name=%s flags=%u", 283 feature->fi_guid, feature->fi_flags); 284 } 285 286 static void 287 zhack_do_feature_enable(int argc, char **argv) 288 { 289 int c; 290 char *desc, *target; 291 spa_t *spa; 292 objset_t *mos; 293 zfeature_info_t feature; 294 const spa_feature_t nodeps[] = { SPA_FEATURE_NONE }; 295 296 /* 297 * Features are not added to the pool's label until their refcounts 298 * are incremented, so fi_mos can just be left as false for now. 299 */ 300 desc = NULL; 301 feature.fi_uname = "zhack"; 302 feature.fi_flags = 0; 303 feature.fi_depends = nodeps; 304 feature.fi_feature = SPA_FEATURE_NONE; 305 306 optind = 1; 307 while ((c = getopt(argc, argv, "+rd:")) != -1) { 308 switch (c) { 309 case 'r': 310 feature.fi_flags |= ZFEATURE_FLAG_READONLY_COMPAT; 311 break; 312 case 'd': 313 if (desc != NULL) 314 free(desc); 315 desc = strdup(optarg); 316 break; 317 default: 318 usage(); 319 break; 320 } 321 } 322 323 if (desc == NULL) 324 desc = strdup("zhack injected"); 325 feature.fi_desc = desc; 326 327 argc -= optind; 328 argv += optind; 329 330 if (argc < 2) { 331 (void) fprintf(stderr, "error: missing feature or pool name\n"); 332 usage(); 333 } 334 target = argv[0]; 335 feature.fi_guid = argv[1]; 336 337 if (!zfeature_is_valid_guid(feature.fi_guid)) 338 fatal(NULL, FTAG, "invalid feature guid: %s", feature.fi_guid); 339 340 zhack_spa_open(target, B_FALSE, FTAG, &spa); 341 mos = spa->spa_meta_objset; 342 343 if (zfeature_is_supported(feature.fi_guid)) 344 fatal(spa, FTAG, "'%s' is a real feature, will not enable", 345 feature.fi_guid); 346 if (0 == zap_contains(mos, spa->spa_feat_desc_obj, feature.fi_guid)) 347 fatal(spa, FTAG, "feature already enabled: %s", 348 feature.fi_guid); 349 350 VERIFY0(dsl_sync_task(spa_name(spa), NULL, 351 zhack_feature_enable_sync, &feature, 5, ZFS_SPACE_CHECK_NORMAL)); 352 353 spa_close(spa, FTAG); 354 355 free(desc); 356 } 357 358 static void 359 feature_incr_sync(void *arg, dmu_tx_t *tx) 360 { 361 spa_t *spa = dmu_tx_pool(tx)->dp_spa; 362 zfeature_info_t *feature = arg; 363 uint64_t refcount; 364 365 VERIFY0(feature_get_refcount_from_disk(spa, feature, &refcount)); 366 feature_sync(spa, feature, refcount + 1, tx); 367 spa_history_log_internal(spa, "zhack feature incr", tx, 368 "name=%s", feature->fi_guid); 369 } 370 371 static void 372 feature_decr_sync(void *arg, dmu_tx_t *tx) 373 { 374 spa_t *spa = dmu_tx_pool(tx)->dp_spa; 375 zfeature_info_t *feature = arg; 376 uint64_t refcount; 377 378 VERIFY0(feature_get_refcount_from_disk(spa, feature, &refcount)); 379 feature_sync(spa, feature, refcount - 1, tx); 380 spa_history_log_internal(spa, "zhack feature decr", tx, 381 "name=%s", feature->fi_guid); 382 } 383 384 static void 385 zhack_do_feature_ref(int argc, char **argv) 386 { 387 int c; 388 char *target; 389 boolean_t decr = B_FALSE; 390 spa_t *spa; 391 objset_t *mos; 392 zfeature_info_t feature; 393 const spa_feature_t nodeps[] = { SPA_FEATURE_NONE }; 394 395 /* 396 * fi_desc does not matter here because it was written to disk 397 * when the feature was enabled, but we need to properly set the 398 * feature for read or write based on the information we read off 399 * disk later. 400 */ 401 feature.fi_uname = "zhack"; 402 feature.fi_flags = 0; 403 feature.fi_desc = NULL; 404 feature.fi_depends = nodeps; 405 feature.fi_feature = SPA_FEATURE_NONE; 406 407 optind = 1; 408 while ((c = getopt(argc, argv, "+md")) != -1) { 409 switch (c) { 410 case 'm': 411 feature.fi_flags |= ZFEATURE_FLAG_MOS; 412 break; 413 case 'd': 414 decr = B_TRUE; 415 break; 416 default: 417 usage(); 418 break; 419 } 420 } 421 argc -= optind; 422 argv += optind; 423 424 if (argc < 2) { 425 (void) fprintf(stderr, "error: missing feature or pool name\n"); 426 usage(); 427 } 428 target = argv[0]; 429 feature.fi_guid = argv[1]; 430 431 if (!zfeature_is_valid_guid(feature.fi_guid)) 432 fatal(NULL, FTAG, "invalid feature guid: %s", feature.fi_guid); 433 434 zhack_spa_open(target, B_FALSE, FTAG, &spa); 435 mos = spa->spa_meta_objset; 436 437 if (zfeature_is_supported(feature.fi_guid)) { 438 fatal(spa, FTAG, 439 "'%s' is a real feature, will not change refcount", 440 feature.fi_guid); 441 } 442 443 if (0 == zap_contains(mos, spa->spa_feat_for_read_obj, 444 feature.fi_guid)) { 445 feature.fi_flags &= ~ZFEATURE_FLAG_READONLY_COMPAT; 446 } else if (0 == zap_contains(mos, spa->spa_feat_for_write_obj, 447 feature.fi_guid)) { 448 feature.fi_flags |= ZFEATURE_FLAG_READONLY_COMPAT; 449 } else { 450 fatal(spa, FTAG, "feature is not enabled: %s", feature.fi_guid); 451 } 452 453 if (decr) { 454 uint64_t count; 455 if (feature_get_refcount_from_disk(spa, &feature, 456 &count) == 0 && count == 0) { 457 fatal(spa, FTAG, "feature refcount already 0: %s", 458 feature.fi_guid); 459 } 460 } 461 462 VERIFY0(dsl_sync_task(spa_name(spa), NULL, 463 decr ? feature_decr_sync : feature_incr_sync, &feature, 464 5, ZFS_SPACE_CHECK_NORMAL)); 465 466 spa_close(spa, FTAG); 467 } 468 469 static int 470 zhack_do_feature(int argc, char **argv) 471 { 472 char *subcommand; 473 474 argc--; 475 argv++; 476 if (argc == 0) { 477 (void) fprintf(stderr, 478 "error: no feature operation specified\n"); 479 usage(); 480 } 481 482 subcommand = argv[0]; 483 if (strcmp(subcommand, "stat") == 0) { 484 zhack_do_feature_stat(argc, argv); 485 } else if (strcmp(subcommand, "enable") == 0) { 486 zhack_do_feature_enable(argc, argv); 487 } else if (strcmp(subcommand, "ref") == 0) { 488 zhack_do_feature_ref(argc, argv); 489 } else { 490 (void) fprintf(stderr, "error: unknown subcommand: %s\n", 491 subcommand); 492 usage(); 493 } 494 495 return (0); 496 } 497 498 #define ASHIFT_UBERBLOCK_SHIFT(ashift) \ 499 MIN(MAX(ashift, UBERBLOCK_SHIFT), \ 500 MAX_UBERBLOCK_SHIFT) 501 #define ASHIFT_UBERBLOCK_SIZE(ashift) \ 502 (1ULL << ASHIFT_UBERBLOCK_SHIFT(ashift)) 503 504 #define REPAIR_LABEL_STATUS_CKSUM (1 << 0) 505 #define REPAIR_LABEL_STATUS_UB (1 << 1) 506 507 static int 508 zhack_repair_read_label(const int fd, vdev_label_t *vl, 509 const uint64_t label_offset, const int l) 510 { 511 const int err = pread64(fd, vl, sizeof (vdev_label_t), label_offset); 512 513 if (err == -1) { 514 (void) fprintf(stderr, 515 "error: cannot read label %d: %s\n", 516 l, strerror(errno)); 517 return (err); 518 } else if (err != sizeof (vdev_label_t)) { 519 (void) fprintf(stderr, 520 "error: bad label %d read size\n", l); 521 return (err); 522 } 523 524 return (0); 525 } 526 527 static void 528 zhack_repair_calc_cksum(const int byteswap, void *data, const uint64_t offset, 529 const uint64_t abdsize, zio_eck_t *eck, zio_cksum_t *cksum) 530 { 531 zio_cksum_t verifier; 532 zio_cksum_t current_cksum; 533 zio_checksum_info_t *ci; 534 abd_t *abd; 535 536 ZIO_SET_CHECKSUM(&verifier, offset, 0, 0, 0); 537 538 if (byteswap) 539 byteswap_uint64_array(&verifier, sizeof (zio_cksum_t)); 540 541 current_cksum = eck->zec_cksum; 542 eck->zec_cksum = verifier; 543 544 ci = &zio_checksum_table[ZIO_CHECKSUM_LABEL]; 545 abd = abd_get_from_buf(data, abdsize); 546 ci->ci_func[byteswap](abd, abdsize, NULL, cksum); 547 abd_free(abd); 548 549 eck->zec_cksum = current_cksum; 550 } 551 552 static int 553 zhack_repair_check_label(uberblock_t *ub, const int l, const char **cfg_keys, 554 const size_t cfg_keys_len, nvlist_t *cfg, nvlist_t *vdev_tree_cfg, 555 uint64_t *ashift) 556 { 557 int err; 558 559 if (ub->ub_txg != 0) { 560 (void) fprintf(stderr, 561 "error: label %d: UB TXG of 0 expected, but got %" 562 PRIu64 "\n", 563 l, ub->ub_txg); 564 (void) fprintf(stderr, "It would appear the device was not " 565 "properly removed.\n"); 566 return (1); 567 } 568 569 for (int i = 0; i < cfg_keys_len; i++) { 570 uint64_t val; 571 err = nvlist_lookup_uint64(cfg, cfg_keys[i], &val); 572 if (err) { 573 (void) fprintf(stderr, 574 "error: label %d, %d: " 575 "cannot find nvlist key %s\n", 576 l, i, cfg_keys[i]); 577 return (err); 578 } 579 } 580 581 err = nvlist_lookup_nvlist(cfg, 582 ZPOOL_CONFIG_VDEV_TREE, &vdev_tree_cfg); 583 if (err) { 584 (void) fprintf(stderr, 585 "error: label %d: cannot find nvlist key %s\n", 586 l, ZPOOL_CONFIG_VDEV_TREE); 587 return (err); 588 } 589 590 err = nvlist_lookup_uint64(vdev_tree_cfg, 591 ZPOOL_CONFIG_ASHIFT, ashift); 592 if (err) { 593 (void) fprintf(stderr, 594 "error: label %d: cannot find nvlist key %s\n", 595 l, ZPOOL_CONFIG_ASHIFT); 596 return (err); 597 } 598 599 if (*ashift == 0) { 600 (void) fprintf(stderr, 601 "error: label %d: nvlist key %s is zero\n", 602 l, ZPOOL_CONFIG_ASHIFT); 603 return (err); 604 } 605 606 return (0); 607 } 608 609 static int 610 zhack_repair_undetach(uberblock_t *ub, nvlist_t *cfg, const int l) 611 { 612 /* 613 * Uberblock root block pointer has valid birth TXG. 614 * Copying it to the label NVlist 615 */ 616 if (BP_GET_LOGICAL_BIRTH(&ub->ub_rootbp) != 0) { 617 const uint64_t txg = BP_GET_LOGICAL_BIRTH(&ub->ub_rootbp); 618 ub->ub_txg = txg; 619 620 if (nvlist_remove_all(cfg, ZPOOL_CONFIG_CREATE_TXG) != 0) { 621 (void) fprintf(stderr, 622 "error: label %d: " 623 "Failed to remove pool creation TXG\n", 624 l); 625 return (1); 626 } 627 628 if (nvlist_remove_all(cfg, ZPOOL_CONFIG_POOL_TXG) != 0) { 629 (void) fprintf(stderr, 630 "error: label %d: Failed to remove pool TXG to " 631 "be replaced.\n", 632 l); 633 return (1); 634 } 635 636 if (nvlist_add_uint64(cfg, ZPOOL_CONFIG_POOL_TXG, txg) != 0) { 637 (void) fprintf(stderr, 638 "error: label %d: " 639 "Failed to add pool TXG of %" PRIu64 "\n", 640 l, txg); 641 return (1); 642 } 643 } 644 645 return (0); 646 } 647 648 static boolean_t 649 zhack_repair_write_label(const int l, const int fd, const int byteswap, 650 void *data, zio_eck_t *eck, const uint64_t offset, const uint64_t abdsize) 651 { 652 zio_cksum_t actual_cksum; 653 zhack_repair_calc_cksum(byteswap, data, offset, abdsize, eck, 654 &actual_cksum); 655 zio_cksum_t expected_cksum = eck->zec_cksum; 656 ssize_t err; 657 658 if (ZIO_CHECKSUM_EQUAL(actual_cksum, expected_cksum)) 659 return (B_FALSE); 660 661 eck->zec_cksum = actual_cksum; 662 663 err = pwrite64(fd, data, abdsize, offset); 664 if (err == -1) { 665 (void) fprintf(stderr, "error: cannot write label %d: %s\n", 666 l, strerror(errno)); 667 return (B_FALSE); 668 } else if (err != abdsize) { 669 (void) fprintf(stderr, "error: bad write size label %d\n", l); 670 return (B_FALSE); 671 } else { 672 (void) fprintf(stderr, 673 "label %d: wrote %" PRIu64 " bytes at offset %" PRIu64 "\n", 674 l, abdsize, offset); 675 } 676 677 return (B_TRUE); 678 } 679 680 static void 681 zhack_repair_write_uberblock(vdev_label_t *vl, const int l, 682 const uint64_t ashift, const int fd, const int byteswap, 683 const uint64_t label_offset, uint32_t *labels_repaired) 684 { 685 void *ub_data = 686 (char *)vl + offsetof(vdev_label_t, vl_uberblock); 687 zio_eck_t *ub_eck = 688 (zio_eck_t *) 689 ((char *)(ub_data) + (ASHIFT_UBERBLOCK_SIZE(ashift))) - 1; 690 691 if (ub_eck->zec_magic != 0) { 692 (void) fprintf(stderr, 693 "error: label %d: " 694 "Expected Uberblock checksum magic number to " 695 "be 0, but got %" PRIu64 "\n", 696 l, ub_eck->zec_magic); 697 (void) fprintf(stderr, "It would appear there's already " 698 "a checksum for the uberblock.\n"); 699 return; 700 } 701 702 703 ub_eck->zec_magic = byteswap ? BSWAP_64(ZEC_MAGIC) : ZEC_MAGIC; 704 705 if (zhack_repair_write_label(l, fd, byteswap, 706 ub_data, ub_eck, 707 label_offset + offsetof(vdev_label_t, vl_uberblock), 708 ASHIFT_UBERBLOCK_SIZE(ashift))) 709 labels_repaired[l] |= REPAIR_LABEL_STATUS_UB; 710 } 711 712 static void 713 zhack_repair_print_cksum(FILE *stream, const zio_cksum_t *cksum) 714 { 715 (void) fprintf(stream, 716 "%016llx:%016llx:%016llx:%016llx", 717 (u_longlong_t)cksum->zc_word[0], 718 (u_longlong_t)cksum->zc_word[1], 719 (u_longlong_t)cksum->zc_word[2], 720 (u_longlong_t)cksum->zc_word[3]); 721 } 722 723 static int 724 zhack_repair_test_cksum(const int byteswap, void *vdev_data, 725 zio_eck_t *vdev_eck, const uint64_t vdev_phys_offset, const int l) 726 { 727 const zio_cksum_t expected_cksum = vdev_eck->zec_cksum; 728 zio_cksum_t actual_cksum; 729 zhack_repair_calc_cksum(byteswap, vdev_data, vdev_phys_offset, 730 VDEV_PHYS_SIZE, vdev_eck, &actual_cksum); 731 const uint64_t expected_magic = byteswap ? 732 BSWAP_64(ZEC_MAGIC) : ZEC_MAGIC; 733 const uint64_t actual_magic = vdev_eck->zec_magic; 734 int err = 0; 735 if (actual_magic != expected_magic) { 736 (void) fprintf(stderr, "error: label %d: " 737 "Expected " 738 "the nvlist checksum magic number to not be %" 739 PRIu64 " not %" PRIu64 "\n", 740 l, expected_magic, actual_magic); 741 err = ECKSUM; 742 } 743 if (!ZIO_CHECKSUM_EQUAL(actual_cksum, expected_cksum)) { 744 (void) fprintf(stderr, "error: label %d: " 745 "Expected the nvlist checksum to be ", l); 746 (void) zhack_repair_print_cksum(stderr, 747 &expected_cksum); 748 (void) fprintf(stderr, " not "); 749 zhack_repair_print_cksum(stderr, &actual_cksum); 750 (void) fprintf(stderr, "\n"); 751 err = ECKSUM; 752 } 753 return (err); 754 } 755 756 static void 757 zhack_repair_one_label(const zhack_repair_op_t op, const int fd, 758 vdev_label_t *vl, const uint64_t label_offset, const int l, 759 uint32_t *labels_repaired) 760 { 761 ssize_t err; 762 uberblock_t *ub = (uberblock_t *)vl->vl_uberblock; 763 void *vdev_data = 764 (char *)vl + offsetof(vdev_label_t, vl_vdev_phys); 765 zio_eck_t *vdev_eck = 766 (zio_eck_t *)((char *)(vdev_data) + VDEV_PHYS_SIZE) - 1; 767 const uint64_t vdev_phys_offset = 768 label_offset + offsetof(vdev_label_t, vl_vdev_phys); 769 const char *cfg_keys[] = { ZPOOL_CONFIG_VERSION, 770 ZPOOL_CONFIG_POOL_STATE, ZPOOL_CONFIG_GUID }; 771 nvlist_t *cfg; 772 nvlist_t *vdev_tree_cfg = NULL; 773 uint64_t ashift; 774 int byteswap; 775 776 err = zhack_repair_read_label(fd, vl, label_offset, l); 777 if (err) 778 return; 779 780 if (vdev_eck->zec_magic == 0) { 781 (void) fprintf(stderr, "error: label %d: " 782 "Expected the nvlist checksum magic number to not be zero" 783 "\n", 784 l); 785 (void) fprintf(stderr, "There should already be a checksum " 786 "for the label.\n"); 787 return; 788 } 789 790 byteswap = 791 (vdev_eck->zec_magic == BSWAP_64((uint64_t)ZEC_MAGIC)); 792 793 if (byteswap) { 794 byteswap_uint64_array(&vdev_eck->zec_cksum, 795 sizeof (zio_cksum_t)); 796 vdev_eck->zec_magic = BSWAP_64(vdev_eck->zec_magic); 797 } 798 799 if ((op & ZHACK_REPAIR_OP_CKSUM) == 0 && 800 zhack_repair_test_cksum(byteswap, vdev_data, vdev_eck, 801 vdev_phys_offset, l) != 0) { 802 (void) fprintf(stderr, "It would appear checksums are " 803 "corrupted. Try zhack repair label -c <device>\n"); 804 return; 805 } 806 807 err = nvlist_unpack(vl->vl_vdev_phys.vp_nvlist, 808 VDEV_PHYS_SIZE - sizeof (zio_eck_t), &cfg, 0); 809 if (err) { 810 (void) fprintf(stderr, 811 "error: cannot unpack nvlist label %d\n", l); 812 return; 813 } 814 815 err = zhack_repair_check_label(ub, 816 l, cfg_keys, ARRAY_SIZE(cfg_keys), cfg, vdev_tree_cfg, &ashift); 817 if (err) 818 return; 819 820 if ((op & ZHACK_REPAIR_OP_UNDETACH) != 0) { 821 char *buf; 822 size_t buflen; 823 824 err = zhack_repair_undetach(ub, cfg, l); 825 if (err) 826 return; 827 828 buf = vl->vl_vdev_phys.vp_nvlist; 829 buflen = VDEV_PHYS_SIZE - sizeof (zio_eck_t); 830 if (nvlist_pack(cfg, &buf, &buflen, NV_ENCODE_XDR, 0) != 0) { 831 (void) fprintf(stderr, 832 "error: label %d: Failed to pack nvlist\n", l); 833 return; 834 } 835 836 zhack_repair_write_uberblock(vl, 837 l, ashift, fd, byteswap, label_offset, labels_repaired); 838 } 839 840 if (zhack_repair_write_label(l, fd, byteswap, vdev_data, vdev_eck, 841 vdev_phys_offset, VDEV_PHYS_SIZE)) 842 labels_repaired[l] |= REPAIR_LABEL_STATUS_CKSUM; 843 844 fsync(fd); 845 } 846 847 static const char * 848 zhack_repair_label_status(const uint32_t label_status, 849 const uint32_t to_check) 850 { 851 return ((label_status & to_check) != 0 ? "repaired" : "skipped"); 852 } 853 854 static int 855 zhack_label_repair(const zhack_repair_op_t op, const int argc, char **argv) 856 { 857 uint32_t labels_repaired[VDEV_LABELS] = {0}; 858 vdev_label_t labels[VDEV_LABELS] = {{{0}}}; 859 struct stat64 st; 860 int fd; 861 off_t filesize; 862 uint32_t repaired = 0; 863 864 abd_init(); 865 866 if (argc < 1) { 867 (void) fprintf(stderr, "error: missing device\n"); 868 usage(); 869 } 870 871 if ((fd = open(argv[0], O_RDWR)) == -1) 872 fatal(NULL, FTAG, "cannot open '%s': %s", argv[0], 873 strerror(errno)); 874 875 if (fstat64_blk(fd, &st) != 0) 876 fatal(NULL, FTAG, "cannot stat '%s': %s", argv[0], 877 strerror(errno)); 878 879 filesize = st.st_size; 880 (void) fprintf(stderr, "Calculated filesize to be %jd\n", 881 (intmax_t)filesize); 882 883 if (filesize % sizeof (vdev_label_t) != 0) 884 filesize = 885 (filesize / sizeof (vdev_label_t)) * sizeof (vdev_label_t); 886 887 for (int l = 0; l < VDEV_LABELS; l++) { 888 zhack_repair_one_label(op, fd, &labels[l], 889 vdev_label_offset(filesize, l, 0), l, labels_repaired); 890 } 891 892 close(fd); 893 894 abd_fini(); 895 896 for (int l = 0; l < VDEV_LABELS; l++) { 897 const uint32_t lr = labels_repaired[l]; 898 (void) printf("label %d: ", l); 899 (void) printf("uberblock: %s ", 900 zhack_repair_label_status(lr, REPAIR_LABEL_STATUS_UB)); 901 (void) printf("checksum: %s\n", 902 zhack_repair_label_status(lr, REPAIR_LABEL_STATUS_CKSUM)); 903 repaired |= lr; 904 } 905 906 if (repaired > 0) 907 return (0); 908 909 return (1); 910 } 911 912 static int 913 zhack_do_label_repair(int argc, char **argv) 914 { 915 zhack_repair_op_t op = ZHACK_REPAIR_OP_UNKNOWN; 916 int c; 917 918 optind = 1; 919 while ((c = getopt(argc, argv, "+cu")) != -1) { 920 switch (c) { 921 case 'c': 922 op |= ZHACK_REPAIR_OP_CKSUM; 923 break; 924 case 'u': 925 op |= ZHACK_REPAIR_OP_UNDETACH; 926 break; 927 default: 928 usage(); 929 break; 930 } 931 } 932 933 argc -= optind; 934 argv += optind; 935 936 if (op == ZHACK_REPAIR_OP_UNKNOWN) 937 op = ZHACK_REPAIR_OP_CKSUM; 938 939 return (zhack_label_repair(op, argc, argv)); 940 } 941 942 static int 943 zhack_do_label(int argc, char **argv) 944 { 945 char *subcommand; 946 int err; 947 948 argc--; 949 argv++; 950 if (argc == 0) { 951 (void) fprintf(stderr, 952 "error: no label operation specified\n"); 953 usage(); 954 } 955 956 subcommand = argv[0]; 957 if (strcmp(subcommand, "repair") == 0) { 958 err = zhack_do_label_repair(argc, argv); 959 } else { 960 (void) fprintf(stderr, "error: unknown subcommand: %s\n", 961 subcommand); 962 usage(); 963 } 964 965 return (err); 966 } 967 968 #define MAX_NUM_PATHS 1024 969 970 int 971 main(int argc, char **argv) 972 { 973 char *path[MAX_NUM_PATHS]; 974 const char *subcommand; 975 int rv = 0; 976 int c; 977 978 g_importargs.path = path; 979 980 dprintf_setup(&argc, argv); 981 zfs_prop_init(); 982 983 while ((c = getopt(argc, argv, "+c:d:")) != -1) { 984 switch (c) { 985 case 'c': 986 g_importargs.cachefile = optarg; 987 break; 988 case 'd': 989 assert(g_importargs.paths < MAX_NUM_PATHS); 990 g_importargs.path[g_importargs.paths++] = optarg; 991 break; 992 default: 993 usage(); 994 break; 995 } 996 } 997 998 argc -= optind; 999 argv += optind; 1000 optind = 1; 1001 1002 if (argc == 0) { 1003 (void) fprintf(stderr, "error: no command specified\n"); 1004 usage(); 1005 } 1006 1007 subcommand = argv[0]; 1008 1009 if (strcmp(subcommand, "feature") == 0) { 1010 rv = zhack_do_feature(argc, argv); 1011 } else if (strcmp(subcommand, "label") == 0) { 1012 return (zhack_do_label(argc, argv)); 1013 } else { 1014 (void) fprintf(stderr, "error: unknown subcommand: %s\n", 1015 subcommand); 1016 usage(); 1017 } 1018 1019 if (!g_readonly && spa_export(g_pool, NULL, B_TRUE, B_FALSE) != 0) { 1020 fatal(NULL, FTAG, "pool export failed; " 1021 "changes may not be committed to disk\n"); 1022 } 1023 1024 kernel_fini(); 1025 1026 return (rv); 1027 } 1028