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 /* 28994fb6b8SMax Grossman * Copyright (c) 2013 by Delphix. All rights reserved. 29994fb6b8SMax Grossman */ 30994fb6b8SMax Grossman 31994fb6b8SMax Grossman #include <ctype.h> 32495db6fbSLori Alt #include <libnvpair.h> 33495db6fbSLori Alt #include <stdio.h> 34495db6fbSLori Alt #include <stdlib.h> 35495db6fbSLori Alt #include <strings.h> 36495db6fbSLori Alt #include <unistd.h> 37495db6fbSLori Alt 38495db6fbSLori Alt #include <sys/dmu.h> 39495db6fbSLori Alt #include <sys/zfs_ioctl.h> 40495db6fbSLori Alt #include <zfs_fletcher.h> 41495db6fbSLori Alt 42994fb6b8SMax Grossman /* 43994fb6b8SMax Grossman * If dump mode is enabled, the number of bytes to print per line 44994fb6b8SMax Grossman */ 45994fb6b8SMax Grossman #define BYTES_PER_LINE 16 46994fb6b8SMax Grossman /* 47994fb6b8SMax Grossman * If dump mode is enabled, the number of bytes to group together, separated 48994fb6b8SMax Grossman * by newlines or spaces 49994fb6b8SMax Grossman */ 50994fb6b8SMax Grossman #define DUMP_GROUPING 4 51994fb6b8SMax Grossman 52495db6fbSLori Alt uint64_t total_write_size = 0; 53495db6fbSLori Alt uint64_t total_stream_len = 0; 54495db6fbSLori Alt FILE *send_stream = 0; 55495db6fbSLori Alt boolean_t do_byteswap = B_FALSE; 56495db6fbSLori Alt boolean_t do_cksum = B_TRUE; 57495db6fbSLori Alt #define INITIAL_BUFLEN (1<<20) 58495db6fbSLori Alt 59495db6fbSLori Alt static void 60495db6fbSLori Alt usage(void) 61495db6fbSLori Alt { 62994fb6b8SMax Grossman (void) fprintf(stderr, "usage: zstreamdump [-v] [-C] [-d] < file\n"); 63495db6fbSLori Alt (void) fprintf(stderr, "\t -v -- verbose\n"); 64495db6fbSLori Alt (void) fprintf(stderr, "\t -C -- suppress checksum verification\n"); 65994fb6b8SMax Grossman (void) fprintf(stderr, "\t -d -- dump contents of blocks modified, " 66994fb6b8SMax Grossman "implies verbose\n"); 67495db6fbSLori Alt exit(1); 68495db6fbSLori Alt } 69495db6fbSLori Alt 70495db6fbSLori Alt /* 71495db6fbSLori Alt * ssread - send stream read. 72495db6fbSLori Alt * 73495db6fbSLori Alt * Read while computing incremental checksum 74495db6fbSLori Alt */ 75495db6fbSLori Alt 76495db6fbSLori Alt static size_t 77495db6fbSLori Alt ssread(void *buf, size_t len, zio_cksum_t *cksum) 78495db6fbSLori Alt { 79495db6fbSLori Alt size_t outlen; 80495db6fbSLori Alt 81495db6fbSLori Alt if ((outlen = fread(buf, len, 1, send_stream)) == 0) 82495db6fbSLori Alt return (0); 83495db6fbSLori Alt 84495db6fbSLori Alt if (do_cksum && cksum) { 85495db6fbSLori Alt if (do_byteswap) 86495db6fbSLori Alt fletcher_4_incremental_byteswap(buf, len, cksum); 87495db6fbSLori Alt else 88495db6fbSLori Alt fletcher_4_incremental_native(buf, len, cksum); 89495db6fbSLori Alt } 90495db6fbSLori Alt total_stream_len += len; 91495db6fbSLori Alt return (outlen); 92495db6fbSLori Alt } 93495db6fbSLori Alt 94994fb6b8SMax Grossman /* 95994fb6b8SMax Grossman * Print part of a block in ASCII characters 96994fb6b8SMax Grossman */ 97994fb6b8SMax Grossman static void 98994fb6b8SMax Grossman print_ascii_block(char *subbuf, int length) 99994fb6b8SMax Grossman { 100994fb6b8SMax Grossman int i; 101994fb6b8SMax Grossman 102994fb6b8SMax Grossman for (i = 0; i < length; i++) { 103994fb6b8SMax Grossman char char_print = isprint(subbuf[i]) ? subbuf[i] : '.'; 104994fb6b8SMax Grossman if (i != 0 && i % DUMP_GROUPING == 0) { 105994fb6b8SMax Grossman (void) printf(" "); 106994fb6b8SMax Grossman } 107994fb6b8SMax Grossman (void) printf("%c", char_print); 108994fb6b8SMax Grossman } 109994fb6b8SMax Grossman (void) printf("\n"); 110994fb6b8SMax Grossman } 111994fb6b8SMax Grossman 112994fb6b8SMax Grossman /* 113994fb6b8SMax Grossman * print_block - Dump the contents of a modified block to STDOUT 114994fb6b8SMax Grossman * 115994fb6b8SMax Grossman * Assume that buf has capacity evenly divisible by BYTES_PER_LINE 116994fb6b8SMax Grossman */ 117994fb6b8SMax Grossman static void 118994fb6b8SMax Grossman print_block(char *buf, int length) 119994fb6b8SMax Grossman { 120994fb6b8SMax Grossman int i; 121994fb6b8SMax Grossman /* 122994fb6b8SMax Grossman * Start printing ASCII characters at a constant offset, after 123994fb6b8SMax Grossman * the hex prints. Leave 3 characters per byte on a line (2 digit 124994fb6b8SMax Grossman * hex number plus 1 space) plus spaces between characters and 125*5d7b4d43SMatthew Ahrens * groupings. 126994fb6b8SMax Grossman */ 127994fb6b8SMax Grossman int ascii_start = BYTES_PER_LINE * 3 + 128994fb6b8SMax Grossman BYTES_PER_LINE / DUMP_GROUPING + 2; 129994fb6b8SMax Grossman 130994fb6b8SMax Grossman for (i = 0; i < length; i += BYTES_PER_LINE) { 131994fb6b8SMax Grossman int j; 132994fb6b8SMax Grossman int this_line_length = MIN(BYTES_PER_LINE, length - i); 133994fb6b8SMax Grossman int print_offset = 0; 134994fb6b8SMax Grossman 135994fb6b8SMax Grossman for (j = 0; j < this_line_length; j++) { 136994fb6b8SMax Grossman int buf_offset = i + j; 137994fb6b8SMax Grossman 138994fb6b8SMax Grossman /* 139994fb6b8SMax Grossman * Separate every DUMP_GROUPING bytes by a space. 140994fb6b8SMax Grossman */ 141994fb6b8SMax Grossman if (buf_offset % DUMP_GROUPING == 0) { 142994fb6b8SMax Grossman print_offset += printf(" "); 143994fb6b8SMax Grossman } 144994fb6b8SMax Grossman 145994fb6b8SMax Grossman /* 146994fb6b8SMax Grossman * Print the two-digit hex value for this byte. 147994fb6b8SMax Grossman */ 148994fb6b8SMax Grossman unsigned char hex_print = buf[buf_offset]; 149994fb6b8SMax Grossman print_offset += printf("%02x ", hex_print); 150994fb6b8SMax Grossman } 151994fb6b8SMax Grossman 152994fb6b8SMax Grossman (void) printf("%*s", ascii_start - print_offset, " "); 153994fb6b8SMax Grossman 154994fb6b8SMax Grossman print_ascii_block(buf + i, this_line_length); 155994fb6b8SMax Grossman } 156994fb6b8SMax Grossman } 157994fb6b8SMax Grossman 158495db6fbSLori Alt int 159495db6fbSLori Alt main(int argc, char *argv[]) 160495db6fbSLori Alt { 161495db6fbSLori Alt char *buf = malloc(INITIAL_BUFLEN); 162*5d7b4d43SMatthew Ahrens uint64_t drr_record_count[DRR_NUMTYPES] = { 0 }; 163*5d7b4d43SMatthew Ahrens uint64_t total_records = 0; 164495db6fbSLori Alt dmu_replay_record_t thedrr; 165495db6fbSLori Alt dmu_replay_record_t *drr = &thedrr; 166495db6fbSLori Alt struct drr_begin *drrb = &thedrr.drr_u.drr_begin; 167495db6fbSLori Alt struct drr_end *drre = &thedrr.drr_u.drr_end; 168495db6fbSLori Alt struct drr_object *drro = &thedrr.drr_u.drr_object; 169495db6fbSLori Alt struct drr_freeobjects *drrfo = &thedrr.drr_u.drr_freeobjects; 170495db6fbSLori Alt struct drr_write *drrw = &thedrr.drr_u.drr_write; 1719e69d7d0SLori Alt struct drr_write_byref *drrwbr = &thedrr.drr_u.drr_write_byref; 172495db6fbSLori Alt struct drr_free *drrf = &thedrr.drr_u.drr_free; 1730a586ceaSMark Shellenbaum struct drr_spill *drrs = &thedrr.drr_u.drr_spill; 174*5d7b4d43SMatthew Ahrens struct drr_write_embedded *drrwe = &thedrr.drr_u.drr_write_embedded; 175495db6fbSLori Alt char c; 176495db6fbSLori Alt boolean_t verbose = B_FALSE; 177495db6fbSLori Alt boolean_t first = B_TRUE; 178994fb6b8SMax Grossman /* 179994fb6b8SMax Grossman * dump flag controls whether the contents of any modified data blocks 180994fb6b8SMax Grossman * are printed to the console during processing of the stream. Warning: 181994fb6b8SMax Grossman * for large streams, this can obviously lead to massive prints. 182994fb6b8SMax Grossman */ 183994fb6b8SMax Grossman boolean_t dump = B_FALSE; 1848e714474SLori Alt int err; 185495db6fbSLori Alt zio_cksum_t zc = { 0 }; 186495db6fbSLori Alt zio_cksum_t pcksum = { 0 }; 187495db6fbSLori Alt 188994fb6b8SMax Grossman while ((c = getopt(argc, argv, ":vCd")) != -1) { 189495db6fbSLori Alt switch (c) { 190495db6fbSLori Alt case 'C': 191495db6fbSLori Alt do_cksum = B_FALSE; 192495db6fbSLori Alt break; 193495db6fbSLori Alt case 'v': 194495db6fbSLori Alt verbose = B_TRUE; 195495db6fbSLori Alt break; 196994fb6b8SMax Grossman case 'd': 197994fb6b8SMax Grossman dump = B_TRUE; 198994fb6b8SMax Grossman verbose = B_TRUE; 199994fb6b8SMax Grossman break; 200495db6fbSLori Alt case ':': 201495db6fbSLori Alt (void) fprintf(stderr, 202495db6fbSLori Alt "missing argument for '%c' option\n", optopt); 203495db6fbSLori Alt usage(); 204495db6fbSLori Alt break; 205495db6fbSLori Alt case '?': 206495db6fbSLori Alt (void) fprintf(stderr, "invalid option '%c'\n", 207495db6fbSLori Alt optopt); 208495db6fbSLori Alt usage(); 209495db6fbSLori Alt } 210495db6fbSLori Alt } 211495db6fbSLori Alt 212495db6fbSLori Alt if (isatty(STDIN_FILENO)) { 213495db6fbSLori Alt (void) fprintf(stderr, 214495db6fbSLori Alt "Error: Backup stream can not be read " 215495db6fbSLori Alt "from a terminal.\n" 216495db6fbSLori Alt "You must redirect standard input.\n"); 217495db6fbSLori Alt exit(1); 218495db6fbSLori Alt } 219495db6fbSLori Alt 220495db6fbSLori Alt send_stream = stdin; 221495db6fbSLori Alt pcksum = zc; 222495db6fbSLori Alt while (ssread(drr, sizeof (dmu_replay_record_t), &zc)) { 223495db6fbSLori Alt 224994fb6b8SMax Grossman /* 225994fb6b8SMax Grossman * If this is the first DMU record being processed, check for 226994fb6b8SMax Grossman * the magic bytes and figure out the endian-ness based on them. 227994fb6b8SMax Grossman */ 228495db6fbSLori Alt if (first) { 229495db6fbSLori Alt if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) { 230495db6fbSLori Alt do_byteswap = B_TRUE; 231495db6fbSLori Alt if (do_cksum) { 232495db6fbSLori Alt ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0); 233495db6fbSLori Alt /* 234495db6fbSLori Alt * recalculate header checksum now 235495db6fbSLori Alt * that we know it needs to be 236495db6fbSLori Alt * byteswapped. 237495db6fbSLori Alt */ 238495db6fbSLori Alt fletcher_4_incremental_byteswap(drr, 239495db6fbSLori Alt sizeof (dmu_replay_record_t), &zc); 240495db6fbSLori Alt } 241495db6fbSLori Alt } else if (drrb->drr_magic != DMU_BACKUP_MAGIC) { 242495db6fbSLori Alt (void) fprintf(stderr, "Invalid stream " 243495db6fbSLori Alt "(bad magic number)\n"); 244495db6fbSLori Alt exit(1); 245495db6fbSLori Alt } 246495db6fbSLori Alt first = B_FALSE; 247495db6fbSLori Alt } 248495db6fbSLori Alt if (do_byteswap) { 249495db6fbSLori Alt drr->drr_type = BSWAP_32(drr->drr_type); 250495db6fbSLori Alt drr->drr_payloadlen = 251495db6fbSLori Alt BSWAP_32(drr->drr_payloadlen); 252495db6fbSLori Alt } 253495db6fbSLori Alt 254495db6fbSLori Alt /* 255495db6fbSLori Alt * At this point, the leading fields of the replay record 256495db6fbSLori Alt * (drr_type and drr_payloadlen) have been byte-swapped if 257495db6fbSLori Alt * necessary, but the rest of the data structure (the 258495db6fbSLori Alt * union of type-specific structures) is still in its 259495db6fbSLori Alt * original state. 260495db6fbSLori Alt */ 261495db6fbSLori Alt if (drr->drr_type >= DRR_NUMTYPES) { 262495db6fbSLori Alt (void) printf("INVALID record found: type 0x%x\n", 263495db6fbSLori Alt drr->drr_type); 264495db6fbSLori Alt (void) printf("Aborting.\n"); 265495db6fbSLori Alt exit(1); 266495db6fbSLori Alt } 267495db6fbSLori Alt 268495db6fbSLori Alt drr_record_count[drr->drr_type]++; 269*5d7b4d43SMatthew Ahrens total_records++; 270495db6fbSLori Alt 271495db6fbSLori Alt switch (drr->drr_type) { 272495db6fbSLori Alt case DRR_BEGIN: 273495db6fbSLori Alt if (do_byteswap) { 274495db6fbSLori Alt drrb->drr_magic = BSWAP_64(drrb->drr_magic); 2759e69d7d0SLori Alt drrb->drr_versioninfo = 2769e69d7d0SLori Alt BSWAP_64(drrb->drr_versioninfo); 277495db6fbSLori Alt drrb->drr_creation_time = 278495db6fbSLori Alt BSWAP_64(drrb->drr_creation_time); 279495db6fbSLori Alt drrb->drr_type = BSWAP_32(drrb->drr_type); 280495db6fbSLori Alt drrb->drr_flags = BSWAP_32(drrb->drr_flags); 281495db6fbSLori Alt drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 282495db6fbSLori Alt drrb->drr_fromguid = 283495db6fbSLori Alt BSWAP_64(drrb->drr_fromguid); 284495db6fbSLori Alt } 285495db6fbSLori Alt 286495db6fbSLori Alt (void) printf("BEGIN record\n"); 2879e69d7d0SLori Alt (void) printf("\thdrtype = %lld\n", 2889e69d7d0SLori Alt DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo)); 2899e69d7d0SLori Alt (void) printf("\tfeatures = %llx\n", 2909e69d7d0SLori Alt DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo)); 291495db6fbSLori Alt (void) printf("\tmagic = %llx\n", 292495db6fbSLori Alt (u_longlong_t)drrb->drr_magic); 293495db6fbSLori Alt (void) printf("\tcreation_time = %llx\n", 294495db6fbSLori Alt (u_longlong_t)drrb->drr_creation_time); 295495db6fbSLori Alt (void) printf("\ttype = %u\n", drrb->drr_type); 296495db6fbSLori Alt (void) printf("\tflags = 0x%x\n", drrb->drr_flags); 297495db6fbSLori Alt (void) printf("\ttoguid = %llx\n", 298495db6fbSLori Alt (u_longlong_t)drrb->drr_toguid); 299495db6fbSLori Alt (void) printf("\tfromguid = %llx\n", 300495db6fbSLori Alt (u_longlong_t)drrb->drr_fromguid); 301495db6fbSLori Alt (void) printf("\ttoname = %s\n", drrb->drr_toname); 302495db6fbSLori Alt if (verbose) 303495db6fbSLori Alt (void) printf("\n"); 304495db6fbSLori Alt 3059e69d7d0SLori Alt if ((DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == 3069e69d7d0SLori Alt DMU_COMPOUNDSTREAM) && drr->drr_payloadlen != 0) { 307495db6fbSLori Alt nvlist_t *nv; 308495db6fbSLori Alt int sz = drr->drr_payloadlen; 309495db6fbSLori Alt 310994fb6b8SMax Grossman if (sz > INITIAL_BUFLEN) { 311495db6fbSLori Alt free(buf); 312495db6fbSLori Alt buf = malloc(sz); 313495db6fbSLori Alt } 314495db6fbSLori Alt (void) ssread(buf, sz, &zc); 315495db6fbSLori Alt if (ferror(send_stream)) 316495db6fbSLori Alt perror("fread"); 317495db6fbSLori Alt err = nvlist_unpack(buf, sz, &nv, 0); 318495db6fbSLori Alt if (err) 319495db6fbSLori Alt perror(strerror(err)); 320495db6fbSLori Alt nvlist_print(stdout, nv); 321495db6fbSLori Alt nvlist_free(nv); 322495db6fbSLori Alt } 323495db6fbSLori Alt break; 324495db6fbSLori Alt 325495db6fbSLori Alt case DRR_END: 326495db6fbSLori Alt if (do_byteswap) { 327495db6fbSLori Alt drre->drr_checksum.zc_word[0] = 328495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[0]); 329495db6fbSLori Alt drre->drr_checksum.zc_word[1] = 330495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[1]); 331495db6fbSLori Alt drre->drr_checksum.zc_word[2] = 332495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[2]); 333495db6fbSLori Alt drre->drr_checksum.zc_word[3] = 334495db6fbSLori Alt BSWAP_64(drre->drr_checksum.zc_word[3]); 335495db6fbSLori Alt } 336495db6fbSLori Alt /* 337495db6fbSLori Alt * We compare against the *previous* checksum 338495db6fbSLori Alt * value, because the stored checksum is of 339495db6fbSLori Alt * everything before the DRR_END record. 340495db6fbSLori Alt */ 341495db6fbSLori Alt if (do_cksum && !ZIO_CHECKSUM_EQUAL(drre->drr_checksum, 342495db6fbSLori Alt pcksum)) { 343495db6fbSLori Alt (void) printf("Expected checksum differs from " 344495db6fbSLori Alt "checksum in stream.\n"); 345495db6fbSLori Alt (void) printf("Expected checksum = " 346495db6fbSLori Alt "%llx/%llx/%llx/%llx\n", 347495db6fbSLori Alt pcksum.zc_word[0], 348495db6fbSLori Alt pcksum.zc_word[1], 349495db6fbSLori Alt pcksum.zc_word[2], 350495db6fbSLori Alt pcksum.zc_word[3]); 351495db6fbSLori Alt } 352495db6fbSLori Alt (void) printf("END checksum = %llx/%llx/%llx/%llx\n", 353495db6fbSLori Alt drre->drr_checksum.zc_word[0], 354495db6fbSLori Alt drre->drr_checksum.zc_word[1], 355495db6fbSLori Alt drre->drr_checksum.zc_word[2], 356495db6fbSLori Alt drre->drr_checksum.zc_word[3]); 357495db6fbSLori Alt 358495db6fbSLori Alt ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0); 359495db6fbSLori Alt break; 360495db6fbSLori Alt 361495db6fbSLori Alt case DRR_OBJECT: 362495db6fbSLori Alt if (do_byteswap) { 363495db6fbSLori Alt drro->drr_object = BSWAP_64(drro->drr_object); 364495db6fbSLori Alt drro->drr_type = BSWAP_32(drro->drr_type); 365495db6fbSLori Alt drro->drr_bonustype = 366495db6fbSLori Alt BSWAP_32(drro->drr_bonustype); 367495db6fbSLori Alt drro->drr_blksz = BSWAP_32(drro->drr_blksz); 368495db6fbSLori Alt drro->drr_bonuslen = 369495db6fbSLori Alt BSWAP_32(drro->drr_bonuslen); 3709e69d7d0SLori Alt drro->drr_toguid = BSWAP_64(drro->drr_toguid); 371495db6fbSLori Alt } 372495db6fbSLori Alt if (verbose) { 373495db6fbSLori Alt (void) printf("OBJECT object = %llu type = %u " 374495db6fbSLori Alt "bonustype = %u blksz = %u bonuslen = %u\n", 375495db6fbSLori Alt (u_longlong_t)drro->drr_object, 376495db6fbSLori Alt drro->drr_type, 377495db6fbSLori Alt drro->drr_bonustype, 378495db6fbSLori Alt drro->drr_blksz, 379495db6fbSLori Alt drro->drr_bonuslen); 380495db6fbSLori Alt } 381495db6fbSLori Alt if (drro->drr_bonuslen > 0) { 382*5d7b4d43SMatthew Ahrens (void) ssread(buf, 383*5d7b4d43SMatthew Ahrens P2ROUNDUP(drro->drr_bonuslen, 8), &zc); 384994fb6b8SMax Grossman if (dump) { 385994fb6b8SMax Grossman print_block(buf, 386994fb6b8SMax Grossman P2ROUNDUP(drro->drr_bonuslen, 8)); 387994fb6b8SMax Grossman } 388495db6fbSLori Alt } 389495db6fbSLori Alt break; 390495db6fbSLori Alt 391495db6fbSLori Alt case DRR_FREEOBJECTS: 392495db6fbSLori Alt if (do_byteswap) { 393495db6fbSLori Alt drrfo->drr_firstobj = 394495db6fbSLori Alt BSWAP_64(drrfo->drr_firstobj); 395495db6fbSLori Alt drrfo->drr_numobjs = 396495db6fbSLori Alt BSWAP_64(drrfo->drr_numobjs); 3979e69d7d0SLori Alt drrfo->drr_toguid = BSWAP_64(drrfo->drr_toguid); 398495db6fbSLori Alt } 399495db6fbSLori Alt if (verbose) { 400495db6fbSLori Alt (void) printf("FREEOBJECTS firstobj = %llu " 401495db6fbSLori Alt "numobjs = %llu\n", 402495db6fbSLori Alt (u_longlong_t)drrfo->drr_firstobj, 403495db6fbSLori Alt (u_longlong_t)drrfo->drr_numobjs); 404495db6fbSLori Alt } 405495db6fbSLori Alt break; 406495db6fbSLori Alt 407495db6fbSLori Alt case DRR_WRITE: 408495db6fbSLori Alt if (do_byteswap) { 409495db6fbSLori Alt drrw->drr_object = BSWAP_64(drrw->drr_object); 410495db6fbSLori Alt drrw->drr_type = BSWAP_32(drrw->drr_type); 411495db6fbSLori Alt drrw->drr_offset = BSWAP_64(drrw->drr_offset); 412495db6fbSLori Alt drrw->drr_length = BSWAP_64(drrw->drr_length); 4139e69d7d0SLori Alt drrw->drr_toguid = BSWAP_64(drrw->drr_toguid); 4148e714474SLori Alt drrw->drr_key.ddk_prop = 4158e714474SLori Alt BSWAP_64(drrw->drr_key.ddk_prop); 416495db6fbSLori Alt } 417994fb6b8SMax Grossman /* 418994fb6b8SMax Grossman * If this is verbose and/or dump output, 419994fb6b8SMax Grossman * print info on the modified block 420994fb6b8SMax Grossman */ 421495db6fbSLori Alt if (verbose) { 422495db6fbSLori Alt (void) printf("WRITE object = %llu type = %u " 4238e714474SLori Alt "checksum type = %u\n" 4248e714474SLori Alt "offset = %llu length = %llu " 4258e714474SLori Alt "props = %llx\n", 426495db6fbSLori Alt (u_longlong_t)drrw->drr_object, 427495db6fbSLori Alt drrw->drr_type, 4288e714474SLori Alt drrw->drr_checksumtype, 429495db6fbSLori Alt (u_longlong_t)drrw->drr_offset, 4308e714474SLori Alt (u_longlong_t)drrw->drr_length, 4318e714474SLori Alt (u_longlong_t)drrw->drr_key.ddk_prop); 432495db6fbSLori Alt } 433994fb6b8SMax Grossman /* 434994fb6b8SMax Grossman * Read the contents of the block in from STDIN to buf 435994fb6b8SMax Grossman */ 436495db6fbSLori Alt (void) ssread(buf, drrw->drr_length, &zc); 437994fb6b8SMax Grossman /* 438994fb6b8SMax Grossman * If in dump mode 439994fb6b8SMax Grossman */ 440994fb6b8SMax Grossman if (dump) { 441994fb6b8SMax Grossman print_block(buf, drrw->drr_length); 442994fb6b8SMax Grossman } 443495db6fbSLori Alt total_write_size += drrw->drr_length; 444495db6fbSLori Alt break; 445495db6fbSLori Alt 4469e69d7d0SLori Alt case DRR_WRITE_BYREF: 4479e69d7d0SLori Alt if (do_byteswap) { 4489e69d7d0SLori Alt drrwbr->drr_object = 4499e69d7d0SLori Alt BSWAP_64(drrwbr->drr_object); 4509e69d7d0SLori Alt drrwbr->drr_offset = 4519e69d7d0SLori Alt BSWAP_64(drrwbr->drr_offset); 4529e69d7d0SLori Alt drrwbr->drr_length = 4539e69d7d0SLori Alt BSWAP_64(drrwbr->drr_length); 4549e69d7d0SLori Alt drrwbr->drr_toguid = 4559e69d7d0SLori Alt BSWAP_64(drrwbr->drr_toguid); 4569e69d7d0SLori Alt drrwbr->drr_refguid = 4579e69d7d0SLori Alt BSWAP_64(drrwbr->drr_refguid); 4589e69d7d0SLori Alt drrwbr->drr_refobject = 4599e69d7d0SLori Alt BSWAP_64(drrwbr->drr_refobject); 4609e69d7d0SLori Alt drrwbr->drr_refoffset = 4619e69d7d0SLori Alt BSWAP_64(drrwbr->drr_refoffset); 4628e714474SLori Alt drrwbr->drr_key.ddk_prop = 4638e714474SLori Alt BSWAP_64(drrwbr->drr_key.ddk_prop); 4649e69d7d0SLori Alt } 4659e69d7d0SLori Alt if (verbose) { 4669e69d7d0SLori Alt (void) printf("WRITE_BYREF object = %llu " 4678e714474SLori Alt "checksum type = %u props = %llx\n" 4689e69d7d0SLori Alt "offset = %llu length = %llu\n" 4699e69d7d0SLori Alt "toguid = %llx refguid = %llx\n" 4709e69d7d0SLori Alt "refobject = %llu refoffset = %llu\n", 4719e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_object, 4728e714474SLori Alt drrwbr->drr_checksumtype, 4738e714474SLori Alt (u_longlong_t)drrwbr->drr_key.ddk_prop, 4749e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_offset, 4759e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_length, 4769e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_toguid, 4779e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_refguid, 4789e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_refobject, 4799e69d7d0SLori Alt (u_longlong_t)drrwbr->drr_refoffset); 4809e69d7d0SLori Alt } 4819e69d7d0SLori Alt break; 4829e69d7d0SLori Alt 483495db6fbSLori Alt case DRR_FREE: 484495db6fbSLori Alt if (do_byteswap) { 485495db6fbSLori Alt drrf->drr_object = BSWAP_64(drrf->drr_object); 486495db6fbSLori Alt drrf->drr_offset = BSWAP_64(drrf->drr_offset); 487495db6fbSLori Alt drrf->drr_length = BSWAP_64(drrf->drr_length); 488495db6fbSLori Alt } 489495db6fbSLori Alt if (verbose) { 490495db6fbSLori Alt (void) printf("FREE object = %llu " 491495db6fbSLori Alt "offset = %llu length = %lld\n", 492495db6fbSLori Alt (u_longlong_t)drrf->drr_object, 493495db6fbSLori Alt (u_longlong_t)drrf->drr_offset, 494495db6fbSLori Alt (longlong_t)drrf->drr_length); 495495db6fbSLori Alt } 496495db6fbSLori Alt break; 4970a586ceaSMark Shellenbaum case DRR_SPILL: 4980a586ceaSMark Shellenbaum if (do_byteswap) { 4990a586ceaSMark Shellenbaum drrs->drr_object = BSWAP_64(drrs->drr_object); 5000a586ceaSMark Shellenbaum drrs->drr_length = BSWAP_64(drrs->drr_length); 5010a586ceaSMark Shellenbaum } 5020a586ceaSMark Shellenbaum if (verbose) { 5030a586ceaSMark Shellenbaum (void) printf("SPILL block for object = %llu " 5040a586ceaSMark Shellenbaum "length = %llu\n", drrs->drr_object, 5050a586ceaSMark Shellenbaum drrs->drr_length); 5060a586ceaSMark Shellenbaum } 5070a586ceaSMark Shellenbaum (void) ssread(buf, drrs->drr_length, &zc); 508994fb6b8SMax Grossman if (dump) { 509994fb6b8SMax Grossman print_block(buf, drrs->drr_length); 510994fb6b8SMax Grossman } 5110a586ceaSMark Shellenbaum break; 512*5d7b4d43SMatthew Ahrens case DRR_WRITE_EMBEDDED: 513*5d7b4d43SMatthew Ahrens if (do_byteswap) { 514*5d7b4d43SMatthew Ahrens drrwe->drr_object = 515*5d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_object); 516*5d7b4d43SMatthew Ahrens drrwe->drr_offset = 517*5d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_offset); 518*5d7b4d43SMatthew Ahrens drrwe->drr_length = 519*5d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_length); 520*5d7b4d43SMatthew Ahrens drrwe->drr_toguid = 521*5d7b4d43SMatthew Ahrens BSWAP_64(drrwe->drr_toguid); 522*5d7b4d43SMatthew Ahrens drrwe->drr_lsize = 523*5d7b4d43SMatthew Ahrens BSWAP_32(drrwe->drr_lsize); 524*5d7b4d43SMatthew Ahrens drrwe->drr_psize = 525*5d7b4d43SMatthew Ahrens BSWAP_32(drrwe->drr_psize); 526*5d7b4d43SMatthew Ahrens } 527*5d7b4d43SMatthew Ahrens if (verbose) { 528*5d7b4d43SMatthew Ahrens (void) printf("WRITE_EMBEDDED object = %llu " 529*5d7b4d43SMatthew Ahrens "offset = %llu length = %llu\n" 530*5d7b4d43SMatthew Ahrens "toguid = %llx comp = %u etype = %u " 531*5d7b4d43SMatthew Ahrens "lsize = %u psize = %u\n", 532*5d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_object, 533*5d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_offset, 534*5d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_length, 535*5d7b4d43SMatthew Ahrens (u_longlong_t)drrwe->drr_toguid, 536*5d7b4d43SMatthew Ahrens drrwe->drr_compression, 537*5d7b4d43SMatthew Ahrens drrwe->drr_etype, 538*5d7b4d43SMatthew Ahrens drrwe->drr_lsize, 539*5d7b4d43SMatthew Ahrens drrwe->drr_psize); 540*5d7b4d43SMatthew Ahrens } 541*5d7b4d43SMatthew Ahrens (void) ssread(buf, 542*5d7b4d43SMatthew Ahrens P2ROUNDUP(drrwe->drr_psize, 8), &zc); 543*5d7b4d43SMatthew Ahrens break; 544495db6fbSLori Alt } 545495db6fbSLori Alt pcksum = zc; 546495db6fbSLori Alt } 547495db6fbSLori Alt free(buf); 548495db6fbSLori Alt 549495db6fbSLori Alt /* Print final summary */ 550495db6fbSLori Alt 551495db6fbSLori Alt (void) printf("SUMMARY:\n"); 552495db6fbSLori Alt (void) printf("\tTotal DRR_BEGIN records = %lld\n", 553495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_BEGIN]); 554495db6fbSLori Alt (void) printf("\tTotal DRR_END records = %lld\n", 555495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_END]); 556495db6fbSLori Alt (void) printf("\tTotal DRR_OBJECT records = %lld\n", 557495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_OBJECT]); 558495db6fbSLori Alt (void) printf("\tTotal DRR_FREEOBJECTS records = %lld\n", 559495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_FREEOBJECTS]); 560495db6fbSLori Alt (void) printf("\tTotal DRR_WRITE records = %lld\n", 561495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_WRITE]); 562*5d7b4d43SMatthew Ahrens (void) printf("\tTotal DRR_WRITE_BYREF records = %lld\n", 563*5d7b4d43SMatthew Ahrens (u_longlong_t)drr_record_count[DRR_WRITE_BYREF]); 564*5d7b4d43SMatthew Ahrens (void) printf("\tTotal DRR_WRITE_EMBEDDED records = %lld\n", 565*5d7b4d43SMatthew Ahrens (u_longlong_t)drr_record_count[DRR_WRITE_EMBEDDED]); 566495db6fbSLori Alt (void) printf("\tTotal DRR_FREE records = %lld\n", 567495db6fbSLori Alt (u_longlong_t)drr_record_count[DRR_FREE]); 5680a586ceaSMark Shellenbaum (void) printf("\tTotal DRR_SPILL records = %lld\n", 5690a586ceaSMark Shellenbaum (u_longlong_t)drr_record_count[DRR_SPILL]); 570495db6fbSLori Alt (void) printf("\tTotal records = %lld\n", 571*5d7b4d43SMatthew Ahrens (u_longlong_t)total_records); 572495db6fbSLori Alt (void) printf("\tTotal write size = %lld (0x%llx)\n", 573495db6fbSLori Alt (u_longlong_t)total_write_size, (u_longlong_t)total_write_size); 574495db6fbSLori Alt (void) printf("\tTotal stream length = %lld (0x%llx)\n", 575495db6fbSLori Alt (u_longlong_t)total_stream_len, (u_longlong_t)total_stream_len); 576495db6fbSLori Alt return (0); 577495db6fbSLori Alt } 578