src/tviced/state_analyzer.c

   1 /*
   2  * Copyright 2006, Sine Nomine Associates and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * demand attach fs
  12  * fileserver state serialization
  13  *
  14  * state analyzer
  15  */
  16
  17 #include <afsconfig.h>
  18 #include <afs/param.h>
  19
  20 RCSID
  21     ("$Header$");
  22
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <sys/file.h>
  26 #include <netdb.h>
  27 #include <netinet/in.h>
  28 #include <time.h>
  29
  30 #ifdef HAVE_STRING_H
  31 #include <string.h>
  32 #else
  33 #ifdef HAVE_STRINGS_H
  34 #include <strings.h>
  35 #endif
  36 #endif
  37
  38 #include <afs/stds.h>
  39 #include <rx/xdr.h>
  40 #include <afs/assert.h>
  41 #include <lwp.h>
  42 #include <lock.h>
  43 #include <afs/afsint.h>
  44 #include <afs/rxgen_consts.h>
  45 #include <afs/nfs.h>
  46 #include <afs/errors.h>
  47 #include <afs/ihandle.h>
  48 #include <afs/vnode.h>
  49 #include <afs/volume.h>
  50 #ifdef AFS_ATHENA_STDENV
  51 #include <krb.h>
  52 #endif
  53 #include <afs/acl.h>
  54 #include <afs/ptclient.h>
  55 #include <afs/prs_fs.h>
  56 #include <afs/auth.h>
  57 #include <afs/afsutil.h>
  58 #include <rx/rx.h>
  59 #include <afs/cellconfig.h>
  60 #include <stdlib.h>
  61 #include "../util/afsutil_prototypes.h"
  62 #include "../viced/viced.h"
  63 #include "../viced/host.h"
  64 #include "../viced/callback.h"
  65 #include "serialize_state.h"
  66 #include <fcntl.h>
  67 #include <sys/types.h>
  68 #include <sys/stat.h>
  69 #include <sys/mman.h>
  70 #include <unistd.h>
  71
  72 /*@+fcnmacros +macrofcndecl@*/
  73 #ifdef O_LARGEFILE
  74 #ifdef S_SPLINT_S
  75 extern off64_t afs_lseek(int FD, off64_t O, int F);
  76 #endif /*S_SPLINT_S */
  77 #define afs_lseek(FD, O, F)     lseek64(FD, (off64_t)(O), F)
  78 #define afs_stat                stat64
  79 #define afs_fstat               fstat64
  80 #define afs_open                open64
  81 #define afs_fopen               fopen64
  82 #define afs_mmap                mmap64
  83 #ifdef AFS_AIX_ENV
  84 extern void * mmap64();  /* ugly hack since aix build env appears to be somewhat broken */
  85 #endif
  86 #else /* !O_LARGEFILE */
  87 #ifdef S_SPLINT_S
  88 extern off_t afs_lseek(int FD, off_t O, int F);
  89 #endif /*S_SPLINT_S */
  90 #define afs_lseek(FD, O, F)     lseek(FD, (off_t)(O), F)
  91 #define afs_stat                stat
  92 #define afs_fstat               fstat
  93 #define afs_open                open
  94 #define afs_fopen               fopen
  95 #define afs_mmap                mmap
  96 #endif /* !O_LARGEFILE */
  97 /*@=fcnmacros =macrofcndecl@*/
  98
  99
 100 #ifndef AFS_DEMAND_ATTACH_FS
 101 int
 102 main (int argc, char ** argv)
 103 {
 104     fprintf(stderr, "%s is only supported for demand attach fileservers\n",
 105             argv[0] ? argv[0] : "state analyzer");
 106     return 1;
 107 }
 108 #else /* AFS_DEMAND_ATTACH_FS */
 109
 110 static void usage(char * prog);
 111 static int openFile(char * path);
 112 static void initState(void);
 113
 114 static void banner(void);
 115 static void prompt(void);
 116
 117 static void print_help(void);
 118 static void print_global_help(void);
 119 static void print_h_help(void);
 120 static void print_fe_help(void);
 121 static void print_cb_help(void);
 122
 123 static void dump_hdr(void);
 124 static void dump_h_hdr(void);
 125 static void dump_cb_hdr(void);
 126
 127 static void dump_cb_timeout(void);
 128 static void dump_cb_fehash(void);
 129
 130 static void dump_all_hes(void);
 131 static void dump_all_fes(void);
 132 static void dump_all_cbs(void);
 133
 134 static void dump_he(afs_uint32 idx);
 135 static void dump_fe(afs_uint32 idx);
 136 static void dump_cb(afs_uint32 idx);
 137 static void dump_this_he(void);
 138 static void dump_this_fe(void);
 139 static void dump_this_cb(void);
 140 static void dump_next_he(void);
 141 static void dump_next_fe(void);
 142 static void dump_next_cb(void);
 143 static void dump_prev_he(void);
 144 static void dump_prev_fe(void);
 145 static void dump_prev_cb(void);
 146 static void dump_first_he(void);
 147 static void dump_first_fe(void);
 148 static void dump_first_cb(void);
 149 static void dump_last_he(void);
 150 static void dump_last_fe(void);
 151 static void dump_last_cb(void);
 152 static void dump_he_hdr(void);
 153 static void dump_he_entry(void);
 154 static void dump_he_interfaces(void);
 155 static void dump_he_hcps(void);
 156 static void dump_fe_hdr(void);
 157 static void dump_fe_entry(void);
 158 static void dump_cb_entry(void);
 159
 160 static void hexdump_map(afs_uint32 offset, afs_uint32 len);
 161
 162 static int get_hdr(void);
 163 static int get_h_hdr(void);
 164 static int get_cb_hdr(void);
 165 static int get_cb_timeout_hdr(void);
 166 static int get_cb_timeout(void);
 167 static int get_cb_fehash_hdr(void);
 168 static int get_cb_fehash(void);
 169 static int get_he(afs_uint32 idx);
 170 static int get_he_hdr(void);
 171 static int get_he_entry(void);
 172 static int get_fe(afs_uint32 idx);
 173 static int get_fe_hdr(void);
 174 static int get_fe_entry(void);
 175 static int get_cb(afs_uint32 idx);
 176 static int get_cb_entry(void);
 177
 178 static int find_fe_by_index(afs_uint32 idx);
 179 static int find_cb_by_index(afs_uint32 idx);
 180 static int find_fe_by_fid(afs_uint32 vol, afs_uint32 vn, afs_uint32 uniq);
 181
 182
 183 static int dump_fd = -1;
 184 static void * map = NULL;
 185 static size_t map_len;
 186
 187 static struct {
 188     struct fs_state_header hdr;
 189     struct host_state_header h_hdr;
 190     struct callback_state_header cb_hdr;
 191     struct callback_state_timeout_header timeout_hdr;
 192     struct callback_state_fehash_header fehash_hdr;
 193     afs_uint32 * timeout;
 194     afs_uint32 * fehash;
 195
 196     /* pointers into the memory map */
 197     void * hdr_p;
 198     void * h_hdr_p;
 199     void * cb_hdr_p;
 200     void * timeout_hdr_p;
 201     void * timeout_p;
 202     void * fehash_hdr_p;
 203     void * fehash_p;
 204
 205     byte hdr_valid;
 206     byte h_hdr_valid;
 207     byte cb_hdr_valid;
 208     byte timeout_hdr_valid;
 209     byte fehash_hdr_valid;
 210 } hdrs;
 211
 212 static struct {
 213     void * fh;
 214     void * cursor;
 215     void * ifp;
 216     void * hcps;
 217     struct host_state_entry_header hdr;
 218     struct hostDiskEntry he;
 219     afs_uint32 idx;
 220     byte hdr_valid;
 221     byte he_valid;
 222 } he_cursor;
 223
 224 static struct {
 225     void ** cursor;
 226 } he_cache;
 227
 228 static struct {
 229     void * ffe;
 230     void * cursor;
 231     void * fcb;
 232     struct callback_state_entry_header hdr;
 233     struct FEDiskEntry fe;
 234     afs_uint32 idx;
 235     byte hdr_valid;
 236     byte fe_valid;
 237 } fe_cursor;
 238
 239 static struct {
 240     void ** cursor;
 241 } fe_cache;
 242
 243 static struct {
 244     void * cursor;
 245     struct CBDiskEntry cb;
 246     afs_uint32 idx;
 247     byte cb_valid;
 248 } cb_cursor;
 249
 250 static struct {
 251     void ** cursor;
 252 } cb_cache;
 253
 254 static void
 255 usage(char * prog)
 256 {
 257     fprintf(stderr, "usage: %s [<state dump file>]\n");
 258 }
 259
 260 int
 261 main(int argc, char ** argv)
 262 {
 263     banner();
 264
 265     if (argc > 2 || (argc == 2 && !strcmp(argv[1], "-h"))) {
 266         usage(argv[0]);
 267         return 1;
 268     }
 269
 270     initState();
 271
 272     if (argc > 1) {
 273         if (openFile(argv[1]))
 274             return 1;
 275     } else {
 276         if (openFile(AFSDIR_SERVER_FSSTATE_FILEPATH))
 277             return 1;
 278     }
 279
 280     prompt();
 281     return 0;
 282 }
 283
 284
 285 static int
 286 openFile(char * path)
 287 {
 288     int ret = 0;
 289     struct afs_stat status;
 290
 291     dump_fd = afs_open(path, O_RDWR);
 292     if (dump_fd == -1) {
 293         fprintf(stderr, "dump file '%s' failed to open\n", path);
 294         ret = 1;
 295         goto done;
 296     }
 297
 298     printf("opened dump file '%s'\n", path);
 299
 300     if (afs_fstat(dump_fd, &status) == -1) {
 301         fprintf(stderr, "failed to stat file\n");
 302         ret = 1;
 303         goto done;
 304     }
 305
 306     map_len = status.st_size;
 307
 308     map = afs_mmap(NULL, map_len, PROT_READ, MAP_SHARED, dump_fd, 0);
 309     if (map == MAP_FAILED) {
 310         fprintf(stderr, "failed to mmap file\n");
 311         ret = 1;
 312         goto done;
 313     }
 314
 315     printf("mapped %d bytes at 0x%x\n", map_len, map);
 316
 317  done:
 318     if (ret) {
 319         if (map) {
 320             munmap(map, map_len);
 321             map = NULL;
 322         }
 323         if (dump_fd != -1) {
 324             close(dump_fd);
 325             dump_fd = -1;
 326         }
 327     }
 328     return ret;
 329 }
 330
 331 static void
 332 initState(void)
 333 {
 334     hdrs.hdr_valid = hdrs.h_hdr_valid = hdrs.cb_hdr_valid = 0;
 335     he_cursor.cursor = fe_cursor.cursor = cb_cursor.cursor = NULL;
 336     he_cursor.fh = fe_cursor.ffe = fe_cursor.fcb = NULL;
 337     he_cache.cursor = fe_cache.cursor = NULL;
 338 }
 339
 340 static void
 341 banner(void)
 342 {
 343     fprintf(stderr, "demand attach fs\n");
 344     fprintf(stderr, "fileserver state analyzer\n");
 345     fprintf(stderr, "version 0.1\n");
 346 }
 347
 348 #define PROGNAME "fs state analyzer"
 349
 350 static void
 351 prompt(void)
 352 {
 353     char input[256];
 354     char prev_input[256];
 355     char * tok = NULL;
 356     afs_uint32 x, y, z;
 357     enum {
 358         PR_GLOBAL_MODE,
 359         PR_H_MODE,
 360         PR_FE_MODE,
 361         PR_CB_MODE
 362     } mode = PR_GLOBAL_MODE, next_mode;
 363
 364     next_mode = mode;
 365     input[0] = prev_input[0] = '\0';
 366
 367     while (1) {
 368         if (!tok) {
 369             switch(mode) {
 370             case PR_GLOBAL_MODE:
 371                 printf(PROGNAME "> ");
 372                 break;
 373             case PR_H_MODE:
 374                 printf(PROGNAME ": h(%d)> ", he_cursor.idx);
 375                 break;
 376             case PR_FE_MODE:
 377                 printf(PROGNAME ": fe(%d)> ", fe_cursor.idx);
 378                 break;
 379             case PR_CB_MODE:
 380                 printf(PROGNAME ": fe(%d):cb(%d)> ", fe_cursor.idx, cb_cursor.idx);
 381                 break;
 382             default:
 383                 fprintf(stderr, "prompt state broken; aborting\n");
 384                 return;
 385             }
 386             gets(input);
 387
 388             if (!strcmp(input, "")) {
 389                 /* repeat last command */
 390                 if (!strcmp(prev_input, "")) {
 391                     continue;
 392                 }
 393                 strlcpy(input, prev_input, sizeof(input));
 394             } else {
 395                 /* save command for repetition */
 396                 strlcpy(prev_input, input, sizeof(prev_input));
 397             }
 398
 399             tok = strtok(input, " \t");
 400         }
 401         while (tok && !strcmp(tok, ";")) {
 402             tok = strtok(NULL, "; \t");
 403         }
 404
 405         if (!tok) {
 406             continue;
 407         }
 408
 409         if (!strcasecmp(tok, "exit")) {
 410             return;
 411         } else if (!strcasecmp(tok, "quit")) {
 412             switch(mode) {
 413             case PR_CB_MODE:
 414                 next_mode = PR_FE_MODE;
 415                 break;
 416             case PR_FE_MODE:
 417             case PR_H_MODE:
 418                 next_mode = PR_GLOBAL_MODE;
 419                 break;
 420             default:
 421                 return;
 422             }
 423         } else if (!strcasecmp(tok, "h")) {
 424             tok = strtok(NULL, " \t");
 425             mode = PR_H_MODE;
 426             if (!tok) {
 427                 next_mode = mode;
 428             }
 429             continue;
 430         } else if (!strcasecmp(tok, "fe")) {
 431             tok = strtok(NULL, " \t");
 432             mode = PR_FE_MODE;
 433             if (!tok) {
 434                 next_mode = mode;
 435             }
 436             continue;
 437         } else if (!strcasecmp(tok, "fs")) {
 438             tok = strtok(NULL, " \t");
 439             mode = PR_GLOBAL_MODE;
 440             if (!tok) {
 441                 next_mode = mode;
 442             }
 443             continue;
 444         } else if (!strcasecmp(tok, "cb")) {
 445             tok = strtok(NULL, " \t");
 446             mode = PR_CB_MODE;
 447             if (!tok) {
 448                 next_mode = mode;
 449             }
 450             continue;
 451         } else if (!strcasecmp(tok, "help")) {
 452             switch(mode) {
 453             case PR_H_MODE:
 454                 print_h_help();
 455                 break;
 456             case PR_FE_MODE:
 457                 print_fe_help();
 458                 break;
 459             case PR_CB_MODE:
 460                 print_cb_help();
 461                 break;
 462             default:
 463                 print_global_help();
 464             }
 465             print_help();
 466         } else if (!strcasecmp(tok, "hexdump")) {
 467             tok = strtok(NULL, " \t");
 468             if (!tok) {
 469                 hexdump_map(0, map_len);
 470                 continue;
 471             }
 472             if (sscanf(tok, "%u", &x) != 1) {
 473                 fprintf(stderr, "hexdump parse error 1\n");
 474                 tok = NULL;
 475                 continue;
 476             }
 477             tok = strtok(NULL, " \t");
 478             if (!tok) {
 479                 hexdump_map(x, map_len - x);
 480                 continue;
 481             }
 482             if (sscanf(tok, "%u", &y) != 1) {
 483                 fprintf(stderr, "hexdump parse error 2\n");
 484                 continue;
 485             }
 486             hexdump_map(x,y);
 487         } else if (!strcasecmp(tok, "hdr")) {
 488             switch(mode) {
 489             case PR_H_MODE:
 490                 dump_h_hdr();
 491                 break;
 492             case PR_FE_MODE:
 493                 dump_cb_hdr();
 494                 break;
 495             case PR_CB_MODE:
 496                 dump_this_fe();
 497                 break;
 498             default:
 499                 dump_hdr();
 500             }
 501         } else if (!strcasecmp(tok, "this")) {
 502             switch(mode) {
 503             case PR_H_MODE:
 504                 dump_this_he();
 505                 break;
 506             case PR_FE_MODE:
 507                 dump_this_fe();
 508                 break;
 509             case PR_CB_MODE:
 510                 dump_this_cb();
 511                 break;
 512             default:
 513                 fprintf(stderr, "command not valid for this mode\n");
 514             }
 515         } else if (!strcasecmp(tok, "next")) {
 516             switch(mode) {
 517             case PR_H_MODE:
 518                 dump_next_he();
 519                 break;
 520             case PR_FE_MODE:
 521                 dump_next_fe();
 522                 break;
 523             case PR_CB_MODE:
 524                 dump_next_cb();
 525                 break;
 526             default:
 527                 fprintf(stderr, "command not valid for this mode\n");
 528             }
 529         } else if (!strcasecmp(tok, "prev")) {
 530             switch(mode) {
 531             case PR_H_MODE:
 532                 dump_prev_he();
 533                 break;
 534             case PR_FE_MODE:
 535                 dump_prev_fe();
 536                 break;
 537             case PR_CB_MODE:
 538                 dump_prev_cb();
 539                 break;
 540             default:
 541                 fprintf(stderr, "command not valid for this mode\n");
 542             }
 543         } else if (!strcasecmp(tok, "first")) {
 544             switch(mode) {
 545             case PR_H_MODE:
 546                 dump_first_he();
 547                 break;
 548             case PR_FE_MODE:
 549                 dump_first_fe();
 550                 break;
 551             case PR_CB_MODE:
 552                 dump_first_cb();
 553                 break;
 554             default:
 555                 fprintf(stderr, "command not valid for this mode\n");
 556             }
 557         } else if (!strcasecmp(tok, "last")) {
 558             switch(mode) {
 559             case PR_H_MODE:
 560                 dump_last_he();
 561                 break;
 562             case PR_FE_MODE:
 563                 dump_last_fe();
 564                 break;
 565             case PR_CB_MODE:
 566                 dump_last_cb();
 567                 break;
 568             default:
 569                 fprintf(stderr, "command not valid for this mode\n");
 570             }
 571         } else if (!strcasecmp(tok, "dump")) {
 572             switch(mode) {
 573             case PR_H_MODE:
 574                 dump_all_hes();
 575                 break;
 576             case PR_FE_MODE:
 577                 dump_all_fes();
 578                 break;
 579             case PR_CB_MODE:
 580                 dump_all_cbs();
 581                 break;
 582             default:
 583                 fprintf(stderr, "command not valid for this mode\n");
 584             }
 585         } else if (!strcasecmp(tok, "find")) {
 586             tok = strtok(NULL, " \t");
 587             if (!tok || strcasecmp(tok, "by")) {
 588                 tok = NULL;
 589                 fprintf(stderr, "find syntax error 1 (%s)\n",
 590                         (tok) ? tok : "nil");
 591                 continue;
 592             }
 593             tok = strtok(NULL, " \t");
 594             if (!tok) {
 595                 fprintf(stderr, "find syntax error 2\n");
 596                 continue;
 597             }
 598             switch(mode) {
 599             case PR_H_MODE:
 600                 fprintf(stderr, "not implemented yet\n");
 601                 break;
 602             case PR_FE_MODE:
 603                 if (!strcasecmp(tok, "index")) {
 604                     tok = strtok(NULL, " \t");
 605                     if (!tok || sscanf(tok, "%u", &x) != 1) {
 606                         tok = NULL;
 607                         fprintf(stderr, "find syntax error 3\n");
 608                         continue;
 609                     }
 610                     if (find_fe_by_index(x)) {
 611                         fprintf(stderr, "find returned no results\n");
 612                     }
 613                 } else if (!strcasecmp(tok, "fid")) {
 614                     tok = strtok(NULL, "(), \t");
 615                     if (!tok || sscanf(tok, "%u", &x) != 1) {
 616                         tok = NULL;
 617                         fprintf(stderr, "find syntax error 4\n");
 618                         continue;
 619                     }
 620                     tok = strtok(NULL, "(), \t");
 621                     if (!tok || sscanf(tok, "%u", &y) != 1) {
 622                         tok = NULL;
 623                         fprintf(stderr, "find syntax error 5\n");
 624                         continue;
 625                     }
 626                     tok = strtok(NULL, "(), \t");
 627                     if (!tok || sscanf(tok, "%u", &z) != 1) {
 628                         tok = NULL;
 629                         fprintf(stderr, "find syntax error 6\n");
 630                         continue;
 631                     }
 632                     if (find_fe_by_fid(x,y,z)) {
 633                         fprintf(stderr, "find returned no results\n");
 634                     }
 635                 } else {
 636                     fprintf(stderr, "unsupported filter type\n");
 637                 }
 638                 break;
 639             case PR_CB_MODE:
 640                 if (!strcasecmp(tok, "index")) {
 641                     tok = strtok(NULL, " \t");
 642                     if (!tok || sscanf(tok, "%u", &x) != 1) {
 643                         tok = NULL;
 644                         fprintf(stderr, "find syntax error 3\n");
 645                         continue;
 646                     }
 647                     if (find_cb_by_index(x)) {
 648                         fprintf(stderr, "find returned no results\n");
 649                     }
 650                 } else {
 651                     fprintf(stderr, "unsupported filter type\n");
 652                 }
 653                 break;
 654             default:
 655                 fprintf(stderr, "find not supported for this menu\n");
 656             }
 657         } else if (!strcspn(tok, "0123456789")) {
 658             if (sscanf(tok, "%u", &x) == 1) {
 659                 switch(mode) {
 660                 case PR_H_MODE:
 661                     dump_he(x);
 662                     break;
 663                 case PR_FE_MODE:
 664                     dump_fe(x);
 665                     break;
 666                 case PR_CB_MODE:
 667                     dump_cb(x);
 668                     break;
 669                 default:
 670                     fprintf(stderr, "command not available from this menu\n");
 671                 }
 672             } else {
 673                 fprintf(stderr, "input parse error ('%s')\n", tok);
 674             }
 675         } else if (mode == PR_FE_MODE) {
 676             if (!strcmp(tok, "timeout")) {
 677                 dump_cb_timeout();
 678             } else if (!strcmp(tok, "hash")) {
 679                 dump_cb_fehash();
 680             }
 681         } else {
 682             fprintf(stderr, "unknown command\n");
 683         }
 684         tok = strtok(NULL, " \t");
 685         mode = next_mode;
 686     }
 687 }
 688
 689 static void
 690 print_help(void)
 691 {
 692     printf("\th <...>  -- host menu commands\n");
 693     printf("\tfe <...> -- FileEntry menu commands\n");
 694     printf("\tcb <...> -- CallBack menu commands\n");
 695     printf("\thexdump [<offset> [<len>]]\n\t\t -- hex dump the raw data\n");
 696     printf("\tquit     -- quit this menu\n");
 697     printf("\texit     -- exit the debugger\n");
 698     printf("\thelp     -- this help message\n");
 699 }
 700
 701 static void
 702 print_global_help(void)
 703 {
 704     printf("\thdr      -- display the fs_state_header struct\n");
 705 }
 706
 707 static void
 708 print_h_help(void)
 709 {
 710     printf("\thdr      -- display the host_state_header struct\n");
 711     printf("\tfirst    -- display the first host\n");
 712     printf("\tprev     -- display the previous host\n");
 713     printf("\tthis     -- display this host\n");
 714     printf("\tnext     -- display the next host\n");
 715     printf("\tlast     -- display the last host\n");
 716     printf("\tdump     -- display all hosts\n");
 717 }
 718
 719 static void
 720 print_fe_help(void)
 721 {
 722     printf("\thdr      -- display the callback_state_header struct\n");
 723     printf("\tfirst    -- display the first FE\n");
 724     printf("\tprev     -- display the previous FE\n");
 725     printf("\tthis     -- display this FE\n");
 726     printf("\tnext     -- display the next FE\n");
 727     printf("\tlast     -- display the last FE\n");
 728     printf("\tdump     -- display all FEs\n");
 729     printf("\ttimeout  -- display the timeout queue heads\n");
 730     printf("\thash   -- display the file entry hash buckets\n");
 731     printf("\tfind by index <id>\n\t\t -- find an fe by its array index\n");
 732     printf("\tfind by fid <(vol,vnode,unique)>\n\t\t -- find an fe by its AFSFid\n");
 733 }
 734
 735 static void
 736 print_cb_help(void)
 737 {
 738     printf("\thdr      -- display the callback_state_entry_header struct\n");
 739     printf("\tfirst    -- display the first CB\n");
 740     printf("\tprev     -- display the previous CB\n");
 741     printf("\tthis     -- display this CB\n");
 742     printf("\tnext     -- display the next CB\n");
 743     printf("\tlast     -- display the last CB\n");
 744     printf("\tdump     -- display all CBs\n");
 745 }
 746
 747 #define DPFTB0 "\t"
 748 #define DPFTB1 "\t\t"
 749 #define DPFTB2 "\t\t\t"
 750
 751 #define DPFOFF(addr) \
 752     do { \
 753         char * _p = (char *)addr; \
 754         char * _m = (char *)map; \
 755         printf("loading structure from address 0x%x (offset %u)\n", \
 756                addr, _p-_m); \
 757     } while (0)
 758
 759 /* structs */
 760 #define DPFSO(T, name) printf(T "%s = {\n", name)
 761 #define DPFSO0(name) DPFSO(DPFTB0, name)
 762 #define DPFSO1(name) DPFSO(DPFTB1, name)
 763 #define DPFSC(T) printf(T "}\n")
 764 #define DPFSC0 DPFSC(DPFTB0)
 765 #define DPFSC1 DPFSC(DPFTB1)
 766
 767 /* arrays */
 768 #define DPFAO(T1, T2, name) printf(T1 "%s =\n" T2 "{ ", name)
 769 #define DPFAO0(name) DPFAO(DPFTB0, DPFTB1, name)
 770 #define DPFAO1(name) DPFAO(DPFTB1, DPFTB2, name)
 771 #define DPFAC0 printf(" }\n")
 772 #define DPFAC1 DPFAC0
 773 #define DPFA1 printf(DPFTB1 "  ")
 774 #define DPFA2 printf(DPFTB2 "  ")
 775 #define DPFAN printf("\n")
 776 #define DPFALE(type, var) printf("%" type, var)
 777 #define DPFAE(type, var) printf("%" type ",\t", var)
 778
 779 /* normal vars */
 780 #define DPFV(T, name, type, var) printf(T "%s = %" type "\n", name, var)
 781 #define DPFV1(name, type, var) DPFV(DPFTB1, name, type, var)
 782 #define DPFV2(name, type, var) DPFV(DPFTB2, name, type, var)
 783
 784 /* hex */
 785 #define DPFX(T, name, var) printf(T "%s = 0x%x\n", name, var)
 786 #define DPFX1(name, var) DPFX(DPFTB1, name, var)
 787 #define DPFX2(name, var) DPFX(DPFTB2, name, var)
 788
 789 /* strings */
 790 #define DPFS(T, name, var) printf(T "%s = \"%s\"\n", name, var)
 791 #define DPFS1(name, var) DPFS(DPFTB1, name, var)
 792 #define DPFS2(name, var) DPFS(DPFTB2, name, var)
 793
 794 /* time */
 795 #define DPFT(T, name, var) \
 796     do { \
 797         char * last; \
 798         printf(T "%s = \"%s\"\n", name, strtok_r(ctime(&(var)), "\r\n", &last)); \
 799     } while(0)
 800 #define DPFT1(name, var) DPFT(DPFTB1, name, var)
 801 #define DPFT2(name, var) DPFT(DPFTB2, name, var)
 802
 803 static void
 804 dump_hdr(void)
 805 {
 806     char uuid_str[40];
 807     afs_uint32 hi, lo;
 808
 809     if (get_hdr())
 810         return;
 811
 812     DPFOFF(map);
 813     DPFSO0("fs_state_header");
 814     DPFSO1("stamp");
 815     DPFX2("magic", hdrs.hdr.stamp.magic);
 816     DPFV2("version", "u", hdrs.hdr.stamp.version);
 817     DPFSC1;
 818     DPFT1("timestamp", hdrs.hdr.timestamp);
 819     DPFV1("sys_name", "u", hdrs.hdr.sys_name);
 820
 821     afsUUID_to_string(&hdrs.hdr.server_uuid, uuid_str, sizeof(uuid_str));
 822     DPFS1("server_uuid", uuid_str);
 823     DPFV1("valid", "d", hdrs.hdr.valid);
 824     DPFV1("endianness", "d", hdrs.hdr.endianness);
 825     DPFV1("stats_detailed", "d", hdrs.hdr.stats_detailed);
 826
 827     SplitInt64(hdrs.hdr.h_offset, hi, lo);
 828     DPFSO1("h_offset");
 829     DPFV2("hi", "u", hi);
 830     DPFV2("lo", "u", lo);
 831     DPFSC1;
 832
 833     SplitInt64(hdrs.hdr.cb_offset, hi, lo);
 834     DPFSO1("cb_offset");
 835     DPFV2("hi", "u", hi);
 836     DPFV2("lo", "u", lo);
 837     DPFSC1;
 838
 839     DPFS1("server_version_string", hdrs.hdr.server_version_string);
 840     DPFSC0;
 841
 842     if (hdrs.hdr.stamp.magic != FS_STATE_MAGIC) {
 843         fprintf(stderr, "* magic check failed\n");
 844     }
 845     if (hdrs.hdr.stamp.version != FS_STATE_VERSION) {
 846         fprintf(stderr, "* version check failed\n");
 847     }
 848 }
 849
 850 static void
 851 dump_h_hdr(void)
 852 {
 853     if (get_h_hdr())
 854         return;
 855
 856     DPFOFF(hdrs.h_hdr_p);
 857     DPFSO0("host_state_header");
 858     DPFSO1("stamp");
 859     DPFX2("magic", hdrs.h_hdr.stamp.magic);
 860     DPFV2("version", "u", hdrs.h_hdr.stamp.version);
 861     DPFSC1;
 862     DPFV1("records", "u", hdrs.h_hdr.records);
 863     DPFV1("index_max", "u", hdrs.h_hdr.index_max);
 864     DPFSC0;
 865
 866     if (hdrs.h_hdr.stamp.magic != HOST_STATE_MAGIC) {
 867         fprintf(stderr, "* magic check failed\n");
 868     }
 869     if (hdrs.h_hdr.stamp.version != HOST_STATE_VERSION) {
 870         fprintf(stderr, "* version check failed\n");
 871     }
 872 }
 873
 874 static void
 875 dump_cb_hdr(void)
 876 {
 877     afs_uint32 hi, lo;
 878
 879     if (get_cb_hdr())
 880         return;
 881
 882     DPFOFF(hdrs.cb_hdr_p);
 883     DPFSO0("callback_state_header");
 884     DPFSO1("stamp");
 885     DPFX2("magic", hdrs.cb_hdr.stamp.magic);
 886     DPFV2("version", "u", hdrs.cb_hdr.stamp.version);
 887     DPFSC1;
 888     DPFV1("nFEs", "u", hdrs.cb_hdr.nFEs);
 889     DPFV1("nCBs", "u", hdrs.cb_hdr.nCBs);
 890     DPFV1("fe_max", "u", hdrs.cb_hdr.fe_max);
 891     DPFV1("cb_max", "u", hdrs.cb_hdr.cb_max);
 892     DPFV1("tfirst", "d", hdrs.cb_hdr.tfirst);
 893
 894     SplitInt64(hdrs.cb_hdr.timeout_offset, hi, lo);
 895     DPFSO1("timeout_offset");
 896     DPFV2("hi", "u", hi);
 897     DPFV2("lo", "u", lo);
 898     DPFSC1;
 899
 900     SplitInt64(hdrs.cb_hdr.fehash_offset, hi, lo);
 901     DPFSO1("fehash_offset");
 902     DPFV2("hi", "u", hi);
 903     DPFV2("lo", "u", lo);
 904     DPFSC1;
 905
 906     SplitInt64(hdrs.cb_hdr.fe_offset, hi, lo);
 907     DPFSO1("fe_offset");
 908     DPFV2("hi", "u", hi);
 909     DPFV2("lo", "u", lo);
 910     DPFSC1;
 911
 912     DPFSC0;
 913
 914     if (hdrs.cb_hdr.stamp.magic != CALLBACK_STATE_MAGIC) {
 915         fprintf(stderr, "* magic check failed\n");
 916     }
 917     if (hdrs.cb_hdr.stamp.version != CALLBACK_STATE_VERSION) {
 918         fprintf(stderr, "* version check failed\n");
 919     }
 920 }
 921
 922 static void
 923 dump_cb_timeout(void)
 924 {
 925     int i;
 926
 927     if (get_cb_hdr())
 928         return;
 929
 930     if (get_cb_timeout_hdr())
 931         return;
 932
 933     if (get_cb_timeout())
 934         return;
 935
 936     DPFOFF(hdrs.timeout_hdr_p);
 937     DPFSO0("callback_state_timeout_header");
 938     DPFX1("magic", hdrs.timeout_hdr.magic);
 939     DPFV1("len", "u", hdrs.timeout_hdr.len);
 940     DPFV1("records", "u", hdrs.timeout_hdr.records);
 941     DPFSC0;
 942
 943     if (hdrs.timeout_hdr.magic != CALLBACK_STATE_TIMEOUT_MAGIC) {
 944         fprintf(stderr, "* magic check failed\n");
 945     }
 946
 947     DPFOFF(hdrs.timeout_p);
 948     DPFAO0("timeout");
 949     for (i = 0; i < 127; i++) {
 950         DPFAE("u", hdrs.timeout[i]);
 951         if ((i % 8) == 7) {
 952             DPFAN;
 953             DPFA1;
 954         }
 955     }
 956     DPFALE("u", hdrs.timeout[127]);
 957     DPFAC0;
 958 }
 959
 960 static void
 961 dump_cb_fehash(void)
 962 {
 963     int i;
 964
 965     if (get_cb_hdr())
 966         return;
 967
 968     if (get_cb_fehash_hdr())
 969         return;
 970
 971     if (get_cb_fehash())
 972         return;
 973
 974     DPFOFF(hdrs.fehash_hdr_p);
 975     DPFSO0("callback_state_fehash_header");
 976     DPFX1("magic", hdrs.fehash_hdr.magic);
 977     DPFV1("len", "u", hdrs.fehash_hdr.len);
 978     DPFV1("records", "u", hdrs.fehash_hdr.records);
 979     DPFSC0;
 980
 981     if (hdrs.fehash_hdr.magic != CALLBACK_STATE_FEHASH_MAGIC) {
 982         fprintf(stderr, "* magic check failed\n");
 983     }
 984
 985     DPFOFF(hdrs.fehash_p);
 986     DPFAO0("fehash");
 987     for (i = 0; i < hdrs.fehash_hdr.records - 1; i++) {
 988         DPFAE("u", hdrs.fehash[i]);
 989         if ((i % 8) == 7) {
 990             DPFAN;
 991             DPFA1;
 992         }
 993     }
 994     DPFALE("u", hdrs.fehash[hdrs.fehash_hdr.records-1]);
 995     DPFAC0;
 996 }
 997
 998 static void
 999 dump_all_hes(void)
