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