Bug Summary

File:xstat/xstat_fs_test.c
Location:line 819, column 5
Description:Value stored to 'code' is never read

Annotated Source Code

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