1000 {
1001     int i;
1002
1003     if (get_h_hdr()) {
1004         fprintf(stderr, "error getting host_state_header\n");
1005         return;
1006     }
1007
1008     for (i = 0; i < hdrs.h_hdr.records; i++) {
1009         dump_he(i);
1010     }
1011 }
1012
1013 static void
1014 dump_all_fes(void)
1015 {
1016     int i;
1017
1018     if (get_cb_hdr()) {
1019         fprintf(stderr, "error getting callback_state_header\n");
1020         return;
1021     }
1022
1023     for (i = 0; i < hdrs.cb_hdr.nFEs; i++) {
1024         dump_fe(i);
1025     }
1026 }
1027
1028 static void
1029 dump_all_cbs(void)
1030 {
1031     int i;
1032
1033     if (get_fe_hdr()) {
1034         fprintf(stderr, "error getting callback_state_entry_header\n");
1035         return;
1036     }
1037
1038     for (i = 0; i < fe_cursor.hdr.nCBs; i++) {
1039         dump_cb(i);
1040     }
1041 }
1042
1043 static void
1044 dump_he(afs_uint32 idx)
1045 {
1046     if (get_he(idx)) {
1047         fprintf(stderr, "error getting he %d\n", idx);
1048         return;
1049     }
1050
1051     DPFOFF(he_cursor.cursor);
1052     dump_he_hdr();
1053     dump_he_entry();
1054     dump_he_interfaces();
1055     dump_he_hcps();
1056 }
1057
1058 static void
1059 dump_fe(afs_uint32 idx)
1060 {
1061     if (get_fe(idx)) {
1062         fprintf(stderr, "error getting fe %d\n", idx);
1063         return;
1064     }
1065
1066     DPFOFF(fe_cursor.cursor);
1067     dump_fe_hdr();
1068     dump_fe_entry();
1069 }
1070
1071 static void
1072 dump_cb(afs_uint32 idx)
1073 {
1074     if (get_cb(idx)) {
1075         fprintf(stderr, "error getting cb %d\n", idx);
1076         return;
1077     }
1078
1079     DPFOFF(cb_cursor.cursor);
1080     dump_cb_entry();
1081 }
1082
1083 static void
1084 dump_this_he(void)
1085 {
1086     dump_he(he_cursor.idx);
1087 }
1088
1089 static void
1090 dump_this_fe(void)
1091 {
1092     dump_fe(fe_cursor.idx);
1093 }
1094
1095 static void
1096 dump_this_cb(void)
1097 {
1098     dump_cb(cb_cursor.idx);
1099 }
1100
1101 static void
1102 dump_next_he(void)
1103 {
1104     if (get_h_hdr()) {
1105         fprintf(stderr, "error getting host_state_header\n");
1106         return;
1107     }
1108
1109     if ((he_cursor.idx + 1) >= hdrs.h_hdr.records) {
1110         fprintf(stderr, "no more HEs\n");
1111         return;
1112     }
1113
1114     dump_he(he_cursor.idx+1);
1115 }
1116
1117 static void
1118 dump_next_fe(void)
1119 {
1120     if (get_cb_hdr()) {
1121         fprintf(stderr, "error getting callback_state_header\n");
1122         return;
1123     }
1124
1125     if ((fe_cursor.idx + 1) >= hdrs.cb_hdr.nFEs) {
1126         fprintf(stderr, "no more FEs\n");
1127         return;
1128     }
1129
1130     dump_fe(fe_cursor.idx+1);
1131 }
1132
1133 static void
1134 dump_next_cb(void)
1135 {
1136     if (get_fe_hdr()) {
1137         fprintf(stderr, "error getting callback_state_entry_header\n");
1138         return;
1139     }
1140
1141     if ((cb_cursor.idx + 1) >= fe_cursor.hdr.nCBs) {
1142         fprintf(stderr, "no more CBs\n");
1143         return;
1144     }
1145
1146     dump_cb(cb_cursor.idx+1);
1147 }
1148
1149 static void
1150 dump_prev_he(void)
1151 {
1152     if (!he_cursor.idx) {
1153         fprintf(stderr, "no more HEs\n");
1154         return;
1155     }
1156
1157     dump_he(he_cursor.idx-1);
1158 }
1159
1160 static void
1161 dump_prev_fe(void)
1162 {
1163     if (!fe_cursor.idx) {
1164         fprintf(stderr, "no more FEs\n");
1165         return;
1166     }
1167
1168     dump_fe(fe_cursor.idx-1);
1169 }
1170
1171 static void
1172 dump_prev_cb(void)
1173 {
1174     if (!cb_cursor.idx) {
1175         fprintf(stderr, "no more CBs\n");
1176         return;
1177     }
1178
1179     dump_cb(cb_cursor.idx-1);
1180 }
1181
1182 static void
1183 dump_first_fe(void)
1184 {
1185     if (get_cb_hdr()) {
1186         fprintf(stderr, "error getting callback_state_header\n");
1187         return;
1188     }
1189
1190     if (!hdrs.cb_hdr.nFEs) {
1191         fprintf(stderr, "no FEs present\n");
1192         return;
1193     }
1194
1195     dump_fe(0);
1196 }
1197
1198 static void
1199 dump_first_he(void)
1200 {
1201     if (get_h_hdr()) {
1202         fprintf(stderr, "error getting host_state_header\n");
1203         return;
1204     }
1205
1206     if (!hdrs.h_hdr.records) {
1207         fprintf(stderr, "no HEs present\n");
1208         return;
1209     }
1210
1211     dump_he(0);
1212 }
1213
1214 static void
1215 dump_first_cb(void)
1216 {
1217     if (get_fe_hdr()) {
1218         fprintf(stderr, "error getting callback_state_entry_header\n");
1219         return;
1220     }
1221
1222     if (!fe_cursor.hdr.nCBs) {
1223         fprintf(stderr, "no CBs present\n");
1224         return;
1225     }
1226
1227     dump_cb(0);
1228 }
1229
1230 static void
1231 dump_last_he(void)
1232 {
1233     if (get_h_hdr()) {
1234         fprintf(stderr, "error getting host_state_header\n");
1235         return;
1236     }
1237
1238     if (!hdrs.h_hdr.records) {
1239         fprintf(stderr, "no HEs present\n");
1240         return;
1241     }
1242
1243     dump_he(hdrs.h_hdr.records-1);
1244 }
1245
1246 static void
1247 dump_last_fe(void)
1248 {
1249     if (get_cb_hdr()) {
1250         fprintf(stderr, "error getting callback_state_header\n");
1251         return;
1252     }
1253
1254     if (!hdrs.cb_hdr.nFEs) {
1255         fprintf(stderr, "no FEs present\n");
1256         return;
1257     }
1258
1259     dump_fe(hdrs.cb_hdr.nFEs-1);
1260 }
1261
1262 static void
1263 dump_last_cb(void)
1264 {
1265     if (get_fe_hdr()) {
1266         fprintf(stderr, "error getting callback_state_entry_header\n");
1267         return;
1268     }
1269
1270     if (!fe_cursor.hdr.nCBs) {
1271         fprintf(stderr, "no CBs present\n");
1272         return;
1273     }
1274
1275     dump_cb(fe_cursor.hdr.nCBs-1);
1276 }
1277
1278 static void
1279 dump_he_hdr(void)
1280 {
1281     DPFSO0("host_state_entry_header");
1282     DPFX1("magic", he_cursor.hdr.magic);
1283     DPFV1("len", "u", he_cursor.hdr.len);
1284     DPFV1("interfaces", "u", he_cursor.hdr.interfaces);
1285     DPFV1("hcps", "u", he_cursor.hdr.hcps);
1286     DPFSC0;
1287
1288     if (he_cursor.hdr.magic != HOST_STATE_ENTRY_MAGIC) {
1289         fprintf(stderr, "* magic check failed\n");
1290     }
1291 }
1292
1293 static void
1294 dump_he_entry(void)
1295 {
1296     DPFSO0("hostDiskEntry");
1297     DPFS1("host", afs_inet_ntoa(he_cursor.he.host));
1298     DPFV1("port", "u", he_cursor.he.port);
1299     DPFX1("hostFlags", he_cursor.he.hostFlags);
1300     DPFV1("Console", "u", he_cursor.he.Console);
1301     DPFV1("hcpsfailed", "u", he_cursor.he.hcpsfailed);
1302     DPFV1("hcps_valid", "u", he_cursor.he.hcps_valid);
1303     if (hdrs.hdr.stats_detailed) {
1304 #ifdef FS_STATS_DETAILED
1305         DPFV1("InSameNetwork", "u", he_cursor.he.InSameNetwork);
1306 #else
1307         DPFV1("InSameNetwork", "u", he_cursor.he.padding1[0]);
1308 #endif
1309     }
1310     DPFV1("hcps_len", "u", he_cursor.he.hcps_len);
1311     DPFT1("LastCall", he_cursor.he.LastCall);
1312     DPFT1("ActiveCall", he_cursor.he.ActiveCall);
1313     DPFT1("cpsCall", he_cursor.he.cpsCall);
1314     DPFV1("cblist", "u", he_cursor.he.cblist);
1315     DPFV1("index", "u", he_cursor.he.index);
1316     DPFSC0;
1317 }
1318
1319 static void
1320 dump_he_interfaces(void)
1321 {
1322     char temp_str[40];
1323     struct Interface * ifp;
1324     int len, i;
1325
1326     if (!he_cursor.hdr.interfaces)
1327         return;
1328
1329     len = sizeof(struct Interface) + ((he_cursor.hdr.interfaces-1)*sizeof(struct AddrPort));
1330     ifp = (struct Interface *) malloc(len);
1331     assert(ifp != NULL);
1332
1333     memcpy(ifp, he_cursor.ifp, len);
1334
1335     DPFSO0("Interface");
1336     DPFV1("numberOfInterfaces", "u", ifp->numberOfInterfaces);
1337
1338     afsUUID_to_string(&ifp->uuid, temp_str, sizeof(temp_str));
1339     DPFS1("uuid", temp_str);
1340     for (i = 0; i < he_cursor.hdr.interfaces; i++) {
1341         snprintf(temp_str, sizeof(temp_str), "interface[%d]", i);
1342         DPFSO1(temp_str);
1343         DPFS2("addr", afs_inet_ntoa(ifp->interface[i].addr));
1344         DPFV2("port", "u", ifp->interface[i].port);
1345         DPFSC1;
1346     }
1347
1348     DPFSC0;
1349
1350     if (he_cursor.hdr.interfaces != ifp->numberOfInterfaces) {
1351         fprintf(stderr, "* interface count mismatch between header and Interface struct\n");
1352     }
1353     free(ifp);
1354 }
1355
1356 static void
1357 dump_he_hcps(void)
1358 {
1359     char temp_str[40];
1360     afs_int32 * hcps;
1361     int len, i;
1362
1363     if (!he_cursor.hdr.hcps)
1364         return;
1365
1366     len = (he_cursor.hdr.hcps)*sizeof(afs_uint32);
1367     hcps = (afs_int32 *) malloc(len);
1368     assert(hcps != NULL);
1369     memcpy(hcps, he_cursor.hcps, len);
1370
1371     DPFSO0("hcps");
1372     DPFAO1("prlist_val");
1373     for (i = 0; i < he_cursor.hdr.hcps - 1; i++) {
1374         DPFAE("d", hcps[i]);
1375         if ((i % 8) == 7) {
1376             DPFAN;
1377             DPFA2;
1378         }
1379     }
1380     DPFALE("d", hcps[he_cursor.hdr.hcps-1]);
1381     DPFAC1;
1382     DPFSC0;
1383     free(hcps);
1384 }
1385
1386 static void
1387 dump_fe_hdr(void)
1388 {
1389     DPFSO0("callback_state_entry_header");
1390     DPFX1("magic", fe_cursor.hdr.magic);
1391     DPFV1("len", "u", fe_cursor.hdr.len);
1392     DPFV1("nCBs", "u", fe_cursor.hdr.nCBs);
1393     DPFSC0;
1394
1395     if (fe_cursor.hdr.magic != CALLBACK_STATE_ENTRY_MAGIC) {
1396         fprintf(stderr, "* magic check failed\n");
1397     }
1398 }
1399
1400 static void
1401 dump_fe_entry(void)
1402 {
1403     DPFSO0("FEDiskEntry");
1404     DPFSO1("fe");
1405     DPFV2("vnode", "u", fe_cursor.fe.fe.vnode);
1406     DPFV2("unique", "u", fe_cursor.fe.fe.unique);
1407     DPFV2("volid", "u", fe_cursor.fe.fe.volid);
1408     DPFV2("fnext", "u", fe_cursor.fe.fe.fnext);
1409     DPFV2("ncbs", "u", fe_cursor.fe.fe.ncbs);
1410     DPFV2("firstcb", "u", fe_cursor.fe.fe.firstcb);
1411     DPFV2("status", "u", fe_cursor.fe.fe.status);
1412     DPFSC1;
1413     DPFV1("index", "u", fe_cursor.fe.index);
1414     DPFSC0;
1415 }
1416
1417 static void
1418 dump_cb_entry(void)
1419 {
1420     DPFSO0("CBDiskEntry");
1421     DPFSO1("cb");
1422     DPFV2("cnext", "u", cb_cursor.cb.cb.cnext);
1423     DPFV2("fhead", "u", cb_cursor.cb.cb.fhead);
1424     DPFV2("thead", "u", (afs_uint32)cb_cursor.cb.cb.thead);
1425     DPFV2("status", "u", (afs_uint32)cb_cursor.cb.cb.status);
1426     DPFV2("hhead", "u", cb_cursor.cb.cb.hhead);
1427     DPFV2("tprev", "u", cb_cursor.cb.cb.tprev);
1428     DPFV2("tnext", "u", cb_cursor.cb.cb.tnext);
1429     DPFV2("hprev", "u", cb_cursor.cb.cb.hprev);
1430     DPFV2("hnext", "u", cb_cursor.cb.cb.hnext);
1431     DPFSC1;
1432     DPFV1("index", "u", cb_cursor.cb.index);
1433     DPFSC0;
1434 }
1435
1436 #define DPFHMS printf("  ")
1437 #define DPFHS printf("    ")
1438 #define DPFHN(offset) printf("\n%u\t", offset)
1439 #define DPFHD(x) printf("%02X  ", x)
1440 #define DPFHE printf("\n")
1441
1442 static void
1443 hexdump_map(afs_uint32 offset, afs_uint32 len)
1444 {
1445     int i;
1446     unsigned char * p = (unsigned char *)map;
1447     afs_uint32 c32;
1448
1449     if (!len)
1450         return;
1451
1452     if ((offset + len) > map_len) {
1453         fprintf(stderr, "offset + length exceeds memory map size (%u > %u)\n",
1454                 offset+len, map_len);
1455         return;
1456     }
1457
1458     p += offset;
1459     DPFOFF(p);
1460     DPFHN(offset);
1461
1462     for (i = offset % 16; i > 0; i--) {
1463         DPFHS;
1464     }
1465
1466     for (i=0; i < len; i++, p++, offset++) {
1467         if (!(offset % 16)) {
1468             DPFHN(offset);
1469         } else if (!(offset % 8)) {
1470             DPFHMS;
1471         }
1472         DPFHD(*p);
1473     }
1474     DPFHE;
1475 }
1476
1477 static int
1478 get_hdr(void)
1479 {
1480     if (!hdrs.hdr_valid) {
1481         if (map_len < sizeof(struct fs_state_header)) {
1482             fprintf(stderr, "corrupt state dump: fs_state_header larger than memory map\n");
1483             return 1;
1484         }
1485         memcpy(&hdrs.hdr, map, sizeof(hdrs.hdr));
1486         hdrs.hdr_p = map;
1487         hdrs.hdr_valid = 1;
1488     }
1489     return 0;
1490 }
1491
1492 static int
1493 get_h_hdr(void)
1494 {
1495     char * buf;
1496     afs_uint32 hi, lo;
1497
1498     if (hdrs.h_hdr_valid)
1499         return 0;
1500
1501     if (get_hdr())
1502         return 1;
1503
1504     SplitInt64(hdrs.hdr.h_offset, hi, lo);
1505
1506     if (hi) {
1507         fprintf(stderr, "hi offset bits set in h_offset; can't get host_state_header\n");
1508         return 1;
1509     }
1510     if ((lo >= map_len) ||
1511         ((lo + sizeof(struct host_state_header)) > map_len) ||
1512         (lo + sizeof(struct host_state_header) < lo)) {
1513         fprintf(stderr, "h_offset puts host_state_header beyond end of memory map\n");
1514         return 1;
1515     }
1516
1517     buf = (char *) map;
1518     buf += lo;
1519     memcpy(&hdrs.h_hdr, buf, sizeof(struct host_state_header));
1520     hdrs.h_hdr_p = buf;
1521     buf += sizeof(struct host_state_header);
1522     he_cursor.fh = (void *)buf;
1523     return 0;
1524 }
1525
1526 static int
1527 get_cb_hdr(void)
1528 {
1529     char * buf;
1530     afs_uint32 hi, lo;
1531
1532     if (hdrs.cb_hdr_valid)
1533         return 0;
1534
1535     if (get_hdr())
1536         return 1;
1537
1538     SplitInt64(hdrs.hdr.cb_offset, hi, lo);
1539
1540     if (hi) {
1541         fprintf(stderr, "hi offset bits set in cb_offset; can't get callback_state_header\n");
1542         return 1;
1543     }
1544     if ((lo >= map_len) ||
1545         ((lo + sizeof(struct callback_state_header)) > map_len) ||
1546         (lo + sizeof(struct callback_state_header) < lo)) {
1547         fprintf(stderr, "cb_offset puts callback_state_header beyond end of memory map\n");
1548         return 1;
1549     }
1550
1551     buf = (char *) map;
1552     buf += lo;
1553     memcpy(&hdrs.cb_hdr, buf, sizeof(struct callback_state_header));
1554     hdrs.cb_hdr_p = buf;
1555     hdrs.cb_hdr_valid = 1;
1556
1557     SplitInt64(hdrs.cb_hdr.fe_offset, hi, lo);
1558
1559     if (hi) {
1560         fprintf(stderr, "hi offset bits set in fe_offset; can't get callback_state_entry_header\n");
1561         return 1;
1562     }
1563     hi = lo + (hdrs.cb_hdr.nFEs * (sizeof(struct callback_state_entry_header) +
1564                                   sizeof(struct FEDiskEntry)) +
1565                hdrs.cb_hdr.nCBs * sizeof(struct CBDiskEntry));
1566     if ((hi > map_len) ||
1567         (lo > hi)) {
1568         fprintf(stderr, "fe_offset puts callback_state_entry_header beyond end of memory map\n");
1569         return 1;
1570     }
1571
1572     buf = (char *) map;
1573     buf += lo;
1574     fe_cursor.ffe = (void *)buf;
1575
1576     return 0;
1577 }
1578
1579 static int
1580 get_cb_timeout_hdr(void)
1581 {
1582     char * buf;
1583     afs_uint32 hi, lo;
1584
1585     if (hdrs.timeout_hdr_valid)
1586         return 0;
1587
1588     if (get_cb_hdr())
1589         return 1;
1590
1591     SplitInt64(hdrs.cb_hdr.timeout_offset, hi, lo);
1592
1593     if (hi) {
1594         fprintf(stderr, "hi offset bits set in timeout_offset; can't get callback_state_timeout_header\n");
1595         return 1;
1596     }
1597     if ((lo >= map_len) ||
1598         ((lo + sizeof(struct callback_state_timeout_header)) > map_len) ||
1599         (lo + sizeof(struct callback_state_timeout_header) < lo)) {
1600         fprintf(stderr, "timeout_offset puts callback_state_timeout_header beyond end of memory map\n");
1601         return 1;
1602     }
1603
1604     buf = (char *) map;
1605     buf += lo;
1606     memcpy(&hdrs.timeout_hdr, buf, sizeof(struct callback_state_timeout_header));
1607     hdrs.timeout_hdr_p = buf;
1608     hdrs.timeout_hdr_valid = 1;
1609     buf += sizeof(struct callback_state_timeout_header);
1610     hdrs.timeout_p = buf;
1611
1612     return 0;
1613 }
1614
1615 static int
1616 get_cb_timeout(void)
1617 {
1618     char * buf;
1619
1620     if (hdrs.timeout)
1621         return 0;
1622
1623     if (get_cb_timeout_hdr())
1624         return 1;
1625
1626     hdrs.timeout = (afs_uint32 *) calloc(hdrs.timeout_hdr.records, sizeof(afs_uint32));
1627     assert(hdrs.timeout != NULL);
1628     memcpy(hdrs.timeout, hdrs.timeout_p, hdrs.timeout_hdr.records * sizeof(afs_uint32));
1629     return 0;
1630 }
1631
1632 static int
1633 get_cb_fehash_hdr(void)
1634 {
1635     char * buf;
1636     afs_uint32 hi, lo;
1637
1638     if (hdrs.fehash_hdr_valid)
1639         return 0;
1640
1641     if (get_cb_hdr())
1642         return 1;
1643
1644     SplitInt64(hdrs.cb_hdr.fehash_offset, hi, lo);
1645
1646     if (hi) {
1647         fprintf(stderr, "hi offset bits set in fehash_offset; can't get callback_state_fehash_header\n");
1648         return 1;
1649     }
1650     if ((lo >= map_len) ||
1651         ((lo + sizeof(struct callback_state_fehash_header)) > map_len) ||
1652         (lo + sizeof(struct callback_state_fehash_header) < lo)) {
1653         fprintf(stderr, "timeout_offset puts callback_state_fehash_header beyond end of memory map\n");
1654         return 1;
1655     }
1656
1657     buf = (char *) map;
1658     buf += lo;
1659     memcpy(&hdrs.fehash_hdr, buf, sizeof(struct callback_state_fehash_header));
1660     hdrs.fehash_hdr_p = buf;
1661     hdrs.fehash_hdr_valid = 1;
1662     buf += sizeof(struct callback_state_fehash_header);
1663     hdrs.fehash_p = buf;
1664
1665     return 0;
1666 }
1667
1668 static int
1669 get_cb_fehash(void)
1670 {
1671     char * buf;
1672
1673     if (hdrs.fehash)
1674         return 0;
1675
1676     if (get_cb_fehash_hdr())
1677         return 1;
1678
1679     hdrs.fehash = (afs_uint32 *) calloc(hdrs.fehash_hdr.records, sizeof(afs_uint32));
1680     assert(hdrs.fehash != NULL);
1681     memcpy(hdrs.fehash, hdrs.fehash_p, hdrs.fehash_hdr.records * sizeof(afs_uint32));
1682     return 0;
1683 }
1684
1685 static int
1686 get_he(afs_uint32 idx)
1687 {
1688     int i;
1689     char * p;
1690
1691     if (get_h_hdr())
1692         return 1;
1693
1694     if (idx >= hdrs.h_hdr.records)
1695         return 1;
1696
1697     if (he_cursor.idx == idx && he_cursor.hdr_valid && he_cursor.he_valid)
1698         return 0;
1699
1700     he_cursor.hdr_valid = he_cursor.he_valid = 0;
1701
1702     if (he_cache.cursor == NULL) {
1703         he_cache.cursor = (void **) calloc(hdrs.h_hdr.records, sizeof(void *));
1704         assert(he_cache.cursor != NULL);
1705     }
1706
1707     if (idx && he_cache.cursor[idx-1] == NULL) {
1708         for (i = 0; i < idx; i++) {
1709             if (he_cache.cursor[i] == NULL) {
1710                 get_he(i);
1711             }
1712         }
1713     }
1714
1715     if (!idx) {
1716         he_cursor.cursor = he_cursor.fh;
1717     } else if (he_cursor.cursor == he_cache.cursor[idx-1]) {
1718         p = (char *)he_cursor.cursor;
1719         p += he_cursor.hdr.len;
1720         he_cursor.cursor = (void *)p;
1721     } else {
1722         he_cursor.cursor = he_cache.cursor[idx-1];
1723         if (get_he_hdr())
1724             return 1;
1725         p = (char *)he_cursor.cursor;
1726         p += he_cursor.hdr.len;
1727         he_cursor.cursor = (void *)p;
1728     }
1729
1730     he_cursor.idx = idx;
1731     he_cache.cursor[idx] = he_cursor.cursor;
1732
1733     if (get_he_hdr())
1734         return 1;
1735     if (get_he_entry())
1736         return 1;
1737
1738     return 0;
1739 }
1740
1741 static int
1742 get_he_hdr(void)
1743 {
1744     memcpy(&he_cursor.hdr, he_cursor.cursor, sizeof(struct host_state_entry_header));
1745     he_cursor.hdr_valid = 1;
1746     return 0;
1747 }
1748
1749 static int
1750 get_he_entry(void)
1751 {
1752     char * p;
1753
1754     if (!he_cursor.hdr_valid) {
1755         if (get_he_hdr()) {
1756             return 1;
1757         }
1758     }
1759
1760     p = (char *) he_cursor.cursor;
1761     p += sizeof(struct host_state_entry_header);
1762
1763     memcpy(&he_cursor.he, p, sizeof(struct hostDiskEntry));
1764
1765     he_cursor.he_valid = 1;
1766     p += sizeof(struct hostDiskEntry);
1767     he_cursor.ifp = (void *)p;
1768     if (he_cursor.hdr.interfaces) {
1769         p += sizeof(struct Interface) + ((he_cursor.hdr.interfaces-1)*sizeof(struct AddrPort));
1770         he_cursor.hcps = (void *)p;
1771     } else {
1772         he_cursor.hcps = he_cursor.ifp;
1773     }
1774     return 0;
1775 }
1776
1777 static int
1778 get_fe(afs_uint32 idx)
1779 {
1780     int i;
1781     char * p;
1782
1783     cb_cursor.cb_valid = 0;
1784
1785     if (get_cb_hdr())
1786         return 1;
1787
1788     if (idx >= hdrs.cb_hdr.nFEs)
1789         return 1;
1790
1791     if (fe_cursor.idx == idx && fe_cursor.hdr_valid && fe_cursor.fe_valid)
1792         return 0;
1793
1794     fe_cursor.hdr_valid = fe_cursor.fe_valid = 0;
1795
1796     if (fe_cache.cursor == NULL) {
1797         fe_cache.cursor = (void **) calloc(hdrs.cb_hdr.nFEs, sizeof(void *));
1798         assert(fe_cache.cursor != NULL);
1799     }
1800
1801     if (idx && fe_cache.cursor[idx-1] == NULL) {
1802         for (i = 0; i < idx; i++) {
1803             if (fe_cache.cursor[i] == NULL) {
1804                 get_fe(i);
1805             }
1806         }
1807     }
1808
1809     if (!idx) {
1810         fe_cursor.cursor = fe_cursor.ffe;
1811     } else if (fe_cursor.cursor == fe_cache.cursor[idx-1]) {
1812         p = (char *)fe_cursor.cursor;
1813         p += fe_cursor.hdr.len;
1814         fe_cursor.cursor = (void *)p;
1815     } else {
1816         fe_cursor.cursor = fe_cache.cursor[idx-1];
1817         if (get_fe_hdr())
1818             return 1;
1819         p = (char *)fe_cursor.cursor;
1820         p += fe_cursor.hdr.len;
1821         fe_cursor.cursor = (void *)p;
1822     }
1823
1824     fe_cursor.idx = idx;
1825     fe_cache.cursor[idx] = fe_cursor.cursor;
1826
1827     if (get_fe_hdr())
1828         return 1;
1829     if (get_fe_entry())
1830         return 1;
1831
1832     return 0;
1833 }
1834
1835 static int
1836 get_fe_hdr(void)
1837 {
1838     memcpy(&fe_cursor.hdr, fe_cursor.cursor, sizeof(struct callback_state_entry_header));
1839     fe_cursor.hdr_valid = 1;
1840     return 0;
1841 }
1842
1843 static int
1844 get_fe_entry(void)
1845 {
1846     char * p;
1847
1848     if (!fe_cursor.hdr_valid) {
1849         if (get_fe_hdr()) {
1850             return 1;
1851         }
1852     }
1853
1854     p = (char *) fe_cursor.cursor;
1855     p += sizeof(struct callback_state_entry_header);
1856
1857     memcpy(&fe_cursor.fe, p, sizeof(struct FEDiskEntry));
1858
1859     fe_cursor.fe_valid = 1;
1860     p += sizeof(struct FEDiskEntry);
1861     fe_cursor.fcb = (void *)p;
1862     return 0;
1863 }
1864
1865 static int
1866 get_cb(afs_uint32 idx)
1867 {
1868     int i;
1869     char * p;
1870
1871     if (get_fe(fe_cursor.idx))
1872         return 1;
1873
1874     if (idx >= fe_cursor.hdr.nCBs)
1875         return 1;
1876
1877     if (idx == cb_cursor.idx && cb_cursor.cb_valid)
1878         return 0;
1879
1880     cb_cursor.cb_valid = 0;
1881
1882     p = (char *)fe_cursor.fcb;
1883     p += idx * sizeof(struct CBDiskEntry);
1884     cb_cursor.cursor = (void *)p;
1885
1886     cb_cursor.idx = idx;
1887
1888     if (get_cb_entry())
1889         return 1;
1890
1891     return 0;
1892 }
1893
1894 static int
1895 get_cb_entry(void)
1896 {
1897     memcpy(&cb_cursor.cb, cb_cursor.cursor, sizeof(struct CBDiskEntry));
1898     cb_cursor.cb_valid = 1;
1899     return 0;
1900 }
1901
1902 static int
1903 find_he_by_index(afs_uint32 idx)
1904 {
1905     int i;
1906
1907     if (get_h_hdr()) {
1908         return 1;
1909     }
1910
1911     for (i = 0; i < hdrs.h_hdr.records; i++) {
1912         if (get_he(i)) {
1913             fprintf(stderr, "error getting he %d\n", i);
1914             return 1;
1915         }
1916         if (he_cursor.he.index == idx)
1917             break;
1918     }
1919
1920     if (i < hdrs.h_hdr.records) {
1921         dump_this_he();
1922         return 0;
1923     }
1924     return 1;
1925 }
1926
1927 static int
1928 find_fe_by_index(afs_uint32 idx)
1929 {
1930     int i;
1931
1932     if (get_cb_hdr()) {
1933         return 1;
1934     }
1935
1936     for (i = 0; i < hdrs.cb_hdr.nFEs; i++) {
1937         if (get_fe(i)) {
1938             fprintf(stderr, "error getting fe %d\n", i);
1939             return 1;
1940         }
1941         if (fe_cursor.fe.index == idx)
1942             break;
1943     }
1944
1945     if (i < hdrs.cb_hdr.nFEs) {
1946         dump_this_fe();
1947         return 0;
1948     }
1949     return 1;
1950 }
1951
1952 static int
1953 find_fe_by_fid(afs_uint32 volid, afs_uint32 vnode, afs_uint32 unique)
1954 {
1955     int i;
1956
1957     if (get_cb_hdr()) {
1958         return 1;
1959     }
1960
1961     for (i = 0; i < hdrs.cb_hdr.nFEs; i++) {
1962         if (get_fe(i)) {
1963             fprintf(stderr, "error getting fe %d\n", i);
1964             return 1;
1965         }
1966         if ((fe_cursor.fe.fe.unique == unique) &&
1967             (fe_cursor.fe.fe.volid == volid) &&
1968             (fe_cursor.fe.fe.vnode == vnode))
1969             break;
1970     }
1971
1972     if (i < hdrs.cb_hdr.nFEs) {
1973         dump_this_fe();
1974         return 0;
1975     }
1976     return 1;
1977 }
1978
1979 static int
1980 find_cb_by_index(afs_uint32 idx)
1981 {
1982     int i;
1983
1984     if (get_fe_hdr()) {
1985         return 1;
1986     }
1987
1988     for (i = 0; i < fe_cursor.hdr.nCBs; i++) {
1989         if (get_cb(i)) {
1990             fprintf(stderr, "error getting cb %d\n", i);
1991             return 1;
1992         }
1993         if (cb_cursor.cb.index == idx)
1994             break;
1995     }
1996
1997     if (i < fe_cursor.hdr.nCBs) {
1998         dump_this_cb();
1999         return 0;
2000     }
2001     return 1;
2002 }
2003
2004 #endif /* AFS_DEMAND_ATTACH_FS */