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