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