75af1a4876252c7eca65e163082c9dc9933b4343
[openafs.git] / src / xstat / xstat_fs_test.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * Description:
12  *      Test of the xstat_fs module.
13  *
14  *------------------------------------------------------------------------*/
15
16 #include <afsconfig.h>
17 #include <afs/param.h>
18
19
20 #include "xstat_fs.h"           /*Interface for xstat_fs module */
21 #include <cmd.h>                /*Command line interpreter */
22 #include <time.h>
23 #include <string.h>
24 #include <afs/afsutil.h>
25
26 /*
27  * Command line parameter indices.
28  *      P_FS_NAMES : List of FileServer names.
29  *      P_COLL_IDS : List of collection IDs to pick up.
30  *      P_ONESHOT  : Are we gathering exactly one round of data?
31  *      P_DEBUG    : Enable debugging output?
32  */
33 #define P_FS_NAMES      0
34 #define P_COLL_IDS      1
35 #define P_ONESHOT       2
36 #define P_FREQUENCY     3
37 #define P_PERIOD        4
38 #define P_DEBUG         5
39
40 /*
41  * Private globals.
42  */
43 static int debugging_on = 0;    /*Are we debugging? */
44 static int one_shot = 0;        /*Single round of data collection? */
45
46 static char *opNames[] = {
47     "FetchData",
48     "FetchACL",
49     "FetchStatus",
50     "StoreData",
51     "StoreACL",
52     "StoreStatus",
53     "RemoveFile",
54     "CreateFile",
55     "Rename",
56     "Symlink",
57     "Link",
58     "MakeDir",
59     "RemoveDir",
60     "SetLock",
61     "ExtendLock",
62     "ReleaseLock",
63     "GetStatistics",
64     "GiveUpCallbacks",
65     "GetVolumeInfo",
66     "GetVolumeStatus",
67     "SetVolumeStatus",
68     "GetRootVolume",
69     "CheckToken",
70     "GetTime",
71     "NGetVolumeInfo",
72     "BulkStatus",
73     "XStatsVersion",
74     "GetXStats"
75 };
76
77 static char *xferOpNames[] = {
78     "FetchData",
79     "StoreData"
80 };
81
82
83 /*------------------------------------------------------------------------
84  * PrintCallInfo
85  *
86  * Description:
87  *      Print out the AFS_XSTATSCOLL_CALL_INFO collection we just
88  *      received.
89  *
90  * Arguments:
91  *      None.
92  *
93  * Returns:
94  *      Nothing.
95  *
96  * Environment:
97  *      All the info we need is nestled into xstat_fs_Results.
98  *
99  * Side Effects:
100  *      As advertised.
101  *------------------------------------------------------------------------*/
102
103 void
104 PrintCallInfo(void)
105 {                               /*PrintCallInfo */
106     register int i;             /*Loop variable */
107     int numInt32s;              /*# int32words returned */
108     afs_int32 *currInt32;       /*Ptr to current afs_int32 value */
109     char *printableTime;        /*Ptr to printable time string */
110     time_t probeTime = xstat_fs_Results.probeTime;
111
112     /*
113      * Just print out the results of the particular probe.
114      */
115     numInt32s = xstat_fs_Results.data.AFS_CollData_len;
116     currInt32 = (afs_int32 *) (xstat_fs_Results.data.AFS_CollData_val);
117     printableTime = ctime(&probeTime);
118     printableTime[strlen(printableTime) - 1] = '\0';
119
120     printf("AFS_XSTATSCOLL_CALL_INFO (coll %d) for FS %s\n[Probe %d, %s]\n\n",
121            xstat_fs_Results.collectionNumber,
122            xstat_fs_Results.connP->hostName, xstat_fs_Results.probeNum,
123            printableTime);
124
125     if (debugging_on)
126         printf("\n[%d entries returned at 0x%" AFS_PTR_FMT "]\n\n", numInt32s, currInt32);
127
128     for (i = 0; i < numInt32s; i++)
129         printf("%d ", *currInt32++);
130     fprintf(stderr, "\n");
131
132 }                               /*PrintCallInfo */
133
134
135 /*------------------------------------------------------------------------
136  * PrintOverallPerfInfo
137  *
138  * Description:
139  *      Print out overall performance numbers.
140  *
141  * Arguments:
142  *      a_ovP : Ptr to the overall performance numbers.
143  *
144  * Returns:
145  *      Nothing.
146  *
147  * Environment:
148  *      Nothing interesting.
149  *
150  * Side Effects:
151  *      As advertised.
152  *------------------------------------------------------------------------*/
153
154 void
155 PrintOverallPerfInfo(struct afs_PerfStats *a_ovP)
156 {
157     printf("\t%10d numPerfCalls\n\n", a_ovP->numPerfCalls);
158
159     /*
160      * Vnode cache section.
161      */
162     printf("\t%10d vcache_L_Entries\n", a_ovP->vcache_L_Entries);
163     printf("\t%10d vcache_L_Allocs\n", a_ovP->vcache_L_Allocs);
164     printf("\t%10d vcache_L_Gets\n", a_ovP->vcache_L_Gets);
165     printf("\t%10d vcache_L_Reads\n", a_ovP->vcache_L_Reads);
166     printf("\t%10d vcache_L_Writes\n\n", a_ovP->vcache_L_Writes);
167
168     printf("\t%10d vcache_S_Entries\n", a_ovP->vcache_S_Entries);
169     printf("\t%10d vcache_S_Allocs\n", a_ovP->vcache_S_Allocs);
170     printf("\t%10d vcache_S_Gets\n", a_ovP->vcache_S_Gets);
171     printf("\t%10d vcache_S_Reads\n", a_ovP->vcache_S_Reads);
172     printf("\t%10d vcache_S_Writes\n\n", a_ovP->vcache_S_Writes);
173
174     printf("\t%10d vcache_H_Entries\n", a_ovP->vcache_H_Entries);
175     printf("\t%10d vcache_H_Gets\n", a_ovP->vcache_H_Gets);
176     printf("\t%10d vcache_H_Replacements\n\n", a_ovP->vcache_H_Replacements);
177
178     /*
179      * Directory package section.
180      */
181     printf("\t%10d dir_Buffers\n", a_ovP->dir_Buffers);
182     printf("\t%10d dir_Calls\n", a_ovP->dir_Calls);
183     printf("\t%10d dir_IOs\n\n", a_ovP->dir_IOs);
184
185     /*
186      * Rx section.
187      */
188     printf("\t%10d rx_packetRequests\n", a_ovP->rx_packetRequests);
189     printf("\t%10d rx_noPackets_RcvClass\n", a_ovP->rx_noPackets_RcvClass);
190     printf("\t%10d rx_noPackets_SendClass\n", a_ovP->rx_noPackets_SendClass);
191     printf("\t%10d rx_noPackets_SpecialClass\n",
192            a_ovP->rx_noPackets_SpecialClass);
193     printf("\t%10d rx_socketGreedy\n", a_ovP->rx_socketGreedy);
194     printf("\t%10d rx_bogusPacketOnRead\n", a_ovP->rx_bogusPacketOnRead);
195     printf("\t%10d rx_bogusHost\n", a_ovP->rx_bogusHost);
196     printf("\t%10d rx_noPacketOnRead\n", a_ovP->rx_noPacketOnRead);
197     printf("\t%10d rx_noPacketBuffersOnRead\n",
198            a_ovP->rx_noPacketBuffersOnRead);
199     printf("\t%10d rx_selects\n", a_ovP->rx_selects);
200     printf("\t%10d rx_sendSelects\n", a_ovP->rx_sendSelects);
201     printf("\t%10d rx_packetsRead_RcvClass\n",
202            a_ovP->rx_packetsRead_RcvClass);
203     printf("\t%10d rx_packetsRead_SendClass\n",
204            a_ovP->rx_packetsRead_SendClass);
205     printf("\t%10d rx_packetsRead_SpecialClass\n",
206            a_ovP->rx_packetsRead_SpecialClass);
207     printf("\t%10d rx_dataPacketsRead\n", a_ovP->rx_dataPacketsRead);
208     printf("\t%10d rx_ackPacketsRead\n", a_ovP->rx_ackPacketsRead);
209     printf("\t%10d rx_dupPacketsRead\n", a_ovP->rx_dupPacketsRead);
210     printf("\t%10d rx_spuriousPacketsRead\n", a_ovP->rx_spuriousPacketsRead);
211     printf("\t%10d rx_packetsSent_RcvClass\n",
212            a_ovP->rx_packetsSent_RcvClass);
213     printf("\t%10d rx_packetsSent_SendClass\n",
214            a_ovP->rx_packetsSent_SendClass);
215     printf("\t%10d rx_packetsSent_SpecialClass\n",
216            a_ovP->rx_packetsSent_SpecialClass);
217     printf("\t%10d rx_ackPacketsSent\n", a_ovP->rx_ackPacketsSent);
218     printf("\t%10d rx_pingPacketsSent\n", a_ovP->rx_pingPacketsSent);
219     printf("\t%10d rx_abortPacketsSent\n", a_ovP->rx_abortPacketsSent);
220     printf("\t%10d rx_busyPacketsSent\n", a_ovP->rx_busyPacketsSent);
221     printf("\t%10d rx_dataPacketsSent\n", a_ovP->rx_dataPacketsSent);
222     printf("\t%10d rx_dataPacketsReSent\n", a_ovP->rx_dataPacketsReSent);
223     printf("\t%10d rx_dataPacketsPushed\n", a_ovP->rx_dataPacketsPushed);
224     printf("\t%10d rx_ignoreAckedPacket\n", a_ovP->rx_ignoreAckedPacket);
225     printf("\t%10d rx_totalRtt_Sec\n", a_ovP->rx_totalRtt_Sec);
226     printf("\t%10d rx_totalRtt_Usec\n", a_ovP->rx_totalRtt_Usec);
227     printf("\t%10d rx_minRtt_Sec\n", a_ovP->rx_minRtt_Sec);
228     printf("\t%10d rx_minRtt_Usec\n", a_ovP->rx_minRtt_Usec);
229     printf("\t%10d rx_maxRtt_Sec\n", a_ovP->rx_maxRtt_Sec);
230     printf("\t%10d rx_maxRtt_Usec\n", a_ovP->rx_maxRtt_Usec);
231     printf("\t%10d rx_nRttSamples\n", a_ovP->rx_nRttSamples);
232     printf("\t%10d rx_nServerConns\n", a_ovP->rx_nServerConns);
233     printf("\t%10d rx_nClientConns\n", a_ovP->rx_nClientConns);
234     printf("\t%10d rx_nPeerStructs\n", a_ovP->rx_nPeerStructs);
235     printf("\t%10d rx_nCallStructs\n", a_ovP->rx_nCallStructs);
236     printf("\t%10d rx_nFreeCallStructs\n", a_ovP->rx_nFreeCallStructs);
237     printf("\t%10d rx_nBusies\n\n", a_ovP->rx_nBusies);
238
239     printf("\t%10d fs_nBusies\n", a_ovP->fs_nBusies);
240     printf("\t%10d fs_GetCapabilities\n\n", a_ovP->fs_nGetCaps);
241     /*
242      * Host module fields.
243      */
244     printf("\t%10d host_NumHostEntries\n", a_ovP->host_NumHostEntries);
245     printf("\t%10d host_HostBlocks\n", a_ovP->host_HostBlocks);
246     printf("\t%10d host_NonDeletedHosts\n", a_ovP->host_NonDeletedHosts);
247     printf("\t%10d host_HostsInSameNetOrSubnet\n",
248            a_ovP->host_HostsInSameNetOrSubnet);
249     printf("\t%10d host_HostsInDiffSubnet\n", a_ovP->host_HostsInDiffSubnet);
250     printf("\t%10d host_HostsInDiffNetwork\n",
251            a_ovP->host_HostsInDiffNetwork);
252     printf("\t%10d host_NumClients\n", a_ovP->host_NumClients);
253     printf("\t%10d host_ClientBlocks\n\n", a_ovP->host_ClientBlocks);
254
255     printf("\t%10d sysname_ID\n", a_ovP->sysname_ID);
256 }
257
258
259 /*------------------------------------------------------------------------
260  * PrintOpTiming
261  *
262  * Description:
263  *      Print out the contents of an RPC op timing structure.
264  *
265  * Arguments:
266  *      a_opIdx   : Index of the AFS operation we're printing number on.
267  *      a_opTimeP : Ptr to the op timing structure to print.
268  *
269  * Returns:
270  *      Nothing.
271  *
272  * Environment:
273  *      Nothing interesting.
274  *
275  * Side Effects:
276  *      As advertised.
277  *------------------------------------------------------------------------*/
278
279 void
280 PrintOpTiming(int a_opIdx, struct fs_stats_opTimingData *a_opTimeP)
281 {
282     double fSumTime, avg;
283
284     fSumTime =
285         ((double)(a_opTimeP->sumTime.tv_sec)) +
286         (((double)(a_opTimeP->sumTime.tv_usec)) / ((double)(1000000)));
287 /*    printf("Double sum time is %f\n", fSumTime);*/
288     avg = fSumTime / ((double)(a_opTimeP->numSuccesses));
289
290     printf
291         ("%15s: %d ops (%d OK); sum=%d.%06d, sqr=%d.%06d, min=%d.%06d, max=%d.%06d\n",
292          opNames[a_opIdx], a_opTimeP->numOps, a_opTimeP->numSuccesses,
293          a_opTimeP->sumTime.tv_sec, a_opTimeP->sumTime.tv_usec,
294          a_opTimeP->sqrTime.tv_sec, a_opTimeP->sqrTime.tv_usec,
295          a_opTimeP->minTime.tv_sec, a_opTimeP->minTime.tv_usec,
296          a_opTimeP->maxTime.tv_sec, a_opTimeP->maxTime.tv_usec);
297 }
298
299
300 /*------------------------------------------------------------------------
301  * PrintXferTiming
302  *
303  * Description:
304  *      Print out the contents of a data transfer structure.
305  *
306  * Arguments:
307  *      a_opIdx : Index of the AFS operation we're printing number on.
308  *      a_xferP : Ptr to the data transfer structure to print.
309  *
310  * Returns:
311  *      Nothing.
312  *
313  * Environment:
314  *      Nothing interesting.
315  *
316  * Side Effects:
317  *      As advertised.
318  *------------------------------------------------------------------------*/
319
320 void
321 PrintXferTiming(int a_opIdx, struct fs_stats_xferData *a_xferP)
322 {
323     double fSumTime, avg;
324
325     fSumTime =
326         ((double)(a_xferP->sumTime.tv_sec)) +
327         ((double)(a_xferP->sumTime.tv_usec)) / ((double)(1000000));
328
329     avg = fSumTime / ((double)(a_xferP->numSuccesses));
330
331     printf
332         ("%s: %d xfers (%d OK), time sum=%d.%06d, sqr=%d.%06d, min=%d.%06d, max=%d.%06d\n",
333          xferOpNames[a_opIdx], a_xferP->numXfers, a_xferP->numSuccesses,
334          a_xferP->sumTime.tv_sec, a_xferP->sumTime.tv_usec,
335          a_xferP->sqrTime.tv_sec, a_xferP->sqrTime.tv_usec,
336          a_xferP->minTime.tv_sec, a_xferP->minTime.tv_usec,
337          a_xferP->maxTime.tv_sec, a_xferP->maxTime.tv_usec);
338     printf("\t[bytes: sum=%lu, min=%d, max=%d]\n", a_xferP->sumBytes,
339            a_xferP->minBytes, a_xferP->maxBytes);
340     printf
341         ("\t[buckets: 0: %d, 1: %d, 2: %d, 3: %d, 4: %d, 5: %d, 6: %d, 7: %d, 8: %d]\n",
342          a_xferP->count[0], a_xferP->count[1], a_xferP->count[2],
343          a_xferP->count[3], a_xferP->count[4], a_xferP->count[5],
344          a_xferP->count[6], a_xferP->count[7], a_xferP->count[8]);
345 }
346
347
348 /*------------------------------------------------------------------------
349  * PrintDetailedPerfInfo
350  *
351  * Description:
352  *      Print out a set of detailed performance numbers.
353  *
354  * Arguments:
355  *      a_detP : Ptr to detailed perf numbers to print.
356  *
357  * Returns:
358  *      Nothing.
359  *
360  * Environment:
361  *      Nothing interesting.
362  *
363  * Side Effects:
364  *      As advertised.
365  *------------------------------------------------------------------------*/
366
367 void
368 PrintDetailedPerfInfo(struct fs_stats_DetailedStats *a_detP)
369 {
370     int currIdx;                /*Loop variable */
371
372     printf("\t%10d epoch\n", a_detP->epoch);
373
374     for (currIdx = 0; currIdx < FS_STATS_NUM_RPC_OPS; currIdx++)
375         PrintOpTiming(currIdx, &(a_detP->rpcOpTimes[currIdx]));
376
377     for (currIdx = 0; currIdx < FS_STATS_NUM_XFER_OPS; currIdx++)
378         PrintXferTiming(currIdx, &(a_detP->xferOpTimes[currIdx]));
379 }
380
381
382 /*------------------------------------------------------------------------
383  * PrintFullPerfInfo
384  *
385  * Description:
386  *      Print out the AFS_XSTATSCOLL_FULL_PERF_INFO collection we just
387  *      received.
388  *
389  * Arguments:
390  *      None.
391  *
392  * Returns:
393  *      Nothing.
394  *
395  * Environment:
396  *      All the info we need is nestled into xstat_fs_Results.
397  *
398  * Side Effects:
399  *      As advertised.
400  *------------------------------------------------------------------------*/
401
402 void
403 PrintFullPerfInfo(void)
404 {
405
406     static afs_int32 fullPerfInt32s = (sizeof(struct fs_stats_FullPerfStats) >> 2);     /*Correct # int32s to rcv */
407     afs_int32 numInt32s;        /*# int32words received */
408     struct fs_stats_FullPerfStats *fullPerfP;   /*Ptr to full perf stats */
409     char *printableTime;        /*Ptr to printable time
410                                  * string */
411     time_t probeTime = xstat_fs_Results.probeTime;
412
413     numInt32s = xstat_fs_Results.data.AFS_CollData_len;
414     if (numInt32s != fullPerfInt32s) {
415         printf("** Data size mismatch in full performance collection!");
416         printf("** Expecting %d, got %d\n", fullPerfInt32s, numInt32s);
417         return;
418     }
419
420     printableTime = ctime(&probeTime);
421     printableTime[strlen(printableTime) - 1] = '\0';
422     fullPerfP = (struct fs_stats_FullPerfStats *)
423         (xstat_fs_Results.data.AFS_CollData_val);
424
425     printf
426         ("AFS_XSTATSCOLL_FULL_PERF_INFO (coll %d) for FS %s\n[Probe %d, %s]\n\n",
427          xstat_fs_Results.collectionNumber, xstat_fs_Results.connP->hostName,
428          xstat_fs_Results.probeNum, printableTime);
429
430     PrintOverallPerfInfo(&(fullPerfP->overall));
431     PrintDetailedPerfInfo(&(fullPerfP->det));
432 }
433
434
435 /*------------------------------------------------------------------------
436  * PrintPerfInfo
437  *
438  * Description:
439  *      Print out the AFS_XSTATSCOLL_PERF_INFO collection we just
440  *      received.
441  *
442  * Arguments:
443  *      None.
444  *
445  * Returns:
446  *      Nothing.
447  *
448  * Environment:
449  *      All the info we need is nestled into xstat_fs_Results.
450  *
451  * Side Effects:
452  *      As advertised.
453  *------------------------------------------------------------------------*/
454
455 void
456 PrintPerfInfo(void)
457 {
458     static afs_int32 perfInt32s = (sizeof(struct afs_PerfStats) >> 2);  /*Correct # int32s to rcv */
459     afs_int32 numInt32s;        /*# int32words received */
460     struct afs_PerfStats *perfP;        /*Ptr to performance stats */
461     char *printableTime;        /*Ptr to printable time string */
462     time_t probeTime = xstat_fs_Results.probeTime;
463
464     numInt32s = xstat_fs_Results.data.AFS_CollData_len;
465     if (numInt32s != perfInt32s) {
466         printf("** Data size mismatch in performance collection!");
467         printf("** Expecting %d, got %d\n", perfInt32s, numInt32s);
468         return;
469     }
470
471     printableTime = ctime(&probeTime);
472     printableTime[strlen(printableTime) - 1] = '\0';
473     perfP = (struct afs_PerfStats *)
474         (xstat_fs_Results.data.AFS_CollData_val);
475
476     printf("AFS_XSTATSCOLL_PERF_INFO (coll %d) for FS %s\n[Probe %d, %s]\n\n",
477            xstat_fs_Results.collectionNumber,
478            xstat_fs_Results.connP->hostName, xstat_fs_Results.probeNum,
479            printableTime);
480
481     PrintOverallPerfInfo(perfP);
482 }
483
484 static char *CbCounterStrings[] = {
485     "DeleteFiles",
486     "DeleteCallBacks",
487     "BreakCallBacks",
488     "AddCallBack",
489     "GotSomeSpaces",
490     "DeleteAllCallBacks",
491     "nFEs", "nCBs", "nblks",
492     "CBsTimedOut",
493     "nbreakers",
494     "GSS1", "GSS2", "GSS3", "GSS4", "GSS5"
495 };
496
497
498 void
499 PrintCbCounters(void) {
500     int numInt32s = sizeof(CbCounterStrings)/sizeof(char *);
501     int i;
502     afs_uint32 *val=xstat_fs_Results.data.AFS_CollData_val;
503
504     if (numInt32s > xstat_fs_Results.data.AFS_CollData_len)
505         numInt32s = xstat_fs_Results.data.AFS_CollData_len;
506
507     for (i=0; i<numInt32s; i++) {
508         printf("\t%10u %s\n", val[i], CbCounterStrings[i]);
509     }
510 }
511
512
513 /*------------------------------------------------------------------------
514  * FS_Handler
515  *
516  * Description:
517  *      Handler routine passed to the xstat_fs module.  This handler is
518  *      called immediately after a poll of one of the File Servers has
519  *      taken place.  All it needs to know is exported by the xstat_fs
520  *      module, namely the data structure where the probe results are
521  *      stored.
522  *
523  * Arguments:
524  *      None.
525  *
526  * Returns:
527  *      0 on success,
528  *      -1 otherwise.
529  *
530  * Environment:
531  *      See above.  All we do now is print out what we got.
532  *
533  * Side Effects:
534  *      As advertised.
535  *------------------------------------------------------------------------*/
536
537 int
538 FS_Handler(void)
539 {
540     static char rn[] = "FS_Handler";    /*Routine name */
541
542     printf
543         ("\n------------------------------------------------------------\n");
544
545     /*
546      * If the probe failed, there isn't much we can do except gripe.
547      */
548     if (xstat_fs_Results.probeOK) {
549         printf("%s: Probe %d to File Server '%s' failed, code=%d\n", rn,
550                xstat_fs_Results.probeNum, xstat_fs_Results.connP->hostName,
551                xstat_fs_Results.probeOK);
552         return (0);
553     }
554
555     switch (xstat_fs_Results.collectionNumber) {
556     case AFS_XSTATSCOLL_CALL_INFO:
557         PrintCallInfo();
558         break;
559
560     case AFS_XSTATSCOLL_PERF_INFO:
561         PrintPerfInfo();
562         break;
563
564     case AFS_XSTATSCOLL_FULL_PERF_INFO:
565         PrintFullPerfInfo();
566         break;
567
568     case AFS_XSTATSCOLL_CBSTATS:
569         PrintCbCounters();
570         break;
571
572     default:
573         printf("** Unknown collection: %d\n",
574                xstat_fs_Results.collectionNumber);
575     }
576
577     /*
578      * Return the happy news.
579      */
580     return (0);
581 }
582
583
584 /*------------------------------------------------------------------------
585  * CountListItems
586  *
587  * Description:
588  *      Given a pointer to the list of File Servers we'll be polling
589  *      (or, in fact, any list at all), compute the length of the list.
590  *
591  * Arguments:
592  *      struct cmd_item *a_firstItem : Ptr to first item in list.
593  *
594  * Returns:
595  *      Length of the above list.
596  *
597  * Environment:
598  *      Nothing interesting.
599  *
600  * Side Effects:
601  *      As advertised.
602  *------------------------------------------------------------------------*/
603
604 static int
605 CountListItems(struct cmd_item *a_firstItem)
606 {
607
608     int list_len;               /*List length */
609     struct cmd_item *curr_item; /*Ptr to current item */
610
611     list_len = 0;
612     curr_item = a_firstItem;
613
614     /*
615      * Count 'em up.
616      */
617     while (curr_item) {
618         list_len++;
619         curr_item = curr_item->next;
620     }
621
622     /*
623      * Return our tally.
624      */
625     return (list_len);
626 }
627
628
629 /*------------------------------------------------------------------------
630  * RunTheTest
631  *
632  * Description:
633  *      Routine called by the command line interpreter to execute the
634  *      meat of the program.  We count the number of File Servers
635  *      to watch, allocate enough space to remember all the connection
636  *      info for them, then go for it.
637  *      
638  *
639  * Arguments:
640  *      a_s : Ptr to the command line syntax descriptor.
641  *
642  * Returns:
643  *      0, but may exit the whole program on an error!
644  *
645  * Environment:
646  *      Nothing interesting.
647  *
648  * Side Effects:
649  *      As advertised.
650  *------------------------------------------------------------------------*/
651
652 int
653 RunTheTest(struct cmd_syndesc *a_s, void *dummy)
654 {
655     static char rn[] = "RunTheTest";    /*Routine name */
656     int code;                   /*Return code */
657     int numFSs;                 /*# File Servers to monitor */
658     int numCollIDs;             /*# collections to fetch */
659     int currFS;                 /*Loop index */
660     int currCollIDIdx;          /*Index of current collection ID */
661     afs_int32 *collIDP;         /*Ptr to array of collection IDs */
662     afs_int32 *currCollIDP;     /*Ptr to current collection ID */
663     struct cmd_item *curr_item; /*Current FS cmd line record */
664     struct sockaddr_in FSSktArray[20];  /*File Server socket array - FIX! */
665     struct hostent *he;         /*Host entry */
666     struct timeval tv;          /*Time structure */
667     int sleep_secs;             /*Number of seconds to sleep */
668     int initFlags;              /*Flags passed to the init fcn */
669     int waitCode;               /*Result of LWP_WaitProcess() */
670     int freq;                   /*Frequency of polls */
671     int period;                 /*Time in minutes of data collection */
672
673     /*
674      * Are we doing one-shot measurements?
675      */
676     if (a_s->parms[P_ONESHOT].items != 0)
677         one_shot = 1;
678
679     /*
680      * Are we doing debugging output?
681      */
682     if (a_s->parms[P_DEBUG].items != 0)
683         debugging_on = 1;
684
685     /*
686      * Pull out the number of File Servers to watch and the number of
687      * collections to get.
688      */
689     numFSs = CountListItems(a_s->parms[P_FS_NAMES].items);
690     numCollIDs = CountListItems(a_s->parms[P_COLL_IDS].items);
691
692     /* Get the polling frequency */
693     if (a_s->parms[P_FREQUENCY].items != 0)
694         freq = atoi(a_s->parms[P_FREQUENCY].items->data);
695     else
696         freq = 30;              /* default to 30 seconds */
697
698     /* Get the time duration to run the tests */
699     if (a_s->parms[P_PERIOD].items != 0)
700         period = atoi(a_s->parms[P_PERIOD].items->data);
701     else
702         period = 10;            /* default to 10 minutes */
703
704
705     /*
706      * Fill in the socket array for each of the File Servers listed.
707      */
708     curr_item = a_s->parms[P_FS_NAMES].items;
709     for (currFS = 0; currFS < numFSs; currFS++) {
710 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
711         FSSktArray[currFS].sin_family = AF_INET;        /*Internet family */
712 #else
713         FSSktArray[currFS].sin_family = htons(AF_INET); /*Internet family */
714 #endif
715         FSSktArray[currFS].sin_port = htons(7000);      /*FileServer port */
716         he = hostutil_GetHostByName(curr_item->data);
717         if (he == NULL) {
718             fprintf(stderr, "[%s] Can't get host info for '%s'\n", rn,
719                     curr_item->data);
720             exit(-1);
721         }
722         memcpy(&(FSSktArray[currFS].sin_addr.s_addr), he->h_addr, 4);
723
724         /*
725          * Move to the next File Server name.
726          */
727         curr_item = curr_item->next;
728
729     }                           /*Get socket info for each File Server */
730
731     /*
732      * Create and fill up the array of desired collection IDs.
733      */
734     if (debugging_on)
735         printf("Allocating %d long(s) for coll ID\n", numCollIDs);
736     collIDP = (afs_int32 *) (malloc(numCollIDs * sizeof(afs_int32)));
737     currCollIDP = collIDP;
738     curr_item = a_s->parms[P_COLL_IDS].items;
739     for (currCollIDIdx = 0; currCollIDIdx < numCollIDs; currCollIDIdx++) {
740         *currCollIDP = (afs_int32) (atoi(curr_item->data));
741         if (debugging_on)
742             printf("CollID at index %d is %d\n", currCollIDIdx, *currCollIDP);
743         curr_item = curr_item->next;
744         currCollIDP++;
745     };
746
747     /*
748      * Crank up the File Server prober, then sit back and have fun.
749      */
750     printf("\nStarting up the xstat_fs service, ");
751     initFlags = 0;
752     if (debugging_on) {
753         initFlags |= XSTAT_FS_INITFLAG_DEBUGGING;
754         printf("debugging enabled, ");
755     } else
756         printf("no debugging, ");
757     if (one_shot) {
758         initFlags |= XSTAT_FS_INITFLAG_ONE_SHOT;
759         printf("one-shot operation\n");
760     } else
761         printf("continuous operation\n");
762
763     code = xstat_fs_Init(numFSs,        /*Num servers */
764                          FSSktArray,    /*File Server socket array */
765                          freq,  /*Probe frequency */
766                          FS_Handler,    /*Handler routine */
767                          initFlags,     /*Initialization flags */
768                          numCollIDs,    /*Number of collection IDs */
769                          collIDP);      /*Ptr to collection ID array */
770     if (code) {
771         fprintf(stderr, "[%s] Error returned by xstat_fs_Init: %d\n", rn,
772                 code);
773         xstat_fs_Cleanup(1);    /*Get rid of malloc'ed structures */
774         exit(-1);
775     }
776
777     if (one_shot) {
778         /*
779          * One-shot operation; just wait for the collection to be done.
780          */
781         if (debugging_on)
782             printf("[%s] Calling LWP_WaitProcess() on event 0x%" AFS_PTR_FMT "\n", rn,
783                    &terminationEvent);
784         waitCode = LWP_WaitProcess(&terminationEvent);
785         if (debugging_on)
786             printf("[%s] Returned from LWP_WaitProcess()\n", rn);
787         if (waitCode) {
788             if (debugging_on)
789                 fprintf(stderr,
790                         "[%s] Error %d encountered by LWP_WaitProcess()\n",
791                         rn, waitCode);
792         }
793     } else {
794         /*
795          * Continuous operation.
796          */
797         sleep_secs = 60 * period;       /*length of data collection */
798         printf
799             ("xstat_fs service started, main thread sleeping for %d secs.\n",
800              sleep_secs);
801
802         /*
803          * Let's just fall asleep for a while, then we'll clean up.
804          */
805         tv.tv_sec = sleep_secs;
806         tv.tv_usec = 0;
807         code = IOMGR_Select(0,  /*Num fds */
808                             0,  /*Descriptors ready for reading */
809                             0,  /*Descriptors ready for writing */
810                             0,  /*Descriptors with exceptional conditions */
811                             &tv);       /*Timeout structure */
812         if (code) {
813             fprintf(stderr,
814                     "[%s] IOMGR_Select() returned non-zero value: %d\n", rn,
815                     code);
816         }
817     }
818
819     /*
820      * We're all done.  Clean up, put the last nail in Rx, then
821      * exit happily.
822      */
823     if (debugging_on)
824         printf("\nYawn, main thread just woke up.  Cleaning things out...\n");
825
826     code = xstat_fs_Cleanup(1); /*Get rid of malloc'ed data */
827     rx_Finalize();
828     return (0);
829 }
830
831
832 #include "AFS_component_version_number.c"
833
834 int
835 main(int argc, char **argv)
836 {
837     static char rn[] = "xstat_fs_test"; /*Routine name */
838     register afs_int32 code;    /*Return code */
839     struct cmd_syndesc *ts;     /*Ptr to cmd line syntax desc */
840
841     /*
842      * Set up the commands we understand.
843      */
844     ts = cmd_CreateSyntax("initcmd", RunTheTest, 0, "initialize the program");
845     cmd_AddParm(ts, "-fsname", CMD_LIST, CMD_REQUIRED,
846                 "File Server name(s) to monitor");
847     cmd_AddParm(ts, "-collID", CMD_LIST, CMD_REQUIRED,
848                 "Collection(s) to fetch");
849     cmd_AddParm(ts, "-onceonly", CMD_FLAG, CMD_OPTIONAL,
850                 "Collect results exactly once, then quit");
851     cmd_AddParm(ts, "-frequency", CMD_SINGLE, CMD_OPTIONAL,
852                 "poll frequency, in seconds");
853     cmd_AddParm(ts, "-period", CMD_SINGLE, CMD_OPTIONAL,
854                 "data collection time, in minutes");
855     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
856                 "turn on debugging output");
857
858     /*
859      * Parse command-line switches & execute the test, then get the
860      * heck out of here.
861      */
862     code = cmd_Dispatch(argc, argv);
863     if (code) {
864         fprintf(stderr, "[%s] Call to cmd_Dispatch() failed; code is %d\n",
865                 rn, code);
866     }
867
868     exit(code);
869 }