sbin/fsck_hammer2/test.c

   1 /*
   2  * Copyright (c) 2019 Tomohiro Kusumi <tkusumi@netbsd.org>
   3  * Copyright (c) 2019 The DragonFly Project
   4  * All rights reserved.
   5  *
   6  * This code is derived from software contributed to The DragonFly Project
   7  * by Matthew Dillon <dillon@dragonflybsd.org>
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  * 3. Neither the name of The DragonFly Project nor the names of its
  20  *    contributors may be used to endorse or promote products derived
  21  *    from this software without specific, prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  27  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  31  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  32  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  33  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <sys/tree.h>
  40 #include <sys/queue.h>
  41 #include <sys/ttycom.h>
  42 #include <sys/diskslice.h>
  43 #include <unistd.h>
  44 #include <fcntl.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <stdarg.h>
  48 #include <stdbool.h>
  49 #include <string.h>
  50 #include <assert.h>
  51
  52 #ifdef HAMMER2_USE_OPENSSL
  53 #include <openssl/sha.h>
  54 #endif
  55
  56 #include <vfs/hammer2/hammer2_disk.h>
  57 #include <vfs/hammer2/hammer2_xxhash.h>
  58
  59 #include "hammer2_subs.h"
  60 #include "fsck_hammer2.h"
  61
  62 struct blockref_msg {
  63         TAILQ_ENTRY(blockref_msg) entry;
  64         hammer2_blockref_t bref;
  65         void *msg;
  66 };
  67
  68 TAILQ_HEAD(blockref_list, blockref_msg);
  69
  70 struct blockref_entry {
  71         RB_ENTRY(blockref_entry) entry;
  72         hammer2_off_t data_off;
  73         struct blockref_list head;
  74 };
  75
  76 static int
  77 blockref_cmp(struct blockref_entry *b1, struct blockref_entry *b2)
  78 {
  79         if (b1->data_off < b2->data_off)
  80                 return -1;
  81         if (b1->data_off > b2->data_off)
  82                 return 1;
  83         return 0;
  84 }
  85
  86 RB_HEAD(blockref_tree, blockref_entry);
  87 RB_PROTOTYPE(blockref_tree, blockref_entry, entry, blockref_cmp);
  88 RB_GENERATE(blockref_tree, blockref_entry, entry, blockref_cmp);
  89
  90 typedef struct {
  91         struct blockref_tree root;
  92         uint8_t type; /* HAMMER2_BREF_TYPE_VOLUME or FREEMAP */
  93         uint64_t total_blockref;
  94         uint64_t total_empty;
  95         uint64_t total_bytes;
  96         union {
  97                 /* use volume or freemap depending on type value */
  98                 struct {
  99                         uint64_t total_inode;
 100                         uint64_t total_indirect;
 101                         uint64_t total_data;
 102                         uint64_t total_dirent;
 103                 } volume;
 104                 struct {
 105                         uint64_t total_freemap_node;
 106                         uint64_t total_freemap_leaf;
 107                 } freemap;
 108         };
 109 } blockref_stats_t;
 110
 111 typedef struct {
 112         uint64_t total_blockref;
 113         uint64_t total_empty;
 114         uint64_t total_bytes;
 115         struct {
 116                 uint64_t total_inode;
 117                 uint64_t total_indirect;
 118                 uint64_t total_data;
 119                 uint64_t total_dirent;
 120         } volume;
 121         struct {
 122                 uint64_t total_freemap_node;
 123                 uint64_t total_freemap_leaf;
 124         } freemap;
 125         long count;
 126 } delta_stats_t;
 127
 128 static void print_blockref_entry(struct blockref_tree *);
 129 static void init_blockref_stats(blockref_stats_t *, uint8_t);
 130 static void cleanup_blockref_stats(blockref_stats_t *);
 131 static void init_delta_root(struct blockref_tree *);
 132 static void cleanup_delta_root(struct blockref_tree *);
 133 static void print_blockref_stats(const blockref_stats_t *, bool);
 134 static int verify_volume_header(const hammer2_volume_data_t *);
 135 static int read_media(const hammer2_blockref_t *, hammer2_media_data_t *,
 136     size_t *);
 137 static int verify_blockref(const hammer2_volume_data_t *,
 138     const hammer2_blockref_t *, bool, blockref_stats_t *,
 139     struct blockref_tree *, delta_stats_t *, int, int);
 140 static void print_pfs(const hammer2_inode_data_t *);
 141 static char *get_inode_filename(const hammer2_inode_data_t *);
 142 static int init_pfs_blockref(const hammer2_volume_data_t *,
 143     const hammer2_blockref_t *, struct blockref_list *);
 144 static void cleanup_pfs_blockref(struct blockref_list *);
 145 static void print_media(FILE *, int, const hammer2_blockref_t *,
 146     const hammer2_media_data_t *, size_t);
 147
 148 static int best_zone = -1;
 149
 150 #define TAB 8
 151
 152 static void
 153 tfprintf(FILE *fp, int tab, const char *ctl, ...)
 154 {
 155         va_list va;
 156         int ret;
 157
 158         ret = fprintf(fp, "%*s", tab * TAB, "");
 159         if (ret < 0)
 160                 return;
 161
 162         va_start(va, ctl);
 163         vfprintf(fp, ctl, va);
 164         va_end(va);
 165 }
 166
 167 static void
 168 tsnprintf(char *str, size_t siz, int tab, const char *ctl, ...)
 169 {
 170         va_list va;
 171         int ret;
 172
 173         ret = snprintf(str, siz, "%*s", tab * TAB, "");
 174         if (ret < 0 || ret >= (int)siz)
 175                 return;
 176
 177         va_start(va, ctl);
 178         vsnprintf(str + ret, siz - ret, ctl, va);
 179         va_end(va);
 180 }
 181
 182 static void
 183 tprintf_zone(int tab, int i, const hammer2_blockref_t *bref)
 184 {
 185         tfprintf(stdout, tab, "zone.%d %016jx%s\n",
 186             i, (uintmax_t)bref->data_off,
 187             (!ScanBest && i == best_zone) ? " (best)" : "");
 188 }
 189
 190 static int
 191 init_root_blockref(int i, uint8_t type, hammer2_blockref_t *bref)
 192 {
 193         hammer2_off_t off;
 194
 195         assert(type == HAMMER2_BREF_TYPE_EMPTY ||
 196                 type == HAMMER2_BREF_TYPE_VOLUME ||
 197                 type == HAMMER2_BREF_TYPE_FREEMAP);
 198         memset(bref, 0, sizeof(*bref));
 199         bref->type = type;
 200         bref->data_off = (i * HAMMER2_ZONE_BYTES64) | HAMMER2_PBUFRADIX;
 201         off = bref->data_off & ~HAMMER2_OFF_MASK_RADIX;
 202
 203         return lseek(hammer2_get_root_volume_fd(),
 204             off - hammer2_get_root_volume_offset(), SEEK_SET);
 205 }
 206
 207 static int
 208 find_best_zone(void)
 209 {
 210         hammer2_blockref_t best;
 211         int i, best_i = -1;
 212
 213         memset(&best, 0, sizeof(best));
 214
 215         for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
 216                 hammer2_volume_data_t voldata;
 217                 hammer2_blockref_t broot;
 218                 ssize_t ret;
 219
 220                 if (i * HAMMER2_ZONE_BYTES64 >=
 221                     hammer2_get_root_volume_size())
 222                         break;
 223                 init_root_blockref(i, HAMMER2_BREF_TYPE_EMPTY, &broot);
 224                 ret = read(hammer2_get_root_volume_fd(), &voldata,
 225                     HAMMER2_PBUFSIZE);
 226                 if (ret == HAMMER2_PBUFSIZE) {
 227                         if ((voldata.magic != HAMMER2_VOLUME_ID_HBO) &&
 228                             (voldata.magic != HAMMER2_VOLUME_ID_ABO))
 229                                 continue;
 230                         broot.mirror_tid = voldata.mirror_tid;
 231                         if (best_i < 0 || best.mirror_tid < broot.mirror_tid) {
 232                                 best_i = i;
 233                                 best = broot;
 234                         }
 235                 } else if (ret == -1) {
 236                         perror("read");
 237                         return -1;
 238                 } else {
 239                         tfprintf(stderr, 1, "Failed to read volume header\n");
 240                         return -1;
 241                 }
 242         }
 243
 244         return best_i;
 245 }
 246
 247 static int
 248 test_volume_header(void)
 249 {
 250         bool failed = false;
 251         int i;
 252
 253         for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
 254                 hammer2_volume_data_t voldata;
 255                 hammer2_blockref_t broot;
 256                 ssize_t ret;
 257
 258                 if (ScanBest && i != best_zone)
 259                         continue;
 260                 if (i * HAMMER2_ZONE_BYTES64 >=
 261                     hammer2_get_root_volume_size()) {
 262                         tfprintf(stderr, 0, "zone.%d exceeds volume size\n", i);
 263                         break;
 264                 }
 265                 init_root_blockref(i, HAMMER2_BREF_TYPE_EMPTY, &broot);
 266                 ret = read(hammer2_get_root_volume_fd(), &voldata,
 267                     HAMMER2_PBUFSIZE);
 268                 if (ret == HAMMER2_PBUFSIZE) {
 269                         tprintf_zone(0, i, &broot);
 270                         if (verify_volume_header(&voldata) == -1)
 271                                 failed = true;
 272                 } else if (ret == -1) {
 273                         perror("read");
 274                         return -1;
 275                 } else {
 276                         tfprintf(stderr, 1, "Failed to read volume header\n");
 277                         return -1;
 278                 }
 279         }
 280
 281         return failed ? -1 : 0;
 282 }
 283
 284 static int
 285 test_blockref(uint8_t type)
 286 {
 287         struct blockref_tree droot;
 288         bool failed = false;
 289         int i;
 290
 291         init_delta_root(&droot);
 292         for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
 293                 hammer2_volume_data_t voldata;
 294                 hammer2_blockref_t broot;
 295                 ssize_t ret;
 296
 297                 if (ScanBest && i != best_zone)
 298                         continue;
 299                 if (i * HAMMER2_ZONE_BYTES64 >=
 300                     hammer2_get_root_volume_size()) {
 301                         tfprintf(stderr, 0, "zone.%d exceeds volume size\n", i);
 302                         break;
 303                 }
 304                 init_root_blockref(i, type, &broot);
 305                 ret = read(hammer2_get_root_volume_fd(), &voldata,
 306                     HAMMER2_PBUFSIZE);
 307                 if (ret == HAMMER2_PBUFSIZE) {
 308                         blockref_stats_t bstats;
 309                         init_blockref_stats(&bstats, type);
 310                         delta_stats_t ds;
 311                         memset(&ds, 0, sizeof(ds));
 312                         tprintf_zone(0, i, &broot);
 313                         if (verify_blockref(&voldata, &broot, false, &bstats,
 314                             &droot, &ds, 0, 0) == -1)
 315                                 failed = true;
 316                         print_blockref_stats(&bstats, true);
 317                         print_blockref_entry(&bstats.root);
 318                         cleanup_blockref_stats(&bstats);
 319                 } else if (ret == -1) {
 320                         perror("read");
 321                         failed = true;
 322                         goto end;
 323                 } else {
 324                         tfprintf(stderr, 1, "Failed to read volume header\n");
 325                         failed = true;
 326                         goto end;
 327                 }
 328         }
 329 end:
 330         cleanup_delta_root(&droot);
 331         return failed ? -1 : 0;
 332 }
 333
 334 static int
 335 test_pfs_blockref(void)
 336 {
 337         struct blockref_tree droot;
 338         uint8_t type = HAMMER2_BREF_TYPE_VOLUME;
 339         bool failed = false;
 340         int i;
 341
 342         init_delta_root(&droot);
 343         for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
 344                 hammer2_volume_data_t voldata;
 345                 hammer2_blockref_t broot;
 346                 ssize_t ret;
 347
 348                 if (ScanBest && i != best_zone)
 349                         continue;
 350                 if (i * HAMMER2_ZONE_BYTES64 >=
 351                     hammer2_get_root_volume_size()) {
 352                         tfprintf(stderr, 0, "zone.%d exceeds volume size\n", i);
 353                         break;
 354                 }
 355                 init_root_blockref(i, type, &broot);
 356                 ret = read(hammer2_get_root_volume_fd(), &voldata,
 357                     HAMMER2_PBUFSIZE);
 358                 if (ret == HAMMER2_PBUFSIZE) {
 359                         struct blockref_list blist;
 360                         struct blockref_msg *p;
 361                         int count = 0;
 362
 363                         tprintf_zone(0, i, &broot);
 364                         TAILQ_INIT(&blist);
 365                         if (init_pfs_blockref(&voldata, &broot, &blist) == -1) {
 366                                 tfprintf(stderr, 1, "Failed to read PFS "
 367                                     "blockref\n");
 368                                 failed = true;
 369                                 continue;
 370                         }
 371                         if (TAILQ_EMPTY(&blist)) {
 372                                 tfprintf(stderr, 1, "Failed to find PFS "
 373                                     "blockref\n");
 374                                 failed = true;
 375                                 continue;
 376                         }
 377                         TAILQ_FOREACH(p, &blist, entry) {
 378                                 blockref_stats_t bstats;
 379                                 bool found = false;
 380                                 char *f = get_inode_filename(p->msg);
 381                                 if (NumPFSNames) {
 382                                         int j;
 383                                         for (j = 0; j < NumPFSNames; j++)
 384                                                 if (!strcmp(PFSNames[j], f))
 385                                                         found = true;
 386                                 } else
 387                                         found = true;
 388                                 if (!found) {
 389                                         free(f);
 390                                         continue;
 391                                 }
 392                                 count++;
 393                                 if (PrintPFS) {
 394                                         print_pfs(p->msg);
 395                                         free(f);
 396                                         continue;
 397                                 }
 398                                 tfprintf(stdout, 1, "%s\n", f);
 399                                 free(f);
 400                                 init_blockref_stats(&bstats, type);
 401                                 delta_stats_t ds;
 402                                 memset(&ds, 0, sizeof(ds));
 403                                 if (verify_blockref(&voldata, &p->bref, false,
 404                                     &bstats, &droot, &ds, 0, 0) == -1)
 405                                         failed = true;
 406                                 print_blockref_stats(&bstats, true);
 407                                 print_blockref_entry(&bstats.root);
 408                                 cleanup_blockref_stats(&bstats);
 409                         }
 410                         cleanup_pfs_blockref(&blist);
 411                         if (NumPFSNames && !count) {
 412                                 tfprintf(stderr, 1, "PFS not found\n");
 413                                 failed = true;
 414                         }
 415                 } else if (ret == -1) {
 416                         perror("read");
 417                         failed = true;
 418                         goto end;
 419                 } else {
 420                         tfprintf(stderr, 1, "Failed to read volume header\n");
 421                         failed = true;
 422                         goto end;
 423                 }
 424         }
 425 end:
 426         cleanup_delta_root(&droot);
 427         return failed ? -1 : 0;
 428 }
 429
 430 static int
 431 charsperline(void)
 432 {
 433         int columns;
 434         char *cp;
 435         struct winsize ws;
 436
 437         columns = 0;
 438         if (ioctl(0, TIOCGWINSZ, &ws) != -1)
 439                 columns = ws.ws_col;
 440         if (columns == 0 && (cp = getenv("COLUMNS")))
 441                 columns = atoi(cp);
 442         if (columns == 0)
 443                 columns = 80;   /* last resort */
 444
 445         return columns;
 446 }
 447
 448 static void
 449 cleanup_blockref_msg(struct blockref_list *head)
 450 {
 451         struct blockref_msg *p;
 452
 453         while ((p = TAILQ_FIRST(head)) != NULL) {
 454                 TAILQ_REMOVE(head, p, entry);
 455                 free(p->msg);
 456                 free(p);
 457         }
 458         assert(TAILQ_EMPTY(head));
 459 }
 460
 461 static void
 462 cleanup_blockref_entry(struct blockref_tree *root)
 463 {
 464         struct blockref_entry *e;
 465
 466         while ((e = RB_ROOT(root)) != NULL) {
 467                 RB_REMOVE(blockref_tree, root, e);
 468                 cleanup_blockref_msg(&e->head);
 469                 free(e);
 470         }
 471         assert(RB_EMPTY(root));
 472 }
 473
 474 static void
 475 add_blockref_msg(struct blockref_list *head, const hammer2_blockref_t *bref,
 476     const void *msg, size_t siz)
 477 {
 478         struct blockref_msg *m;
 479         void *p;
 480
 481         m = calloc(1, sizeof(*m));
 482         assert(m);
 483         m->bref = *bref;
 484         p = calloc(1, siz);
 485         assert(p);
 486         memcpy(p, msg, siz);
 487         m->msg = p;
 488
 489         TAILQ_INSERT_TAIL(head, m, entry);
 490 }
 491
 492 static void
 493 add_blockref_entry(struct blockref_tree *root, const hammer2_blockref_t *bref,
 494     const void *msg, size_t siz)
 495 {
 496         struct blockref_entry *e, bref_find;
 497
 498         memset(&bref_find, 0, sizeof(bref_find));
 499         bref_find.data_off = bref->data_off;
 500         e = RB_FIND(blockref_tree, root, &bref_find);
 501         if (!e) {
 502                 e = calloc(1, sizeof(*e));
 503                 assert(e);
 504                 TAILQ_INIT(&e->head);
 505                 e->data_off = bref->data_off;
 506         }
 507
 508         add_blockref_msg(&e->head, bref, msg, siz);
 509
 510         RB_INSERT(blockref_tree, root, e);
 511 }
 512
 513 static void
 514 __print_blockref(FILE *fp, int tab, const hammer2_blockref_t *bref,
 515     const char *msg)
 516 {
 517         tfprintf(fp, tab, "%016jx %-12s %016jx/%-2d%s%s\n",
 518             (uintmax_t)bref->data_off,
 519             hammer2_breftype_to_str(bref->type),
 520             (uintmax_t)bref->key,
 521             bref->keybits,
 522             msg ? " " : "",
 523             msg ? msg : "");
 524 }
 525
 526 static void
 527 print_blockref(FILE *fp, const hammer2_blockref_t *bref, const char *msg)
 528 {
 529         __print_blockref(fp, 1, bref, msg);
 530 }
 531
 532 static void
 533 print_blockref_debug(FILE *fp, int depth, int index,
 534     const hammer2_blockref_t *bref, const char *msg)
 535 {
 536         if (DebugOpt > 1) {
 537                 char buf[256];
 538                 int i;
 539
 540                 memset(buf, 0, sizeof(buf));
 541                 for (i = 0; i < depth * 2; i++)
 542                         strlcat(buf, " ", sizeof(buf));
 543                 tfprintf(fp, 1, buf);
 544                 fprintf(fp, "%-2d %-3d ", depth, index);
 545                 __print_blockref(fp, 0, bref, msg);
 546         } else if (DebugOpt > 0)
 547                 print_blockref(fp, bref, msg);
 548 }
 549
 550 static void
 551 print_blockref_msg(const struct blockref_list *head)
 552 {
 553         struct blockref_msg *m;
 554
 555         TAILQ_FOREACH(m, head, entry) {
 556                 hammer2_blockref_t *bref = &m->bref;
 557                 print_blockref(stderr, bref, m->msg);
 558                 if (VerboseOpt > 0) {
 559                         hammer2_media_data_t media;
 560                         size_t bytes;
 561                         if (!read_media(bref, &media, &bytes))
 562                                 print_media(stderr, 2, bref, &media, bytes);
 563                         else
 564                                 tfprintf(stderr, 2, "Failed to read media\n");
 565                 }
 566         }
 567 }
 568
 569 static void
 570 print_blockref_entry(struct blockref_tree *root)
 571 {
 572         struct blockref_entry *e;
 573
 574         RB_FOREACH(e, blockref_tree, root)
 575                 print_blockref_msg(&e->head);
 576 }
 577
 578 static void
 579 init_blockref_stats(blockref_stats_t *bstats, uint8_t type)
 580 {
 581         memset(bstats, 0, sizeof(*bstats));
 582         RB_INIT(&bstats->root);
 583         bstats->type = type;
 584 }
 585
 586 static void
 587 cleanup_blockref_stats(blockref_stats_t *bstats)
 588 {
 589         cleanup_blockref_entry(&bstats->root);
 590 }
 591
 592 static void
 593 init_delta_root(struct blockref_tree *droot)
 594 {
 595         RB_INIT(droot);
 596 }
 597
 598 static void
 599 cleanup_delta_root(struct blockref_tree *droot)
 600 {
 601         cleanup_blockref_entry(droot);
 602 }
 603
 604 static void
 605 print_blockref_stats(const blockref_stats_t *bstats, bool newline)
 606 {
 607         size_t siz = charsperline();
 608         char *buf = calloc(1, siz);
 609         char emptybuf[128];
 610
 611         assert(buf);
 612
 613         if (CountEmpty)
 614                 snprintf(emptybuf, sizeof(emptybuf), ", %ju empty",
 615                     (uintmax_t)bstats->total_empty);
 616         else
 617                 strlcpy(emptybuf, "", sizeof(emptybuf));
 618
 619         switch (bstats->type) {
 620         case HAMMER2_BREF_TYPE_VOLUME:
 621                 tsnprintf(buf, siz, 1, "%ju blockref (%ju inode, %ju indirect, "
 622                     "%ju data, %ju dirent%s), %s",
 623                     (uintmax_t)bstats->total_blockref,
 624                     (uintmax_t)bstats->volume.total_inode,
 625                     (uintmax_t)bstats->volume.total_indirect,
 626                     (uintmax_t)bstats->volume.total_data,
 627                     (uintmax_t)bstats->volume.total_dirent,
 628                     emptybuf,
 629                     sizetostr(bstats->total_bytes));
 630                 break;
 631         case HAMMER2_BREF_TYPE_FREEMAP:
 632                 tsnprintf(buf, siz, 1, "%ju blockref (%ju node, %ju leaf%s), "
 633                     "%s",
 634                     (uintmax_t)bstats->total_blockref,
 635                     (uintmax_t)bstats->freemap.total_freemap_node,
 636                     (uintmax_t)bstats->freemap.total_freemap_leaf,
 637                     emptybuf,
 638                     sizetostr(bstats->total_bytes));
 639                 break;
 640         default:
 641                 assert(0);
 642                 break;
 643         }
 644
 645         if (newline) {
 646                 printf("%s\n", buf);
 647         } else {
 648                 printf("%s\r", buf);
 649                 fflush(stdout);
 650         }
 651         free(buf);
 652 }
 653
 654 static int
 655 verify_volume_header(const hammer2_volume_data_t *voldata)
 656 {
 657         hammer2_crc32_t crc0, crc1;
 658         const char *p = (const char*)voldata;
 659
 660         if ((voldata->magic != HAMMER2_VOLUME_ID_HBO) &&
 661             (voldata->magic != HAMMER2_VOLUME_ID_ABO)) {
 662                 tfprintf(stderr, 1, "Bad magic %jX\n", voldata->magic);
 663                 return -1;
 664         }
 665
 666         if (voldata->magic == HAMMER2_VOLUME_ID_ABO)
 667                 tfprintf(stderr, 1, "Reverse endian\n");
 668
 669         crc0 = voldata->icrc_sects[HAMMER2_VOL_ICRC_SECT0];
 670         crc1 = hammer2_icrc32(p + HAMMER2_VOLUME_ICRC0_OFF,
 671             HAMMER2_VOLUME_ICRC0_SIZE);
 672         if (crc0 != crc1) {
 673                 tfprintf(stderr, 1, "Bad HAMMER2_VOL_ICRC_SECT0 CRC\n");
 674                 return -1;
 675         }
 676
 677         crc0 = voldata->icrc_sects[HAMMER2_VOL_ICRC_SECT1];
 678         crc1 = hammer2_icrc32(p + HAMMER2_VOLUME_ICRC1_OFF,
 679             HAMMER2_VOLUME_ICRC1_SIZE);
 680         if (crc0 != crc1) {
 681                 tfprintf(stderr, 1, "Bad HAMMER2_VOL_ICRC_SECT1 CRC\n");
 682                 return -1;
 683         }
 684
 685         crc0 = voldata->icrc_volheader;
 686         crc1 = hammer2_icrc32(p + HAMMER2_VOLUME_ICRCVH_OFF,
 687             HAMMER2_VOLUME_ICRCVH_SIZE);
 688         if (crc0 != crc1) {
 689                 tfprintf(stderr, 1, "Bad volume header CRC\n");
 690                 return -1;
 691         }
 692
 693         return 0;
 694 }
 695
 696 static int
 697 read_media(const hammer2_blockref_t *bref, hammer2_media_data_t *media,
 698     size_t *media_bytes)
 699 {
 700         hammer2_off_t io_off, io_base;
 701         size_t bytes, io_bytes, boff;
 702         int fd;
 703
 704         bytes = (bref->data_off & HAMMER2_OFF_MASK_RADIX);
 705         if (bytes)
 706                 bytes = (size_t)1 << bytes;
 707         if (media_bytes)
 708                 *media_bytes = bytes;
 709
 710         if (!bytes)
 711                 return 0;
 712
 713         io_off = bref->data_off & ~HAMMER2_OFF_MASK_RADIX;
 714         io_base = io_off & ~(hammer2_off_t)(HAMMER2_LBUFSIZE - 1);
 715         boff = io_off - io_base;
 716
 717         io_bytes = HAMMER2_LBUFSIZE;
 718         while (io_bytes + boff < bytes)
 719                 io_bytes <<= 1;
 720
 721         if (io_bytes > sizeof(*media))
 722                 return -1;
 723         fd = hammer2_get_volume_fd(io_off);
 724         if (lseek(fd, io_base - hammer2_get_volume_offset(io_base), SEEK_SET)
 725             == -1)
 726                 return -2;
 727         if (read(fd, media, io_bytes) != (ssize_t)io_bytes)
 728                 return -2;
 729         if (boff)
 730                 memmove(media, (char *)media + boff, bytes);
 731
 732         return 0;
 733 }
 734
 735 static void
 736 load_delta_stats(blockref_stats_t *bstats, const delta_stats_t *dstats)
 737 {
 738         bstats->total_blockref += dstats->total_blockref;
 739         bstats->total_empty += dstats->total_empty;
 740         bstats->total_bytes += dstats->total_bytes;
 741
 742         switch (bstats->type) {
 743         case HAMMER2_BREF_TYPE_VOLUME:
 744                 bstats->volume.total_inode += dstats->volume.total_inode;
 745                 bstats->volume.total_indirect += dstats->volume.total_indirect;
 746                 bstats->volume.total_data += dstats->volume.total_data;
 747                 bstats->volume.total_dirent += dstats->volume.total_dirent;
 748                 break;
 749         case HAMMER2_BREF_TYPE_FREEMAP:
 750                 bstats->freemap.total_freemap_node +=
 751                     dstats->freemap.total_freemap_node;
 752                 bstats->freemap.total_freemap_leaf +=
 753                     dstats->freemap.total_freemap_leaf;
 754                 break;
 755         default:
 756                 assert(0);
 757                 break;
 758         }
 759 }
 760
 761 static void
 762 accumulate_delta_stats(delta_stats_t *dst, const delta_stats_t *src)
 763 {
 764         dst->total_blockref += src->total_blockref;
 765         dst->total_empty += src->total_empty;
 766         dst->total_bytes += src->total_bytes;
 767
 768         dst->volume.total_inode += src->volume.total_inode;
 769         dst->volume.total_indirect += src->volume.total_indirect;
 770         dst->volume.total_data += src->volume.total_data;
 771         dst->volume.total_dirent += src->volume.total_dirent;
 772
 773         dst->freemap.total_freemap_node += src->freemap.total_freemap_node;
 774         dst->freemap.total_freemap_leaf += src->freemap.total_freemap_leaf;
 775
 776         dst->count += src->count;
 777 }
 778
 779 static int
 780 verify_blockref(const hammer2_volume_data_t *voldata,
 781     const hammer2_blockref_t *bref, bool norecurse, blockref_stats_t *bstats,
 782     struct blockref_tree *droot, delta_stats_t *dstats, int depth, int index)
 783 {
 784         hammer2_media_data_t media;
 785         hammer2_blockref_t *bscan;
 786         int i, bcount;
 787         bool failed = false;
 788         size_t bytes;
 789         uint32_t cv;
 790         uint64_t cv64;
 791         char msg[256];
 792 #ifdef HAMMER2_USE_OPENSSL
 793         SHA256_CTX hash_ctx;
 794         union {
 795                 uint8_t digest[SHA256_DIGEST_LENGTH];
 796                 uint64_t digest64[SHA256_DIGEST_LENGTH/8];
 797         } u;
 798 #endif
 799         /* only for DebugOpt > 1 */
 800         if (DebugOpt > 1)
 801                 print_blockref_debug(stdout, depth, index, bref, NULL);
 802
 803         if (bref->data_off) {
 804                 struct blockref_entry *e, bref_find;
 805                 memset(&bref_find, 0, sizeof(bref_find));
 806                 bref_find.data_off = bref->data_off;
 807                 e = RB_FIND(blockref_tree, droot, &bref_find);
 808                 if (e) {
 809                         struct blockref_msg *m;
 810                         TAILQ_FOREACH(m, &e->head, entry) {
 811                                 delta_stats_t *ds = m->msg;
 812                                 if (!memcmp(&m->bref, bref, sizeof(*bref))) {
 813                                         /* delta contains cached delta */
 814                                         accumulate_delta_stats(dstats, ds);
 815                                         load_delta_stats(bstats, ds);
 816                                         print_blockref_debug(stdout, depth,
 817                                             index, &m->bref, "cache-hit");
 818                                         return 0;
 819                                 }
 820                         }
 821                 }
 822         }
 823
 824         bstats->total_blockref++;
 825         dstats->total_blockref++;
 826
 827         switch (bref->type) {
 828         case HAMMER2_BREF_TYPE_EMPTY:
 829                 if (CountEmpty) {
 830                         bstats->total_empty++;
 831                         dstats->total_empty++;
 832                 } else {
 833                         bstats->total_blockref--;
 834                         dstats->total_blockref--;
 835                 }
 836                 break;
 837         case HAMMER2_BREF_TYPE_INODE:
 838                 bstats->volume.total_inode++;
 839                 dstats->volume.total_inode++;
 840                 break;
 841         case HAMMER2_BREF_TYPE_INDIRECT:
 842                 bstats->volume.total_indirect++;
 843                 dstats->volume.total_indirect++;
 844                 break;
 845         case HAMMER2_BREF_TYPE_DATA:
 846                 bstats->volume.total_data++;
 847                 dstats->volume.total_data++;
 848                 break;
 849         case HAMMER2_BREF_TYPE_DIRENT:
 850                 bstats->volume.total_dirent++;
 851                 dstats->volume.total_dirent++;
 852                 break;
 853         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
 854                 bstats->freemap.total_freemap_node++;
 855                 dstats->freemap.total_freemap_node++;
 856                 break;
 857         case HAMMER2_BREF_TYPE_FREEMAP_LEAF:
 858                 bstats->freemap.total_freemap_leaf++;
 859                 dstats->freemap.total_freemap_leaf++;
 860                 break;
 861         case HAMMER2_BREF_TYPE_VOLUME:
 862                 bstats->total_blockref--;
 863                 dstats->total_blockref--;
 864                 break;
 865         case HAMMER2_BREF_TYPE_FREEMAP:
 866                 bstats->total_blockref--;
 867                 dstats->total_blockref--;
 868                 break;
 869         default:
 870                 snprintf(msg, sizeof(msg), "Invalid blockref type %d",
 871                     bref->type);
 872                 add_blockref_entry(&bstats->root, bref, msg, strlen(msg) + 1);
 873                 print_blockref_debug(stdout, depth, index, bref, msg);
 874                 failed = true;
 875                 break;
 876         }
 877
 878         switch (read_media(bref, &media, &bytes)) {
 879         case -1:
 880                 strlcpy(msg, "Bad I/O bytes", sizeof(msg));
 881                 add_blockref_entry(&bstats->root, bref, msg, strlen(msg) + 1);
 882                 print_blockref_debug(stdout, depth, index, bref, msg);
 883                 return -1;
 884         case -2:
 885                 strlcpy(msg, "Failed to read media", sizeof(msg));
 886                 add_blockref_entry(&bstats->root, bref, msg, strlen(msg) + 1);
 887                 print_blockref_debug(stdout, depth, index, bref, msg);
 888                 return -1;
 889         default:
 890                 break;
 891         }
 892
 893         if (bref->type != HAMMER2_BREF_TYPE_VOLUME &&
 894             bref->type != HAMMER2_BREF_TYPE_FREEMAP) {
 895                 bstats->total_bytes += bytes;
 896                 dstats->total_bytes += bytes;
 897         }
 898
 899         if (!CountEmpty && bref->type == HAMMER2_BREF_TYPE_EMPTY) {
 900                 assert(bytes == 0);
 901                 bstats->total_bytes -= bytes;
 902                 dstats->total_bytes -= bytes;
 903         }
 904
 905         if (!DebugOpt && QuietOpt <= 0 && (bstats->total_blockref % 100) == 0)
 906                 print_blockref_stats(bstats, false);
 907
 908         if (!bytes)
 909                 goto end;
 910
 911         switch (HAMMER2_DEC_CHECK(bref->methods)) {
 912         case HAMMER2_CHECK_ISCSI32:
 913                 cv = hammer2_icrc32(&media, bytes);
 914                 if (bref->check.iscsi32.value != cv) {
 915                         strlcpy(msg, "Bad HAMMER2_CHECK_ISCSI32", sizeof(msg));
 916                         add_blockref_entry(&bstats->root, bref, msg,
 917                             strlen(msg) + 1);
 918                         print_blockref_debug(stdout, depth, index, bref, msg);
 919                         failed = true;
 920                 }
 921                 break;
 922         case HAMMER2_CHECK_XXHASH64:
 923                 cv64 = XXH64(&media, bytes, XXH_HAMMER2_SEED);
 924                 if (bref->check.xxhash64.value != cv64) {
 925                         strlcpy(msg, "Bad HAMMER2_CHECK_XXHASH64", sizeof(msg));
 926                         add_blockref_entry(&bstats->root, bref, msg,
 927                             strlen(msg) + 1);
 928                         print_blockref_debug(stdout, depth, index, bref, msg);
 929                         failed = true;
 930                 }
 931                 break;
 932         case HAMMER2_CHECK_SHA192:
 933 #ifdef HAMMER2_USE_OPENSSL
 934                 SHA256_Init(&hash_ctx);
 935                 SHA256_Update(&hash_ctx, &media, bytes);
 936                 SHA256_Final(u.digest, &hash_ctx);
 937                 u.digest64[2] ^= u.digest64[3];
 938                 if (memcmp(u.digest, bref->check.sha192.data,
 939                     sizeof(bref->check.sha192.data))) {
 940                         strlcpy(msg, "Bad HAMMER2_CHECK_SHA192", sizeof(msg));
 941                         add_blockref_entry(&bstats->root, bref, msg,
 942                             strlen(msg) + 1);
 943                         print_blockref_debug(stdout, depth, index, bref, msg);
 944                         failed = true;
 945                 }
 946 #endif
 947                 break;
 948         case HAMMER2_CHECK_FREEMAP:
 949                 cv = hammer2_icrc32(&media, bytes);
 950                 if (bref->check.freemap.icrc32 != cv) {
 951                         strlcpy(msg, "Bad HAMMER2_CHECK_FREEMAP", sizeof(msg));
 952                         add_blockref_entry(&bstats->root, bref, msg,
 953                             strlen(msg) + 1);
 954                         print_blockref_debug(stdout, depth, index, bref, msg);
 955                         failed = true;
 956                 }
 957                 break;
 958         }
 959
 960         switch (bref->type) {
 961         case HAMMER2_BREF_TYPE_INODE:
 962                 if (!(media.ipdata.meta.op_flags & HAMMER2_OPFLAG_DIRECTDATA)) {
 963                         bscan = &media.ipdata.u.blockset.blockref[0];
 964                         bcount = HAMMER2_SET_COUNT;
 965                 } else {
 966                         bscan = NULL;
 967                         bcount = 0;
 968                 }
 969                 break;
 970         case HAMMER2_BREF_TYPE_INDIRECT:
 971                 bscan = &media.npdata[0];
 972                 bcount = bytes / sizeof(hammer2_blockref_t);
 973                 break;
 974         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
 975                 bscan = &media.npdata[0];
 976                 bcount = bytes / sizeof(hammer2_blockref_t);
 977                 break;
 978         case HAMMER2_BREF_TYPE_VOLUME:
 979                 bscan = &media.voldata.sroot_blockset.blockref[0];
 980                 bcount = HAMMER2_SET_COUNT;
 981                 break;
 982         case HAMMER2_BREF_TYPE_FREEMAP:
 983                 bscan = &media.voldata.freemap_blockset.blockref[0];
 984                 bcount = HAMMER2_SET_COUNT;
 985                 break;
 986         default:
 987                 bscan = NULL;
 988                 bcount = 0;
 989                 break;
 990         }
 991
 992         if (ForceOpt)
 993                 norecurse = false;
 994         /*
 995          * If failed, no recurse, but still verify its direct children.
 996          * Beyond that is probably garbage.
 997          */
 998         for (i = 0; norecurse == false && i < bcount; ++i) {
 999                 delta_stats_t ds;
1000                 memset(&ds, 0, sizeof(ds));
1001                 if (verify_blockref(voldata, &bscan[i], failed, bstats, droot,
1002                     &ds, depth + 1, i) == -1)
1003                         return -1;
1004                 if (!failed)
1005                         accumulate_delta_stats(dstats, &ds);
1006         }
1007 end:
1008         if (failed)
1009                 return -1;
1010
1011         dstats->count++;
1012         if (bref->data_off && BlockrefCacheCount > 0 &&
1013             dstats->count >= BlockrefCacheCount) {
1014                 assert(bytes);
1015                 add_blockref_entry(droot, bref, dstats, sizeof(*dstats));
1016                 print_blockref_debug(stdout, depth, index, bref, "cache-add");
1017         }
1018
1019         return 0;
1020 }
1021
1022 static void
1023 print_pfs(const hammer2_inode_data_t *ipdata)
1024 {
1025         const hammer2_inode_meta_t *meta = &ipdata->meta;
1026         char *f, *pfs_id_str = NULL;
1027         const char *type_str;
1028         uuid_t uuid;
1029
1030         f = get_inode_filename(ipdata);
1031         uuid = meta->pfs_clid;
1032         hammer2_uuid_to_str(&uuid, &pfs_id_str);
1033         if (meta->pfs_type == HAMMER2_PFSTYPE_MASTER) {
1034                 if (meta->pfs_subtype == HAMMER2_PFSSUBTYPE_NONE)
1035                         type_str = "MASTER";
1036                 else
1037                         type_str = hammer2_pfssubtype_to_str(meta->pfs_subtype);
1038         } else {
1039                 type_str = hammer2_pfstype_to_str(meta->pfs_type);
1040         }
1041         tfprintf(stdout, 1, "%-11s %s %s\n", type_str, pfs_id_str, f);
1042
1043         free(f);
1044         free(pfs_id_str);
1045 }
1046
1047 static char*
1048 get_inode_filename(const hammer2_inode_data_t *ipdata)
1049 {
1050         char *p = malloc(HAMMER2_INODE_MAXNAME + 1);
1051
1052         memcpy(p, ipdata->filename, sizeof(ipdata->filename));
1053         p[HAMMER2_INODE_MAXNAME] = '\0';
1054
1055         return p;
1056 }
1057
1058 static void
1059 __add_pfs_blockref(const hammer2_blockref_t *bref, struct blockref_list *blist,
1060     const hammer2_inode_data_t *ipdata)
1061 {
1062         struct blockref_msg *newp, *p;
1063
1064         newp = calloc(1, sizeof(*newp));
1065         newp->bref = *bref;
1066         newp->msg = calloc(1, sizeof(*ipdata));
1067         memcpy(newp->msg, ipdata, sizeof(*ipdata));
1068
1069         p = TAILQ_FIRST(blist);
1070         while (p) {
1071                 char *f1 = get_inode_filename(newp->msg);
1072                 char *f2 = get_inode_filename(p->msg);
1073                 if (strcmp(f1, f2) <= 0) {
1074                         TAILQ_INSERT_BEFORE(p, newp, entry);
1075                         free(f1);
1076                         free(f2);
1077                         break;
1078                 }
1079                 p = TAILQ_NEXT(p, entry);
1080                 free(f1);
1081                 free(f2);
1082         }
1083         if (!p)
1084                 TAILQ_INSERT_TAIL(blist, newp, entry);
1085 }
1086
1087 static int
1088 init_pfs_blockref(const hammer2_volume_data_t *voldata,
1089     const hammer2_blockref_t *bref, struct blockref_list *blist)
1090 {
1091         hammer2_media_data_t media;
1092         hammer2_inode_data_t ipdata;
1093         hammer2_blockref_t *bscan;
1094         int i, bcount;
1095         size_t bytes;
1096
1097         if (read_media(bref, &media, &bytes))
1098                 return -1;
1099         if (!bytes)
1100                 return 0;
1101
1102         switch (bref->type) {
1103         case HAMMER2_BREF_TYPE_INODE:
1104                 ipdata = media.ipdata;
1105                 if (ipdata.meta.pfs_type == HAMMER2_PFSTYPE_SUPROOT) {
1106                         bscan = &ipdata.u.blockset.blockref[0];
1107                         bcount = HAMMER2_SET_COUNT;
1108                 } else {
1109                         bscan = NULL;
1110                         bcount = 0;
1111                         if (ipdata.meta.op_flags & HAMMER2_OPFLAG_PFSROOT)
1112                                 __add_pfs_blockref(bref, blist, &ipdata);
1113                         else
1114                                 assert(0); /* should only see SUPROOT or PFS */
1115                 }
1116                 break;
1117         case HAMMER2_BREF_TYPE_INDIRECT:
1118                 bscan = &media.npdata[0];
1119                 bcount = bytes / sizeof(hammer2_blockref_t);
1120                 break;
1121         case HAMMER2_BREF_TYPE_VOLUME:
1122                 bscan = &media.voldata.sroot_blockset.blockref[0];
1123                 bcount = HAMMER2_SET_COUNT;
1124                 break;
1125         default:
1126                 bscan = NULL;
1127                 bcount = 0;
1128                 break;
1129         }
1130
1131         for (i = 0; i < bcount; ++i)
1132                 if (init_pfs_blockref(voldata, &bscan[i], blist) == -1)
1133                         return -1;
1134         return 0;
1135 }
1136
1137 static void
1138 cleanup_pfs_blockref(struct blockref_list *blist)
1139 {
1140         cleanup_blockref_msg(blist);
1141 }
1142
1143 static void
1144 print_media(FILE *fp, int tab, const hammer2_blockref_t *bref,
1145     const hammer2_media_data_t *media, size_t media_bytes)
1146 {
1147         const hammer2_blockref_t *bscan;
1148         const hammer2_inode_data_t *ipdata;
1149         int i, bcount, namelen;
1150         char *str = NULL;
1151         uuid_t uuid;
1152
1153         switch (bref->type) {
1154         case HAMMER2_BREF_TYPE_INODE:
1155                 ipdata = &media->ipdata;
1156                 namelen = ipdata->meta.name_len;
1157                 if (namelen > HAMMER2_INODE_MAXNAME)
1158                         namelen = 0;
1159                 tfprintf(fp, tab, "filename \"%*.*s\"\n", namelen, namelen,
1160                     ipdata->filename);
1161                 tfprintf(fp, tab, "version %d\n", ipdata->meta.version);
1162                 if ((ipdata->meta.op_flags & HAMMER2_OPFLAG_PFSROOT) ||
1163                     ipdata->meta.pfs_type == HAMMER2_PFSTYPE_SUPROOT)
1164                         tfprintf(fp, tab, "pfs_subtype %d (%s)\n",
1165                             ipdata->meta.pfs_subtype,
1166                             hammer2_pfssubtype_to_str(ipdata->meta.pfs_subtype));
1167                 tfprintf(fp, tab, "uflags 0x%08x\n", ipdata->meta.uflags);
1168                 if (ipdata->meta.rmajor || ipdata->meta.rminor) {
1169                         tfprintf(fp, tab, "rmajor %d\n", ipdata->meta.rmajor);
1170                         tfprintf(fp, tab, "rminor %d\n", ipdata->meta.rminor);
1171                 }
1172                 tfprintf(fp, tab, "ctime %s\n",
1173                     hammer2_time64_to_str(ipdata->meta.ctime, &str));
1174                 tfprintf(fp, tab, "mtime %s\n",
1175                     hammer2_time64_to_str(ipdata->meta.mtime, &str));
1176                 tfprintf(fp, tab, "atime %s\n",
1177                     hammer2_time64_to_str(ipdata->meta.atime, &str));
1178                 tfprintf(fp, tab, "btime %s\n",
1179                     hammer2_time64_to_str(ipdata->meta.btime, &str));
1180                 uuid = ipdata->meta.uid;
1181                 tfprintf(fp, tab, "uid %s\n", hammer2_uuid_to_str(&uuid, &str));
1182                 uuid = ipdata->meta.gid;
1183                 tfprintf(fp, tab, "gid %s\n", hammer2_uuid_to_str(&uuid, &str));
1184                 tfprintf(fp, tab, "type %s\n",
1185                     hammer2_iptype_to_str(ipdata->meta.type));
1186                 tfprintf(fp, tab, "op_flags 0x%02x\n", ipdata->meta.op_flags);
1187                 tfprintf(fp, tab, "cap_flags 0x%04x\n", ipdata->meta.cap_flags);
1188                 tfprintf(fp, tab, "mode %-7o\n", ipdata->meta.mode);
1189                 tfprintf(fp, tab, "inum 0x%016jx\n", ipdata->meta.inum);
1190                 tfprintf(fp, tab, "size %ju ", (uintmax_t)ipdata->meta.size);
1191                 if (ipdata->meta.op_flags & HAMMER2_OPFLAG_DIRECTDATA &&
1192                     ipdata->meta.size <= HAMMER2_EMBEDDED_BYTES)
1193                         printf("(embedded data)\n");
1194                 else
1195                         printf("\n");
1196                 tfprintf(fp, tab, "nlinks %ju\n",
1197                     (uintmax_t)ipdata->meta.nlinks);
1198                 tfprintf(fp, tab, "iparent 0x%016jx\n",
1199                     (uintmax_t)ipdata->meta.iparent);
1200                 tfprintf(fp, tab, "name_key 0x%016jx\n",
1201                     (uintmax_t)ipdata->meta.name_key);
1202                 tfprintf(fp, tab, "name_len %u\n", ipdata->meta.name_len);
1203                 tfprintf(fp, tab, "ncopies %u\n", ipdata->meta.ncopies);
1204                 tfprintf(fp, tab, "comp_algo %u\n", ipdata->meta.comp_algo);
1205                 tfprintf(fp, tab, "target_type %u\n", ipdata->meta.target_type);
1206                 tfprintf(fp, tab, "check_algo %u\n", ipdata->meta.check_algo);
1207                 if ((ipdata->meta.op_flags & HAMMER2_OPFLAG_PFSROOT) ||
1208                     ipdata->meta.pfs_type == HAMMER2_PFSTYPE_SUPROOT) {
1209                         tfprintf(fp, tab, "pfs_nmasters %u\n",
1210                             ipdata->meta.pfs_nmasters);
1211                         tfprintf(fp, tab, "pfs_type %u (%s)\n",
1212                             ipdata->meta.pfs_type,
1213                             hammer2_pfstype_to_str(ipdata->meta.pfs_type));
1214                         tfprintf(fp, tab, "pfs_inum 0x%016jx\n",
1215                             (uintmax_t)ipdata->meta.pfs_inum);
1216                         uuid = ipdata->meta.pfs_clid;
1217                         tfprintf(fp, tab, "pfs_clid %s\n",
1218                             hammer2_uuid_to_str(&uuid, &str));
1219                         uuid = ipdata->meta.pfs_fsid;
1220                         tfprintf(fp, tab, "pfs_fsid %s\n",
1221                             hammer2_uuid_to_str(&uuid, &str));
1222                         tfprintf(fp, tab, "pfs_lsnap_tid 0x%016jx\n",
1223                             (uintmax_t)ipdata->meta.pfs_lsnap_tid);
1224                 }
1225                 tfprintf(fp, tab, "data_quota %ju\n",
1226                     (uintmax_t)ipdata->meta.data_quota);
1227                 tfprintf(fp, tab, "data_count %ju\n",
1228                     (uintmax_t)bref->embed.stats.data_count);
1229                 tfprintf(fp, tab, "inode_quota %ju\n",
1230                     (uintmax_t)ipdata->meta.inode_quota);
1231                 tfprintf(fp, tab, "inode_count %ju\n",
1232                     (uintmax_t)bref->embed.stats.inode_count);
1233                 break;
1234         case HAMMER2_BREF_TYPE_INDIRECT:
1235                 bcount = media_bytes / sizeof(hammer2_blockref_t);
1236                 for (i = 0; i < bcount; ++i) {
1237                         bscan = &media->npdata[i];
1238                         tfprintf(fp, tab, "%3d %016jx %-12s %016jx/%-2d\n",
1239                             i, (uintmax_t)bscan->data_off,
1240                             hammer2_breftype_to_str(bscan->type),
1241                             (uintmax_t)bscan->key,
1242                             bscan->keybits);
1243                 }
1244                 break;
1245         case HAMMER2_BREF_TYPE_DIRENT:
1246                 if (bref->embed.dirent.namlen <= sizeof(bref->check.buf)) {
1247                         tfprintf(fp, tab, "filename \"%*.*s\"\n",
1248                             bref->embed.dirent.namlen,
1249                             bref->embed.dirent.namlen,
1250                             bref->check.buf);
1251                 } else {
1252                         tfprintf(fp, tab, "filename \"%*.*s\"\n",
1253                             bref->embed.dirent.namlen,
1254                             bref->embed.dirent.namlen,
1255                             media->buf);
1256                 }
1257                 tfprintf(fp, tab, "inum 0x%016jx\n",
1258                     (uintmax_t)bref->embed.dirent.inum);
1259                 tfprintf(fp, tab, "namlen %d\n",
1260                     (uintmax_t)bref->embed.dirent.namlen);
1261                 tfprintf(fp, tab, "type %s\n",
1262                     hammer2_iptype_to_str(bref->embed.dirent.type));
1263                 break;
1264         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
1265                 bcount = media_bytes / sizeof(hammer2_blockref_t);
1266                 for (i = 0; i < bcount; ++i) {
1267                         bscan = &media->npdata[i];
1268                         tfprintf(fp, tab, "%3d %016jx %-12s %016jx/%-2d\n",
1269                             i, (uintmax_t)bscan->data_off,
1270                             hammer2_breftype_to_str(bscan->type),
1271                             (uintmax_t)bscan->key,
1272                             bscan->keybits);
1273                 }
1274                 break;
1275         case HAMMER2_BREF_TYPE_FREEMAP_LEAF:
1276                 for (i = 0; i < HAMMER2_FREEMAP_COUNT; ++i) {
1277                         hammer2_off_t data_off = bref->key +
1278                                 i * HAMMER2_FREEMAP_LEVEL0_SIZE;
1279 #if HAMMER2_BMAP_ELEMENTS != 8
1280 #error "HAMMER2_BMAP_ELEMENTS != 8"
1281 #endif
1282                         tfprintf(fp, tab, "%016jx %04d.%04x (avail=%7d) "
1283                             "%016jx %016jx %016jx %016jx "
1284                             "%016jx %016jx %016jx %016jx\n",
1285                             data_off, i, media->bmdata[i].class,
1286                             media->bmdata[i].avail,
1287                             media->bmdata[i].bitmapq[0],
1288                             media->bmdata[i].bitmapq[1],
1289                             media->bmdata[i].bitmapq[2],
1290                             media->bmdata[i].bitmapq[3],
1291                             media->bmdata[i].bitmapq[4],
1292                             media->bmdata[i].bitmapq[5],
1293                             media->bmdata[i].bitmapq[6],
1294                             media->bmdata[i].bitmapq[7]);
1295                 }
1296                 break;
1297         default:
1298                 break;
1299         }
1300         if (str)
1301                 free(str);
1302 }
1303
1304 int
1305 test_hammer2(const char *devpath)
1306 {
1307         bool failed = false;
1308
1309         hammer2_init_volumes(devpath, 1);
1310
1311         best_zone = find_best_zone();
1312         if (best_zone == -1)
1313                 fprintf(stderr, "Failed to find best zone\n");
1314
1315         if (PrintPFS) {
1316                 if (test_pfs_blockref() == -1)
1317                         failed = true;
1318                 goto end; /* print PFS info and exit */
1319         }
1320
1321         printf("volume header\n");
1322         if (test_volume_header() == -1) {
1323                 failed = true;
1324                 if (!ForceOpt)
1325                         goto end;
1326         }
1327
1328         printf("freemap\n");
1329         if (test_blockref(HAMMER2_BREF_TYPE_FREEMAP) == -1) {
1330                 failed = true;
1331                 if (!ForceOpt)
1332                         goto end;
1333         }
1334         printf("volume\n");
1335         if (!ScanPFS) {
1336                 if (test_blockref(HAMMER2_BREF_TYPE_VOLUME) == -1) {
1337                         failed = true;
1338                         if (!ForceOpt)
1339                                 goto end;
1340                 }
1341         } else {
1342                 if (test_pfs_blockref() == -1) {
1343                         failed = true;
1344                         if (!ForceOpt)
1345                                 goto end;
1346                 }
1347         }
1348 end:
1349         hammer2_cleanup_volumes();
1350
1351         return failed ? -1 : 0;
1352 }