37 #include <sys/vdev.h>
38 #include <sys/vdev_impl.h>
39 #include <sys/metaslab_impl.h>
40 #include <sys/dmu_objset.h>
41 #include <sys/dsl_dir.h>
42 #include <sys/dsl_dataset.h>
43 #include <sys/dsl_pool.h>
44 #include <sys/dbuf.h>
45 #include <sys/zil.h>
46 #include <sys/zil_impl.h>
47 #include <sys/stat.h>
48 #include <sys/resource.h>
49 #include <sys/dmu_traverse.h>
50 #include <sys/zio_checksum.h>
51 #include <sys/zio_compress.h>
52 #include <sys/zfs_fuid.h>
53 #include <sys/arc.h>
54 #undef ZFS_MAXNAMELEN
55 #undef verify
56 #include <libzfs.h>
57
58 const char cmdname[] = "zdb";
59 uint8_t dump_opt[256];
60
61 typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
62
63 extern void dump_intent_log(zilog_t *);
64 uint64_t *zopt_object = NULL;
65 int zopt_objects = 0;
66 libzfs_handle_t *g_zfs;
67 boolean_t zdb_sig_user_data = B_TRUE;
68 int zdb_sig_cksumalg = ZIO_CHECKSUM_SHA256;
69
70 /*
71 * These libumem hooks provide a reasonable set of defaults for the allocator's
72 * debugging facilities.
73 */
74 const char *
75 _umem_debug_init()
76 {
77 return ("default,verbose"); /* $UMEM_DEBUG setting */
78 }
79
80 const char *
81 _umem_logging_init(void)
82 {
83 return ("fail,contents"); /* $UMEM_LOGGING setting */
84 }
85
86 static void
87 usage(void)
88 {
1055
1056 nicenum(doi.doi_metadata_block_size, iblk);
1057 nicenum(doi.doi_data_block_size, dblk);
1058 nicenum(doi.doi_data_block_size * (doi.doi_max_block_offset + 1),
1059 lsize);
1060 nicenum(doi.doi_physical_blks << 9, asize);
1061 nicenum(doi.doi_bonus_size, bonus_size);
1062
1063 aux[0] = '\0';
1064
1065 if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
1066 (void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
1067 zio_checksum_table[doi.doi_checksum].ci_name);
1068 }
1069
1070 if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
1071 (void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
1072 zio_compress_table[doi.doi_compress].ci_name);
1073 }
1074
1075 (void) printf("%10lld %3u %5s %5s %5s %5s %s%s\n",
1076 (u_longlong_t)object, doi.doi_indirection, iblk, dblk, lsize,
1077 asize, dmu_ot[doi.doi_type].ot_name, aux);
1078
1079 if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
1080 (void) printf("%10s %3s %5s %5s %5s %5s %s\n",
1081 "", "", "", "", bonus_size, "bonus",
1082 dmu_ot[doi.doi_bonus_type].ot_name);
1083 }
1084
1085 if (verbosity >= 4) {
1086 object_viewer[doi.doi_bonus_type](os, object, bonus, bsize);
1087 object_viewer[doi.doi_type](os, object, NULL, 0);
1088 *print_header = 1;
1089 }
1090
1091 if (verbosity >= 5)
1092 dump_indirect(dn);
1093
1094 if (verbosity >= 5) {
1462 int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
1463 int t = (i & 1) ? type : DMU_OT_TOTAL;
1464 zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
1465
1466 zb->zb_asize += BP_GET_ASIZE(bp);
1467 zb->zb_lsize += BP_GET_LSIZE(bp);
1468 zb->zb_psize += BP_GET_PSIZE(bp);
1469 zb->zb_count++;
1470 }
1471
1472 if (dump_opt['S']) {
1473 boolean_t print_sig;
1474
1475 print_sig = !zdb_sig_user_data || (BP_GET_LEVEL(bp) == 0 &&
1476 BP_GET_TYPE(bp) == DMU_OT_PLAIN_FILE_CONTENTS);
1477
1478 if (BP_GET_CHECKSUM(bp) < zdb_sig_cksumalg)
1479 print_sig = B_FALSE;
1480
1481 if (print_sig) {
1482 (void) printf("%llu\t%lld\t%lld\t%s\t%s\t%s\t"
1483 "%llx:%llx:%llx:%llx\n",
1484 (u_longlong_t)BP_GET_LEVEL(bp),
1485 (longlong_t)BP_GET_PSIZE(bp),
1486 (longlong_t)BP_GET_NDVAS(bp),
1487 dmu_ot[BP_GET_TYPE(bp)].ot_name,
1488 zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_name,
1489 zio_compress_table[BP_GET_COMPRESS(bp)].ci_name,
1490 (u_longlong_t)bp->blk_cksum.zc_word[0],
1491 (u_longlong_t)bp->blk_cksum.zc_word[1],
1492 (u_longlong_t)bp->blk_cksum.zc_word[2],
1493 (u_longlong_t)bp->blk_cksum.zc_word[3]);
1494 }
1495 }
1496
1497 if (!dump_opt['L'])
1498 VERIFY(zio_wait(zio_claim(NULL, spa, spa_first_txg(spa), bp,
1499 NULL, NULL, ZIO_FLAG_MUSTSUCCEED)) == 0);
1500 }
1501
1502 static int
1503 zdb_blkptr_cb(spa_t *spa, blkptr_t *bp, const zbookmark_t *zb,
1504 const dnode_phys_t *dnp, void *arg)
1505 {
1506 zdb_cb_t *zcb = arg;
1507 char blkbuf[BP_SPRINTF_LEN];
1508
1509 if (bp == NULL)
1828 (longlong_t)DVA_GET_GRID(&dva[d]),
1829 (longlong_t)DVA_GET_ASIZE(&dva[d]));
1830 (void) printf("\tDVA[%d]: :%llu:%llx:%llx:%s%s%s%s\n", d,
1831 (u_longlong_t)DVA_GET_VDEV(&dva[d]),
1832 (longlong_t)DVA_GET_OFFSET(&dva[d]),
1833 (longlong_t)BP_GET_PSIZE(bp),
1834 BP_SHOULD_BYTESWAP(bp) ? "e" : "",
1835 !DVA_GET_GANG(&dva[d]) && BP_GET_LEVEL(bp) != 0 ?
1836 "d" : "",
1837 DVA_GET_GANG(&dva[d]) ? "g" : "",
1838 BP_GET_COMPRESS(bp) != 0 ? "d" : "");
1839 }
1840 (void) printf("\tLSIZE: %-16llx\t\tPSIZE: %llx\n",
1841 (longlong_t)BP_GET_LSIZE(bp), (longlong_t)BP_GET_PSIZE(bp));
1842 (void) printf("\tENDIAN: %6s\t\t\t\t\tTYPE: %s\n",
1843 BP_GET_BYTEORDER(bp) ? "LITTLE" : "BIG",
1844 dmu_ot[BP_GET_TYPE(bp)].ot_name);
1845 (void) printf("\tBIRTH: %-16llx LEVEL: %-2llu\tFILL: %llx\n",
1846 (u_longlong_t)bp->blk_birth, (u_longlong_t)BP_GET_LEVEL(bp),
1847 (u_longlong_t)bp->blk_fill);
1848 (void) printf("\tCKFUNC: %-16s\t\tCOMP: %s\n",
1849 zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_name,
1850 zio_compress_table[BP_GET_COMPRESS(bp)].ci_name);
1851 (void) printf("\tCKSUM: %llx:%llx:%llx:%llx\n",
1852 (u_longlong_t)bp->blk_cksum.zc_word[0],
1853 (u_longlong_t)bp->blk_cksum.zc_word[1],
1854 (u_longlong_t)bp->blk_cksum.zc_word[2],
1855 (u_longlong_t)bp->blk_cksum.zc_word[3]);
1856 }
1857
1858 static void
1859 zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
1860 {
1861 int i;
1862
1863 for (i = 0; i < nbps; i++)
1864 zdb_print_blkptr(&bp[i], flags);
1865 }
1866
1867 static void
1868 zdb_dump_gbh(void *buf, int flags)
1869 {
1870 zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
2280 break;
2281 case 'e':
2282 exported = 1;
2283 break;
2284 case 'p':
2285 vdev_dir = optarg;
2286 break;
2287 case 'S':
2288 dump_opt[c]++;
2289 dump_all = 0;
2290 zdb_sig_user_data = (strncmp(optarg, "user:", 5) == 0);
2291 if (!zdb_sig_user_data && strncmp(optarg, "all:", 4))
2292 usage();
2293 endstr = strchr(optarg, ':') + 1;
2294 if (strcmp(endstr, "fletcher2") == 0)
2295 zdb_sig_cksumalg = ZIO_CHECKSUM_FLETCHER_2;
2296 else if (strcmp(endstr, "fletcher4") == 0)
2297 zdb_sig_cksumalg = ZIO_CHECKSUM_FLETCHER_4;
2298 else if (strcmp(endstr, "sha256") == 0)
2299 zdb_sig_cksumalg = ZIO_CHECKSUM_SHA256;
2300 else if (strcmp(endstr, "all") == 0)
2301 zdb_sig_cksumalg = ZIO_CHECKSUM_FLETCHER_2;
2302 else
2303 usage();
2304 break;
2305 case 't':
2306 ub_max_txg = strtoull(optarg, NULL, 0);
2307 if (ub_max_txg < TXG_INITIAL) {
2308 (void) fprintf(stderr, "incorrect txg "
2309 "specified: %s\n", optarg);
2310 usage();
2311 }
2312 break;
2313 default:
2314 usage();
2315 break;
2316 }
2317 }
2318
2319 if (vdev_dir != NULL && exported == 0) {
|
37 #include <sys/vdev.h>
38 #include <sys/vdev_impl.h>
39 #include <sys/metaslab_impl.h>
40 #include <sys/dmu_objset.h>
41 #include <sys/dsl_dir.h>
42 #include <sys/dsl_dataset.h>
43 #include <sys/dsl_pool.h>
44 #include <sys/dbuf.h>
45 #include <sys/zil.h>
46 #include <sys/zil_impl.h>
47 #include <sys/stat.h>
48 #include <sys/resource.h>
49 #include <sys/dmu_traverse.h>
50 #include <sys/zio_checksum.h>
51 #include <sys/zio_compress.h>
52 #include <sys/zfs_fuid.h>
53 #include <sys/arc.h>
54 #undef ZFS_MAXNAMELEN
55 #undef verify
56 #include <libzfs.h>
57 #include <sys/zio_crypt.h>
58
59 const char cmdname[] = "zdb";
60 uint8_t dump_opt[256];
61
62 typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
63
64 extern void dump_intent_log(zilog_t *);
65 uint64_t *zopt_object = NULL;
66 int zopt_objects = 0;
67 libzfs_handle_t *g_zfs;
68 boolean_t zdb_sig_user_data = B_TRUE;
69 int zdb_sig_cksumalg = ZIO_CHECKSUM_FUNCTIONS - 1;
70
71 /*
72 * These libumem hooks provide a reasonable set of defaults for the allocator's
73 * debugging facilities.
74 */
75 const char *
76 _umem_debug_init()
77 {
78 return ("default,verbose"); /* $UMEM_DEBUG setting */
79 }
80
81 const char *
82 _umem_logging_init(void)
83 {
84 return ("fail,contents"); /* $UMEM_LOGGING setting */
85 }
86
87 static void
88 usage(void)
89 {
1056
1057 nicenum(doi.doi_metadata_block_size, iblk);
1058 nicenum(doi.doi_data_block_size, dblk);
1059 nicenum(doi.doi_data_block_size * (doi.doi_max_block_offset + 1),
1060 lsize);
1061 nicenum(doi.doi_physical_blks << 9, asize);
1062 nicenum(doi.doi_bonus_size, bonus_size);
1063
1064 aux[0] = '\0';
1065
1066 if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
1067 (void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
1068 zio_checksum_table[doi.doi_checksum].ci_name);
1069 }
1070
1071 if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
1072 (void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
1073 zio_compress_table[doi.doi_compress].ci_name);
1074 }
1075
1076 if (doi.doi_crypt != ZIO_CRYPT_INHERIT || verbosity >= 6) {
1077 (void) snprintf(aux + strlen(aux), sizeof (aux), " (E=%s)",
1078 zio_crypt_table[doi.doi_crypt].ci_name);
1079 }
1080
1081 (void) printf("%10lld %3u %5s %5s %5s %5s %s%s\n",
1082 (u_longlong_t)object, doi.doi_indirection, iblk, dblk, lsize,
1083 asize, dmu_ot[doi.doi_type].ot_name, aux);
1084
1085 if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
1086 (void) printf("%10s %3s %5s %5s %5s %5s %s\n",
1087 "", "", "", "", bonus_size, "bonus",
1088 dmu_ot[doi.doi_bonus_type].ot_name);
1089 }
1090
1091 if (verbosity >= 4) {
1092 object_viewer[doi.doi_bonus_type](os, object, bonus, bsize);
1093 object_viewer[doi.doi_type](os, object, NULL, 0);
1094 *print_header = 1;
1095 }
1096
1097 if (verbosity >= 5)
1098 dump_indirect(dn);
1099
1100 if (verbosity >= 5) {
1468 int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
1469 int t = (i & 1) ? type : DMU_OT_TOTAL;
1470 zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
1471
1472 zb->zb_asize += BP_GET_ASIZE(bp);
1473 zb->zb_lsize += BP_GET_LSIZE(bp);
1474 zb->zb_psize += BP_GET_PSIZE(bp);
1475 zb->zb_count++;
1476 }
1477
1478 if (dump_opt['S']) {
1479 boolean_t print_sig;
1480
1481 print_sig = !zdb_sig_user_data || (BP_GET_LEVEL(bp) == 0 &&
1482 BP_GET_TYPE(bp) == DMU_OT_PLAIN_FILE_CONTENTS);
1483
1484 if (BP_GET_CHECKSUM(bp) < zdb_sig_cksumalg)
1485 print_sig = B_FALSE;
1486
1487 if (print_sig) {
1488 (void) printf("%llu\t%lld\t%lld\t%s\t%s\t%s\t%s\t"
1489 "%llx:%llx:%llx:%llx\n",
1490 (u_longlong_t)BP_GET_LEVEL(bp),
1491 (longlong_t)BP_GET_PSIZE(bp),
1492 (longlong_t)BP_GET_NDVAS(bp),
1493 dmu_ot[BP_GET_TYPE(bp)].ot_name,
1494 zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_name,
1495 zio_compress_table[BP_GET_COMPRESS(bp)].ci_name,
1496 zio_crypt_table[BP_GET_CRYPT(bp)].ci_name,
1497 (u_longlong_t)bp->blk_cksum.zc_word[0],
1498 (u_longlong_t)bp->blk_cksum.zc_word[1],
1499 (u_longlong_t)bp->blk_cksum.zc_word[2],
1500 (u_longlong_t)bp->blk_cksum.zc_word[3]);
1501 }
1502 }
1503
1504 if (!dump_opt['L'])
1505 VERIFY(zio_wait(zio_claim(NULL, spa, spa_first_txg(spa), bp,
1506 NULL, NULL, ZIO_FLAG_MUSTSUCCEED)) == 0);
1507 }
1508
1509 static int
1510 zdb_blkptr_cb(spa_t *spa, blkptr_t *bp, const zbookmark_t *zb,
1511 const dnode_phys_t *dnp, void *arg)
1512 {
1513 zdb_cb_t *zcb = arg;
1514 char blkbuf[BP_SPRINTF_LEN];
1515
1516 if (bp == NULL)
1835 (longlong_t)DVA_GET_GRID(&dva[d]),
1836 (longlong_t)DVA_GET_ASIZE(&dva[d]));
1837 (void) printf("\tDVA[%d]: :%llu:%llx:%llx:%s%s%s%s\n", d,
1838 (u_longlong_t)DVA_GET_VDEV(&dva[d]),
1839 (longlong_t)DVA_GET_OFFSET(&dva[d]),
1840 (longlong_t)BP_GET_PSIZE(bp),
1841 BP_SHOULD_BYTESWAP(bp) ? "e" : "",
1842 !DVA_GET_GANG(&dva[d]) && BP_GET_LEVEL(bp) != 0 ?
1843 "d" : "",
1844 DVA_GET_GANG(&dva[d]) ? "g" : "",
1845 BP_GET_COMPRESS(bp) != 0 ? "d" : "");
1846 }
1847 (void) printf("\tLSIZE: %-16llx\t\tPSIZE: %llx\n",
1848 (longlong_t)BP_GET_LSIZE(bp), (longlong_t)BP_GET_PSIZE(bp));
1849 (void) printf("\tENDIAN: %6s\t\t\t\t\tTYPE: %s\n",
1850 BP_GET_BYTEORDER(bp) ? "LITTLE" : "BIG",
1851 dmu_ot[BP_GET_TYPE(bp)].ot_name);
1852 (void) printf("\tBIRTH: %-16llx LEVEL: %-2llu\tFILL: %llx\n",
1853 (u_longlong_t)bp->blk_birth, (u_longlong_t)BP_GET_LEVEL(bp),
1854 (u_longlong_t)bp->blk_fill);
1855 (void) printf("\tCKFUNC: %-16s\t\tCOMP: %s\t\tCRYPT: %s\n",
1856 zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_name,
1857 zio_compress_table[BP_GET_COMPRESS(bp)].ci_name,
1858 zio_crypt_table[BP_GET_CRYPT(bp)].ci_name);
1859 (void) printf("\tCKSUM: %llx:%llx:%llx:%llx\n",
1860 (u_longlong_t)bp->blk_cksum.zc_word[0],
1861 (u_longlong_t)bp->blk_cksum.zc_word[1],
1862 (u_longlong_t)bp->blk_cksum.zc_word[2],
1863 (u_longlong_t)bp->blk_cksum.zc_word[3]);
1864 }
1865
1866 static void
1867 zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
1868 {
1869 int i;
1870
1871 for (i = 0; i < nbps; i++)
1872 zdb_print_blkptr(&bp[i], flags);
1873 }
1874
1875 static void
1876 zdb_dump_gbh(void *buf, int flags)
1877 {
1878 zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
2288 break;
2289 case 'e':
2290 exported = 1;
2291 break;
2292 case 'p':
2293 vdev_dir = optarg;
2294 break;
2295 case 'S':
2296 dump_opt[c]++;
2297 dump_all = 0;
2298 zdb_sig_user_data = (strncmp(optarg, "user:", 5) == 0);
2299 if (!zdb_sig_user_data && strncmp(optarg, "all:", 4))
2300 usage();
2301 endstr = strchr(optarg, ':') + 1;
2302 if (strcmp(endstr, "fletcher2") == 0)
2303 zdb_sig_cksumalg = ZIO_CHECKSUM_FLETCHER_2;
2304 else if (strcmp(endstr, "fletcher4") == 0)
2305 zdb_sig_cksumalg = ZIO_CHECKSUM_FLETCHER_4;
2306 else if (strcmp(endstr, "sha256") == 0)
2307 zdb_sig_cksumalg = ZIO_CHECKSUM_SHA256;
2308 else if (strcmp(endstr, "sha256+mac") == 0)
2309 zdb_sig_cksumalg = ZIO_CHECKSUM_SHA256_MAC;
2310 else if (strcmp(endstr, "all") == 0)
2311 zdb_sig_cksumalg = ZIO_CHECKSUM_FLETCHER_2;
2312 else
2313 usage();
2314 break;
2315 case 't':
2316 ub_max_txg = strtoull(optarg, NULL, 0);
2317 if (ub_max_txg < TXG_INITIAL) {
2318 (void) fprintf(stderr, "incorrect txg "
2319 "specified: %s\n", optarg);
2320 usage();
2321 }
2322 break;
2323 default:
2324 usage();
2325 break;
2326 }
2327 }
2328
2329 if (vdev_dir != NULL && exported == 0) {
|