2 * Copyright 2000, International Business Machines Corporation and others.
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
12 * Test of the xstat_fs module.
14 *------------------------------------------------------------------------*/
16 #include <afsconfig.h>
17 #include <afs/param.h>
22 #include "xstat_fs.h" /*Interface for xstat_fs module */
23 #include <cmd.h> /*Command line interpreter */
34 * External routines that don't have explicit include file definitions.
36 extern struct hostent *hostutil_GetHostByName();
39 * Command line parameter indices.
40 * P_FS_NAMES : List of FileServer names.
41 * P_COLL_IDS : List of collection IDs to pick up.
42 * P_ONESHOT : Are we gathering exactly one round of data?
43 * P_DEBUG : Enable debugging output?
55 static int debugging_on = 0; /*Are we debugging? */
56 static int one_shot = 0; /*Single round of data collection? */
58 static char *opNames[] = {
89 static char *xferOpNames[] = {
95 /*------------------------------------------------------------------------
99 * Print out the AFS_XSTATSCOLL_CALL_INFO collection we just
109 * All the info we need is nestled into xstat_fs_Results.
113 *------------------------------------------------------------------------*/
119 static char rn[] = "PrintCallInfo"; /*Routine name */
120 register int i; /*Loop variable */
121 int numInt32s; /*# int32words returned */
122 afs_int32 *currInt32; /*Ptr to current afs_int32 value */
123 char *printableTime; /*Ptr to printable time string */
124 time_t probeTime = xstat_fs_Results.probeTime;
127 * Just print out the results of the particular probe.
129 numInt32s = xstat_fs_Results.data.AFS_CollData_len;
130 currInt32 = (afs_int32 *) (xstat_fs_Results.data.AFS_CollData_val);
131 printableTime = ctime(&probeTime);
132 printableTime[strlen(printableTime) - 1] = '\0';
134 printf("AFS_XSTATSCOLL_CALL_INFO (coll %d) for FS %s\n[Probe %d, %s]\n\n",
135 xstat_fs_Results.collectionNumber,
136 xstat_fs_Results.connP->hostName, xstat_fs_Results.probeNum,
140 printf("\n[%d entries returned at 0x%x]\n\n", numInt32s, currInt32);
142 for (i = 0; i < numInt32s; i++)
143 printf("%d ", *currInt32++);
144 fprintf(stderr, "\n");
149 /*------------------------------------------------------------------------
150 * PrintOverallPerfInfo
153 * Print out overall performance numbers.
156 * a_ovP : Ptr to the overall performance numbers.
162 * Nothing interesting.
166 *------------------------------------------------------------------------*/
169 PrintOverallPerfInfo(struct afs_PerfStats *a_ovP)
171 printf("\t%10d numPerfCalls\n\n", a_ovP->numPerfCalls);
174 * Vnode cache section.
176 printf("\t%10d vcache_L_Entries\n", a_ovP->vcache_L_Entries);
177 printf("\t%10d vcache_L_Allocs\n", a_ovP->vcache_L_Allocs);
178 printf("\t%10d vcache_L_Gets\n", a_ovP->vcache_L_Gets);
179 printf("\t%10d vcache_L_Reads\n", a_ovP->vcache_L_Reads);
180 printf("\t%10d vcache_L_Writes\n\n", a_ovP->vcache_L_Writes);
182 printf("\t%10d vcache_S_Entries\n", a_ovP->vcache_S_Entries);
183 printf("\t%10d vcache_S_Allocs\n", a_ovP->vcache_S_Allocs);
184 printf("\t%10d vcache_S_Gets\n", a_ovP->vcache_S_Gets);
185 printf("\t%10d vcache_S_Reads\n", a_ovP->vcache_S_Reads);
186 printf("\t%10d vcache_S_Writes\n\n", a_ovP->vcache_S_Writes);
188 printf("\t%10d vcache_H_Entries\n", a_ovP->vcache_H_Entries);
189 printf("\t%10d vcache_H_Gets\n", a_ovP->vcache_H_Gets);
190 printf("\t%10d vcache_H_Replacements\n\n", a_ovP->vcache_H_Replacements);
193 * Directory package section.
195 printf("\t%10d dir_Buffers\n", a_ovP->dir_Buffers);
196 printf("\t%10d dir_Calls\n", a_ovP->dir_Calls);
197 printf("\t%10d dir_IOs\n\n", a_ovP->dir_IOs);
202 printf("\t%10d rx_packetRequests\n", a_ovP->rx_packetRequests);
203 printf("\t%10d rx_noPackets_RcvClass\n", a_ovP->rx_noPackets_RcvClass);
204 printf("\t%10d rx_noPackets_SendClass\n", a_ovP->rx_noPackets_SendClass);
205 printf("\t%10d rx_noPackets_SpecialClass\n",
206 a_ovP->rx_noPackets_SpecialClass);
207 printf("\t%10d rx_socketGreedy\n", a_ovP->rx_socketGreedy);
208 printf("\t%10d rx_bogusPacketOnRead\n", a_ovP->rx_bogusPacketOnRead);
209 printf("\t%10d rx_bogusHost\n", a_ovP->rx_bogusHost);
210 printf("\t%10d rx_noPacketOnRead\n", a_ovP->rx_noPacketOnRead);
211 printf("\t%10d rx_noPacketBuffersOnRead\n",
212 a_ovP->rx_noPacketBuffersOnRead);
213 printf("\t%10d rx_selects\n", a_ovP->rx_selects);
214 printf("\t%10d rx_sendSelects\n", a_ovP->rx_sendSelects);
215 printf("\t%10d rx_packetsRead_RcvClass\n",
216 a_ovP->rx_packetsRead_RcvClass);
217 printf("\t%10d rx_packetsRead_SendClass\n",
218 a_ovP->rx_packetsRead_SendClass);
219 printf("\t%10d rx_packetsRead_SpecialClass\n",
220 a_ovP->rx_packetsRead_SpecialClass);
221 printf("\t%10d rx_dataPacketsRead\n", a_ovP->rx_dataPacketsRead);
222 printf("\t%10d rx_ackPacketsRead\n", a_ovP->rx_ackPacketsRead);
223 printf("\t%10d rx_dupPacketsRead\n", a_ovP->rx_dupPacketsRead);
224 printf("\t%10d rx_spuriousPacketsRead\n", a_ovP->rx_spuriousPacketsRead);
225 printf("\t%10d rx_packetsSent_RcvClass\n",
226 a_ovP->rx_packetsSent_RcvClass);
227 printf("\t%10d rx_packetsSent_SendClass\n",
228 a_ovP->rx_packetsSent_SendClass);
229 printf("\t%10d rx_packetsSent_SpecialClass\n",
230 a_ovP->rx_packetsSent_SpecialClass);
231 printf("\t%10d rx_ackPacketsSent\n", a_ovP->rx_ackPacketsSent);
232 printf("\t%10d rx_pingPacketsSent\n", a_ovP->rx_pingPacketsSent);
233 printf("\t%10d rx_abortPacketsSent\n", a_ovP->rx_abortPacketsSent);
234 printf("\t%10d rx_busyPacketsSent\n", a_ovP->rx_busyPacketsSent);
235 printf("\t%10d rx_dataPacketsSent\n", a_ovP->rx_dataPacketsSent);
236 printf("\t%10d rx_dataPacketsReSent\n", a_ovP->rx_dataPacketsReSent);
237 printf("\t%10d rx_dataPacketsPushed\n", a_ovP->rx_dataPacketsPushed);
238 printf("\t%10d rx_ignoreAckedPacket\n", a_ovP->rx_ignoreAckedPacket);
239 printf("\t%10d rx_totalRtt_Sec\n", a_ovP->rx_totalRtt_Sec);
240 printf("\t%10d rx_totalRtt_Usec\n", a_ovP->rx_totalRtt_Usec);
241 printf("\t%10d rx_minRtt_Sec\n", a_ovP->rx_minRtt_Sec);
242 printf("\t%10d rx_minRtt_Usec\n", a_ovP->rx_minRtt_Usec);
243 printf("\t%10d rx_maxRtt_Sec\n", a_ovP->rx_maxRtt_Sec);
244 printf("\t%10d rx_maxRtt_Usec\n", a_ovP->rx_maxRtt_Usec);
245 printf("\t%10d rx_nRttSamples\n", a_ovP->rx_nRttSamples);
246 printf("\t%10d rx_nServerConns\n", a_ovP->rx_nServerConns);
247 printf("\t%10d rx_nClientConns\n", a_ovP->rx_nClientConns);
248 printf("\t%10d rx_nPeerStructs\n", a_ovP->rx_nPeerStructs);
249 printf("\t%10d rx_nCallStructs\n", a_ovP->rx_nCallStructs);
250 printf("\t%10d rx_nFreeCallStructs\n", a_ovP->rx_nFreeCallStructs);
251 printf("\t%10d rx_nBusies\n\n", a_ovP->rx_nBusies);
253 printf("\t%10d fs_nBusies\n", a_ovP->fs_nBusies);
254 printf("\t%10d fs_GetCapabilities\n\n", a_ovP->fs_nGetCaps);
256 * Host module fields.
258 printf("\t%10d host_NumHostEntries\n", a_ovP->host_NumHostEntries);
259 printf("\t%10d host_HostBlocks\n", a_ovP->host_HostBlocks);
260 printf("\t%10d host_NonDeletedHosts\n", a_ovP->host_NonDeletedHosts);
261 printf("\t%10d host_HostsInSameNetOrSubnet\n",
262 a_ovP->host_HostsInSameNetOrSubnet);
263 printf("\t%10d host_HostsInDiffSubnet\n", a_ovP->host_HostsInDiffSubnet);
264 printf("\t%10d host_HostsInDiffNetwork\n",
265 a_ovP->host_HostsInDiffNetwork);
266 printf("\t%10d host_NumClients\n", a_ovP->host_NumClients);
267 printf("\t%10d host_ClientBlocks\n\n", a_ovP->host_ClientBlocks);
269 printf("\t%10d sysname_ID\n", a_ovP->sysname_ID);
273 /*------------------------------------------------------------------------
277 * Print out the contents of an RPC op timing structure.
280 * a_opIdx : Index of the AFS operation we're printing number on.
281 * a_opTimeP : Ptr to the op timing structure to print.
287 * Nothing interesting.
291 *------------------------------------------------------------------------*/
294 PrintOpTiming(int a_opIdx, struct fs_stats_opTimingData *a_opTimeP)
296 double fSumTime, avg;
299 ((double)(a_opTimeP->sumTime.tv_sec)) +
300 (((double)(a_opTimeP->sumTime.tv_usec)) / ((double)(1000000)));
301 /* printf("Double sum time is %f\n", fSumTime);*/
302 avg = fSumTime / ((double)(a_opTimeP->numSuccesses));
305 ("%15s: %d ops (%d OK); sum=%d.%06d, sqr=%d.%06d, min=%d.%06d, max=%d.%06d\n",
306 opNames[a_opIdx], a_opTimeP->numOps, a_opTimeP->numSuccesses,
307 a_opTimeP->sumTime.tv_sec, a_opTimeP->sumTime.tv_usec,
308 a_opTimeP->sqrTime.tv_sec, a_opTimeP->sqrTime.tv_usec,
309 a_opTimeP->minTime.tv_sec, a_opTimeP->minTime.tv_usec,
310 a_opTimeP->maxTime.tv_sec, a_opTimeP->maxTime.tv_usec);
314 /*------------------------------------------------------------------------
318 * Print out the contents of a data transfer structure.
321 * a_opIdx : Index of the AFS operation we're printing number on.
322 * a_xferP : Ptr to the data transfer structure to print.
328 * Nothing interesting.
332 *------------------------------------------------------------------------*/
335 PrintXferTiming(int a_opIdx, struct fs_stats_xferData *a_xferP)
337 double fSumTime, avg;
340 ((double)(a_xferP->sumTime.tv_sec)) +
341 ((double)(a_xferP->sumTime.tv_usec)) / ((double)(1000000));
343 avg = fSumTime / ((double)(a_xferP->numSuccesses));
346 ("%s: %d xfers (%d OK), time sum=%d.%06d, sqr=%d.%06d, min=%d.%06d, max=%d.%06d\n",
347 xferOpNames[a_opIdx], a_xferP->numXfers, a_xferP->numSuccesses,
348 a_xferP->sumTime.tv_sec, a_xferP->sumTime.tv_usec,
349 a_xferP->sqrTime.tv_sec, a_xferP->sqrTime.tv_usec,
350 a_xferP->minTime.tv_sec, a_xferP->minTime.tv_usec,
351 a_xferP->maxTime.tv_sec, a_xferP->maxTime.tv_usec);
352 printf("\t[bytes: sum=%lu, min=%d, max=%d]\n", a_xferP->sumBytes,
353 a_xferP->minBytes, a_xferP->maxBytes);
355 ("\t[buckets: 0: %d, 1: %d, 2: %d, 3: %d, 4: %d, 5: %d, 6: %d, 7: %d, 8: %d]\n",
356 a_xferP->count[0], a_xferP->count[1], a_xferP->count[2],
357 a_xferP->count[3], a_xferP->count[4], a_xferP->count[5],
358 a_xferP->count[6], a_xferP->count[7], a_xferP->count[8]);
362 /*------------------------------------------------------------------------
363 * PrintDetailedPerfInfo
366 * Print out a set of detailed performance numbers.
369 * a_detP : Ptr to detailed perf numbers to print.
375 * Nothing interesting.
379 *------------------------------------------------------------------------*/
382 PrintDetailedPerfInfo(struct fs_stats_DetailedStats *a_detP)
384 int currIdx; /*Loop variable */
386 printf("\t%10d epoch\n", a_detP->epoch);
388 for (currIdx = 0; currIdx < FS_STATS_NUM_RPC_OPS; currIdx++)
389 PrintOpTiming(currIdx, &(a_detP->rpcOpTimes[currIdx]));
391 for (currIdx = 0; currIdx < FS_STATS_NUM_XFER_OPS; currIdx++)
392 PrintXferTiming(currIdx, &(a_detP->xferOpTimes[currIdx]));
396 /*------------------------------------------------------------------------
400 * Print out the AFS_XSTATSCOLL_FULL_PERF_INFO collection we just
410 * All the info we need is nestled into xstat_fs_Results.
414 *------------------------------------------------------------------------*/
420 static char rn[] = "PrintFullPerfInfo"; /*Routine name */
421 static afs_int32 fullPerfInt32s = (sizeof(struct fs_stats_FullPerfStats) >> 2); /*Correct # int32s to rcv */
422 afs_int32 numInt32s; /*# int32words received */
423 struct fs_stats_FullPerfStats *fullPerfP; /*Ptr to full perf stats */
424 char *printableTime; /*Ptr to printable time
426 time_t probeTime = xstat_fs_Results.probeTime;
428 numInt32s = xstat_fs_Results.data.AFS_CollData_len;
429 if (numInt32s != fullPerfInt32s) {
430 printf("** Data size mismatch in full performance collection!");
431 printf("** Expecting %d, got %d\n", fullPerfInt32s, numInt32s);
435 printableTime = ctime(&probeTime);
436 printableTime[strlen(printableTime) - 1] = '\0';
437 fullPerfP = (struct fs_stats_FullPerfStats *)
438 (xstat_fs_Results.data.AFS_CollData_val);
441 ("AFS_XSTATSCOLL_FULL_PERF_INFO (coll %d) for FS %s\n[Probe %d, %s]\n\n",
442 xstat_fs_Results.collectionNumber, xstat_fs_Results.connP->hostName,
443 xstat_fs_Results.probeNum, printableTime);
445 PrintOverallPerfInfo(&(fullPerfP->overall));
446 PrintDetailedPerfInfo(&(fullPerfP->det));
450 /*------------------------------------------------------------------------
454 * Print out the AFS_XSTATSCOLL_PERF_INFO collection we just
464 * All the info we need is nestled into xstat_fs_Results.
468 *------------------------------------------------------------------------*/
473 static char rn[] = "PrintPerfInfo"; /*Routine name */
474 static afs_int32 perfInt32s = (sizeof(struct afs_PerfStats) >> 2); /*Correct # int32s to rcv */
475 afs_int32 numInt32s; /*# int32words received */
476 struct afs_PerfStats *perfP; /*Ptr to performance stats */
477 char *printableTime; /*Ptr to printable time string */
478 time_t probeTime = xstat_fs_Results.probeTime;
480 numInt32s = xstat_fs_Results.data.AFS_CollData_len;
481 if (numInt32s != perfInt32s) {
482 printf("** Data size mismatch in performance collection!");
483 printf("** Expecting %d, got %d\n", perfInt32s, numInt32s);
487 printableTime = ctime(&probeTime);
488 printableTime[strlen(printableTime) - 1] = '\0';
489 perfP = (struct afs_PerfStats *)
490 (xstat_fs_Results.data.AFS_CollData_val);
492 printf("AFS_XSTATSCOLL_PERF_INFO (coll %d) for FS %s\n[Probe %d, %s]\n\n",
493 xstat_fs_Results.collectionNumber,
494 xstat_fs_Results.connP->hostName, xstat_fs_Results.probeNum,
497 PrintOverallPerfInfo(perfP);
500 static char *CbCounterStrings[] = {
506 "DeleteAllCallBacks",
507 "nFEs", "nCBs", "nblks",
510 "GSS1", "GSS2", "GSS3", "GSS4", "GSS5"
516 int numInt32s = sizeof(CbCounterStrings)/sizeof(char *);
518 afs_uint32 *val=xstat_fs_Results.data.AFS_CollData_val;
520 if (numInt32s > xstat_fs_Results.data.AFS_CollData_len)
521 numInt32s = xstat_fs_Results.data.AFS_CollData_len;
523 for (i=0; i<numInt32s; i++) {
524 printf("\t%10u %s\n", val[i], CbCounterStrings[i]);
529 /*------------------------------------------------------------------------
533 * Handler routine passed to the xstat_fs module. This handler is
534 * called immediately after a poll of one of the File Servers has
535 * taken place. All it needs to know is exported by the xstat_fs
536 * module, namely the data structure where the probe results are
547 * See above. All we do now is print out what we got.
551 *------------------------------------------------------------------------*/
556 static char rn[] = "FS_Handler"; /*Routine name */
559 ("\n------------------------------------------------------------\n");
562 * If the probe failed, there isn't much we can do except gripe.
564 if (xstat_fs_Results.probeOK) {
565 printf("%s: Probe %d to File Server '%s' failed, code=%d\n", rn,
566 xstat_fs_Results.probeNum, xstat_fs_Results.connP->hostName,
567 xstat_fs_Results.probeOK);
571 switch (xstat_fs_Results.collectionNumber) {
572 case AFS_XSTATSCOLL_CALL_INFO:
576 case AFS_XSTATSCOLL_PERF_INFO:
580 case AFS_XSTATSCOLL_FULL_PERF_INFO:
584 case AFS_XSTATSCOLL_CBSTATS:
589 printf("** Unknown collection: %d\n",
590 xstat_fs_Results.collectionNumber);
594 * Return the happy news.
600 /*------------------------------------------------------------------------
604 * Given a pointer to the list of File Servers we'll be polling
605 * (or, in fact, any list at all), compute the length of the list.
608 * struct cmd_item *a_firstItem : Ptr to first item in list.
611 * Length of the above list.
614 * Nothing interesting.
618 *------------------------------------------------------------------------*/
621 CountListItems(struct cmd_item *a_firstItem)
624 int list_len; /*List length */
625 struct cmd_item *curr_item; /*Ptr to current item */
628 curr_item = a_firstItem;
635 curr_item = curr_item->next;
645 /*------------------------------------------------------------------------
649 * Routine called by the command line interpreter to execute the
650 * meat of the program. We count the number of File Servers
651 * to watch, allocate enough space to remember all the connection
652 * info for them, then go for it.
656 * a_s : Ptr to the command line syntax descriptor.
659 * 0, but may exit the whole program on an error!
662 * Nothing interesting.
666 *------------------------------------------------------------------------*/
669 RunTheTest(struct cmd_syndesc *a_s)
671 static char rn[] = "RunTheTest"; /*Routine name */
672 int code; /*Return code */
673 int numFSs; /*# File Servers to monitor */
674 int numCollIDs; /*# collections to fetch */
675 int currFS; /*Loop index */
676 int currCollIDIdx; /*Index of current collection ID */
677 afs_int32 *collIDP; /*Ptr to array of collection IDs */
678 afs_int32 *currCollIDP; /*Ptr to current collection ID */
679 struct cmd_item *curr_item; /*Current FS cmd line record */
680 struct sockaddr_in FSSktArray[20]; /*File Server socket array - FIX! */
681 struct hostent *he; /*Host entry */
682 struct timeval tv; /*Time structure */
683 int sleep_secs; /*Number of seconds to sleep */
684 int initFlags; /*Flags passed to the init fcn */
685 int waitCode; /*Result of LWP_WaitProcess() */
686 int freq; /*Frequency of polls */
687 int period; /*Time in minutes of data collection */
690 * Are we doing one-shot measurements?
692 if (a_s->parms[P_ONESHOT].items != 0)
696 * Are we doing debugging output?
698 if (a_s->parms[P_DEBUG].items != 0)
702 * Pull out the number of File Servers to watch and the number of
703 * collections to get.
705 numFSs = CountListItems(a_s->parms[P_FS_NAMES].items);
706 numCollIDs = CountListItems(a_s->parms[P_COLL_IDS].items);
708 /* Get the polling frequency */
709 if (a_s->parms[P_FREQUENCY].items != 0)
710 freq = atoi(a_s->parms[P_FREQUENCY].items->data);
712 freq = 30; /* default to 30 seconds */
714 /* Get the time duration to run the tests */
715 if (a_s->parms[P_PERIOD].items != 0)
716 period = atoi(a_s->parms[P_PERIOD].items->data);
718 period = 10; /* default to 10 minutes */
722 * Fill in the socket array for each of the File Servers listed.
724 curr_item = a_s->parms[P_FS_NAMES].items;
725 for (currFS = 0; currFS < numFSs; currFS++) {
726 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
727 FSSktArray[currFS].sin_family = AF_INET; /*Internet family */
729 FSSktArray[currFS].sin_family = htons(AF_INET); /*Internet family */
731 FSSktArray[currFS].sin_port = htons(7000); /*FileServer port */
732 he = hostutil_GetHostByName(curr_item->data);
734 fprintf(stderr, "[%s] Can't get host info for '%s'\n", rn,
738 memcpy(&(FSSktArray[currFS].sin_addr.s_addr), he->h_addr, 4);
741 * Move to the next File Server name.
743 curr_item = curr_item->next;
745 } /*Get socket info for each File Server */
748 * Create and fill up the array of desired collection IDs.
751 printf("Allocating %d long(s) for coll ID\n", numCollIDs);
752 collIDP = (afs_int32 *) (malloc(numCollIDs * sizeof(afs_int32)));
753 currCollIDP = collIDP;
754 curr_item = a_s->parms[P_COLL_IDS].items;
755 for (currCollIDIdx = 0; currCollIDIdx < numCollIDs; currCollIDIdx++) {
756 *currCollIDP = (afs_int32) (atoi(curr_item->data));
758 printf("CollID at index %d is %d\n", currCollIDIdx, *currCollIDP);
759 curr_item = curr_item->next;
764 * Crank up the File Server prober, then sit back and have fun.
766 printf("\nStarting up the xstat_fs service, ");
769 initFlags |= XSTAT_FS_INITFLAG_DEBUGGING;
770 printf("debugging enabled, ");
772 printf("no debugging, ");
774 initFlags |= XSTAT_FS_INITFLAG_ONE_SHOT;
775 printf("one-shot operation\n");
777 printf("continuous operation\n");
779 code = xstat_fs_Init(numFSs, /*Num servers */
780 FSSktArray, /*File Server socket array */
781 freq, /*Probe frequency */
782 FS_Handler, /*Handler routine */
783 initFlags, /*Initialization flags */
784 numCollIDs, /*Number of collection IDs */
785 collIDP); /*Ptr to collection ID array */
787 fprintf(stderr, "[%s] Error returned by xstat_fs_Init: %d\n", rn,
789 xstat_fs_Cleanup(1); /*Get rid of malloc'ed structures */
795 * One-shot operation; just wait for the collection to be done.
798 printf("[%s] Calling LWP_WaitProcess() on event 0x%x\n", rn,
800 waitCode = LWP_WaitProcess(&terminationEvent);
802 printf("[%s] Returned from LWP_WaitProcess()\n", rn);
806 "[%s] Error %d encountered by LWP_WaitProcess()\n",
811 * Continuous operation.
813 sleep_secs = 60 * period; /*length of data collection */
815 ("xstat_fs service started, main thread sleeping for %d secs.\n",
819 * Let's just fall asleep for a while, then we'll clean up.
821 tv.tv_sec = sleep_secs;
823 code = IOMGR_Select(0, /*Num fds */
824 0, /*Descriptors ready for reading */
825 0, /*Descriptors ready for writing */
826 0, /*Descriptors with exceptional conditions */
827 &tv); /*Timeout structure */
830 "[%s] IOMGR_Select() returned non-zero value: %d\n", rn,
836 * We're all done. Clean up, put the last nail in Rx, then
840 printf("\nYawn, main thread just woke up. Cleaning things out...\n");
842 code = xstat_fs_Cleanup(1); /*Get rid of malloc'ed data */
848 #include "AFS_component_version_number.c"
851 main(int argc, char **argv)
853 static char rn[] = "xstat_fs_test"; /*Routine name */
854 register afs_int32 code; /*Return code */
855 struct cmd_syndesc *ts; /*Ptr to cmd line syntax desc */
858 * Set up the commands we understand.
860 ts = cmd_CreateSyntax("initcmd", RunTheTest, 0, "initialize the program");
861 cmd_AddParm(ts, "-fsname", CMD_LIST, CMD_REQUIRED,
862 "File Server name(s) to monitor");
863 cmd_AddParm(ts, "-collID", CMD_LIST, CMD_REQUIRED,
864 "Collection(s) to fetch");
865 cmd_AddParm(ts, "-onceonly", CMD_FLAG, CMD_OPTIONAL,
866 "Collect results exactly once, then quit");
867 cmd_AddParm(ts, "-frequency", CMD_SINGLE, CMD_OPTIONAL,
868 "poll frequency, in seconds");
869 cmd_AddParm(ts, "-period", CMD_SINGLE, CMD_OPTIONAL,
870 "data collection time, in minutes");
871 cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
872 "turn on debugging output");
875 * Parse command-line switches & execute the test, then get the
878 code = cmd_Dispatch(argc, argv);
880 fprintf(stderr, "[%s] Call to cmd_Dispatch() failed; code is %d\n",