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