Commit | Line | Data |
---|---|---|
805e021f CE |
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 */ |