2 * Copyright 2006, Sine Nomine Associates and others.
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
12 * fileserver state serialization
17 #include <afsconfig.h>
18 #include <afs/param.h>
24 #include <netinet/in.h>
32 #include <afs/afs_assert.h>
35 #include <afs/afsint.h>
36 #include <afs/rxgen_consts.h>
38 #include <afs/errors.h>
39 #include <afs/ihandle.h>
40 #include <afs/vnode.h>
41 #include <afs/volume.h>
42 #ifdef AFS_ATHENA_STDENV
46 #include <afs/ptclient.h>
47 #include <afs/prs_fs.h>
48 #include <afs/afsutil.h>
50 #include <afs/cellconfig.h>
52 #include "../util/afsutil_prototypes.h"
53 #include "../viced/viced.h"
54 #include "../viced/host.h"
55 #include "../viced/callback.h"
56 #include "serialize_state.h"
58 #include <sys/types.h>
64 #ifndef AFS_DEMAND_ATTACH_FS
66 main (int argc, char ** argv)
68 fprintf(stderr, "%s is only supported for demand attach fileservers\n",
69 argv[0] ? argv[0] : "state analyzer");
72 #else /* AFS_DEMAND_ATTACH_FS */
74 static void usage(char * prog);
75 static int openFile(char * path);
76 static void initState(void);
78 static void banner(void);
79 static void prompt(void);
81 static void print_help(void);
82 static void print_global_help(void);
83 static void print_h_help(void);
84 static void print_fe_help(void);
85 static void print_cb_help(void);
87 static void dump_hdr(void);
88 static void dump_h_hdr(void);
89 static void dump_cb_hdr(void);
91 static void dump_cb_timeout(void);
92 static void dump_cb_fehash(void);
94 static void dump_all_hes(void);
95 static void dump_all_fes(void);
96 static void dump_all_cbs(void);
98 static void dump_he(afs_uint32 idx);
99 static void dump_fe(afs_uint32 idx);
100 static void dump_cb(afs_uint32 idx);
101 static void dump_this_he(void);
102 static void dump_this_fe(void);
103 static void dump_this_cb(void);
104 static void dump_next_he(void);
105 static void dump_next_fe(void);
106 static void dump_next_cb(void);
107 static void dump_prev_he(void);
108 static void dump_prev_fe(void);
109 static void dump_prev_cb(void);
110 static void dump_first_he(void);
111 static void dump_first_fe(void);
112 static void dump_first_cb(void);
113 static void dump_last_he(void);
114 static void dump_last_fe(void);
115 static void dump_last_cb(void);
116 static void dump_he_hdr(void);
117 static void dump_he_entry(void);
118 static void dump_he_interfaces(void);
119 static void dump_he_hcps(void);
120 static void dump_fe_hdr(void);
121 static void dump_fe_entry(void);
122 static void dump_cb_entry(void);
124 static void hexdump_map(afs_uint32 offset, afs_uint32 len);
126 static int get_hdr(void);
127 static int get_h_hdr(void);
128 static int get_cb_hdr(void);
129 static int get_cb_timeout_hdr(void);
130 static int get_cb_timeout(void);
131 static int get_cb_fehash_hdr(void);
132 static int get_cb_fehash(void);
133 static int get_he(afs_uint32 idx);
134 static int get_he_hdr(void);
135 static int get_he_entry(void);
136 static int get_fe(afs_uint32 idx);
137 static int get_fe_hdr(void);
138 static int get_fe_entry(void);
139 static int get_cb(afs_uint32 idx);
140 static int get_cb_entry(void);
142 static int find_fe_by_index(afs_uint32 idx);
143 static int find_cb_by_index(afs_uint32 idx);
144 static int find_fe_by_fid(afs_uint32 vol, afs_uint32 vn, afs_uint32 uniq);
147 static int dump_fd = -1;
148 static void * map = NULL;
149 static size_t map_len;
152 struct fs_state_header hdr;
153 struct host_state_header h_hdr;
154 struct callback_state_header cb_hdr;
155 struct callback_state_timeout_header timeout_hdr;
156 struct callback_state_fehash_header fehash_hdr;
157 afs_uint32 * timeout;
160 /* pointers into the memory map */
164 void * timeout_hdr_p;
172 byte timeout_hdr_valid;
173 byte fehash_hdr_valid;
181 struct host_state_entry_header hdr;
182 struct hostDiskEntry he;
196 struct callback_state_entry_header hdr;
197 struct FEDiskEntry fe;
209 struct CBDiskEntry cb;
217 fprintf(stderr, "usage: %s [<state dump file>]\n", prog);
221 main(int argc, char ** argv)
224 if (argc > 2 || (argc == 2 && !strcmp(argv[1], "-h"))) {
232 if (openFile(argv[1]))
235 if (openFile((char *)AFSDIR_SERVER_FSSTATE_FILEPATH))
245 openFile(char * path)
248 struct afs_stat status;
250 dump_fd = afs_open(path, O_RDWR);
252 fprintf(stderr, "dump file '%s' failed to open\n", path);
257 printf("opened dump file '%s'\n", path);
259 if (afs_fstat(dump_fd, &status) == -1) {
260 fprintf(stderr, "failed to stat file\n");
265 map_len = status.st_size;
267 map = afs_mmap(NULL, map_len, PROT_READ, MAP_SHARED, dump_fd, 0);
268 if (map == MAP_FAILED) {
269 fprintf(stderr, "failed to mmap file\n");
274 printf("mapped %lu bytes at %"AFS_PTR_FMT"\n", (unsigned long)map_len, map);
279 munmap(map, map_len);
293 hdrs.hdr_valid = hdrs.h_hdr_valid = hdrs.cb_hdr_valid = 0;
294 he_cursor.cursor = fe_cursor.cursor = cb_cursor.cursor = NULL;
295 he_cursor.fh = fe_cursor.ffe = fe_cursor.fcb = NULL;
296 he_cache.cursor = fe_cache.cursor = NULL;
302 fprintf(stderr, "demand attach fs\n");
303 fprintf(stderr, "fileserver state analyzer\n");
304 fprintf(stderr, "version 0.1\n");
307 #define PROGNAME "fs state analyzer"
313 char prev_input[256];
321 } mode = PR_GLOBAL_MODE, next_mode;
324 input[0] = prev_input[0] = '\0';
330 printf(PROGNAME "> ");
333 printf(PROGNAME ": h(%d)> ", he_cursor.idx);
336 printf(PROGNAME ": fe(%d)> ", fe_cursor.idx);
339 printf(PROGNAME ": fe(%d):cb(%d)> ", fe_cursor.idx, cb_cursor.idx);
342 fprintf(stderr, "prompt state broken; aborting\n");
345 fgets(input, 256, stdin);
347 if (!strcmp(input, "")) {
348 /* repeat last command */
349 if (!strcmp(prev_input, "")) {
352 strlcpy(input, prev_input, sizeof(input));
354 /* save command for repetition */
355 strlcpy(prev_input, input, sizeof(prev_input));
358 tok = strtok(input, " \t\n");
360 while (tok && !strcmp(tok, ";")) {
361 tok = strtok(NULL, "; \t\n");
368 if (!strcasecmp(tok, "exit")) {
370 } else if (!strcasecmp(tok, "quit")) {
373 next_mode = PR_FE_MODE;
377 next_mode = PR_GLOBAL_MODE;
382 } else if (!strcasecmp(tok, "h")) {
383 tok = strtok(NULL, " \t");
389 } else if (!strcasecmp(tok, "fe")) {
390 tok = strtok(NULL, " \t");
396 } else if (!strcasecmp(tok, "fs")) {
397 tok = strtok(NULL, " \t");
398 mode = PR_GLOBAL_MODE;
403 } else if (!strcasecmp(tok, "cb")) {
404 tok = strtok(NULL, " \t");
410 } else if (!strcasecmp(tok, "help")) {
425 } else if (!strcasecmp(tok, "hexdump")) {
426 tok = strtok(NULL, " \t");
428 hexdump_map(0, map_len);
431 if (sscanf(tok, "%u", &x) != 1) {
432 fprintf(stderr, "hexdump parse error 1\n");
436 tok = strtok(NULL, " \t");
438 hexdump_map(x, map_len - x);
441 if (sscanf(tok, "%u", &y) != 1) {
442 fprintf(stderr, "hexdump parse error 2\n");
446 } else if (!strcasecmp(tok, "hdr")) {
460 } else if (!strcasecmp(tok, "this")) {
472 fprintf(stderr, "command not valid for this mode\n");
474 } else if (!strcasecmp(tok, "next")) {
486 fprintf(stderr, "command not valid for this mode\n");
488 } else if (!strcasecmp(tok, "prev")) {
500 fprintf(stderr, "command not valid for this mode\n");
502 } else if (!strcasecmp(tok, "first")) {
514 fprintf(stderr, "command not valid for this mode\n");
516 } else if (!strcasecmp(tok, "last")) {
528 fprintf(stderr, "command not valid for this mode\n");
530 } else if (!strcasecmp(tok, "dump")) {
542 fprintf(stderr, "command not valid for this mode\n");
544 } else if (!strcasecmp(tok, "find")) {
545 tok = strtok(NULL, " \t");
546 if (!tok || strcasecmp(tok, "by")) {
548 fprintf(stderr, "find syntax error 1 (%s)\n",
549 (tok) ? tok : "nil");
552 tok = strtok(NULL, " \t");
554 fprintf(stderr, "find syntax error 2\n");
559 fprintf(stderr, "not implemented yet\n");
562 if (!strcasecmp(tok, "index")) {
563 tok = strtok(NULL, " \t");
564 if (!tok || sscanf(tok, "%u", &x) != 1) {
566 fprintf(stderr, "find syntax error 3\n");
569 if (find_fe_by_index(x)) {
570 fprintf(stderr, "find returned no results\n");
572 } else if (!strcasecmp(tok, "fid")) {
573 tok = strtok(NULL, "(), \t");
574 if (!tok || sscanf(tok, "%u", &x) != 1) {
576 fprintf(stderr, "find syntax error 4\n");
579 tok = strtok(NULL, "(), \t");
580 if (!tok || sscanf(tok, "%u", &y) != 1) {
582 fprintf(stderr, "find syntax error 5\n");
585 tok = strtok(NULL, "(), \t");
586 if (!tok || sscanf(tok, "%u", &z) != 1) {
588 fprintf(stderr, "find syntax error 6\n");
591 if (find_fe_by_fid(x,y,z)) {
592 fprintf(stderr, "find returned no results\n");
595 fprintf(stderr, "unsupported filter type\n");
599 if (!strcasecmp(tok, "index")) {
600 tok = strtok(NULL, " \t");
601 if (!tok || sscanf(tok, "%u", &x) != 1) {
603 fprintf(stderr, "find syntax error 3\n");
606 if (find_cb_by_index(x)) {
607 fprintf(stderr, "find returned no results\n");
610 fprintf(stderr, "unsupported filter type\n");
614 fprintf(stderr, "find not supported for this menu\n");
616 } else if (!strcspn(tok, "0123456789")) {
617 if (sscanf(tok, "%u", &x) == 1) {
629 fprintf(stderr, "command not available from this menu\n");
632 fprintf(stderr, "input parse error ('%s')\n", tok);
634 } else if (mode == PR_FE_MODE) {
635 if (!strcmp(tok, "timeout")) {
637 } else if (!strcmp(tok, "hash")) {
641 fprintf(stderr, "unknown command\n");
643 tok = strtok(NULL, " \t");
651 printf("\th <...> -- host menu commands\n");
652 printf("\tfe <...> -- FileEntry menu commands\n");
653 printf("\tcb <...> -- CallBack menu commands\n");
654 printf("\thexdump [<offset> [<len>]]\n\t\t -- hex dump the raw data\n");
655 printf("\tquit -- quit this menu\n");
656 printf("\texit -- exit the debugger\n");
657 printf("\thelp -- this help message\n");
661 print_global_help(void)
663 printf("\thdr -- display the fs_state_header struct\n");
669 printf("\thdr -- display the host_state_header struct\n");
670 printf("\tfirst -- display the first host\n");
671 printf("\tprev -- display the previous host\n");
672 printf("\tthis -- display this host\n");
673 printf("\tnext -- display the next host\n");
674 printf("\tlast -- display the last host\n");
675 printf("\tdump -- display all hosts\n");
681 printf("\thdr -- display the callback_state_header struct\n");
682 printf("\tfirst -- display the first FE\n");
683 printf("\tprev -- display the previous FE\n");
684 printf("\tthis -- display this FE\n");
685 printf("\tnext -- display the next FE\n");
686 printf("\tlast -- display the last FE\n");
687 printf("\tdump -- display all FEs\n");
688 printf("\ttimeout -- display the timeout queue heads\n");
689 printf("\thash -- display the file entry hash buckets\n");
690 printf("\tfind by index <id>\n\t\t -- find an fe by its array index\n");
691 printf("\tfind by fid <(vol,vnode,unique)>\n\t\t -- find an fe by its AFSFid\n");
697 printf("\thdr -- display the callback_state_entry_header struct\n");
698 printf("\tfirst -- display the first CB\n");
699 printf("\tprev -- display the previous CB\n");
700 printf("\tthis -- display this CB\n");
701 printf("\tnext -- display the next CB\n");
702 printf("\tlast -- display the last CB\n");
703 printf("\tdump -- display all CBs\n");
707 #define DPFTB1 "\t\t"
708 #define DPFTB2 "\t\t\t"
710 #define DPFOFF(addr) \
712 char * _p = (char *)addr; \
713 char * _m = (char *)map; \
714 printf("loading structure from address %"AFS_PTR_FMT" (offset %ld)\n", \
715 addr, (long)(_p-_m)); \
719 #define DPFSO(T, name) printf(T "%s = {\n", name)
720 #define DPFSO0(name) DPFSO(DPFTB0, name)
721 #define DPFSO1(name) DPFSO(DPFTB1, name)
722 #define DPFSC(T) printf(T "}\n")
723 #define DPFSC0 DPFSC(DPFTB0)
724 #define DPFSC1 DPFSC(DPFTB1)
727 #define DPFAO(T1, T2, name) printf(T1 "%s =\n" T2 "{ ", name)
728 #define DPFAO0(name) DPFAO(DPFTB0, DPFTB1, name)
729 #define DPFAO1(name) DPFAO(DPFTB1, DPFTB2, name)
730 #define DPFAC0 printf(" }\n")
731 #define DPFAC1 DPFAC0
732 #define DPFA1 printf(DPFTB1 " ")
733 #define DPFA2 printf(DPFTB2 " ")
734 #define DPFAN printf("\n")
735 #define DPFALE(type, var) printf("%" type, var)
736 #define DPFAE(type, var) printf("%" type ",\t", var)
739 #define DPFV(T, name, type, var) printf(T "%s = %" type "\n", name, var)
740 #define DPFV1(name, type, var) DPFV(DPFTB1, name, type, var)
741 #define DPFV2(name, type, var) DPFV(DPFTB2, name, type, var)
744 #define DPFX(T, name, var) printf(T "%s = 0x%x\n", name, var)
745 #define DPFX1(name, var) DPFX(DPFTB1, name, var)
746 #define DPFX2(name, var) DPFX(DPFTB2, name, var)
749 #define DPFS(T, name, var) printf(T "%s = \"%s\"\n", name, var)
750 #define DPFS1(name, var) DPFS(DPFTB1, name, var)
751 #define DPFS2(name, var) DPFS(DPFTB2, name, var)
754 #define DPFT(T, name, var) \
757 printf(T "%s = \"%.24s\"\n", name, ctime(&t)); \
759 #define DPFT1(name, var) DPFT(DPFTB1, name, var)
760 #define DPFT2(name, var) DPFT(DPFTB2, name, var)
772 DPFSO0("fs_state_header");
774 DPFX2("magic", hdrs.hdr.stamp.magic);
775 DPFV2("version", "u", hdrs.hdr.stamp.version);
777 DPFT1("timestamp", hdrs.hdr.timestamp);
778 DPFV1("sys_name", "u", hdrs.hdr.sys_name);
780 afsUUID_to_string(&hdrs.hdr.server_uuid, uuid_str, sizeof(uuid_str));
781 DPFS1("server_uuid", uuid_str);
782 DPFV1("valid", "d", hdrs.hdr.valid);
783 DPFV1("endianness", "d", hdrs.hdr.endianness);
784 DPFV1("stats_detailed", "d", hdrs.hdr.stats_detailed);
786 SplitInt64(hdrs.hdr.h_offset, hi, lo);
788 DPFV2("hi", "u", hi);
789 DPFV2("lo", "u", lo);
792 SplitInt64(hdrs.hdr.cb_offset, hi, lo);
794 DPFV2("hi", "u", hi);
795 DPFV2("lo", "u", lo);
798 DPFS1("server_version_string", hdrs.hdr.server_version_string);
801 if (hdrs.hdr.stamp.magic != FS_STATE_MAGIC) {
802 fprintf(stderr, "* magic check failed\n");
804 if (hdrs.hdr.stamp.version != FS_STATE_VERSION) {
805 fprintf(stderr, "* version check failed\n");
815 DPFOFF(hdrs.h_hdr_p);
816 DPFSO0("host_state_header");
818 DPFX2("magic", hdrs.h_hdr.stamp.magic);
819 DPFV2("version", "u", hdrs.h_hdr.stamp.version);
821 DPFV1("records", "u", hdrs.h_hdr.records);
822 DPFV1("index_max", "u", hdrs.h_hdr.index_max);
825 if (hdrs.h_hdr.stamp.magic != HOST_STATE_MAGIC) {
826 fprintf(stderr, "* magic check failed\n");
828 if (hdrs.h_hdr.stamp.version != HOST_STATE_VERSION) {
829 fprintf(stderr, "* version check failed\n");
841 DPFOFF(hdrs.cb_hdr_p);
842 DPFSO0("callback_state_header");
844 DPFX2("magic", hdrs.cb_hdr.stamp.magic);
845 DPFV2("version", "u", hdrs.cb_hdr.stamp.version);
847 DPFV1("nFEs", "u", hdrs.cb_hdr.nFEs);
848 DPFV1("nCBs", "u", hdrs.cb_hdr.nCBs);
849 DPFV1("fe_max", "u", hdrs.cb_hdr.fe_max);
850 DPFV1("cb_max", "u", hdrs.cb_hdr.cb_max);
851 DPFV1("tfirst", "d", hdrs.cb_hdr.tfirst);
853 SplitInt64(hdrs.cb_hdr.timeout_offset, hi, lo);
854 DPFSO1("timeout_offset");
855 DPFV2("hi", "u", hi);
856 DPFV2("lo", "u", lo);
859 SplitInt64(hdrs.cb_hdr.fehash_offset, hi, lo);
860 DPFSO1("fehash_offset");
861 DPFV2("hi", "u", hi);
862 DPFV2("lo", "u", lo);
865 SplitInt64(hdrs.cb_hdr.fe_offset, hi, lo);
867 DPFV2("hi", "u", hi);
868 DPFV2("lo", "u", lo);
873 if (hdrs.cb_hdr.stamp.magic != CALLBACK_STATE_MAGIC) {
874 fprintf(stderr, "* magic check failed\n");
876 if (hdrs.cb_hdr.stamp.version != CALLBACK_STATE_VERSION) {
877 fprintf(stderr, "* version check failed\n");
882 dump_cb_timeout(void)
889 if (get_cb_timeout_hdr())
892 if (get_cb_timeout())
895 DPFOFF(hdrs.timeout_hdr_p);
896 DPFSO0("callback_state_timeout_header");
897 DPFX1("magic", hdrs.timeout_hdr.magic);
898 DPFV1("len", "u", hdrs.timeout_hdr.len);
899 DPFV1("records", "u", hdrs.timeout_hdr.records);
902 if (hdrs.timeout_hdr.magic != CALLBACK_STATE_TIMEOUT_MAGIC) {
903 fprintf(stderr, "* magic check failed\n");
906 DPFOFF(hdrs.timeout_p);
908 for (i = 0; i < 127; i++) {
909 DPFAE("u", hdrs.timeout[i]);
915 DPFALE("u", hdrs.timeout[127]);
927 if (get_cb_fehash_hdr())
933 DPFOFF(hdrs.fehash_hdr_p);
934 DPFSO0("callback_state_fehash_header");
935 DPFX1("magic", hdrs.fehash_hdr.magic);
936 DPFV1("len", "u", hdrs.fehash_hdr.len);
937 DPFV1("records", "u", hdrs.fehash_hdr.records);
940 if (hdrs.fehash_hdr.magic != CALLBACK_STATE_FEHASH_MAGIC) {
941 fprintf(stderr, "* magic check failed\n");
944 DPFOFF(hdrs.fehash_p);
946 for (i = 0; i < hdrs.fehash_hdr.records - 1; i++) {
947 DPFAE("u", hdrs.fehash[i]);
953 DPFALE("u", hdrs.fehash[hdrs.fehash_hdr.records-1]);
963 fprintf(stderr, "error getting host_state_header\n");
967 for (i = 0; i < hdrs.h_hdr.records; i++) {
978 fprintf(stderr, "error getting callback_state_header\n");
982 for (i = 0; i < hdrs.cb_hdr.nFEs; i++) {
993 fprintf(stderr, "error getting callback_state_entry_header\n");
997 for (i = 0; i < fe_cursor.hdr.nCBs; i++) {
1003 dump_he(afs_uint32 idx)
1006 fprintf(stderr, "error getting he %d\n", idx);
1010 DPFOFF(he_cursor.cursor);
1013 dump_he_interfaces();
1018 dump_fe(afs_uint32 idx)
1021 fprintf(stderr, "error getting fe %d\n", idx);
1025 DPFOFF(fe_cursor.cursor);
1031 dump_cb(afs_uint32 idx)
1034 fprintf(stderr, "error getting cb %d\n", idx);
1038 DPFOFF(cb_cursor.cursor);
1045 dump_he(he_cursor.idx);
1051 dump_fe(fe_cursor.idx);
1057 dump_cb(cb_cursor.idx);
1064 fprintf(stderr, "error getting host_state_header\n");
1068 if ((he_cursor.idx + 1) >= hdrs.h_hdr.records) {
1069 fprintf(stderr, "no more HEs\n");
1073 dump_he(he_cursor.idx+1);
1080 fprintf(stderr, "error getting callback_state_header\n");
1084 if ((fe_cursor.idx + 1) >= hdrs.cb_hdr.nFEs) {
1085 fprintf(stderr, "no more FEs\n");
1089 dump_fe(fe_cursor.idx+1);
1096 fprintf(stderr, "error getting callback_state_entry_header\n");
1100 if ((cb_cursor.idx + 1) >= fe_cursor.hdr.nCBs) {
1101 fprintf(stderr, "no more CBs\n");
1105 dump_cb(cb_cursor.idx+1);
1111 if (!he_cursor.idx) {
1112 fprintf(stderr, "no more HEs\n");
1116 dump_he(he_cursor.idx-1);
1122 if (!fe_cursor.idx) {
1123 fprintf(stderr, "no more FEs\n");
1127 dump_fe(fe_cursor.idx-1);
1133 if (!cb_cursor.idx) {
1134 fprintf(stderr, "no more CBs\n");
1138 dump_cb(cb_cursor.idx-1);
1145 fprintf(stderr, "error getting callback_state_header\n");
1149 if (!hdrs.cb_hdr.nFEs) {
1150 fprintf(stderr, "no FEs present\n");
1161 fprintf(stderr, "error getting host_state_header\n");
1165 if (!hdrs.h_hdr.records) {
1166 fprintf(stderr, "no HEs present\n");
1177 fprintf(stderr, "error getting callback_state_entry_header\n");
1181 if (!fe_cursor.hdr.nCBs) {
1182 fprintf(stderr, "no CBs present\n");
1193 fprintf(stderr, "error getting host_state_header\n");
1197 if (!hdrs.h_hdr.records) {
1198 fprintf(stderr, "no HEs present\n");
1202 dump_he(hdrs.h_hdr.records-1);
1209 fprintf(stderr, "error getting callback_state_header\n");
1213 if (!hdrs.cb_hdr.nFEs) {
1214 fprintf(stderr, "no FEs present\n");
1218 dump_fe(hdrs.cb_hdr.nFEs-1);
1225 fprintf(stderr, "error getting callback_state_entry_header\n");
1229 if (!fe_cursor.hdr.nCBs) {
1230 fprintf(stderr, "no CBs present\n");
1234 dump_cb(fe_cursor.hdr.nCBs-1);
1240 DPFSO0("host_state_entry_header");
1241 DPFX1("magic", he_cursor.hdr.magic);
1242 DPFV1("len", "u", he_cursor.hdr.len);
1243 DPFV1("interfaces", "u", he_cursor.hdr.interfaces);
1244 DPFV1("hcps", "u", he_cursor.hdr.hcps);
1247 if (he_cursor.hdr.magic != HOST_STATE_ENTRY_MAGIC) {
1248 fprintf(stderr, "* magic check failed\n");
1256 DPFSO0("hostDiskEntry");
1257 DPFS1("host", afs_inet_ntoa_r(he_cursor.he.host, hoststr));
1258 DPFV1("port", "u", he_cursor.he.port);
1259 DPFX1("hostFlags", he_cursor.he.hostFlags);
1260 DPFV1("Console", "u", he_cursor.he.Console);
1261 DPFV1("hcpsfailed", "u", he_cursor.he.hcpsfailed);
1262 DPFV1("hcps_valid", "u", he_cursor.he.hcps_valid);
1263 if (hdrs.hdr.stats_detailed) {
1264 #ifdef FS_STATS_DETAILED
1265 DPFV1("InSameNetwork", "u", he_cursor.he.InSameNetwork);
1267 DPFV1("InSameNetwork", "u", he_cursor.he.padding1[0]);
1270 DPFV1("hcps_len", "u", he_cursor.he.hcps_len);
1271 DPFT1("LastCall", he_cursor.he.LastCall);
1272 DPFT1("ActiveCall", he_cursor.he.ActiveCall);
1273 DPFT1("cpsCall", he_cursor.he.cpsCall);
1274 DPFV1("cblist", "u", he_cursor.he.cblist);
1275 DPFV1("index", "u", he_cursor.he.index);
1280 dump_he_interfaces(void)
1283 struct Interface * ifp;
1287 if (!he_cursor.hdr.interfaces)
1290 len = sizeof(struct Interface) + ((he_cursor.hdr.interfaces-1)*sizeof(struct AddrPort));
1291 ifp = (struct Interface *) malloc(len);
1292 assert(ifp != NULL);
1294 memcpy(ifp, he_cursor.ifp, len);
1296 DPFSO0("Interface");
1297 DPFV1("numberOfInterfaces", "u", ifp->numberOfInterfaces);
1299 afsUUID_to_string(&ifp->uuid, temp_str, sizeof(temp_str));
1300 DPFS1("uuid", temp_str);
1301 for (i = 0; i < he_cursor.hdr.interfaces; i++) {
1302 snprintf(temp_str, sizeof(temp_str), "interface[%d]", i);
1304 DPFS2("addr", afs_inet_ntoa_r(ifp->interface[i].addr, hoststr));
1305 DPFV2("port", "u", ifp->interface[i].port);
1311 if (he_cursor.hdr.interfaces != ifp->numberOfInterfaces) {
1312 fprintf(stderr, "* interface count mismatch between header and Interface struct\n");
1323 if (!he_cursor.hdr.hcps)
1326 len = (he_cursor.hdr.hcps)*sizeof(afs_uint32);
1327 hcps = (afs_int32 *) malloc(len);
1328 assert(hcps != NULL);
1329 memcpy(hcps, he_cursor.hcps, len);
1332 DPFAO1("prlist_val");
1333 for (i = 0; i < he_cursor.hdr.hcps - 1; i++) {
1334 DPFAE("d", hcps[i]);
1340 DPFALE("d", hcps[he_cursor.hdr.hcps-1]);
1349 DPFSO0("callback_state_entry_header");
1350 DPFX1("magic", fe_cursor.hdr.magic);
1351 DPFV1("len", "u", fe_cursor.hdr.len);
1352 DPFV1("nCBs", "u", fe_cursor.hdr.nCBs);
1355 if (fe_cursor.hdr.magic != CALLBACK_STATE_ENTRY_MAGIC) {
1356 fprintf(stderr, "* magic check failed\n");
1363 DPFSO0("FEDiskEntry");
1365 DPFV2("vnode", "u", fe_cursor.fe.fe.vnode);
1366 DPFV2("unique", "u", fe_cursor.fe.fe.unique);
1367 DPFV2("volid", "u", fe_cursor.fe.fe.volid);
1368 DPFV2("fnext", "u", fe_cursor.fe.fe.fnext);
1369 DPFV2("ncbs", "u", fe_cursor.fe.fe.ncbs);
1370 DPFV2("firstcb", "u", fe_cursor.fe.fe.firstcb);
1371 DPFV2("status", "u", fe_cursor.fe.fe.status);
1373 DPFV1("index", "u", fe_cursor.fe.index);
1380 DPFSO0("CBDiskEntry");
1382 DPFV2("cnext", "u", cb_cursor.cb.cb.cnext);
1383 DPFV2("fhead", "u", cb_cursor.cb.cb.fhead);
1384 DPFV2("thead", "u", (afs_uint32)cb_cursor.cb.cb.thead);
1385 DPFV2("status", "u", (afs_uint32)cb_cursor.cb.cb.status);
1386 DPFV2("hhead", "u", cb_cursor.cb.cb.hhead);
1387 DPFV2("tprev", "u", cb_cursor.cb.cb.tprev);
1388 DPFV2("tnext", "u", cb_cursor.cb.cb.tnext);
1389 DPFV2("hprev", "u", cb_cursor.cb.cb.hprev);
1390 DPFV2("hnext", "u", cb_cursor.cb.cb.hnext);
1392 DPFV1("index", "u", cb_cursor.cb.index);
1396 #define DPFHMS printf(" ")
1397 #define DPFHS printf(" ")
1398 #define DPFHN(offset) printf("\n%u\t", offset)
1399 #define DPFHD(x) printf("%02X ", x)
1400 #define DPFHE printf("\n")
1403 hexdump_map(afs_uint32 offset, afs_uint32 len)
1406 unsigned char * p = (unsigned char *)map;
1411 if ((offset + len) > map_len) {
1412 fprintf(stderr, "offset + length exceeds memory map size (%u > %lu)\n",
1413 offset+len, (unsigned long)map_len);
1421 for (i = offset % 16; i > 0; i--) {
1425 for (i=0; i < len; i++, p++, offset++) {
1426 if (!(offset % 16)) {
1428 } else if (!(offset % 8)) {
1439 if (!hdrs.hdr_valid) {
1440 if (map_len < sizeof(struct fs_state_header)) {
1441 fprintf(stderr, "corrupt state dump: fs_state_header larger than memory map\n");
1444 memcpy(&hdrs.hdr, map, sizeof(hdrs.hdr));
1457 if (hdrs.h_hdr_valid)
1463 SplitInt64(hdrs.hdr.h_offset, hi, lo);
1466 fprintf(stderr, "hi offset bits set in h_offset; can't get host_state_header\n");
1469 if ((lo >= map_len) ||
1470 ((lo + sizeof(struct host_state_header)) > map_len) ||
1471 (lo + sizeof(struct host_state_header) < lo)) {
1472 fprintf(stderr, "h_offset puts host_state_header beyond end of memory map\n");
1478 memcpy(&hdrs.h_hdr, buf, sizeof(struct host_state_header));
1480 buf += sizeof(struct host_state_header);
1481 he_cursor.fh = (void *)buf;
1491 if (hdrs.cb_hdr_valid)
1497 SplitInt64(hdrs.hdr.cb_offset, hi, lo);
1500 fprintf(stderr, "hi offset bits set in cb_offset; can't get callback_state_header\n");
1503 if ((lo >= map_len) ||
1504 ((lo + sizeof(struct callback_state_header)) > map_len) ||
1505 (lo + sizeof(struct callback_state_header) < lo)) {
1506 fprintf(stderr, "cb_offset puts callback_state_header beyond end of memory map\n");
1512 memcpy(&hdrs.cb_hdr, buf, sizeof(struct callback_state_header));
1513 hdrs.cb_hdr_p = buf;
1514 hdrs.cb_hdr_valid = 1;
1516 SplitInt64(hdrs.cb_hdr.fe_offset, hi, lo);
1519 fprintf(stderr, "hi offset bits set in fe_offset; can't get callback_state_entry_header\n");
1522 hi = lo + (hdrs.cb_hdr.nFEs * (sizeof(struct callback_state_entry_header) +
1523 sizeof(struct FEDiskEntry)) +
1524 hdrs.cb_hdr.nCBs * sizeof(struct CBDiskEntry));
1525 if ((hi > map_len) ||
1527 fprintf(stderr, "fe_offset puts callback_state_entry_header beyond end of memory map\n");
1533 fe_cursor.ffe = (void *)buf;
1539 get_cb_timeout_hdr(void)
1544 if (hdrs.timeout_hdr_valid)
1550 SplitInt64(hdrs.cb_hdr.timeout_offset, hi, lo);
1553 fprintf(stderr, "hi offset bits set in timeout_offset; can't get callback_state_timeout_header\n");
1556 if ((lo >= map_len) ||
1557 ((lo + sizeof(struct callback_state_timeout_header)) > map_len) ||
1558 (lo + sizeof(struct callback_state_timeout_header) < lo)) {
1559 fprintf(stderr, "timeout_offset puts callback_state_timeout_header beyond end of memory map\n");
1565 memcpy(&hdrs.timeout_hdr, buf, sizeof(struct callback_state_timeout_header));
1566 hdrs.timeout_hdr_p = buf;
1567 hdrs.timeout_hdr_valid = 1;
1568 buf += sizeof(struct callback_state_timeout_header);
1569 hdrs.timeout_p = buf;
1575 get_cb_timeout(void)
1580 if (get_cb_timeout_hdr())
1583 hdrs.timeout = (afs_uint32 *) calloc(hdrs.timeout_hdr.records, sizeof(afs_uint32));
1584 assert(hdrs.timeout != NULL);
1585 memcpy(hdrs.timeout, hdrs.timeout_p, hdrs.timeout_hdr.records * sizeof(afs_uint32));
1590 get_cb_fehash_hdr(void)
1595 if (hdrs.fehash_hdr_valid)
1601 SplitInt64(hdrs.cb_hdr.fehash_offset, hi, lo);
1604 fprintf(stderr, "hi offset bits set in fehash_offset; can't get callback_state_fehash_header\n");
1607 if ((lo >= map_len) ||
1608 ((lo + sizeof(struct callback_state_fehash_header)) > map_len) ||
1609 (lo + sizeof(struct callback_state_fehash_header) < lo)) {
1610 fprintf(stderr, "timeout_offset puts callback_state_fehash_header beyond end of memory map\n");
1616 memcpy(&hdrs.fehash_hdr, buf, sizeof(struct callback_state_fehash_header));
1617 hdrs.fehash_hdr_p = buf;
1618 hdrs.fehash_hdr_valid = 1;
1619 buf += sizeof(struct callback_state_fehash_header);
1620 hdrs.fehash_p = buf;
1631 if (get_cb_fehash_hdr())
1634 hdrs.fehash = (afs_uint32 *) calloc(hdrs.fehash_hdr.records, sizeof(afs_uint32));
1635 assert(hdrs.fehash != NULL);
1636 memcpy(hdrs.fehash, hdrs.fehash_p, hdrs.fehash_hdr.records * sizeof(afs_uint32));
1641 get_he(afs_uint32 idx)
1649 if (idx >= hdrs.h_hdr.records)
1652 if (he_cursor.idx == idx && he_cursor.hdr_valid && he_cursor.he_valid)
1655 he_cursor.hdr_valid = he_cursor.he_valid = 0;
1657 if (he_cache.cursor == NULL) {
1658 he_cache.cursor = (void **) calloc(hdrs.h_hdr.records, sizeof(void *));
1659 assert(he_cache.cursor != NULL);
1662 if (idx && he_cache.cursor[idx-1] == NULL) {
1663 for (i = 0; i < idx; i++) {
1664 if (he_cache.cursor[i] == NULL) {
1671 he_cursor.cursor = he_cursor.fh;
1672 } else if (he_cursor.cursor == he_cache.cursor[idx-1]) {
1673 p = (char *)he_cursor.cursor;
1674 p += he_cursor.hdr.len;
1675 he_cursor.cursor = (void *)p;
1677 he_cursor.cursor = he_cache.cursor[idx-1];
1680 p = (char *)he_cursor.cursor;
1681 p += he_cursor.hdr.len;
1682 he_cursor.cursor = (void *)p;
1685 he_cursor.idx = idx;
1686 he_cache.cursor[idx] = he_cursor.cursor;
1699 memcpy(&he_cursor.hdr, he_cursor.cursor, sizeof(struct host_state_entry_header));
1700 he_cursor.hdr_valid = 1;
1709 if (!he_cursor.hdr_valid) {
1715 p = (char *) he_cursor.cursor;
1716 p += sizeof(struct host_state_entry_header);
1718 memcpy(&he_cursor.he, p, sizeof(struct hostDiskEntry));
1720 he_cursor.he_valid = 1;
1721 p += sizeof(struct hostDiskEntry);
1722 he_cursor.ifp = (void *)p;
1723 if (he_cursor.hdr.interfaces) {
1724 p += sizeof(struct Interface) + ((he_cursor.hdr.interfaces-1)*sizeof(struct AddrPort));
1725 he_cursor.hcps = (void *)p;
1727 he_cursor.hcps = he_cursor.ifp;
1733 get_fe(afs_uint32 idx)
1738 cb_cursor.cb_valid = 0;
1743 if (idx >= hdrs.cb_hdr.nFEs)
1746 if (fe_cursor.idx == idx && fe_cursor.hdr_valid && fe_cursor.fe_valid)
1749 fe_cursor.hdr_valid = fe_cursor.fe_valid = 0;
1751 if (fe_cache.cursor == NULL) {
1752 fe_cache.cursor = (void **) calloc(hdrs.cb_hdr.nFEs, sizeof(void *));
1753 assert(fe_cache.cursor != NULL);
1756 if (idx && fe_cache.cursor[idx-1] == NULL) {
1757 for (i = 0; i < idx; i++) {
1758 if (fe_cache.cursor[i] == NULL) {
1765 fe_cursor.cursor = fe_cursor.ffe;
1766 } else if (fe_cursor.cursor == fe_cache.cursor[idx-1]) {
1767 p = (char *)fe_cursor.cursor;
1768 p += fe_cursor.hdr.len;
1769 fe_cursor.cursor = (void *)p;
1771 fe_cursor.cursor = fe_cache.cursor[idx-1];
1774 p = (char *)fe_cursor.cursor;
1775 p += fe_cursor.hdr.len;
1776 fe_cursor.cursor = (void *)p;
1779 fe_cursor.idx = idx;
1780 fe_cache.cursor[idx] = fe_cursor.cursor;
1793 if (!fe_cursor.cursor) {
1794 if(get_fe(fe_cursor.idx)) {
1799 memcpy(&fe_cursor.hdr, fe_cursor.cursor, sizeof(struct callback_state_entry_header));
1800 fe_cursor.hdr_valid = 1;
1809 if (!fe_cursor.hdr_valid) {
1815 p = (char *) fe_cursor.cursor;
1816 p += sizeof(struct callback_state_entry_header);
1818 memcpy(&fe_cursor.fe, p, sizeof(struct FEDiskEntry));
1820 fe_cursor.fe_valid = 1;
1821 p += sizeof(struct FEDiskEntry);
1822 fe_cursor.fcb = (void *)p;
1827 get_cb(afs_uint32 idx)
1831 if (get_fe(fe_cursor.idx))
1834 if (idx >= fe_cursor.hdr.nCBs)
1837 if (idx == cb_cursor.idx && cb_cursor.cb_valid)
1840 cb_cursor.cb_valid = 0;
1842 p = (char *)fe_cursor.fcb;
1843 p += idx * sizeof(struct CBDiskEntry);
1844 cb_cursor.cursor = (void *)p;
1846 cb_cursor.idx = idx;
1857 memcpy(&cb_cursor.cb, cb_cursor.cursor, sizeof(struct CBDiskEntry));
1858 cb_cursor.cb_valid = 1;
1864 find_he_by_index(afs_uint32 idx)
1872 for (i = 0; i < hdrs.h_hdr.records; i++) {
1874 fprintf(stderr, "error getting he %d\n", i);
1877 if (he_cursor.he.index == idx)
1881 if (i < hdrs.h_hdr.records) {
1890 find_fe_by_index(afs_uint32 idx)
1898 for (i = 0; i < hdrs.cb_hdr.nFEs; i++) {
1900 fprintf(stderr, "error getting fe %d\n", i);
1903 if (fe_cursor.fe.index == idx)
1907 if (i < hdrs.cb_hdr.nFEs) {
1915 find_fe_by_fid(afs_uint32 volid, afs_uint32 vnode, afs_uint32 unique)
1923 for (i = 0; i < hdrs.cb_hdr.nFEs; i++) {
1925 fprintf(stderr, "error getting fe %d\n", i);
1928 if ((fe_cursor.fe.fe.unique == unique) &&
1929 (fe_cursor.fe.fe.volid == volid) &&
1930 (fe_cursor.fe.fe.vnode == vnode))
1934 if (i < hdrs.cb_hdr.nFEs) {
1942 find_cb_by_index(afs_uint32 idx)
1950 for (i = 0; i < fe_cursor.hdr.nCBs; i++) {
1952 fprintf(stderr, "error getting cb %d\n", i);
1955 if (cb_cursor.cb.index == idx)
1959 if (i < fe_cursor.hdr.nCBs) {
1966 #endif /* AFS_DEMAND_ATTACH_FS */