cmd/zstreamdump/zstreamdump.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Portions Copyright 2012 Martin Matuska <martin@matuska.org>
  27  */
  28
  29 /*
  30  * Copyright (c) 2013, 2015 by Delphix. All rights reserved.
  31  */
  32
  33 #include <ctype.h>
  34 #include <libnvpair.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <strings.h>
  38 #include <unistd.h>
  39 #include <stddef.h>
  40
  41 #include <sys/dmu.h>
  42 #include <sys/zfs_ioctl.h>
  43 #include <sys/zio.h>
  44 #include <zfs_fletcher.h>
  45
  46 /*
  47  * If dump mode is enabled, the number of bytes to print per line
  48  */
  49 #define BYTES_PER_LINE  16
  50 /*
  51  * If dump mode is enabled, the number of bytes to group together, separated
  52  * by newlines or spaces
  53  */
  54 #define DUMP_GROUPING   4
  55
  56 uint64_t total_write_size = 0;
  57 uint64_t total_stream_len = 0;
  58 FILE *send_stream = 0;
  59 boolean_t do_byteswap = B_FALSE;
  60 boolean_t do_cksum = B_TRUE;
  61
  62 static void
  63 usage(void)
  64 {
  65         (void) fprintf(stderr, "usage: zstreamdump [-v] [-C] [-d] < file\n");
  66         (void) fprintf(stderr, "\t -v -- verbose\n");
  67         (void) fprintf(stderr, "\t -C -- suppress checksum verification\n");
  68         (void) fprintf(stderr, "\t -d -- dump contents of blocks modified, "
  69             "implies verbose\n");
  70         exit(1);
  71 }
  72
  73 static void *
  74 safe_malloc(size_t size)
  75 {
  76         void *rv = malloc(size);
  77         if (rv == NULL) {
  78                 (void) fprintf(stderr, "ERROR; failed to allocate %zu bytes\n",
  79                     size);
  80                 abort();
  81         }
  82         return (rv);
  83 }
  84
  85 /*
  86  * ssread - send stream read.
  87  *
  88  * Read while computing incremental checksum
  89  */
  90 static size_t
  91 ssread(void *buf, size_t len, zio_cksum_t *cksum)
  92 {
  93         size_t outlen;
  94
  95         if ((outlen = fread(buf, len, 1, send_stream)) == 0)
  96                 return (0);
  97
  98         if (do_cksum) {
  99                 if (do_byteswap)
 100                         fletcher_4_incremental_byteswap(buf, len, cksum);
 101                 else
 102                         fletcher_4_incremental_native(buf, len, cksum);
 103         }
 104         total_stream_len += len;
 105         return (outlen);
 106 }
 107
 108 static size_t
 109 read_hdr(dmu_replay_record_t *drr, zio_cksum_t *cksum)
 110 {
 111         ASSERT3U(offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum),
 112             ==, sizeof (dmu_replay_record_t) - sizeof (zio_cksum_t));
 113         size_t r = ssread(drr, sizeof (*drr) - sizeof (zio_cksum_t), cksum);
 114         if (r == 0)
 115                 return (0);
 116         zio_cksum_t saved_cksum = *cksum;
 117         r = ssread(&drr->drr_u.drr_checksum.drr_checksum,
 118             sizeof (zio_cksum_t), cksum);
 119         if (r == 0)
 120                 return (0);
 121         if (!ZIO_CHECKSUM_IS_ZERO(&drr->drr_u.drr_checksum.drr_checksum) &&
 122             !ZIO_CHECKSUM_EQUAL(saved_cksum,
 123             drr->drr_u.drr_checksum.drr_checksum)) {
 124                 fprintf(stderr, "invalid checksum\n");
 125                 (void) printf("Incorrect checksum in record header.\n");
 126                 (void) printf("Expected checksum = %llx/%llx/%llx/%llx\n",
 127                     (longlong_t)saved_cksum.zc_word[0],
 128                     (longlong_t)saved_cksum.zc_word[1],
 129                     (longlong_t)saved_cksum.zc_word[2],
 130                     (longlong_t)saved_cksum.zc_word[3]);
 131                 return (0);
 132         }
 133         return (sizeof (*drr));
 134 }
 135
 136 /*
 137  * Print part of a block in ASCII characters
 138  */
 139 static void
 140 print_ascii_block(char *subbuf, int length)
 141 {
 142         int i;
 143
 144         for (i = 0; i < length; i++) {
 145                 char char_print = isprint(subbuf[i]) ? subbuf[i] : '.';
 146                 if (i != 0 && i % DUMP_GROUPING == 0) {
 147                         (void) printf(" ");
 148                 }
 149                 (void) printf("%c", char_print);
 150         }
 151         (void) printf("\n");
 152 }
 153
 154 /*
 155  * print_block - Dump the contents of a modified block to STDOUT
 156  *
 157  * Assume that buf has capacity evenly divisible by BYTES_PER_LINE
 158  */
 159 static void
 160 print_block(char *buf, int length)
 161 {
 162         int i;
 163         /*
 164          * Start printing ASCII characters at a constant offset, after
 165          * the hex prints. Leave 3 characters per byte on a line (2 digit
 166          * hex number plus 1 space) plus spaces between characters and
 167          * groupings.
 168          */
 169         int ascii_start = BYTES_PER_LINE * 3 +
 170             BYTES_PER_LINE / DUMP_GROUPING + 2;
 171
 172         for (i = 0; i < length; i += BYTES_PER_LINE) {
 173                 int j;
 174                 int this_line_length = MIN(BYTES_PER_LINE, length - i);
 175                 int print_offset = 0;
 176
 177                 for (j = 0; j < this_line_length; j++) {
 178                         int buf_offset = i + j;
 179
 180                         /*
 181                          * Separate every DUMP_GROUPING bytes by a space.
 182                          */
 183                         if (buf_offset % DUMP_GROUPING == 0) {
 184                                 print_offset += printf(" ");
 185                         }
 186
 187                         /*
 188                          * Print the two-digit hex value for this byte.
 189                          */
 190                         unsigned char hex_print = buf[buf_offset];
 191                         print_offset += printf("%02x ", hex_print);
 192                 }
 193
 194                 (void) printf("%*s", ascii_start - print_offset, " ");
 195
 196                 print_ascii_block(buf + i, this_line_length);
 197         }
 198 }
 199
 200 int
 201 main(int argc, char *argv[])
 202 {
 203         char *buf = safe_malloc(SPA_MAXBLOCKSIZE);
 204         uint64_t drr_record_count[DRR_NUMTYPES] = { 0 };
 205         uint64_t total_records = 0;
 206         dmu_replay_record_t thedrr;
 207         dmu_replay_record_t *drr = &thedrr;
 208         struct drr_begin *drrb = &thedrr.drr_u.drr_begin;
 209         struct drr_end *drre = &thedrr.drr_u.drr_end;
 210         struct drr_object *drro = &thedrr.drr_u.drr_object;
 211         struct drr_freeobjects *drrfo = &thedrr.drr_u.drr_freeobjects;
 212         struct drr_write *drrw = &thedrr.drr_u.drr_write;
 213         struct drr_write_byref *drrwbr = &thedrr.drr_u.drr_write_byref;
 214         struct drr_free *drrf = &thedrr.drr_u.drr_free;
 215         struct drr_spill *drrs = &thedrr.drr_u.drr_spill;
 216         struct drr_write_embedded *drrwe = &thedrr.drr_u.drr_write_embedded;
 217         struct drr_checksum *drrc = &thedrr.drr_u.drr_checksum;
 218         char c;
 219         boolean_t verbose = B_FALSE;
 220         boolean_t very_verbose = B_FALSE;
 221         boolean_t first = B_TRUE;
 222         /*
 223          * dump flag controls whether the contents of any modified data blocks
 224          * are printed to the console during processing of the stream. Warning:
 225          * for large streams, this can obviously lead to massive prints.
 226          */
 227         boolean_t dump = B_FALSE;
 228         int err;
 229         zio_cksum_t zc = { { 0 } };
 230         zio_cksum_t pcksum = { { 0 } };
 231
 232         while ((c = getopt(argc, argv, ":vCd")) != -1) {
 233                 switch (c) {
 234                 case 'C':
 235                         do_cksum = B_FALSE;
 236                         break;
 237                 case 'v':
 238                         if (verbose)
 239                                 very_verbose = B_TRUE;
 240                         verbose = B_TRUE;
 241                         break;
 242                 case 'd':
 243                         dump = B_TRUE;
 244                         verbose = B_TRUE;
 245                         very_verbose = B_TRUE;
 246                         break;
 247                 case ':':
 248                         (void) fprintf(stderr,
 249                             "missing argument for '%c' option\n", optopt);
 250                         usage();
 251                         break;
 252                 case '?':
 253                         (void) fprintf(stderr, "invalid option '%c'\n",
 254                             optopt);
 255                         usage();
 256                         break;
 257                 }
 258         }
 259
 260         if (isatty(STDIN_FILENO)) {
 261                 (void) fprintf(stderr,
 262                     "Error: Backup stream can not be read "
 263                     "from a terminal.\n"
 264                     "You must redirect standard input.\n");
 265                 exit(1);
 266         }
 267
 268         send_stream = stdin;
 269         while (read_hdr(drr, &zc)) {
 270
 271                 /*
 272                  * If this is the first DMU record being processed, check for
 273                  * the magic bytes and figure out the endian-ness based on them.
 274                  */
 275                 if (first) {
 276                         if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) {
 277                                 do_byteswap = B_TRUE;
 278                                 if (do_cksum) {
 279                                         ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0);
 280                                         /*
 281                                          * recalculate header checksum now
 282                                          * that we know it needs to be
 283                                          * byteswapped.
 284                                          */
 285                                         fletcher_4_incremental_byteswap(drr,
 286                                             sizeof (dmu_replay_record_t), &zc);
 287                                 }
 288                         } else if (drrb->drr_magic != DMU_BACKUP_MAGIC) {
 289                                 (void) fprintf(stderr, "Invalid stream "
 290                                     "(bad magic number)\n");
 291                                 exit(1);
 292                         }
 293                         first = B_FALSE;
 294                 }
 295                 if (do_byteswap) {
 296                         drr->drr_type = BSWAP_32(drr->drr_type);
 297                         drr->drr_payloadlen =
 298                             BSWAP_32(drr->drr_payloadlen);
 299                 }
 300
 301                 /*
 302                  * At this point, the leading fields of the replay record
 303                  * (drr_type and drr_payloadlen) have been byte-swapped if
 304                  * necessary, but the rest of the data structure (the
 305                  * union of type-specific structures) is still in its
 306                  * original state.
 307                  */
 308                 if (drr->drr_type >= DRR_NUMTYPES) {
 309                         (void) printf("INVALID record found: type 0x%x\n",
 310                             drr->drr_type);
 311                         (void) printf("Aborting.\n");
 312                         exit(1);
 313                 }
 314
 315                 drr_record_count[drr->drr_type]++;
 316                 total_records++;
 317
 318                 switch (drr->drr_type) {
 319                 case DRR_BEGIN:
 320                         if (do_byteswap) {
 321                                 drrb->drr_magic = BSWAP_64(drrb->drr_magic);
 322                                 drrb->drr_versioninfo =
 323                                     BSWAP_64(drrb->drr_versioninfo);
 324                                 drrb->drr_creation_time =
 325                                     BSWAP_64(drrb->drr_creation_time);
 326                                 drrb->drr_type = BSWAP_32(drrb->drr_type);
 327                                 drrb->drr_flags = BSWAP_32(drrb->drr_flags);
 328                                 drrb->drr_toguid = BSWAP_64(drrb->drr_toguid);
 329                                 drrb->drr_fromguid =
 330                                     BSWAP_64(drrb->drr_fromguid);
 331                         }
 332
 333                         (void) printf("BEGIN record\n");
 334                         (void) printf("\thdrtype = %lld\n",
 335                             DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo));
 336                         (void) printf("\tfeatures = %llx\n",
 337                             DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo));
 338                         (void) printf("\tmagic = %llx\n",
 339                             (u_longlong_t)drrb->drr_magic);
 340                         (void) printf("\tcreation_time = %llx\n",
 341                             (u_longlong_t)drrb->drr_creation_time);
 342                         (void) printf("\ttype = %u\n", drrb->drr_type);
 343                         (void) printf("\tflags = 0x%x\n", drrb->drr_flags);
 344                         (void) printf("\ttoguid = %llx\n",
 345                             (u_longlong_t)drrb->drr_toguid);
 346                         (void) printf("\tfromguid = %llx\n",
 347                             (u_longlong_t)drrb->drr_fromguid);
 348                         (void) printf("\ttoname = %s\n", drrb->drr_toname);
 349                         if (verbose)
 350                                 (void) printf("\n");
 351
 352                         if (drr->drr_payloadlen != 0) {
 353                                 nvlist_t *nv;
 354                                 int sz = drr->drr_payloadlen;
 355
 356                                 if (sz > SPA_MAXBLOCKSIZE) {
 357                                         free(buf);
 358                                         buf = safe_malloc(sz);
 359                                 }
 360                                 (void) ssread(buf, sz, &zc);
 361                                 if (ferror(send_stream))
 362                                         perror("fread");
 363                                 err = nvlist_unpack(buf, sz, &nv, 0);
 364                                 if (err)
 365                                         perror(strerror(err));
 366                                 nvlist_print(stdout, nv);
 367                                 nvlist_free(nv);
 368                         }
 369                         break;
 370
 371                 case DRR_END:
 372                         if (do_byteswap) {
 373                                 drre->drr_checksum.zc_word[0] =
 374                                     BSWAP_64(drre->drr_checksum.zc_word[0]);
 375                                 drre->drr_checksum.zc_word[1] =
 376                                     BSWAP_64(drre->drr_checksum.zc_word[1]);
 377                                 drre->drr_checksum.zc_word[2] =
 378                                     BSWAP_64(drre->drr_checksum.zc_word[2]);
 379                                 drre->drr_checksum.zc_word[3] =
 380                                     BSWAP_64(drre->drr_checksum.zc_word[3]);
 381                         }
 382                         /*
 383                          * We compare against the *previous* checksum
 384                          * value, because the stored checksum is of
 385                          * everything before the DRR_END record.
 386                          */
 387                         if (do_cksum && !ZIO_CHECKSUM_EQUAL(drre->drr_checksum,
 388                             pcksum)) {
 389                                 (void) printf("Expected checksum differs from "
 390                                     "checksum in stream.\n");
 391                                 (void) printf("Expected checksum = "
 392                                     "%llx/%llx/%llx/%llx\n",
 393                                     (long long unsigned int)pcksum.zc_word[0],
 394                                     (long long unsigned int)pcksum.zc_word[1],
 395                                     (long long unsigned int)pcksum.zc_word[2],
 396                                     (long long unsigned int)pcksum.zc_word[3]);
 397                         }
 398                         (void) printf("END checksum = %llx/%llx/%llx/%llx\n",
 399                             (long long unsigned int)
 400                             drre->drr_checksum.zc_word[0],
 401                             (long long unsigned int)
 402                             drre->drr_checksum.zc_word[1],
 403                             (long long unsigned int)
 404                             drre->drr_checksum.zc_word[2],
 405                             (long long unsigned int)
 406                             drre->drr_checksum.zc_word[3]);
 407
 408                         ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0);
 409                         break;
 410
 411                 case DRR_OBJECT:
 412                         if (do_byteswap) {
 413                                 drro->drr_object = BSWAP_64(drro->drr_object);
 414                                 drro->drr_type = BSWAP_32(drro->drr_type);
 415                                 drro->drr_bonustype =
 416                                     BSWAP_32(drro->drr_bonustype);
 417                                 drro->drr_blksz = BSWAP_32(drro->drr_blksz);
 418                                 drro->drr_bonuslen =
 419                                     BSWAP_32(drro->drr_bonuslen);
 420                                 drro->drr_toguid = BSWAP_64(drro->drr_toguid);
 421                         }
 422                         if (verbose) {
 423                                 (void) printf("OBJECT object = %llu type = %u "
 424                                     "bonustype = %u blksz = %u bonuslen = %u\n",
 425                                     (u_longlong_t)drro->drr_object,
 426                                     drro->drr_type,
 427                                     drro->drr_bonustype,
 428                                     drro->drr_blksz,
 429                                     drro->drr_bonuslen);
 430                         }
 431                         if (drro->drr_bonuslen > 0) {
 432                                 (void) ssread(buf, P2ROUNDUP(drro->drr_bonuslen,
 433                                     8), &zc);
 434                                 if (dump) {
 435                                         print_block(buf,
 436                                             P2ROUNDUP(drro->drr_bonuslen, 8));
 437                                 }
 438                         }
 439                         break;
 440
 441                 case DRR_FREEOBJECTS:
 442                         if (do_byteswap) {
 443                                 drrfo->drr_firstobj =
 444                                     BSWAP_64(drrfo->drr_firstobj);
 445                                 drrfo->drr_numobjs =
 446                                     BSWAP_64(drrfo->drr_numobjs);
 447                                 drrfo->drr_toguid = BSWAP_64(drrfo->drr_toguid);
 448                         }
 449                         if (verbose) {
 450                                 (void) printf("FREEOBJECTS firstobj = %llu "
 451                                     "numobjs = %llu\n",
 452                                     (u_longlong_t)drrfo->drr_firstobj,
 453                                     (u_longlong_t)drrfo->drr_numobjs);
 454                         }
 455                         break;
 456
 457                 case DRR_WRITE:
 458                         if (do_byteswap) {
 459                                 drrw->drr_object = BSWAP_64(drrw->drr_object);
 460                                 drrw->drr_type = BSWAP_32(drrw->drr_type);
 461                                 drrw->drr_offset = BSWAP_64(drrw->drr_offset);
 462                                 drrw->drr_logical_size =
 463                                     BSWAP_64(drrw->drr_logical_size);
 464                                 drrw->drr_toguid = BSWAP_64(drrw->drr_toguid);
 465                                 drrw->drr_key.ddk_prop =
 466                                     BSWAP_64(drrw->drr_key.ddk_prop);
 467                                 drrw->drr_compressed_size =
 468                                     BSWAP_64(drrw->drr_compressed_size);
 469                         }
 470
 471                         uint64_t payload_size = DRR_WRITE_PAYLOAD_SIZE(drrw);
 472
 473                         /*
 474                          * If this is verbose and/or dump output,
 475                          * print info on the modified block
 476                          */
 477                         if (verbose) {
 478                                 (void) printf("WRITE object = %llu type = %u "
 479                                     "checksum type = %u compression type = %u\n"
 480                                     "    offset = %llu logical_size = %llu "
 481                                     "compressed_size = %llu "
 482                                     "payload_size = %llu "
 483                                     "props = %llx\n",
 484                                     (u_longlong_t)drrw->drr_object,
 485                                     drrw->drr_type,
 486                                     drrw->drr_checksumtype,
 487                                     drrw->drr_compressiontype,
 488                                     (u_longlong_t)drrw->drr_offset,
 489                                     (u_longlong_t)drrw->drr_logical_size,
 490                                     (u_longlong_t)drrw->drr_compressed_size,
 491                                     (u_longlong_t)payload_size,
 492                                     (u_longlong_t)drrw->drr_key.ddk_prop);
 493                         }
 494
 495                         /*
 496                          * Read the contents of the block in from STDIN to buf
 497                          */
 498                         (void) ssread(buf, payload_size, &zc);
 499                         /*
 500                          * If in dump mode
 501                          */
 502                         if (dump) {
 503                                 print_block(buf, payload_size);
 504                         }
 505                         total_write_size += payload_size;
 506                         break;
 507
 508                 case DRR_WRITE_BYREF:
 509                         if (do_byteswap) {
 510                                 drrwbr->drr_object =
 511                                     BSWAP_64(drrwbr->drr_object);
 512                                 drrwbr->drr_offset =
 513                                     BSWAP_64(drrwbr->drr_offset);
 514                                 drrwbr->drr_length =
 515                                     BSWAP_64(drrwbr->drr_length);
 516                                 drrwbr->drr_toguid =
 517                                     BSWAP_64(drrwbr->drr_toguid);
 518                                 drrwbr->drr_refguid =
 519                                     BSWAP_64(drrwbr->drr_refguid);
 520                                 drrwbr->drr_refobject =
 521                                     BSWAP_64(drrwbr->drr_refobject);
 522                                 drrwbr->drr_refoffset =
 523                                     BSWAP_64(drrwbr->drr_refoffset);
 524                                 drrwbr->drr_key.ddk_prop =
 525                                     BSWAP_64(drrwbr->drr_key.ddk_prop);
 526                         }
 527                         if (verbose) {
 528                                 (void) printf("WRITE_BYREF object = %llu "
 529                                     "checksum type = %u props = %llx\n"
 530                                     "    offset = %llu length = %llu\n"
 531                                     "toguid = %llx refguid = %llx\n"
 532                                     "    refobject = %llu refoffset = %llu\n",
 533                                     (u_longlong_t)drrwbr->drr_object,
 534                                     drrwbr->drr_checksumtype,
 535                                     (u_longlong_t)drrwbr->drr_key.ddk_prop,
 536                                     (u_longlong_t)drrwbr->drr_offset,
 537                                     (u_longlong_t)drrwbr->drr_length,
 538                                     (u_longlong_t)drrwbr->drr_toguid,
 539                                     (u_longlong_t)drrwbr->drr_refguid,
 540                                     (u_longlong_t)drrwbr->drr_refobject,
 541                                     (u_longlong_t)drrwbr->drr_refoffset);
 542                         }
 543                         break;
 544
 545                 case DRR_FREE:
 546                         if (do_byteswap) {
 547                                 drrf->drr_object = BSWAP_64(drrf->drr_object);
 548                                 drrf->drr_offset = BSWAP_64(drrf->drr_offset);
 549                                 drrf->drr_length = BSWAP_64(drrf->drr_length);
 550                         }
 551                         if (verbose) {
 552                                 (void) printf("FREE object = %llu "
 553                                     "offset = %llu length = %lld\n",
 554                                     (u_longlong_t)drrf->drr_object,
 555                                     (u_longlong_t)drrf->drr_offset,
 556                                     (longlong_t)drrf->drr_length);
 557                         }
 558                         break;
 559                 case DRR_SPILL:
 560                         if (do_byteswap) {
 561                                 drrs->drr_object = BSWAP_64(drrs->drr_object);
 562                                 drrs->drr_length = BSWAP_64(drrs->drr_length);
 563                         }
 564                         if (verbose) {
 565                                 (void) printf("SPILL block for object = %llu "
 566                                     "length = %llu\n",
 567                                     (long long unsigned int)drrs->drr_object,
 568                                     (long long unsigned int)drrs->drr_length);
 569                         }
 570                         (void) ssread(buf, drrs->drr_length, &zc);
 571                         if (dump) {
 572                                 print_block(buf, drrs->drr_length);
 573                         }
 574                         break;
 575                 case DRR_WRITE_EMBEDDED:
 576                         if (do_byteswap) {
 577                                 drrwe->drr_object =
 578                                     BSWAP_64(drrwe->drr_object);
 579                                 drrwe->drr_offset =
 580                                     BSWAP_64(drrwe->drr_offset);
 581                                 drrwe->drr_length =
 582                                     BSWAP_64(drrwe->drr_length);
 583                                 drrwe->drr_toguid =
 584                                     BSWAP_64(drrwe->drr_toguid);
 585                                 drrwe->drr_lsize =
 586                                     BSWAP_32(drrwe->drr_lsize);
 587                                 drrwe->drr_psize =
 588                                     BSWAP_32(drrwe->drr_psize);
 589                         }
 590                         if (verbose) {
 591                                 (void) printf("WRITE_EMBEDDED object = %llu "
 592                                     "offset = %llu length = %llu\n"
 593                                     "    toguid = %llx comp = %u etype = %u "
 594                                     "lsize = %u psize = %u\n",
 595                                     (u_longlong_t)drrwe->drr_object,
 596                                     (u_longlong_t)drrwe->drr_offset,
 597                                     (u_longlong_t)drrwe->drr_length,
 598                                     (u_longlong_t)drrwe->drr_toguid,
 599                                     drrwe->drr_compression,
 600                                     drrwe->drr_etype,
 601                                     drrwe->drr_lsize,
 602                                     drrwe->drr_psize);
 603                         }
 604                         (void) ssread(buf,
 605                             P2ROUNDUP(drrwe->drr_psize, 8), &zc);
 606                         break;
 607                 case DRR_NUMTYPES:
 608                         /* should never be reached */
 609                         exit(1);
 610                 }
 611                 if (drr->drr_type != DRR_BEGIN && very_verbose) {
 612                         (void) printf("    checksum = %llx/%llx/%llx/%llx\n",
 613                             (longlong_t)drrc->drr_checksum.zc_word[0],
 614                             (longlong_t)drrc->drr_checksum.zc_word[1],
 615                             (longlong_t)drrc->drr_checksum.zc_word[2],
 616                             (longlong_t)drrc->drr_checksum.zc_word[3]);
 617                 }
 618                 pcksum = zc;
 619         }
 620         free(buf);
 621
 622         /* Print final summary */
 623
 624         (void) printf("SUMMARY:\n");
 625         (void) printf("\tTotal DRR_BEGIN records = %lld\n",
 626             (u_longlong_t)drr_record_count[DRR_BEGIN]);
 627         (void) printf("\tTotal DRR_END records = %lld\n",
 628             (u_longlong_t)drr_record_count[DRR_END]);
 629         (void) printf("\tTotal DRR_OBJECT records = %lld\n",
 630             (u_longlong_t)drr_record_count[DRR_OBJECT]);
 631         (void) printf("\tTotal DRR_FREEOBJECTS records = %lld\n",
 632             (u_longlong_t)drr_record_count[DRR_FREEOBJECTS]);
 633         (void) printf("\tTotal DRR_WRITE records = %lld\n",
 634             (u_longlong_t)drr_record_count[DRR_WRITE]);
 635         (void) printf("\tTotal DRR_WRITE_BYREF records = %lld\n",
 636             (u_longlong_t)drr_record_count[DRR_WRITE_BYREF]);
 637         (void) printf("\tTotal DRR_WRITE_EMBEDDED records = %lld\n",
 638             (u_longlong_t)drr_record_count[DRR_WRITE_EMBEDDED]);
 639         (void) printf("\tTotal DRR_FREE records = %lld\n",
 640             (u_longlong_t)drr_record_count[DRR_FREE]);
 641         (void) printf("\tTotal DRR_SPILL records = %lld\n",
 642             (u_longlong_t)drr_record_count[DRR_SPILL]);
 643         (void) printf("\tTotal records = %lld\n",
 644             (u_longlong_t)total_records);
 645         (void) printf("\tTotal write size = %lld (0x%llx)\n",
 646             (u_longlong_t)total_write_size, (u_longlong_t)total_write_size);
 647         (void) printf("\tTotal stream length = %lld (0x%llx)\n",
 648             (u_longlong_t)total_stream_len, (u_longlong_t)total_stream_len);
 649         return (0);
 650 }