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