src/xstat/xstat_cm_test.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 /*
  11  * Description:
  12  *      Test of the xstat_cm module.
  13  *
  14  *------------------------------------------------------------------------*/
  15
  16 #include <afsconfig.h>
  17 #include <afs/param.h>
  18
  19 #include <roken.h>
  20
  21 #include "xstat_cm.h"           /*Interface for xstat_cm module */
  22 #include <afs/cmd.h>            /*Command line interpreter */
  23 #include <afs/afsutil.h>
  24
  25 /*
  26  * Command line parameter indices.
  27  *      P_CM_NAMES : List of CacheManager names.
  28  *      P_COLL_IDS : List of collection IDs to pick up.
  29  *      P_ONESHOT  : Are we gathering exactly one round of data?
  30  *      P_DEBUG    : Enable debugging output?
  31  */
  32 #define P_CM_NAMES      0
  33 #define P_COLL_IDS      1
  34 #define P_ONESHOT       2
  35 #define P_FREQUENCY     3
  36 #define P_PERIOD        4
  37 #define P_DEBUG         5
  38
  39 /*
  40  * Private globals.
  41  */
  42 static int debugging_on = 0;    /*Are we debugging? */
  43 static int one_shot = 0;        /*Single round of data collection? */
  44
  45 static char *fsOpNames[] = {
  46     "FetchData",
  47     "FetchACL",
  48     "FetchStatus",
  49     "StoreData",
  50     "StoreACL",
  51     "StoreStatus",
  52     "RemoveFile",
  53     "CreateFile",
  54     "Rename",
  55     "Symlink",
  56     "Link",
  57     "MakeDir",
  58     "RemoveDir",
  59     "SetLock",
  60     "ExtendLock",
  61     "ReleaseLock",
  62     "GetStatistics",
  63     "GiveUpCallbacks",
  64     "GetVolumeInfo",
  65     "GetVolumeStatus",
  66     "SetVolumeStatus",
  67     "GetRootVolume",
  68     "CheckToken",
  69     "GetTime",
  70     "NGetVolumeInfo",
  71     "BulkStatus",
  72     "XStatsVersion",
  73     "GetXStats",
  74     "XLookup"
  75 };
  76
  77 static char *cmOpNames[] = {
  78     "CallBack",
  79     "InitCallBackState",
  80     "Probe",
  81     "GetLock",
  82     "GetCE",
  83     "XStatsVersion",
  84     "GetXStats"
  85 };
  86
  87 static char *xferOpNames[] = {
  88     "FetchData",
  89     "StoreData"
  90 };
  91
  92
  93 /* Print detailed functional call statistics */
  94
  95 void
  96 print_cmCallStats(void)
  97 {
  98     char *printableTime;        /*Ptr to printable time string */
  99     struct afs_CMStats *cmp;
 100     time_t probeTime = xstat_cm_Results.probeTime;
 101
 102     printableTime = ctime(&probeTime);
 103     printableTime[strlen(printableTime) - 1] = '\0';
 104
 105     printf
 106         ("AFSCB_XSTATSCOLL_CALL_INFO (coll %d) for CM %s\n[Probe %u, %s]\n\n",
 107          xstat_cm_Results.collectionNumber, xstat_cm_Results.connP->hostName,
 108          xstat_cm_Results.probeNum, printableTime);
 109
 110     cmp = (struct afs_CMStats *)(xstat_cm_Results.data.AFSCB_CollData_val);
 111
 112     if (xstat_cm_Results.data.AFSCB_CollData_len != sizeof(struct afs_CMStats))
 113         printf("Data sets differ in size. Is cache manager a different version?");
 114
 115     printf("\t%10u afs_init\n", cmp->callInfo.C_afs_init);
 116     printf("\t%10u gop_rdwr\n", cmp->callInfo.C_gop_rdwr);
 117     printf("\t%10u aix_gnode_rele\n", cmp->callInfo.C_aix_gnode_rele);
 118     printf("\t%10u gettimeofday\n", cmp->callInfo.C_gettimeofday);
 119     printf("\t%10u m_cpytoc\n", cmp->callInfo.C_m_cpytoc);
 120     printf("\t%10u aix_vattr_null\n", cmp->callInfo.C_aix_vattr_null);
 121     printf("\t%10u afs_gn_ftrunc\n", cmp->callInfo.C_afs_gn_ftrunc);
 122     printf("\t%10u afs_gn_rdwr\n", cmp->callInfo.C_afs_gn_rdwr);
 123     printf("\t%10u afs_gn_ioctl\n", cmp->callInfo.C_afs_gn_ioctl);
 124     printf("\t%10u afs_gn_locktl\n", cmp->callInfo.C_afs_gn_lockctl);
 125     printf("\t%10u afs_gn_readlink\n", cmp->callInfo.C_afs_gn_readlink);
 126     printf("\t%10u afs_gn_readdir\n", cmp->callInfo.C_afs_gn_readdir);
 127     printf("\t%10u afs_gn_select\n", cmp->callInfo.C_afs_gn_select);
 128     printf("\t%10u afs_gn_strategy\n", cmp->callInfo.C_afs_gn_strategy);
 129     printf("\t%10u afs_gn_symlink\n", cmp->callInfo.C_afs_gn_symlink);
 130     printf("\t%10u afs_gn_revoke\n", cmp->callInfo.C_afs_gn_revoke);
 131     printf("\t%10u afs_gn_link\n", cmp->callInfo.C_afs_gn_link);
 132     printf("\t%10u afs_gn_mkdir\n", cmp->callInfo.C_afs_gn_mkdir);
 133     printf("\t%10u afs_gn_mknod\n", cmp->callInfo.C_afs_gn_mknod);
 134     printf("\t%10u afs_gn_remove\n", cmp->callInfo.C_afs_gn_remove);
 135     printf("\t%10u afs_gn_rename\n", cmp->callInfo.C_afs_gn_rename);
 136     printf("\t%10u afs_gn_rmdir\n", cmp->callInfo.C_afs_gn_rmdir);
 137     printf("\t%10u afs_gn_fid\n", cmp->callInfo.C_afs_gn_fid);
 138     printf("\t%10u afs_gn_lookup\n", cmp->callInfo.C_afs_gn_lookup);
 139     printf("\t%10u afs_gn_open\n", cmp->callInfo.C_afs_gn_open);
 140     printf("\t%10u afs_gn_create\n", cmp->callInfo.C_afs_gn_create);
 141     printf("\t%10u afs_gn_close\n", cmp->callInfo.C_afs_gn_close);
 142     printf("\t%10u afs_gn_map\n", cmp->callInfo.C_afs_gn_map);
 143     printf("\t%10u afs_gn_hold\n", cmp->callInfo.C_afs_gn_hold);
 144     printf("\t%10u afs_gn_rele\n", cmp->callInfo.C_afs_gn_rele);
 145     printf("\t%10u afs_gn_unmap\n", cmp->callInfo.C_afs_gn_unmap);
 146     printf("\t%10u afs_gn_access\n", cmp->callInfo.C_afs_gn_access);
 147     printf("\t%10u afs_gn_getattr\n", cmp->callInfo.C_afs_gn_getattr);
 148     printf("\t%10u afs_gn_setattr\n", cmp->callInfo.C_afs_gn_setattr);
 149     printf("\t%10u afs_gn_fclear\n", cmp->callInfo.C_afs_gn_fclear);
 150     printf("\t%10u afs_gn_fsync\n", cmp->callInfo.C_afs_gn_fsync);
 151     printf("\t%10u phash\n", cmp->callInfo.C_pHash);
 152     printf("\t%10u DInit\n", cmp->callInfo.C_DInit);
 153     printf("\t%10u DRead\n", cmp->callInfo.C_DRead);
 154     printf("\t%10u FixupBucket\n", cmp->callInfo.C_FixupBucket);
 155     printf("\t%10u afs_newslot\n", cmp->callInfo.C_afs_newslot);
 156     printf("\t%10u DRelease\n", cmp->callInfo.C_DRelease);
 157     printf("\t%10u DFlush\n", cmp->callInfo.C_DFlush);
 158     printf("\t%10u DFlushEntry\n", cmp->callInfo.C_DFlushEntry);
 159     printf("\t%10u DVOffset\n", cmp->callInfo.C_DVOffset);
 160     printf("\t%10u DZap\n", cmp->callInfo.C_DZap);
 161     printf("\t%10u shutdown_bufferpackage\n",
 162            cmp->callInfo.C_shutdown_bufferpackage);
 163     printf("\t%10u afs_CheckKnownBad\n", cmp->callInfo.C_afs_CheckKnownBad);
 164     printf("\t%10u DNew\n", cmp->callInfo.C_DNew);
 165     printf("\t%10u afs_RemoveVCB\n", cmp->callInfo.C_afs_RemoveVCB);
 166     printf("\t%10u afs_NewVCache\n", cmp->callInfo.C_afs_NewVCache);
 167     printf("\t%10u afs_FlushActiveVcaches\n",
 168            cmp->callInfo.C_afs_FlushActiveVcaches);
 169     printf("\t%10u afs_VerifyVCache\n", cmp->callInfo.C_afs_VerifyVCache);
 170     printf("\t%10u afs_WriteVCache\n", cmp->callInfo.C_afs_WriteVCache);
 171     printf("\t%10u afs_GetVCache\n", cmp->callInfo.C_afs_GetVCache);
 172     printf("\t%10u afs_StuffVcache\n", cmp->callInfo.C_afs_StuffVcache);
 173     printf("\t%10u afs_FindVCache\n", cmp->callInfo.C_afs_FindVCache);
 174     printf("\t%10u afs_PutDCache\n", cmp->callInfo.C_afs_PutDCache);
 175     printf("\t%10u afs_PutVCache\n", cmp->callInfo.C_afs_PutVCache);
 176     printf("\t%10u CacheStoreProc\n", cmp->callInfo.C_CacheStoreProc);
 177     printf("\t%10u afs_FindDcache\n", cmp->callInfo.C_afs_FindDCache);
 178     printf("\t%10u afs_TryToSmush\n", cmp->callInfo.C_afs_TryToSmush);
 179     printf("\t%10u afs_AdjustSize\n", cmp->callInfo.C_afs_AdjustSize);
 180     printf("\t%10u afs_CheckSize\n", cmp->callInfo.C_afs_CheckSize);
 181     printf("\t%10u afs_StoreWarn\n", cmp->callInfo.C_afs_StoreWarn);
 182     printf("\t%10u CacheFetchProc\n", cmp->callInfo.C_CacheFetchProc);
 183     printf("\t%10u UFS_CacheStoreProc\n", cmp->callInfo.C_UFS_CacheStoreProc);
 184     printf("\t%10u UFS_CacheFetchProc\n", cmp->callInfo.C_UFS_CacheFetchProc);
 185     printf("\t%10u afs_GetDCache\n", cmp->callInfo.C_afs_GetDCache);
 186     printf("\t%10u afs_SimpleVStat\n", cmp->callInfo.C_afs_SimpleVStat);
 187     printf("\t%10u afs_ProcessFS\n", cmp->callInfo.C_afs_ProcessFS);
 188     printf("\t%10u afs_InitCacheInfo\n", cmp->callInfo.C_afs_InitCacheInfo);
 189     printf("\t%10u afs_InitVolumeInfo\n", cmp->callInfo.C_afs_InitVolumeInfo);
 190     printf("\t%10u afs_InitCacheFile\n", cmp->callInfo.C_afs_InitCacheFile);
 191     printf("\t%10u afs_CacheInit\n", cmp->callInfo.C_afs_CacheInit);
 192     printf("\t%10u afs_GetDSlot\n", cmp->callInfo.C_afs_GetDSlot);
 193     printf("\t%10u afs_WriteThroughDSlots\n",
 194            cmp->callInfo.C_afs_WriteThroughDSlots);
 195     printf("\t%10u afs_MemGetDSlot\n", cmp->callInfo.C_afs_MemGetDSlot);
 196     printf("\t%10u afs_UFSGetDSlot\n", cmp->callInfo.C_afs_UFSGetDSlot);
 197     printf("\t%10u afs_StoreDCache\n", cmp->callInfo.C_afs_StoreDCache);
 198     printf("\t%10u shutdown_cache\n", cmp->callInfo.C_shutdown_cache);
 199     printf("\t%10u afs_StoreMini\n", cmp->callInfo.C_afs_StoreMini);
 200     printf("\t%10u afs_StoreAllSegments\n",
 201            cmp->callInfo.C_afs_StoreAllSegments);
 202     printf("\t%10u afs_InvalidateAllSegments\n",
 203            cmp->callInfo.C_afs_InvalidateAllSegments);
 204     printf("\t%10u afs_TruncateAllSegments\n",
 205            cmp->callInfo.C_afs_TruncateAllSegments);
 206     printf("\t%10u afs_CheckVolSync\n", cmp->callInfo.C_afs_CheckVolSync);
 207     printf("\t%10u afs_wakeup\n", cmp->callInfo.C_afs_wakeup);
 208     printf("\t%10u afs_CFileOpen\n", cmp->callInfo.C_afs_CFileOpen);
 209     printf("\t%10u afs_CFileTruncate\n", cmp->callInfo.C_afs_CFileTruncate);
 210     printf("\t%10u afs_GetDownD\n", cmp->callInfo.C_afs_GetDownD);
 211     printf("\t%10u afs_WriteDCache\n", cmp->callInfo.C_afs_WriteDCache);
 212     printf("\t%10u afs_FlushDCache\n", cmp->callInfo.C_afs_FlushDCache);
 213     printf("\t%10u afs_GetDownDSlot\n", cmp->callInfo.C_afs_GetDownDSlot);
 214     printf("\t%10u afs_FlushVCache\n", cmp->callInfo.C_afs_FlushVCache);
 215     printf("\t%10u afs_GetDownV\n", cmp->callInfo.C_afs_GetDownV);
 216     printf("\t%10u afs_QueueVCB\n", cmp->callInfo.C_afs_QueueVCB);
 217     printf("\t%10u afs_call\n", cmp->callInfo.C_afs_call);
 218     printf("\t%10u syscall\n", cmp->callInfo.C_syscall);
 219     printf("\t%10u afs_syscall_call\n", cmp->callInfo.C_afs_syscall_call);
 220     printf("\t%10u afs_syscall_icreate\n",
 221            cmp->callInfo.C_afs_syscall_icreate);
 222     printf("\t%10u afs_syscall_iopen\n", cmp->callInfo.C_afs_syscall_iopen);
 223     printf("\t%10u afs_syscall_iincdec\n",
 224            cmp->callInfo.C_afs_syscall_iincdec);
 225     printf("\t%10u iincdec\n", cmp->callInfo.C_iincdec);
 226     printf("\t%10u afs_syscall_ireadwrite\n",
 227            cmp->callInfo.C_afs_syscall_ireadwrite);
 228     printf("\t%10u afs_syscall\n", cmp->callInfo.C_afs_syscall);
 229     printf("\t%10u lpioctl\n", cmp->callInfo.C_lpioctl);
 230     printf("\t%10u lsetpag\n", cmp->callInfo.C_lsetpag);
 231     printf("\t%10u afs_shutdown\n", cmp->callInfo.C_afs_shutdown);
 232     printf("\t%10u shutdown_BKG\n", cmp->callInfo.C_shutdown_BKG);
 233     printf("\t%10u shutdown_afstest\n", cmp->callInfo.C_shutdown_afstest);
 234     printf("\t%10u afs_CheckInit\n", cmp->callInfo.C_afs_CheckInit);
 235     printf("\t%10u ClearCallback\n", cmp->callInfo.C_ClearCallBack);
 236     printf("\t%10u SRXAFSCB_GetCE\n", cmp->callInfo.C_SRXAFSCB_GetCE);
 237     printf("\t%10u SRXAFSCB_GetLock\n", cmp->callInfo.C_SRXAFSCB_GetLock);
 238     printf("\t%10u SRXAFSCB_CallBack\n", cmp->callInfo.C_SRXAFSCB_CallBack);
 239     printf("\t%10u SRXAFSCB_InitCallBackState\n",
 240            cmp->callInfo.C_SRXAFSCB_InitCallBackState);
 241     printf("\t%10u afs_RXCallBackServer\n",
 242            cmp->callInfo.C_afs_RXCallBackServer);
 243     printf("\t%10u shutdown_CB\n", cmp->callInfo.C_shutdown_CB);
 244     printf("\t%10u SRXAFSCB_Probe\n", cmp->callInfo.C_SRXAFSCB_Probe);
 245     printf("\t%10u afs_Chunk\n", cmp->callInfo.C_afs_Chunk);
 246     printf("\t%10u afs_ChunkBase\n", cmp->callInfo.C_afs_ChunkBase);
 247     printf("\t%10u afs_ChunkOffset\n", cmp->callInfo.C_afs_ChunkOffset);
 248     printf("\t%10u afs_ChunkSize\n", cmp->callInfo.C_afs_ChunkSize);
 249     printf("\t%10u afs_ChunkToBase\n", cmp->callInfo.C_afs_ChunkToBase);
 250     printf("\t%10u afs_ChunkToSize\n", cmp->callInfo.C_afs_ChunkToSize);
 251     printf("\t%10u afs_SetChunkSize\n", cmp->callInfo.C_afs_SetChunkSize);
 252     printf("\t%10u afs_config\n", cmp->callInfo.C_afs_config);
 253     printf("\t%10u mem_freebytes\n", cmp->callInfo.C_mem_freebytes);
 254     printf("\t%10u fpalloc\n", cmp->callInfo.C_fpalloc);
 255     printf("\t%10u kluge_init\n", cmp->callInfo.C_kluge_init);
 256     printf("\t%10u ufdalloc\n", cmp->callInfo.C_ufdalloc);
 257     printf("\t%10u ufdfree\n", cmp->callInfo.C_ufdfree);
 258     printf("\t%10u commit\n", cmp->callInfo.C_commit);
 259     printf("\t%10u dev_ialloc\n", cmp->callInfo.C_dev_ialloc);
 260     printf("\t%10u ffree\n", cmp->callInfo.C_ffree);
 261     printf("\t%10u iget\n", cmp->callInfo.C_iget);
 262     printf("\t%10u iptovp\n", cmp->callInfo.C_iptovp);
 263     printf("\t%10u ilock\n", cmp->callInfo.C_ilock);
 264     printf("\t%10u irele\n", cmp->callInfo.C_irele);
 265     printf("\t%10u iput\n", cmp->callInfo.C_iput);
 266     printf("\t%10u mem_getbytes\n", cmp->callInfo.C_mem_getbytes);
 267     printf("\t%10u afs_Daemon\n", cmp->callInfo.C_afs_Daemon);
 268     printf("\t%10u afs_CheckRootVolume\n",
 269            cmp->callInfo.C_afs_CheckRootVolume);
 270     printf("\t%10u BPath\n", cmp->callInfo.C_BPath);
 271     printf("\t%10u BPrefetch\n", cmp->callInfo.C_BPrefetch);
 272     printf("\t%10u BStore\n", cmp->callInfo.C_BStore);
 273     printf("\t%10u afs_BBusy\n", cmp->callInfo.C_afs_BBusy);
 274     printf("\t%10u afs_BQueue\n", cmp->callInfo.C_afs_BQueue);
 275     printf("\t%10u afs_BRelease\n", cmp->callInfo.C_afs_BRelease);
 276     printf("\t%10u shutdown_daemons\n", cmp->callInfo.C_shutdown_daemons);
 277     printf("\t%10u afs_BackgroundDaemon\n",
 278            cmp->callInfo.C_afs_BackgroundDaemon);
 279     printf("\t%10u exporter_add\n", cmp->callInfo.C_exporter_add);
 280     printf("\t%10u exporter_find\n", cmp->callInfo.C_exporter_find);
 281     printf("\t%10u IsAfsVnode\n", cmp->callInfo.C_IsAfsVnode);
 282     printf("\t%10u SetAfsVnode\n", cmp->callInfo.C_SetAfsVnode);
 283     printf("\t%10u afs_gfs_kalloc\n", cmp->callInfo.C_afs_gfs_kalloc);
 284     printf("\t%10u afs_gfs_kfree\n", cmp->callInfo.C_afs_gfs_kfree);
 285     printf("\t%10u gfsvop_getattr\n", cmp->callInfo.C_gfsvop_getattr);
 286     printf("\t%10u gfsvop_rdwr\n", cmp->callInfo.C_gfsvop_rdwr);
 287     printf("\t%10u gop_lookupname\n", cmp->callInfo.C_gop_lookupname);
 288     printf("\t%10u afs_uniqtime\n", cmp->callInfo.C_afs_uniqtime);
 289     printf("\t%10u gfs_vattr_null\n", cmp->callInfo.C_gfs_vattr_null);
 290     printf("\t%10u afs_lock\n", cmp->callInfo.C_afs_lock);
 291     printf("\t%10u afs_unlock\n", cmp->callInfo.C_afs_unlock);
 292     printf("\t%10u afs_update\n", cmp->callInfo.C_afs_update);
 293     printf("\t%10u afs_gclose\n", cmp->callInfo.C_afs_gclose);
 294     printf("\t%10u afs_gopen\n", cmp->callInfo.C_afs_gopen);
 295     printf("\t%10u afs_greadlink\n", cmp->callInfo.C_afs_greadlink);
 296     printf("\t%10u afs_select\n", cmp->callInfo.C_afs_select);
 297     printf("\t%10u afs_gbmap\n", cmp->callInfo.C_afs_gbmap);
 298     printf("\t%10u afs_getfsdata\n", cmp->callInfo.C_afs_getfsdata);
 299     printf("\t%10u afs_gsymlink\n", cmp->callInfo.C_afs_gsymlink);
 300     printf("\t%10u printgnode\n", cmp->callInfo.C_printgnode);
 301     printf("\t%10u HaveGFSLock\n", cmp->callInfo.C_HaveGFSLock);
 302     printf("\t%10u afs_namei\n", cmp->callInfo.C_afs_namei);
 303     printf("\t%10u AddGFSLock\n", cmp->callInfo.C_AddGFSLock);
 304     printf("\t%10u RemoveGFSLock\n", cmp->callInfo.C_RemoveGFSLock);
 305     printf("\t%10u afs_grlock\n", cmp->callInfo.C_afs_grlock);
 306     printf("\t%10u afs_gumount\n", cmp->callInfo.C_afs_gumount);
 307     printf("\t%10u afs_gmount\n", cmp->callInfo.C_afs_gmount);
 308     printf("\t%10u afs_gget\n", cmp->callInfo.C_afs_gget);
 309     printf("\t%10u afs_glink\n", cmp->callInfo.C_afs_glink);
 310     printf("\t%10u afs_sbupdate\n", cmp->callInfo.C_afs_sbupdate);
 311     printf("\t%10u afs_gmkdir\n", cmp->callInfo.C_afs_gmkdir);
 312     printf("\t%10u afs_unlink\n", cmp->callInfo.C_afs_unlink);
 313     printf("\t%10u afs_grmdir\n", cmp->callInfo.C_afs_grmdir);
 314     printf("\t%10u afs_makenode\n", cmp->callInfo.C_afs_makenode);
 315     printf("\t%10u afs_grename\n", cmp->callInfo.C_afs_grename);
 316     printf("\t%10u afs_rele\n", cmp->callInfo.C_afs_rele);
 317     printf("\t%10u afs_syncgp\n", cmp->callInfo.C_afs_syncgp);
 318     printf("\t%10u afs_gfshack\n", cmp->callInfo.C_afs_gfshack);
 319     printf("\t%10u afs_getval\n", cmp->callInfo.C_afs_getval);
 320     printf("\t%10u afs_trunc\n", cmp->callInfo.C_afs_trunc);
 321     printf("\t%10u afs_rwgp\n", cmp->callInfo.C_afs_rwgp);
 322     printf("\t%10u afs_stat\n", cmp->callInfo.C_afs_stat);
 323     printf("\t%10u hpsobind\n", cmp->callInfo.C_hpsobind);
 324     printf("\t%10u hpsoclose\n", cmp->callInfo.C_hpsoclose);
 325     printf("\t%10u hpsocreate\n", cmp->callInfo.C_hpsocreate);
 326     printf("\t%10u hpsoreserve\n", cmp->callInfo.C_hpsoreserve);
 327     printf("\t%10u afsc_link\n", cmp->callInfo.C_afsc_link);
 328     printf("\t%10u devtovfs\n", cmp->callInfo.C_devtovfs);
 329     printf("\t%10u afs_vfs_mount\n", cmp->callInfo.C_afs_vfs_mount);
 330     printf("\t%10u afs_uniqtime\n", cmp->callInfo.C_afs_uniqtime);
 331     printf("\t%10u iopen\n", cmp->callInfo.C_iopen);
 332     printf("\t%10u idec\n", cmp->callInfo.C_idec);
 333     printf("\t%10u iinc\n", cmp->callInfo.C_iinc);
 334     printf("\t%10u oiread\n", cmp->callInfo.C_oiread);
 335     printf("\t%10u AHash\n", cmp->callInfo.C_AHash);
 336     printf("\t%10u QTOA\n", cmp->callInfo.C_QTOA);
 337     printf("\t%10u afs_FindPartByDev\n", cmp->callInfo.C_afs_FindPartByDev);
 338     printf("\t%10u aux_init\n", cmp->callInfo.C_aux_init);
 339     printf("\t%10u afs_GetNewPart\n", cmp->callInfo.C_afs_GetNewPart);
 340     printf("\t%10u afs_InitAuxVolFile\n",
 341            cmp->callInfo.C_afs_InitAuxVolFile);
 342     printf("\t%10u afs_CreateAuxEntry\n",
 343            cmp->callInfo.C_afs_CreateAuxEntry);
 344     printf("\t%10u afs_GetAuxSlot\n", cmp->callInfo.C_afs_GetAuxSlot);
 345     printf("\t%10u afs_GetDownAux\n", cmp->callInfo.C_afs_GetDownAux);
 346     printf("\t%10u afs_FlushAuxCache\n", cmp->callInfo.C_afs_FlushAuxCache);
 347     printf("\t%10u afs_GetAuxInode\n", cmp->callInfo.C_afs_GetAuxInode);
 348     printf("\t%10u afs_PutAuxInode\n", cmp->callInfo.C_afs_PutAuxInode);
 349     printf("\t%10u afs_ReadAuxInode\n", cmp->callInfo.C_afs_ReadAuxInode);
 350     printf("\t%10u afs_WriteAuxInode\n", cmp->callInfo.C_afs_WriteAuxInode);
 351     printf("\t%10u afs_auxcall\n", cmp->callInfo.C_afs_auxcall);
 352     printf("\t%10u tmpdbg_auxtbl\n", cmp->callInfo.C_tmpdbg_auxtbl);
 353     printf("\t%10u tmpdbg_parttbl\n", cmp->callInfo.C_tmpdbg_parttbl);
 354     printf("\t%10u ireadwrite\n", cmp->callInfo.C_ireadwrite);
 355     printf("\t%10u iread\n", cmp->callInfo.C_iread);
 356     printf("\t%10u getinode\n", cmp->callInfo.C_getinode);
 357     printf("\t%10u trygetfs\n", cmp->callInfo.C_trygetfs);
 358     printf("\t%10u iwrite\n", cmp->callInfo.C_iwrite);
 359     printf("\t%10u iforget\n", cmp->callInfo.C_iforget);
 360     printf("\t%10u Lock_Init\n", cmp->callInfo.C_Lock_Init);
 361     printf("\t%10u Lock_Obtain\n", cmp->callInfo.C_Lock_Obtain);
 362     printf("\t%10u Lock_ReleaseR\n", cmp->callInfo.C_Lock_ReleaseR);
 363     printf("\t%10u Lock_ReleaseW\n", cmp->callInfo.C_Lock_ReleaseW);
 364     printf("\t%10u afs_BozonLock\n", cmp->callInfo.C_afs_BozonLock);
 365     printf("\t%10u afs_BozonUnlock\n", cmp->callInfo.C_afs_BozonUnlock);
 366     printf("\t%10u icreate\n", cmp->callInfo.C_icreate);
 367     printf("\t%10u igetinode\n", cmp->callInfo.C_igetinode);
 368     printf("\t%10u osi_SleepR\n", cmp->callInfo.C_osi_SleepR);
 369     printf("\t%10u osi_SleepS\n", cmp->callInfo.C_osi_SleepS);
 370     printf("\t%10u osi_SleepW\n", cmp->callInfo.C_osi_SleepW);
 371     printf("\t%10u afs_BozonInit\n", cmp->callInfo.C_afs_BozonInit);
 372     printf("\t%10u afs_CheckBozonLock\n",
 373            cmp->callInfo.C_afs_CheckBozonLock);
 374     printf("\t%10u afs_CheckBozonLockBlocking\n",
 375            cmp->callInfo.C_afs_CheckBozonLockBlocking);
 376     printf("\t%10u xxxinit\n", cmp->callInfo.C_xxxinit);
 377     printf("\t%10u KernelEntry\n", cmp->callInfo.C_KernelEntry);
 378     printf("\t%10u afs_InitMemCache\n", cmp->callInfo.C_afs_InitMemCache);
 379     printf("\t%10u osi_Sleep\n", cmp->callInfo.C_osi_Sleep);
 380     printf("\t%10u afs_LookupMCE\n", cmp->callInfo.C_afs_LookupMCE);
 381     printf("\t%10u afs_MemReadBlk\n", cmp->callInfo.C_afs_MemReadBlk);
 382     printf("\t%10u afs_MemReadUIO\n", cmp->callInfo.C_afs_MemReadUIO);
 383     printf("\t%10u afs_MemWriteBlk\n", cmp->callInfo.C_afs_MemWriteBlk);
 384     printf("\t%10u afs_MemWriteUIO\n", cmp->callInfo.C_afs_MemWriteUIO);
 385     printf("\t%10u afs_MemCacheStoreProc\n",
 386            cmp->callInfo.C_afs_MemCacheStoreProc);
 387     printf("\t%10u afs_vnode_pager_create\n",
 388            cmp->callInfo.C_afs_vnode_pager_create);
 389     printf("\t%10u next_KernelEntry\n", cmp->callInfo.C_next_KernelEntry);
 390     printf("\t%10u afs_MemCacheFetchProc\n",
 391            cmp->callInfo.C_afs_MemCacheFetchProc);
 392     printf("\t%10u afs_MemCacheTruncate\n",
 393            cmp->callInfo.C_afs_MemCacheTruncate);
 394     printf("\t%10u afs_MemCacheStoreProc\n",
 395            cmp->callInfo.C_afs_MemCacheStoreProc);
 396     printf("\t%10u afs_GetNfsClientPag\n",
 397            cmp->callInfo.C_afs_GetNfsClientPag);
 398     printf("\t%10u afs_FindNfsClientPag\n",
 399            cmp->callInfo.C_afs_FindNfsClientPag);
 400     printf("\t%10u afs_PutNfsClientPag\n",
 401            cmp->callInfo.C_afs_PutNfsClientPag);
 402     printf("\t%10u afs_nfsclient_reqhandler\n",
 403            cmp->callInfo.C_afs_nfsclient_reqhandler);
 404     printf("\t%10u afs_nfsclient_GC\n", cmp->callInfo.C_afs_nfsclient_GC);
 405     printf("\t%10u afs_nfsclient_hold\n", cmp->callInfo.C_afs_nfsclient_hold);
 406     printf("\t%10u afs_nfsclient_stats\n",
 407            cmp->callInfo.C_afs_nfsclient_stats);
 408     printf("\t%10u afs_nfsclient_shutdown\n",
 409            cmp->callInfo.C_afs_nfsclient_shutdown);
 410     printf("\t%10u afs_rfs_readdir_fixup\n",
 411            cmp->callInfo.C_afs_rfs_readdir_fixup);
 412     printf("\t%10u afs_nfsclient_sysname\n",
 413            cmp->callInfo.C_afs_nfsclient_sysname);
 414     printf("\t%10u afs_xnfs_svc\n", cmp->callInfo.C_afs_xnfs_svc);
 415     printf("\t%10u afs_xdr_putrddirres\n",
 416            cmp->callInfo.C_afs_xdr_putrddirres);
 417     printf("\t%10u afs_rfs_readdir\n", cmp->callInfo.C_afs_rfs_readdir);
 418     printf("\t%10u afs_rfs_rddirfree\n", cmp->callInfo.C_afs_rfs_rddirfree);
 419     printf("\t%10u rfs_dupcreate\n", cmp->callInfo.C_rfs_dupcreate);
 420     printf("\t%10u rfs_dupsetattr\n", cmp->callInfo.C_rfs_dupsetattr);
 421     printf("\t%10u afs_rfs_dispatch\n", cmp->callInfo.C_afs_rfs_dispatch);
 422     printf("\t%10u afs_nfs2afscall\n", cmp->callInfo.C_Nfs2AfsCall);
 423     printf("\t%10u afs_sun_xuntext\n", cmp->callInfo.C_afs_sun_xuntext);
 424     printf("\t%10u osi_Active\n", cmp->callInfo.C_osi_Active);
 425     printf("\t%10u osi_FlushPages\n", cmp->callInfo.C_osi_FlushPages);
 426     printf("\t%10u osi_FlushText\n", cmp->callInfo.C_osi_FlushText);
 427     printf("\t%10u osi_CallProc\n", cmp->callInfo.C_osi_CallProc);
 428     printf("\t%10u osi_CancelProc\n", cmp->callInfo.C_osi_CancelProc);
 429     printf("\t%10u osi_Invisible\n", cmp->callInfo.C_osi_Invisible);
 430     printf("\t%10u osi_Time\n", cmp->callInfo.C_osi_Time);
 431     printf("\t%10u osi_Alloc\n", cmp->callInfo.C_osi_Alloc);
 432     printf("\t%10u osi_SetTime\n", cmp->callInfo.C_osi_SetTime);
 433     printf("\t%10u osi_Dump\n", cmp->callInfo.C_osi_Dump);
 434     printf("\t%10u shutdown_osi\n", cmp->callInfo.C_shutdown_osi);
 435     printf("\t%10u osi_Free\n", cmp->callInfo.C_osi_Free);
 436     printf("\t%10u osi_UFSOpen\n", cmp->callInfo.C_osi_UFSOpen);
 437     printf("\t%10u osi_Close\n", cmp->callInfo.C_osi_Close);
 438     printf("\t%10u osi_Stat\n", cmp->callInfo.C_osi_Stat);
 439     printf("\t%10u osi_Truncate\n", cmp->callInfo.C_osi_Truncate);
 440     printf("\t%10u osi_Read\n", cmp->callInfo.C_osi_Read);
 441     printf("\t%10u osi_Write\n", cmp->callInfo.C_osi_Write);
 442     printf("\t%10u shutdown_osifile\n", cmp->callInfo.C_shutdown_osifile);
 443     printf("\t%10u osi_MapStrategy\n", cmp->callInfo.C_osi_MapStrategy);
 444     printf("\t%10u osi_AllocLargeSpace\n",
 445            cmp->callInfo.C_osi_AllocLargeSpace);
 446     printf("\t%10u osi_FreeLargeSpace\n", cmp->callInfo.C_osi_FreeLargeSpace);
 447     printf("\t%10u osi_AllocSmallSpace\n",
 448            cmp->callInfo.C_osi_AllocSmallSpace);
 449     printf("\t%10u pkt_iodone\n", cmp->callInfo.C_pkt_iodone);
 450     printf("\t%10u shutdown_osinet\n", cmp->callInfo.C_shutdown_osinet);
 451     printf("\t%10u afs_cs\n", cmp->callInfo.C_afs_cs);
 452     printf("\t%10u osi_FreeSmallSpace\n", cmp->callInfo.C_osi_FreeSmallSpace);
 453     printf("\t%10u osi_CloseToTheEdge\n", cmp->callInfo.C_osi_CloseToTheEdge);
 454     printf("\t%10u osi_xgreedy\n", cmp->callInfo.C_osi_xgreedy);
 455     printf("\t%10u osi_FreeSocket\n", cmp->callInfo.C_osi_FreeSocket);
 456     printf("\t%10u trysblock\n", cmp->callInfo.C_trysblock);
 457     printf("\t%10u osi_NewSocket\n", cmp->callInfo.C_osi_NewSocket);
 458     printf("\t%10u osi_NetSend\n", cmp->callInfo.C_osi_NetSend);
 459     printf("\t%10u WaitHack\n", cmp->callInfo.C_WaitHack);
 460     printf("\t%10u osi_InitWaitHandle\n",
 461            cmp->callInfo.C_osi_InitWaitHandle);
 462     printf("\t%10u osi_CancelWait\n", cmp->callInfo.C_osi_CancelWait);
 463     printf("\t%10u osi_Wakeup\n", cmp->callInfo.C_osi_Wakeup);
 464     printf("\t%10u osi_Wait\n", cmp->callInfo.C_osi_Wait);
 465     printf("\t%10u dirp_SetCacheDev\n", cmp->callInfo.C_dirp_SetCacheDev);
 466     printf("\t%10u Die\n", cmp->callInfo.C_Die);
 467     printf("\t%10u dirp_Read\n", cmp->callInfo.C_dirp_Read);
 468     printf("\t%10u dirp_Cpy\n", cmp->callInfo.C_dirp_Cpy);
 469     printf("\t%10u dirp_Eq\n", cmp->callInfo.C_dirp_Eq);
 470     printf("\t%10u dirp_Write\n", cmp->callInfo.C_dirp_Write);
 471     printf("\t%10u dirp_Zap\n", cmp->callInfo.C_dirp_Zap);
 472     printf("\t%10u afs_ioctl\n", cmp->callInfo.C_afs_ioctl);
 473     printf("\t%10u _AFSIOCTL\n", cmp->callInfo.C__AFSIOCTL);
 474     printf("\t%10u _VALIDAFSIOCTL\n", cmp->callInfo.C__VALIDAFSIOCTL);
 475     printf("\t%10u handleIoctl\n", cmp->callInfo.C_HandleIoctl);
 476     printf("\t%10u afs_xioctl\n", cmp->callInfo.C_afs_xioctl);
 477     printf("\t%10u afs_syscall_pioctl\n",
 478            cmp->callInfo.C_afs_syscall_pioctl);
 479     printf("\t%10u afs_pioctl\n", cmp->callInfo.C_afs_pioctl);
 480     printf("\t%10u HandlePioctl\n", cmp->callInfo.C_HandlePioctl);
 481     printf("\t%10u PGetVolumeStatus\n", cmp->callInfo.C_PGetVolumeStatus);
 482     printf("\t%10u PSetVolumeStatus\n", cmp->callInfo.C_PSetVolumeStatus);
 483     printf("\t%10u PFlush\n", cmp->callInfo.C_PFlush);
 484     printf("\t%10u PFlushVolumeData\n", cmp->callInfo.C_PFlushVolumeData);
 485     printf("\t%10u PNewStatMount\n", cmp->callInfo.C_PNewStatMount);
 486     printf("\t%10u PGetTokens\n", cmp->callInfo.C_PGetTokens);
 487     printf("\t%10u PSetTokens\n", cmp->callInfo.C_PSetTokens);
 488     printf("\t%10u PUnlog\n", cmp->callInfo.C_PUnlog);
 489     printf("\t%10u PMariner\n", cmp->callInfo.C_PMariner);
 490     printf("\t%10u PCheckServers\n", cmp->callInfo.C_PCheckServers);
 491     printf("\t%10u PCheckAuth\n", cmp->callInfo.C_PCheckAuth);
 492     printf("\t%10u PCheckVolNames\n", cmp->callInfo.C_PCheckVolNames);
 493     printf("\t%10u PFindVolume\n", cmp->callInfo.C_PFindVolume);
 494     printf("\t%10u Prefetch\n", cmp->callInfo.C_Prefetch);
 495     printf("\t%10u PGetCacheSize\n", cmp->callInfo.C_PGetCacheSize);
 496     printf("\t%10u PSetCacheSize\n", cmp->callInfo.C_PSetCacheSize);
 497     printf("\t%10u PSetSysName\n", cmp->callInfo.C_PSetSysName);
 498     printf("\t%10u PExportAfs\n", cmp->callInfo.C_PExportAfs);
 499     printf("\t%10u HandleClientContext\n",
 500            cmp->callInfo.C_HandleClientContext);
 501     printf("\t%10u PViceAccess\n", cmp->callInfo.C_PViceAccess);
 502     printf("\t%10u PRemoveCallBack\n", cmp->callInfo.C_PRemoveCallBack);
 503     printf("\t%10u PRemoveMount\n", cmp->callInfo.C_PRemoveMount);
 504     printf("\t%10u PSetVolumeStatus\n", cmp->callInfo.C_PSetVolumeStatus);
 505     printf("\t%10u PListCells\n", cmp->callInfo.C_PListCells);
 506     printf("\t%10u PNewCell\n", cmp->callInfo.C_PNewCell);
 507     printf("\t%10u PGetUserCell\n", cmp->callInfo.C_PGetUserCell);
 508     printf("\t%10u PGetCellStatus\n", cmp->callInfo.C_PGetCellStatus);
 509     printf("\t%10u PSetCellStatus\n", cmp->callInfo.C_PSetCellStatus);
 510     printf("\t%10u PVenusLogging\n", cmp->callInfo.C_PVenusLogging);
 511     printf("\t%10u PGetAcl\n", cmp->callInfo.C_PGetAcl);
 512     printf("\t%10u PGetFID\n", cmp->callInfo.C_PGetFID);
 513     printf("\t%10u PBogus\n", cmp->callInfo.C_PBogus);
 514     printf("\t%10u PSetAcl\n", cmp->callInfo.C_PSetAcl);
 515     printf("\t%10u PGetFileCell\n", cmp->callInfo.C_PGetFileCell);
 516     printf("\t%10u PNoop\n", cmp->callInfo.C_PNoop);
 517     printf("\t%10u PGetWSCell\n", cmp->callInfo.C_PGetWSCell);
 518     printf("\t%10u afs_warn\n", cmp->callInfo.C_afs_warn);
 519     printf("\t%10u afs_warnuser\n", cmp->callInfo.C_afs_warnuser);
 520     printf("\t%10u PGetSPrefs\n", cmp->callInfo.C_PGetSPrefs);
 521     printf("\t%10u PSetSPrefs\n", cmp->callInfo.C_PSetSPrefs);
 522     printf("\t%10u afs_ResetAccessCache\n",
 523            cmp->callInfo.C_afs_ResetAccessCache);
 524     printf("\t%10u afs_FindUser\n", cmp->callInfo.C_afs_FindUser);
 525     printf("\t%10u afs_GetUser\n", cmp->callInfo.C_afs_GetUser);
 526     printf("\t%10u VSleep\n", cmp->callInfo.C_VSleep);
 527     printf("\t%10u afs_GCUserData\n", cmp->callInfo.C_afs_GCUserData);
 528     printf("\t%10u afs_PutUser\n", cmp->callInfo.C_afs_PutUser);
 529     printf("\t%10u afs_SetPrimary\n", cmp->callInfo.C_afs_SetPrimary);
 530     printf("\t%10u afs_ResetUserConns\n", cmp->callInfo.C_afs_ResetUserConns);
 531     printf("\t%10u afs_MarinerLog\n", cmp->callInfo.C_afs_MarinerLog);
 532     printf("\t%10u afs_vtoi\n", cmp->callInfo.C_afs_vtoi);
 533     printf("\t%10u afs_RemoveUserConns\n", cmp->callInfo.C_RemoveUserConns);
 534     printf("\t%10u afs_ResourceInit\n", cmp->callInfo.C_afs_ResourceInit);
 535     printf("\t%10u afs_GetCell\n", cmp->callInfo.C_afs_GetCell);
 536     printf("\t%10u afs_GetCellByIndex\n", cmp->callInfo.C_afs_GetCellByIndex);
 537     printf("\t%10u afs_GetCellByName\n", cmp->callInfo.C_afs_GetCellByName);
 538     printf("\t%10u afs_GetRealCellByIndex\n",
 539            cmp->callInfo.C_afs_GetRealCellByIndex);
 540     printf("\t%10u afs_NewCell\n", cmp->callInfo.C_afs_NewCell);
 541     printf("\t%10u CheckVLDB\n", cmp->callInfo.C_CheckVLDB);
 542     printf("\t%10u afs_GetVolume\n", cmp->callInfo.C_afs_GetVolume);
 543     printf("\t%10u afs_PutVolume\n", cmp->callInfo.C_afs_PutVolume);
 544     printf("\t%10u afs_GetVolumeByName\n",
 545            cmp->callInfo.C_afs_GetVolumeByName);
 546     printf("\t%10u ranstage\n", cmp->callInfo.C_ranstage);
 547     printf("\t%10u afs_random\n", cmp->callInfo.C_afs_random);
 548     printf("\t%10u InstallVolumeEntry\n", cmp->callInfo.C_InstallVolumeEntry);
 549     printf("\t%10u InstallVolumeInfo\n", cmp->callInfo.C_InstallVolumeInfo);
 550     printf("\t%10u StartLogFile\n", cmp->callInfo.C_StartLogFile);
 551     printf("\t%10u afs_SetLogFile\n", cmp->callInfo.C_afs_SetLogFile);
 552     printf("\t%10u EndLogFile\n", cmp->callInfo.C_EndLogFile);
 553     printf("\t%10u afs_dp\n", cmp->callInfo.C_afs_dp);
 554     printf("\t%10u fprf\n", cmp->callInfo.C_fprf);
 555     printf("\t%10u fprint\n", cmp->callInfo.C_fprint);
 556     printf("\t%10u fprintn\n", cmp->callInfo.C_fprintn);
 557     printf("\t%10u afs_ResetVolumeInfo\n",
 558            cmp->callInfo.C_afs_ResetVolumeInfo);
 559     printf("\t%10u afs_FindServer\n", cmp->callInfo.C_afs_FindServer);
 560     printf("\t%10u afs_GetServer\n", cmp->callInfo.C_afs_GetServer);
 561     printf("\t%10u afs_SortServers\n", cmp->callInfo.C_afs_SortServers);
 562     printf("\t%10u afs_AddToMean\n", cmp->callInfo.C_afs_AddToMean);
 563     printf("\t%10u afs_GetCMStat\n", cmp->callInfo.C_afs_GetCMStat);
 564     printf("\t%10u afs_CheckServers\n", cmp->callInfo.C_afs_CheckServers);
 565     printf("\t%10u ServerDown\n", cmp->callInfo.C_ServerDown);
 566     printf("\t%10u afs_Conn\n", cmp->callInfo.C_afs_Conn);
 567     printf("\t%10u afs_PutConn\n", cmp->callInfo.C_afs_PutConn);
 568     printf("\t%10u afs_ConnByHost\n", cmp->callInfo.C_afs_ConnByHost);
 569     printf("\t%10u afs_ConnByMHosts\n", cmp->callInfo.C_afs_ConnByMHosts);
 570     printf("\t%10u afs_Analyze\n", cmp->callInfo.C_afs_Analyze);
 571     printf("\t%10u puttofile\n", cmp->callInfo.C_puttofile);
 572     printf("\t%10u shutdown_AFS\n", cmp->callInfo.C_shutdown_AFS);
 573     printf("\t%10u afs_CheckLocks\n", cmp->callInfo.C_afs_CheckLocks);
 574     printf("\t%10u haveCallBacksFrom\n", cmp->callInfo.C_HaveCallBacksFrom);
 575     printf("\t%10u CheckVLServer\n", cmp->callInfo.C_CheckVLServer);
 576     printf("\t%10u afs_CheckCacheResets\n",
 577            cmp->callInfo.C_afs_CheckCacheResets);
 578     printf("\t%10u afs_CheckVolumeNames\n",
 579            cmp->callInfo.C_afs_CheckVolumeNames);
 580     printf("\t%10u afs_CheckCode\n", cmp->callInfo.C_afs_CheckCode);
 581     printf("\t%10u afs_CopyError\n", cmp->callInfo.C_afs_CopyError);
 582     printf("\t%10u afs_cv2string\n", cmp->callInfo.C_afs_cv2string);
 583     printf("\t%10u afs_FindVolCache\n", cmp->callInfo.C_afs_FindVolCache);
 584     printf("\t%10u afs_FinalizeReq\n", cmp->callInfo.C_afs_FinalizeReq);
 585     printf("\t%10u afs_GetVolCache\n", cmp->callInfo.C_afs_GetVolCache);
 586     printf("\t%10u afs_GetVolSlot\n", cmp->callInfo.C_afs_GetVolSlot);
 587     printf("\t%10u afs_UFSGetVolSlot\n", cmp->callInfo.C_afs_UFSGetVolSlot);
 588     printf("\t%10u print_internet_address\n",
 589            cmp->callInfo.C_print_internet_address);
 590     printf("\t%10u afs_MemGetVolSlot\n", cmp->callInfo.C_afs_MemGetVolSlot);
 591     printf("\t%10u afs_WriteVolCache\n", cmp->callInfo.C_afs_WriteVolCache);
 592     printf("\t%10u haveCallbacksfrom\n", cmp->callInfo.C_HaveCallBacksFrom);
 593     printf("\t%10u afs_getpage\n", cmp->callInfo.C_afs_getpage);
 594     printf("\t%10u afs_putpage\n", cmp->callInfo.C_afs_putpage);
 595     printf("\t%10u afs_nfsrdwr\n", cmp->callInfo.C_afs_nfsrdwr);
 596     printf("\t%10u afs_map\n", cmp->callInfo.C_afs_map);
 597     printf("\t%10u afs_cntl\n", cmp->callInfo.C_afs_cntl);
 598     printf("\t%10u afs_dump\n", cmp->callInfo.C_afs_dump);
 599     printf("\t%10u afs_realvp\n", cmp->callInfo.C_afs_realvp);
 600     printf("\t%10u afs_cmp\n", cmp->callInfo.C_afs_cmp);
 601     printf("\t%10u afsinit\n", cmp->callInfo.C_afsinit);
 602     printf("\t%10u afs_PageLeft\n", cmp->callInfo.C_afs_PageLeft);
 603     printf("\t%10u afs_mount\n", cmp->callInfo.C_afs_mount);
 604     printf("\t%10u afs_unmount\n", cmp->callInfo.C_afs_unmount);
 605     printf("\t%10u afs_root\n", cmp->callInfo.C_afs_root);
 606     printf("\t%10u afs_statfs\n", cmp->callInfo.C_afs_statfs);
 607     printf("\t%10u afs_sync\n", cmp->callInfo.C_afs_sync);
 608     printf("\t%10u afs_mountroot\n", cmp->callInfo.C_afs_mountroot);
 609     printf("\t%10u afs_swapvp\n", cmp->callInfo.C_afs_swapvp);
 610     printf("\t%10u afs_vget\n", cmp->callInfo.C_afs_vget);
 611     printf("\t%10u afs_noop\n", cmp->callInfo.C_afs_noop);
 612     printf("\t%10u afs_index\n", cmp->callInfo.C_afs_index);
 613     printf("\t%10u afs_setpag\n", cmp->callInfo.C_afs_setpag);
 614     printf("\t%10u genpag\n", cmp->callInfo.C_genpag);
 615     printf("\t%10u getpag\n", cmp->callInfo.C_getpag);
 616     printf("\t%10u genpag\n", cmp->callInfo.C_genpag);
 617     printf("\t%10u afs_badop\n", cmp->callInfo.C_afs_badop);
 618     printf("\t%10u afs_GetMariner\n", cmp->callInfo.C_afs_GetMariner);
 619     printf("\t%10u afs_AddMarinerName\n", cmp->callInfo.C_afs_AddMarinerName);
 620     printf("\t%10u afs_open\n", cmp->callInfo.C_afs_open);
 621     printf("\t%10u afs_close\n", cmp->callInfo.C_afs_close);
 622     printf("\t%10u afs_closex\n", cmp->callInfo.C_afs_closex);
 623     printf("\t%10u afs_write\n", cmp->callInfo.C_afs_write);
 624     printf("\t%10u afs_UFSwrite\n", cmp->callInfo.C_afs_UFSWrite);
 625     printf("\t%10u afs_Memwrite\n", cmp->callInfo.C_afs_MemWrite);
 626     printf("\t%10u afs_rdwr\n", cmp->callInfo.C_afs_rdwr);
 627     printf("\t%10u FIXUPSTUPIDINODE\n", cmp->callInfo.C_FIXUPSTUPIDINODE);
 628     printf("\t%10u afs_read\n", cmp->callInfo.C_afs_read);
 629     printf("\t%10u afs_UFSread\n", cmp->callInfo.C_afs_UFSRead);
 630     printf("\t%10u afs_Memread\n", cmp->callInfo.C_afs_MemRead);
 631     printf("\t%10u afs_CopyOutAttrs\n", cmp->callInfo.C_afs_CopyOutAttrs);
 632     printf("\t%10u ENameOK\n", cmp->callInfo.C_ENameOK);
 633     printf("\t%10u HandleAtName\n", cmp->callInfo.C_HandleAtName);
 634     printf("\t%10u getsysname\n", cmp->callInfo.C_getsysname);
 635     printf("\t%10u strcat\n", cmp->callInfo.C_strcat);
 636     printf("\t%10u afs_access\n", cmp->callInfo.C_afs_access);
 637     printf("\t%10u afs_getattr\n", cmp->callInfo.C_afs_getattr);
 638     printf("\t%10u afs_setattr\n", cmp->callInfo.C_afs_setattr);
 639     printf("\t%10u afs_VAttrToAS\n", cmp->callInfo.C_afs_VAttrToAS);
 640     printf("\t%10u EvalMountPoint\n", cmp->callInfo.C_EvalMountPoint);
 641     printf("\t%10u afs_lookup\n", cmp->callInfo.C_afs_lookup);
 642     printf("\t%10u afs_create\n", cmp->callInfo.C_afs_create);
 643     printf("\t%10u FetchWholeEnchilada\n",
 644            cmp->callInfo.C_FetchWholeEnchilada);
 645     printf("\t%10u afs_LocalHero\n", cmp->callInfo.C_afs_LocalHero);
 646     printf("\t%10u afs_remove\n", cmp->callInfo.C_afs_remove);
 647     printf("\t%10u afs_link\n", cmp->callInfo.C_afs_link);
 648     printf("\t%10u afs_rename\n", cmp->callInfo.C_afs_rename);
 649     printf("\t%10u afs_InitReq\n", cmp->callInfo.C_afs_InitReq);
 650     printf("\t%10u BlobScan\n", cmp->callInfo.C_BlobScan);
 651     printf("\t%10u afs_mkdir\n", cmp->callInfo.C_afs_mkdir);
 652     printf("\t%10u RecLen\n", cmp->callInfo.C_RecLen);
 653     printf("\t%10u RoundToInt\n", cmp->callInfo.C_RoundToInt);
 654     printf("\t%10u afs_readdir_with_offlist\n",
 655            cmp->callInfo.C_afs_readdir_with_offlist);
 656     printf("\t%10u DIRSIZ_LEN\n", cmp->callInfo.C_DIRSIZ_LEN);
 657     printf("\t%10u afs_rmdir\n", cmp->callInfo.C_afs_rmdir);
 658     printf("\t%10u afs_readdir\n", cmp->callInfo.C_afs_readdir);
 659     printf("\t%10u afs_read1dir\n", cmp->callInfo.C_afs_read1dir);
 660     printf("\t%10u afs_readdir_move\n", cmp->callInfo.C_afs_readdir_move);
 661     printf("\t%10u afs_readdir_iter\n", cmp->callInfo.C_afs_readdir_iter);
 662     printf("\t%10u afs_symlink\n", cmp->callInfo.C_afs_symlink);
 663     printf("\t%10u afs_HandleLink\n", cmp->callInfo.C_afs_HandleLink);
 664     printf("\t%10u afs_MemHandleLink\n", cmp->callInfo.C_afs_MemHandleLink);
 665     printf("\t%10u afs_UFSHandleLink\n", cmp->callInfo.C_afs_UFSHandleLink);
 666     printf("\t%10u HandleFlock\n", cmp->callInfo.C_HandleFlock);
 667     printf("\t%10u afs_readlink\n", cmp->callInfo.C_afs_readlink);
 668     printf("\t%10u afs_fsync\n", cmp->callInfo.C_afs_fsync);
 669     printf("\t%10u afs_inactive\n", cmp->callInfo.C_afs_inactive);
 670     printf("\t%10u afs_ustrategy\n", cmp->callInfo.C_afs_ustrategy);
 671     printf("\t%10u afs_strategy\n", cmp->callInfo.C_afs_strategy);
 672     printf("\t%10u afs_bread\n", cmp->callInfo.C_afs_bread);
 673     printf("\t%10u afs_brelse\n", cmp->callInfo.C_afs_brelse);
 674     printf("\t%10u afs_bmap\n", cmp->callInfo.C_afs_bmap);
 675     printf("\t%10u afs_fid\n", cmp->callInfo.C_afs_fid);
 676     printf("\t%10u afs_FakeOpen\n", cmp->callInfo.C_afs_FakeOpen);
 677     printf("\t%10u afs_FakeClose\n", cmp->callInfo.C_afs_FakeClose);
 678     printf("\t%10u afs_StoreOnLastReference\n",
 679            cmp->callInfo.C_afs_StoreOnLastReference);
 680     printf("\t%10u shutdown_vnodeops\n", cmp->callInfo.C_shutdown_vnodeops);
 681     printf("\t%10u afs_AccessOK\n", cmp->callInfo.C_afs_AccessOK);
 682     printf("\t%10u afs_GetAccessBits\n", cmp->callInfo.C_afs_GetAccessBits);
 683     printf("\t%10u afsio_copy\n", cmp->callInfo.C_afsio_copy);
 684     printf("\t%10u afsio_trim\n", cmp->callInfo.C_afsio_trim);
 685     printf("\t%10u afsio_skip\n", cmp->callInfo.C_afsio_skip);
 686     printf("\t%10u afs_page_read\n", cmp->callInfo.C_afs_page_read);
 687     printf("\t%10u afs_page_write\n", cmp->callInfo.C_afs_page_write);
 688     printf("\t%10u afs_page_read\n", cmp->callInfo.C_afs_page_read);
 689     printf("\t%10u afs_get_groups_from_pag\n",
 690            cmp->callInfo.C_afs_get_groups_from_pag);
 691     printf("\t%10u afs_get_pag_from_groups\n",
 692            cmp->callInfo.C_afs_get_pag_from_groups);
 693     printf("\t%10u AddPag\n", cmp->callInfo.C_AddPag);
 694     printf("\t%10u PagInCred\n", cmp->callInfo.C_PagInCred);
 695     printf("\t%10u setpag\n", cmp->callInfo.C_setpag);
 696     printf("\t%10u afs_setgroups\n", cmp->callInfo.C_afs_setgroups);
 697     printf("\t%10u afs_getgroups\n", cmp->callInfo.C_afs_getgroups);
 698     printf("\t%10u afs_page_in\n", cmp->callInfo.C_afs_page_in);
 699     printf("\t%10u afs_page_out\n", cmp->callInfo.C_afs_page_out);
 700     printf("\t%10u afs_AdvanceFD\n", cmp->callInfo.C_afs_AdvanceFD);
 701     printf("\t%10u afs_lockf\n", cmp->callInfo.C_afs_lockf);
 702     printf("\t%10u afs_xsetgroups\n", cmp->callInfo.C_afs_xsetgroups);
 703     printf("\t%10u DoLockWarning\n", cmp->callInfo.C_DoLockWarning);
 704     printf("\t%10u afs_nlinks\n", cmp->callInfo.C_afs_nlinks);
 705     printf("\t%10u afs_lockctl\n", cmp->callInfo.C_afs_lockctl);
 706     printf("\t%10u afs_xflock\n", cmp->callInfo.C_afs_xflock);
 707     printf("\t%10u PGetCPrefs\n", cmp->callInfo.C_PGetCPrefs);
 708     printf("\t%10u SRXAFSCB_WhoAreYou\n",
 709            cmp->callInfo.C_SRXAFSCB_WhoAreYou);
 710     printf("\t%10u afs_DiscardDCache\n", cmp->callInfo.C_afs_DiscardDCache);
 711     printf("\t%10u afs_FreeDiscardedDCache\n",
 712            cmp->callInfo.C_afs_FreeDiscardedDCache);
 713     printf("\t%10u afs_MaybeFreeDiscardedDCache\n",
 714            cmp->callInfo.C_afs_MaybeFreeDiscardedDCache);
 715     printf("\t%10u PSetCPrefs\n", cmp->callInfo.C_PSetCPrefs);
 716     printf("\t%10u afs_pagein\n", cmp->callInfo.C_afs_pagein);
 717     printf("\t%10u afs_pageout\n", cmp->callInfo.C_afs_pageout);
 718     printf("\t%10u afs_hp_strategy\n", cmp->callInfo.C_afs_hp_strategy);
 719     printf("\t%10u PFlushMount\n", cmp->callInfo.C_PFlushMount);
 720     printf("\t%10u SRXAFSCB_GetServerPrefs\n",
 721            cmp->callInfo.C_SRXAFSCB_GetServerPrefs);
 722     printf("\t%10u SRXAFSCB_GetCellServDB\n",
 723            cmp->callInfo.C_SRXAFSCB_GetCellServDB);
 724     printf("\t%10u SRXAFSCB_GetLocalCell\n",
 725            cmp->callInfo.C_SRXAFSCB_GetLocalCell);
 726     printf("\t%10u afs_MarshallCacheConfig\n",
 727            cmp->callInfo.C_afs_MarshallCacheConfig);
 728     printf("\t%10u SRXAFSCB_GetCacheConfig\n",
 729            cmp->callInfo.C_SRXAFSCB_GetCacheConfig);
 730     printf("\t%10u SRXAFSCB_GetCE64\n", cmp->callInfo.C_SRXAFSCB_GetCE64);
 731     printf("\t%10u SRXAFSCB_GetCellByNum\n",
 732            cmp->callInfo.C_SRXAFSCB_GetCellByNum);
 733     printf("\t%10u BPrefetchNoCache\n", cmp->callInfo.C_BPrefetchNoCache);
 734     printf("\t%10u PSetTokens2\n", cmp->callInfo.C_PSetTokens2);
 735     printf("\t%10u PPrefetchFromTape\n", cmp->callInfo.C_PPrefetchFromTape);
 736     printf("\t%10u afs_ReadNoCache\n", cmp->callInfo.C_afs_ReadNoCache);
 737 }
 738
 739
 740 /*------------------------------------------------------------------------
 741  * PrintUpDownStats
 742  *
 743  * Description:
 744  *      Print the up/downtime stats for the given class of server records
 745  *      provided.
 746  *
 747  * Arguments:
 748  *      a_upDownP : Ptr to the server up/down info.
 749  *
 750  * Returns:
 751  *      Nothing.
 752  *
 753  * Environment:
 754  *      Nothing interesting.
 755  *
 756  * Side Effects:
 757  *      As advertised.
 758  *------------------------------------------------------------------------*/
 759
 760 void
 761 PrintUpDownStats(struct afs_stats_SrvUpDownInfo *a_upDownP)
 762 {                               /*PrintUpDownStats */
 763
 764     /*
 765      * First, print the simple values.
 766      */
 767     printf("\t\t%10u numTtlRecords\n", a_upDownP->numTtlRecords);
 768     printf("\t\t%10u numUpRecords\n", a_upDownP->numUpRecords);
 769     printf("\t\t%10u numDownRecords\n", a_upDownP->numDownRecords);
 770     printf("\t\t%10u sumOfRecordAges\n", a_upDownP->sumOfRecordAges);
 771     printf("\t\t%10u ageOfYoungestRecord\n", a_upDownP->ageOfYoungestRecord);
 772     printf("\t\t%10u ageOfOldestRecord\n", a_upDownP->ageOfOldestRecord);
 773     printf("\t\t%10u numDowntimeIncidents\n",
 774            a_upDownP->numDowntimeIncidents);
 775     printf("\t\t%10u numRecordsNeverDown\n", a_upDownP->numRecordsNeverDown);
 776     printf("\t\t%10u maxDowntimesInARecord\n",
 777            a_upDownP->maxDowntimesInARecord);
 778     printf("\t\t%10u sumOfDowntimes\n", a_upDownP->sumOfDowntimes);
 779     printf("\t\t%10u shortestDowntime\n", a_upDownP->shortestDowntime);
 780     printf("\t\t%10u longestDowntime\n", a_upDownP->longestDowntime);
 781
 782     /*
 783      * Now, print the array values.
 784      */
 785     printf("\t\tDowntime duration distribution:\n");
 786     printf("\t\t\t%8u: 0 min .. 10 min\n", a_upDownP->downDurations[0]);
 787     printf("\t\t\t%8u: 10 min .. 30 min\n", a_upDownP->downDurations[1]);
 788     printf("\t\t\t%8u: 30 min .. 1 hr\n", a_upDownP->downDurations[2]);
 789     printf("\t\t\t%8u: 1 hr .. 2 hr\n", a_upDownP->downDurations[3]);
 790     printf("\t\t\t%8u: 2 hr .. 4 hr\n", a_upDownP->downDurations[4]);
 791     printf("\t\t\t%8u: 4 hr .. 8 hr\n", a_upDownP->downDurations[5]);
 792     printf("\t\t\t%8u: > 8 hr\n", a_upDownP->downDurations[6]);
 793
 794     printf("\t\tDowntime incident distribution:\n");
 795     printf("\t\t\t%8u: 0 times\n", a_upDownP->downIncidents[0]);
 796     printf("\t\t\t%8u: 1 time\n", a_upDownP->downIncidents[1]);
 797     printf("\t\t\t%8u: 2 .. 5 times\n", a_upDownP->downIncidents[2]);
 798     printf("\t\t\t%8u: 6 .. 10 times\n", a_upDownP->downIncidents[3]);
 799     printf("\t\t\t%8u: 10 .. 50 times\n", a_upDownP->downIncidents[4]);
 800     printf("\t\t\t%8u: > 50 times\n", a_upDownP->downIncidents[5]);
 801
 802 }                               /*PrintUpDownStats */
 803
 804
 805 /*------------------------------------------------------------------------
 806  * PrintOverallPerfInfo
 807  *
 808  * Description:
 809  *      Print out overall performance numbers.
 810  *
 811  * Arguments:
 812  *      a_ovP : Ptr to the overall performance numbers.
 813  *
 814  * Returns:
 815  *      Nothing.
 816  *
 817  * Environment:
 818  *      All the info we need is nestled into xstat_cm_Results.
 819  *
 820  * Side Effects:
 821  *      As advertised.
 822  *------------------------------------------------------------------------*/
 823
 824 void
 825 PrintOverallPerfInfo(struct afs_stats_CMPerf *a_ovP)
 826 {                               /*PrintOverallPerfInfo */
 827
 828     printf("\t%10u numPerfCalls\n", a_ovP->numPerfCalls);
 829
 830     printf("\t%10u epoch\n", a_ovP->epoch);
 831     printf("\t%10u numCellsVisible\n", a_ovP->numCellsVisible);
 832     printf("\t%10u numCellsContacted\n", a_ovP->numCellsContacted);
 833     printf("\t%10u dlocalAccesses\n", a_ovP->dlocalAccesses);
 834     printf("\t%10u vlocalAccesses\n", a_ovP->vlocalAccesses);
 835     printf("\t%10u dremoteAccesses\n", a_ovP->dremoteAccesses);
 836     printf("\t%10u vremoteAccesses\n", a_ovP->vremoteAccesses);
 837     printf("\t%10u cacheNumEntries\n", a_ovP->cacheNumEntries);
 838     printf("\t%10u cacheBlocksTotal\n", a_ovP->cacheBlocksTotal);
 839     printf("\t%10u cacheBlocksInUse\n", a_ovP->cacheBlocksInUse);
 840     printf("\t%10u cacheBlocksOrig\n", a_ovP->cacheBlocksOrig);
 841     printf("\t%10u cacheMaxDirtyChunks\n", a_ovP->cacheMaxDirtyChunks);
 842     printf("\t%10u cacheCurrDirtyChunks\n", a_ovP->cacheCurrDirtyChunks);
 843     printf("\t%10u dcacheHits\n", a_ovP->dcacheHits);
 844     printf("\t%10u vcacheHits\n", a_ovP->vcacheHits);
 845     printf("\t%10u dcacheMisses\n", a_ovP->dcacheMisses);
 846     printf("\t%10u vcacheMisses\n", a_ovP->vcacheMisses);
 847     printf("\t%10u cacheFilesReused\n", a_ovP->cacheFilesReused);
 848     printf("\t%10u vcacheXAllocs\n", a_ovP->vcacheXAllocs);
 849     printf("\t%10u dcacheXAllocs\n", a_ovP->dcacheXAllocs);
 850
 851     printf("\t%10u bufAlloced\n", a_ovP->bufAlloced);
 852     printf("\t%10u bufHits\n", a_ovP->bufHits);
 853     printf("\t%10u bufMisses\n", a_ovP->bufMisses);
 854     printf("\t%10u bufFlushDirty\n", a_ovP->bufFlushDirty);
 855
 856     printf("\t%10u LargeBlocksActive\n", a_ovP->LargeBlocksActive);
 857     printf("\t%10u LargeBlocksAlloced\n", a_ovP->LargeBlocksAlloced);
 858     printf("\t%10u SmallBlocksActive\n", a_ovP->SmallBlocksActive);
 859     printf("\t%10u SmallBlocksAlloced\n", a_ovP->SmallBlocksAlloced);
 860     printf("\t%10u OutStandingMemUsage\n", a_ovP->OutStandingMemUsage);
 861     printf("\t%10u OutStandingAllocs\n", a_ovP->OutStandingAllocs);
 862     printf("\t%10u CallBackAlloced\n", a_ovP->CallBackAlloced);
 863     printf("\t%10u CallBackFlushes\n", a_ovP->CallBackFlushes);
 864     printf("\t%10u CallBackLoops\n", a_ovP->cbloops);
 865
 866     printf("\t%10u srvRecords\n", a_ovP->srvRecords);
 867     printf("\t%10u srvNumBuckets\n", a_ovP->srvNumBuckets);
 868     printf("\t%10u srvMaxChainLength\n", a_ovP->srvMaxChainLength);
 869     printf("\t%10u srvMaxChainLengthHWM\n", a_ovP->srvMaxChainLengthHWM);
 870     printf("\t%10u srvRecordsHWM\n", a_ovP->srvRecordsHWM);
 871
 872     printf("\t%10u cacheBucket0_Discarded\n",  a_ovP->cacheBucket0_Discarded);
 873     printf("\t%10u cacheBucket1_Discarded\n",  a_ovP->cacheBucket1_Discarded);
 874     printf("\t%10u cacheBucket2_Discarded\n",  a_ovP->cacheBucket2_Discarded);
 875
 876     printf("\t%10u sysName_ID\n", a_ovP->sysName_ID);
 877
 878     printf("\tFile Server up/downtimes, same cell:\n");
 879     PrintUpDownStats(&(a_ovP->fs_UpDown[0]));
 880
 881     printf("\tFile Server up/downtimes, diff cell:\n");
 882     PrintUpDownStats(&(a_ovP->fs_UpDown[1]));
 883
 884     printf("\tVL Server up/downtimes, same cell:\n");
 885     PrintUpDownStats(&(a_ovP->vl_UpDown[0]));
 886
 887     printf("\tVL Server up/downtimes, diff cell:\n");
 888     PrintUpDownStats(&(a_ovP->vl_UpDown[1]));
 889
 890 }                               /*PrintOverallPerfInfo */
 891
 892
 893 /*------------------------------------------------------------------------
 894  * PrintPerfInfo
 895  *
 896  * Description:
 897  *      Print out the AFSCB_XSTATSCOLL_PERF_INFO collection we just
 898  *      received.
 899  *
 900  * Arguments:
 901  *      None.
 902  *
 903  * Returns:
 904  *      Nothing.
 905  *
 906  * Environment:
 907  *      All the info we need is nestled into xstat_cm_Results.
 908  *
 909  * Side Effects:
 910  *      As advertised.
 911  *------------------------------------------------------------------------*/
 912
 913 void
 914 PrintPerfInfo(void)
 915 {                               /*PrintPerfInfo */
 916
 917     static afs_int32 perfInt32s = (sizeof(struct afs_stats_CMPerf) >> 2);       /*Correct # int32s to rcv */
 918     afs_int32 numInt32s;        /*# int32words received */
 919     struct afs_stats_CMPerf *perfP;     /*Ptr to performance stats */
 920     char *printableTime;        /*Ptr to printable time string */
 921     time_t probeTime = xstat_cm_Results.probeTime;
 922
 923     numInt32s = xstat_cm_Results.data.AFSCB_CollData_len;
 924     if (numInt32s != perfInt32s) {
 925         printf("** Data size mismatch in performance collection!");
 926         printf("** Expecting %u, got %u\n", perfInt32s, numInt32s);
 927         printf("** Version mismatch with Cache Manager\n");
 928         return;
 929     }
 930
 931     printableTime = ctime(&probeTime);
 932     printableTime[strlen(printableTime) - 1] = '\0';
 933     perfP = (struct afs_stats_CMPerf *)
 934         (xstat_cm_Results.data.AFSCB_CollData_val);
 935
 936     printf
 937         ("AFSCB_XSTATSCOLL_PERF_INFO (coll %d) for CM %s\n[Probe %u, %s]\n\n",
 938          xstat_cm_Results.collectionNumber, xstat_cm_Results.connP->hostName,
 939          xstat_cm_Results.probeNum, printableTime);
 940
 941     PrintOverallPerfInfo(perfP);
 942
 943 }                               /*PrintPerfInfo */
 944
 945
 946 /*------------------------------------------------------------------------
 947  * PrintOpTiming
 948  *
 949  * Description:
 950  *      Print out the contents of an FS RPC op timing structure.
 951  *
 952  * Arguments:
 953  *      a_opIdx   : Index of the AFS operation we're printing number on.
 954  *      a_opNames : Ptr to table of operaton names.
 955  *      a_opTimeP : Ptr to the op timing structure to print.
 956  *
 957  * Returns:
 958  *      Nothing.
 959  *
 960  * Environment:
 961  *      Nothing interesting.
 962  *
 963  * Side Effects:
 964  *      As advertised.
 965  *------------------------------------------------------------------------*/
 966
 967 void
 968 PrintOpTiming(int a_opIdx, char *a_opNames[],
 969               struct afs_stats_opTimingData *a_opTimeP)
 970 {                               /*PrintOpTiming */
 971
 972     printf
 973         ("%15s: %u ops (%u OK); sum=%lu.%06lu, sqr=%lu.%06lu, min=%lu.%06lu, max=%lu.%06lu\n",
 974          a_opNames[a_opIdx], a_opTimeP->numOps, a_opTimeP->numSuccesses,
 975          (long)a_opTimeP->sumTime.tv_sec, (long)a_opTimeP->sumTime.tv_usec,
 976          (long)a_opTimeP->sqrTime.tv_sec, (long)a_opTimeP->sqrTime.tv_usec,
 977          (long)a_opTimeP->minTime.tv_sec, (long)a_opTimeP->minTime.tv_usec,
 978          (long)a_opTimeP->maxTime.tv_sec, (long)a_opTimeP->maxTime.tv_usec);
 979
 980 }                               /*PrintOpTiming */
 981
 982
 983 /*------------------------------------------------------------------------
 984  * PrintXferTiming
 985  *
 986  * Description:
 987  *      Print out the contents of a data transfer structure.
 988  *
 989  * Arguments:
 990  *      a_opIdx : Index of the AFS operation we're printing number on.
 991  *      a_opNames : Ptr to table of operation names.
 992  *      a_xferP : Ptr to the data transfer structure to print.
 993  *
 994  * Returns:
 995  *      Nothing.
 996  *
 997  * Environment:
 998  *      Nothing interesting.
 999  *
1000  * Side Effects:
1001  *      As advertised.
1002  *------------------------------------------------------------------------*/
1003
1004 void
1005 PrintXferTiming(int a_opIdx, char *a_opNames[],
1006                 struct afs_stats_xferData *a_xferP)
1007 {                               /*PrintXferTiming */
1008
1009     printf
1010         ("%s: %u xfers (%u OK), time sum=%lu.%06lu, sqr=%lu.%06lu, min=%lu.%06lu, max=%lu.%06lu\n",
1011          a_opNames[a_opIdx], a_xferP->numXfers, a_xferP->numSuccesses,
1012          (long)a_xferP->sumTime.tv_sec, (long)a_xferP->sumTime.tv_usec,
1013          (long)a_xferP->sqrTime.tv_sec, (long)a_xferP->sqrTime.tv_usec,
1014          (long)a_xferP->minTime.tv_sec, (long)a_xferP->minTime.tv_usec,
1015          (long)a_xferP->maxTime.tv_sec, (long)a_xferP->maxTime.tv_usec);
1016     printf("\t[bytes: sum=%u, min=%u, max=%u]\n", a_xferP->sumBytes,
1017            a_xferP->minBytes, a_xferP->maxBytes);
1018     printf
1019         ("\t[buckets: 0: %u, 1: %u, 2: %u, 3: %u, 4: %u, 5: %u, 6: %u, 7: %u, 8: %u]\n",
1020          a_xferP->count[0], a_xferP->count[1], a_xferP->count[2],
1021          a_xferP->count[3], a_xferP->count[4], a_xferP->count[5],
1022          a_xferP->count[6], a_xferP->count[7], a_xferP->count[8]);
1023
1024
1025 }                               /*PrintXferTiming */
1026
1027
1028 /*------------------------------------------------------------------------
1029  * PrintErrInfo
1030  *
1031  * Description:
1032  *      Print out the contents of an FS RPC error info structure.
1033  *
1034  * Arguments:
1035  *      a_opIdx   : Index of the AFS operation we're printing.
1036  *      a_opNames : Ptr to table of operation names.
1037  *      a_opErrP  : Ptr to the op timing structure to print.
1038  *
1039  * Returns:
1040  *      Nothing.
1041  *
1042  * Environment:
1043  *      Nothing interesting.
1044  *
1045  * Side Effects:
1046  *      As advertised.
1047  *------------------------------------------------------------------------*/
1048
1049 void
1050 PrintErrInfo(int a_opIdx, char *a_opNames[],
1051              struct afs_stats_RPCErrors *a_opErrP)
1052 {                               /*PrintErrInfo */
1053
1054     printf
1055         ("%15s: %u server, %u network, %u prot, %u vol, %u busies, %u other\n",
1056          a_opNames[a_opIdx], a_opErrP->err_Server, a_opErrP->err_Network,
1057          a_opErrP->err_Protection, a_opErrP->err_Volume,
1058          a_opErrP->err_VolumeBusies, a_opErrP->err_Other);
1059
1060 }                               /*PrintErrInfo */
1061
1062
1063 /*------------------------------------------------------------------------
1064  * PrintRPCPerfInfo
1065  *
1066  * Description:
1067  *      Print out a set of RPC performance numbers.
1068  *
1069  * Arguments:
1070  *      a_rpcP : Ptr to RPC perf numbers to print.
1071  *
1072  * Returns:
1073  *      Nothing.
1074  *
1075  * Environment:
1076  *      Nothing interesting.
1077  *
1078  * Side Effects:
1079  *      As advertised.
1080  *------------------------------------------------------------------------*/
1081
1082 void
1083 PrintRPCPerfInfo(struct afs_stats_RPCOpInfo *a_rpcP)
1084 {                               /*PrintRPCPerfInfo */
1085
1086     int currIdx;                /*Loop variable */
1087
1088     /*
1089      * Print the contents of each of the opcode-related arrays.
1090      */
1091     printf("FS Operation Timings:\n---------------------\n");
1092     for (currIdx = 0; currIdx < AFS_STATS_NUM_FS_RPC_OPS; currIdx++)
1093         PrintOpTiming(currIdx, fsOpNames, &(a_rpcP->fsRPCTimes[currIdx]));
1094
1095     printf("\nError Info:\n-----------\n");
1096     for (currIdx = 0; currIdx < AFS_STATS_NUM_FS_RPC_OPS; currIdx++)
1097         PrintErrInfo(currIdx, fsOpNames, &(a_rpcP->fsRPCErrors[currIdx]));
1098
1099     printf("\nTransfer timings:\n-----------------\n");
1100     for (currIdx = 0; currIdx < AFS_STATS_NUM_FS_XFER_OPS; currIdx++)
1101         PrintXferTiming(currIdx, xferOpNames,
1102                         &(a_rpcP->fsXferTimes[currIdx]));
1103
1104     printf("\nCM Operation Timings:\n---------------------\n");
1105     for (currIdx = 0; currIdx < AFS_STATS_NUM_CM_RPC_OPS; currIdx++)
1106         PrintOpTiming(currIdx, cmOpNames, &(a_rpcP->cmRPCTimes[currIdx]));
1107
1108 }                               /*PrintRPCPerfInfo */
1109
1110
1111 /*------------------------------------------------------------------------
1112  * PrintFullPerfInfo
1113  *
1114  * Description:
1115  *      Print out a set of full performance numbers.
1116  *
1117  * Arguments:
1118  *      None.
1119  *
1120  * Returns:
1121  *      Nothing.
1122  *
1123  * Environment:
1124  *      Nothing interesting.
1125  *
1126  * Side Effects:
1127  *      As advertised.
1128  *------------------------------------------------------------------------*/
1129
1130 void
1131 PrintFullPerfInfo(void)
1132 {                               /*PrintFullPerfInfo */
1133
1134     struct afs_stats_AuthentInfo *authentP;     /*Ptr to authentication stats */
1135     struct afs_stats_AccessInfo *accessinfP;    /*Ptr to access stats */
1136     static afs_int32 fullPerfInt32s = (sizeof(struct afs_stats_CMFullPerf) >> 2);       /*Correct #int32s */
1137     afs_int32 numInt32s;        /*# int32s actually received */
1138     struct afs_stats_CMFullPerf *fullP; /*Ptr to full perf info */
1139
1140     char *printableTime;        /*Ptr to printable time string */
1141     time_t probeTime = xstat_cm_Results.probeTime;
1142
1143     numInt32s = xstat_cm_Results.data.AFSCB_CollData_len;
1144     if (numInt32s != fullPerfInt32s) {
1145         printf("** Data size mismatch in performance collection!");
1146         printf("** Expecting %u, got %u\n", fullPerfInt32s, numInt32s);
1147         printf("** Version mismatch with Cache Manager\n");
1148         return;
1149     }
1150
1151     printableTime = ctime(&probeTime);
1152     printableTime[strlen(printableTime) - 1] = '\0';
1153     fullP = (struct afs_stats_CMFullPerf *)
1154         (xstat_cm_Results.data.AFSCB_CollData_val);
1155
1156     printf
1157         ("AFSCB_XSTATSCOLL_FULL_PERF_INFO (coll %d) for CM %s\n[Probe %u, %s]\n\n",
1158          xstat_cm_Results.collectionNumber, xstat_cm_Results.connP->hostName,
1159          xstat_cm_Results.probeNum, printableTime);
1160
1161     /*
1162      * Print the overall numbers first, followed by all of the RPC numbers,
1163      * then each of the other groupings.
1164      */
1165     printf("Overall Performance Info:\n-------------------------\n");
1166     PrintOverallPerfInfo(&(fullP->perf));
1167     printf("\n");
1168     PrintRPCPerfInfo(&(fullP->rpc));
1169
1170     authentP = &(fullP->authent);
1171     printf("\nAuthentication info:\n--------------------\n");
1172     printf
1173         ("\t%u PAGS, %u records (%u auth, %u unauth), %u max in PAG, chain max: %u\n",
1174          authentP->curr_PAGs, authentP->curr_Records,
1175          authentP->curr_AuthRecords, authentP->curr_UnauthRecords,
1176          authentP->curr_MaxRecordsInPAG, authentP->curr_LongestChain);
1177     printf("\t%u PAG creations, %u tkt updates\n", authentP->PAGCreations,
1178            authentP->TicketUpdates);
1179     printf("\t[HWMs: %u PAGS, %u records, %u max in PAG, chain max: %u]\n",
1180            authentP->HWM_PAGs, authentP->HWM_Records,
1181            authentP->HWM_MaxRecordsInPAG, authentP->HWM_LongestChain);
1182
1183     accessinfP = &(fullP->accessinf);
1184     printf("\n[Un]replicated accesses:\n------------------------\n");
1185     printf
1186         ("\t%u unrep, %u rep, %u reps accessed, %u max reps/ref, %u first OK\n\n",
1187          accessinfP->unreplicatedRefs, accessinfP->replicatedRefs,
1188          accessinfP->numReplicasAccessed, accessinfP->maxReplicasPerRef,
1189          accessinfP->refFirstReplicaOK);
1190
1191     /* There really isn't any authorship info
1192      * authorP = &(fullP->author); */
1193
1194 }                               /*PrintFullPerfInfo */
1195
1196
1197 /*------------------------------------------------------------------------
1198  * CM_Handler
1199  *
1200  * Description:
1201  *      Handler routine passed to the xstat_cm module.  This handler is
1202  *      called immediately after a poll of one of the Cache Managers has
1203  *      taken place.  All it needs to know is exported by the xstat_cm
1204  *      module, namely the data structure where the probe results are
1205  *      stored.
1206  *
1207  * Arguments:
1208  *      None.
1209  *
1210  * Returns:
1211  *      0 on success,
1212  *      -1 otherwise.
1213  *
1214  * Environment:
1215  *      See above.  All we do now is print out what we got.
1216  *
1217  * Side Effects:
1218  *      As advertised.
1219  *------------------------------------------------------------------------*/
1220
1221 int
1222 CM_Handler(void)
1223 {                               /*CM_Handler */
1224
1225     static char rn[] = "CM_Handler";    /*Routine name */
1226
1227     printf("\n-----------------------------------------------------------\n");
1228
1229     /*
1230      * If the probe failed, there isn't much we can do except gripe.
1231      */
1232     if (xstat_cm_Results.probeOK) {
1233         printf("%s: Probe %u, collection %d to CM on '%s' failed, code=%d\n",
1234                rn, xstat_cm_Results.probeNum,
1235                xstat_cm_Results.collectionNumber,
1236                xstat_cm_Results.connP->hostName, xstat_cm_Results.probeOK);
1237         return (0);
1238     }
1239
1240     if (debugging_on) {
1241         int i;
1242         int numInt32s = xstat_cm_Results.data.AFSCB_CollData_len;
1243         afs_int32 *entry = xstat_cm_Results.data.AFSCB_CollData_val;
1244
1245         printf("debug: got collection number %d\n", xstat_cm_Results.collectionNumber);
1246         printf("debug: collection data length is %d\n", numInt32s);
1247         for (i = 0; i < numInt32s; i++) {
1248             printf("debug: entry %d %u\n", i, entry[i]);
1249         }
1250         printf("\n");
1251     }
1252
1253     switch (xstat_cm_Results.collectionNumber) {
1254     case AFSCB_XSTATSCOLL_CALL_INFO:
1255         print_cmCallStats();
1256         break;
1257
1258     case AFSCB_XSTATSCOLL_PERF_INFO:
1259         /* we will do nothing here */
1260         /* PrintPerfInfo(); */
1261         break;
1262
1263     case AFSCB_XSTATSCOLL_FULL_PERF_INFO:
1264         PrintFullPerfInfo();
1265         break;
1266
1267     default:
1268         printf("** Unknown collection: %d\n",
1269                xstat_cm_Results.collectionNumber);
1270     }
1271
1272     /*
1273      * Return the happy news.
1274      */
1275     return (0);
1276
1277 }                               /*CM_Handler */
1278
1279
1280 /*------------------------------------------------------------------------
1281  * CountListItems
1282  *
1283  * Description:
1284  *      Given a pointer to the list of Cache Managers we'll be polling
1285  *      (or, in fact, any list at all), compute the length of the list.
1286  *
1287  * Arguments:
1288  *      struct cmd_item *a_firstItem : Ptr to first item in list.
1289  *
1290  * Returns:
1291  *      Length of the above list.
1292  *
1293  * Environment:
1294  *      Nothing interesting.
1295  *
1296  * Side Effects:
1297  *      As advertised.
1298  *------------------------------------------------------------------------*/
1299
1300 static int
1301 CountListItems(struct cmd_item *a_firstItem)
1302 {                               /*CountListItems */
1303
1304     int list_len;               /*List length */
1305     struct cmd_item *curr_item; /*Ptr to current item */
1306
1307     list_len = 0;
1308     curr_item = a_firstItem;
1309
1310     /*
1311      * Count 'em up.
1312      */
1313     while (curr_item) {
1314         list_len++;
1315         curr_item = curr_item->next;
1316     }
1317
1318     /*
1319      * Return our tally.
1320      */
1321     return (list_len);
1322
1323 }                               /*CountListItems */
1324
1325
1326 /*------------------------------------------------------------------------
1327  * RunTheTest
1328  *
1329  * Description:
1330  *      Routine called by the command line interpreter to execute the
1331  *      meat of the program.  We count the number of Cache Managers
1332  *      to watch, allocate enough space to remember all the connection
1333  *      info for them, then go for it.
1334  *
1335  *
1336  * Arguments:
1337  *      a_s : Ptr to the command line syntax descriptor.
1338  *
1339  * Returns:
1340  *      0, but may exit the whole program on an error!
1341  *
1342  * Environment:
1343  *      Nothing interesting.
1344  *
1345  * Side Effects:
1346  *      As advertised.
1347  *------------------------------------------------------------------------*/
1348
1349 int
1350 RunTheTest(struct cmd_syndesc *a_s, void *arock)
1351 {                               /*RunTheTest */
1352
1353     static char rn[] = "RunTheTest";    /*Routine name */
1354     int code;                   /*Return code */
1355     int numCMs;                 /*# Cache Managers to monitor */
1356     int numCollIDs;             /*# collections to fetch */
1357     int currCM;                 /*Loop index */
1358     int currCollIDIdx;          /*Index of current collection ID */
1359     afs_int32 *collIDP;         /*Ptr to array of collection IDs */
1360     afs_int32 *currCollIDP;     /*Ptr to current collection ID */
1361     struct cmd_item *curr_item; /*Current CM cmd line record */
1362     struct sockaddr_in *CMSktArray;     /*Cache Manager socket array */
1363     struct hostent *he;         /*Host entry */
1364     struct timeval tv;          /*Time structure */
1365     int sleep_secs;             /*Number of seconds to sleep */
1366     int initFlags;              /*Flags passed to the init fcn */
1367     int waitCode;               /*Result of LWP_WaitProcess() */
1368     int freq;                   /*Frequency of polls */
1369     int period;                 /*Time in minutes of data collection */
1370
1371     /*
1372      * Are we doing one-shot measurements?
1373      */
1374     if (a_s->parms[P_ONESHOT].items != 0)
1375         one_shot = 1;
1376
1377     /*
1378      * Are we doing debugging output?
1379      */
1380     if (a_s->parms[P_DEBUG].items != 0)
1381         debugging_on = 1;
1382
1383     /*
1384      * Pull out the number of Cache Managers to watch and the number of
1385      * collections to get.
1386      */
1387     numCMs = CountListItems(a_s->parms[P_CM_NAMES].items);
1388     numCollIDs = CountListItems(a_s->parms[P_COLL_IDS].items);
1389
1390     /* Get the polling frequency */
1391     if (a_s->parms[P_FREQUENCY].items != 0)
1392         freq = atoi(a_s->parms[P_FREQUENCY].items->data);
1393     else
1394         freq = 30;              /* default to 30 seconds */
1395
1396     /* Get the time duration to run the tests */
1397     if (a_s->parms[P_PERIOD].items != 0)
1398         period = atoi(a_s->parms[P_PERIOD].items->data);
1399     else
1400         period = 10;            /* default to 10 minutes */
1401
1402     /*
1403      * Allocate the socket array.
1404      */
1405     if (debugging_on)
1406         printf("%s: Allocating socket array for %d Cache Manager(s)\n", rn,
1407                numCMs);
1408     CMSktArray = malloc(numCMs * sizeof(struct sockaddr_in));
1409     if (CMSktArray == (struct sockaddr_in *)0) {
1410         printf("%s: Can't allocate socket array for %d Cache Managers\n", rn,
1411                numCMs);
1412         exit(1);
1413     }
1414
1415     /*
1416      * Fill in the socket array for each of the Cache Managers listed.
1417      */
1418     curr_item = a_s->parms[P_CM_NAMES].items;
1419     for (currCM = 0; currCM < numCMs; currCM++) {
1420         CMSktArray[currCM].sin_family = AF_INET;
1421         CMSktArray[currCM].sin_port = htons(7001);      /* Cache Manager port */
1422         he = hostutil_GetHostByName(curr_item->data);
1423         if (he == NULL) {
1424             fprintf(stderr, "[%s] Can't get host info for '%s'\n", rn,
1425                     curr_item->data);
1426             exit(-1);
1427         }
1428         memcpy(&(CMSktArray[currCM].sin_addr.s_addr), he->h_addr, 4);
1429
1430         /*
1431          * Move to the next CM name.
1432          */
1433         curr_item = curr_item->next;
1434
1435     }                           /*Get socket info for each Cache Manager */
1436
1437     /*
1438      * Create and fill up the array of desired collection IDs.
1439      */
1440     if (debugging_on)
1441         printf("Allocating %d long(s) for coll ID\n", numCollIDs);
1442     collIDP = malloc(numCollIDs * sizeof(afs_int32));
1443     currCollIDP = collIDP;
1444     curr_item = a_s->parms[P_COLL_IDS].items;
1445     for (currCollIDIdx = 0; currCollIDIdx < numCollIDs; currCollIDIdx++) {
1446         *currCollIDP = (afs_int32) (atoi(curr_item->data));
1447         if (debugging_on)
1448             printf("CollID at index %d is %d\n", currCollIDIdx, *currCollIDP);
1449         curr_item = curr_item->next;
1450         currCollIDP++;
1451     };
1452
1453     /*
1454      * Crank up the Cache Manager prober, then sit back and have fun.
1455      */
1456     printf("\nStarting up the xstat_cm service, ");
1457     initFlags = 0;
1458     if (debugging_on) {
1459         initFlags |= XSTAT_CM_INITFLAG_DEBUGGING;
1460         printf("debugging enabled, ");
1461     } else
1462         printf("no debugging, ");
1463     if (one_shot) {
1464         initFlags |= XSTAT_CM_INITFLAG_ONE_SHOT;
1465         printf("one-shot operation\n");
1466     } else
1467         printf("continuous operation\n");
1468
1469     code = xstat_cm_Init(numCMs,        /*Num CMs */
1470                          CMSktArray,    /*File Server socket array */
1471                          freq,  /*Probe every 30 seconds */
1472                          CM_Handler,    /*Handler routine */
1473                          initFlags,     /*Initialization flags */
1474                          numCollIDs,    /*Number of collection IDs */
1475                          collIDP);      /*Ptr to collection ID array */
1476     if (code) {
1477         fprintf(stderr, "[%s] Error returned by xstat_cm_Init: %d\n", rn,
1478                 code);
1479         xstat_cm_Cleanup(1);    /*Get rid of malloc'ed structures */
1480         exit(-1);
1481     }
1482
1483     if (one_shot) {
1484         /*
1485          * One-shot operation; just wait for the collection to be done.
1486          */
1487         if (debugging_on)
1488             printf("[%s] Calling LWP_WaitProcess() on event %" AFS_PTR_FMT
1489                    "\n", rn, &terminationEvent);
1490         waitCode = LWP_WaitProcess(&terminationEvent);
1491         if (debugging_on)
1492             printf("[%s] Returned from LWP_WaitProcess()\n", rn);
1493         if (waitCode) {
1494             if (debugging_on)
1495                 fprintf(stderr,
1496                         "[%s] Error %d encountered by LWP_WaitProcess()\n",
1497                         rn, waitCode);
1498         }
1499     } else {
1500         /*
1501          * Continuous operation.
1502          */
1503         sleep_secs = 60 * period;       /*length of data collection */
1504         printf
1505             ("xstat_cm service started, main thread sleeping for %d secs.\n",
1506              sleep_secs);
1507
1508         /*
1509          * Let's just fall asleep for a while, then we'll clean up.
1510          */
1511         tv.tv_sec = sleep_secs;
1512         tv.tv_usec = 0;
1513         code = IOMGR_Select(0,  /*Num fds */
1514                             0,  /*Descriptors ready for reading */
1515                             0,  /*Descriptors ready for writing */
1516                             0,  /*Descriptors with exceptional conditions */
1517                             &tv);       /*Timeout structure */
1518         if (code) {
1519             fprintf(stderr,
1520                     "[%s] IOMGR_Select() returned non-zero value: %d\n", rn,
1521                     code);
1522         }
1523     }
1524
1525     /*
1526      * We're all done.  Clean up, put the last nail in Rx, then
1527      * exit happily.
1528      */
1529     if (debugging_on)
1530         printf("\nYawn, main thread just woke up.  Cleaning things out...\n");
1531     code = xstat_cm_Cleanup(1); /*Get rid of malloc'ed data */
1532     rx_Finalize();
1533     return (0);
1534
1535 }                               /*RunTheTest */
1536
1537
1538 #include "AFS_component_version_number.c"
1539 int
1540 main(int argc, char **argv)
1541 {                               /*Main routine */
1542
1543     static char rn[] = "xstat_cm_test"; /*Routine name */
1544     afs_int32 code;     /*Return code */
1545     struct cmd_syndesc *ts;     /*Ptr to cmd line syntax desc */
1546
1547     /*
1548      * Set up the commands we understand.
1549      */
1550     ts = cmd_CreateSyntax("initcmd", RunTheTest, NULL, "initialize the program");
1551     cmd_AddParm(ts, "-cmname", CMD_LIST, CMD_REQUIRED,
1552                 "Cache Manager name(s) to monitor");
1553     cmd_AddParm(ts, "-collID", CMD_LIST, CMD_REQUIRED,
1554                 "Collection(s) to fetch");
1555     cmd_AddParm(ts, "-onceonly", CMD_FLAG, CMD_OPTIONAL,
1556                 "Collect results exactly once, then quit");
1557     cmd_AddParm(ts, "-frequency", CMD_SINGLE, CMD_OPTIONAL,
1558                 "poll frequency, in seconds");
1559     cmd_AddParm(ts, "-period", CMD_SINGLE, CMD_OPTIONAL,
1560                 "data collection time, in minutes");
1561     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
1562                 "turn on debugging output");
1563
1564     /*
1565      * Parse command-line switches & execute the test, then get the
1566      * heck out of here.
1567      */
1568     code = cmd_Dispatch(argc, argv);
1569     if (code) {
1570         fprintf(stderr, "[%s] Call to cmd_Dispatch() failed; code is %d\n",
1571                 rn, code);
1572     }
1573
1574     exit(code);
1575
1576 }                               /*Main routine */