1495db6fbSLori Alt /* 2495db6fbSLori Alt * CDDL HEADER START 3495db6fbSLori Alt * 4495db6fbSLori Alt * The contents of this file are subject to the terms of the 5495db6fbSLori Alt * Common Development and Distribution License (the "License"). 6495db6fbSLori Alt * You may not use this file except in compliance with the License. 7495db6fbSLori Alt * 8495db6fbSLori Alt * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9495db6fbSLori Alt * or http://www.opensolaris.org/os/licensing. 10495db6fbSLori Alt * See the License for the specific language governing permissions 11495db6fbSLori Alt * and limitations under the License. 12495db6fbSLori Alt * 13495db6fbSLori Alt * When distributing Covered Code, include this CDDL HEADER in each 14495db6fbSLori Alt * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15495db6fbSLori Alt * If applicable, add the following below this CDDL HEADER, with the 16495db6fbSLori Alt * fields enclosed by brackets "[]" replaced with your own identifying 17495db6fbSLori Alt * information: Portions Copyright [yyyy] [name of copyright owner] 18495db6fbSLori Alt * 19495db6fbSLori Alt * CDDL HEADER END 20495db6fbSLori Alt */ 21495db6fbSLori Alt 22495db6fbSLori Alt /* 230a586ceaSMark Shellenbaum * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24495db6fbSLori Alt * Use is subject to license terms. 25495db6fbSLori Alt */ 26495db6fbSLori Alt 27994fb6b8SMax Grossman /* 28c3d26abcSMatthew Ahrens * Copyright (c) 2014 Integros [integros.com] 295602294fSDan Kimmel * Copyright (c) 2013, 2015 by Delphix. All rights reserved. 30994fb6b8SMax Grossman */ 31994fb6b8SMax Grossman 32994fb6b8SMax Grossman #include <ctype.h> 33495db6fbSLori Alt #include <libnvpair.h> 34495db6fbSLori Alt #include <stdio.h> 35495db6fbSLori Alt #include <stdlib.h> 36495db6fbSLori Alt #include <strings.h> 37495db6fbSLori Alt #include <unistd.h> 3898110f08SMatthew Ahrens #include <stddef.h> 39495db6fbSLori Alt 40495db6fbSLori Alt #include <sys/dmu.h> 41495db6fbSLori Alt #include <sys/zfs_ioctl.h> 425602294fSDan Kimmel #include <sys/zio.h> 43495db6fbSLori Alt #include <zfs_fletcher.h> 44495db6fbSLori Alt 45994fb6b8SMax Grossman /* 46994fb6b8SMax Grossman * If dump mode is enabled, the number of bytes to print per line 47994fb6b8SMax Grossman */ 48994fb6b8SMax Grossman #define BYTES_PER_LINE 16 49994fb6b8SMax Grossman /* 50994fb6b8SMax Grossman * If dump mode is enabled, the number of bytes to group together, separated 51994fb6b8SMax Grossman * by newlines or spaces 52994fb6b8SMax Grossman */ 53994fb6b8SMax Grossman #define DUMP_GROUPING 4 54994fb6b8SMax Grossman 55495db6fbSLori Alt uint64_t total_write_size = 0; 56495db6fbSLori Alt uint64_t total_stream_len = 0; 57495db6fbSLori Alt FILE *send_stream = 0; 58495db6fbSLori Alt boolean_t do_byteswap = B_FALSE; 59495db6fbSLori Alt boolean_t do_cksum = B_TRUE; 60495db6fbSLori Alt 61495db6fbSLori Alt static void 62495db6fbSLori Alt usage(void) 63495db6fbSLori Alt { 64994fb6b8SMax Grossman (void) fprintf(stderr, "usage: zstreamdump [-v] [-C] [-d] < file\n"); 65495db6fbSLori Alt (void) fprintf(stderr, "\t -v -- verbose\n"); 66495db6fbSLori Alt (void) fprintf(stderr, "\t -C -- suppress checksum verification\n"); 67994fb6b8SMax Grossman (void) fprintf(stderr, "\t -d -- dump contents of blocks modified, " 68994fb6b8SMax Grossman "implies verbose\n"); 69495db6fbSLori Alt exit(1); 70495db6fbSLori Alt } 71495db6fbSLori Alt 72b5152584SMatthew Ahrens static void * 73b5152584SMatthew Ahrens safe_malloc(size_t size) 74b5152584SMatthew Ahrens { 75b5152584SMatthew Ahrens void *rv = malloc(size); 76b5152584SMatthew Ahrens if (rv == NULL) { 77b5152584SMatthew Ahrens (void) fprintf(stderr, "ERROR; failed to allocate %zu bytes\n", 78b5152584SMatthew Ahrens size); 79b5152584SMatthew Ahrens abort(); 80b5152584SMatthew Ahrens } 81b5152584SMatthew Ahrens return (rv); 82b5152584SMatthew Ahrens } 83b5152584SMatthew Ahrens 84495db6fbSLori Alt /* 85495db6fbSLori Alt * ssread - send stream read. 86495db6fbSLori Alt * 87495db6fbSLori Alt * Read while computing incremental checksum 88495db6fbSLori Alt */ 89495db6fbSLori Alt static size_t 90495db6fbSLori Alt ssread(void *buf, size_t len, zio_cksum_t *cksum) 91495db6fbSLori Alt { 92495db6fbSLori Alt size_t outlen; 93495db6fbSLori Alt 94495db6fbSLori Alt if ((outlen = fread(buf, len, 1, send_stream)) == 0) 95495db6fbSLori Alt return (0); 96495db6fbSLori Alt 9798110f08SMatthew Ahrens if (do_cksum) { 98495db6fbSLori Alt if (do_byteswap) 99495db6fbSLori Alt fletcher_4_incremental_byteswap(buf, len, cksum); 100495db6fbSLori Alt else 101495db6fbSLori Alt fletcher_4_incremental_native(buf, len, cksum); 102495db6fbSLori Alt } 103495db6fbSLori Alt total_stream_len += len; 104495db6fbSLori Alt return (outlen); 105495db6fbSLori Alt } 106495db6fbSLori Alt 10798110f08SMatthew Ahrens static size_t 10898110f08SMatthew Ahrens read_hdr(dmu_replay_record_t *drr, zio_cksum_t *cksum) 10998110f08SMatthew Ahrens { 11098110f08SMatthew Ahrens ASSERT3U(offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum), 11198110f08SMatthew Ahrens ==, sizeof (dmu_replay_record_t) - sizeof (zio_cksum_t)); 11298110f08SMatthew Ahrens size_t r = ssread(drr, sizeof (*drr) - sizeof (zio_cksum_t), cksum); 11398110f08SMatthew Ahrens if (r == 0) 11498110f08SMatthew Ahrens return (0); 11598110f08SMatthew Ahrens zio_cksum_t saved_cksum = *cksum; 11698110f08SMatthew Ahrens r = ssread(&drr->drr_u.drr_checksum.drr_checksum, 11798110f08SMatthew Ahrens sizeof (zio_cksum_t), cksum); 11898110f08SMatthew Ahrens if (r == 0) 11998110f08SMatthew Ahrens return (0); 12098110f08SMatthew Ahrens if (!ZIO_CHECKSUM_IS_ZERO(&drr->drr_u.drr_checksum.drr_checksum) && 12198110f08SMatthew Ahrens !ZIO_CHECKSUM_EQUAL(saved_cksum, 12298110f08SMatthew Ahrens drr->drr_u.drr_checksum.drr_checksum)) { 12398110f08SMatthew Ahrens fprintf(stderr, "invalid checksum\n"); 12498110f08SMatthew Ahrens (void) printf("Incorrect checksum in record header.\n"); 12598110f08SMatthew Ahrens (void) printf("Expected checksum = %llx/%llx/%llx/%llx\n", 12698110f08SMatthew Ahrens saved_cksum.zc_word[0], 12798110f08SMatthew Ahrens saved_cksum.zc_word[1], 12898110f08SMatthew Ahrens saved_cksum.zc_word[2], 12998110f08SMatthew Ahrens saved_cksum.zc_word[3]); 1309c3fd121SMatthew Ahrens return (0); 13198110f08SMatthew Ahrens } 13298110f08SMatthew Ahrens return (sizeof (*drr)); 13398110f08SMatthew Ahrens } 13498110f08SMatthew Ahrens 135994fb6b8SMax Grossman /* 136994fb6b8SMax Grossman * Print part of a block in ASCII characters 137994fb6b8SMax Grossman */ 138994fb6b8SMax Grossman static void 139994fb6b8SMax Grossman print_ascii_block(char *subbuf, int length) 140994fb6b8SMax Grossman { 141994fb6b8SMax Grossman int i; 142994fb6b8SMax Grossman 143994fb6b8SMax Grossman for (i = 0; i < length; i++) { 144994fb6b8SMax Grossman char char_print = isprint(subbuf[i]) ? subbuf[i] : '.'; 145994fb6b8SMax Grossman if (i != 0 && i % DUMP_GROUPING == 0) { 146994fb6b8SMax Grossman (void) printf(" "); 147994fb6b8SMax Grossman } 148994fb6b8SMax Grossman (void) printf("%c", char_print); 149994fb6b8SMax Grossman } 150994fb6b8SMax Grossman (void) printf("\n"); 151994fb6b8SMax Grossman } 152994fb6b8SMax Grossman 153994fb6b8SMax Grossman /* 154994fb6b8SMax Grossman * print_block - Dump the contents of a modified block to STDOUT 155994fb6b8SMax Grossman * 156994fb6b8SMax Grossman * Assume that buf has capacity evenly divisible by BYTES_PER_LINE 157994fb6b8SMax Grossman */ 158994fb6b8SMax Grossman static void 159994fb6b8SMax Grossman print_block(char *buf, int length) 160994fb6b8SMax Grossman { 161994fb6b8SMax Grossman int i; 162994fb6b8SMax Grossman /* 163994fb6b8SMax Grossman * Start printing ASCII characters at a constant offset, after 164994fb6b8SMax Grossman * the hex prints. Leave 3 characters per byte on a line (2 digit 165994fb6b8SMax Grossman * hex number plus 1 space) plus spaces between characters and 1665d7b4d43SMatthew Ahrens * groupings. 167994fb6b8SMax Grossman */ 168994fb6b8SMax Grossman int ascii_start = BYTES_PER_LINE * 3 + 169994fb6b8SMax Grossman BYTES_PER_LINE / DUMP_GROUPING + 2; 170994fb6b8SMax Grossman 171994fb6b8SMax Grossman for (i = 0; i < length; i += BYTES_PER_LINE) { 172994fb6b8SMax Grossman int j; 173994fb6b8SMax Grossman int this_line_length = MIN(BYTES_PER_LINE, length - i); 174994fb6b8SMax Grossman int print_offset = 0; 175994fb6b8SMax Grossman 176994fb6b8SMax Grossman for (j = 0; j < this_line_length; j++) { 177994fb6b8SMax Grossman int buf_offset = i + j; 178994fb6b8SMax Grossman 179994fb6b8SMax Grossman /* 180994fb6b8SMax Grossman * Separate every DUMP_GROUPING bytes by a space. 181994fb6b8SMax Grossman */ 182994fb6b8SMax Grossman if (buf_offset % DUMP_GROUPING == 0) { 183994fb6b8SMax Grossman print_offset += printf(" "); 184994fb6b8SMax Grossman } 185994fb6b8SMax Grossman 186994fb6b8SMax Grossman /* 187994fb6b8SMax Grossman * Print the two-digit hex value for this byte. 188994fb6b8SMax Grossman */ 189994fb6b8SMax Grossman unsigned char hex_print = buf[buf_offset]; 190994fb6b8SMax Grossman print_offset += printf("%02x ", hex_print); 191994fb6b8SMax Grossman } 192994fb6b8SMax Grossman 193994fb6b8SMax Grossman (void) printf("%*s", ascii_start - print_offset, " "); 194994fb6b8SMax Grossman 195994fb6b8SMax Grossman print_ascii_block(buf + i, this_line_length); 196994fb6b8SMax Grossman } 197994fb6b8SMax Grossman } 198994fb6b8SMax Grossman 199495db6fbSLori Alt int 200495db6fbSLori Alt main(int argc, char *argv[]) 201495db6fbSLori Alt { 202b5152584SMatthew Ahrens char *buf = safe_malloc(SPA_MAXBLOCKSIZE); 2035d7b4d43SMatthew Ahrens uint64_t drr_record_count[DRR_NUMTYPES] = { 0 }; 2045d7b4d43SMatthew Ahrens uint64_t total_records = 0; 205495db6fbSLori Alt dmu_replay_record_t thedrr; 206495db6fbSLori Alt dmu_replay_record_t *drr = &thedrr; 207495db6fbSLori Alt struct drr_begin *drrb = &thedrr.drr_u.drr_begin; 208495db6fbSLori Alt struct drr_end *drre = &thedrr.drr_u.drr_end; 209495db6fbSLori Alt struct drr_object *drro = &thedrr.drr_u.drr_object; 210495db6fbSLori Alt struct drr_freeobjects *drrfo = &thedrr.drr_u.drr_freeobjects; 211495db6fbSLori Alt struct drr_write *drrw = &thedrr.drr_u.drr_write; 2129e69d7d0SLori Alt struct drr_write_byref *drrwbr = &thedrr.drr_u.drr_write_byref; 213495db6fbSLori Alt struct drr_free *drrf = &thedrr.drr_u.drr_free; 2140a586ceaSMark Shellenbaum struct drr_spill *drrs = &thedrr.drr_u.drr_spill; 2155d7b4d43SMatthew Ahrens struct drr_write_embedded *drrwe = &thedrr.drr_u.drr_write_embedded; 21698110f08SMatthew Ahrens struct drr_checksum *drrc = &thedrr.drr_u.drr_checksum; 217495db6fbSLori Alt char c; 218495db6fbSLori Alt boolean_t verbose = B_FALSE; 21998110f08SMatthew Ahrens boolean_t very_verbose = B_FALSE; 220495db6fbSLori Alt boolean_t first = B_TRUE; 221994fb6b8SMax Grossman /* 222994fb6b8SMax Grossman * dump flag controls whether the contents of any modified data blocks 223994fb6b8SMax Grossman * are printed to the console during processing of the stream. Warning: 224994fb6b8SMax Grossman * for large streams, this can obviously lead to massive prints. 225994fb6b8SMax Grossman */ 226994fb6b8SMax Grossman boolean_t dump = B_FALSE; 2278e714474SLori Alt int err; 228495db6fbSLori Alt zio_cksum_t zc = { 0 }; 229495db6fbSLori Alt zio_cksum_t pcksum = { 0 }; 230495db6fbSLori Alt 231994fb6b8SMax Grossman while ((c = getopt(argc, argv, ":vCd")) != -1) { 232495db6fbSLori Alt switch (c) { 233495db6fbSLori Alt case 'C': 234495db6fbSLori Alt do_cksum = B_FALSE; 235495db6fbSLori Alt break; 236495db6fbSLori Alt case 'v': 23798110f08SMatthew Ahrens if (verbose) 23898110f08SMatthew Ahrens very_verbose = B_TRUE; 239495db6fbSLori Alt verbose = B_TRUE; 240495db6fbSLori Alt break; 241994fb6b8SMax Grossman case 'd': 242994fb6b8SMax Grossman dump = B_TRUE; 243994fb6b8SMax Grossman verbose = B_TRUE; 24498110f08SMatthew Ahrens very_verbose = B_TRUE; 245994fb6b8SMax Grossman break; 246495db6fbSLori Alt case ':': 247495db6fbSLori Alt (void) fprintf(stderr, 248495db6fbSLori Alt "missing argument for '%c' option\n", optopt); 249495db6fbSLori Alt usage(); 250495db6fbSLori Alt break; 251495db6fbSLori Alt case '?': 252495db6fbSLori Alt (void) fprintf(stderr, "invalid option '%c'\n", 253495db6fbSLori Alt optopt); 254495db6fbSLori Alt usage(); 2555602294fSDan Kimmel break; 256495db6fbSLori Alt } 257495db6fbSLori Alt } 258495db6fbSLori Alt 259495db6fbSLori Alt if (isatty(STDIN_FILENO)) { 260495db6fbSLori Alt (void) fprintf(stderr, 261495db6fbSLori Alt "Error: Backup stream can not be read " 262495db6fbSLori Alt "from a terminal.\n" 263495db6fbSLori Alt "You must redirect standard input.\n"); 264495db6fbSLori Alt exit(1); 265495db6fbSLori Alt } 266495db6fbSLori Alt 267495db6fbSLori Alt send_stream = stdin; 26898110f08SMatthew Ahrens while (read_hdr(drr, &zc)) { 269495db6fbSLori Alt 270994fb6b8SMax Grossman /* 271994fb6b8SMax Grossman * If this is the first DMU record being processed, check for 272994fb6b8SMax Grossman * the magic bytes and figure out the endian-ness based on them. 273994fb6b8SMax Grossman */ 274495db6fbSLori Alt if (first) { 275495db6fbSLori Alt if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) { 276495db6fbSLori Alt do_byteswap = B_TRUE; 277495db6fbSLori Alt if (do_cksum) { 278495db6fbSLori Alt ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0); 279495db6fbSLori Alt /* 280495db6fbSLori Alt * recalculate header checksum now 281495db6fbSLori Alt * that we know it needs to be 282495db6fbSLori Alt * byteswapped. 283495db6fbSLori Alt */ 284495db6fbSLori Alt fletcher_4_incremental_byteswap(drr, 285495db6fbSLori Alt sizeof (dmu_replay_record_t), &zc); 286495db6fbSLori Alt } 287495db6fbSLori Alt } else if (drrb->drr_magic != DMU_BACKUP_MAGIC) { 288495db6fbSLori Alt (void) fprintf(stderr, "Invalid stream " 289495db6fbSLori Alt "(bad magic number)\n"); 290495db6fbSLori Alt exit(1); 291495db6fbSLori Alt } 292495db6fbSLori Alt first = B_FALSE; 293495db6fbSLori Alt } 294495db6fbSLori Alt if (do_byteswap) { 295495db6fbSLori Alt drr->drr_type = BSWAP_32(drr->drr_type); 296495db6fbSLori Alt drr->drr_payloadlen = 297495db6fbSLori Alt BSWAP_32(drr->drr_payloadlen); 298495db6fbSLori Alt } 299495db6fbSLori Alt 300495db6fbSLori Alt /* 301495db6fbSLori Alt * At this point, the leading fields of the replay record 302495db6fbSLori Alt * (drr_type and drr_payloadlen) have been byte-swapped if 303495db6fbSLori Alt * necessary, but the rest of the data structure (the 304495db6fbSLori Alt * union of type-specific structures) is still in its 305495db6fbSLori Alt * original state. 306495db6fbSLori Alt */ 307495db6fbSLori Alt if (drr->drr_type >= DRR_NUMTYPES) { 308495db6fbSLori Alt (void) printf("INVALID record found: type 0x%x\n", 309495db6fbSLori Alt drr->drr_type); 310495db6fbSLori Alt (void) printf("Aborting.\n"); 311495db6fbSLori Alt exit(1); 312495db6fbSLori Alt } 313495db6fbSLori Alt 314495db6fbSLori Alt drr_record_count[drr->drr_type]++; 3155d7b4d43SMatthew Ahrens total_records++; 316495db6fbSLori Alt 317495db6fbSLori Alt switch (drr->drr_type) { 318495db6fbSLori Alt case DRR_BEGIN: 319495db6fbSLori Alt if (do_byteswap) { 320495db6fbSLori Alt drrb->drr_magic = BSWAP_64(drrb->drr_magic); 3219e69d7d0SLori Alt drrb->drr_versioninfo = 3229e69d7d0SLori Alt BSWAP_64(drrb->drr_versioninfo); 323495db6fbSLori Alt drrb->drr_creation_time = 324495db6fbSLori Alt BSWAP_64(drrb->drr_creation_time); 325495db6fbSLori Alt drrb->drr_type = BSWAP_32(drrb->drr_type); 326495db6fbSLori Alt drrb->drr_flags = BSWAP_32(drrb->drr_flags); 327495db6fbSLori Alt drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 328495db6fbSLori Alt drrb->drr_fromguid = 329495db6fbSLori Alt BSWAP_64(drrb->drr_fromguid); 330495db6fbSLori Alt } 331495db6fbSLori Alt 332495db6fbSLori Alt (void) printf("BEGIN record\n"); 3339e69d7d0SLori Alt (void) printf("\thdrtype = %lld\n", 3349e69d7d0SLori Alt DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo)); 3359e69d7d0SLori Alt (void) printf("\tfeatures = %llx\n", 3369e69d7d0SLori Alt DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo)); 337495db6fbSLori Alt (void) printf("\tmagic = %llx\n", 338495db6fbSLori Alt (u_longlong_t)drrb->drr_magic); 339495db6fbSLori Alt (void) printf("\tcreation_time = %llx\n", 340495db6fbSLori Alt (u_longlong_t)drrb->drr_creation_time); 341495db6fbSLori Alt (void) printf("\ttype = %u\n", drrb->drr_type); 342495db6fbSLori Alt (void) printf("\tflags = 0x%x\n", drrb->drr_flags); 343495db6fbSLori Alt (void) printf("\ttoguid = %llx\n", 344495db6fbSLori Alt (u_longlong_t)drrb->drr_toguid); 345495db6fbSLori Alt (void) printf("\tfromguid = %llx\n", 346495db6fbSLori Alt (u_longlong_t)drrb->drr_fromguid); 347495db6fbSLori Alt (void) printf("\ttoname = %s\n", drrb->drr_toname); 348495db6fbSLori Alt if (verbose) 349495db6fbSLori Alt (void) printf("\n"); 350495db6fbSLori Alt 3519c3fd121SMatthew Ahrens if (drr->drr_payloadlen != 0) { 352495db6fbSLori Alt nvlist_t *nv; 353495db6fbSLori Alt int sz = drr->drr_payloadlen; 354495db6fbSLori Alt 355b5152584SMatthew Ahrens if (sz > SPA_MAXBLOCKSIZE) { 356495db6fbSLori Alt free(buf); 357b5152584SMatthew Ahrens buf = safe_malloc(sz); 358495db6fbSLori Alt } 359495db6fbSLori Alt (void) ssread(buf, sz, &zc); 360495db6fbSLori Alt if (ferror(send_stream)) 361495db6fbSLori Alt perror("fread"); 362495db6fbSLori Alt err = nvlist_unpack(buf, sz, &nv, 0); 363495db6fbSLori Alt if (err) 364495db6fbSLori Alt perror(strerror(err)); 365495db6fbSLori Alt nvlist_print(stdout, nv); 366495db6fbSLori Alt nvlist_free(nv); 367495db6fbSLori Alt } 368495db6fbSLori Alt break; 369495db6fbSLori Alt 370495db6fbSLori Alt case DRR_END: 371495db6fbSLori Alt if (do_byteswap) { 372495db6fbSLori Alt drre->drr_checksum.zc_word[0] = 373495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[0]); 374495db6fbSLori Alt drre->drr_checksum.zc_word[1] = 375495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[1]); 376495db6fbSLori Alt drre->drr_checksum.zc_word[2] = 377495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[2]); 378495db6fbSLori Alt drre->drr_checksum.zc_word[3] = 379495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[3]); 380495db6fbSLori Alt } 381495db6fbSLori Alt /* 382495db6fbSLori Alt * We compare against the *previous* checksum 383495db6fbSLori Alt * value, because the stored checksum is of 384495db6fbSLori Alt * everything before the DRR_END record. 385495db6fbSLori Alt */ 386495db6fbSLori Alt if (do_cksum && !ZIO_CHECKSUM_EQUAL(drre->drr_checksum, 387495db6fbSLori Alt pcksum)) { 388495db6fbSLori Alt (void) printf("Expected checksum differs from " 389495db6fbSLori Alt "checksum in stream.\n"); 390495db6fbSLori Alt (void) printf("Expected checksum = " 391495db6fbSLori Alt "%llx/%llx/%llx/%llx\n", 392495db6fbSLori Alt pcksum.zc_word[0], 393495db6fbSLori Alt pcksum.zc_word[1], 394495db6fbSLori Alt pcksum.zc_word[2], 395495db6fbSLori Alt pcksum.zc_word[3]); 396495db6fbSLori Alt } 397495db6fbSLori Alt (void) printf("END checksum = %llx/%llx/%llx/%llx\n", 398495db6fbSLori Alt drre->drr_checksum.zc_word[0], 399495db6fbSLori Alt drre->drr_checksum.zc_word[1], 400495db6fbSLori Alt drre->drr_checksum.zc_word[2], 401495db6fbSLori Alt drre->drr_checksum.zc_word[3]); 402495db6fbSLori Alt 403495db6fbSLori Alt ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0); 404495db6fbSLori Alt break; 405495db6fbSLori Alt 406495db6fbSLori Alt case DRR_OBJECT: 407495db6fbSLori Alt if (do_byteswap) { 408495db6fbSLori Alt drro->drr_object = BSWAP_64(drro->drr_object); 409495db6fbSLori Alt drro->drr_type = BSWAP_32(drro->drr_type); 410495db6fbSLori Alt drro->drr_bonustype = 411495db6fbSLori Alt BSWAP_32(drro->drr_bonustype); 412495db6fbSLori Alt drro->drr_blksz = BSWAP_32(drro->drr_blksz); 413495db6fbSLori Alt drro->drr_bonuslen = 414495db6fbSLori Alt BSWAP_32(drro->drr_bonuslen); 4159e69d7d0SLori Alt drro->drr_toguid = BSWAP_64(drro->drr_toguid); 416495db6fbSLori Alt } 417495db6fbSLori Alt if (verbose) { 418*54811da5SToomas Soome (void) printf("OBJECT object = %" PRIu64 419*54811da5SToomas Soome " type = %u bonustype = %u blksz = %u" 420*54811da5SToomas Soome " bonuslen = %u dn_slots = %u\n", 421*54811da5SToomas Soome drro->drr_object, 422495db6fbSLori Alt drro->drr_type, 423495db6fbSLori Alt drro->drr_bonustype, 424495db6fbSLori Alt drro->drr_blksz, 425*54811da5SToomas Soome drro->drr_bonuslen, 426*54811da5SToomas Soome drro->drr_dn_slots); 427495db6fbSLori Alt } 428495db6fbSLori Alt if (drro->drr_bonuslen > 0) { 4295d7b4d43SMatthew Ahrens (void) ssread(buf, 4305d7b4d43SMatthew Ahrens P2ROUNDUP(drro->drr_bonuslen, 8), &zc); 431994fb6b8SMax Grossman if (dump) { 432994fb6b8SMax Grossman print_block(buf, 433994fb6b8SMax Grossman P2ROUNDUP(drro->drr_bonuslen, 8)); 434994fb6b8SMax Grossman } 435495db6fbSLori Alt } 436495db6fbSLori Alt break; 437495db6fbSLori Alt 438495db6fbSLori Alt case DRR_FREEOBJECTS: 439495db6fbSLori Alt if (do_byteswap) { 440495db6fbSLori Alt drrfo->drr_firstobj = 441495db6fbSLori Alt BSWAP_64(drrfo->drr_firstobj); 442495db6fbSLori Alt drrfo->drr_numobjs = 443495db6fbSLori Alt BSWAP_64(drrfo->drr_numobjs); 4449e69d7d0SLori Alt drrfo->drr_toguid = BSWAP_64(drrfo->drr_toguid); 445495db6fbSLori Alt } 446495db6fbSLori Alt if (verbose) { 447495db6fbSLori Alt (void) printf("FREEOBJECTS firstobj = %llu " 448495db6fbSLori Alt "numobjs = %llu\n", 449495db6fbSLori Alt (u_longlong_t)drrfo->drr_firstobj, 450495db6fbSLori Alt (u_longlong_t)drrfo->drr_numobjs); 451495db6fbSLori Alt } 452495db6fbSLori Alt break; 453495db6fbSLori Alt 454495db6fbSLori Alt case DRR_WRITE: 455495db6fbSLori Alt if (do_byteswap) { 456495db6fbSLori Alt drrw->drr_object = BSWAP_64(drrw->drr_object); 457495db6fbSLori Alt drrw->drr_type = BSWAP_32(drrw->drr_type); 458495db6fbSLori Alt drrw->drr_offset = BSWAP_64(drrw->drr_offset); 4595602294fSDan Kimmel drrw->drr_logical_size = 4605602294fSDan Kimmel BSWAP_64(drrw->drr_logical_size); 4619e69d7d0SLori Alt drrw->drr_toguid = BSWAP_64(drrw->drr_toguid); 4628e714474SLori Alt drrw->drr_key.ddk_prop = 4638e714474SLori Alt BSWAP_64(drrw->drr_key.ddk_prop); 4645602294fSDan Kimmel drrw->drr_compressed_size = 4655602294fSDan Kimmel BSWAP_64(drrw->drr_compressed_size); 466495db6fbSLori Alt } 4675602294fSDan Kimmel 4685602294fSDan Kimmel uint64_t payload_size = DRR_WRITE_PAYLOAD_SIZE(drrw); 4695602294fSDan Kimmel 470994fb6b8SMax Grossman /* 471994fb6b8SMax Grossman * If this is verbose and/or dump output, 472994fb6b8SMax Grossman * print info on the modified block 473994fb6b8SMax Grossman */ 474495db6fbSLori Alt if (verbose) { 475495db6fbSLori Alt (void) printf("WRITE object = %llu type = %u " 4765602294fSDan Kimmel "checksum type = %u compression type = %u\n" 4775602294fSDan Kimmel " offset = %llu logical_size = %llu " 4785602294fSDan Kimmel "compressed_size = %llu " 4795602294fSDan Kimmel "payload_size = %llu " 4808e714474SLori Alt "props = %llx\n", 481495db6fbSLori Alt (u_longlong_t)drrw->drr_object, 482495db6fbSLori Alt drrw->drr_type, 4838e714474SLori Alt drrw->drr_checksumtype, 4845602294fSDan Kimmel drrw->drr_compressiontype, 485495db6fbSLori Alt (u_longlong_t)drrw->drr_offset, 4865602294fSDan Kimmel (u_longlong_t)drrw->drr_logical_size, 4875602294fSDan Kimmel (u_longlong_t)drrw->drr_compressed_size, 4885602294fSDan Kimmel (u_longlong_t)payload_size, 4898e714474SLori Alt (u_longlong_t)drrw->drr_key.ddk_prop); 490495db6fbSLori Alt } 4915602294fSDan Kimmel 492994fb6b8SMax Grossman /* 493994fb6b8SMax Grossman * Read the contents of the block in from STDIN to buf 494994fb6b8SMax Grossman */ 4955602294fSDan Kimmel (void) ssread(buf, payload_size, &zc); 496994fb6b8SMax Grossman /* 497994fb6b8SMax Grossman * If in dump mode 498994fb6b8SMax Grossman */ 499994fb6b8SMax Grossman if (dump) { 5005602294fSDan Kimmel print_block(buf, payload_size); 501994fb6b8SMax Grossman } 5025602294fSDan Kimmel total_write_size += payload_size; 503495db6fbSLori Alt break; 504495db6fbSLori Alt 5059e69d7d0SLori Alt case DRR_WRITE_BYREF: 5069e69d7d0SLori Alt if (do_byteswap) { 5079e69d7d0SLori Alt drrwbr->drr_object = 5089e69d7d0SLori Alt BSWAP_64(drrwbr->drr_object); 5099e69d7d0SLori Alt drrwbr->drr_offset = 5109e69d7d0SLori Alt BSWAP_64(drrwbr->drr_offset); 5119e69d7d0SLori Alt drrwbr->drr_length = 5129e69d7d0SLori Alt BSWAP_64(drrwbr->drr_length); 5139e69d7d0SLori Alt drrwbr->drr_toguid = 5149e69d7d0SLori Alt BSWAP_64(drrwbr->drr_toguid); 5159e69d7d0SLori Alt drrwbr->drr_refguid = 5169e69d7d0SLori Alt BSWAP_64(drrwbr->drr_refguid); 5179e69d7d0SLori Alt drrwbr->drr_refobject = 5189e69d7d0SLori Alt BSWAP_64(drrwbr->drr_refobject); 5199e69d7d0SLori Alt drrwbr->drr_refoffset = 5209e69d7d0SLori Alt BSWAP_64(drrwbr->drr_refoffset); 5218e714474SLori Alt drrwbr->drr_key.ddk_prop = 5228e714474SLori Alt BSWAP_64(drrwbr->drr_key.ddk_prop); 5239e69d7d0SLori Alt } 5249e69d7d0SLori Alt if (verbose) { 5259e69d7d0SLori Alt (void) printf("WRITE_BYREF object = %llu " 5268e714474SLori Alt "checksum type = %u props = %llx\n" 5279e69d7d0SLori Alt " offset = %llu length = %llu\n" 5289e69d7d0SLori Alt "toguid = %llx refguid = %llx\n" 5299e69d7d0SLori Alt " refobject = %llu refoffset = %llu\n", 5309e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_object, 5318e714474SLori Alt drrwbr->drr_checksumtype, 5328e714474SLori Alt (u_longlong_t)drrwbr->drr_key.ddk_prop, 5339e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_offset, 5349e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_length, 5359e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_toguid, 5369e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_refguid, 5379e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_refobject, 5389e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_refoffset); 5399e69d7d0SLori Alt } 5409e69d7d0SLori Alt break; 5419e69d7d0SLori Alt 542495db6fbSLori Alt case DRR_FREE: 543495db6fbSLori Alt if (do_byteswap) { 544495db6fbSLori Alt drrf->drr_object = BSWAP_64(drrf->drr_object); 545495db6fbSLori Alt drrf->drr_offset = BSWAP_64(drrf->drr_offset); 546495db6fbSLori Alt drrf->drr_length = BSWAP_64(drrf->drr_length); 547495db6fbSLori Alt } 548495db6fbSLori Alt if (verbose) { 549495db6fbSLori Alt (void) printf("FREE object = %llu " 550495db6fbSLori Alt "offset = %llu length = %lld\n", 551495db6fbSLori Alt (u_longlong_t)drrf->drr_object, 552495db6fbSLori Alt (u_longlong_t)drrf->drr_offset, 553495db6fbSLori Alt (longlong_t)drrf->drr_length); 554495db6fbSLori Alt } 555495db6fbSLori Alt break; 5560a586ceaSMark Shellenbaum case DRR_SPILL: 5570a586ceaSMark Shellenbaum if (do_byteswap) { 5580a586ceaSMark Shellenbaum drrs->drr_object = BSWAP_64(drrs->drr_object); 5590a586ceaSMark Shellenbaum drrs->drr_length = BSWAP_64(drrs->drr_length); 5600a586ceaSMark Shellenbaum } 5610a586ceaSMark Shellenbaum if (verbose) { 5620a586ceaSMark Shellenbaum (void) printf("SPILL block for object = %llu " 5630a586ceaSMark Shellenbaum "length = %llu\n", drrs->drr_object, 5640a586ceaSMark Shellenbaum drrs->drr_length); 5650a586ceaSMark Shellenbaum } 5660a586ceaSMark Shellenbaum (void) ssread(buf, drrs->drr_length, &zc); 567994fb6b8SMax Grossman if (dump) { 568994fb6b8SMax Grossman print_block(buf, drrs->drr_length); 569994fb6b8SMax Grossman } 5700a586ceaSMark Shellenbaum break; 5715d7b4d43SMatthew Ahrens case DRR_WRITE_EMBEDDED: 5725d7b4d43SMatthew Ahrens if (do_byteswap) { 5735d7b4d43SMatthew Ahrens drrwe->drr_object = 5745d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_object); 5755d7b4d43SMatthew Ahrens drrwe->drr_offset = 5765d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_offset); 5775d7b4d43SMatthew Ahrens drrwe->drr_length = 5785d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_length); 5795d7b4d43SMatthew Ahrens drrwe->drr_toguid = 5805d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_toguid); 5815d7b4d43SMatthew Ahrens drrwe->drr_lsize = 5825d7b4d43SMatthew Ahrens BSWAP_32(drrwe->drr_lsize); 5835d7b4d43SMatthew Ahrens drrwe->drr_psize = 5845d7b4d43SMatthew Ahrens BSWAP_32(drrwe->drr_psize); 5855d7b4d43SMatthew Ahrens } 5865d7b4d43SMatthew Ahrens if (verbose) { 5875d7b4d43SMatthew Ahrens (void) printf("WRITE_EMBEDDED object = %llu " 5885d7b4d43SMatthew Ahrens "offset = %llu length = %llu\n" 5895d7b4d43SMatthew Ahrens " toguid = %llx comp = %u etype = %u " 5905d7b4d43SMatthew Ahrens "lsize = %u psize = %u\n", 5915d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_object, 5925d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_offset, 5935d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_length, 5945d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_toguid, 5955d7b4d43SMatthew Ahrens drrwe->drr_compression, 5965d7b4d43SMatthew Ahrens drrwe->drr_etype, 5975d7b4d43SMatthew Ahrens drrwe->drr_lsize, 5985d7b4d43SMatthew Ahrens drrwe->drr_psize); 5995d7b4d43SMatthew Ahrens } 6005d7b4d43SMatthew Ahrens (void) ssread(buf, 6015d7b4d43SMatthew Ahrens P2ROUNDUP(drrwe->drr_psize, 8), &zc); 6025d7b4d43SMatthew Ahrens break; 603495db6fbSLori Alt } 60498110f08SMatthew Ahrens if (drr->drr_type != DRR_BEGIN && very_verbose) { 60598110f08SMatthew Ahrens (void) printf(" checksum = %llx/%llx/%llx/%llx\n", 60698110f08SMatthew Ahrens (longlong_t)drrc->drr_checksum.zc_word[0], 60798110f08SMatthew Ahrens (longlong_t)drrc->drr_checksum.zc_word[1], 60898110f08SMatthew Ahrens (longlong_t)drrc->drr_checksum.zc_word[2], 60998110f08SMatthew Ahrens (longlong_t)drrc->drr_checksum.zc_word[3]); 61098110f08SMatthew Ahrens } 611495db6fbSLori Alt pcksum = zc; 612495db6fbSLori Alt } 613495db6fbSLori Alt free(buf); 614495db6fbSLori Alt 615495db6fbSLori Alt /* Print final summary */ 616495db6fbSLori Alt 617495db6fbSLori Alt (void) printf("SUMMARY:\n"); 618495db6fbSLori Alt (void) printf("\tTotal DRR_BEGIN records = %lld\n", 619495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_BEGIN]); 620495db6fbSLori Alt (void) printf("\tTotal DRR_END records = %lld\n", 621495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_END]); 622495db6fbSLori Alt (void) printf("\tTotal DRR_OBJECT records = %lld\n", 623495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_OBJECT]); 624495db6fbSLori Alt (void) printf("\tTotal DRR_FREEOBJECTS records = %lld\n", 625495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_FREEOBJECTS]); 626495db6fbSLori Alt (void) printf("\tTotal DRR_WRITE records = %lld\n", 627495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_WRITE]); 6285d7b4d43SMatthew Ahrens (void) printf("\tTotal DRR_WRITE_BYREF records = %lld\n", 6295d7b4d43SMatthew Ahrens (u_longlong_t)drr_record_count[DRR_WRITE_BYREF]); 6305d7b4d43SMatthew Ahrens (void) printf("\tTotal DRR_WRITE_EMBEDDED records = %lld\n", 6315d7b4d43SMatthew Ahrens (u_longlong_t)drr_record_count[DRR_WRITE_EMBEDDED]); 632495db6fbSLori Alt (void) printf("\tTotal DRR_FREE records = %lld\n", 633495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_FREE]); 6340a586ceaSMark Shellenbaum (void) printf("\tTotal DRR_SPILL records = %lld\n", 6350a586ceaSMark Shellenbaum (u_longlong_t)drr_record_count[DRR_SPILL]); 636495db6fbSLori Alt (void) printf("\tTotal records = %lld\n", 6375d7b4d43SMatthew Ahrens (u_longlong_t)total_records); 638495db6fbSLori Alt (void) printf("\tTotal write size = %lld (0x%llx)\n", 639495db6fbSLori Alt (u_longlong_t)total_write_size, (u_longlong_t)total_write_size); 640495db6fbSLori Alt (void) printf("\tTotal stream length = %lld (0x%llx)\n", 641495db6fbSLori Alt (u_longlong_t)total_stream_len, (u_longlong_t)total_stream_len); 642495db6fbSLori Alt return (0); 643495db6fbSLori Alt } 644