Remove DUX/OSF code
[openafs.git] / src / venus / kdump.c
1 /*
2  * Copyright 2000, International Business Machines Corporation 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 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14
15 #include <afs/cmd.h>
16
17 #if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
18 /* Here be hacks. */
19 #ifdef AFS_LINUX24_ENV
20 #define __KERNEL__
21 #include <linux/string.h>
22 #define _STRING_H 1
23 #define _SYS_STATFS_H 1
24 #define _BITS_SIGCONTEXT_H 1
25 #undef USE_UCONTEXT
26 #endif
27
28 #ifdef AFS_LINUX26_ENV
29 /* For some reason, this doesn't get defined in linux/types.h
30    if __KERNEL_STRICT_NAMES is defined. But the definition of
31    struct inode uses it.
32 */
33 #ifndef pgoff_t
34 #define pgoff_t unsigned long
35 #endif
36 #endif
37
38 #include <string.h>
39
40 #ifdef __linux__
41 #define _CFS_HEADER_
42 #define _AFFS_FS_I
43 #define _NFS_FS_I
44 #define _SYSV_FS_SB
45 #define _AFFS_FS_SB
46 #define _NFS_FS_SB
47 #define __LINUX_UFS_FS_SB_H
48 #define _SYSV_FS_I
49 #define _LINUX_CODA_FS_I
50 #define _LINUX_NTFS_FS_SB_H
51 #define _LINUX_NTFS_FS_I_H
52 #define _NCP_FS_SB
53 struct sysv_sb_info {
54 };
55 struct affs_sb_info {
56 };
57 struct ufs_sb_info {
58 };
59 struct nfs_sb_info {
60 };
61 struct nfs_inode_info {
62 };
63 struct sysv_inode_info {
64 };
65 struct coda_inode_info {
66 };
67 struct affs_inode_info {
68 };
69 struct nfs_lock_info {
70 };
71 struct ntfs_sb_info {
72 };
73 struct ntfs_inode_info {
74 };
75 struct ncp_sb_info {
76 };
77 #include <linux/types.h>
78 #define u32 unsigned int
79 #define s32 int
80 #define u16 unsigned short
81 #include <features.h>
82 #if __GLIBC_MINOR__ >= 2
83 #define _SYS_TYPES_H 1
84 #endif
85 #define __KERNEL__
86 #endif
87
88 /* This tells afs.h to pick up afs_args from the dest tree. */
89 #define KDUMP_KERNEL
90
91 /*
92  * Need to include <netdb.h> before _KERNEL is defined since on IRIX 6.5
93  * <netdb.h> includes <netinet/in.h>, which in turn declares inet_addr()
94  * if _KERNEL is defined.  This declaration conflicts with that in
95  * <arpa/inet.h>.
96  */
97 #if     ! defined(AFS_AIX_ENV)
98 #include <netdb.h>
99 #endif
100
101 /* For AFS_SGI61_ENV and a 64 bit OS, _KMEMUSER should be defined on the
102  * compile line for kdump.o in the Makefile. This lets us pick up
103  * app32_ptr_t from types.h when included from afs/param.h.
104  */
105 #ifdef AFS_SGI62_ENV
106 #define _KERNEL 1
107 #endif
108
109 #ifndef AFS_LINUX20_ENV
110 #include <nlist.h>
111 #endif
112
113 #ifdef AFS_HPUX_ENV
114 #include <a.out.h>
115 #endif
116
117 #include <afs/stds.h>
118
119 #ifdef  AFS_SUN5_ENV /*XXXXX*/
120 #include <sys/t_lock.h>
121 struct vnode foo;
122 #endif
123
124 #ifdef AFS_SGI53_ENV
125 #define _KERNEL 1
126 #include <sys/sema.h>
127 #ifndef AFS_SGI62_ENV
128 #undef _KERNEL 1
129 #endif
130 #endif
131
132 #ifdef AFS_SGI62_ENV
133 #include <sys/fcntl.h>
134 #ifndef L_SET
135 #define L_SET 0
136 #endif
137 #endif
138
139 #include <sys/param.h>
140
141 #ifndef AFS_SGI64_ENV
142 #include <sys/user.h>
143 #endif
144
145 #ifndef AFS_LINUX26_ENV
146 #include <sys/file.h>
147 #endif
148
149 /*
150  * On SGIs, when _KERNEL is defined, <netinet/in.h> declares inet_addr()
151  * in a way that conflicts with the declaration in <arpa/inet.h>.
152  *
153  * Here we bring in <netinet/in.h> without _KERNEL defined and restore
154  * _KERNEL afterwards if needed.
155  *
156  * A better solution might be to straighten out which #includes are
157  * sensitive to _KERNEL on SGIs....
158  */
159 #if defined(AFS_SGI_ENV) && defined(_KERNEL)
160 # undef _KERNEL
161 # include <netinet/in.h>        /* struct in_addr */
162 # define _KERNEL 1
163 #else
164 # include <netinet/in.h>        /* struct in_addr */
165 #endif
166
167 #if defined(AFS_SGI_ENV)
168 #ifdef       AFS_SGI_ENV
169 #include <sys/vnode.h>
170 #endif /* AFS_SGI_ENV */
171 #else
172 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
173 #include <sys/vnode.h>
174 #include <sys/mount.h>
175 #include <ufs/ufs/quota.h>
176 #include <ufs/ufs/inode.h>
177 #include <ufs/ffs/fs.h>
178 #else
179 #include "sys/vfs.h"
180 #ifdef AFS_LINUX20_ENV
181 #ifndef UIO_MAXIOV
182 #define UIO_MAXIOV 1            /* don't care */
183 #endif
184 #if __GLIBC_MINOR__ == 0
185 #include <iovec.h>
186 #endif
187 /*#define _TIME_H*/
188 /*#define _SYS_UIO_H */
189 #define _LINUX_SOCKET_H
190 #undef INT_MAX
191 #undef UINT_MAX
192 #undef LONG_MAX
193 #undef ULONG_MAX
194 #define _LINUX_TIME_H
195 #ifndef AFS_LINUX26_ENV
196 #define _LINUX_FCNTL_H
197 #endif
198 #ifdef AFS_IA64_LINUX24_ENV
199 #define flock64  flock
200 #endif /* AFS_IA64_LINUX24_ENV */
201 #ifdef AFS_S390_LINUX20_ENV
202 #define _S390_STATFS_H
203 #else
204 #ifdef AFS_SPARC64_LINUX20_ENV
205 #define _SPARC64_STATFS_H
206 #define _SPARC_STATFS_H
207 #else
208 #ifdef AFS_SPARC_LINUX20_ENV
209 #define _SPARC_STATFS_H
210 #else
211 #ifdef AFS_ALPHA_LINUX20_ENV
212 #define _ALPHA_STATFS_H
213 #else
214 #define _I386_STATFS_H
215 #endif /* AFS_ALPHA_LINUX20_ENV */
216 #endif /* AFS_SPARC_LINUX20_ENV */
217 #endif /* AFS_SPARC64_LINUX20_ENV */
218 #endif /* AFS_S390_LINUX20_ENV */
219 struct timezone {
220     int a, b;
221 };
222 #if 0                           /*ndef AFS_ALPHA_LINUX20_ENV */
223 typedef struct timeval {
224     int tv_sec;
225     int tv_usec;
226 } timeval_t;                    /* Needed here since KERNEL defined. */
227 #endif /*AFS_ALPHA_LINUX20_ENV */
228 #if defined(WORDS_BIGENDIAN)
229 #define _LINUX_BYTEORDER_BIG_ENDIAN_H
230 #else
231 #define _LINUX_BYTEORDER_LITTLE_ENDIAN_H
232 #endif
233 /* Avoid problems with timer_t redefinition */
234 #ifndef timer_t
235 #define timer_t ktimer_t
236 #define timer_t_redefined
237 #endif
238 #ifdef AFS_LINUX26_ENV
239 /* For some reason, this doesn't get defined in linux/types.h
240    if __KERNEL_STRICT_NAMES is defined. But the definition of
241    struct inode uses it.
242 */
243 #ifndef HAVE_SECTOR_T
244 /* got it from linux/types.h */
245 typedef unsigned long sector_t;
246 #endif /* HAVE_SECTOR_T */
247 #endif /* AFS_LINUX26_ENV */
248 #include <linux/version.h>
249 #include <linux/fs.h>
250 #include <osi_vfs.h>
251 #ifdef timer_t_redefined
252 #undef timer_t
253 #undef timer_t_redefined
254 #endif
255 #else /* AFS_LINUX20_ENV */
256 #ifdef AFS_HPUX110_ENV
257 #define  KERNEL
258 #define  _KERNEL 1
259 /* Declare following so sys/vnode.h will compile with KERNEL defined */
260 #define FILE FILe
261 typedef enum _spustate {        /* FROM /etc/conf/h/_types.h */
262     SPUSTATE_NONE = 0,          /* must be 0 for proper initialization */
263     SPUSTATE_IDLE,              /* spu is idle */
264     SPUSTATE_USER,              /* spu is in user mode */
265     SPUSTATE_SYSTEM,            /* spu is in system mode */
266     SPUSTATE_UNKNOWN,           /* utility code for NEW_INTERVAL() */
267     SPUSTATE_NOCHANGE           /* utility code for NEW_INTERVAL() */
268 } spustate_t;
269 #define k_off_t off_t
270 #include "sys/vnode.h"
271 #undef KERNEL
272 #undef _KERNEL
273 #else /* AFS_HPUX110_ENV */
274 #include "sys/vnode.h"
275 #endif /* else AFS_HPUX110_ENV */
276 #endif /* else AFS_LINUX20_ENV */
277 #ifdef  AFS_HPUX_ENV
278 #include "sys/inode.h"
279 #else
280 #ifndef AFS_AIX_ENV
281 #ifdef  AFS_SUN5_ENV
282 #include "sys/fs/ufs_inode.h"
283 #else
284 #ifndef AFS_LINUX20_ENV
285 #include "ufs/inode.h"
286 #endif
287 #endif
288 #endif
289 #endif
290 #endif
291 #endif
292
293 /* AFS includes */
294 #ifdef AFS_AIX41_ENV
295 /* This definition is in rx_machdep.h, currently only for AIX 41 */
296 #define RX_ENABLE_LOCKS
297 /* The following two defines are from rx_machdep.h and are used in rx_
298  * structures.
299  */
300 #define afs_kmutex_t int
301 #define afs_kcondvar_t int
302 #endif /* AFS_AIX41_ENV */
303
304
305 #ifdef AFS_SUN5_ENV
306
307 #define RX_ENABLE_LOCKS
308
309 /**
310   * Removed redefinitions of afs_kmutex_t and afs_kcondvar_t and included
311   * the system header files in which they are defined
312   */
313 #include <sys/mutex.h>
314 #include <sys/condvar.h>
315 typedef kmutex_t afs_kmutex_t;
316 typedef kcondvar_t afs_kcondvar_t;
317 #endif /* AFS_SUN5_ENV */
318
319 #ifdef AFS_HPUX110_ENV
320 #define RX_ENABLE_LOCKS
321 typedef struct {
322     void *s_lock;
323     int count;
324     long sa_fill1;
325     void *wait_list;
326     void *sa_fill2[2];
327     int sa_fill2b[2];
328     long sa_fill2c[3];
329     int sa_fill2d[16];
330     int order;
331     int sa_fill3;
332 } afs_kmutex_t;
333 typedef char *afs_kcondvar_t;
334 #endif /* AFS_HPUX110_ENV */
335
336 #ifdef AFS_SGI65_ENV
337 #define RX_ENABLE_LOCKS 1
338 typedef struct {
339     __psunsigned_t opaque1;
340     void *opaque2;
341 } afs_kmutex_t;
342 typedef struct {
343     __psunsigned_t opaque;
344 } afs_kcondvar_t;
345 #endif /* AFS_SGI65_ENV */
346
347 #ifdef AFS_LINUX20_ENV
348 #include <asm/atomic.h>
349 #include <asm/semaphore.h>
350 #define RX_ENABLE_LOCKS 1
351 typedef struct {
352     struct semaphore opaque1;
353     int opaque2;
354 } afs_kmutex_t;
355 typedef void *afs_kcondvar_t;
356 #endif /* AFS_LINUX20_ENV */
357
358 #include <afs/exporter.h>
359 /*#include "afs/osi.h"*/
360
361 typedef struct {
362     int tv_sec;
363     int tv_usec;
364 } osi_timeval_t;                /* Needed here since KERNEL defined. */
365
366 /*#include "afs/volerrors.h"*/
367 #ifdef AFS_LINUX20_ENV
368 #define _SYS_TIME_H
369 #endif
370
371 #include <afs/afsint.h>
372 #include "vlserver/vldbint.h"
373 #include "afs/lock.h"
374
375 #define KERNEL
376
377 #ifndef notdef
378 #define AFS34
379 #define AFS33
380 #define AFS32a
381 #else
382 #define AFS32
383 #endif
384
385
386 #ifdef AFS_SGI61_ENV
387 extern off64_t lseek64();
388 #define KDUMP_SIZE_T size_t
389 #else /* AFS_SGI61_ENV */
390 #define KDUMP_SIZE_T int
391 #endif /* AFS_SGI61_ENV */
392
393 #include "afs/afs.h"            /* XXXX Getting it from the obj tree XXX */
394 #include "afs/afs_axscache.h"   /* XXXX Getting it from the obj tree XXX */
395 #include <afs/afs_stats.h>
396 #include <afs/nfsclient.h>
397
398 #include <afs/cmd.h>
399 #include <rx/rx.h>
400
401
402 #undef  KERNEL
403
404 #if defined(AFS_SGI_ENV)
405 #define UNIX "/unix"
406 #else
407 #if     defined(AFS_HPUX100_ENV)
408 #define UNIX "/stand/vmunix"
409 #else
410 #ifdef  AFS_HPUX_ENV
411 #define UNIX  "/hp-ux"
412 #else
413 #ifdef  AFS_SUN5_ENV
414 #define UNIX  "/dev/ksyms"
415 #else
416 #define UNIX  "/vmunix"
417 #endif
418 #endif /* AFS_HPUX_ENV */
419 #endif /* AFS_HPUX100_ENV */
420 #endif /* AFS_SGI_ENV */
421
422 #if     defined(AFS_SUN5_ENV)
423 #define CORE "/dev/mem"
424 #else
425 #define CORE "/dev/kmem"
426 #endif
427
428 /* Forward declarations */
429 void print_Conns();
430 void print_cbHash();
431 void print_DindexTimes();
432 void print_DdvnextTbl();
433 void print_DdcnextTbl();
434 void print_DindexFlags();
435 void print_buffers();
436 void print_allocs();
437 void kread(int kmem, off_t loc, void *buf, KDUMP_SIZE_T len);
438 void print_exporter();
439 void print_nfsclient();
440 void print_unixuser();
441 void print_cell();
442 void print_server();
443 void print_conns();
444 void print_conn();
445 void print_volume();
446 void print_venusfid();
447 void print_vnode();
448 void print_vcache();
449 void print_dcache();
450 void print_bkg();
451 void print_vlru();
452 void print_dlru();
453 void print_callout();
454 void print_dnlc();
455 void print_global_locks();
456 void print_global_afs_resource();
457 void print_global_afs_cache();
458 void print_rxstats();
459 void print_rx();
460 void print_services();
461 #ifdef KDUMP_RX_LOCK
462 void print_peertable_lock();
463 void print_conntable_lock();
464 void print_calltable_lock();
465 #endif
466 void print_peertable();
467 void print_conntable();
468 void print_calltable();
469 void print_eventtable();
470 void print_upDownStats();
471 void print_cmperfstats();
472 void print_cmstats();
473
474
475
476
477 int opencore();
478
479 #if     defined(AFS_HPUX_ENV) && defined(__LP64__)
480 #define afs_nlist nlist64
481 #define AFSNLIST(N, C) nlist64((N), (C))
482 #else /* defined(AFS_HPUX_ENV) && defined(__LP64__) */
483 #ifdef AFS_SGI61_ENV
484 #ifdef AFS_32BIT_KERNEL_ENV
485 #define afs_nlist nlist
486 #define AFSNLIST(N, C) nlist((N), (C))
487 #else
488 #define afs_nlist nlist64
489 #define AFSNLIST(N, C) nlist64((N), (C))
490 #endif /* AFS_32BIT_KERNEL_ENV */
491 #else /* AFS_SGI61_ENV */
492 #ifdef AFS_LINUX20_ENV
493 struct afs_nlist {
494     char *n_name;
495     unsigned long n_value;
496 };
497 #else /* AFS_LINUX20_ENV */
498 #define afs_nlist nlist
499 #endif /* AFS_LINUX20_ENV */
500 #define AFSNLIST(N, C) nlist((N), (C))
501 #endif /* AFS_SGI61_ENV */
502 #endif /* defined(AFS_HPUX_ENV) && defined(__LP64__) */
503
504 char *obj = UNIX, *core = CORE;
505 int kmem;
506
507 int Dcells = 0, Dusers = 0, Dservers = 0, Dconns = 0, Dvols = 0, Ddvols =
508     0, mem = 0;
509 int Dvstats = 0, Ddstats = 0, Dnfs = 0, Dglobals = 0, Dstats = 0, Dlocks =
510     0, Dall = 1;
511 int Dindextimes = 0, Dindexflags = 0, Dvnodes = 0, Dbuffers = 0, DCallbacks =
512     0, Dallocs = 0, UserLevel = 0;
513 int DdvnextTbl = 0, DdcnextTbl = 0;
514 int Nconns = 0, Drxstats = 0, Drx = 0, Dbkg = 0, Dvlru = 0, Ddlru =
515     0, Dcallout = 0;
516 int Ddnlc = 0;
517 int Dgcpags = 0;
518
519 #if     defined(AFS_SUN5_ENV)
520 #include <string.h>
521 #include <sys/types.h>
522 #include <sys/signal.h>
523 #include <sys/elf.h>
524 #include <libelf.h>
525 #include <sys/elf_M32.h>
526 #include <sys/proc.h>
527 #include <sys/file.h>
528 #define _NLIST_H                /* XXXXXXXXXXXXX */
529 #include <kvm.h>
530 kvm_t *kd;
531 #endif /* defined(AFS_SUN5_ENV) */
532
533 /* Pretty Printers - print real IP addresses and the like if running
534  * in interpret_mode.
535  */
536 int pretty = 1;
537
538 char *
539 PrintIPAddr(int addr)
540 {
541     static char str[32];
542     struct in_addr in_addr;
543
544     if (pretty) {
545         if (addr == 1) {
546             strcpy(str, "local");
547         } else {
548             in_addr.s_addr = addr;
549             (void)strcpy(str, inet_ntoa(in_addr));
550         }
551     } else {
552         (void)sprintf(str, "%x", addr);
553     }
554     return (char *)str;
555 }
556
557 #ifdef AFS_LINUX20_ENV
558 /* Find symbols in a live kernel. */
559
560 #ifdef AFS_LINUX26_ENV
561 #define KSYMS "/proc/kallsyms"
562 #else
563 #define KSYMS "/proc/ksyms"
564 #endif
565
566 /* symlist_t contains all the kernel symbols. Forcing a 64 byte array is
567  * a bit wasteful, but simple.
568  */
569 #define MAXNAMELEN 64
570 typedef struct symlist {
571     char s_name[MAXNAMELEN];
572 #ifdef AFS_LINUX_64BIT_KERNEL
573     unsigned long s_value;
574 #else
575     int s_value;
576 #endif /* AFS_LINUX_64BIT_KERNEL */
577 } symlist_t;
578
579 #define KSYM_ALLOC_STEP 128
580 #define KSYM_ALLOC_BASE 1024
581 symlist_t *ksyms = NULL;
582 int nksyms = 0;
583 int availksyms = 0;
584
585 #define MAXLINE 1024
586
587 int
588 compare_strings(const void *a, const void *b)
589 {
590     symlist_t *syma = (symlist_t *) a;
591     symlist_t *symb = (symlist_t *) b;
592     return strcmp(syma->s_name, symb->s_name);
593 }
594
595 /* Read in all the kernel symbols */
596 void
597 read_ksyms(void)
598 {
599     FILE *fp;
600     char line[MAXLINE];
601     char *p, *q;
602
603     if (ksyms)
604         return;
605
606     fp = fopen(KSYMS, "r");
607     if (fp == NULL) {
608         printf("Can't open %s, exiting.\n", KSYMS);
609         exit(1);
610     }
611
612     availksyms = KSYM_ALLOC_BASE;
613     ksyms = malloc(availksyms * sizeof(symlist_t));
614     if (!ksyms) {
615         printf("Can't malloc %d elements for symbol list.\n", availksyms);
616         exit(1);
617     }
618
619     /* proc is organized as <addr> <name> <module> */
620     while (fgets(line, MAXLINE, fp)) {
621         if (nksyms >= availksyms) {
622             availksyms += KSYM_ALLOC_STEP;
623             ksyms = realloc(ksyms, availksyms * sizeof(symlist_t));
624             if (!ksyms) {
625                 printf("Failed to realloc %d symbols.\n", availksyms);
626                 exit(1);
627             }
628         }
629 #ifdef AFS_LINUX_64BIT_KERNEL
630         ksyms[nksyms].s_value = (unsigned long)strtoul(line, &p, 16);
631 #else
632         ksyms[nksyms].s_value = (int)strtoul(line, &p, 16);
633 #endif /* AFS_LINUX_64BIT_KERNEL */
634         p++;
635 #ifdef AFS_LINUX26_ENV
636         /* Linux 2.6 /proc/kallsyms has a one-char symbol type
637            between address and name, so step over it and the following
638            blank.
639         */
640         p += 2;
641 #endif
642         q = strchr(p, '\t');
643         if (q)
644             *q = '\0';
645         if (strlen(p) >= MAXLINE) {
646             printf("Symbol '%s' too long, ignoring it.\n", p);
647             continue;
648         }
649         (void)strcpy(ksyms[nksyms].s_name, p);
650         nksyms++;
651     }
652
653     /* Sort them in lexical order */
654     qsort(ksyms, nksyms, sizeof(symlist_t), compare_strings);
655 }
656
657
658
659 /* find_symbol returns 0 if not found, otherwise value for symbol */
660 #ifdef AFS_LINUX_64BIT_KERNEL
661 unsigned long
662 #else
663 int
664 #endif /* AFS_LINUX_64BIT_KERNEL */
665 find_symbol(char *name)
666 {
667     symlist_t *tmp;
668     symlist_t entry;
669
670     if (!ksyms)
671         read_ksyms();
672
673     (void)strcpy(entry.s_name, name);
674     tmp =
675         (symlist_t *) bsearch(&entry, ksyms, nksyms, sizeof(symlist_t),
676                               compare_strings);
677
678     return tmp ? tmp->s_value : 0;
679 }
680
681 /* nlist fills in values in list until a null name is found. */
682 int
683 nlist(void *notused, struct afs_nlist *nlp)
684 {
685     for (; nlp->n_name && *nlp->n_name; nlp++)
686         nlp->n_value = find_symbol(nlp->n_name);
687
688     return 0;
689 }
690
691 #endif
692
693 #if     defined(AFS_SUN5_ENV)
694 #ifdef  _LP64
695 Elf64_Sym *tbl;
696 #else
697 Elf32_Sym *tbl;                 /* symbol tbl */
698 #endif
699 char *tblp;                     /* ptr to symbol tbl */
700 int scnt = 0;
701
702 #ifdef  _LP64
703 Elf64_Sym *
704 symsrch(s)
705      char *s;
706 {
707     Elf64_Sym *sp;
708 #else
709 Elf32_Sym *
710 symsrch(s)
711      char *s;
712 {
713     Elf32_Sym *sp;
714 #endif  /** _LP64 **/
715     char *name;
716     unsigned char type;
717
718     for (sp = tbl; sp < &tbl[scnt]; sp++) {
719 #ifdef _LP64
720         type = ELF64_ST_TYPE(sp->st_info);
721 #else
722         type = ELF32_ST_TYPE(sp->st_info);
723 #endif  /** _LP64 **/
724         if (((type == STB_LOCAL) || (type == STB_GLOBAL)
725              || (type == STB_WEAK))
726             && ((afs_uint32) sp->st_value >= 0x10000)) {
727             name = tblp + sp->st_name;
728             if (!strcmp(name, s))
729                 return (sp);
730         }
731     }
732     return (0);
733 }
734
735 #endif /*defined(AFS_SUN5_ENV) */
736
737 #endif /*!defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) */
738
739 #ifndef AFS_KDUMP_LIB
740 static int
741 cmdproc(struct cmd_syndesc *as, void *arock)
742 {
743     afs_int32 code = 0;
744
745 #if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
746     if (as->parms[0].items) {   /* -kobj */
747         obj = as->parms[0].items->data;
748     }
749     if (as->parms[1].items) {   /* -kcore */
750         core = as->parms[1].items->data;
751     }
752     if (as->parms[2].items) {   /* -cells */
753         Dcells = 1, Dall = 0;
754     }
755     if (as->parms[3].items) {   /* -users */
756         Dusers = 1, Dall = 0;
757     }
758     if (as->parms[4].items) {   /* -servers */
759         Dservers = 1, Dall = 0;
760     }
761     if (as->parms[5].items) {   /* -conns */
762         Dconns = 1, Dall = 0;
763     }
764     if (as->parms[6].items) {   /* -volumes */
765         Dvols = 1, Dall = 0;
766     }
767     if (as->parms[7].items) {   /* -dvolumes */
768         Ddvols = 1, Dall = 0;
769     }
770     if (as->parms[8].items) {   /* -vstats */
771         Dvstats = 1, Dall = 0;
772     }
773     if (as->parms[9].items) {   /* -dstats */
774         Ddstats = 1, Dall = 0;
775     }
776     if (as->parms[10].items) {  /* -nfstats */
777         Dnfs = 1, Dall = 0;
778     }
779     if (as->parms[11].items) {  /* -globals */
780         Dglobals = 1, Dall = 0;
781     }
782     if (as->parms[12].items) {  /* -stats */
783         Dstats = 1, Dall = 0;
784     }
785     if (as->parms[13].items) {  /* -locks */
786         Dlocks = 1, Dall = 0;
787     }
788     if (as->parms[14].items) {  /* -mem */
789         mem = 1;
790     }
791     if (as->parms[15].items) {  /* -rxstats */
792         Drxstats = 1, Dall = 0;
793     }
794     if (as->parms[16].items) {  /* -rx */
795         Drx = 1, Dall = 0;
796     }
797     if (as->parms[17].items) {  /* -timestable */
798         Dindextimes = 1, Dall = 0;
799     }
800     if (as->parms[18].items) {  /* -flagstable */
801         Dindexflags = 1, Dall = 0;
802     }
803     if (as->parms[19].items) {  /* -cbhash */
804         DCallbacks = 1, Dall = 0;
805     }
806     if (as->parms[20].items) {  /* -vnodes */
807         Dvnodes = 1, Dall = 0;
808     }
809     if (as->parms[21].items) {  /* -buffers */
810         Dbuffers = 1, Dall = 0;
811     }
812     if (as->parms[22].items) {  /* -allocedmem */
813         Dallocs = 1, Dall = 0;
814     }
815     if (as->parms[23].items) {  /* -user */
816         UserLevel = 1;
817     }
818     if (as->parms[24].items) {  /* -bkg */
819         Dbkg = 1, Dall = 0;
820     }
821     if (as->parms[25].items) {  /* -vlru */
822         Dvlru = 1, Dall = 0;
823     }
824     if (as->parms[26].items) {  /* -callout */
825         Dcallout = 1, Dall = 0;
826     }
827     if (as->parms[27].items) {  /* -dnlc */
828         Ddnlc = 1, Dall = 0;
829     }
830     if (as->parms[28].items) {  /* -dlru */
831         Ddlru = 1, Dall = 0;
832     }
833
834     if (as->parms[29].items) {  /* -raw */
835         pretty = 0;
836     }
837
838     if (as->parms[30].items) {  /* -gcpags */
839         Dgcpags = 1, Dall = 0;
840     }
841
842     if (as->parms[31].items) {  /* -dhash */
843         DdvnextTbl = 1, DdcnextTbl = 1, Dall = 0;
844     }
845 #endif
846
847     code = kdump();
848     return code;
849 }
850
851 #include "AFS_component_version_number.c"
852
853 int
854 main(int argc, char **argv)
855 {
856     struct cmd_syndesc *ts;
857     afs_int32 code;
858
859 #ifdef  AFS_AIX32_ENV
860     struct sigaction nsa;
861
862     sigemptyset(&nsa.sa_mask);
863     nsa.sa_handler = SIG_DFL;
864     nsa.sa_flags = SA_FULLDUMP;
865     sigaction(SIGSEGV, &nsa, NULL);
866 #endif
867
868     ts = cmd_CreateSyntax(NULL, cmdproc, NULL, 0,
869                           "Read internal cache manager structs");
870     cmd_AddParm(ts, "-kobj", CMD_SINGLE, CMD_OPTIONAL,
871                 "kernel object (default /vmunix)");
872     cmd_AddParm(ts, "-kcore", CMD_SINGLE, CMD_OPTIONAL,
873                 "kernel core image (default /dev/kmem)");
874     cmd_AddParm(ts, "-cells", CMD_FLAG, CMD_OPTIONAL, "cell state");
875     cmd_AddParm(ts, "-users", CMD_FLAG, CMD_OPTIONAL, "users state");
876     cmd_AddParm(ts, "-servers", CMD_FLAG, CMD_OPTIONAL, "servers state");
877     cmd_AddParm(ts, "-conns", CMD_FLAG, CMD_OPTIONAL, "conns state");
878     cmd_AddParm(ts, "-volumes", CMD_FLAG, CMD_OPTIONAL,
879                 "incore volume state");
880     cmd_AddParm(ts, "-dvolumes", CMD_FLAG, CMD_OPTIONAL, "disk volume state");
881     cmd_AddParm(ts, "-vstats", CMD_FLAG, CMD_OPTIONAL, "stat file state");
882     cmd_AddParm(ts, "-dstats", CMD_FLAG, CMD_OPTIONAL, "file data state");
883     cmd_AddParm(ts, "-nfstats", CMD_FLAG, CMD_OPTIONAL,
884                 "nfs translator state");
885     cmd_AddParm(ts, "-globals", CMD_FLAG, CMD_OPTIONAL,
886                 "general global state");
887     cmd_AddParm(ts, "-stats", CMD_FLAG, CMD_OPTIONAL,
888                 "general cm performance state");
889     cmd_AddParm(ts, "-locks", CMD_FLAG, CMD_OPTIONAL,
890                 "global cm related locks state");
891     cmd_AddParm(ts, "-mem", CMD_FLAG, CMD_OPTIONAL,
892                 "core represents the physical mem (i.e. /dev/mem) and not virtual");
893     cmd_AddParm(ts, "-rxstats", CMD_FLAG, CMD_OPTIONAL,
894                 "general rx statistics");
895     cmd_AddParm(ts, "-rx", CMD_FLAG, CMD_OPTIONAL, "all info about rx");
896     cmd_AddParm(ts, "-timestable", CMD_FLAG, CMD_OPTIONAL,
897                 "dcache LRU info table");
898     cmd_AddParm(ts, "-flagstable", CMD_FLAG, CMD_OPTIONAL,
899                 "dcache flags info table");
900     cmd_AddParm(ts, "-cbhash", CMD_FLAG, CMD_OPTIONAL,
901                 "vcache hashed by cbExpires");
902     cmd_AddParm(ts, "-vnodes", CMD_FLAG, CMD_OPTIONAL, "afs vnodes");
903     cmd_AddParm(ts, "-buffers", CMD_FLAG, CMD_OPTIONAL,
904                 "afs dir buffer cache");
905     cmd_AddParm(ts, "-allocedmem", CMD_FLAG, CMD_OPTIONAL,
906                 "allocated memory");
907     cmd_AddParm(ts, "-user", CMD_FLAG, CMD_OPTIONAL,
908                 "core is from a user-level program");
909     cmd_AddParm(ts, "-bkg", CMD_FLAG, CMD_OPTIONAL, "background daemon info");
910     cmd_AddParm(ts, "-vlru", CMD_FLAG, CMD_OPTIONAL, "vcache lru list");
911     cmd_AddParm(ts, "-callout", CMD_FLAG, CMD_OPTIONAL,
912                 "callout info (aix only)");
913     cmd_AddParm(ts, "-dnlc", CMD_FLAG, CMD_OPTIONAL,
914                 "DNLC table,freelist,trace");
915     cmd_AddParm(ts, "-dlru", CMD_FLAG, CMD_OPTIONAL, "dcache lru list");
916
917
918     cmd_AddParm(ts, "-raw", CMD_FLAG, CMD_OPTIONAL, "show raw values");
919     cmd_AddParm(ts, "-gcpags", CMD_FLAG, CMD_OPTIONAL,
920                 "PAG garbage collection info");
921     cmd_AddParm(ts, "-dhash", CMD_FLAG, CMD_OPTIONAL,
922                 "show dcache hash chains");
923
924     code = cmd_Dispatch(argc, argv);
925     return code;
926 }
927 #endif /* !AFS_KDUMP_LIB */
928
929 #ifdef  AFS_AIX_ENV
930 #ifndef AFS_KDUMP_LIB
931 int
932 Knlist(struct afs_nlist *sp, int cnt, int size)
933 {
934     int code;
935
936     if (UserLevel)
937         code = nlist(obj, sp);
938     else
939         code = knlist(sp, cnt, size);
940     return code;
941 }
942 #endif /*AFS_KDUMP_LIB */
943 #endif
944
945 #if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
946 int
947 findsym(char *sname, off_t * offset)
948 {
949 #if     defined(AFS_SUN5_ENV)
950 #ifdef  _LP64
951     Elf64_Sym *ss_ans;
952 #else
953     Elf32_Sym *ss_ans;
954 #endif
955     ss_ans = symsrch(sname);
956     if (!ss_ans) {
957         printf("(WARNING) Couldn't find %s in %s. Proceeding..\n", sname,
958                obj);
959         *offset = 0;
960         return 0;
961     }
962     *offset = ss_ans->st_value;
963     return 1;
964 #else /* defined(AFS_SUN5_ENV) */
965 #if     defined(AFS_AIX_ENV)
966     if (!UserLevel) {
967         struct afs_nlist nl;
968         nl.n_name = sname;
969         if (Knlist(&nl, 1, sizeof nl) == -1) {
970             printf("(WARNING) knlist: couldn't find %s. Proceeding...",
971                    sname);
972             *offset = 0;
973             return 0;
974         }
975         *offset = nl.n_value;
976         return 1;
977     }
978 #endif /* defined(AFS_AIX_ENV) */
979     {
980         struct afs_nlist request[2];
981
982         memset(request, 0, sizeof request);
983         request[0].n_name = sname;
984         if (AFSNLIST(obj, request) < 0) {
985             fprintf(stderr, "nlist(%s, %s) failure: %d (%s)\n", obj, sname,
986                     errno, strerror(errno));
987             exit(1);
988         }
989         *offset = request[0].n_value;
990         if (!request[0].n_value) {
991             printf("(WARNING) Couldn't find %s in %s. Proceeding..\n", sname,
992                    obj);
993             return 0;
994         }
995         return 1;
996     }
997 #endif /* defined(AFS_SUN5_ENV) */
998 }
999 #endif
1000
1001 #define CBHTSIZE 128
1002
1003 int
1004 kdump(void)
1005 {
1006 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
1007     printf("Kdump not supported\n");
1008 #else
1009     int cell, cnt, cnt1;
1010 #ifndef AFS_KDUMP_LIB
1011
1012     kmem = opencore(core);
1013
1014 #endif /* AFS_KDUMP_LIB */
1015
1016 #ifdef KDUMP_RX_LOCK
1017     /* Test to see if kernel is using RX_ENABLE_LOCKS in rx structs. */
1018 #ifdef AFS_SGI53_ENV
1019 #ifdef AFS_SGI64_ENV
1020     use_rx_lock = 1;            /* Always using fine gain locking. */
1021 #else
1022     use_rx_lock = (sysmp(MP_NPROCS) > 1) ? 1 : 0;
1023 #endif
1024 #endif /* AFS_SGI53_ENV */
1025 #endif /* KDUMP_RX_LOCK */
1026
1027     if (Dcells || Dall) {
1028         print_cells(1);         /* Handle the afs_cells structures */
1029         print_cellaliases(1);
1030         print_cellnames(1);
1031     }
1032
1033     if (Dusers || Dall) {
1034         print_users(1);         /* Handle the afs_users structs */
1035     }
1036
1037     if (Dservers || Dall) {
1038         print_servers(1);       /* Handle the afs_servers structs */
1039     }
1040
1041     if (Dconns) {
1042         print_Conns(1);         /* Handle the afs_servers structs */
1043     }
1044
1045     if (Dvols || Dall) {
1046         print_volumes(1);       /* Handle the afs_volumes structs */
1047     }
1048
1049     if (Ddvols || Dall) {
1050         printf
1051             ("\n\nIGNORE reading the 'volumeinfo' file for now (NOT IMPORTANT)!\n");
1052     }
1053
1054     if (DCallbacks || Dall) {
1055         print_cbHash(1);        /* Handle the cbHashT table of queued vcaches */
1056     }
1057
1058     if (Dvstats || Dall || Dvnodes) {
1059         print_vcaches(1);       /* Handle the afs_vcaches structs */
1060     }
1061
1062     if (Ddstats || Dall) {
1063         print_dcaches(1);
1064     }
1065
1066     if (Dindextimes || Dall) {
1067         print_DindexTimes(1);
1068     }
1069
1070     if (Dindexflags || Dall) {
1071         print_DindexFlags(1);
1072     }
1073
1074     if (DdvnextTbl || Dall) {
1075         print_DdvnextTbl(1);
1076     }
1077
1078     if (DdcnextTbl || Dall) {
1079         print_DdcnextTbl(1);
1080     }
1081
1082     if (Dbuffers || Dall) {
1083         print_buffers(1);
1084     }
1085
1086     if (Dnfs || Dall) {
1087         print_nfss(1);
1088     }
1089
1090     if (Dstats || Dall) {
1091         off_t symoff;
1092         struct afs_CMStats afs_cmstats;
1093         struct afs_stats_CMPerf afs_cmperfstats;
1094
1095         printf("\n\nPrinting count references to cm-related functions..\n\n");
1096         findsym("afs_cmstats", &symoff);
1097         kread(kmem, symoff, (char *)&afs_cmstats, sizeof afs_cmstats);
1098         print_cmstats(&afs_cmstats);
1099         printf("\n\nPrinting some cm struct performance stats..\n\n");
1100         findsym("afs_stats_cmperf", &symoff);
1101         kread(kmem, symoff, (char *)&afs_cmperfstats, sizeof afs_cmperfstats);
1102         print_cmperfstats(&afs_cmperfstats);
1103
1104     }
1105     if (Dlocks || Dall) {
1106         print_global_locks(kmem);
1107     }
1108     if (Dglobals || Dall) {
1109         printf("\n\nPrinting Misc afs globals...\n");
1110         print_global_afs_resource(kmem);
1111         print_global_afs_cache(kmem);
1112     }
1113     if (Dbkg || Dall) {
1114         print_bkg(kmem);
1115     }
1116     if (Dvlru || Dall) {
1117         print_vlru(kmem);
1118     }
1119     if (Ddlru || Dall) {
1120         print_dlru(kmem);
1121     }
1122     if (Drxstats || Dall) {
1123         print_rxstats(kmem);
1124     }
1125     if (Drx || Dall) {
1126         print_rx(kmem);
1127     }
1128 #ifndef AFS_KDUMP_LIB
1129     if (Dallocs || Dall) {
1130         print_allocs(1);
1131     }
1132 #endif
1133     if (Dcallout || Dall) {
1134         print_callout(kmem);
1135     }
1136     if (Ddnlc || Dall) {
1137         print_dnlc(kmem);
1138     }
1139     if (Dgcpags || Dall) {
1140         print_gcpags(1);
1141     }
1142 #endif
1143     return 0;
1144 }
1145
1146 #if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
1147 int Sum_cellnames = 0, Sum_userstp = 0, Sum_volnames = 0, Sum_exps =
1148     0, Sum_nfssysnames = 0;
1149 int Sum_vcachemvids = 0, Sum_vcachelinkData = 0, Sum_vcacheacc =
1150     0, Sum_vcachelocks = 0;
1151 int Sum_cellaliases = 0, Sum_cellname_names = 0;
1152
1153 int
1154 print_cells(int pnt)
1155 {
1156     off_t symoff;
1157     struct cell *cells, cle, *clentry = &cle, *clep;
1158     long j = 0, cell;
1159     struct afs_q CellLRU, lru, *vu = &lru, *tq, *uq;
1160     u_long lru_addr;
1161
1162     if (pnt)
1163         printf("\n\nPrinting Cells' LRU list...\n");
1164     findsym("CellLRU", &symoff);
1165     kread(kmem, symoff, (char *)&CellLRU, sizeof CellLRU);
1166     lru_addr = (u_long) symoff;
1167     for (tq = CellLRU.next; (u_long) tq != lru_addr; tq = uq) {
1168         clep = QTOC(tq);
1169         kread(kmem, (off_t) tq, (char *)vu, sizeof CellLRU);
1170         uq = vu->next;
1171         kread(kmem, (off_t) clep, (char *)clentry, sizeof *clentry);
1172         print_cell(kmem, clentry, clep, pnt);
1173         j++;
1174     }
1175     if (pnt)
1176         printf("... found %d 'afs_cells' entries\n", j);
1177
1178     return j;
1179 }
1180
1181 int
1182 print_cellaliases(int pnt)
1183 {
1184     off_t symoff;
1185     struct cell_alias *ca, cae;
1186     long j = 0;
1187
1188     if (pnt)
1189         printf("\n\nPrinting cell_alias list...\n");
1190     findsym("afs_cellalias_head", &symoff);
1191     kread(kmem, symoff, (char *)&ca, sizeof ca);
1192     while (ca) {
1193         char alias[100], cell[100];
1194
1195         kread(kmem, (off_t) ca, (char *)&cae, sizeof cae);
1196         kread(kmem, (off_t) cae.alias, alias, (KDUMP_SIZE_T) 40);
1197         alias[40] = '\0';
1198         Sum_cellaliases += strlen(alias) + 1;
1199         kread(kmem, (off_t) cae.cell, cell, (KDUMP_SIZE_T) 40);
1200         cell[40] = '\0';
1201         Sum_cellaliases += strlen(cell) + 1;
1202         if (pnt)
1203             printf("%x: alias=%s cell=%s index=%d\n", ca, alias, cell,
1204                    cae.index);
1205         ca = cae.next;
1206         j++;
1207     }
1208     if (pnt)
1209         printf("... found %d 'cell_alias' entries\n", j);
1210
1211     return j;
1212 }
1213
1214 int
1215 print_cellnames(int pnt)
1216 {
1217     off_t symoff;
1218     struct cell_name *cn, cne;
1219     long j = 0;
1220
1221     if (pnt)
1222         printf("\n\nPrinting cell_name list...\n");
1223     findsym("afs_cellname_head", &symoff);
1224     kread(kmem, symoff, (char *)&cn, sizeof cn);
1225     while (cn) {
1226         char cellname[100];
1227
1228         kread(kmem, (off_t) cn, (char *)&cne, sizeof cne);
1229         kread(kmem, (off_t) cne.cellname, cellname, (KDUMP_SIZE_T) 40);
1230         cellname[40] = '\0';
1231         Sum_cellname_names += strlen(cellname) + 1;
1232         if (pnt)
1233             printf("%x: cellnum=%d cellname=%s used=%d\n", cn, cne.cellnum,
1234                    cellname, cne.used);
1235         cn = cne.next;
1236         j++;
1237     }
1238     if (pnt)
1239         printf("... found %d 'cell_name' entries\n", j);
1240
1241     return j;
1242 }
1243
1244 int
1245 print_users(int pnt)
1246 {
1247     off_t symoff;
1248     struct unixuser *afs_users[NUSERS], ue, *uentry = &ue, *uep;
1249     int i, j;
1250
1251     if (pnt)
1252         printf("\n\nPrinting 'afs_users' structures...\n");
1253     findsym("afs_users", &symoff);
1254     kread(kmem, symoff, (char *)afs_users, sizeof afs_users);
1255     for (i = 0, j = 0; i < NUSERS; i++) {
1256         for (uep = afs_users[i]; uep; uep = uentry->next, j++) {
1257             kread(kmem, (off_t) uep, (char *)uentry, sizeof *uentry);
1258             print_unixuser(kmem, uentry, uep, pnt);
1259         }
1260     }
1261     if (pnt)
1262         printf("... found %d 'afs_users' entries\n", j);
1263     return j;
1264 }
1265
1266 struct server **serversFound = NULL;
1267 afs_int32 NserversFound = 0;
1268 #define SF_ALLOCATION_STEP 500
1269
1270 int
1271 add_found_server(struct server *sep)
1272 {
1273     static afs_int32 NserversAllocated = 0;
1274     static afs_int32 failed = 0;
1275
1276     if (failed)
1277         return -1;
1278
1279     if (NserversFound >= NserversAllocated) {
1280         NserversAllocated += SF_ALLOCATION_STEP;
1281         if (!serversFound) {
1282             serversFound = malloc(NserversAllocated *
1283                                   sizeof(struct server *));
1284         } else {
1285             serversFound = realloc(serversFound,
1286                                    NserversAllocated *
1287                                    sizeof(struct server *));
1288         }
1289         if (!serversFound) {
1290             printf("Can't allocate %lu bytes for list of found servers.\n",
1291                    NserversAllocated * sizeof(struct server *));
1292             failed = 1;
1293             NserversFound = 0;
1294             return -1;
1295         }
1296     }
1297     serversFound[NserversFound++] = sep;
1298     return 0;
1299 }
1300
1301 int
1302 find_server(struct server *sep)
1303 {
1304     int i;
1305
1306     for (i = 0; i < NserversFound; i++) {
1307         if (sep == serversFound[i])
1308             return 1;
1309     }
1310     return 0;
1311 }
1312
1313 int
1314 print_servers(int pnt)
1315 {
1316     off_t symoff;
1317     struct server *afs_servers[NSERVERS], se, *sentry = &se, *sep;
1318     struct srvAddr *afs_srvAddrs[NSERVERS], sa, *sap;
1319     afs_int32 i, nServers, nSrvAddrs, nSrvAddrStructs;
1320     afs_int32 afs_totalServers, afs_totalSrvAddrs;
1321     int failed = 0;
1322     int chainCount[NSERVERS];
1323
1324     if (pnt) {
1325         memset(chainCount, 0, sizeof(chainCount));
1326         printf("\n\nPrinting 'afs_servers' structures...\n");
1327     }
1328     findsym("afs_servers", &symoff);
1329     kread(kmem, symoff, (char *)afs_servers, NSERVERS * sizeof(long));
1330     for (i = 0, nServers = 0; i < NSERVERS; i++) {
1331         if (pnt)
1332             printf(" --- Chain %d ---\n", i);
1333         for (sep = afs_servers[i]; sep; sep = sentry->next, nServers++) {
1334             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
1335             if (pnt && !failed) {
1336                 if (add_found_server(sep) < 0)
1337                     failed = 1;
1338             }
1339             if (pnt)
1340                 chainCount[i]++;
1341             if (Dconns || Dall || !pnt)
1342                 print_server(kmem, sentry, sep, 1, pnt);
1343             else
1344                 print_server(kmem, sentry, sep, 0, pnt);
1345         }
1346     }
1347     if (pnt) {
1348         if (Dconns || Dall)
1349             printf("... found %d 'afs_servers' entries (total conns = %d)\n",
1350                    nServers, Nconns);
1351         else
1352             printf("... found %d 'afs_servers' entries\n", nServers);
1353         printf("Chain lengths:\n");
1354         for (i = 0; i < NSERVERS; i++) {
1355             printf("%2d: %5d\n", i, chainCount[i]);
1356         }
1357     }
1358     Dconns = 0;
1359
1360
1361     /* Verify against afs_totalServers. */
1362     if (pnt) {
1363         memset(chainCount, 0, sizeof(chainCount));
1364         if (findsym("afs_totalServers", &symoff)) {
1365             kread(kmem, symoff, (char *)&afs_totalServers, sizeof(afs_int32));
1366             if (afs_totalServers != nServers) {
1367                 printf
1368                     ("ERROR: afs_totalServers = %d, differs from # of servers in hash table.\n",
1369                      afs_totalServers);
1370             } else {
1371                 printf("afs_totalServers = %d, matches hash chain count.\n",
1372                        afs_totalServers);
1373             }
1374         }
1375
1376         printf("\n\nPrinting 'afs_srvAddr' structures...\n");
1377         if (findsym("afs_srvAddrs", &symoff)) {
1378             kread(kmem, symoff, (char *)afs_srvAddrs,
1379                   NSERVERS * sizeof(long));
1380             nSrvAddrStructs = 0;
1381             for (i = 0, nSrvAddrs = 0; i < NSERVERS; i++) {
1382                 printf(" --- Chain %d ---\n", i);
1383                 for (sap = afs_srvAddrs[i]; sap; sap = sa.next_bkt) {
1384                     kread(kmem, (off_t) sap, (char *)&sa, sizeof(sa));
1385                     printf
1386                         ("%lx: sa_ip=%s, sa_port=%d, sa_iprank=%d, sa_flags=%x, conns=%lx, server=%lx, nexth=%lx\n",
1387                          sap, PrintIPAddr(sa.sa_ip), sa.sa_portal,
1388                          sa.sa_iprank, sa.sa_flags, sa.conns, sa.server,
1389                          sa.next_bkt);
1390                     if (sap != (struct srvAddr *)sa.server) {
1391                         /* only count ones not in a server struct. */
1392                         nSrvAddrStructs++;
1393                     }
1394                     nSrvAddrs++;
1395                     chainCount[i]++;
1396                     if (!failed) {
1397                         if (!find_server(sa.server)) {
1398                             kread(kmem, (off_t) sa.server, (char *)sentry,
1399                                   sizeof *sentry);
1400                             printf
1401                                 ("ERROR: Server missing from hash chain: server=%lx, server->next=%lx\n",
1402                                  sa.server, sentry->next);
1403                             print_server(kmem, sentry, sa.server, 1, pnt);
1404                             printf
1405                                 ("----------------------------------------------------\n");
1406                         }
1407                     }
1408
1409                 }
1410             }
1411             printf
1412                 ("... found %d 'afs_srvAddr' entries, %d alloc'd (not in server struct)\n",
1413                  nSrvAddrs, nSrvAddrStructs);
1414             printf("Chain lengths:\n");
1415             for (i = 0; i < NSERVERS; i++) {
1416                 printf("%2d: %5d\n", i, chainCount[i]);
1417             }
1418             if (findsym("afs_totalSrvAddrs", &symoff)) {
1419                 kread(kmem, symoff, (char *)&afs_totalSrvAddrs,
1420                       sizeof(afs_int32));
1421                 if (afs_totalSrvAddrs != nSrvAddrStructs) {
1422                     printf
1423                         ("ERROR: afs_totalSrvAddrs = %d, differs from number of alloc'd srvAddrs in hash table.\n",
1424                          afs_totalSrvAddrs);
1425                 } else {
1426                     printf
1427                         ("afs_totalSrvAddrs = %d, matches alloc'd srvAddrs in hash chain count.\n",
1428                          afs_totalSrvAddrs);
1429                 }
1430             }
1431         }
1432     }
1433     return nServers;
1434 }
1435
1436
1437 void
1438 print_Conns(int pnt)
1439 {
1440     off_t symoff;
1441     struct server *afs_servers[NSERVERS], se, *sentry = &se, *sep;
1442     afs_int32 i, j;
1443
1444     if (pnt)
1445         printf("\n\nPrinting all 'afs_conns' to  the servers...\n");
1446     findsym("afs_servers", &symoff);
1447     kread(kmem, symoff, (char *)afs_servers, sizeof afs_servers);
1448     for (i = 0, j = 0; i < NSERVERS; i++) {
1449         for (sep = afs_servers[i]; sep; sep = sentry->next, j++) {
1450             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
1451             print_server(kmem, sentry, sep, 2, pnt);
1452         }
1453     }
1454     if (pnt)
1455         printf("... found %d 'afs_conns' entries\n", Nconns);
1456 }
1457
1458
1459 int
1460 print_volumes(int pnt)
1461 {
1462     off_t symoff;
1463     struct volume *afs_volumes[NVOLS], ve, *ventry = &ve, *vep;
1464     afs_int32 i, j;
1465
1466     if (pnt)
1467         printf("\n\nPrinting 'afs_volumes' structures...\n");
1468     findsym("afs_volumes", &symoff);
1469     kread(kmem, symoff, (char *)afs_volumes, NVOLS * sizeof(long));
1470     for (i = 0, j = 0; i < NVOLS; i++) {
1471         for (vep = afs_volumes[i]; vep; vep = ventry->next, j++) {
1472             kread(kmem, (off_t) vep, (char *)ventry, sizeof *ventry);
1473             print_volume(kmem, ventry, vep, pnt);
1474         }
1475     }
1476     if (pnt)
1477         printf("... found %d 'afs_volumes' entries\n", j);
1478     return (j);
1479 }
1480
1481 void
1482 print_cbHash(int pnt)
1483 {
1484     off_t symoff;
1485     struct afs_q cbHashT[CBHTSIZE];
1486     afs_int32 i, j;
1487
1488     if (pnt)
1489         printf("\n\nPrinting 'cbHashT' table...\n");
1490     findsym("cbHashT", &symoff);
1491     kread(kmem, symoff, (char *)cbHashT, sizeof cbHashT);
1492     for (i = 0; i < CBHTSIZE; i++) {
1493         if (pnt)
1494             printf("%lx: %x %x\n", (long)symoff + 8 * i, cbHashT[i].prev,
1495                    cbHashT[i].next);
1496     }
1497     if (pnt)
1498         printf("... that should be %d callback hash entries\n", i);
1499 }
1500
1501 int
1502 print_vcaches(int pnt)
1503 {
1504     off_t symoff;
1505     struct vcache *afs_vhashTable[VCSIZE], Ve, *Ventry = &Ve, *Vep;
1506     afs_int32 i, j;
1507
1508     if (pnt)
1509         printf("\n\nPrinting afs_vcaches structures...\n");
1510     if (pnt)
1511         printf("print_vcaches: sizeof(struct vcache) = %ld\n",
1512                (long)sizeof(struct vcache));
1513     findsym("afs_vhashT", &symoff);
1514     kread(kmem, symoff, (char *)afs_vhashTable, sizeof afs_vhashTable);
1515     for (i = 0, j = 0; i < VCSIZE; i++) {
1516         if (pnt)
1517             printf("Printing hash chain %d...\n", i);
1518         for (Vep = afs_vhashTable[i]; Vep; Vep = Ventry->hnext, j++) {
1519             kread(kmem, (off_t) Vep, (char *)Ventry, sizeof *Ventry);
1520             if (Dvstats || Dall || !pnt)
1521                 print_vcache(kmem, Ventry, Vep, pnt);
1522             if (Dvnodes || Dall)
1523                 print_vnode(kmem, Ventry, Vep, pnt);
1524         }
1525     }
1526     if (pnt)
1527         printf("... found %d 'afs_vcaches' entries\n", j);
1528     return j;
1529 }
1530
1531 int
1532 print_dcaches(int pnt)
1533 {
1534     off_t symoff;
1535     long table, *ptr;
1536     struct dcache dc, *dcp = &dc, *dp;
1537     afs_int32 i, j, count;
1538     struct afs_q dlru;
1539
1540     /* Handle the afs_dcaches structs */
1541     if (pnt)
1542         printf("\n\nPrinting afs_dcache related structures...\n");
1543     findsym("afs_cacheFiles", &symoff);
1544     kread(kmem, symoff, (char *)&count, sizeof count);
1545     findsym("afs_indexTable", &symoff);
1546     kread(kmem, symoff, (char *)&table, sizeof(long));
1547     ptr = malloc(count * sizeof(long));
1548     kread(kmem, table, (char *)ptr, count * sizeof(long));
1549     for (i = 0, j = 0; i < count; i++) {
1550         if (dp = (struct dcache *)ptr[i]) {
1551             if (pnt)
1552                 printf("afs_indexTable[%d] %x: ", i, dp);
1553             kread(kmem, (off_t) dp, (char *)dcp, sizeof *dcp);
1554             print_dcache(kmem, dcp, dp, pnt);
1555             j++;
1556         }
1557     }
1558     if (pnt)
1559         printf("... found %d 'dcache' entries\n", j);
1560     findsym("afs_DLRU", &symoff);
1561     kread(kmem, symoff, (char *)&dlru, sizeof(struct afs_q));
1562     if (pnt)
1563         printf("DLRU next=0x%x, prev=0x%x\n", dlru.next, dlru.prev);
1564     free(ptr);
1565
1566     return j;
1567 }
1568
1569
1570 void
1571 print_DindexTimes(int pnt)
1572 {
1573     off_t symoff;
1574     long table;
1575     afs_hyper_t *ptr;
1576     afs_int32 temp, *indexTime = &temp;
1577     afs_int32 i, j, count;
1578
1579     /* Handle the afs_indexTimes array */
1580     if (pnt)
1581         printf("\n\nPrinting afs_indexTimes[]...\n");
1582     findsym("afs_cacheFiles", &symoff);
1583     kread(kmem, symoff, (char *)&count, sizeof count);
1584     findsym("afs_indexTimes", &symoff);
1585     kread(kmem, symoff, (char *)&table, sizeof(long));
1586     ptr = malloc(count * sizeof(afs_hyper_t));
1587     kread(kmem, table, (char *)ptr, count * sizeof(afs_hyper_t));
1588     for (i = 0, j = 0; i < count; i++) {
1589         if (pnt)
1590             printf("afs_indexTimes[%d]\t%10d.%d\n", i, ptr[i].high,
1591                    ptr[i].low);
1592 /*      if (dp = (struct dcache *)ptr[i]) {
1593         printf("afs_indexTable[%d] %lx: ", i, dp);
1594         kread(kmem, (off_t) dp, (char *)dcp, sizeof *dcp);
1595         print_dcache(kmem, dcp, dp);
1596         }
1597 */
1598         j++;
1599     }
1600     if (pnt)
1601         printf("afs_indexTimes has %d entries\n", j);
1602     free(ptr);
1603 }
1604
1605
1606 void
1607 print_DdvnextTbl(int pnt)
1608 {
1609     off_t symoff;
1610     long table;
1611     afs_int32 *ptr;
1612     afs_int32 temp, *indexTime = &temp;
1613     afs_int32 i, j, count;
1614
1615     /* Handle the afs_dvnextTbl arrays */
1616     if (pnt)
1617         printf("\n\nPrinting afs_dvnextTbl[]...\n");
1618     findsym("afs_cacheFiles", &symoff);
1619     kread(kmem, symoff, (char *)&count, sizeof count);
1620     findsym("afs_dvnextTbl", &symoff);
1621     kread(kmem, symoff, (char *)&table, sizeof(long));
1622     ptr = malloc(count * sizeof(afs_int32));
1623     kread(kmem, table, (char *)ptr, count * sizeof(afs_int32));
1624     for (i = 0, j = 0; i < count; i++) {
1625         if (pnt)
1626             printf("afs_dvnextTbl[%d]\t%d\n", i, ptr[i]);
1627         j++;
1628     }
1629     if (pnt)
1630         printf("afs_dvnextTbl has %d entries\n", j);
1631     free(ptr);
1632 }
1633
1634
1635 void
1636 print_DdcnextTbl(int pnt)
1637 {
1638     off_t symoff;
1639     long table;
1640     afs_int32 *ptr;
1641     afs_int32 temp, *indexTime = &temp;
1642     afs_int32 i, j, count;
1643
1644     /* Handle the afs_dcnextTbl arrays */
1645     if (pnt)
1646         printf("\n\nPrinting afs_dcnextTbl[]...\n");
1647     findsym("afs_cacheFiles", &symoff);
1648     kread(kmem, symoff, (char *)&count, sizeof count);
1649     findsym("afs_dcnextTbl", &symoff);
1650     kread(kmem, symoff, (char *)&table, sizeof(long));
1651     ptr = malloc(count * sizeof(afs_int32));
1652     kread(kmem, table, (char *)ptr, count * sizeof(afs_int32));
1653     for (i = 0, j = 0; i < count; i++) {
1654         if (pnt)
1655             printf("afs_dcnextTbl[%d]\t%d\n", i, ptr[i]);
1656         j++;
1657     }
1658     if (pnt)
1659         printf("afs_dcnextTbl has %d entries\n", j);
1660     free(ptr);
1661 }
1662
1663
1664 void
1665 print_DindexFlags(int pnt)
1666 {
1667     off_t symoff;
1668     afs_int32 count;
1669     long table;
1670     unsigned char *flags;
1671     afs_int32 temp, *indexTime = &temp;
1672     afs_int32 i, j;
1673
1674     /* Handle the afs_indexFlags array */
1675     if (pnt)
1676         printf("\n\nPrinting afs_indexFlags[]...\n");
1677     findsym("afs_cacheFiles", &symoff);
1678     kread(kmem, symoff, (char *)&count, sizeof count);
1679     findsym("afs_indexFlags", &symoff);
1680     kread(kmem, symoff, (char *)&table, sizeof(long));
1681     flags = malloc(count * sizeof(char));
1682     kread(kmem, table, flags, count * sizeof(char));
1683     for (i = 0, j = 0; i < count; i++) {
1684         if (pnt)
1685             printf("afs_indexFlags[%d]\t%4u\n", i, flags[i]);
1686         j++;
1687     }
1688     if (pnt)
1689         printf("afs_indexFlags has %d entries\n", j);
1690     free(flags);
1691 }
1692
1693
1694 void
1695 print_buffers(int pnt)
1696 {
1697     off_t symoff;
1698     long table;
1699     afs_int32 count;
1700     unsigned char *buffers;
1701     struct buffer *bp;
1702     afs_int32 i, j;
1703
1704     if (pnt)
1705         printf("\n\nPrinting 'buffers' table...\n");
1706     findsym("Buffers", &symoff);
1707     kread(kmem, symoff, (char *)&table, sizeof(long));
1708     findsym("nbuffers", &symoff);
1709     kread(kmem, symoff, (char *)&count, sizeof(int));
1710     buffers = malloc(count * sizeof(struct buffer));
1711     kread(kmem, table, buffers, count * sizeof(struct buffer));
1712     bp = (struct buffer *)buffers;
1713     for (i = 0, j = 0; i < count; i++, bp++) {
1714 #ifdef AFS_SGI62_ENV
1715         if (pnt)
1716             printf
1717                 ("Buffer #%d:\tfid=%llu page=%d, accTime=%d,\n\tHash=%x, data=%x, lockers=%x, dirty=%d, hashI=%d\n",
1718                  i, bp->fid[0], bp->page, bp->accesstime, bp->hashNext,
1719                  bp->data, bp->lockers, bp->dirty, bp->hashIndex);
1720 #else
1721         if (pnt)
1722             printf
1723                 ("Buffer #%d:\tfid=%lu page=%d, accTime=%d,\n\tHash=%x, data=%x, lockers=%x, dirty=%d, hashI=%d\n",
1724                  i, bp->fid, bp->page, bp->accesstime, bp->hashNext,
1725                  bp->data, bp->lockers, bp->dirty, bp->hashIndex);
1726 #endif
1727         j++;
1728     }
1729     if (pnt)
1730         printf("\n\t   ... that should be %d buffer entries\n", i);
1731 }
1732
1733
1734 int
1735 print_nfss(int pnt)
1736 {
1737     off_t symoff;
1738     struct afs_exporter *exp_entry, ex, *exp = &ex, *exp1;
1739     struct nfsclientpag *afs_nfspags[NNFSCLIENTS], e, *entry = &e, *ep;
1740     long i, j, cell;
1741
1742     /* Handle the afs_exporter structures */
1743     if (pnt)
1744         printf("\n\nPrinting 'afs_exporters' link list...\n");
1745     findsym("root_exported", &symoff);
1746     kread(kmem, symoff, (char *)&cell, sizeof(long));
1747     for (exp1 = (struct afs_exporter *)cell, j = 0; exp1;
1748          exp1 = exp->exp_next, j++) {
1749         kread(kmem, (off_t) exp1, (char *)exp, sizeof *exp);
1750         if (pnt)
1751             printf("AFS_EXPORTER(%x): \n", exp1);
1752         print_exporter(kmem, exp, exp1, pnt);
1753         Sum_exps++;
1754     }
1755     if (pnt)
1756         printf("... found %d 'afs_exporters' entries\n", j);
1757
1758     /* Handle the afs_nfsclientpags structs */
1759     if (pnt)
1760         printf("\n\nPrinting 'afs_nfsclientpags' structures...\n");
1761     if (!findsym("afs_nfspags", &symoff))
1762         return 0;
1763     kread(kmem, symoff, (char *)afs_nfspags, sizeof afs_nfspags);
1764     for (i = 0, j = 0; i < NNFSCLIENTS; i++) {
1765         for (ep = afs_nfspags[i]; ep; ep = entry->next, j++) {
1766             kread(kmem, (off_t) ep, (char *)entry, sizeof *entry);
1767             print_nfsclient(kmem, entry, ep, pnt);
1768         }
1769     }
1770     if (pnt)
1771         printf("... found %d 'afs_nfsclientpags' entries\n", j);
1772     return j;
1773 }
1774
1775 #if defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX41_ENV)
1776 typedef struct event {
1777     struct event *next;         /* next in hash chain */
1778     char *event;                /* lwp event: an address */
1779     int refcount;               /* Is it in use? */
1780     kcondvar_t cond;            /* Currently associated condition variable */
1781     int seq;                    /* Sequence number: this is incremented
1782                                  * by wakeup calls; wait will not return until
1783                                  * it changes */
1784 } event_t;
1785 #endif
1786
1787
1788 #ifdef AFS_LINUX22_ENV
1789 /* This is replicated from LINUX/osi_alloc.c */
1790 #define MEM_SPACE sizeof(int)
1791
1792 #define KM_TYPE 1
1793 #define VM_TYPE 2
1794 struct osi_linux_mem {
1795     int mem_next;               /* types are or'd into low bits of next */
1796     char data[1];
1797 };
1798 #define MEMTYPE(A) ((A) & 0x3)
1799 #define MEMADDR(A) ((struct osi_linux_mem*)((A) & (~0x3)))
1800 #define PR_MEMTYPE(A) ((MEMTYPE(A) == KM_TYPE) ? "phys" : "virt")
1801 void
1802 print_alloced_memlist(void)
1803 {
1804     off_t symoff;
1805     struct osi_linux_mem *memp, memlist, next;
1806     off_t next_addr;
1807     int count;
1808     int n = 0;
1809
1810     findsym("afs_linux_memlist_size", &symoff);
1811     kread(kmem, symoff, (char *)&count, sizeof count);
1812     findsym("afs_linux_memlist", &symoff);
1813     kread(kmem, symoff, (char *)&memp, sizeof memp);
1814     if (memp) {
1815 #ifdef AFS_LINUX_64BIT_KERNEL
1816         kread(kmem, (unsigned long)memp, (char *)&next, sizeof next);
1817 #else
1818         kread(kmem, (int)memp, (char *)&next, sizeof next);
1819 #endif /* AFS_LINUX_64BIT_KERNEL */
1820     } else {
1821         memset(&next, 0, sizeof next);
1822     }
1823     printf("Allocated memory list: %d elements\n", count);
1824     printf("%20s %4s %10s\n", "Address", "Type", "Next");
1825     printf("%20lx %4s %10x\n", (long)((char *)memp) + MEM_SPACE,
1826            PR_MEMTYPE(next.mem_next), next.mem_next);
1827     n = 1;
1828     while (next_addr = (off_t) MEMADDR(next.mem_next)) {
1829         n++;
1830         memlist = next;
1831         kread(kmem, next_addr, (char *)&next, sizeof next);
1832         printf("%20lx %4s %10x\n", (long)next_addr + MEM_SPACE,
1833                PR_MEMTYPE(next.mem_next), next.mem_next);
1834     }
1835     printf("Found %d elements in allocated memory list, expected %d\n", n,
1836            count);
1837 }
1838 #endif
1839
1840 void
1841 print_allocs(int pnt)
1842 {
1843     off_t symoff;
1844     long count, i, j, k, l, m, n, T = 0, tvs;
1845     struct afs_CMStats afs_cmstats;
1846     struct afs_stats_CMPerf afs_cmperfstats;
1847
1848     findsym("afs_cmstats", &symoff);
1849     kread(kmem, symoff, (char *)&afs_cmstats, sizeof afs_cmstats);
1850     findsym("afs_stats_cmperf", &symoff);
1851     kread(kmem, symoff, (char *)&afs_cmperfstats, sizeof afs_cmperfstats);
1852
1853     T += MAXSYSNAME;
1854     printf("\n\n%20s:\t%8d bytes\n", "Sysname area", MAXSYSNAME);
1855
1856     Sum_cellnames = 0;
1857     i = print_cells(0);
1858     j = (i * sizeof(struct cell)) + Sum_cellnames;
1859     T += j;
1860     printf
1861         ("%20s:\t%8d bytes\t[%d cells/%d bytes each + %d bytes for cell names]\n",
1862          "Cell package", j, i, sizeof(struct cell), Sum_cellnames);
1863
1864     Sum_cellaliases = 0;
1865     i = print_cellaliases(0);
1866     j = (i * sizeof(struct cell_alias)) + Sum_cellaliases;
1867     T += j;
1868     printf
1869         ("%20s:\t%8d bytes\t[%d cell_aliases/%d bytes each + %d bytes for cell names]\n",
1870          "Cell package", j, i, sizeof(struct cell_alias), Sum_cellaliases);
1871
1872     Sum_cellname_names = 0;
1873     i = print_cellnames(0);
1874     j = (i * sizeof(struct cell_name)) + Sum_cellname_names;
1875     T += j;
1876     printf
1877         ("%20s:\t%8d bytes\t[%d cell_names/%d bytes each + %d bytes for cell name strings]\n",
1878          "Cell package", j, i, sizeof(struct cell_name), Sum_cellname_names);
1879
1880     Sum_userstp = 0;
1881     i = print_users(0);
1882     j = (i * sizeof(struct unixuser)) + Sum_userstp;
1883     T += j;
1884     printf
1885         ("%20s:\t%8d bytes\t[%d users/%d bytes each + %d bytes for secret tokens]\n",
1886          "User package", j, i, sizeof(struct unixuser), Sum_userstp);
1887
1888     i = print_servers(0);
1889     j = (i * sizeof(struct server));
1890     T += j;
1891     printf("%20s:\t%8d bytes\t[%d servers/%d bytes each]\n", "Server package",
1892            j, i, sizeof(struct server));
1893     j = (Nconns * sizeof(struct afs_conn));
1894     T += j;
1895     printf("%20s:\t%8d bytes\t[%d conns/%d bytes each]\n",
1896            "Connection package", j, Nconns, sizeof(struct afs_conn));
1897
1898     i = (AFS_NCBRS * sizeof(struct afs_cbr)) * (j =
1899                                                 afs_cmperfstats.
1900                                                 CallBackAlloced);
1901     T += i;
1902     if (i)
1903         printf("%20s:\t%8d bytes\t[%d cbs/%d bytes each]\n",
1904                "Server CB free pool", i, (j * AFS_NCBRS),
1905                sizeof(struct afs_cbr));
1906
1907     Sum_volnames = 0;
1908     i = print_volumes(0);
1909     j = (MAXVOLS * sizeof(struct volume)) + Sum_volnames;
1910     T += j;
1911     printf
1912         ("%20s:\t%8d bytes\t[%d volumes/%d bytes each + %d bytes for volnames - %d active entries]\n",
1913          "Volume package", j, MAXVOLS, sizeof(struct volume), Sum_volnames,
1914          i);
1915
1916     Sum_vcachemvids = Sum_vcachelinkData = Sum_vcacheacc = Sum_vcachelocks =
1917         0;
1918     tvs = i = print_vcaches(0);
1919     j = (i * sizeof(struct vcache));
1920 /*    T += j;*/
1921 /*    printf("%20s:\t%d bytes\t[%d vcaches/%d bytes each]\n", "Vcache package", j, i, sizeof(struct vcache));*/
1922 #ifdef  AFS_AIX32_ENV
1923     i = (tvs + Sum_vcachemvids + Sum_vcachelinkData +
1924          Sum_vcachelocks) * AFS_SMALLOCSIZ;
1925     printf
1926         ("%20s:\t%8d bytes\t[%d act gnodes, %d mount pnts, %d symbolic links, %d unix locks]\n",
1927          "[VC use of sml fp]*", i, tvs, Sum_vcachemvids, Sum_vcachelinkData,
1928          Sum_vcachelocks);
1929 #else
1930     i = (Sum_vcachemvids + Sum_vcachelinkData +
1931          Sum_vcachelocks) * AFS_SMALLOCSIZ;
1932     printf
1933         ("%20s:\t8%d bytes\t[%d mount pnts, %d symbolic links, %d unix locks]\n",
1934          "[VC use of sml fp]*", i, Sum_vcachemvids, Sum_vcachelinkData,
1935          Sum_vcachelocks);
1936 #endif
1937
1938 #define NAXSs (1000 / sizeof(struct axscache))
1939 #ifdef  AFS32
1940     i = (NAXSs * sizeof(struct axscache));
1941     T += i;
1942     printf("%20s:\t%8d bytes\t[%d access used by vcaches/%d bytes each]\n",
1943            "ACL List free pool", i, Sum_vcacheacc, sizeof(struct axscache));
1944 #else
1945     {
1946         struct axscache *xp, xpe, *nxp = &xpe;
1947
1948         findsym("afs_xaxscnt", &symoff);
1949         kread(kmem, symoff, (char *)&i, sizeof i);
1950         j = i * (NAXSs * sizeof(struct axscache));
1951         T += j;
1952         printf
1953             ("%20s:\t%8d bytes\t[%d access used by vcaches/%d bytes each - %d blocks of %d]\n",
1954              "ACL List free pool", j, Sum_vcacheacc, sizeof(struct axscache),
1955              i, (NAXSs * sizeof(struct axscache)));
1956     }
1957 #endif
1958
1959 #ifdef  AFS32
1960     i = print_dcaches(0);
1961     j = (i * sizeof(struct dcache));
1962     T += j;
1963     printf
1964         ("%20s:\t%8d bytes\t[%d dcaches/%d bytes each - ONLY USED COUNTED]\n",
1965          "Dcache package", j, i, sizeof(struct dcache));
1966 #else
1967     findsym("afs_dcentries", &symoff);
1968     kread(kmem, symoff, (char *)&i, sizeof i);
1969     j = (i * sizeof(struct dcache));
1970     T += j;
1971     printf("%20s:\t%8d bytes\t[%d dcaches/%d bytes each]\n", "Dcache package",
1972            j, i, sizeof(struct dcache));
1973 #endif
1974     findsym("afs_cacheFiles", &symoff);
1975     kread(kmem, symoff, (char *)&i, sizeof i);
1976     findsym("afs_cacheStats", &symoff);
1977     kread(kmem, symoff, (char *)&j, sizeof j);
1978
1979     k = (j * sizeof(struct vcache));
1980     printf
1981         ("%20s:\t%8d bytes\t[%d free vcaches/%d bytes each - %d active entries]\n",
1982          "Vcache free list", k, j, sizeof(struct vcache), tvs);
1983     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
1984            "Dcache Index Table", i * 4, i, 4);
1985 #ifndef AFS32
1986     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
1987            "Dcache Index Times", i * 8, i, 8);
1988 #else
1989     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
1990            "Dcache Index Times", i * 4, i, 4);
1991 #endif
1992     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
1993            "Dcache Index Flags", i, i, 1);
1994 /*    printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n", "Dcache free list", i, i, 1);*/
1995 #ifndef AFS32
1996     T += k + (i * 4) + (i * 8) + i;
1997 #else
1998     T += k + (i * 4) + (i * 4) + i;
1999 #endif
2000
2001     i = (j = afs_cmperfstats.bufAlloced) * sizeof(struct buffer);
2002     T += i;
2003     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n", "Buffer package",
2004            i, j, sizeof(struct buffer));
2005 #define AFS_BUFFER_PAGESIZE 2048
2006     i = j * AFS_BUFFER_PAGESIZE;
2007     T += i;
2008     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
2009            "Xtra Buffer pkg area", i, j, AFS_BUFFER_PAGESIZE);
2010
2011     Sum_exps = 0;
2012     Sum_nfssysnames = 0;
2013     i = print_nfss(0);
2014     k = Sum_exps * sizeof(struct afs_exporter);
2015     T += k;
2016     if (k)
2017         printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
2018                "Xlator Exporter list", k, Sum_exps,
2019                sizeof(struct afs_exporter));
2020
2021     j = (i * sizeof(struct nfsclientpag)) + Sum_nfssysnames;
2022     T += j;
2023     if (j)
2024         printf
2025             ("%20s:\t%8d bytes\t[%d entries/%d bytes each + %d for remote sysnames]\n",
2026              "Xlator Nfs clnt pkg", j, i, sizeof(struct nfsclientpag),
2027              Sum_nfssysnames);
2028
2029     i = (j = afs_cmperfstats.LargeBlocksAlloced) * AFS_LRALLOCSIZ;
2030     T += i;
2031     printf
2032         ("%20s:\t%8d bytes\t[%d entries/%d bytes each - %d active entries]\n",
2033          "Large Free Pool", i, j, AFS_LRALLOCSIZ,
2034          afs_cmperfstats.LargeBlocksActive);
2035
2036     i = (j = afs_cmperfstats.SmallBlocksAlloced) * AFS_SMALLOCSIZ;
2037     T += i;
2038     printf
2039         ("%20s:\t%8d bytes\t[%d entries/%d bytes each - %d active entries]\n",
2040          "Small Free Pool", i, j, AFS_SMALLOCSIZ,
2041          afs_cmperfstats.SmallBlocksActive);
2042
2043 #if defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX41_ENV)
2044     findsym("afs_evhashcnt", &symoff);
2045     kread(kmem, symoff, (char *)&j, sizeof j);
2046     i = (j * sizeof(event_t));
2047     T += i;
2048     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
2049            "afs glock Event Pool", i, j, sizeof(event_t));
2050 /*    printf("XXXXXXX Count event queue allocs!!!! XXXXXX\n");*/
2051
2052 #endif
2053     i = j = 0;
2054     if (findsym("rxevent_nFree", &symoff))
2055         kread(kmem, symoff, (char *)&j, sizeof j);
2056     if (findsym("rxevent_nPosted", &symoff))
2057         kread(kmem, symoff, (char *)&i, sizeof i);
2058     k = (i + j) * sizeof(struct rxevent);
2059     if (k) {
2060         T += k;
2061         printf("%20s:\t%8d bytes\t[%d free, %d posted/%d bytes each]\n",
2062                "Rx event pkg", k, j, i, sizeof(struct rxevent));
2063     } else {
2064         T += (k = 20 * sizeof(struct rxevent));
2065         printf
2066             ("%20s:\t%8d bytes\t[%d entries/%d bytes each - THIS IS MIN ALLOC/NOT ACTUAL]\n",
2067              "Rx event pkg", k, 20, sizeof(struct rxevent));
2068     }
2069
2070     findsym("rx_nFreePackets", &symoff);
2071     kread(kmem, symoff, (char *)&count, sizeof count);
2072 /*
2073     findsym("rx_initSendWindow", &symoff);
2074     kread(kmem, symoff, (char *) &i, sizeof i);
2075 */
2076     i = 0;
2077     findsym("rx_nPackets", &symoff);
2078     kread(kmem, symoff, (char *)&j, sizeof j);
2079     k = (j + i + 2) * sizeof(struct rx_packet);
2080     T += k;
2081     printf("%20s:\t%8d bytes\t[%d free packets/%d bytes each]\n",
2082            "Rx packet freelist", k, count, sizeof(struct rx_packet));
2083 #define rx_hashTableSize 256    /* XXX */
2084     i = (rx_hashTableSize * sizeof(struct rx_connection *));
2085     j = (rx_hashTableSize * sizeof(struct rx_peer *));
2086     k = i + j;
2087     T += k;
2088     printf("%20s:\t%8d bytes\t[%d entries/%d bytes each]\n",
2089            "Rx conn/peer tables", k, rx_hashTableSize,
2090            sizeof(struct rx_connection *));
2091
2092     findsym("rxi_Alloccnt", &symoff);
2093     kread(kmem, symoff, (char *)&j, sizeof j);
2094     findsym("rxi_Allocsize", &symoff);
2095     kread(kmem, symoff, (char *)&i, sizeof i);
2096     T += i;
2097     printf("%20s:\t%8d bytes\t[%d outstanding allocs]\n", "RX misc allocs", i,
2098            j);
2099
2100
2101     j = afs_cmperfstats.OutStandingMemUsage;
2102     printf("\n\n%20s:\t%8d bytes\n", "Mem used by afs", j);
2103     printf("%20s:\t%8d bytes\n", "Accounted-for mem", T);
2104     printf("%20s:\t%8d bytes\n", "Non acc'd-for mem", j - T);
2105
2106     printf
2107         ("\n\nNOTE:\n\tAll [...]* entries above aren't counted towards the total mem since they're redundant\n");
2108
2109 #ifdef AFS_LINUX22_ENV
2110     if (pnt)
2111         print_alloced_memlist();
2112 #endif
2113 }
2114
2115 #if     defined(sparc) && !defined(__linux__)
2116 int
2117 readmem(kmem, buf, vad, len)
2118      int kmem, len;
2119 #ifdef AFS_SUN5_ENV
2120      uintptr_t vad;
2121 #else
2122      int vad;
2123 #endif          /** AFS_SUN5_ENV **/
2124      char *buf;
2125 {
2126     int newlen;
2127     if ((newlen = kvm_kread(kd, vad, buf, len)) != len) {
2128         printf("Couldn't process dumpfile with supplied namelist %s\n", obj);
2129         exit(1);
2130     }
2131 }
2132 #endif
2133
2134 #ifndef AFS_KDUMP_LIB
2135 void
2136 kread(int kmem, off_t loc, void *buf, KDUMP_SIZE_T len)
2137 {
2138     int i;
2139
2140     memset(buf, 0, len);
2141
2142 #if     defined(sparc) && !defined(__linux__)
2143 #ifndef AFS_SUN5_ENV
2144     if (mem) {
2145 #endif
2146         readmem(kmem, buf, (off_t) loc, len);
2147         return;
2148 #ifndef AFS_SUN5_ENV
2149     }
2150 #endif
2151 #endif
2152 #if     ! defined(AFS_SUN5_ENV)
2153 #if defined(AFS_SGI61_ENV) && !defined(AFS_32BIT_KERNEL_ENV)
2154     if (lseek64(kmem, loc, L_SET /*0 */ ) != loc)
2155 #else
2156     if (lseek(kmem, loc, L_SET /*0 */ ) != loc)
2157 #endif
2158     {
2159         perror("lseek");
2160         exit(1);
2161     }
2162     if (loc == 0)
2163         printf("WARNING: Read failed: loc=0\n");
2164     else
2165         if ((i = read(kmem, buf, len)) != len) {
2166             printf("WARNING: Read failed: ");
2167             if (sizeof(loc) > sizeof(long)) {
2168                 printf("loc=%llx", loc);
2169             } else {
2170                 printf("loc=%lx", (long)loc);
2171             }
2172             printf(", buf=%lx, len=%ld, i=%d, errno=%d\n", (long)buf,
2173                    (long)len, i, errno);
2174             return;                     /*exit(1); */
2175         }
2176 #endif
2177 }
2178 #endif /* AFS_KDUMP_LIB */
2179
2180 #ifdef  AFS_SUN5_ENV
2181
2182 /**
2183   * When examining the dump of a 64 bit kernel, we use this function to
2184   * read symbols. The function opencore() calls this or rdsymbols() using
2185   * the macro RDSYMBOLS
2186   */
2187
2188 void
2189 rdsymbols(void)
2190 {
2191
2192     FILE *fp;
2193     Elf *efd;
2194     Elf_Scn *cn = NULL;
2195 #ifdef  _LP64
2196     Elf64_Shdr *shdr;
2197     Elf64_Sym *stbl, *p1, *p2;
2198     Elf64_Shdr *(*elf_getshdr) (Elf_Scn *) = elf64_getshdr;
2199 #else
2200     Elf32_Shdr *shdr;
2201     Elf32_Sym *stbl, *p1, *p2;
2202     Elf32_Shdr *(*elf_getshdr) (Elf_Scn *) = elf32_getshdr;
2203 #endif
2204     Elf_Data *dp = NULL, *sdp = NULL;
2205
2206     int nsyms, i, fd;
2207
2208     if (!(fp = fopen(obj, "r"))) {
2209         printf("Can't open %s (%d)\n", core, errno);
2210         exit(1);
2211     }
2212
2213     fd = fileno(fp);
2214     lseek(fd, 0L, 0);
2215     if ((efd = elf_begin(fd, ELF_C_READ, 0)) == NULL) {
2216         printf("Can't elf begin (%d)\n", errno);
2217         exit(1);
2218     }
2219     while (cn = elf_nextscn(efd, cn)) {
2220         if ((shdr = elf_getshdr(cn)) == NULL) {
2221             elf_end(efd);
2222             printf("Can't read section header (%d)\n", errno);
2223             exit(1);
2224         }
2225         if (shdr->sh_type == SHT_SYMTAB)
2226             break;
2227     }
2228     dp = elf_getdata(cn, dp);
2229     p1 = stbl = (void *)dp->d_buf;
2230     nsyms = dp->d_size / sizeof(*stbl);
2231     cn = elf_getscn(efd, shdr->sh_link);
2232     sdp = elf_getdata(cn, sdp);
2233     tblp = malloc(sdp->d_size);
2234     memcpy(tblp, sdp->d_buf, sdp->d_size);
2235     p2 = tbl = malloc(nsyms * sizeof(*stbl));
2236     for (i = 0, scnt = 0; i < nsyms; i++, p1++, p2++) {
2237         p2->st_name = p1->st_name;
2238         p2->st_value = p1->st_value;
2239         p2->st_size = p1->st_size;
2240         p2->st_info = p1->st_info;
2241         p2->st_shndx = p1->st_shndx;
2242         scnt++;
2243     }
2244     elf_end(efd);
2245     close(fd);
2246 }
2247
2248 #endif          /** AFS_SUN5_ENV **/
2249
2250
2251 int
2252 opencore(char *core)
2253 {
2254 #ifdef AFS_KDUMP_LIB
2255     return 0;
2256 #else /* AFS_KDUMP_LIB */
2257     int fd;
2258
2259 #if     defined(sparc) && !defined(__linux__)
2260 #ifndef AFS_SUN5_ENV
2261     if (mem) {
2262 #endif
2263
2264         if ((kd = kvm_open(obj, core, NULL, O_RDONLY, "crash")) == NULL) {
2265             printf("Can't open kvm - core file %s\n", core);
2266             exit(1);
2267         }
2268 #ifndef AFS_SUN5_ENV
2269     } else
2270 #endif
2271 #ifdef  AFS_SUN5_ENV
2272         rdsymbols();
2273 #endif
2274 #endif /* sparc */
2275
2276     {
2277         if ((fd = open(core, O_RDONLY)) < 0) {
2278             perror(core);
2279             exit(1);
2280         }
2281         return fd;
2282     }
2283 #endif /* AFS_KDUMP_LIB */
2284 }
2285
2286
2287 void
2288 print_exporter(int kmem, struct afs_exporter *exporter,
2289                struct afs_exporter *ptr, int pnt)
2290 {
2291     if (pnt) {
2292         printf("\tstates=%x, type=%x, *data=%lx\n", exporter->exp_states,
2293                exporter->exp_type, exporter->exp_data);
2294         printf
2295             ("\texp_stats (calls=%d, rejectedcalls=%d, nopag=%d, invalidpag=%d)\n",
2296              exporter->exp_stats.calls, exporter->exp_stats.rejectedcalls,
2297              exporter->exp_stats.nopag, exporter->exp_stats.invalidpag);
2298     }
2299 }
2300
2301
2302 void
2303 print_nfsclient(int kmem, struct nfsclientpag *ep,
2304                 struct nfsclientpag *ptr, int pnt)
2305 {
2306     char sysname[100];
2307         int count;
2308
2309     if (pnt)
2310         printf("%lx: uid=%d, host=%x, pag=%x, lastt=%d, ref=%d count=%d\n",
2311                ptr, ep->uid, ep->host, ep->pag,
2312                ep->lastcall, ep->refCount, ep->sysnamecount);
2313
2314         for(count = 0; count < ep->sysnamecount; count++){
2315                 kread(kmem, (off_t) ep->sysname[count], sysname, (KDUMP_SIZE_T) 30);
2316                 printf("   %lx: @sys[%d]=%s\n",
2317                         ep->sysname[count], count, sysname);
2318                 Sum_nfssysnames += MAXSYSNAME;
2319         }
2320 }
2321
2322
2323 #if     defined(AFS_SUN5_ENV)
2324 void
2325 pmutex(char *sp, kmutex_t *mp)
2326 {
2327 }
2328
2329 #endif
2330
2331 void
2332 print_unixuser(int kmem, struct unixuser *uep,
2333                struct unixuser *ptr, int pnt)
2334 {
2335     Sum_userstp += uep->stLen;
2336     if (pnt) {
2337         printf
2338             ("%lx: uid=x%x, cell=%x, vid=%d, refc=%d, states=%x, tokTime=%d, tikLen=%d\n",
2339              ptr, uep->uid, uep->cell, uep->vid, uep->refCount, uep->states,
2340              uep->tokenTime, uep->stLen);
2341         printf
2342             ("\tstp=%lx, clearTok[Han=x%x, x<%x,%x,%x,%x,%x,%x,%x,%x>, vid=%d, Bt=%d, Et=%d], exporter=%lx\n",
2343              uep->stp, uep->ct.AuthHandle, uep->ct.HandShakeKey[0],
2344              uep->ct.HandShakeKey[1], uep->ct.HandShakeKey[2],
2345              uep->ct.HandShakeKey[3], uep->ct.HandShakeKey[4],
2346              uep->ct.HandShakeKey[5], uep->ct.HandShakeKey[6],
2347              uep->ct.HandShakeKey[7], uep->ct.ViceId, uep->ct.BeginTimestamp,
2348              uep->ct.EndTimestamp, uep->exporter);
2349     }
2350 }
2351
2352 void
2353 print_cell(int kmem, struct cell *clep, struct cell *ptr, int pnt)
2354 {
2355     int i;
2356     char cellName[100];
2357     struct in_addr in;
2358
2359
2360     kread(kmem, (off_t) clep->cellName, cellName, (KDUMP_SIZE_T) 40);
2361     cellName[40] = 0;
2362     Sum_cellnames += strlen(cellName) + 1;
2363     if (pnt) {
2364         printf
2365             ("%lx: cellname=%s, states=%x, cnum=%d, cindex=%d fsport=%d vlport=%d timeout=%d cnamep=%x\n",
2366              ptr, cellName, clep->states, clep->cellNum, clep->cellIndex,
2367              clep->fsport, clep->vlport, clep->timeout, clep->cnamep);
2368 #ifdef  AFS33
2369         if (clep->lcellp)
2370             printf("\tlinked cellp %lx\n", clep->lcellp);
2371 #endif
2372         printf("\tCell's servers: ");
2373         for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
2374             if (pretty && (clep->cellHosts[i] == 0))
2375                 break;
2376             printf("[%lx] ", clep->cellHosts[i]);
2377         }
2378         printf("\n");
2379     }
2380 }
2381
2382
2383 void
2384 print_server(int kmem, struct server *sep, struct server *ptr, int conns,
2385              int pnt)
2386 {
2387     struct srvAddr sa, *sap = &sa, *sap1;
2388     int j, mh = 0, cnt;
2389
2390     if (conns != 2 && pnt) {
2391         printf
2392             ("%lx: cell=%lx, addr=%lx, flags=0x%x, actTime=%x, lastDownS=%x, numDownIn=%d, sumofDownt=%d\n",
2393              ptr, sep->cell, sep->addr, sep->flags, sep->activationTime,
2394              sep->lastDowntimeStart, sep->numDowntimeIncidents,
2395              sep->sumOfDowntimes);
2396         if (sep->flags & SRVR_MULTIHOMED) {
2397             if (pnt) {
2398                 printf
2399                     ("\tuuid=[%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x]  addr_uniquifier=%x\n",
2400                      sep->sr_uuid.time_low, sep->sr_uuid.time_mid,
2401                      sep->sr_uuid.time_hi_and_version,
2402                      sep->sr_uuid.clock_seq_hi_and_reserved,
2403                      sep->sr_uuid.clock_seq_low, sep->sr_uuid.node[0],
2404                      sep->sr_uuid.node[1], sep->sr_uuid.node[2],
2405                      sep->sr_uuid.node[3], sep->sr_uuid.node[4],
2406                      sep->sr_uuid.node[5], sep->sr_addr_uniquifier);
2407             }
2408             mh = 1;
2409         }
2410         for (j = 0, cnt = 1, sap1 = sep->addr; sap1;
2411              sap1 = sap->next_sa, j++, cnt++) {
2412             kread(kmem, (off_t) sap1, (char *)sap, sizeof(*sap));
2413             if (pnt) {
2414                 if (mh) {
2415                     printf
2416                         ("\t   #%d ip-addr(%lx): [sa_ip=%s, sa_port=%d, sa_iprank=%d, sa_flags=%x, conns=%lx, server=%lx, next_bkt=%lx]\n",
2417                          cnt, sap1, PrintIPAddr(sap->sa_ip), sap->sa_portal,
2418                          sap->sa_iprank, sap->sa_flags, sap->conns,
2419                          sap->server, sap->next_bkt);
2420                 } else {
2421                     printf
2422                         ("\t[sa_ip=%s, sa_port=%d, sa_iprank=%d, sa_flags=%x, conns=%lx, server=%lx, nexth=%lx]\n",
2423                          PrintIPAddr(sap->sa_ip), sap->sa_portal,
2424                          sap->sa_iprank, sap->sa_flags, sap->conns,
2425                          sap->server, sap->next_bkt);
2426                 }
2427             }
2428         }
2429     }
2430     if (sep->cbrs && pnt) {
2431         struct afs_cbr cba, *cbsap = &cba, *cbsap1;
2432
2433         printf(" Callbacks to be returned:\n");
2434         for (j = 0, cbsap1 = sep->cbrs; cbsap1; cbsap1 = cbsap->next, j++) {
2435             kread(kmem, (off_t) cbsap1, (char *)cbsap, sizeof(*cbsap));
2436             printf("     #%2d) %lx [v=%d, n=%d, u=%d]\n", j, cbsap1,
2437                    cbsap->fid.Volume, cbsap->fid.Vnode, cbsap->fid.Unique);
2438         }
2439     }
2440     if (conns) {
2441         for (j = 0, sap1 = sep->addr; sap1; sap1 = sap->next_sa, j++) {
2442             kread(kmem, (off_t) sap1, (char *)sap, sizeof(*sap));
2443             print_conns(kmem, sap1, sap->conns, conns, pnt);
2444         }
2445     } else if (pnt)
2446         printf("\n");
2447 }
2448
2449
2450 void
2451 print_conns(int kmem, struct srvAddr *srv, struct afs_conn *conns, int Con,
2452             int pnt)
2453 {
2454     struct afs_conn *cep, ce, *centry = &ce;
2455     int i = 1;
2456
2457     cep = (struct afs_conn *)conns;
2458     if (pnt && Con != 2) {
2459         if (cep)
2460             printf("\tRPC connections for server %lx:\n", srv);
2461         else
2462             printf("\tNO RPC connections for server %x\n", srv);
2463     }
2464     for (; cep; cep = centry->next, Nconns++, i++) {
2465         if (pnt && Con != 2)
2466             printf("\t   #%d> ", i);
2467         kread(kmem, (off_t) cep, (char *)centry, sizeof *centry);
2468         print_conn(kmem, centry, cep, pnt);
2469     }
2470 }
2471
2472
2473 void
2474 print_conn(int kmem, struct afs_conn *conns, struct afs_conn *ptr, int pnt)
2475 {
2476     if (!pnt)
2477         return;
2478     printf("%lx: user=%lx, rx=%lx, srvr=%lx, ref=%d, port=%d, forceC=%d\n",
2479            ptr, conns->user, conns->id, conns->srvr, conns->refCount,
2480            conns->port, conns->forceConnectFS);
2481
2482 }
2483
2484
2485 void
2486 print_volume(int kmem, struct volume *vep, struct volume *ptr, int pnt)
2487 {
2488     int i;
2489     afs_int32 *loc;
2490     char Volname[100];
2491
2492
2493
2494     loc = (afs_int32 *) & vep->lock;
2495     if (vep->name) {
2496         kread(kmem, (off_t) vep->name, Volname, (KDUMP_SIZE_T) 40);
2497         Sum_volnames += strlen(Volname) + 1;
2498     }
2499     if (!pnt)
2500         return;
2501     printf("%lx: cell=%x, vol=%d, name=%s, roVol=%d, backVol=%d\n", ptr,
2502            vep->cell, vep->volume, (vep->name ? Volname : "nil"), vep->roVol,
2503            vep->backVol);
2504 #ifdef  AFS33
2505     printf
2506         ("\trwVol=%d, setupTime=%d, copyDate=%d, expTime=%d, vtix=%d, refC=%d, states=%x\n",
2507          vep->rwVol, vep->setupTime, vep->copyDate, vep->expireTime,
2508          vep->vtix, vep->refCount, vep->states);
2509 #else
2510     printf
2511         ("\trwVol=%d, setupTime=%d, copyDate=%d, vtix=%d, refC=%d, states=%x\n",
2512          vep->rwVol, vep->setupTime, vep->copyDate, vep->vtix, vep->refCount,
2513          vep->states);
2514 #endif
2515     printf("\tVolume's statuses: ");
2516     for (i = 0; i < AFS_MAXHOSTS && vep->serverHost[i]; i++)
2517         printf("[%d] ", vep->status[i]);
2518     printf("\n");
2519
2520     printf("\tVolume's servers: ");
2521     for (i = 0; i < AFS_MAXHOSTS && vep->serverHost[i]; i++)
2522         printf("[%lx] ", vep->serverHost[i]);
2523     printf("\n");
2524
2525     print_venusfid("\tdotdot", &vep->dotdot);
2526     printf("\n");
2527
2528     print_venusfid("\tmtpnt", &vep->mtpoint);
2529     printf("\n");
2530
2531 #ifdef  AFS33
2532     if (vep->rootVnode)
2533         printf("\trootVnode = %d, rootUnique = %d\n", vep->rootVnode,
2534                vep->rootUnique);
2535 #endif
2536     printf("\tlock=0x%x\n", *loc);
2537 }
2538
2539
2540 void
2541 print_venusfid(char *string, struct VenusFid *vid)
2542 {
2543     printf("%s(c=%x, v=%d, n=%d, u=%d)", string, vid->Cell, vid->Fid.Volume,
2544            vid->Fid.Vnode, vid->Fid.Unique);
2545 }
2546
2547
2548 void
2549 print_vnode(int kmem, struct vnode *vep, struct vnode *ptr, int pnt)
2550 {
2551 #ifdef AFS_AIX_ENV
2552     struct gnode gnode;
2553     struct gnode *save_gnode;
2554 #endif /* AFS_AIX_ENV */
2555
2556     if (!pnt)
2557         return;
2558     printf("\n");
2559 #ifdef AFS_AIX_ENV
2560     save_gnode = vep->v_gnode;
2561     kread(kmem, (off_t) save_gnode, (char *)&gnode, sizeof(struct gnode));
2562     vep->v_gnode = &gnode;
2563 #endif /* AFS_AIX_ENV */
2564
2565 #ifdef  AFS_SUN5_ENV
2566     printf("%x: v_type=%d, v_flag=%d, v_count=%d, \n", ptr, vep->v_type,
2567            vep->v_flag, vep->v_count);
2568     printf
2569         ("\tv_v_stream=%x, v_pages=0x%x, v_mountdhere=%d, v_rdev=%d, v_vfsp=0x%x, v_filocks=0x%x\n",
2570          vep->v_stream, vep->v_pages, vep->v_vfsmountedhere, vep->v_rdev,
2571          vep->v_vfsp, vep->v_filocks);
2572     pmutex("\tVnode", &vep->v_lock);
2573     printf("\tCond v: 0x%x\n", vep->v_cv);
2574 #endif
2575 #ifdef AFS_AIX_ENV
2576     vep->v_gnode = save_gnode;
2577 #endif /* AFS_AIX_ENV */
2578 #ifdef AFS_SGI65_ENV
2579 #if defined(AFS_32BIT_KERNEL_ENV)
2580     printf("%lx: v_mreg=0x%lx", ptr, vep->v_mreg);
2581 #else
2582     printf("%llx: v_mreg=0x%llx", ptr, vep->v_mreg);
2583 #endif
2584     printf(", v_mregb=0x%lx\n", vep->v_mregb);
2585 #endif
2586 #ifdef AFS_LINUX22_ENV
2587     /* Print out the stat cache and other inode info. */
2588     printf
2589         ("\ti_ino=%d, i_mode=%x, i_nlink=%d, i_uid=%d, i_gid=%d, i_size=%d\n",
2590          vep->i_ino, vep->i_mode, vep->i_nlink, vep->i_uid, vep->i_gid,
2591          vep->i_size);
2592 #ifdef AFS_LINUX24_ENV
2593     printf
2594         ("\ti_atime=%u, i_mtime=%u, i_ctime=%u, i_version=%u, i_nrpages=%u\n",
2595          vep->i_atime, vep->i_mtime, vep->i_ctime, vep->i_version,
2596          vep->i_data.nrpages);
2597 #else
2598     printf
2599         ("\ti_atime=%u, i_mtime=%u, i_ctime=%u, i_version=%u, i_nrpages=%u\n",
2600          vep->i_atime, vep->i_mtime, vep->i_ctime, vep->i_version,
2601          vep->i_nrpages);
2602 #endif
2603 #ifdef AFS_LINUX26_ENV
2604     printf("\ti_op=0x%x, i_rdev=0x%x, i_sb=0x%x\n", vep->i_op,
2605            vep->i_rdev, vep->i_sb);
2606 #else /* AFS_LINUX26_ENV */
2607     printf("\ti_op=0x%x, i_dev=0x%x, i_rdev=0x%x, i_sb=0x%x\n", vep->i_op,
2608            vep->i_dev, vep->i_rdev, vep->i_sb);
2609 #endif /* AFS_LINUX26_ENV */
2610 #ifdef AFS_LINUX24_ENV
2611 #ifdef AFS_PARISC_LINUX24_ENV
2612     printf("\ti_sem: count=%d, wait=0x%x\n", vep->i_sem.count,
2613            vep->i_sem.wait);
2614 #else
2615     printf("\ti_sem: count=%d, sleepers=%d, wait=0x%x\n", vep->i_sem.count,
2616            vep->i_sem.sleepers, vep->i_sem.wait);
2617 #endif
2618 #else
2619     printf("\ti_sem: count=%d, waking=%d, wait=0x%x\n", vep->i_sem.count,
2620            vep->i_sem.waking, vep->i_sem.wait);
2621 #endif
2622 #ifdef AFS_LINUX26_ENV
2623     printf("\ti_hash=0x%x:0x%x, i_list=0x%x:0x%x, i_dentry=0x%x:0x%x\n",
2624            vep->i_hash.pprev, vep->i_hash.next, vep->i_list.prev,
2625            vep->i_list.next, vep->i_dentry.prev, vep->i_dentry.next);
2626 #else /* AFS_LINUX26_ENV */
2627     printf("\ti_hash=0x%x:0x%x, i_list=0x%x:0x%x, i_dentry=0x%x:0x%x\n",
2628            vep->i_hash.prev, vep->i_hash.next, vep->i_list.prev,
2629            vep->i_list.next, vep->i_dentry.prev, vep->i_dentry.next);
2630 #endif /* AFS_LINUX26_ENV */
2631 #endif /* AFS_LINUX22_ENV */
2632 }
2633
2634 void
2635 print_vcache(int kmem, struct vcache *vep, struct vcache *ptr, int pnt)
2636 {
2637     long *loc, j = 0;
2638     char *cloc;
2639     struct VenusFid vid;
2640     struct axscache acc, *accp = &acc, *acp;
2641     struct SimpleLocks sl, *slcp = &sl, *slp;
2642     char linkchar;
2643
2644     if (vep->mvid) {
2645         kread(kmem, (off_t) vep->mvid, (char *)&vid, sizeof(struct VenusFid));
2646         Sum_vcachemvids++;
2647     }
2648     if (vep->linkData)
2649         Sum_vcachelinkData++;
2650     loc = (long *)&vep->lock;
2651
2652     if (pnt) {
2653         if (!Dvnodes)
2654             printf("\n");
2655 #ifdef  AFS33
2656         printf("%lx: refC=%d, pv=%d, pu=%d, flushDv=%d.%d, mapDV=%d.%d, ",
2657                ptr, VREFCOUNT(vep), vep->parentVnode, vep->parentUnique,
2658                vep->flushDV.high, vep->flushDV.low, vep->mapDV.high,
2659                vep->mapDV.low);
2660 #ifdef AFS_64BIT_CLIENT
2661         printf
2662             ("truncPos=(0x%x, 0x%x),\n\tcallb=x%lx, cbE=%d, opens=%d, XoW=%d, ",
2663              (int)(vep->truncPos >> 32), (int)(vep->truncPos & 0xffffffff),
2664              vep->callback, vep->cbExpires, vep->opens, vep->execsOrWriters);
2665 #else /* AFS_64BIT_CLIENT */
2666         printf("truncPos=%d,\n\tcallb=x%lx, cbE=%d, opens=%d, XoW=%d, ",
2667                vep->truncPos, vep->callback, vep->cbExpires, vep->opens,
2668                vep->execsOrWriters);
2669 #endif /* AFS_64BIT_CLIENT */
2670         printf("flcnt=%d, mvstat=%d\n", vep->flockCount, vep->mvstat);
2671         printf("\tstates=x%x, ", vep->states);
2672 #ifdef  AFS_SUN5_ENV
2673         printf("vstates=x%x, ", vep->vstates);
2674 #endif /* AFS_SUN5_ENV */
2675         printf("dchint=%x, anyA=0x%x\n", vep->dchint, vep->anyAccess);
2676 #ifdef AFS_64BIT_CLIENT
2677         printf
2678             ("\tmstat[len=(0x%x, 0x%x), DV=%d.%d, Date=%d, Owner=%d, Group=%d, Mode=0%o, linkc=%d]\n",
2679              (int)(vep->m.Length >> 32), (int)(vep->m.Length & 0xffffffff),
2680              vep->m.DataVersion.high, vep->m.DataVersion.low, vep->m.Date,
2681              vep->m.Owner, vep->m.Group, vep->m.Mode, vep->m.LinkCount);
2682 #else /* AFS_64BIT_CLIENT */
2683         printf("\tquick[dc=%x, stamp=%x, f=%x, min=%d, len=%d]\n",
2684                vep->quick.dc, vep->quick.stamp, vep->quick.f,
2685                vep->quick.minLoc, vep->quick.len);
2686         printf
2687             ("\tmstat[len=%d, DV=%d.%d, Date=%d, Owner=%d, Group=%d, Mode=0%o, linkc=%d]\n",
2688              vep->m.Length, vep->m.DataVersion.high, vep->m.DataVersion.low,
2689              vep->m.Date, vep->m.Owner, vep->m.Group, vep->m.Mode,
2690              vep->m.LinkCount);
2691 #endif /* AFS_64BIT_CLIENT */
2692 #else /* AFS33 */
2693         printf
2694             ("%x: refC=%d, pv=%d, pu=%d, flushDv=%d, mapDV=%d, truncPos=%d\n",
2695              ptr, vep->vrefCount, vep->parentVnode, vep->parentUnique,
2696              vep->flushDV, vep->mapDV, vep->truncPos);
2697         printf("\tcallb=x%x, cbE=%d, opens=%d, XoW=%d, flcnt=%d, mvstat=%d\n",
2698                vep->callback, vep->cbExpires, vep->opens, vep->execsOrWriters,
2699                vep->flockCount, vep->mvstat);
2700         printf("\tstates=x%x, dchint=%x, anyA=0x%x\n", vep->states,
2701                vep->h1.dchint, vep->anyAccess);
2702         printf
2703             ("\tmstat[len=%d, DV=%d, Date=%d, Owner=%d, Group=%d, Mode=%d, linkc=%d]\n",
2704              vep->m.Length, vep->m.DataVersion, vep->m.Date, vep->m.Owner,
2705              vep->m.Group, vep->m.Mode, vep->m.LinkCount);
2706 #endif /* AFS33 */
2707 #ifdef  AFS_AIX32_ENV
2708         loc = (afs_int32 *) & vep->pvmlock;
2709         printf("\tpvmlock=x%x, segid=%X, credp=%lx\n", *loc, vep->segid,
2710                vep->credp);
2711 #endif
2712         printf
2713             ("\tlock [wait=%x excl=%x readers=%x #waiting=%x last_reader=%d writer=%d src=%d]\n",
2714              vep->lock.wait_states, vep->lock.excl_locked,
2715              vep->lock.readers_reading, vep->lock.num_waiting,
2716              vep->lock.pid_last_reader, vep->lock.pid_writer,
2717              vep->lock.src_indicator);
2718         print_venusfid("\tfid", &vep->fid);
2719         if (vep->mvid) {
2720             printf(" ");
2721             print_venusfid("mvid", &vid);
2722         }
2723         printf("\n");
2724     }
2725     if (vep->Access) {
2726         if (pnt)
2727             printf("\tAccess Link list: %x\n", vep->Access);
2728         for (j = 0, acp = vep->Access; acp; acp = accp->next, j++) {
2729             kread(kmem, (off_t) acp, (char *)accp, sizeof(*accp));
2730             Sum_vcacheacc++;
2731             if (pnt)
2732                 printf("\t   %lx: %d) uid=0x%x, access=0x%x, next=%lx\n", acp,
2733                        j, accp->uid, accp->axess, accp->next);
2734         }
2735     }
2736     if (vep->slocks) {
2737         if (pnt)
2738             printf("\tLocking Link list: %lx\n", vep->slocks);
2739     }
2740 #ifdef  AFS33
2741     if (pnt)
2742         printf("\tCallbacks queue prev= %lx next= %lx\n", vep->callsort.prev,
2743                vep->callsort.next);
2744 #endif
2745     printf("\tvlruq.prev=%lx, vlruq.next=%lx\n", vep->vlruq.prev,
2746            vep->vlruq.next);
2747
2748     /* For defect 7733 - Print linkData field for symlinks */
2749     if (pnt) {
2750         if (vep->linkData) {
2751             cloc = (char *)vep->linkData;
2752             printf("\tSymlink information = '");
2753             while (1) {
2754                 kread(kmem, (off_t) cloc, &linkchar, (KDUMP_SIZE_T) 1);
2755                 cloc++;
2756                 if (linkchar == '\0') {
2757                     printf("'\n");
2758                     break;
2759                 } else {
2760                     printf("%c", linkchar);
2761                 }
2762             }
2763         }
2764     }
2765 #ifdef AFS_LINUX22_ENV
2766     printf("\tmapcnt=%d\n", vep->mapcnt);
2767 #endif
2768 }
2769
2770
2771 void
2772 print_dcache(int kmem, struct dcache *dcp, struct dcache *dp, int pnt)
2773 {
2774     if (!pnt)
2775         return;
2776     printf("%lx: ", dp);
2777     print_venusfid(" fid", &dcp->f.fid);
2778     printf("refcnt=%d, dflags=%x, mflags=%x, validPos=%d\n", dcp->refCount,
2779            dcp->dflags, dcp->mflags, dcp->validPos);
2780
2781 #ifdef  AFS33
2782     printf("\tf.modtime=%d, f.versNo=%d.%d\n", dcp->f.modTime,
2783            dcp->f.versionNo.high, dcp->f.versionNo.low);
2784 #else
2785     printf("\tf.hvn=%d, f.hcn=%d, f.modtime=%d, f.versNo=%d\n",
2786            dcp->f.hvNextp, dcp->f.hcNextp, dcp->f.modTime, dcp->f.versionNo);
2787 #endif
2788 #ifdef AFS_SGI62_ENV
2789     printf
2790         ("\tf.chunk=%d, f.inode=%" AFS_INT64_FMT ", f.chunkBytes=%d, f.states=%x",
2791          dcp->f.chunk, dcp->f.inode, dcp->f.chunkBytes, dcp->f.states);
2792 #else
2793     printf
2794         ("\tf.chunk=%d, f.inode=%d, f.chunkBytes=%d, f.states=%x\n",
2795          dcp->f.chunk, dcp->f.inode, dcp->f.chunkBytes, dcp->f.states);
2796 #endif
2797     printf("\tlruq.prev=%lx, lruq.next=%lx, index=%d\n",
2798            dcp->lruq.prev, dcp->lruq.next, dcp->index);
2799 }
2800
2801 void
2802 print_bkg(int kmem)
2803 {
2804     off_t symoff;
2805     struct brequest afs_brs[NBRS], ue, *uentry = &ue, *uep;
2806     afs_int32 count, i, j;
2807     short scount;
2808
2809     printf("\n\nPrinting some background daemon info...\n\n");
2810     findsym("afs_brsWaiters", &symoff);
2811     kread(kmem, symoff, (char *)&scount, sizeof scount);
2812     printf("Number of processes waiting for bkg daemon %d\n", scount);
2813     findsym("afs_brsDaemons", &symoff);
2814     kread(kmem, symoff, (char *)&scount, sizeof scount);
2815     printf("Number of free bkg daemons %d\n", scount);
2816     findsym("afs_brs", &symoff);
2817     kread(kmem, symoff, (char *)afs_brs, sizeof afs_brs);
2818     printf("Print the current bkg process table\n");
2819     for (i = 0, j = 0; i < NBRS; i++, j++) {
2820 /*      kread(kmem, (off_t) afs_brs[i], (char *)uentry, sizeof *uentry);*/
2821         uentry = &afs_brs[i];
2822         if (uentry->refCount == 0)
2823             break;
2824         printf
2825             ("[%d] vcache=0x%lx, cred=0x%lx, code=%d, refCount=%d, opcode=%d, flags=%x [%lx, %lx, %lx, %lx]\n",
2826              i, uentry->vc, uentry->cred, uentry->code, uentry->refCount,
2827              uentry->opcode, uentry->flags, uentry->size_parm[0],
2828              uentry->size_parm[1], uentry->ptr_parm[0], uentry->ptr_parm[1]);
2829
2830     }
2831     printf("... found %d active 'afs_brs' entries\n", j);
2832 }
2833
2834 void
2835 print_vlru(int kmem)
2836 {
2837     off_t symoff;
2838     struct vcache Ve, *Ventry = &Ve, *Vep, *tvc;
2839     struct afs_q VLRU, vlru, *vu = &vlru, *tq, *uq;
2840     u_long vlru_addr, l1, l2, l3;
2841     afs_int32 count, i, j = 0, maxvcount, vcount, nvnode;
2842     short scount;
2843
2844     printf("\n\nPrinting vcache VLRU info (oldest first)...\n\n");
2845     findsym("afs_cacheStats", &symoff);
2846     kread(kmem, symoff, (char *)&maxvcount, sizeof maxvcount);
2847     findsym("VLRU", &symoff);
2848     kread(kmem, symoff, (char *)&VLRU, sizeof VLRU);
2849     vlru_addr = (u_long) symoff;
2850     for (tq = VLRU.prev; (u_long) tq != vlru_addr; tq = uq) {
2851         tvc = QTOV(tq);
2852         kread(kmem, (off_t) tq, (char *)vu, sizeof VLRU);
2853         uq = vu->prev;
2854         kread(kmem, (off_t) tvc, (char *)Ventry, sizeof *Ventry);
2855         print_vcache(kmem, Ventry, tvc, 1);
2856         j++;
2857     }
2858     printf("... found %d active vcache entries in the VLRU\n", j);
2859 }
2860
2861 void
2862 print_dlru(int kmem)
2863 {
2864     off_t symoff;
2865     struct dcache Ve, *Ventry = &Ve, *Vep, *tdc;
2866     struct afs_q DLRU, dlru, *vu = &dlru, *tq, *uq;
2867     u_long dlru_addr, l1, l2, l3;
2868     afs_int32 count, i, j = 0, maxvcount, vcount, nvnode;
2869     short scount;
2870
2871     printf("\n\nPrinting vcache DLRU info...\n\n");
2872     findsym("afs_DLRU", &symoff);
2873     kread(kmem, symoff, (char *)&DLRU, sizeof DLRU);
2874     dlru_addr = (u_long) symoff;
2875     for (tq = DLRU.prev; (u_long) tq != dlru_addr; tq = uq) {
2876         tdc = (struct dcache *)tq;
2877         kread(kmem, (off_t) tq, (char *)vu, sizeof DLRU);
2878         uq = vu->prev;
2879         kread(kmem, (off_t) tdc, (char *)Ventry, sizeof *Ventry);
2880         print_dcache(kmem, Ventry, tdc, 1);
2881         j++;
2882     }
2883     printf("... found %d active dcache entries in the DLRU\n\n\n", j);
2884
2885     findsym("afs_freeDSList", &symoff);
2886     kread(kmem, symoff, (char *)&dlru_addr, sizeof dlru_addr);
2887     printf("\tfreeDSList link list starts at 0x%x\n", dlru_addr);
2888     j = 0;
2889     for (tdc = (struct dcache *)dlru_addr; tdc;
2890          tdc = (struct dcache *)Ventry->lruq.next) {
2891         kread(kmem, (off_t) tdc, (char *)Ventry, sizeof *Ventry);
2892         print_dcache(kmem, Ventry, tdc, 1);
2893         j++;
2894 /*      printf("%3d) %x\n", j, tdc);*/
2895     }
2896     printf("... found %d dcache entries in the freeDSList\n", j);
2897 }
2898
2899 int
2900 print_gcpags(int pnt)
2901 {
2902     off_t symoff;
2903     afs_int32 afs_gcpags;
2904     afs_int32 afs_gcpags_procsize;
2905
2906     if (pnt)
2907         printf("\n\nPrinting GCPAGS structures...\n");
2908
2909     findsym("afs_gcpags", &symoff);
2910     kread(kmem, symoff, (char *)&afs_gcpags, sizeof afs_gcpags);
2911
2912     findsym("afs_gcpags_procsize", &symoff);
2913     kread(kmem, symoff, (char *)&afs_gcpags_procsize,
2914           sizeof afs_gcpags_procsize);
2915
2916     printf("afs_gcpags=%d\n", afs_gcpags);
2917     printf("afs_gcpags_procsize=%d\n", afs_gcpags_procsize);
2918
2919     return 0;
2920 }
2921
2922
2923 #ifdef  AFS_AIX_ENV
2924 #include <sys/syspest.h>        /* to define the assert and ASSERT macros       */
2925 #include <sys/timer.h>          /* For the timer related defines                */
2926 #include <sys/intr.h>           /* for the serialization defines                */
2927 #include <sys/malloc.h>         /* for the parameters to xmalloc()              */
2928
2929 struct tos {
2930     struct tos *toprev;         /* previous tos in callout table */
2931     struct tos *tonext;         /* next tos in callout table    */
2932     struct trb *trb;            /* this timer request block     */
2933     afs_int32 type;
2934     long p1;
2935 };
2936
2937 struct callo {
2938     int ncallo;                 /* number of callout table elements     */
2939     struct tos *head;           /* callout table head element           */
2940 };
2941 #endif
2942
2943 void
2944 print_callout(int kmem)
2945 {
2946     off_t symoff;
2947 #ifndef AFS_AIX_ENV
2948     printf("\n\nCallout table doesn't exist for this system\n");
2949 #else
2950     struct callo Co, *Coe = &Co, *Cop;
2951     struct tos To, *Toe = &To, *tos;
2952     struct trb Trb, *Trbe = &Trb, *trb;
2953     int i = 0;
2954
2955
2956     printf("\n\nPrinting callout table info...\n\n");
2957     findsym("afs_callo", &symoff);
2958     kread(kmem, symoff, (char *)&Co, sizeof Co);
2959     printf("Number of callouts %d\n", Co.ncallo);
2960     if (Co.ncallo > 0) {
2961         printf("Count\tType\taddr\tfunc\tdata\n");
2962         for (tos = Co.head; tos != NULL; tos = Toe->tonext) {
2963             i++;
2964             kread(kmem, (off_t) tos, (char *)&To, sizeof To);
2965             kread(kmem, (off_t) Toe->trb, (char *)&Trb, sizeof Trb);
2966             printf("%d\t%d\t%x\t%x\t%x\n", i, Toe->type, Toe->p1, Trbe->tof,
2967                    Trbe->func_data);
2968         }
2969     }
2970 #endif
2971 }
2972
2973 void
2974 print_dnlc(int kmem)
2975 {
2976     struct nc *nameHash[256];
2977
2978 }
2979
2980
2981 void
2982 print_global_locks(int kmem)
2983 {
2984     off_t symoff;
2985     afs_int32 count;
2986     int i;
2987     static struct {
2988         char *name;
2989     } locks[] = { {
2990     "afs_xvcache"}, {
2991     "afs_xdcache"}, {
2992     "afs_xserver"}, {
2993     "afs_xvcb"}, {
2994     "afs_xbrs"}, {
2995     "afs_xcell"}, {
2996     "afs_xconn"}, {
2997     "afs_xuser"}, {
2998     "afs_xvolume"},
2999 #ifndef AFS_AIX_ENV
3000     {
3001     "osi_fsplock"},
3002 #endif
3003     {
3004     "osi_flplock"}, {
3005     "afs_xcbhash"}, {
3006     "afs_xinterface"}, {
3007     0},};
3008
3009
3010     printf("\n\nPrinting afs global locks...\n\n");
3011     for (i = 0; locks[i].name; i++) {
3012         findsym(locks[i].name, &symoff);
3013         kread(kmem, symoff, (char *)&count, sizeof count);
3014         printf("%s = 0x%x\n", locks[i].name, count);
3015     }
3016 }
3017
3018
3019 void
3020 print_global_afs_resource(int kmem)
3021 {
3022     off_t symoff;
3023     char sysname[100];
3024     afs_int32 count;
3025     long addr;
3026
3027     printf("\n\nPrinting some general resource related globals...\n\n");
3028     findsym("afs_setTimeHost", &symoff);
3029     kread(kmem, symoff, (char *)&count, sizeof count);
3030     printf("\tafs_setTimeHost = 0x%x\n", count);
3031     findsym("afs_volCounter", &symoff);
3032     kread(kmem, symoff, (char *)&count, sizeof count);
3033     printf("\tafs_volCounter = 0x%x\n", count);
3034     findsym("afs_cellindex", &symoff);
3035     kread(kmem, symoff, (char *)&count, sizeof count);
3036     printf("\tafs_cellIndex = 0x%x\n", count);
3037     findsym("afs_marinerHost", &symoff);
3038     kread(kmem, symoff, (char *)&count, sizeof count);
3039     printf("\tafs_marinerHost = 0x%x\n", count);
3040     findsym("afs_sysname", &symoff);
3041     kread(kmem, symoff, (char *)&addr, sizeof addr);
3042 #ifdef  AFS_HPUX_ENV
3043     printf("\tafs_sysname = %d\n", addr);
3044 #else
3045     kread(kmem, (off_t) addr, sysname, (KDUMP_SIZE_T) 30);
3046     printf("\tafs_sysname = %s\n", sysname);
3047 #endif
3048 #ifdef AFS_SGI65_ENV
3049     findsym("afs_ipno", &symoff);
3050     kread(kmem, symoff, (char *)&count, sizeof count);
3051     printf("\tCPU BOARD = IP%d\n", count);
3052 #endif
3053 }
3054
3055
3056 void
3057 print_global_afs_cache(int kmem)
3058 {
3059     off_t symoff;
3060     char sysname[100];
3061     afs_int32 count;
3062 #ifdef AFS_SGI62_ENV
3063     ino64_t inode;
3064 #endif
3065 #ifndef AFS32
3066     afs_hyper_t h;
3067 #endif
3068
3069     printf("\n\nPrinting some general cache related globals...\n\n");
3070     findsym("afs_mariner", &symoff);
3071     kread(kmem, symoff, (char *)&count, sizeof count);
3072     printf("\tafs_mariner = 0x%x\n", count);
3073     findsym("freeVCList", &symoff);
3074     kread(kmem, symoff, (char *)&count, sizeof count);
3075     printf("\tafs_freeVCList = 0x%x XXX\n", count);
3076     findsym("afs_freeDCList", &symoff);
3077     kread(kmem, symoff, (char *)&count, sizeof count);
3078     printf("\tfreeDCList = 0x%x\n", count);
3079     findsym("afs_freeDCCount", &symoff);
3080     kread(kmem, symoff, (char *)&count, sizeof count);
3081     printf("\tfreeDCCount = 0x%x (%d)\n", count, count);
3082     findsym("afs_discardDCList", &symoff);
3083     kread(kmem, symoff, (char *)&count, sizeof count);
3084     printf("\tdiscardDCList = 0x%x\n", count);
3085     findsym("afs_discardDCCount", &symoff);
3086     kread(kmem, symoff, (char *)&count, sizeof count);
3087     printf("\tdiscardDCCount = 0x%x (%d)\n", count, count);
3088     findsym("afs_freeDSList", &symoff);
3089     kread(kmem, symoff, (char *)&count, sizeof count);
3090     printf("\tfreeDSList= 0x%x XXXX\n", count);
3091 #ifdef AFS_SGI62_ENV
3092     findsym("cacheInode", &symoff);
3093     kread(kmem, symoff, (char *)&inode, sizeof inode);
3094     printf("\tcacheInode = 0x%llx (%" AFS_INT64_FMT ")\n", inode, inode);
3095     findsym("volumeInode", &symoff);
3096     kread(kmem, symoff, (char *)&inode, sizeof inode);
3097     printf("\tvolumeInode = 0x%llx (%" AFS_INT64_FMT ")\n", inode, inode);
3098 #else
3099     findsym("cacheInode", &symoff);
3100     kread(kmem, symoff, (char *)&count, sizeof count);
3101     printf("\tcacheInode = 0x%x (%d)\n", count, count);
3102     findsym("volumeInode", &symoff);
3103     kread(kmem, symoff, (char *)&count, sizeof count);
3104     printf("\tvolumeInode = 0x%x (%d)\n", count, count);
3105 #endif
3106     findsym("cacheDiskType", &symoff);
3107     kread(kmem, symoff, (char *)&count, sizeof count);
3108     printf("\tcacheDiskType = 0x%x (%d)\n", count, count);
3109 #ifndef AFS32
3110     findsym("afs_indexCounter", &symoff);
3111     kread(kmem, symoff, (char *)&h, sizeof(struct afs_hyper_t));
3112     printf("\tafs_indexCounter = 0x%X.%X (%d.%d)\n", h.high, h.low, h.high,
3113            h.low);
3114 #endif
3115     findsym("afs_cacheFiles", &symoff);
3116     kread(kmem, symoff, (char *)&count, sizeof count);
3117     printf("\tafs_cacheFiles = 0x%x (%d)\n", count, count);
3118     findsym("afs_cacheBlocks", &symoff);
3119     kread(kmem, symoff, (char *)&count, sizeof count);
3120     printf("\tafs_cacheBlocks = 0x%x (%d)\n", count, count);
3121     findsym("afs_cacheStats", &symoff);
3122     kread(kmem, symoff, (char *)&count, sizeof count);
3123     printf("\tafs_cacheStats = 0x%x (%d)\n", count, count);
3124     findsym("afs_blocksUsed", &symoff);
3125     kread(kmem, symoff, (char *)&count, sizeof count);
3126     printf("\tafs_blocksUsed = 0x%x (%d)\n", count, count);
3127     findsym("afs_blocksDiscarded", &symoff);
3128     kread(kmem, symoff, (char *)&count, sizeof count);
3129     printf("\tafs_blocksDiscarded = 0x%x (%d)\n", count, count);
3130     findsym("afs_fsfragsize", &symoff);
3131     kread(kmem, symoff, (char *)&count, sizeof count);
3132     printf("\tafs_fsfragsize = 0x%x\n", count);
3133     findsym("afs_WaitForCacheDrain", &symoff);
3134     kread(kmem, symoff, (char *)&count, sizeof count);
3135     printf("\tafs_WaitForCacheDrain = 0x%x (%d)\n", count, count);
3136     findsym("afs_CacheTooFull", &symoff);
3137     kread(kmem, symoff, (char *)&count, sizeof count);
3138     printf("\tafs_CacheTooFull = 0x%x (%d)\n", count, count);
3139
3140
3141     if (findsym("pagCounter", &symoff)) {
3142         kread(kmem, symoff, (char *)&count, sizeof count);
3143         printf("\tpagCounter = 0x%x (%d)\n", count, count);
3144     } else {
3145         printf("Ignoring pagCounter\n");
3146     }
3147 }
3148
3149
3150 void
3151 print_rxstats(int kmem)
3152 {
3153     off_t symoff;
3154     char sysname[100];
3155     afs_int32 count, i;
3156     struct rx_statistics rx_stats;
3157
3158     printf("\n\nPrinting some general RX stats...\n\n");
3159     findsym("rx_stats", &symoff);
3160     kread(kmem, symoff, (char *)&rx_stats, sizeof rx_stats);
3161     printf("\t\tpacketRequests = %d\n", rx_stats.packetRequests);
3162     printf("\t\tnoPackets[%d] = %d\n", RX_PACKET_CLASS_RECEIVE,
3163            rx_stats.receivePktAllocFailures);
3164     printf("\t\tnoPackets[%d] = %d\n", RX_PACKET_CLASS_SEND,
3165            rx_stats.sendPktAllocFailures);
3166     printf("\t\tnoPackets[%d] = %d\n", RX_PACKET_CLASS_SPECIAL,
3167            rx_stats.specialPktAllocFailures);
3168     printf("\t\tnoPackets[%d] = %d\n", RX_PACKET_CLASS_RECV_CBUF,
3169            rx_stats.receiveCbufPktAllocFailures);
3170     printf("\t\tnoPackets[%d] = %d\n", RX_PACKET_CLASS_SEND_CBUF,
3171            rx_stats.sendCbufPktAllocFailures);
3172     printf("\t\tsocketGreedy = %d\n", rx_stats.socketGreedy);
3173     printf("\t\tbogusPacketOnRead = %d\n", rx_stats.bogusPacketOnRead);
3174     printf("\t\tbogusHost = %d\n", rx_stats.bogusHost);
3175     printf("\t\tnoPacketOnRead = %d\n", rx_stats.noPacketOnRead);
3176     printf("\t\tnoPacketBuffersOnRead = %d\n",
3177            rx_stats.noPacketBuffersOnRead);
3178     printf("\t\tselects = %d\n", rx_stats.selects);
3179     printf("\t\tsendSelects = %d\n", rx_stats.sendSelects);
3180     for (i = 0; i < RX_N_PACKET_TYPES; i++)
3181         printf("\t\tpacketsRead[%d] = %d\n", i, rx_stats.packetsRead[i]);
3182     printf("\t\tdataPacketsRead = %d\n", rx_stats.dataPacketsRead);
3183     printf("\t\tackPacketsRead = %d\n", rx_stats.ackPacketsRead);
3184     printf("\t\tdupPacketsRead = %d\n", rx_stats.dupPacketsRead);
3185     printf("\t\tspuriousPacketsRead = %d\n", rx_stats.spuriousPacketsRead);
3186     for (i = 0; i < RX_N_PACKET_TYPES; i++)
3187         printf("\t\tpacketsSent[%d] = %d\n", i, rx_stats.packetsSent[i]);
3188     printf("\t\tackPacketsSent = %d\n", rx_stats.ackPacketsSent);
3189     printf("\t\tpingPacketsSent = %d\n", rx_stats.pingPacketsSent);
3190     printf("\t\tabortPacketsSent = %d\n", rx_stats.abortPacketsSent);
3191     printf("\t\tbusyPacketsSent = %d\n", rx_stats.busyPacketsSent);
3192     printf("\t\tdataPacketsSent = %d\n", rx_stats.dataPacketsSent);
3193     printf("\t\tdataPacketsReSent = %d\n", rx_stats.dataPacketsReSent);
3194     printf("\t\tdataPacketsPushed = %d\n", rx_stats.dataPacketsPushed);
3195     printf("\t\tignoreAckedPacket = %d\n", rx_stats.ignoreAckedPacket);
3196     printf("\t\ttotalRtt = %d sec, %d usec\n", rx_stats.totalRtt.sec,
3197            rx_stats.totalRtt.usec);
3198     printf("\t\tminRtt = %d sec, %d usec\n", rx_stats.minRtt.sec,
3199            rx_stats.minRtt.usec);
3200     printf("\t\tmaxRtt = %d sec, %d usec\n", rx_stats.maxRtt.sec,
3201            rx_stats.maxRtt.usec);
3202     printf("\t\tnRttSamples = %d\n", rx_stats.nRttSamples);
3203     printf("\t\tnServerConns = %d\n", rx_stats.nServerConns);
3204     printf("\t\tnClientConns = %d\n", rx_stats.nClientConns);
3205     printf("\t\tnPeerStructs = %d\n", rx_stats.nPeerStructs);
3206     printf("\t\tnCallStructs = %d\n", rx_stats.nCallStructs);
3207     printf("\t\tnFreeCallStructs = %d\n", rx_stats.nFreeCallStructs);
3208     printf("\t\tnetSendFailures  = %d\n", rx_stats.netSendFailures);
3209     printf("\t\tfatalErrors      = %d\n", rx_stats.fatalErrors);
3210 }
3211
3212
3213 void
3214 print_rx(int kmem)
3215 {
3216     off_t symoff;
3217     char sysname[100], c;
3218     afs_int32 count, i, ar[100];
3219     short sm;
3220     struct rx_statistics rx_stats;
3221
3222     printf("\n\nPrinting some RX globals...\n\n");
3223     findsym("rx_extraQuota", &symoff);
3224     kread(kmem, symoff, (char *)&count, sizeof count);
3225     printf("\trx_extraQuota = %d\n", count);
3226     findsym("rx_extraPackets", &symoff);
3227     kread(kmem, symoff, (char *)&count, sizeof count);
3228     printf("\trx_extraPackets = %d\n", count);
3229     findsym("rx_stackSize", &symoff);
3230     kread(kmem, symoff, (char *)&count, sizeof count);
3231     printf("\trx_stackSize = %d\n", count);
3232     findsym("rx_connDeadTime", &symoff);
3233     kread(kmem, symoff, (char *)&count, sizeof count);
3234
3235     printf("\trx_connDeadTime = %d\n", count);
3236     findsym("rx_idleConnectionTime", &symoff);
3237     kread(kmem, symoff, (char *)&count, sizeof count);
3238
3239     printf("\trx_idleConnectionTime = %d\n", count);
3240
3241     findsym("rx_idlePeerTime", &symoff);
3242     kread(kmem, symoff, (char *)&count, sizeof count);
3243     printf("\trx_idlePeerTime = %d\n", count);
3244
3245     findsym("rx_initSendWindow", &symoff);
3246     kread(kmem, symoff, (char *)&count, sizeof count);
3247     printf("\trx_initSendWindow = %d\n", count);
3248
3249     findsym("rxi_nSendFrags", &symoff);
3250     kread(kmem, symoff, (char *)&count, sizeof count);
3251     printf("\trxi_nSendFrags = %d\n", count);
3252
3253     findsym("rx_nPackets", &symoff);
3254     kread(kmem, symoff, (char *)&count, sizeof count);
3255
3256     printf("\trx_nPackets = %d\n", count);
3257     findsym("rx_nFreePackets", &symoff);
3258     kread(kmem, symoff, (char *)&count, sizeof count);
3259
3260     printf("\trx_nFreePackets = %d\n", count);
3261     findsym("rx_socket", &symoff);
3262     kread(kmem, symoff, (char *)&count, sizeof count);
3263
3264     printf("\trx_socket = 0x%x\n", count);
3265     findsym("rx_port", &symoff);
3266     kread(kmem, symoff, (char *)&sm, sizeof sm);
3267
3268     printf("\trx_Port = %d\n", sm);
3269     findsym("rx_packetQuota", &symoff);
3270     kread(kmem, symoff, (char *)ar, sizeof ar);
3271
3272     for (i = 0; i < RX_N_PACKET_CLASSES; i++)
3273         printf("\trx_packetQuota[%d] = %d\n", i, ar[i]);
3274     findsym("rx_nextCid", &symoff);
3275     kread(kmem, symoff, (char *)&count, sizeof count);
3276
3277     printf("\trx_nextCid = 0x%x\n", count);
3278     findsym("rx_epoch", &symoff);
3279     kread(kmem, symoff, (char *)&count, sizeof count);
3280
3281     printf("\trx_epoch = 0u%u\n", count);
3282     findsym("rx_waitingForPackets", &symoff);
3283     kread(kmem, symoff, (char *)&c, sizeof(c));
3284
3285     printf("\trx_waitingForPackets = %x\n", (int)c);
3286     findsym("rxi_nCalls", &symoff);
3287     kread(kmem, symoff, (char *)&count, sizeof count);
3288
3289     printf("\trxi_nCalls = %d\n", count);
3290     findsym("rxi_dataQuota", &symoff);
3291     kread(kmem, symoff, (char *)&count, sizeof count);
3292
3293     printf("\trxi_dataQuota = %d\n", count);
3294 #ifdef  AFS_AIX_ENV
3295     if (findsym("rxi_Alloccnt", &symoff)) {
3296         kread(kmem, symoff, (char *)&count, sizeof count);
3297         printf("\trxi_Alloccnt = %d\n", count);
3298     }
3299
3300     if (findsym("rxi_Allocsize", &symoff)) {
3301         kread(kmem, symoff, (char *)&count, sizeof count);
3302         printf("\trxi_Allocsize = %d\n", count);
3303     }
3304 #endif
3305     findsym("rxi_availProcs", &symoff);
3306     kread(kmem, symoff, (char *)&count, sizeof count);
3307
3308     printf("\trxi_availProcs = %d\n", count);
3309     findsym("rxi_totalMin", &symoff);
3310     kread(kmem, symoff, (char *)&count, sizeof count);
3311
3312     printf("\trxi_totalMin = %d\n", count);
3313     findsym("rxi_minDeficit", &symoff);
3314     kread(kmem, symoff, (char *)&count, sizeof count);
3315
3316     printf("\trxi_minDeficit = %d\n", count);
3317     print_services(kmem);
3318 #ifdef KDUMP_RX_LOCK
3319     if (use_rx_lock) {
3320         print_peertable_lock(kmem);
3321         print_conntable_lock(kmem);
3322         print_calltable_lock(kmem);
3323     } else {
3324         print_peertable(kmem);
3325         print_conntable(kmem);
3326         print_calltable(kmem);
3327     }
3328 #else
3329     print_peertable(kmem);
3330     print_conntable(kmem);
3331     print_calltable(kmem);
3332 #endif
3333     print_eventtable(kmem);
3334     print_rxstats(kmem);
3335 }
3336
3337
3338 void
3339 print_services(afs_int32 kmem)
3340 {
3341     off_t symoff;
3342     struct rx_service *rx_services[RX_MAX_SERVICES], se, *sentry = &se, *sep;
3343     char sysname[100];
3344     afs_int32 count, i, j;
3345
3346     findsym("rx_services", &symoff);
3347     kread(kmem, symoff, (char *)rx_services, RX_MAX_SERVICES * sizeof(long));
3348
3349     printf("\n\nPrinting all 'rx_services' structures...\n");
3350     for (i = 0, j = 0; i < RX_MAX_SERVICES; i++) {
3351         if (rx_services[i]) {
3352             j++;
3353             kread(kmem, (off_t) rx_services[i], (char *)sentry,
3354                   sizeof *sentry);
3355             kread(kmem, (off_t) sentry->serviceName, sysname,
3356                   (KDUMP_SIZE_T) 40);
3357             printf
3358                 ("\t%lx: serviceId=%d, port=%d, serviceName=%s, socket=0x%x\n",
3359                  rx_services[i], sentry->serviceId, sentry->servicePort,
3360                  sysname, sentry->socket);
3361             printf
3362                 ("\t\tnSecObj=%d, nReqRunning=%d, maxProcs=%d, minProcs=%d, connDeadTime=%d, idleDeadTime=%d\n",
3363                  sentry->nSecurityObjects, sentry->nRequestsRunning,
3364                  sentry->maxProcs, sentry->minProcs, sentry->connDeadTime,
3365                  sentry->idleDeadTime);
3366         }
3367     }
3368     printf("... found %d 'rx_services' entries in the table\n", j);
3369 }
3370
3371
3372 #ifdef KDUMP_RX_LOCK
3373 void
3374 print_peertable_lock(afs_int32 kmem)
3375 {
3376     off_t symoff;
3377     struct rx_peer_rx_lock *rx_peerTable[256], se, *sentry = &se, *sep;
3378     long count, i, j;
3379
3380     findsym("rx_peerHashTable", &symoff);
3381     kread(kmem, symoff, (char *)&count, sizeof(long));
3382     if (!count) {
3383         printf("No 'rx_peer' structures found.\n");
3384         return;
3385     }
3386
3387     kread(kmem, count, (char *)rx_peerTable, 256 * sizeof(long));
3388     printf("\n\nPrinting all 'rx_peer' structures...\n");
3389     for (i = 0, j = 0; i < 256; i++) {
3390         for (sep = rx_peerTable[i]; sep; sep = sentry->next, j++) {
3391             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
3392             printf("\t%lx: next=0x%lx, host=0x%x, ", sep, sentry->next,
3393                    sentry->host);
3394             printf("ifMTU=%d, natMTU=%d, maxMTU=%d\n", sentry->ifMTU,
3395                    sentry->natMTU, sentry->maxMTU);
3396             printf("\t\trtt=%d:%d, timeout(%d:%d), nSent=%d, reSends=%d\n",
3397                    sentry->rtt, sentry->rtt_dev, sentry->timeout.sec,
3398                    sentry->timeout.usec, sentry->nSent, sentry->reSends);
3399             printf("\t\trefCount=%d, port=%d, idleWhen=0x%x\n",
3400                    sentry->refCount, sentry->port, sentry->idleWhen);
3401             printf
3402                 ("\t\tCongestionQueue (0x%x:0x%x), inPacketSkew=0x%x, outPacketSkew=0x%x\n",
3403                  sentry->congestionQueue.prev, sentry->congestionQueue.next,
3404                  sentry->inPacketSkew, sentry->outPacketSkew);
3405             printf("\t\tpeer_lock=%d\n", sentry->peer_lock);
3406         }
3407     }
3408     printf("... found %d 'rx_peer' entries in the table\n", j);
3409 }
3410
3411 #endif /* KDUMP_RX_LOCK */
3412 void
3413 print_peertable(afs_int32 kmem)
3414 {
3415     off_t symoff;
3416     struct rx_peer *rx_peerTable[256], se, *sentry = &se, *sep;
3417     long count, i, j;
3418
3419     findsym("rx_peerHashTable", &symoff);
3420     kread(kmem, symoff, (char *)&count, sizeof(long));
3421
3422     kread(kmem, count, (char *)rx_peerTable, 256 * sizeof(long));
3423     printf("\n\nPrinting all 'rx_peer' structures...\n");
3424     for (i = 0, j = 0; i < 256; i++) {
3425         for (sep = rx_peerTable[i]; sep; sep = sentry->next, j++) {
3426             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
3427             printf("\t%lx: next=0x%lx, host=0x%x, ", sep, sentry->next,
3428                    sentry->host);
3429             printf("ifMTU=%d, natMTU=%d, maxMTU=%d\n", sentry->ifMTU,
3430                    sentry->natMTU, sentry->maxMTU);
3431             printf("\t\trtt=%d:%d, timeout(%d:%d), nSent=%d, reSends=%d\n",
3432                    sentry->rtt, sentry->rtt_dev, sentry->timeout.sec,
3433                    sentry->timeout.usec, sentry->nSent, sentry->reSends);
3434             printf("\t\trefCount=%d, port=%d, idleWhen=0x%x\n",
3435                    sentry->refCount, sentry->port, sentry->idleWhen);
3436             printf
3437                 ("\t\tCongestionQueue (0x%x:0x%x), inPacketSkew=0x%x, outPacketSkew=0x%x\n",
3438                  sentry->congestionQueue.prev, sentry->congestionQueue.next,
3439                  sentry->inPacketSkew, sentry->outPacketSkew);
3440 #ifdef RX_ENABLE_LOCKS
3441             printf("\t\tpeer_lock=%d\n", sentry->peer_lock);
3442 #endif /* RX_ENABLE_LOCKS */
3443         }
3444     }
3445     printf("... found %d 'rx_peer' entries in the table\n", j);
3446 }
3447
3448
3449 #ifdef KDUMP_RX_LOCK
3450 void
3451 print_conntable_lock(afs_int32 kmem)
3452 {
3453     off_t symoff;
3454     struct rx_connection_rx_lock *rx_connTable[256], se, *sentry = &se;
3455     struct rx_connection_rx_lock *sep;
3456     long count, i, j;
3457
3458     findsym("rx_connHashTable", &symoff);
3459     kread(kmem, symoff, (char *)&count, sizeof(long));
3460     if (!count) {
3461         printf("No 'rx_connection' structures found.\n");
3462         return;
3463     }
3464
3465     kread(kmem, count, (char *)rx_connTable, 256 * sizeof(long));
3466     printf("\n\nPrinting all 'rx_connection' structures...\n");
3467     for (i = 0, j = 0; i < 256; i++) {
3468         for (sep = rx_connTable[i]; sep; sep = sentry->next, j++) {
3469             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
3470             printf
3471                 ("\t%lx: next=0x%lx, peer=0x%lx, epoch=0x%x, cid=0x%x, ackRate=%d\n",
3472                  sep, se.next, se.peer, se.epoch, se.cid, se.ackRate);
3473             printf("\t\tcall[%lx=%d, %lx=%d, %lx=%d, %lx=%d]\n", se.call[0],
3474                    se.callNumber[0], se.call[1], se.callNumber[1], se.call[2],
3475                    se.callNumber[2], se.call[3], se.callNumber[3]);
3476             printf
3477                 ("\t\ttimeout=%d, flags=0x%x, type=0x%x, serviceId=%d, service=0x%lx, refCount=%d\n",
3478                  se.timeout, se.flags, se.type, se.serviceId, se.service,
3479                  se.refCount);
3480             printf
3481                 ("\t\tserial=%d, lastSerial=%d, secsUntilDead=%d, secsUntilPing=%d, secIndex=%d\n",
3482                  se.serial, se.lastSerial, se.secondsUntilDead,
3483                  se.secondsUntilPing, se.securityIndex);
3484             printf
3485                 ("\t\terror=%d, secObject=0x%lx, secData=0x%lx, secHeaderSize=%d, secmaxTrailerSize=%d\n",
3486                  se.error, se.securityObject, se.securityData,
3487                  se.securityHeaderSize, se.securityMaxTrailerSize);
3488             printf
3489                 ("\t\tchallEvent=0x%lx, lastSendTime=0x%x, maxSerial=%d, hardDeadTime=%d\n",
3490                  se.challengeEvent, se.lastSendTime, se.maxSerial,
3491                  se.hardDeadTime);
3492             if (se.flags & RX_CONN_MAKECALL_WAITING)
3493                 printf
3494                     ("\t\t***** Conn in RX_CONN_MAKECALL_WAITING state *****\n");
3495             printf
3496                 ("\t\tcall_lock=%d, call_cv=%d, data_lock=%d, refCount=%d\n",
3497                  se.conn_call_lock, se.conn_call_cv, se.conn_data_lock,
3498                  se.refCount);
3499         }
3500     }
3501     printf("... found %d 'rx_connection' entries in the table\n", j);
3502 }
3503 #endif /* KDUMP_RX_LOCK */
3504
3505 void
3506 print_conntable(afs_int32 kmem)
3507 {
3508     off_t symoff;
3509     struct rx_connection *rx_connTable[256], se, *sentry = &se, *sep;
3510     long count, i, j;
3511
3512     findsym("rx_connHashTable", &symoff);
3513     kread(kmem, symoff, (char *)&count, sizeof(long));
3514
3515     kread(kmem, count, (char *)rx_connTable, 256 * sizeof(long));
3516     printf("\n\nPrinting all 'rx_connection' structures...\n");
3517     for (i = 0, j = 0; i < 256; i++) {
3518         for (sep = rx_connTable[i]; sep; sep = sentry->next, j++) {
3519             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
3520             printf
3521                 ("\t%lx: next=0x%lx, peer=0x%lx, epoch=0x%x, cid=0x%x, ackRate=%d\n",
3522                  sep, se.next, se.peer, se.epoch, se.cid, se.ackRate);
3523             printf("\t\tcall[%x=%d, %x=%d, %x=%d, %x=%d]\n", se.call[0],
3524                    se.callNumber[0], se.call[1], se.callNumber[1], se.call[2],
3525                    se.callNumber[2], se.call[3], se.callNumber[3]);
3526             printf
3527                 ("\t\ttimeout=%d, flags=0x%x, type=0x%x, serviceId=%d, service=0x%lx, refCount=%d\n",
3528                  se.timeout, se.flags, se.type, se.serviceId, se.service,
3529                  se.refCount);
3530             printf
3531                 ("\t\tserial=%d, lastSerial=%d, secsUntilDead=%d, secsUntilPing=%d, secIndex=%d\n",
3532                  se.serial, se.lastSerial, se.secondsUntilDead,
3533                  se.secondsUntilPing, se.securityIndex);
3534             printf
3535                 ("\t\terror=%d, secObject=0x%lx, secData=0x%lx, secHeaderSize=%d, secmaxTrailerSize=%d\n",
3536                  se.error, se.securityObject, se.securityData,
3537                  se.securityHeaderSize, se.securityMaxTrailerSize);
3538             printf
3539                 ("\t\tchallEvent=0x%lx, lastSendTime=0x%x, maxSerial=%d, hardDeadTime=%d\n",
3540                  se.challengeEvent, se.lastSendTime, se.maxSerial,
3541                  se.hardDeadTime);
3542             if (se.flags & RX_CONN_MAKECALL_WAITING)
3543                 printf
3544                     ("\t\t***** Conn in RX_CONN_MAKECALL_WAITING state *****\n");
3545 #ifdef RX_ENABLE_LOCKS
3546             printf
3547                 ("\t\tcall_lock=%d, call_cv=%d, data_lock=%d, refCount=%d\n",
3548                  se.conn_call_lock, se.conn_call_cv, se.conn_data_lock,
3549                  se.refCount);
3550 #endif /* RX_ENABLE_LOCKS */
3551         }
3552     }
3553     printf("... found %d 'rx_connection' entries in the table\n", j);
3554 }
3555
3556
3557 #ifdef KDUMP_RX_LOCK
3558 void
3559 print_calltable_lock(afs_int32 kmem)
3560 {
3561     off_t symoff;
3562     struct rx_connection_rx_lock *rx_connTable[256], se;
3563     struct rx_connection_rx_lock *sentry = &se;
3564     struct rx_connection_rx_lock *sep;
3565     long count, i, j, k;
3566
3567     findsym("rx_connHashTable", &symoff);
3568     kread(kmem, symoff, (char *)&count, sizeof(long));
3569     if (!count) {
3570         printf("No 'rx_call' structures found.\n");
3571         return;
3572     }
3573
3574     kread(kmem, count, (char *)rx_connTable, 256 * sizeof(long));
3575     printf("\n\nPrinting all active 'rx_call' structures...\n");
3576     for (i = 0, j = 0; i < 256; i++) {
3577         for (sep = rx_connTable[i]; sep; sep = se.next) {
3578             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
3579             for (k = 0; k < RX_MAXCALLS; k++) {
3580                 struct rx_call_rx_lock ce, *centry = &ce;
3581                 struct rx_call_rx_lock *call = se.call[k];
3582                 if (call) {
3583                     j++;
3584                     kread(kmem, (off_t) call, (char *)centry, sizeof *centry);
3585                     printf
3586                         ("\t%lx: conn=0x%lx, qiheader(0x%lx:0x%lx), tq(0x%lx:0x%lx), rq(0x%lx:0x%lx)\n",
3587                          call, centry->conn, centry->queue_item_header.prev,
3588                          centry->queue_item_header.next, centry->tq.prev,
3589                          centry->tq.next, centry->rq.prev, centry->rq.next);
3590                     printf
3591                         ("\t\t: curvec=%d, curpos=%d, nLeft=%d, nFree=%d, currPacket=0x%lx, callNumber=0x%x\n",
3592                          centry->curvec, centry->curpos, centry->nLeft,
3593                          centry->nFree, centry->currentPacket,
3594                          centry->callNumber);
3595                     printf
3596                         ("\t\t: channel=%d, state=0x%x, mode=0x%x, flags=0x%x, localStatus=0x%x, remStatus=0x%x\n",
3597                          centry->channel, centry->state, centry->mode,
3598                          centry->flags, centry->localStatus,
3599                          centry->remoteStatus);
3600                     printf
3601                         ("\t\t: error=%d, timeout=0x%x, rnext=0x%x, rprev=0x%x, rwind=0x%x, tfirst=0x%x, tnext=0x%x\n",
3602                          centry->error, centry->timeout, centry->rnext,
3603                          centry->rprev, centry->rwind, centry->tfirst,
3604                          centry->tnext);
3605                     printf
3606                         ("\t\t: twind=%d, resendEvent=0x%lx, timeoutEvent=0x%lx, keepAliveEvent=0x%lx, delayedAckEvent=0x%lx\n",
3607                          centry->twind, centry->resendEvent,
3608                          centry->timeoutEvent, centry->keepAliveEvent,
3609                          centry->delayedAckEvent);
3610                     printf
3611                         ("\t\t: lastSendTime=0x%x, lastReceiveTime=0x%x, lastAcked=0x%x, startTime=0x%x, startWait=0x%x\n",
3612                          centry->lastSendTime, centry->lastReceiveTime,
3613                          centry->lastAcked, centry->startTime,
3614                          centry->startWait);
3615                     if (centry->flags & RX_CALL_WAIT_PROC)
3616                         printf
3617                             ("\t\t******** Call in RX_CALL_WAIT_PROC state **********\n");
3618                     if (centry->flags & RX_CALL_WAIT_WINDOW_ALLOC)
3619                         printf
3620                             ("\t\t******** Call in RX_CALL_WAIT_WINDOW_ALLOC state **********\n");
3621                     if (centry->flags & RX_CALL_READER_WAIT)
3622                         printf
3623                             ("\t\t******** Conn in RX_CALL_READER_WAIT state **********\n");
3624                     if (centry->flags & RX_CALL_WAIT_PACKETS)
3625                         printf
3626                             ("\t\t******** Conn in RX_CALL_WAIT_PACKETS state **********\n");
3627                     printf
3628                         ("\t\t: lock=0x%x, cv_twind=0x%x, cv_rq=0x%x, refCount=%d\n",
3629                          centry->lock, centry->cv_twind, centry->cv_rq,
3630                          centry->refCount);
3631                     printf("\t\t: MTU=%d\n", centry->MTU);
3632                 }
3633             }
3634         }
3635     }
3636     printf("... found %d 'rx_call' entries in the table\n", j);
3637 }
3638 #endif /* KDUMP_RX_LOCK */
3639
3640 void
3641 print_calltable(afs_int32 kmem)
3642 {
3643     off_t symoff;
3644     struct rx_connection *rx_connTable[256], se, *sentry = &se, *sep;
3645     long count, i, j, k;
3646
3647     findsym("rx_connHashTable", &symoff);
3648     kread(kmem, symoff, (char *)&count, sizeof(long));
3649
3650     kread(kmem, count, (char *)rx_connTable, 256 * sizeof(long));
3651     printf("\n\nPrinting all active 'rx_call' structures...\n");
3652     for (i = 0, j = 0; i < 256; i++) {
3653         for (sep = rx_connTable[i]; sep; sep = se.next) {
3654             kread(kmem, (off_t) sep, (char *)sentry, sizeof *sentry);
3655             for (k = 0; k < RX_MAXCALLS; k++) {
3656                 struct rx_call ce, *centry = &ce, *call = se.call[k];
3657                 if (call) {
3658                     j++;
3659                     kread(kmem, (off_t) call, (char *)centry, sizeof *centry);
3660                     printf
3661                         ("\t%lx: conn=0x%lx, qiheader(0x%lx:0x%lx), tq(0x%lx:0x%lx), rq(0x%lx:0x%lx)\n",
3662                          call, centry->conn, centry->queue_item_header.prev,
3663                          centry->queue_item_header.next, centry->tq.prev,
3664                          centry->tq.next, centry->rq.prev, centry->rq.next);
3665                     printf
3666                         ("\t\t: curvec=%d, curpos=%d, nLeft=%d, nFree=%d, currPacket=0x%lx, callNumber=0x%x\n",
3667                          centry->curvec, centry->curpos, centry->nLeft,
3668                          centry->nFree, centry->currentPacket,
3669                          centry->callNumber);
3670                     printf
3671                         ("\t\t: channel=%d, state=0x%x, mode=0x%x, flags=0x%x, localStatus=0x%x, remStatus=0x%x\n",
3672                          centry->channel, centry->state, centry->mode,
3673                          centry->flags, centry->localStatus,
3674                          centry->remoteStatus);
3675                     printf
3676                         ("\t\t: error=%d, timeout=0x%x, rnext=0x%x, rprev=0x%x, rwind=0x%x, tfirst=0x%x, tnext=0x%x\n",
3677                          centry->error, centry->timeout, centry->rnext,
3678                          centry->rprev, centry->rwind, centry->tfirst,
3679                          centry->tnext);
3680                     printf
3681                         ("\t\t: twind=%d, resendEvent=0x%lx, timeoutEvent=0x%lx, keepAliveEvent=0x%lx, delayedAckEvent=0x%lx\n",
3682                          centry->twind, centry->resendEvent,
3683                          centry->timeoutEvent, centry->keepAliveEvent,
3684                          centry->delayedAckEvent);
3685                     printf
3686                         ("\t\t: lastSendTime=0x%x, lastReceiveTime=0x%x, lastAcked=0x%x, startTime=0x%x, startWait=0x%x\n",
3687                          centry->lastSendTime, centry->lastReceiveTime,
3688                          centry->lastAcked, centry->startTime,
3689                          centry->startWait);
3690                     if (centry->flags & RX_CALL_WAIT_PROC)
3691                         printf
3692                             ("\t\t******** Call in RX_CALL_WAIT_PROC state **********\n");
3693                     if (centry->flags & RX_CALL_WAIT_WINDOW_ALLOC)
3694                         printf
3695                             ("\t\t******** Call in RX_CALL_WAIT_WINDOW_ALLOC state **********\n");
3696                     if (centry->flags & RX_CALL_READER_WAIT)
3697                         printf
3698                             ("\t\t******** Conn in RX_CALL_READER_WAIT state **********\n");
3699                     if (centry->flags & RX_CALL_WAIT_PACKETS)
3700                         printf
3701                             ("\t\t******** Conn in RX_CALL_WAIT_PACKETS state **********\n");
3702 #ifdef RX_ENABLE_LOCKS
3703                     printf
3704                         ("\t\t: lock=0x%x, cv_twind=0x%x, cv_rq=0x%x, refCount=%d\n",
3705                          centry->lock, centry->cv_twind, centry->cv_rq,
3706                          centry->refCount);
3707 #endif /* RX_ENABLE_LOCKS */
3708                     printf("\t\t: MTU=%d\n", centry->MTU);
3709                 }
3710             }
3711         }
3712     }
3713     printf("... found %d 'rx_call' entries in the table\n", j);
3714 }
3715
3716 void
3717 print_eventtable(afs_int32 kmem)
3718 {
3719     off_t symoff;
3720     struct rx_queue epq;
3721     struct rx_queue evq;
3722     char *epend, *evend;
3723     afs_int32 count, i, j = 0, k = 0;
3724
3725 #if ! defined(AFS_HPUX_ENV) && ! defined(AFS_AIX_ENV)
3726     findsym("rxevent_nFree", &symoff);
3727     kread(kmem, symoff, (char *)&count, sizeof(afs_int32));
3728     printf("\n\n\trxevent_nFree = %d\n", count);
3729
3730     findsym("rxevent_nPosted", &symoff);
3731     kread(kmem, symoff, (char *)&count, sizeof(afs_int32));
3732     printf("\trxevent_nPosted = %d\n", count);
3733 #endif
3734 }
3735
3736 /*
3737  * print_upDownStats
3738  *
3739  * Print the up/downtime stats for the given class of server records
3740  * provided.
3741  */
3742 void
3743 print_upDownStats(struct afs_stats_SrvUpDownInfo *a_upDownP)
3744 {                               /*print_upDownStats */
3745
3746     /*
3747      * First, print the simple values.
3748      */
3749     printf("\t\t%10d numTtlRecords\n", a_upDownP->numTtlRecords);
3750     printf("\t\t%10d numUpRecords\n", a_upDownP->numUpRecords);
3751     printf("\t\t%10d numDownRecords\n", a_upDownP->numDownRecords);
3752     printf("\t\t%10d sumOfRecordAges\n", a_upDownP->sumOfRecordAges);
3753     printf("\t\t%10d ageOfYoungestRecord\n", a_upDownP->ageOfYoungestRecord);
3754     printf("\t\t%10d ageOfOldestRecord\n", a_upDownP->ageOfOldestRecord);
3755     printf("\t\t%10d numDowntimeIncidents\n",
3756            a_upDownP->numDowntimeIncidents);
3757     printf("\t\t%10d numRecordsNeverDown\n", a_upDownP->numRecordsNeverDown);
3758     printf("\t\t%10d maxDowntimesInARecord\n",
3759            a_upDownP->maxDowntimesInARecord);
3760     printf("\t\t%10d sumOfDowntimes\n", a_upDownP->sumOfDowntimes);
3761     printf("\t\t%10d shortestDowntime\n", a_upDownP->shortestDowntime);
3762     printf("\t\t%10d longestDowntime\n", a_upDownP->longestDowntime);
3763
3764     /*
3765      * Now, print the array values.
3766      */
3767     printf("\t\tDowntime duration distribution:\n");
3768     printf("\t\t\t%8d: 0 min .. 10 min\n", a_upDownP->downDurations[0]);
3769     printf("\t\t\t%8d: 10 min .. 30 min\n", a_upDownP->downDurations[1]);
3770     printf("\t\t\t%8d: 30 min .. 1 hr\n", a_upDownP->downDurations[2]);
3771     printf("\t\t\t%8d: 1 hr .. 2 hr\n", a_upDownP->downDurations[3]);
3772     printf("\t\t\t%8d: 2 hr .. 4 hr\n", a_upDownP->downDurations[4]);
3773     printf("\t\t\t%8d: 4 hr .. 8 hr\n", a_upDownP->downDurations[5]);
3774     printf("\t\t\t%8d: > 8 hr\n", a_upDownP->downDurations[6]);
3775
3776     printf("\t\tDowntime incident distribution:\n");
3777     printf("\t\t\t%8d: 0 times\n", a_upDownP->downIncidents[0]);
3778     printf("\t\t\t%8d: 1 time\n", a_upDownP->downDurations[1]);
3779     printf("\t\t\t%8d: 2 .. 5 times\n", a_upDownP->downDurations[2]);
3780     printf("\t\t\t%8d: 6 .. 10 times\n", a_upDownP->downDurations[3]);
3781     printf("\t\t\t%8d: 10 .. 50 times\n", a_upDownP->downDurations[4]);
3782     printf("\t\t\t%8d: > 50 times\n", a_upDownP->downDurations[5]);
3783 }     &