Prototype strcasestr in afsmonitor.c
[openafs.git] / src / afsmonitor / afsmonitor.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  * Portions Copyright (c) 2003 Apple Computer, Inc.
10  */
11
12 /*
13  * Afsmonitor: An AFS Performance Monitoring Tool
14  *
15  *-------------------------------------------------------------------------*/
16
17
18 #include <afsconfig.h>
19 #include <afs/param.h>
20
21
22 #include <stdio.h>
23 #include <math.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <cmd.h>
27 #include <signal.h>
28 #undef IN
29 #include <sys/types.h>
30 #include <netinet/in.h>
31 #include <sys/socket.h>
32 #include <netdb.h>
33 #include <ctype.h>
34
35 #include <gtxwindows.h>         /*Generic window package */
36 #include <gtxobjects.h>         /*Object definitions */
37 #include <gtxlightobj.h>        /*Light object interface */
38 #include <gtxcurseswin.h>       /*Curses window package */
39 #include <gtxdumbwin.h>         /*Dumb terminal window package */
40 #include <gtxX11win.h>          /*X11 window package */
41 #include <gtxframe.h>           /*Frame package */
42 #include <gtxinput.h>
43
44 #include <afs/xstat_fs.h>
45 #include <afs/xstat_cm.h>
46
47 #include "afsmonitor.h"
48
49 /* command line parameter indices */
50
51 #define P_CONFIG        0
52 #define P_FREQUENCY     1
53 #define P_OUTPUT        2
54 #define P_DETAILED      3
55 /* #define P_PACKAGE    X */
56 #define P_DEBUG         4
57 #define P_FSHOSTS       5
58 #define P_CMHOSTS       6
59 #define P_BUFFERS       7
60
61
62 int afsmon_debug = 0;           /* debug info to file ? */
63 FILE *debugFD;                  /* debugging file descriptor */
64 static int afsmon_output = 0;   /* output to file ? */
65 static int afsmon_detOutput = 0;        /* detailed output ? */
66 static int afsmon_onceOnly = 0; /* probe once only ? (not implemented) */
67 int afsmon_probefreq;           /* probe frequency */
68 static int wpkg_to_use;         /* graphics package to use */
69 static char output_filename[80];        /* output filename */
70 char errMsg[256];               /* buffers used to print error messages after */
71 char errMsg1[256];              /* gtx is initialized (stderr/stdout gone !) */
72 int num_bufSlots = 0;           /* number of slots in fs & cm circular buffers */
73
74 /* Flags used to process "show" directives in config file */
75 short fs_showFlags[NUM_FS_STAT_ENTRIES];
76 short cm_showFlags[NUM_CM_STAT_ENTRIES];
77
78
79 /* afsmonitor misc definitions */
80
81 #define DEFAULT_FREQUENCY 60    /* default proble frequency in seconds */
82 #define DEFAULT_BUFSLOTS  0     /* default number of buffer slots */
83 #define CFG_STR_LEN     80      /* max length of config file fields */
84 #define FS 1                    /* for misc. use */
85 #define CM 2                    /* for misc. use */
86
87
88 #define NUM_XSTAT_FS_AFS_PERFSTATS_LONGS 66     /* number of fields (longs) in struct afs_PerfStats that we display */
89 #define NUM_AFS_STATS_CMPERF_LONGS 40   /* number of longs in struct afs_stats_CMPerf excluding up/down stats and fields we dont display */
90
91
92 /* variables used for exec'ing user provided threshold handlers */
93 char *fsHandler_argv[20];       /* *argv[] for the handler */
94 char fsHandler_args[20][256];   /* buffer space for arguments */
95 int exec_fsThreshHandler = 0;   /* execute fs threshold handler ? */
96
97
98 /* THRESHOLD STRUCTURE DEFINITIONS */
99
100 /* flag to indicate that threshold entries apply to all hosts. these will
101    be turned off when the first fs or cm host entry is processed */
102 static int global_ThreshFlag = 1;
103 static int global_fsThreshCount = 0;    /* number of global fs thresholds */
104 static int global_cmThreshCount = 0;    /* number of global cm thresholds */
105
106
107
108 /* Linked lists of file server and cache manager host names are made from
109 the entries in the config file. Head pointers to FS and CM server name lists. */
110 static struct afsmon_hostEntry *FSnameList;
111 static struct afsmon_hostEntry *CMnameList;
112
113 /* number of fileservers and cache managers to monitor */
114 int numFS = 0;
115 int numCM = 0;
116
117 /* variables used for processing config file */
118 /* ptr to the hostEntry structure of the last "fs" or "cm" entry processed
119 in the config file */
120 static struct afsmon_hostEntry *last_hostEntry;
121 /* names of the last host processed in the config file */
122 static char last_fsHost[HOST_NAME_LEN];
123 static char last_cmHost[HOST_NAME_LEN];
124 static int lastHostType = 0;    /* 0 = no host entries processed
125                                  * 1 = last host was file server
126                                  * 2 = last host was cache manager. */
127
128
129 /* FILE SERVER CIRCULAR BUFFER VARIABLES  */
130
131 struct afsmon_fs_Results_list {
132     struct xstat_fs_ProbeResults *fsResults;    /* ptr to results struct */
133     int empty;                  /* fsResults empty ? */
134     struct afsmon_fs_Results_list *next;
135 };
136
137 struct afsmon_fs_Results_CBuffer {
138     int probeNum;               /* probe number of entries in this slot */
139     struct afsmon_fs_Results_list *list;        /* ptr to list of results */
140 };
141
142 /* buffer for FS probe results */
143 struct afsmon_fs_Results_CBuffer *afsmon_fs_ResultsCB;
144
145 int afsmon_fs_curr_CBindex = 0; /* current fs CB slot */
146
147 /* Probe number variables. The current probe number is incremented 
148 when the first probe from a new probe cycle is received. The prev probe
149 number is incremented when the last probe of the current cycle is
150 received. This difference is because of the purpose for which these
151 counters are used */
152
153 int afsmon_fs_curr_probeNum = 1;        /* current fs probe number */
154 int afsmon_fs_prev_probeNum = 0;        /* previous fs probe number */
155
156
157 /* CACHE MANAGER CIRCULAR BUFFER VARIABLES  */
158
159 struct afsmon_cm_Results_list {
160     struct xstat_cm_ProbeResults *cmResults;    /* ptr to results struct */
161     int empty;                  /* cmResults empty ? */
162     struct afsmon_cm_Results_list *next;
163 };
164
165 struct afsmon_cm_Results_CBuffer {
166     int probeNum;               /* probe number of entries in this slot */
167     struct afsmon_cm_Results_list *list;        /* ptr to list of results */
168 };
169
170 /* buffer for CM probe results */
171 struct afsmon_cm_Results_CBuffer *afsmon_cm_ResultsCB;
172
173 int afsmon_cm_curr_CBindex = 0; /* current cm CB slot */
174
175
176 /* Probe number variables. The current probe number is incremented 
177 when the first probe from a new probe cycle is received. The prev probe
178 number is incremented when the last probe of the current cycle is
179 received. This difference is because of the purpose for which these
180 counters are used */
181
182 int afsmon_cm_curr_probeNum = 1;        /* current cm probe number */
183 int afsmon_cm_prev_probeNum = 0;        /* previous cm probe number */
184
185
186 /* Structures to hold FS & CM results in string format(suitable for display ) */
187
188 /* ptr to array holding the results of FS probes in ascii format */
189         /* for current probe cycle */
190 struct fs_Display_Data *curr_fsData = (struct fs_Display_Data *)0;
191         /* for previous probe cycle */
192 struct fs_Display_Data *prev_fsData = (struct fs_Display_Data *)0;
193
194
195 /* ptr to array holding the results of CM probes in ascii format */
196         /* for current probe cycle */
197 struct cm_Display_Data *curr_cmData = (struct cm_Display_Data *)0;
198         /* for previous probe cycle */
199 struct cm_Display_Data *prev_cmData = (struct cm_Display_Data *)0;
200
201 /* EXTERN DEFINITIONS */
202
203 /* file server and cache manager variable names (from afsmon_labels.h) */
204 extern char *fs_varNames[];
205 extern char *cm_varNames[];
206
207 /* GTX & MISC VARIABLES */
208
209 /* afsmonitor window */
210 extern struct gwin *afsmon_win;
211
212 /* current page number in the overview frame */
213 extern int ovw_currPage;
214
215 /* number of FS alerts and number of hosts on FS alerts */
216 int num_fs_alerts;
217 int numHosts_onfs_alerts;
218
219 /* number of CM alerts and number of hosts on FS alerts */
220 int num_cm_alerts;
221 int numHosts_oncm_alerts;
222
223 /* flag to indicate that atleast one probe cycle has completed and 
224 data is available for updating the display */
225 extern int fs_Data_Available;
226 extern int cm_Data_Available;
227
228 extern int gtx_initialized;     /* gtx initialized ? */
229
230 /* This array contains the indices of the file server data items that
231 are to be displayed on the File Servers screen. For example, suppose the
232 user wishes to display only the vcache statistics then the following array
233 will contain indices 2 to 14 corresponding to the position of the
234 vcache data items in the fs_varNames[] array. If the config file contains
235 no "show fs .." directives, it will contain the indices of all the 
236 items in the fs_varNames[] array */
237
238 short fs_Display_map[XSTAT_FS_FULLPERF_RESULTS_LEN];
239 int fs_DisplayItems_count = 0;  /* number of items to display */
240 int fs_showDefault = 1;         /* show all of FS data ? */
241
242
243 /* same use as above for Cache Managers  */
244 short cm_Display_map[XSTAT_CM_FULLPERF_RESULTS_LEN];
245 int cm_DisplayItems_count = 0;  /* number of items to display */
246 int cm_showDefault = 1;         /* show all of CM data ? */
247
248 extern int fs_currPage;         /* current page number in the File Servers frame */
249 extern int fs_curr_LCol;        /* current leftmost column on display on FS frame */
250
251 extern int cm_currPage;         /* current page number in the Cache Managers frame */
252 extern int cm_curr_LCol;        /* current leftmost column on display on CM frame */
253
254 /* File server and Cache manager data is classified into sections & 
255 groups to help the user choose what he wants displayed */
256 extern char *fs_categories[];   /* file server data category names */
257 extern char *cm_categories[];   /* cache manager data category names */
258
259
260
261 #ifdef HAVE_STRCASESTR
262 extern char * strcasestr(const char *, const char *);
263 #else
264 /*      
265         strcasestr(): Return first occurence of pattern s2 in s1, case 
266         insensitive. 
267
268         This routine is required since I made pattern matching of the
269         config file to be case insensitive. 
270 */
271
272 char *
273 strcasestr(s1, s2)
274      char *s1;
275      char *s2;
276 {
277     char *ptr;
278     int len1, len2;
279
280     len1 = strlen(s1);
281     len2 = strlen(s2);
282
283     if (len1 < len2)
284         return ((char *)NULL);
285
286     ptr = s1;
287
288     while (len1 >= len2 && len1 > 0) {
289         if ((strncasecmp(ptr, s2, len2)) == 0)
290             return (ptr);
291         ptr++;
292         len1--;
293     }
294     return ((char *)NULL);
295 }
296 #endif
297
298 struct hostent *
299 GetHostByName(char *name)
300 {
301     struct hostent *he;
302 #ifdef AFS_SUN5_ENV
303     char ip_addr[32];
304 #endif
305
306     he = gethostbyname(name);
307 #ifdef AFS_SUN5_ENV
308     /* On solaris the above does not resolve hostnames to full names */
309     if (he != NULL) {
310         memcpy(ip_addr, he->h_addr, he->h_length);
311         he = gethostbyaddr(ip_addr, he->h_length, he->h_addrtype);
312     }
313 #endif
314     return (he);
315 }
316
317
318 /*-----------------------------------------------------------------------
319  * afsmon_Exit()
320  *
321  * Description
322  *      Exit gracefully from the afsmonitor. Frees memory where appropriate,
323  *      cleans up after gtx and closes all open file descriptors. If a user 
324  *      provided threshold handler is to be exec'ed then gtx cleanup is
325  *      not performed and an exec() is made instead of an exit(). 
326  *
327  * Returns
328  *      Nothing.
329  *
330  * Comments 
331  *      This function is called to execute a user handler only 
332  *      by a child process.
333  * 
334  *----------------------------------------------------------------------*/
335
336 int
337 afsmon_Exit(int a_exitVal)      /* exit code */
338 {                               /* afsmon_Exit */
339     static char rn[] = "afsmon_Exit";
340     struct afsmon_fs_Results_list *tmp_fslist;
341     struct afsmon_fs_Results_list *next_fslist;
342     struct xstat_fs_ProbeResults *tmp_xstat_fsPR;
343     struct afsmon_cm_Results_list *tmp_cmlist;
344     struct afsmon_cm_Results_list *next_cmlist;
345     struct xstat_cm_ProbeResults *tmp_xstat_cmPR;
346     struct afsmon_hostEntry *curr_hostEntry;
347     struct afsmon_hostEntry *prev_hostEntry;
348     int i;
349     int j;
350     int bufslot;
351     int code;
352
353     if (afsmon_debug) {
354         fprintf(debugFD, "[ %s ] Called with exit code %d\n", rn, a_exitVal);
355         fflush(debugFD);
356     }
357
358     /* get out of curses first, but not if we are here to exec a threshold
359      * handler. If we do, the screen gets messed up  */
360     if (gtx_initialized && !exec_fsThreshHandler)
361         gator_cursesgwin_cleanup(afsmon_win);
362
363     /* print the error message buffer */
364     if (errMsg[0] != '\0')
365         fprintf(stderr, "%s", errMsg);
366     if (errMsg1[0] != '\0')
367         fprintf(stderr, "%s", errMsg1);
368
369     /* deallocate file server circular buffers */
370     if (numFS && num_bufSlots) {
371         if (afsmon_debug) {
372             fprintf(debugFD, "freeing FS circular buffers ");
373             fflush(debugFD);
374         }
375
376         for (bufslot = 0; bufslot < num_bufSlots; bufslot++) {
377             if (afsmon_debug)
378                 fprintf(debugFD, " %d) ", bufslot);
379             if (afsmon_fs_ResultsCB[bufslot].list !=
380                 (struct afsmon_fs_Results_list *)0) {
381                 tmp_fslist = afsmon_fs_ResultsCB[bufslot].list;
382                 j = numFS;
383                 while (tmp_fslist) {
384                     /* make sure we do not go astray */
385                     if (--j < 0) {
386                         if (afsmon_debug)
387                             fprintf(debugFD,
388                                     "[ %s ] error in deallocating fs CB\n",
389                                     rn);
390                         break;
391                     }
392                     next_fslist = tmp_fslist->next;
393                     tmp_xstat_fsPR = tmp_fslist->fsResults;
394
395                     if (afsmon_debug)
396                         fprintf(debugFD, "%d ", numFS - j);
397
398                     /* free xstat_fs_Results data */
399                     free(tmp_xstat_fsPR->data.AFS_CollData_val);
400                     free(tmp_xstat_fsPR->connP);
401                     free(tmp_xstat_fsPR);
402
403                     /* free the fs list item */
404                     free(tmp_fslist);
405                     tmp_fslist = next_fslist;
406
407                 }               /* while fs list items in this slot */
408             }                   /* if entries in this buffer slot */
409         }                       /* for each fs buffer slot */
410         if (afsmon_debug)
411             fprintf(debugFD, "\n");
412     }
413
414     if (afsmon_debug)
415         fflush(debugFD);
416     /* deallocate cache manager curcular buffers */
417     if (numCM && num_bufSlots) {
418         if (afsmon_debug)
419             fprintf(debugFD, "freeing CM curcular buffers ");
420         for (bufslot = 0; bufslot < num_bufSlots; bufslot++) {
421             if (afsmon_debug)
422                 fprintf(debugFD, " %d) ", bufslot);
423             if (afsmon_cm_ResultsCB[bufslot].list !=
424                 (struct afsmon_cm_Results_list *)0) {
425                 tmp_cmlist = afsmon_cm_ResultsCB[bufslot].list;
426                 j = numCM;
427                 while (tmp_cmlist) {
428                     /* make sure we do not go astray */
429                     if (--j < 0) {
430                         if (afsmon_debug)
431                             fprintf(debugFD,
432                                     "[ %s ] error in deallocating cm CB\n",
433                                     rn);
434                         break;
435                     }
436                     next_cmlist = tmp_cmlist->next;
437                     tmp_xstat_cmPR = tmp_cmlist->cmResults;
438
439                     if (afsmon_debug)
440                         fprintf(debugFD, "%d ", numCM - j);
441                     /* make sure data is ok */
442                     /* Print_cm_FullPerfInfo(tmp_xstat_cmPR); */
443
444                     /* free xstat_cm_Results data */
445                     free(tmp_xstat_cmPR->data.AFSCB_CollData_val);
446                     free(tmp_xstat_cmPR->connP);
447                     free(tmp_xstat_cmPR);
448
449                     /* free the cm list item */
450                     free(tmp_cmlist);
451                     tmp_cmlist = next_cmlist;
452
453                 }               /* while cm list items in this slot */
454             }                   /* if entries in this buffer slot */
455         }                       /* for each cm buffer slot */
456         if (afsmon_debug)
457             fprintf(debugFD, "\n");
458     }
459
460
461     /* deallocate FS & CM Print buffers */
462     if (curr_fsData != (struct fs_Display_Data *)0) {
463         if (afsmon_debug)
464             fprintf(debugFD, "Deallocating FS Print Buffers .... curr");
465         free(curr_fsData);
466     }
467     if (prev_fsData != (struct fs_Display_Data *)0) {
468         if (afsmon_debug)
469             fprintf(debugFD, ", prev \n");
470         free(prev_fsData);
471     }
472     if (prev_cmData != (struct cm_Display_Data *)0) {
473         if (afsmon_debug)
474             fprintf(debugFD, "Deallocating CM Print Buffers .... curr");
475         free(curr_cmData);
476     }
477     if (prev_cmData != (struct cm_Display_Data *)0) {
478         if (afsmon_debug)
479             fprintf(debugFD, ", prev \n");
480         free(prev_cmData);
481     }
482
483     /* deallocate hostEntry lists */
484     if (numFS) {
485         if (afsmon_debug)
486             fprintf(debugFD, "Deallocating FS hostEntries ..");
487         curr_hostEntry = FSnameList;
488         for (i = 0; i < numFS; i++) {
489             prev_hostEntry = curr_hostEntry;
490             if (curr_hostEntry->thresh != NULL)
491                 free(curr_hostEntry->thresh);
492             free(curr_hostEntry);
493             if (afsmon_debug)
494                 fprintf(debugFD, " %d", i);
495             curr_hostEntry = prev_hostEntry->next;
496         }
497         if (afsmon_debug)
498             fprintf(debugFD, "\n");
499     }
500     if (numCM) {
501         if (afsmon_debug)
502             fprintf(debugFD, "Deallocating CM hostEntries ..");
503         curr_hostEntry = CMnameList;
504         for (i = 0; i < numCM; i++) {
505             prev_hostEntry = curr_hostEntry;
506             if (curr_hostEntry->thresh != NULL)
507                 free(curr_hostEntry->thresh);
508             free(curr_hostEntry);
509             if (afsmon_debug)
510                 fprintf(debugFD, " %d", i);
511             curr_hostEntry = prev_hostEntry->next;
512         }
513         if (afsmon_debug)
514             fprintf(debugFD, "\n");
515     }
516
517     /* close debug file */
518     if (afsmon_debug) {
519         fflush(debugFD);
520         fclose(debugFD);
521     }
522
523     if (exec_fsThreshHandler) {
524         code = execvp(fsHandler_argv[0], fsHandler_argv);
525         if (code == -1) {
526             fprintf(stderr, "execvp() of %s returned %d, errno %d\n",
527                     fsHandler_argv[0], code, errno);
528             exit(-1);
529         }
530     }
531
532     exit(a_exitVal);
533 }                               /* afsmon_Exit */
534
535 /*-----------------------------------------------------------------------
536  * insert_FS()
537  *
538  * Description:
539  *      Insert a hostname in the file server names list.
540  *
541  * Returns:
542  *      Success: 0
543  *      Failure: -1
544  *----------------------------------------------------------------------*/
545
546 int
547 insert_FS(char *a_hostName)             /* name of cache manager to be inserted in list */
548 {                               /* insert_FS() */
549     static struct afsmon_hostEntry *curr_item;
550     static struct afsmon_hostEntry *prev_item;
551
552     if (*a_hostName == '\0')
553         return (-1);
554     curr_item = (struct afsmon_hostEntry *)
555         malloc(sizeof(struct afsmon_hostEntry));
556     if (curr_item == (struct afsmon_hostEntry *)0) {
557         fprintf(stderr, "Failed to allocate space for FS nameList\n");
558         return (-1);
559     }
560
561     strncpy(curr_item->hostName, a_hostName, CFG_STR_LEN);
562     curr_item->next = (struct afsmon_hostEntry *)0;
563     curr_item->numThresh = 0;
564     curr_item->thresh = NULL;
565
566     if (FSnameList == (struct afsmon_hostEntry *)0)
567         FSnameList = curr_item;
568     else
569         prev_item->next = curr_item;
570
571     prev_item = curr_item;
572     /*  record the address of this entry so that its threshold
573      * count can be incremented during  the first pass of the config file */
574     last_hostEntry = curr_item;
575
576     return (0);
577 }
578
579 /*-----------------------------------------------------------------------
580  * print_FS()
581  *
582  * Description:
583  *      Debug routine.
584  *      Prints the file server names linked list.
585  *
586  * Returns:
587  *      Nothing.
588  *----------------------------------------------------------------------*/
589 void
590 print_FS(void)
591 {                               /* print_FS() */
592     static char rn[] = "print_FS";
593     struct afsmon_hostEntry *tempFS;
594     struct Threshold *threshP;
595     int i;
596
597     if (afsmon_debug) {
598         fprintf(debugFD, "[ %s ] Called\n", rn);
599         fflush(debugFD);
600     }
601
602     if (afsmon_debug) {
603         tempFS = FSnameList;
604         fprintf(debugFD, "No of File Servers: %d\n", numFS);
605         if (numFS) {
606             do {
607                 fprintf(debugFD, "\t %s threshCount = %d\n", tempFS->hostName,
608                         tempFS->numThresh);
609                 threshP = tempFS->thresh;
610                 for (i = 0; i < tempFS->numThresh; i++, threshP++)
611                     fprintf(debugFD, "\t thresh (%2d) %s %s %s\n",
612                             threshP->index, threshP->itemName,
613                             threshP->threshVal, threshP->handler);
614             } while ((tempFS = tempFS->next) != (struct afsmon_hostEntry *)0);
615         }
616         fprintf(debugFD, "\t\t-----End of List-----\n");
617         fflush(debugFD);
618     }
619
620 }
621
622 /*-----------------------------------------------------------------------
623  * insert_CM()
624  *
625  * Description:
626  *      Insert a hostname in the cache manager names list.
627  *
628  * Returns:
629  *      Success: 0
630  *      Failure: -1
631  *----------------------------------------------------------------------*/
632
633 int
634 insert_CM(char *a_hostName)             /* name of cache manager to be inserted in list */
635 {                               /* insert_CM */
636     static struct afsmon_hostEntry *curr_item;
637     static struct afsmon_hostEntry *prev_item;
638
639     if (*a_hostName == '\0')
640         return (-1);
641     curr_item = (struct afsmon_hostEntry *)
642         malloc(sizeof(struct afsmon_hostEntry));
643     if (curr_item == (struct afsmon_hostEntry *)0) {
644         fprintf(stderr, "Failed to allocate space for CM nameList\n");
645         return (-1);
646     }
647
648     strncpy(curr_item->hostName, a_hostName, CFG_STR_LEN);
649     curr_item->next = (struct afsmon_hostEntry *)0;
650     curr_item->numThresh = 0;
651     curr_item->thresh = NULL;
652
653     if (CMnameList == (struct afsmon_hostEntry *)0)
654         CMnameList = curr_item;
655     else
656         prev_item->next = curr_item;
657
658     prev_item = curr_item;
659     /* side effect. note the address of this entry so that its threshold
660      * count can be incremented during  the first pass of the config file */
661     last_hostEntry = curr_item;
662
663     return (0);
664 }
665
666
667 /*-----------------------------------------------------------------------
668  * print_CM()
669  *
670  * Description:
671  *      Debug routine.
672  *      Prints the cache manager names linked list.
673  *
674  * Returns:
675  *      Nothing.
676  *----------------------------------------------------------------------*/
677 int
678 print_CM(void)
679 {                               /* print_CM() */
680     static char rn[] = "print_CM";
681     struct afsmon_hostEntry *tempCM;
682     struct Threshold *threshP;
683     int i;
684
685     if (afsmon_debug) {
686         fprintf(debugFD, "[ %s ] Called\n", rn);
687         fflush(debugFD);
688     }
689
690     if (afsmon_debug) {
691         tempCM = CMnameList;
692         fprintf(debugFD, "No of Cache Managers: %d\n", numCM);
693         if (numCM) {
694             do {
695                 fprintf(debugFD, "\t %s threshCount = %d\n", tempCM->hostName,
696                         tempCM->numThresh);
697                 threshP = tempCM->thresh;
698                 for (i = 0; i < tempCM->numThresh; i++, threshP++)
699                     fprintf(debugFD, "\t thresh (%2d) %s %s %s\n",
700                             threshP->index, threshP->itemName,
701                             threshP->threshVal, threshP->handler);
702             } while ((tempCM = tempCM->next) != (struct afsmon_hostEntry *)0);
703         }
704         fprintf(debugFD, "\t\t-----End of List-----\n");
705     }
706     return (0);
707 }                               /* print_CM() */
708
709
710
711 /*-----------------------------------------------------------------------
712  * parse_hostEntry()
713  *
714  * Description:
715  *      Parse the host entry line in the config file. Check the syntax,
716  *      and inserts the host name in the FS ot CM linked list. Also
717  *      remember if this entry was an fs or cm & the ptr to its hostEntry
718  *      structure. The threshold entries in the config file are dependent
719  *      on their position relative to the hostname entries. Hence it is
720  *      required to remember the names of the last file server and cache
721  *      manager entries that were processed.
722  *
723  * Returns:
724  *      Success: 0
725  *      Failure: -1
726  *
727  *----------------------------------------------------------------------*/
728
729 int
730 parse_hostEntry(char *a_line)
731 {                               /* parse_hostEntry */
732
733     static char rn[] = "parse_hostEntry";       /* routine name */
734     char opcode[CFG_STR_LEN];   /* specifies type of config entry */
735     char arg1[CFG_STR_LEN];     /* hostname or qualifier (fs/cm?)  */
736     char arg2[CFG_STR_LEN];     /* threshold variable */
737     char arg3[CFG_STR_LEN];     /* threshold value */
738     char arg4[CFG_STR_LEN];     /* user's handler  */
739     struct hostent *he;         /* host entry */
740
741     if (afsmon_debug) {
742         fprintf(debugFD, "[ %s ] Called, a_line = %s\n", rn, a_line);
743         fflush(debugFD);
744     }
745
746     /* break it up */
747     opcode[0] = 0;
748     arg1[0] = 0;
749     arg2[0] = 0;
750     arg3[0] = 0;
751     arg4[0] = 0;
752     sscanf(a_line, "%s %s %s %s %s", opcode, arg1, arg2, arg3, arg4);
753     /* syntax is "opcode hostname" */
754     if ((strlen(arg2)) != 0) {
755         fprintf(stderr, "[ %s ] Extraneous characters at end of line\n", rn);
756         return (-1);
757     }
758
759     /* good host ? */
760     he = GetHostByName(arg1);
761     if (he == NULL) {
762         fprintf(stderr, "[ %s ] Unable to resolve hostname %s\n", rn, arg1);
763         return (-1);
764     }
765
766     if ((strcasecmp(opcode, "fs")) == 0) {
767         /* use the complete host name to insert in the file server names list */
768         insert_FS(he->h_name);
769         /* note that last host entry in the config file was fs */
770         lastHostType = 1;
771         numFS++;
772         /* threholds are not global anymore */
773         if (global_ThreshFlag)
774             global_ThreshFlag = 0;
775     } else if ((strcasecmp(opcode, "cm")) == 0) {
776         /* use the complete host name to insert in the CM names list */
777         insert_CM(he->h_name);
778         /* last host entry in the config file was cm */
779         lastHostType = 2;
780         numCM++;
781         /* threholds are not global anymore */
782         if (global_ThreshFlag)
783             global_ThreshFlag = 0;
784     } else
785         return (-1);
786
787     return (0);
788 }
789
790 /*-----------------------------------------------------------------------
791  * parse_threshEntry()
792  *
793  * Description
794  *      Parse the threshold entry line in the config file. This function is
795  *      called in the the first pass of the config file. It checks the syntax 
796  *      of the config lines and verifies their positional validity - eg.,
797  *      a cm threshold cannot appear after a fs hostname entry, etc.
798  *      It also counts the thresholds applicable to each host.
799  *
800  * Returns
801  *      Success: 0
802  *      Failure: -1
803  *
804  *----------------------------------------------------------------------*/
805
806 int
807 parse_threshEntry(char *a_line)
808 {                               /* parse_threshEntry */
809     static char rn[] = "parse_threshEntry";     /* routine name */
810     char opcode[CFG_STR_LEN];   /* specifies type of config entry */
811     char arg1[CFG_STR_LEN];     /* hostname or qualifier (fs/cm?)  */
812     char arg2[CFG_STR_LEN];     /* threshold variable */
813     char arg3[CFG_STR_LEN];     /* threshold value */
814     char arg4[CFG_STR_LEN];     /* user's handler  */
815     char arg5[CFG_STR_LEN];     /* junk characters */
816
817     if (afsmon_debug) {
818         fprintf(debugFD, "[ %s ] Called, a_line = %s\n", rn, a_line);
819         fflush(debugFD);
820     }
821
822     /* break it up */
823     opcode[0] = 0;
824     arg1[0] = 0;
825     arg2[0] = 0;
826     arg3[0] = 0;
827     arg4[0] = 0;
828     arg5[0] = 0;
829     sscanf(a_line, "%s %s %s %s %s %s", opcode, arg1, arg2, arg3, arg4, arg5);
830
831     /* syntax is "thresh fs/cm variable_name threshold_value [handler] " */
832     if (((strlen(arg1)) == 0) || ((strlen(arg2)) == 0)
833         || ((strlen(arg3)) == 0)) {
834         fprintf(stderr, "[ %s ] Incomplete line\n", rn);
835         return (-1);
836     }
837     if (strlen(arg3) > THRESH_VAR_LEN - 2) {
838         fprintf(stderr, "[%s ] threshold value too long\n", rn);
839         return (-1);
840     }
841
842     if ((strcasecmp(arg1, "fs")) == 0) {
843         switch (lastHostType) {
844         case 0:         /* its a global threshold */
845             global_fsThreshCount++;
846             break;
847         case 1:         /* inc thresh count of last file server */
848             last_hostEntry->numThresh++;
849             break;
850         case 2:
851             fprintf(stderr,
852                     "[ %s ] A threshold for a File Server cannot be placed after a Cache Manager host entry in the config file \n",
853                     rn);
854             return (-1);
855         default:
856             fprintf(stderr, "[ %s ] Programming error 1\n", rn);
857             return (-1);
858         }
859     } else if ((strcasecmp(arg1, "cm")) == 0) {
860         switch (lastHostType) {
861         case 0:         /* its a global threshold */
862             global_cmThreshCount++;
863             break;
864         case 2:         /* inc thresh count of last cache manager */
865             last_hostEntry->numThresh++;
866             break;
867         case 1:
868             fprintf(stderr,
869                     "[ %s ] A threshold for a Cache Manager cannot be placed after a File Server host entry in the config file \n",
870                     rn);
871             return (-1);
872         default:
873             fprintf(stderr, "[ %s ] Programming error 2\n", rn);
874             return (-1);
875         }
876     } else {
877         fprintf(stderr,
878                 "[ %s ] Syntax error. Second argument should be \"fs\" or \"cm\" \n",
879                 rn);
880         return (-1);
881     }
882
883     return (0);
884 }                               /* parse_threshEntry */
885
886
887 /*-----------------------------------------------------------------------
888  * store_threshold()
889  *
890  * Description
891  *      The thresholds applicable to each host machine are stored in the
892  *      FSnameList and CMnameList. Threshold entries in the config file are
893  *      context sensitive. The host to which this threshold is applicable
894  *      is pointed to by last_fsHost (for file servers) and last_cmHost
895  *      for cache managers. For global thresholds the info is recorded for
896  *      all the hosts. This function is called in the second pass of the
897  *      config file. In the first pass a count of the number of global
898  *      thresholds is determined and this information is used in this 
899  *      routine. If threshold entries are duplicated the first entry is
900  *      overwritten.
901  *      Each threshold entry also has an index field. This is a positional
902  *      index to the corresponding variable in the prev_[fs/cm]Data arrays.
903  *      This makes it easy to check the threshold for overflow.
904  *
905  * Returns:
906  *      Success: 0
907  *      Failure: -1
908  *----------------------------------------------------------------------*/
909
910 int
911 store_threshold(int a_type,             /* 1 = fs , 2 = cm */
912                 char *a_varName,        /* threshold name */
913                 char *a_value,          /* threshold value */
914                 char *a_handler)        /* threshold overflow handler */
915 {                               /* store_thresholds */
916
917     static char rn[] = "store_thresholds";      /* routine name */
918     struct afsmon_hostEntry *tmp_host;  /* tmp ptr to hostEntry */
919     struct afsmon_hostEntry *Header;    /* tmp ptr to hostEntry list header */
920     struct Threshold *threshP;  /* tmp ptr to threshold list */
921     char *hostname;
922     int index;                  /* index to fs_varNames or cm_varNames */
923     int found;
924     int done;
925     int srvCount;               /* tmp count of host names */
926     int *global_TC;             /* ptr to global_xxThreshCount */
927     int i, j;
928
929     if (afsmon_debug) {
930         fprintf(debugFD,
931                 "[ %s ] Called, a_type= %d, a_varName= %s, a_value= %s, a_handler=%s\n",
932                 rn, a_type, a_varName, a_value, a_handler);
933         fflush(debugFD);
934     }
935
936     /* resolve the threshold variable name */
937     found = 0;
938     if (a_type == 1) {          /* fs threshold */
939         for (index = 0; index < NUM_FS_STAT_ENTRIES; index++) {
940             if (strcasecmp(a_varName, fs_varNames[index]) == 0) {
941                 found = 1;
942                 break;
943             }
944         }
945         if (!found) {
946             fprintf(stderr, "[ %s ] Unknown FS threshold variable name %s\n",
947                     rn, a_varName);
948             return (-1);
949         }
950         Header = FSnameList;
951         srvCount = numFS;
952         hostname = last_fsHost;
953         global_TC = &global_fsThreshCount;
954     } else if (a_type == 2) {   /* cm threshold */
955         for (index = 0; index < NUM_CM_STAT_ENTRIES; index++) {
956             if (strcasecmp(a_varName, cm_varNames[index]) == 0) {
957                 found = 1;
958                 break;
959             }
960         }
961         if (!found) {
962             fprintf(stderr, "[ %s ] Unknown CM threshold variable name %s\n",
963                     rn, a_varName);
964             return (-1);
965         }
966         Header = CMnameList;
967         srvCount = numCM;
968         hostname = last_cmHost;
969         global_TC = &global_cmThreshCount;
970     } else
971         return (-1);
972
973
974
975     /* if the global thresh count is not zero, place this threshold on
976      * all the host entries  */
977
978     if (*global_TC) {
979         tmp_host = Header;
980         for (i = 0; i < srvCount; i++) {
981             threshP = tmp_host->thresh;
982             done = 0;
983             for (j = 0; j < tmp_host->numThresh; j++) {
984                 if ((threshP->itemName[0] == '\0')
985                     || (strcasecmp(threshP->itemName, a_varName) == 0)) {
986                     strncpy(threshP->itemName, a_varName,
987                             THRESH_VAR_NAME_LEN);
988                     strncpy(threshP->threshVal, a_value, THRESH_VAR_LEN);
989                     strcpy(threshP->handler, a_handler);
990                     threshP->index = index;
991                     done = 1;
992                     break;
993                 }
994                 threshP++;
995             }
996             if (!done) {
997                 fprintf(stderr, "[ %s ] Could not insert threshold entry",
998                         rn);
999                 fprintf(stderr, "for %s in thresh list of host %s \n",
1000                         a_varName, tmp_host->hostName);
1001                 return (-1);
1002             }
1003             tmp_host = tmp_host->next;
1004         }
1005         (*global_TC)--;
1006         return (0);
1007     }
1008
1009     /* it is not a global threshold, insert it in the thresh list of this
1010      * host only. We overwrite the global threshold if it was alread set */
1011
1012     if (*hostname == '\0') {
1013         fprintf(stderr, "[ %s ] Programming error 3\n", rn);
1014         return (-1);
1015     }
1016
1017     /* get the hostEntry that this threshold belongs to */
1018     tmp_host = Header;
1019     found = 0;
1020     for (i = 0; i < srvCount; i++) {
1021         if (strcasecmp(tmp_host->hostName, hostname) == 0) {
1022             found = 1;
1023             break;
1024         }
1025         tmp_host = tmp_host->next;
1026     }
1027     if (!found) {
1028         fprintf(stderr, "[ %s ] Unable to find host %s in %s hostEntry list",
1029                 rn, hostname, (a_type - 1) ? "CM" : "FS");
1030         return (-1);
1031     }
1032
1033     /* put this entry on the thresh list of this host, overwrite global value
1034      * if needed */
1035
1036     threshP = tmp_host->thresh;
1037     done = 0;
1038     for (i = 0; i < tmp_host->numThresh; i++) {
1039         if ((threshP->itemName[0] == '\0')
1040             || (strcasecmp(threshP->itemName, a_varName) == 0)) {
1041             strncpy(threshP->itemName, a_varName, THRESH_VAR_NAME_LEN);
1042             strncpy(threshP->threshVal, a_value, THRESH_VAR_LEN);
1043             strcpy(threshP->handler, a_handler);
1044             threshP->index = index;
1045             done = 1;
1046             break;
1047         }
1048         threshP++;
1049     }
1050
1051     if (!done) {
1052         fprintf(stderr,
1053                 "[ %s ] Unable to insert threshold %s for %s host %s\n", rn,
1054                 a_varName, (a_type - 1) ? "CM" : "FS", tmp_host->hostName);
1055         return (-1);
1056     }
1057
1058     return (0);
1059
1060 }                               /* store_thresholds */
1061
1062
1063 /*-----------------------------------------------------------------------
1064  * parse_showEntry()
1065  *
1066  * Description:
1067  *      This function process a "show" entry in the config file. A "show"
1068  *      entry specifies what statistics the user wants to see. File
1069  *      server and Cache Manager data is divided into sections. Each section
1070  *      is made up of one or more groups. If a group name is specified only
1071  *      those statistics under that group are shown. If a section name is
1072  *      specified all the groups under this section are shown.
1073  *      Data as obtained from the xstat probes is considered to be ordered.
1074  *      This data is mapped to the screen thru fs_Display_map[] and
1075  *      cm_Display_map[]. This routine parses the "show" entry against the
1076  *      section/group names in the [fs/cm]_categories[] array. If there is
1077  *      no match it tries to match it against a variable name in 
1078  *      [fs/cm]_varNames[] array. In each case the corresponding indices to
1079  *      the data is the [fs/cm]_displayInfo[] is recorded. 
1080  *
1081  * Returns:
1082  *      Success: 0
1083  *      Failure: -1 (invalid entry)
1084  *               > -1 (programming error)
1085  *----------------------------------------------------------------------*/
1086
1087 int
1088 parse_showEntry(char *a_line)
1089 {                               /* parse_showEntry */
1090     static char rn[] = "parse_showEntry";
1091     char opcode[CFG_STR_LEN];   /* specifies type of config entry */
1092     char arg1[CFG_STR_LEN];     /* show fs or cm entry ? */
1093     char arg2[CFG_STR_LEN];     /* what we gotta show  */
1094     char arg3[CFG_STR_LEN];     /* junk */
1095     char catName[CFG_STR_LEN];  /* for category names */
1096     int numGroups;              /* number of groups in a section */
1097     int fromIdx;
1098     int toIdx;
1099     int found;
1100     int idx = 0;                /* index to fs_categories[] */
1101     int i;
1102     int j;
1103
1104
1105     if (afsmon_debug) {
1106         fprintf(debugFD, "[ %s ] Called, a_line= %s\n", rn, a_line);
1107         fflush(debugFD);
1108     }
1109     opcode[0] = 0;
1110     arg1[0] = 0;
1111     arg2[0] = 0;
1112     arg3[0] = 0;
1113     sscanf(a_line, "%s %s %s %s", opcode, arg1, arg2, arg3);
1114
1115     if (arg3[0] != '\0') {
1116         fprintf(stderr, "[ %s ] Extraneous characters at end of line\n", rn);
1117         return (-1);
1118     }
1119
1120     if ((strcasecmp(arg1, "fs") != 0) && (strcasecmp(arg1, "cm") != 0)) {
1121         fprintf(stderr,
1122                 "[ %s ] Second argument of \"show\" directive should be \"fs\" or \"cm\" \n",
1123                 rn);
1124         return (-1);
1125     }
1126
1127     /* Each entry can either be a variable name or a section/group name. Variable
1128      * names are listed in xx_varNames[] and section/group names in xx_categories[].
1129      * The section/group names in xx_categiries[] also give the starting/ending
1130      * indices of the variables belonging to that section/group. These indices
1131      * are stored in order in xx_Display_map[] and displayed to the screen in that
1132      * order. */
1133
1134     /* To handle duplicate "show" entries we keep track of what what we have
1135      * already marked to show in the xx_showFlags[] */
1136
1137     if (strcasecmp(arg1, "fs") == 0) {  /* its a File Server entry */
1138
1139         /* mark that we have to show only what the user wants */
1140         fs_showDefault = 0;
1141
1142         /* if it is a section/group name, find it in the fs_categories[] array */
1143
1144         found = 0;
1145         if (strcasestr(arg2, "_section") != (char *)NULL
1146             || strcasestr(arg2, "_group") != (char *)NULL) {
1147             idx = 0;
1148             while (idx < FS_NUM_DATA_CATEGORIES) {
1149                 sscanf(fs_categories[idx], "%s %d %d", catName, &fromIdx,
1150                        &toIdx);
1151                 idx++;
1152                 if (strcasecmp(arg2, catName) == 0) {
1153                     found = 1;
1154                     break;
1155                 }
1156             }
1157
1158             if (!found) {       /* typo in section/group name */
1159                 fprintf(stderr,
1160                         "[ %s ] Could not find section/group name %s\n", rn,
1161                         arg2);
1162                 return (-1);
1163             }
1164         }
1165
1166         /* if it is a group name, read its start/end indices and fill in the
1167          * fs_Display_map[]. */
1168
1169         if (strcasestr(arg2, "_group") != (char *)NULL) {
1170
1171             if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_FS_STAT_ENTRIES
1172                 || toIdx > NUM_FS_STAT_ENTRIES)
1173                 return (-2);
1174             for (j = fromIdx; j <= toIdx; j++) {
1175                 if (!fs_showFlags[j]) {
1176                     fs_Display_map[fs_DisplayItems_count] = j;
1177                     fs_DisplayItems_count++;
1178                     fs_showFlags[j] = 1;
1179                 }
1180                 if (fs_DisplayItems_count > NUM_FS_STAT_ENTRIES) {
1181                     fprintf(stderr, "[ %s ] fs_DisplayItems_count ovf\n", rn);
1182                     return (-3);
1183                 }
1184             }
1185         } else
1186             /* if it is a section name, get the count of number of groups in it and
1187              * for each group fill in the start/end indices in the fs_Display_map[] */
1188
1189         if (strcasestr(arg2, "_section") != (char *)NULL) {
1190             /* fromIdx is actually the number of groups in thi section */
1191             numGroups = fromIdx;
1192             /* for each group in section */
1193             while (idx < FS_NUM_DATA_CATEGORIES && numGroups) {
1194                 sscanf(fs_categories[idx], "%s %d %d", catName, &fromIdx,
1195                        &toIdx);
1196
1197                 if (strcasestr(catName, "_group") != NULL) {
1198                     if (fromIdx < 0 || toIdx < 0
1199                         || fromIdx > NUM_FS_STAT_ENTRIES
1200                         || toIdx > NUM_FS_STAT_ENTRIES)
1201                         return (-4);
1202                     for (j = fromIdx; j <= toIdx; j++) {
1203                         if (!fs_showFlags[j]) {
1204                             fs_Display_map[fs_DisplayItems_count] = j;
1205                             fs_DisplayItems_count++;
1206                             fs_showFlags[j] = 1;
1207                         }
1208                         if (fs_DisplayItems_count > NUM_FS_STAT_ENTRIES) {
1209                             fprintf(stderr,
1210                                     "[ %s ] fs_DisplayItems_count ovf\n", rn);
1211                             return (-5);
1212                         }
1213                     }
1214                 } else {
1215                     fprintf(stderr, "[ %s ] Error parsing groups for %s\n",
1216                             rn, arg2);
1217                     return (-6);
1218                 }
1219                 idx++;
1220                 numGroups--;
1221             }                   /* for each group in section */
1222
1223
1224         } else {                /* it is a variable name */
1225
1226             for (i = 0; i < NUM_FS_STAT_ENTRIES; i++) {
1227                 if (strcasecmp(arg2, fs_varNames[i]) == 0) {
1228                     if (!fs_showFlags[i]) {
1229                         fs_Display_map[fs_DisplayItems_count] = i;
1230                         fs_DisplayItems_count++;
1231                         fs_showFlags[i] = 1;
1232                     }
1233                     if (fs_DisplayItems_count >= NUM_FS_STAT_ENTRIES) {
1234                         fprintf(stderr, "[ %s ] fs_DisplayItems_count ovf\n",
1235                                 rn);
1236                         return (-25);
1237                     }
1238                     found = 1;
1239                 }
1240             }
1241             if (!found) {       /* typo in section/group name */
1242                 fprintf(stderr, "[ %s ] Could not find variable name %s\n",
1243                         rn, arg2);
1244                 return (-1);
1245             }
1246         }                       /* its a variable name */
1247
1248     }
1249
1250     /* it is an fs entry */
1251     if (strcasecmp(arg1, "cm") == 0) {  /* its a Cache Manager entry */
1252
1253
1254         /* mark that we have to show only what the user wants */
1255         cm_showDefault = 0;
1256
1257         /* if it is a section/group name, find it in the cm_categories[] array */
1258
1259         found = 0;
1260         if (strcasestr(arg2, "_section") != (char *)NULL
1261             || strcasestr(arg2, "_group") != (char *)NULL) {
1262             idx = 0;
1263             while (idx < CM_NUM_DATA_CATEGORIES) {
1264                 sscanf(cm_categories[idx], "%s %d %d", catName, &fromIdx,
1265                        &toIdx);
1266                 idx++;
1267                 if (strcasecmp(arg2, catName) == 0) {
1268                     found = 1;
1269                     break;
1270                 }
1271             }
1272
1273             if (!found) {       /* typo in section/group name */
1274                 fprintf(stderr,
1275                         "[ %s ] Could not find section/group name %s\n", rn,
1276                         arg2);
1277                 return (-1);
1278             }
1279         }
1280
1281         /* if it is a group name, read its start/end indices and fill in the
1282          * cm_Display_map[]. */
1283
1284         if (strcasestr(arg2, "_group") != (char *)NULL) {
1285
1286             if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_CM_STAT_ENTRIES
1287                 || toIdx > NUM_CM_STAT_ENTRIES)
1288                 return (-10);
1289             for (j = fromIdx; j <= toIdx; j++) {
1290                 if (!cm_showFlags[j]) {
1291                     cm_Display_map[cm_DisplayItems_count] = j;
1292                     cm_DisplayItems_count++;
1293                     cm_showFlags[j] = 1;
1294                 }
1295                 if (cm_DisplayItems_count > NUM_CM_STAT_ENTRIES) {
1296                     fprintf(stderr, "[ %s ] cm_DisplayItems_count ovf\n", rn);
1297                     return (-11);
1298                 }
1299             }
1300         } else
1301             /* if it is a section name, get the count of number of groups in it and
1302              * for each group fill in the start/end indices in the cm_Display_map[] */
1303
1304         if (strcasestr(arg2, "_section") != (char *)NULL) {
1305             /* fromIdx is actually the number of groups in thi section */
1306             numGroups = fromIdx;
1307             /* for each group in section */
1308             while (idx < CM_NUM_DATA_CATEGORIES && numGroups) {
1309                 sscanf(cm_categories[idx], "%s %d %d", catName, &fromIdx,
1310                        &toIdx);
1311
1312                 if (strcasestr(catName, "_group") != NULL) {
1313                     if (fromIdx < 0 || toIdx < 0
1314                         || fromIdx > NUM_CM_STAT_ENTRIES
1315                         || toIdx > NUM_CM_STAT_ENTRIES)
1316                         return (-12);
1317                     for (j = fromIdx; j <= toIdx; j++) {
1318                         if (!cm_showFlags[j]) {
1319                             cm_Display_map[cm_DisplayItems_count] = j;
1320                             cm_DisplayItems_count++;
1321                             cm_showFlags[j] = 1;
1322                         }
1323                         if (cm_DisplayItems_count > NUM_CM_STAT_ENTRIES) {
1324                             fprintf(stderr,
1325                                     "[ %s ] cm_DisplayItems_count ovf\n", rn);
1326                             return (-13);
1327                         }
1328                     }
1329                 } else {
1330                     fprintf(stderr, "[ %s ] Error parsing groups for %s\n",
1331                             rn, arg2);
1332                     return (-15);
1333                 }
1334                 idx++;
1335                 numGroups--;
1336             }                   /* for each group in section */
1337         } else {                /* it is a variable name */
1338
1339             for (i = 0; i < NUM_CM_STAT_ENTRIES; i++) {
1340                 if (strcasecmp(arg2, cm_varNames[i]) == 0) {
1341                     if (!cm_showFlags[i]) {
1342                         cm_Display_map[cm_DisplayItems_count] = i;
1343                         cm_DisplayItems_count++;
1344                         cm_showFlags[i] = 1;
1345                     }
1346                     if (cm_DisplayItems_count >= NUM_CM_STAT_ENTRIES) {
1347                         fprintf(stderr, "[ %s ] cm_DisplayItems_count ovf\n",
1348                                 rn);
1349                         return (-20);
1350                     }
1351                     found = 1;
1352                 }
1353             }
1354             if (!found) {       /* typo in section/group name */
1355                 fprintf(stderr, "[ %s ] Could not find variable name %s\n",
1356                         rn, arg2);
1357                 return (-1);
1358             }
1359         }                       /* its a variable name */
1360
1361     }
1362     /* it is an cm entry */
1363     return (0);
1364 }                               /* parse_showEntry */
1365
1366
1367 /*-----------------------------------------------------------------------
1368  * process_config_file()
1369  *
1370  * Description:
1371  *      Parse config file entries in two passes. In the first pass: 
1372  *              - the syntax of all the entries is checked
1373  *              - host names are noted and the FSnamesList and CMnamesList 
1374  *                constructed. 
1375  *              - a count of the global thresholds and local thresholds of 
1376  *                each host are counted. 
1377  *              - "show" entries are processed.
1378  *      In the second pass:
1379  *              - thresholds are stored 
1380  *
1381  * Returns:
1382  *      Success: 0
1383  *      Failure: Exits afsmonitor showing error and line.
1384  *----------------------------------------------------------------------*/
1385
1386 int
1387 process_config_file(char *a_config_filename)
1388 {                               /* process_config_file() */
1389     static char rn[] = "process_config_file";   /* routine name */
1390     FILE *configFD;             /* config file descriptor */
1391     char line[4 * CFG_STR_LEN]; /* a line of config file */
1392     char opcode[CFG_STR_LEN];   /* specifies type of config entry */
1393     char arg1[CFG_STR_LEN];     /* hostname or qualifier (fs/cm?)  */
1394     char arg2[CFG_STR_LEN];     /* threshold variable */
1395     char arg3[CFG_STR_LEN];     /* threshold value */
1396     char arg4[CFG_STR_LEN];     /* user's handler  */
1397     struct afsmon_hostEntry *curr_host;
1398     struct hostent *he;         /* hostentry to resolve host name */
1399     char *handlerPtr;           /* ptr to pass theresh handler string */
1400     int code = 0;               /* error code */
1401     int linenum = 0;            /* config file line number */
1402     int threshCount;            /* count of thresholds for each server */
1403     int error_in_config;        /* syntax errors in config file  ?? */
1404     int i;
1405     int numBytes;
1406
1407     if (afsmon_debug) {
1408         fprintf(debugFD, "[ %s ] Called, a_config_filename= %s\n", rn,
1409                 a_config_filename);
1410         fflush(debugFD);
1411     }
1412
1413     /* open config file */
1414
1415     configFD = fopen(a_config_filename, "r");
1416     if (configFD == (FILE *) 0) {
1417         fprintf(stderr, "Failed to open config file %s \n",
1418                 a_config_filename);
1419         if (afsmon_debug) {
1420             fprintf(debugFD, "[ %s ] Failed to open config file %s \n", rn,
1421                     a_config_filename);
1422         }
1423         afsmon_Exit(5);
1424     }
1425
1426
1427     /* parse config file */
1428
1429     /* We process the config file in two passes. In the first pass we check
1430      * for correct syntax and for valid entries and also keep count of the
1431      * number of servers and thresholds to monitor. This the data strctures
1432      * can be arrays instead of link lists since we would know their sizes. */
1433
1434     /* First Pass */
1435
1436     numFS = 0;
1437     numCM = 0;
1438     threshCount = 0;
1439     error_in_config = 0;        /* flag to note if config file has syntax errors */
1440
1441     while ((fgets(line, CFG_STR_LEN, configFD)) != NULL) {
1442         opcode[0] = 0;
1443         arg1[0] = 0;
1444         arg2[0] = 0;
1445         arg3[0] = 0;
1446         arg4[0] = 0;
1447         sscanf(line, "%s %s %s %s %s", opcode, arg1, arg2, arg3, arg4);
1448         linenum++;
1449         /* skip blank lines and comment lines */
1450         if ((strlen(opcode) == 0) || line[0] == '#')
1451             continue;
1452
1453         if ((strcasecmp(opcode, "fs") == 0)
1454             || (strcasecmp(opcode, "cm")) == 0) {
1455             code = parse_hostEntry(line);
1456         } else if ((strcasecmp(opcode, "thresh")) == 0) {
1457             code = parse_threshEntry(line);
1458         } else if ((strcasecmp(opcode, "show")) == 0) {
1459             code = parse_showEntry(line);
1460         } else {
1461             fprintf(stderr, "[ %s ] Unknown opcode %s\n", rn, opcode);
1462             code = 1;
1463         }
1464
1465         if (code) {
1466             fprintf(stderr, "[ %s ] Error in line:\n %d: %s\n", rn, linenum,
1467                     line);
1468             error_in_config = 1;
1469         }
1470     }
1471
1472     if (error_in_config)
1473         afsmon_Exit(10);
1474
1475     if (afsmon_debug) {
1476         fprintf(debugFD, "Global FS thresholds count = %d\n",
1477                 global_fsThreshCount);
1478         fprintf(debugFD, "Global CM thresholds count = %d\n",
1479                 global_cmThreshCount);
1480         fflush(debugFD);
1481     }
1482
1483     /* the threshold count of all hosts in increased by 1 for each global
1484      * threshold. If one of the hosts has a local threshold for the same 
1485      * variable it would end up being counted twice. whats a few bytes of memory
1486      * wasted anyway ? */
1487
1488     if (global_fsThreshCount) {
1489         curr_host = FSnameList;
1490         for (i = 0; i < numFS; i++) {
1491             curr_host->numThresh += global_fsThreshCount;
1492             curr_host = curr_host->next;
1493         }
1494     }
1495     if (global_cmThreshCount) {
1496         curr_host = CMnameList;
1497         for (i = 0; i < numCM; i++) {
1498             curr_host->numThresh += global_cmThreshCount;
1499             curr_host = curr_host->next;
1500         }
1501     }
1502
1503
1504     /* make sure we have something to monitor */
1505     if (numFS == 0 && numCM == 0) {
1506         fprintf(stderr,
1507                 "\nConfig file must specify atleast one File Server or Cache Manager host to monitor.\n");
1508         fclose(configFD);
1509         afsmon_Exit(15);
1510     }
1511
1512     /* Second Pass */
1513
1514     fseek(configFD, 0, 0);      /* seek to the beginning */
1515
1516
1517     /* allocate memory for threshold lists */
1518     curr_host = FSnameList;
1519     for (i = 0; i < numFS; i++) {
1520         if (curr_host->hostName[0] == '\0') {
1521             fprintf(stderr, "[ %s ] Programming error 4\n", rn);
1522             afsmon_Exit(20);
1523         }
1524         if (curr_host->numThresh) {
1525             numBytes = curr_host->numThresh * sizeof(struct Threshold);
1526             curr_host->thresh = (struct Threshold *)malloc(numBytes);
1527             if (curr_host->thresh == NULL) {
1528                 fprintf(stderr, "[ %s ] Memory Allocation error 1", rn);
1529                 afsmon_Exit(25);
1530             }
1531             memset(curr_host->thresh, 0, numBytes);
1532         }
1533         curr_host = curr_host->next;;
1534     }
1535
1536     curr_host = CMnameList;
1537     for (i = 0; i < numCM; i++) {
1538         if (curr_host->hostName[0] == '\0') {
1539             fprintf(stderr, "[ %s ] Programming error 5\n", rn);
1540             afsmon_Exit(30);
1541         }
1542         if (curr_host->numThresh) {
1543             numBytes = curr_host->numThresh * sizeof(struct Threshold);
1544             curr_host->thresh = (struct Threshold *)malloc(numBytes);
1545             if (curr_host->thresh == NULL) {
1546                 fprintf(stderr, "[ %s ] Memory Allocation error 2", rn);
1547                 afsmon_Exit(35);
1548             }
1549             memset(curr_host->thresh, 0, numBytes);
1550         }
1551         curr_host = curr_host->next;;
1552     }
1553
1554
1555     opcode[0] = 0;
1556     arg1[0] = 0;
1557     arg2[0] = 0;
1558     arg3[0] = 0;
1559     arg4[0] = 0;
1560     last_fsHost[0] = '\0';
1561     last_cmHost[0] = '\0';
1562     linenum = 0;
1563     while ((fgets(line, CFG_STR_LEN, configFD)) != NULL) {
1564         opcode[0] = 0;
1565         arg1[0] = 0;
1566         arg2[0] = 0;
1567         arg3[0] = 0;
1568         arg4[0] = 0;
1569         sscanf(line, "%s %s %s %s %s", opcode, arg1, arg2, arg3, arg4);
1570         linenum++;
1571
1572         /* if we have a host entry, remember the host name */
1573         if (strcasecmp(opcode, "fs") == 0) {
1574             he = GetHostByName(arg1);
1575             strncpy(last_fsHost, he->h_name, HOST_NAME_LEN);
1576         } else if (strcasecmp(opcode, "cm") == 0) {
1577             he = GetHostByName(arg1);
1578             strncpy(last_cmHost, he->h_name, HOST_NAME_LEN);
1579         } else if (strcasecmp(opcode, "thresh") == 0) {
1580             /* if we have a threshold handler it may have arguments
1581              * and the sscanf() above would not get them, so do the 
1582              * following */
1583             if (strlen(arg4)) {
1584                 handlerPtr = line;
1585                 /* now skip over 4 words - this is done by first
1586                  * skipping leading blanks then skipping a word */
1587                 for (i = 0; i < 4; i++) {
1588                     while (isspace(*handlerPtr))
1589                         handlerPtr++;
1590                     while (!isspace(*handlerPtr))
1591                         handlerPtr++;
1592                 }
1593                 while (isspace(*handlerPtr))
1594                     handlerPtr++;
1595                 /* we how have a pointer to the start of the handler
1596                  * name & args */
1597             } else
1598                 handlerPtr = arg4;      /* empty string */
1599
1600
1601             if (strcasecmp(arg1, "fs") == 0)
1602                 code = store_threshold(1,       /* 1 = fs */
1603                                        arg2, arg3, handlerPtr);
1604
1605             else if (strcasecmp(arg1, "cm") == 0)
1606                 code = store_threshold(2,       /* 2 = fs */
1607                                        arg2, arg3, handlerPtr);
1608
1609             else {
1610                 fprintf(stderr, "[ %s ] Programming error 6\n", rn);
1611                 afsmon_Exit(40);
1612             }
1613             if (code) {
1614                 fprintf(stderr, "[ %s ] Failed to store threshold\n", rn);
1615                 fprintf(stderr, "[ %s ] Error processing line:\n%d: %s", rn,
1616                         linenum, line);
1617                 afsmon_Exit(45);
1618             }
1619         }
1620     }
1621
1622
1623     fclose(configFD);
1624     return (0);
1625 }
1626
1627 /*-----------------------------------------------------------------------
1628  * Print_FS_CB
1629  *
1630  * Description:
1631  *      Debug routine.
1632  *      Print the File Server circular buffer.
1633  *
1634  * Returns:
1635  *      Nothing.
1636  *----------------------------------------------------------------------*/
1637
1638 void
1639 Print_FS_CB(void)
1640 {                               /* Print_FS_CB() */
1641
1642     struct afsmon_fs_Results_list *fslist;
1643     int i;
1644     int j;
1645
1646     /* print valid info in the fs CB */
1647
1648     if (afsmon_debug) {
1649         fprintf(debugFD,
1650                 "==================== FS Buffer ========================\n");
1651         fprintf(debugFD, "afsmon_fs_curr_CBindex = %d\n",
1652                 afsmon_fs_curr_CBindex);
1653         fprintf(debugFD, "afsmon_fs_curr_probeNum = %d\n\n",
1654                 afsmon_fs_curr_probeNum);
1655
1656         for (i = 0; i < num_bufSlots; i++) {
1657             fprintf(debugFD, "\t--------- slot %d ----------\n", i);
1658             fslist = afsmon_fs_ResultsCB[i].list;
1659             j = 0;
1660             while (j < numFS) {
1661                 if (!fslist->empty) {
1662                     fprintf(debugFD, "\t %d) probeNum = %d host = %s", j,
1663                             fslist->fsResults->probeNum,
1664                             fslist->fsResults->connP->hostName);
1665                     if (fslist->fsResults->probeOK)
1666                         fprintf(debugFD, " NOTOK\n");
1667                     else
1668                         fprintf(debugFD, " OK\n");
1669                 } else
1670                     fprintf(debugFD, "\t %d) -- empty --\n", j);
1671                 fslist = fslist->next;
1672                 j++;
1673             }
1674             if (fslist != (struct afsmon_fs_Results_list *)0)
1675                 fprintf(debugFD, "dangling last next ptr fs CB\n");
1676         }
1677     }
1678 }                               /* Print_FS_CB() */
1679
1680 /*-----------------------------------------------------------------------
1681  * save_FS_results_inCB()
1682  *
1683  * Description:
1684  *      Saves the results of the latest FS probe in the fs circular
1685  *      buffers. If the current probe cycle is in progress the contents
1686  *      of xstat_fs_Results are copied to the end of the list of results
1687  *      in the current slot (pointed to by afsmon_fs_curr_CBindex). If
1688  *      a new probe cycle has started the next slot in the circular buffer
1689  *      is initialized and the results copied. Note that the Rx related
1690  *      information available in xstat_fs_Results is not copied.
1691  *
1692  * Returns:
1693  *      Success: 0
1694  *      Failure: Exits afsmonitor.
1695  *----------------------------------------------------------------------*/
1696 int
1697 save_FS_results_inCB(int a_newProbeCycle)       /* start of a new probe cycle ? */
1698 {                               /* save_FS_results_inCB() */
1699     static char rn[] = "save_FS_results_inCB";  /* routine name */
1700     struct afsmon_fs_Results_list *tmp_fslist_item;     /* temp fs list item */
1701     struct xstat_fs_ProbeResults *tmp_fsPR;     /* temp ptr */
1702     int i;
1703
1704     if (afsmon_debug) {
1705         fprintf(debugFD, "[ %s ] Called, a_newProbeCycle= %d\n", rn,
1706                 a_newProbeCycle);
1707         fflush(debugFD);
1708     }
1709
1710
1711     /* If a new probe cycle started, mark the list in the current buffer
1712      * slot empty for resuse. Note that afsmon_fs_curr_CBindex was appropriately
1713      * incremented in afsmon_FS_Handler() */
1714
1715     if (a_newProbeCycle) {
1716         tmp_fslist_item = afsmon_fs_ResultsCB[afsmon_fs_curr_CBindex].list;
1717         for (i = 0; i < numFS; i++) {
1718             tmp_fslist_item->empty = 1;
1719             tmp_fslist_item = tmp_fslist_item->next;
1720         }
1721     }
1722
1723     /* locate last unused item in list */
1724     tmp_fslist_item = afsmon_fs_ResultsCB[afsmon_fs_curr_CBindex].list;
1725     for (i = 0; i < numFS; i++) {
1726         if (tmp_fslist_item->empty)
1727             break;
1728         tmp_fslist_item = tmp_fslist_item->next;
1729     }
1730
1731     /* if we could not find one we have an inconsistent list */
1732     if (!tmp_fslist_item->empty) {
1733         fprintf(stderr,
1734                 "[ %s ] list inconsistency 1. unable to find an empty slot to store results of probenum %d of %s\n",
1735                 rn, xstat_fs_Results.probeNum,
1736                 xstat_fs_Results.connP->hostName);
1737         afsmon_Exit(50);
1738     }
1739
1740     tmp_fsPR = tmp_fslist_item->fsResults;
1741
1742     /* copy hostname and probe number and probe time and probe status.
1743      * if the probe failed return now */
1744
1745     memcpy(tmp_fsPR->connP->hostName, xstat_fs_Results.connP->hostName,
1746            sizeof(xstat_fs_Results.connP->hostName));
1747     tmp_fsPR->probeNum = xstat_fs_Results.probeNum;
1748     tmp_fsPR->probeTime = xstat_fs_Results.probeTime;
1749     tmp_fsPR->probeOK = xstat_fs_Results.probeOK;
1750     if (xstat_fs_Results.probeOK) {     /* probeOK = 1 => notOK */
1751         /* we have a nonempty results structure so mark the list item used */
1752         tmp_fslist_item->empty = 0;
1753         return (0);
1754     }
1755
1756     /* copy connection information */
1757     memcpy(&(tmp_fsPR->connP->skt), &(xstat_fs_Results.connP->skt),
1758            sizeof(struct sockaddr_in));
1759
1760     memcpy(tmp_fsPR->connP->hostName, xstat_fs_Results.connP->hostName,
1761            sizeof(xstat_fs_Results.connP->hostName));
1762     tmp_fsPR->collectionNumber = xstat_fs_Results.collectionNumber;
1763
1764     /* copy the probe data information */
1765     tmp_fsPR->data.AFS_CollData_len = xstat_fs_Results.data.AFS_CollData_len;
1766     memcpy(tmp_fsPR->data.AFS_CollData_val,
1767            xstat_fs_Results.data.AFS_CollData_val,
1768            xstat_fs_Results.data.AFS_CollData_len * sizeof(afs_int32));
1769
1770
1771     /* we have a valid results structure so mark the list item used */
1772     tmp_fslist_item->empty = 0;
1773
1774     /* Print the fs circular buffer */
1775     Print_FS_CB();
1776
1777     return (0);
1778 }                               /* save_FS_results_inCB() */
1779
1780
1781 /*-----------------------------------------------------------------------
1782  * fs_Results_ltoa()
1783  *
1784  * Description:
1785  *      The results of xstat probes are stored in a string format in 
1786  *      the arrays curr_fsData and prev_fsData. The information stored in
1787  *      prev_fsData is copied to the screen. 
1788  *      This function converts xstat FS results from longs to strings and 
1789  *      place them in the given buffer (a pointer to an item in curr_fsData).
1790  *      When a probe cycle completes, curr_fsData is copied to prev_fsData
1791  *      in afsmon_FS_Hnadler().
1792  *
1793  * Returns:
1794  *      Always returns 0.
1795  *----------------------------------------------------------------------*/
1796
1797 int
1798 fs_Results_ltoa(struct fs_Display_Data *a_fsData,       /* target buffer */
1799                 struct xstat_fs_ProbeResults *a_fsResults)      /* ptr to xstat fs Results */
1800 {                               /* fs_Results_ltoa */
1801
1802     static char rn[] = "fs_Results_ltoa";       /* routine name */
1803     afs_int32 *srcbuf;
1804     struct fs_stats_FullPerfStats *fullPerfP;
1805     int idx;
1806     int i, j;
1807     afs_int32 *tmpbuf;
1808
1809     if (afsmon_debug) {
1810         fprintf(debugFD, "[ %s ] Called, a_fsData= %p, a_fsResults= %p\n", rn,
1811                 a_fsData, a_fsResults);
1812         fflush(debugFD);
1813     }
1814
1815     fullPerfP = (struct fs_stats_FullPerfStats *)
1816         (a_fsResults->data.AFS_CollData_val);
1817
1818     /* there are two parts to the xstat FS statistics 
1819      * - fullPerfP->overall which give the overall performance statistics, and
1820      * - fullPerfP->det which gives detailed info about file server operation
1821      * execution times */
1822
1823     /* copy overall performance statistics */
1824     srcbuf = (afs_int32 *) & (fullPerfP->overall);
1825     idx = 0;
1826     for (i = 0; i < NUM_XSTAT_FS_AFS_PERFSTATS_LONGS; i++) {
1827         sprintf(a_fsData->data[idx], "%d", *srcbuf);
1828         idx++;
1829         srcbuf++;
1830     }
1831
1832     /* copy epoch */
1833     srcbuf = (afs_int32 *) & (fullPerfP->det.epoch);
1834     sprintf(a_fsData->data[idx], "%d", *srcbuf);        /* epoch */
1835     idx++;
1836
1837     /* copy fs operation timing */
1838
1839     srcbuf = (afs_int32 *) (fullPerfP->det.rpcOpTimes);
1840
1841     for (i = 0; i < FS_STATS_NUM_RPC_OPS; i++) {
1842         sprintf(a_fsData->data[idx], "%d", *srcbuf);    /* numOps */
1843         idx++;
1844         srcbuf++;
1845         sprintf(a_fsData->data[idx], "%d", *srcbuf);    /* numSuccesses */
1846         idx++;
1847         srcbuf++;
1848         tmpbuf = srcbuf++;      /* sum time */
1849         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1850         idx++;
1851         srcbuf++;
1852         tmpbuf = srcbuf++;      /* sqr time */
1853         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1854         idx++;
1855         srcbuf++;
1856         tmpbuf = srcbuf++;      /* min time */
1857         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1858         idx++;
1859         srcbuf++;
1860         tmpbuf = srcbuf++;      /* max time */
1861         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1862         idx++;
1863         srcbuf++;
1864     }
1865
1866     /* copy fs transfer timings */
1867
1868     srcbuf = (afs_int32 *) (fullPerfP->det.xferOpTimes);
1869     for (i = 0; i < FS_STATS_NUM_XFER_OPS; i++) {
1870         sprintf(a_fsData->data[idx], "%d", *srcbuf);    /* numOps */
1871         idx++;
1872         srcbuf++;
1873         sprintf(a_fsData->data[idx], "%d", *srcbuf);    /* numSuccesses */
1874         idx++;
1875         srcbuf++;
1876         tmpbuf = srcbuf++;      /* sum time */
1877         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1878         idx++;
1879         srcbuf++;
1880         tmpbuf = srcbuf++;      /* sqr time */
1881         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1882         idx++;
1883         srcbuf++;
1884         tmpbuf = srcbuf++;      /* min time */
1885         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1886         idx++;
1887         srcbuf++;
1888         tmpbuf = srcbuf++;      /* max time */
1889         sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
1890         idx++;
1891         srcbuf++;
1892         sprintf(a_fsData->data[idx], "%d", *srcbuf);    /* sum bytes */
1893         idx++;
1894         srcbuf++;
1895         sprintf(a_fsData->data[idx], "%d", *srcbuf);    /* min bytes */
1896         idx++;
1897         srcbuf++;
1898         sprintf(a_fsData->data[idx], "%d", *srcbuf);    /* max bytes */
1899         idx++;
1900         srcbuf++;
1901         for (j = 0; j < FS_STATS_NUM_XFER_BUCKETS; j++) {
1902             sprintf(a_fsData->data[idx], "%d", *srcbuf);        /* bucket[j] */
1903             idx++;
1904             srcbuf++;
1905         }
1906     }
1907
1908     return (0);
1909 }                               /* fs_Results_ltoa */
1910
1911
1912
1913 /*-----------------------------------------------------------------------
1914  * execute_thresh_handler()
1915  *
1916  * Description:
1917  *      Execute a threshold handler. An agrv[] array of pointers is 
1918  *      constructed from the given data. A child process is forked 
1919  *      which immediately calls afsmon_Exit() with indication that a
1920  *      threshold handler is to be exec'ed insted of exiting. 
1921  *
1922  * Returns:
1923  *      Success: 0
1924  *      Failure: Afsmonitor exits if threshold handler has more than 20 args.
1925  *----------------------------------------------------------------------*/
1926
1927 int
1928 execute_thresh_handler(char *a_handler,         /* ptr to handler function + args */
1929                        char *a_hostName,        /* host name for which threshold crossed */
1930                        int a_hostType,          /* fs or cm ? */
1931                        char *a_threshName,      /* threshold variable name */
1932                        char *a_threshValue,     /* threshold value */
1933                        char *a_actValue)        /* actual value */
1934 {                               /* execute_thresh_handler */
1935
1936     static char rn[] = "execute_thresh_handler";
1937     char fileName[256];         /* file name to execute */
1938     int i;
1939     char *ch;
1940     int code;
1941     int argNum;
1942     int anotherArg;             /* boolean used to flag if another arg is available */
1943
1944     if (afsmon_debug) {
1945         fprintf(debugFD,
1946                 "[ %s ] Called, a_handler= %s, a_hostName= %s, a_hostType= %d, a_threshName= %s, a_threshValue= %s, a_actValue= %s\n",
1947                 rn, a_handler, a_hostName, a_hostType, a_threshName,
1948                 a_threshValue, a_actValue);
1949         fflush(debugFD);
1950     }
1951
1952
1953     /* get the filename to execute - the first argument */
1954     sscanf(a_handler, "%s", fileName);
1955
1956     /* construct the contents of *argv[] */
1957
1958     strncpy(fsHandler_args[0], fileName, 256);
1959     strncpy(fsHandler_args[1], a_hostName, HOST_NAME_LEN);
1960     if (a_hostType == FS)
1961         strcpy(fsHandler_args[2], "fs");
1962     else
1963         strcpy(fsHandler_args[2], "cm");
1964     strncpy(fsHandler_args[3], a_threshName, THRESH_VAR_NAME_LEN);
1965     strncpy(fsHandler_args[4], a_threshValue, THRESH_VAR_LEN);
1966     strncpy(fsHandler_args[5], a_actValue, THRESH_VAR_LEN);
1967
1968
1969     argNum = 6;
1970     anotherArg = 1;
1971     ch = a_handler;
1972
1973     /* we have already extracted the file name so skip to the 1st arg */
1974     while (isspace(*ch))        /* leading blanks */
1975         ch++;
1976     while (!isspace(*ch) && *ch != '\0')        /* handler filename */
1977         ch++;
1978
1979     while (*ch != '\0') {
1980         if (isspace(*ch)) {
1981             anotherArg = 1;
1982         } else if (anotherArg) {
1983             anotherArg = 0;
1984             sscanf(ch, "%s", fsHandler_args[argNum]);
1985             argNum++;
1986         }
1987         ch++;
1988         if (argNum >= 20) {
1989             sprintf(errMsg,
1990                     "Threshold handlers cannot have more than 20 arguments\n");
1991             afsmon_Exit(55);
1992         }
1993
1994     }
1995
1996     fsHandler_argv[argNum] = NULL;
1997     for (i = 0; i < argNum; i++)
1998         fsHandler_argv[i] = fsHandler_args[i];
1999
2000
2001     /* exec the threshold handler */
2002
2003     if (fork() == 0) {
2004         exec_fsThreshHandler = 1;
2005         code = afsmon_Exit(60);
2006     }
2007
2008     return (0);
2009 }                               /* execute_thresh_handler */
2010
2011
2012
2013 /*-----------------------------------------------------------------------
2014  * check_fs_thresholds()
2015  *
2016  * Description:
2017  *      Checks the thresholds and sets the overflow flag. Recall that the
2018  *      thresholds for each host are stored in the hostEntry lists
2019  *      [fs/cm]nameList arrays. The probe results are passed to this 
2020  *      function in the display-ready format - ie., as strings. Though
2021  *      this looks stupid the overhead incurred in converting the strings
2022  *      back to floats and comparing them is insignificant and 
2023  *      programming is easier this way. 
2024  *      The threshold flags are a part of the display structures
2025  *      curr_[fs/cm]Data.
2026  *
2027  * Returns:
2028  *      0
2029  *----------------------------------------------------------------------*/
2030
2031 int
2032 check_fs_thresholds(struct afsmon_hostEntry *a_hostEntry, /* ptr to hostEntry */
2033                     struct fs_Display_Data *a_Data)       /* ptr to fs data to be displayed */
2034 {                               /* check_fs_thresholds */
2035
2036     static char rn[] = "check_fs_thresholds";
2037     struct Threshold *threshP;
2038     double tValue;              /* threshold value */
2039     double pValue;              /* probe value */
2040     int i;
2041     int idx;
2042     int count;                  /* number of thresholds exceeded */
2043
2044     if (afsmon_debug) {
2045         fprintf(debugFD, "[ %s ] Called, a_hostEntry= %p, a_Data= %p\n", rn,
2046                 a_hostEntry, a_Data);
2047         fflush(debugFD);
2048     }
2049
2050     if (a_hostEntry->numThresh == 0) {
2051         /* store in ovf count ?? */
2052         return (0);
2053     }
2054
2055     count = 0;
2056     threshP = a_hostEntry->thresh;
2057     for (i = 0; i < a_hostEntry->numThresh; i++) {
2058         if (threshP->itemName[0] == '\0') {
2059             threshP++;
2060             continue;
2061         }
2062         idx = threshP->index;   /* positional index to the data array */
2063         tValue = atof(threshP->threshVal);      /* threshold value */
2064         pValue = atof(a_Data->data[idx]);       /* probe value */
2065         if (pValue > tValue) {
2066
2067             if (afsmon_debug) {
2068                 fprintf(debugFD,
2069                         "[ %s ] fs = %s, thresh ovf for %s, threshold= %s, probevalue= %s\n",
2070                         rn, a_hostEntry->hostName, threshP->itemName,
2071                         threshP->threshVal, a_Data->data[idx]);
2072                 fflush(debugFD);
2073             }
2074             /* if the threshold is crossed, call the handler function
2075              * only if this was a transition -ie, if the threshold was
2076              * crossed in the last probe too just count & keep quite! */
2077
2078             if (!a_Data->threshOvf[idx]) {
2079                 a_Data->threshOvf[idx] = 1;
2080                 /* call the threshold handler if provided */
2081                 if (threshP->handler[0] != '\0') {
2082                     if (afsmon_debug) {
2083                         fprintf(debugFD, "[ %s ] Calling ovf handler %s\n",
2084                                 rn, threshP->handler);
2085                         fflush(debugFD);
2086                     }
2087                     execute_thresh_handler(threshP->handler, a_Data->hostName,
2088                                            FS, threshP->itemName,
2089                                            threshP->threshVal,
2090                                            a_Data->data[idx]);
2091                 }
2092             }
2093
2094             count++;
2095         } else
2096             /* in case threshold was previously crossed, blank it out */
2097             a_Data->threshOvf[idx] = 0;
2098         threshP++;
2099     }
2100     /* store the overflow count */
2101     a_Data->ovfCount = count;
2102
2103     return (0);
2104 }                               /* check_fs_thresholds */
2105
2106
2107 /*-----------------------------------------------------------------------
2108  * save_FS_data_forDisplay()
2109  *
2110  * Description:
2111  *      Does the following:
2112  *      - if the probe number changed (ie, a cycle completed) curr_fsData
2113  *      is copied to prev_fsData, curr_fsData zeroed and refresh the 
2114  *      overview screen and file server screen with the new data.
2115  *      - store the results of the current probe from xstat_fs_Results into
2116  *      curr_fsData. ie., convert longs to strings.
2117  *      - check the thresholds 
2118  *
2119  * Returns:
2120  *      Success: 0
2121  *      Failure: Exits afsmonitor.
2122  *----------------------------------------------------------------------*/
2123
2124 int
2125 save_FS_data_forDisplay(struct xstat_fs_ProbeResults *a_fsResults)
2126 {                               /* save_FS_data_forDisplay */
2127
2128     static char rn[] = "save_FS_data_forDisplay";       /* routine name */
2129     struct fs_Display_Data *curr_fsDataP;       /* tmp ptr to curr_fsData */
2130     struct fs_Display_Data *prev_fsDataP;       /* tmp ptr to prev_fsData */
2131     struct afsmon_hostEntry *curr_host;
2132     static int probes_Received = 0;     /* number of probes reveived in
2133                                          * the current cycle. If this is equal to numFS we got all
2134                                          * the data we want in this cycle and can now display it */
2135     int numBytes;
2136     int okay;
2137     int i;
2138     int code;
2139     int done;
2140
2141
2142     if (afsmon_debug) {
2143         fprintf(debugFD, "[ %s ] Called, a_fsResults= %p\n", rn, a_fsResults);
2144         fflush(debugFD);
2145     }
2146
2147     /* store results in the display array */
2148
2149     okay = 0;
2150     curr_fsDataP = curr_fsData;
2151     for (i = 0; i < numFS; i++) {
2152         if ((strcasecmp(curr_fsDataP->hostName, a_fsResults->connP->hostName))
2153             == 0) {
2154             okay = 1;
2155             break;
2156         }
2157         curr_fsDataP++;
2158     }
2159
2160     if (!okay) {
2161         fprintf(stderr,
2162                 "[ %s ] Could not insert FS probe results for host %s in fs display array\n",
2163                 rn, a_fsResults->connP->hostName);
2164         afsmon_Exit(65);
2165     }
2166
2167     /*  Check the status of the probe. If it succeeded, we store its
2168      * results in the display data structure. If it failed we only mark 
2169      * the failed status in the display data structure. */
2170
2171     if (a_fsResults->probeOK) { /* 1 => notOK the xstat results */
2172         curr_fsDataP->probeOK = 0;
2173
2174         /* print the probe status */
2175         if (afsmon_debug) {
2176             fprintf(debugFD, "\n\t\t ----- fs display data ------\n");
2177             fprintf(debugFD, "HostName = %s  PROBE FAILED \n",
2178                     curr_fsDataP->hostName);
2179             fflush(debugFD);
2180         }
2181
2182     } else {                    /* probe succeeded, update display data structures */
2183         curr_fsDataP->probeOK = 1;
2184
2185         /* covert longs to strings and place them in curr_fsDataP */
2186         fs_Results_ltoa(curr_fsDataP, a_fsResults);
2187
2188         /* compare with thresholds and set the overflow flags.
2189          * note that the threshold information is in the hostEntry structure and 
2190          * each threshold item has a positional index associated with it */
2191
2192         /* locate the hostEntry for this host */
2193         done = 0;
2194         curr_host = FSnameList;
2195         for (i = 0; i < numFS; i++) {
2196             if (strcasecmp(curr_host->hostName, a_fsResults->connP->hostName)
2197                 == 0) {
2198                 done = 1;
2199                 break;
2200             }
2201             curr_host = curr_host->next;;
2202         }
2203         if (!done)
2204             afsmon_Exit(70);
2205
2206         code = check_fs_thresholds(curr_host, curr_fsDataP);
2207         if (code) {
2208             fprintf(stderr, "[ %s ] Error in checking thresholds\n", rn);
2209             afsmon_Exit(75);
2210         }
2211
2212         /* print the info we just saved */
2213
2214         if (afsmon_debug) {
2215             fprintf(debugFD, "\n\t\t ----- fs display data ------\n");
2216             fprintf(debugFD, "HostName = %s\n", curr_fsDataP->hostName);
2217             for (i = 0; i < NUM_FS_STAT_ENTRIES; i++)
2218                 fprintf(debugFD, "%20s  %30s  %s\n", curr_fsDataP->data[i],
2219                         fs_varNames[i],
2220                         curr_fsDataP->threshOvf[i] ? "(ovf)" : "");
2221
2222             fprintf(debugFD, "\t\t--------------------------------\n\n");
2223             fflush(debugFD);
2224         }
2225
2226     }                           /* the probe succeeded, so we store the data in the display structure */
2227
2228
2229     /* if we have received a reply from all the hosts for this probe cycle,
2230      * it is time to display the data */
2231
2232     probes_Received++;
2233     if (probes_Received == numFS) {
2234         probes_Received = 0;
2235
2236         if (afsmon_fs_curr_probeNum != afsmon_fs_prev_probeNum + 1) {
2237             sprintf(errMsg, "[ %s ] Probe number %d missed! \n", rn,
2238                     afsmon_fs_prev_probeNum + 1);
2239             afsmon_Exit(80);
2240         } else
2241             afsmon_fs_prev_probeNum++;
2242
2243         /* backup the display data of the probe cycle that just completed -
2244          * ie., store curr_fsData in prev_fsData */
2245
2246         memcpy((char *)prev_fsData, (char *)curr_fsData,
2247                (numFS * sizeof(struct fs_Display_Data)));
2248
2249
2250         /* initialize curr_fsData but retain the threshold flag information.
2251          * The previous state of threshold flags is used in check_fs_thresholds() */
2252
2253         numBytes = NUM_FS_STAT_ENTRIES * CM_STAT_STRING_LEN;
2254         curr_fsDataP = curr_fsData;
2255         for (i = 0; i < numFS; i++) {
2256             curr_fsDataP->probeOK = 0;
2257             curr_fsDataP->ovfCount = 0;
2258             memset((char *)curr_fsDataP->data, 0, numBytes);
2259             curr_fsDataP++;
2260         }
2261
2262
2263         /* prev_fsData now contains all the information for the probe cycle
2264          * that just completed. Now count the number of threshold overflows for
2265          * use in the overview screen */
2266
2267         prev_fsDataP = prev_fsData;
2268         num_fs_alerts = 0;
2269         numHosts_onfs_alerts = 0;
2270         for (i = 0; i < numFS; i++) {
2271             if (!prev_fsDataP->probeOK) {       /* if probe failed */
2272                 num_fs_alerts++;
2273                 numHosts_onfs_alerts++;
2274             }
2275             if (prev_fsDataP->ovfCount) {       /* overflows ?? */
2276                 num_fs_alerts += prev_fsDataP->ovfCount;
2277                 numHosts_onfs_alerts++;
2278             }
2279             prev_fsDataP++;
2280         }
2281         if (afsmon_debug)
2282             fprintf(debugFD, "Number of FS alerts = %d (on %d hosts)\n",
2283                     num_fs_alerts, numHosts_onfs_alerts);
2284
2285         /* flag that the data is now ready to be displayed */
2286         fs_Data_Available = 1;
2287
2288         /* call the Overview frame update routine (update only FS info) */
2289         ovw_refresh(ovw_currPage, OVW_UPDATE_FS);
2290
2291         /* call the File Servers frame update routine */
2292         fs_refresh(fs_currPage, fs_curr_LCol);
2293
2294     }
2295     /* display data */
2296     return (0);
2297 }                               /* save_FS_data_forDisplay */
2298
2299
2300
2301
2302 /*-----------------------------------------------------------------------
2303  * afsmon_FS_Handler()
2304  *
2305  * Description:
2306  *      This is the File Server probe Handler. It updates the afsmonitor
2307  *      probe counts, fs circular buffer indices and calls the functions
2308  *      to process the results of this probe.
2309  *
2310  * Returns:
2311  *      Success: 0
2312  *      Failure: Exits afsmonitor.
2313  *----------------------------------------------------------------------*/
2314
2315 int
2316 afsmon_FS_Handler(void)
2317 {                               /* afsmon_FS_Handler() */
2318     static char rn[] = "afsmon_FS_Handler";     /* routine name */
2319     int newProbeCycle;          /* start of new probe cycle ? */
2320     int code;                   /* return status */
2321
2322
2323     if (afsmon_debug) {
2324         fprintf(debugFD,
2325                 "[ %s ] Called, hostName= %s, probeNum= %d, status=%s\n", rn,
2326                 xstat_fs_Results.connP->hostName, xstat_fs_Results.probeNum,
2327                 xstat_fs_Results.probeOK ? "FAILED" : "OK");
2328         fflush(debugFD);
2329     }
2330
2331
2332     /* print the probe results to output file */
2333     if (afsmon_output) {
2334         code = afsmon_fsOutput(output_filename, afsmon_detOutput);
2335         if (code) {
2336             fprintf(stderr,
2337                     "[ %s ] output to file %s returned error code=%d\n", rn,
2338                     output_filename, code);
2339         }
2340     }
2341
2342     /* Update current probe number and circular buffer index. if current 
2343      * probenum changed make sure it is only by 1 */
2344
2345     newProbeCycle = 0;
2346     if (xstat_fs_Results.probeNum != afsmon_fs_curr_probeNum) {
2347         if (xstat_fs_Results.probeNum == afsmon_fs_curr_probeNum + 1) {
2348             afsmon_fs_curr_probeNum++;
2349             newProbeCycle = 1;
2350             if (num_bufSlots)
2351                 afsmon_fs_curr_CBindex =
2352                     (afsmon_fs_curr_probeNum - 1) % num_bufSlots;
2353         } else {
2354             fprintf(stderr, "[ %s ] probe number %d-1 missed\n", rn,
2355                     xstat_fs_Results.probeNum);
2356             afsmon_Exit(85);
2357         }
2358     }
2359
2360     /* store the results of this probe in the FS circular buffer */
2361     if (num_bufSlots)
2362         save_FS_results_inCB(newProbeCycle);
2363
2364
2365     /* store the results of the current probe in the fs data display structure.
2366      * if the current probe number changed, swap the current and previous display
2367      * structures. note that the display screen is updated from these structures 
2368      * and should start showing the data of the just completed probe cycle */
2369
2370     save_FS_data_forDisplay(&xstat_fs_Results);
2371
2372     return (0);
2373 }
2374
2375
2376
2377 /*----------------------------------------------------------------------- * 
2378  * Print_CM_CB()     
2379  *
2380  * Description:
2381  *      Debug routine.
2382  *      Prints the  Cache Manager circular buffer 
2383  *----------------------------------------------------------------------*/
2384
2385 void
2386 Print_CM_CB(void)
2387 {                               /* Print_CM_CB() */
2388
2389     struct afsmon_cm_Results_list *cmlist;
2390     int i;
2391     int j;
2392
2393     /* print valid info in the cm CB */
2394
2395     if (afsmon_debug) {
2396         fprintf(debugFD,
2397                 "==================== CM Buffer ========================\n");
2398         fprintf(debugFD, "afsmon_cm_curr_CBindex = %d\n",
2399                 afsmon_cm_curr_CBindex);
2400         fprintf(debugFD, "afsmon_cm_curr_probeNum = %d\n\n",
2401                 afsmon_cm_curr_probeNum);
2402
2403         for (i = 0; i < num_bufSlots; i++) {
2404             fprintf(debugFD, "\t--------- slot %d ----------\n", i);
2405             cmlist = afsmon_cm_ResultsCB[i].list;
2406             j = 0;
2407             while (j < numCM) {
2408                 if (!cmlist->empty) {
2409                     fprintf(debugFD, "\t %d) probeNum = %d host = %s", j,
2410                             cmlist->cmResults->probeNum,
2411                             cmlist->cmResults->connP->hostName);
2412                     if (cmlist->cmResults->probeOK)
2413                         fprintf(debugFD, " NOTOK\n");
2414                     else
2415                         fprintf(debugFD, " OK\n");
2416                 } else
2417                     fprintf(debugFD, "\t %d) -- empty --\n", j);
2418                 cmlist = cmlist->next;
2419                 j++;
2420             }
2421             if (cmlist != (struct afsmon_cm_Results_list *)0)
2422                 fprintf(debugFD, "dangling last next ptr cm CB\n");
2423         }
2424     }
2425 }
2426
2427
2428 /*-----------------------------------------------------------------------
2429  * save_CM_results_inCB()
2430  *
2431  * Description:
2432  *      Saves the results of the latest CM probe in the cm circular
2433  *      buffers. If the current probe cycle is in progress the contents
2434  *      of xstat_cm_Results are copied to the end of the list of results
2435  *      in the current slot (pointed to by afsmon_cm_curr_CBindex). If
2436  *      a new probe cycle has started the next slot in the circular buffer
2437  *      is initialized and the results copied. Note that the Rx related
2438  *      information available in xstat_cm_Results is not copied.
2439  *
2440  * Returns:
2441  *      Success: 0
2442  *      Failure: Exits afsmonitor.
2443  *----------------------------------------------------------------------*/
2444
2445 int
2446 save_CM_results_inCB(int a_newProbeCycle)       /* start of new probe cycle ? */
2447 {                               /* save_CM_results_inCB() */
2448     static char rn[] = "save_CM_results_inCB";  /* routine name */
2449     struct afsmon_cm_Results_list *tmp_cmlist_item;     /* temp cm list item */
2450     struct xstat_cm_ProbeResults *tmp_cmPR;     /* temp ptr */
2451     int i;
2452
2453
2454     if (afsmon_debug) {
2455         fprintf(debugFD, "[ %s ] Called, a_newProbeCycle= %d\n", rn,
2456                 a_newProbeCycle);
2457         fflush(debugFD);
2458     }
2459
2460     /* If a new probe cycle started, mark the list in the current buffer
2461      * slot empty for resuse. Note that afsmon_cm_curr_CBindex was appropriately
2462      * incremented in afsmon_CM_Handler() */
2463
2464     if (a_newProbeCycle) {
2465         tmp_cmlist_item = afsmon_cm_ResultsCB[afsmon_cm_curr_CBindex].list;
2466         for (i = 0; i < numCM; i++) {
2467             tmp_cmlist_item->empty = 1;
2468             tmp_cmlist_item = tmp_cmlist_item->next;
2469         }
2470     }
2471
2472     /* locate last unused item in list */
2473     tmp_cmlist_item = afsmon_cm_ResultsCB[afsmon_cm_curr_CBindex].list;
2474     for (i = 0; i < numCM; i++) {
2475         if (tmp_cmlist_item->empty)
2476             break;
2477         tmp_cmlist_item = tmp_cmlist_item->next;
2478     }
2479
2480     /* if we could not find one we have an inconsistent list */
2481     if (!tmp_cmlist_item->empty) {
2482         fprintf(stderr,
2483                 "[ %s ] list inconsistency 1. unable to find an empty slot to store results of probenum %d of %s\n",
2484                 rn, xstat_cm_Results.probeNum,
2485                 xstat_cm_Results.connP->hostName);
2486         afsmon_Exit(90);
2487     }
2488
2489     tmp_cmPR = tmp_cmlist_item->cmResults;
2490
2491     /* copy hostname and probe number and probe time and probe status.
2492      * if the probe failed return now */
2493
2494     memcpy(tmp_cmPR->connP->hostName, xstat_cm_Results.connP->hostName,
2495            sizeof(xstat_cm_Results.connP->hostName));
2496     tmp_cmPR->probeNum = xstat_cm_Results.probeNum;
2497     tmp_cmPR->probeTime = xstat_cm_Results.probeTime;
2498     tmp_cmPR->probeOK = xstat_cm_Results.probeOK;
2499     if (xstat_cm_Results.probeOK) {     /* probeOK = 1 => notOK */
2500         /* we have a nonempty results structure so mark the list item used */
2501         tmp_cmlist_item->empty = 0;
2502         return (0);
2503     }
2504
2505
2506     /* copy connection information */
2507     memcpy(&(tmp_cmPR->connP->skt), &(xstat_cm_Results.connP->skt),
2508            sizeof(struct sockaddr_in));
2509
2510    /**** NEED TO COPY rx_connection INFORMATION HERE ******/
2511
2512     memcpy(tmp_cmPR->connP->hostName, xstat_cm_Results.connP->hostName,
2513            sizeof(xstat_cm_Results.connP->hostName));
2514     tmp_cmPR->collectionNumber = xstat_cm_Results.collectionNumber;
2515
2516     /* copy the probe data information */
2517     tmp_cmPR->data.AFSCB_CollData_len =
2518         xstat_cm_Results.data.AFSCB_CollData_len;
2519     memcpy(tmp_cmPR->data.AFSCB_CollData_val,
2520            xstat_cm_Results.data.AFSCB_CollData_val,
2521            xstat_cm_Results.data.AFSCB_CollData_len * sizeof(afs_int32));
2522
2523
2524     /* we have a valid results structure so mark the list item used */
2525     tmp_cmlist_item->empty = 0;
2526
2527     /* print the stored info - to make sure we copied it right */
2528     /*   Print_cm_FullPerfInfo(tmp_cmPR);        */
2529     /* Print the cm circular buffer */
2530     Print_CM_CB();
2531     return (0);
2532 }                               /* save_CM_results_inCB */
2533
2534
2535
2536 /*-----------------------------------------------------------------------
2537  * cm_Results_ltoa()
2538  *
2539  * Description:
2540  *      The results of xstat probes are stored in a string format in 
2541  *      the arrays curr_cmData and prev_cmData. The information stored in
2542  *      prev_cmData is copied to the screen. 
2543  *      This function converts xstat FS results from longs to strings and 
2544  *      places them in the given buffer (a pointer to an item in curr_cmData).
2545  *      When a probe cycle completes, curr_cmData is copied to prev_cmData
2546  *      in afsmon_CM_Handler().
2547  *
2548  * Returns:
2549  *      Always returns 0.
2550  *----------------------------------------------------------------------*/
2551
2552 int
2553 cm_Results_ltoa(struct cm_Display_Data *a_cmData,       /* target buffer */
2554                 struct xstat_cm_ProbeResults *a_cmResults)      /* ptr to xstat cm Results */
2555 {                               /* cm_Results_ltoa */
2556
2557     static char rn[] = "cm_Results_ltoa";       /* routine name */
2558     struct afs_stats_CMFullPerf *fullP; /* ptr to complete CM stats */
2559     afs_int32 *srcbuf;
2560     afs_int32 *tmpbuf;
2561     int i, j;
2562     int idx;
2563     afs_int32 numLongs;
2564
2565     if (afsmon_debug) {
2566         fprintf(debugFD, "[ %s ] Called, a_cmData= %p, a_cmResults= %p\n", rn,
2567                 a_cmData, a_cmResults);
2568         fflush(debugFD);
2569     }
2570
2571
2572     fullP = (struct afs_stats_CMFullPerf *)
2573         (a_cmResults->data.AFSCB_CollData_val);
2574
2575     /* There are 4 parts to CM statistics
2576      * - Overall performance statistics (including up/down statistics)
2577      * - This CMs FS RPC operations info 
2578      * - This CMs FS RPC errors info
2579      * - This CMs FS transfers info
2580      * - Authentication info
2581      * - [Un]Replicated access info
2582      */
2583
2584     /* copy overall performance statistics */
2585     srcbuf = (afs_int32 *) & (fullP->perf);
2586     idx = 0;
2587     /* we skip the 19 entry, ProtServAddr, so the index must account for this */
2588     for (i = 0; i < NUM_AFS_STATS_CMPERF_LONGS + 1; i++) {
2589         if (i == 19) {
2590             srcbuf++;
2591             continue;           /* skip ProtServerAddr */
2592         }
2593         sprintf(a_cmData->data[idx], "%d", *srcbuf);
2594         idx++;
2595         srcbuf++;
2596     }
2597
2598     /*printf("Ending index value = %d\n",idx-1); */
2599
2600     /* server up/down statistics */
2601     /* copy file server up/down stats */
2602     srcbuf = (afs_int32 *) (fullP->perf.fs_UpDown);
2603     numLongs =
2604         2 * (sizeof(struct afs_stats_SrvUpDownInfo) / sizeof(afs_int32));
2605     for (i = 0; i < numLongs; i++) {
2606         sprintf(a_cmData->data[idx], "%d", *srcbuf);
2607         idx++;
2608         srcbuf++;
2609     }
2610
2611     /*printf("Ending index value = %d\n",idx-1); */
2612
2613     /* copy volume location  server up/down stats */
2614     srcbuf = (afs_int32 *) (fullP->perf.vl_UpDown);
2615     numLongs =
2616         2 * (sizeof(struct afs_stats_SrvUpDownInfo) / sizeof(afs_int32));
2617     for (i = 0; i < numLongs; i++) {
2618         sprintf(a_cmData->data[idx], "%d", *srcbuf);
2619         idx++;
2620         srcbuf++;
2621     }
2622
2623     /*printf("Ending index value = %d\n",idx-1); */
2624
2625     /* copy CMs individual FS RPC operations info */
2626     srcbuf = (afs_int32 *) (fullP->rpc.fsRPCTimes);
2627     for (i = 0; i < AFS_STATS_NUM_FS_RPC_OPS; i++) {
2628         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* numOps */
2629         idx++;
2630         srcbuf++;
2631         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* numSuccesses */
2632         idx++;
2633         srcbuf++;
2634         tmpbuf = srcbuf++;      /* sum time */
2635         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2636         idx++;
2637         srcbuf++;
2638         tmpbuf = srcbuf++;      /* sqr time */
2639         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2640         idx++;
2641         srcbuf++;
2642         tmpbuf = srcbuf++;      /* min time */
2643         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2644         idx++;
2645         srcbuf++;
2646         tmpbuf = srcbuf++;      /* max time */
2647         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2648         idx++;
2649         srcbuf++;
2650     }
2651
2652     /*printf("Ending index value = %d\n",idx-1); */
2653
2654     /* copy CMs individual FS RPC errors info */
2655
2656     srcbuf = (afs_int32 *) (fullP->rpc.fsRPCErrors);
2657     for (i = 0; i < AFS_STATS_NUM_FS_RPC_OPS; i++) {
2658         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* server */
2659         idx++;
2660         srcbuf++;
2661         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* network */
2662         idx++;
2663         srcbuf++;
2664         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* prot */
2665         idx++;
2666         srcbuf++;
2667         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* vol */
2668         idx++;
2669         srcbuf++;
2670         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* busies */
2671         idx++;
2672         srcbuf++;
2673         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* other */
2674         idx++;
2675         srcbuf++;
2676     }
2677
2678     /*printf("Ending index value = %d\n",idx-1); */
2679
2680     /* copy CMs individual RPC transfers info */
2681
2682     srcbuf = (afs_int32 *) (fullP->rpc.fsXferTimes);
2683     for (i = 0; i < AFS_STATS_NUM_FS_XFER_OPS; i++) {
2684         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* numOps */
2685         idx++;
2686         srcbuf++;
2687         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* numSuccesses */
2688         idx++;
2689         srcbuf++;
2690         tmpbuf = srcbuf++;      /* sum time */
2691         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2692         idx++;
2693         srcbuf++;
2694         tmpbuf = srcbuf++;      /* sqr time */
2695         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2696         idx++;
2697         srcbuf++;
2698         tmpbuf = srcbuf++;      /* min time */
2699         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2700         idx++;
2701         srcbuf++;
2702         tmpbuf = srcbuf++;      /* max time */
2703         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2704         idx++;
2705         srcbuf++;
2706         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* sum bytes */
2707         idx++;
2708         srcbuf++;
2709         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* min bytes */
2710         idx++;
2711         srcbuf++;
2712         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* max bytes */
2713         idx++;
2714         srcbuf++;
2715         for (j = 0; j < AFS_STATS_NUM_XFER_BUCKETS; j++) {
2716             sprintf(a_cmData->data[idx], "%d", *srcbuf);        /* bucket[j] */
2717             idx++;
2718             srcbuf++;
2719         }
2720     }
2721
2722     /*printf("Ending index value = %d\n",idx-1); */
2723
2724     /* copy CM operations timings */
2725
2726     srcbuf = (afs_int32 *) (fullP->rpc.cmRPCTimes);
2727     for (i = 0; i < AFS_STATS_NUM_CM_RPC_OPS; i++) {
2728         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* numOps */
2729         idx++;
2730         srcbuf++;
2731         sprintf(a_cmData->data[idx], "%d", *srcbuf);    /* numSuccesses */
2732         idx++;
2733         srcbuf++;
2734         tmpbuf = srcbuf++;      /* sum time */
2735         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2736         idx++;
2737         srcbuf++;
2738         tmpbuf = srcbuf++;      /* sqr time */
2739         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2740         idx++;
2741         srcbuf++;
2742         tmpbuf = srcbuf++;      /* min time */
2743         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2744         idx++;
2745         srcbuf++;
2746         tmpbuf = srcbuf++;      /* max time */
2747         sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
2748         idx++;
2749         srcbuf++;
2750     }
2751
2752     /*printf("Ending index value = %d\n",idx-1); */
2753
2754     /* copy authentication info */
2755
2756     srcbuf = (afs_int32 *) & (fullP->authent);
2757     numLongs = sizeof(struct afs_stats_AuthentInfo) / sizeof(afs_int32);
2758     for (i = 0; i < numLongs; i++) {
2759         sprintf(a_cmData->data[idx], "%d", *srcbuf);
2760         idx++;
2761         srcbuf++;
2762     }
2763
2764     /*printf("Ending index value = %d\n",idx-1); */
2765
2766     /* copy CM [un]replicated access info */
2767
2768     srcbuf = (afs_int32 *) & (fullP->accessinf);
2769     numLongs = sizeof(struct afs_stats_AccessInfo) / sizeof(afs_int32);
2770     for (i = 0; i < numLongs; i++) {
2771         sprintf(a_cmData->data[idx], "%d", *srcbuf);
2772         idx++;
2773         srcbuf++;
2774     }
2775
2776     /*printf("Ending index value = %d\n",idx-1); */
2777     return (0);
2778
2779 }                               /* cm_Results_ltoa */
2780
2781
2782 /*-----------------------------------------------------------------------
2783  * Function:    check_cm_thresholds()
2784  *
2785  * Description:
2786  *      Checks the thresholds and sets the overflow flag. Recall that the
2787  *      thresholds for each host are stored in the hostEntry lists
2788  *      [fs/cm]nameList arrays. The probe results are passed to this 
2789  *      function in the display-ready format - ie., as strings. Though
2790  *      this looks stupid the overhead incurred in converting the strings
2791  *      back to floats and comparing them is insignificant and 
2792  *      programming is easier this way. 
2793  *      The threshold flags are a part of the display structures
2794  *      curr_[fs/cm]Data.
2795  *
2796  * Returns:
2797  *      0
2798  *----------------------------------------------------------------------*/
2799
2800 int
2801 check_cm_thresholds(struct afsmon_hostEntry *a_hostEntry,       /* ptr to hostEntry */
2802                     struct cm_Display_Data *a_Data)             /* ptr to cm data to be displayed */
2803 {                               /* check_cm_thresholds */
2804
2805     static char rn[] = "check_cm_thresholds";
2806     struct Threshold *threshP;
2807     double tValue;              /* threshold value */
2808     double pValue;              /* probe value */
2809     int i;
2810     int idx;
2811     int count;                  /* number of thresholds exceeded */
2812
2813     if (afsmon_debug) {
2814         fprintf(debugFD, "[ %s ] Called, a_hostEntry= %p, a_Data= %p\n", rn,
2815                 a_hostEntry, a_Data);
2816         fflush(debugFD);
2817     }
2818
2819     if (a_hostEntry->numThresh == 0) {
2820         /* store in ovf count ?? */
2821         return (0);
2822     }
2823
2824     count = 0;
2825     threshP = a_hostEntry->thresh;
2826     for (i = 0; i < a_hostEntry->numThresh; i++) {
2827         if (threshP->itemName[0] == '\0') {
2828             threshP++;
2829             continue;
2830         }
2831         idx = threshP->index;   /* positional index to the data array */
2832         tValue = atof(threshP->threshVal);      /* threshold value */
2833         pValue = atof(a_Data->data[idx]);       /* probe value */
2834         if (pValue > tValue) {
2835
2836             if (afsmon_debug) {
2837                 fprintf(debugFD,
2838                         "[ %s ] cm = %s, thresh ovf for %s, threshold= %s, probevalue= %s\n",
2839                         rn, a_hostEntry->hostName, threshP->itemName,
2840                         threshP->threshVal, a_Data->data[idx]);
2841                 fflush(debugFD);
2842             }
2843
2844             /* if the threshold is crossed, call the handler function
2845              * only if this was a transition -ie, if the threshold was
2846              * crossed in the last probe too just count & keep quite! */
2847
2848             if (!a_Data->threshOvf[idx]) {
2849                 a_Data->threshOvf[idx] = 1;
2850                 /* call the threshold handler if provided */
2851                 if (threshP->handler[0] != '\0') {
2852                     if (afsmon_debug) {
2853                         fprintf(debugFD, "[ %s ] Calling ovf handler %s\n",
2854                                 rn, threshP->handler);
2855                         fflush(debugFD);
2856                     }
2857                     execute_thresh_handler(threshP->handler, a_Data->hostName,
2858                                            CM, threshP->itemName,
2859                                            threshP->threshVal,
2860                                            a_Data->data[idx]);
2861                 }
2862             }
2863
2864             count++;
2865         } else
2866             /* in case threshold was previously crossed, blank it out */
2867             a_Data->threshOvf[idx] = 0;
2868         threshP++;
2869     }
2870     /* store the overflow count */
2871     a_Data->ovfCount = count;
2872
2873     return (0);
2874 }                               /* check_cm_thresholds */
2875
2876
2877 /*-----------------------------------------------------------------------
2878  * save_CM_data_forDisplay()
2879  *
2880  * Description:
2881  *      Does the following:
2882  *      - if the probe number changed (ie, a cycle completed) curr_cmData
2883  *      is copied to prev_cmData, curr_cmData zeroed and refresh the 
2884  *      overview screen and file server screen with the new data.
2885  *      - store the results of the current probe from xstat_cm_Results into
2886  *      curr_cmData. ie., convert longs to strings.
2887  *      - check the thresholds 
2888  *
2889  * Returns:
2890  *      Success: 0
2891  *      Failure: Exits afsmonitor.
2892  *
2893  *----------------------------------------------------------------------*/
2894
2895 int
2896 save_CM_data_forDisplay(struct xstat_cm_ProbeResults *a_cmResults)
2897 {                               /* save_CM_data_forDisplay */
2898
2899     static char rn[] = "save_CM_data_forDisplay";       /* routine name */
2900     struct cm_Display_Data *curr_cmDataP;
2901     struct cm_Display_Data *prev_cmDataP;
2902     struct afsmon_hostEntry *curr_host;
2903     static int probes_Received = 0;     /* number of probes reveived in
2904                                          * the current cycle. If this is equal to numFS we got all
2905                                          * the data we want in this cycle and can now display it */
2906     int numBytes;
2907     int done;
2908     int code;
2909     int okay;
2910     int i;
2911
2912     if (afsmon_debug) {
2913         fprintf(debugFD, "[ %s ] Called, a_cmResults= %p\n", rn, a_cmResults);
2914         fflush(debugFD);
2915     }
2916
2917     /* store results in the display array */
2918
2919     okay = 0;
2920     curr_cmDataP = curr_cmData;
2921     for (i = 0; i < numCM; i++) {
2922         if ((strcasecmp(curr_cmDataP->hostName, a_cmResults->connP->hostName))
2923             == 0) {
2924             okay = 1;
2925             break;
2926         }
2927         curr_cmDataP++;
2928     }
2929
2930     if (!okay) {
2931         fprintf(stderr,
2932                 "[ %s ] Could not insert CM probe results for host %s in cm display array\n",
2933                 rn, a_cmResults->connP->hostName);
2934         afsmon_Exit(95);
2935     }
2936
2937     /*  Check the status of the probe. If it succeeded, we store its
2938      * results in the display data structure. If it failed we only mark 
2939      * the failed status in the display data structure. */
2940
2941
2942     if (a_cmResults->probeOK) { /* 1 => notOK the xstat results */
2943         curr_cmDataP->probeOK = 0;
2944
2945         /* print the probe status */
2946         if (afsmon_debug) {
2947             fprintf(debugFD, "\n\t\t ----- cm display data ------\n");
2948             fprintf(debugFD, "HostName = %s  PROBE FAILED \n",
2949                     curr_cmDataP->hostName);
2950             fflush(debugFD);
2951         }
2952
2953     } else {                    /* probe succeeded, update display data structures */
2954         curr_cmDataP->probeOK = 1;
2955
2956
2957         /* covert longs to strings and place them in curr_cmDataP */
2958         cm_Results_ltoa(curr_cmDataP, a_cmResults);
2959
2960         /* compare with thresholds and set the overflow flags.
2961          * note that the threshold information is in the hostEntry structure and 
2962          * each threshold item has a positional index associated with it */
2963
2964         /* locate the hostEntry for this host */
2965         done = 0;
2966         curr_host = CMnameList;
2967         for (i = 0; i < numCM; i++) {
2968             if (strcasecmp(curr_host->hostName, a_cmResults->connP->hostName)
2969                 == 0) {
2970                 done = 1;
2971                 break;
2972             }
2973             curr_host = curr_host->next;
2974         }
2975         if (!done)
2976             afsmon_Exit(100);
2977
2978         code = check_cm_thresholds(curr_host, curr_cmDataP);
2979         if (code) {
2980             fprintf(stderr, "[ %s ] Error in checking thresholds\n", rn);
2981             afsmon_Exit(105);
2982         }
2983
2984         /* print the info we just saved */
2985         if (afsmon_debug) {
2986             fprintf(debugFD, "\n\t\t ----- CM display data ------\n");
2987             fprintf(debugFD, "HostName = %s\n", curr_cmDataP->hostName);
2988             for (i = 0; i < NUM_CM_STAT_ENTRIES; i++) {
2989                 switch (i) {
2990                 case 0:
2991                     fprintf(debugFD, "\t -- Overall Perf Info --\n");
2992                     break;
2993                 case 39:
2994                     fprintf(debugFD,
2995                             "\t -- File Server up/down stats - same cell --\n");
2996                     break;
2997                 case 64:
2998                     fprintf(debugFD,
2999                             "\t -- File Server up/down stats - diff cell --\n");
3000                     break;
3001                 case 89:
3002                     fprintf(debugFD,
3003                             "\t -- VL server up/down stats - same cell --\n");
3004                     break;
3005                 case 114:
3006                     fprintf(debugFD,
3007                             "\t -- VL server up/down stats - diff cell --\n");
3008                     break;
3009                 case 139:
3010                     fprintf(debugFD, "\t -- FS Operation Timings --\n");
3011                     break;
3012                 case 279:
3013                     fprintf(debugFD, "\t -- FS Error Info --\n");
3014                     break;
3015                 case 447:
3016                     fprintf(debugFD, "\t -- FS Transfer Timings --\n");
3017                     break;
3018                 case 475:
3019                     fprintf(debugFD, "\t -- CM Operations Timings --\n");
3020                     break;
3021                 case 510:
3022                     fprintf(debugFD, "\t -- Authentication Info --\n");
3023                     break;
3024                 case 522:
3025                     fprintf(debugFD, "\t -- Access Info --\n");
3026                     break;
3027                 default:
3028                     break;
3029                 }
3030
3031                 fprintf(debugFD, "%20s  %30s %s\n", curr_cmDataP->data[i],
3032                         cm_varNames[i],
3033                         curr_cmDataP->threshOvf[i] ? "(ovf)" : "");
3034             }
3035             fprintf(debugFD, "\t\t--------------------------------\n\n");
3036         }
3037
3038     }                           /* if the probe succeeded, update the display data structures */
3039
3040     /* if we have received a reply from all the hosts for this probe cycle,
3041      * it is time to display the data */
3042
3043     probes_Received++;
3044     if (probes_Received == numCM) {
3045         probes_Received = 0;
3046
3047         if (afsmon_cm_curr_probeNum != afsmon_cm_prev_probeNum + 1) {
3048             sprintf(errMsg, "[ %s ] Probe number %d missed! \n", rn,
3049                     afsmon_cm_prev_probeNum + 1);
3050             afsmon_Exit(110);
3051         } else
3052             afsmon_cm_prev_probeNum++;
3053
3054
3055         /* backup the display data of the probe cycle that just completed -
3056          * ie., store curr_cmData in prev_cmData */
3057
3058         memcpy((char *)prev_cmData, (char *)curr_cmData,
3059                (numCM * sizeof(struct cm_Display_Data)));
3060
3061
3062         /* initialize curr_cmData but retain the threshold flag information.
3063          * The previous state of threshold flags is used in check_cm_thresholds() */
3064
3065         curr_cmDataP = curr_cmData;
3066         numBytes = NUM_CM_STAT_ENTRIES * CM_STAT_STRING_LEN;
3067         for (i = 0; i < numCM; i++) {
3068             curr_cmDataP->probeOK = 0;
3069             curr_cmDataP->ovfCount = 0;
3070             memset((char *)curr_cmDataP->data, 0, numBytes);
3071             curr_cmDataP++;
3072         }
3073
3074         /* prev_cmData now contains all the information for the probe cycle
3075          * that just completed. Now count the number of threshold overflows for
3076          * use in the overview screen */
3077
3078         prev_cmDataP = prev_cmData;
3079         num_cm_alerts = 0;
3080         numHosts_oncm_alerts = 0;
3081         for (i = 0; i < numCM; i++) {
3082             if (!prev_cmDataP->probeOK) {       /* if probe failed */
3083                 num_cm_alerts++;
3084                 numHosts_oncm_alerts++;
3085             } else if (prev_cmDataP->ovfCount) {        /* overflows ?? */
3086                 num_cm_alerts += prev_cmDataP->ovfCount;
3087                 numHosts_oncm_alerts++;
3088             }
3089             prev_cmDataP++;
3090         }
3091         if (afsmon_debug)
3092             fprintf(debugFD, "Number of CM alerts = %d (on %d hosts)\n",
3093                     num_cm_alerts, numHosts_oncm_alerts);
3094
3095
3096         /* flag that the data is now ready to be displayed */
3097         cm_Data_Available = 1;
3098
3099         /* update the Overview frame (only CM info) */
3100         ovw_refresh(ovw_currPage, OVW_UPDATE_CM);
3101
3102         /* update the Cache Managers frame */
3103         cm_refresh(cm_currPage, cm_curr_LCol);
3104
3105     }
3106
3107
3108     return (0);
3109 }                               /* save_CM_data_forDisplay */
3110
3111
3112
3113 /*-----------------------------------------------------------------------
3114  * afsmon_CM_Handler()
3115  *
3116  * Description:
3117  *      This is the Cache Manager probe Handler. It updates the afsmonitor
3118  *      probe counts, cm circular buffer indices and calls the functions
3119  *      to process the results of this probe.
3120  *
3121  * Returns:
3122  *      Success: 0
3123  *      Failure: Exits afsmonitor.
3124  *----------------------------------------------------------------------*/
3125
3126 int
3127 afsmon_CM_Handler(void)
3128 {                               /* afsmon_CM_Handler() */
3129     static char rn[] = "afsmon_CM_Handler";     /* routine name */
3130     int code;                   /* return status */
3131     int newProbeCycle;          /* start of new probe cycle ? */
3132
3133     if (afsmon_debug) {
3134         fprintf(debugFD,
3135                 "[ %s ] Called, hostName= %s, probeNum= %d, status= %s\n", rn,
3136                 xstat_cm_Results.connP->hostName, xstat_cm_Results.probeNum,
3137                 xstat_cm_Results.probeOK ? "FAILED" : "OK");
3138         fflush(debugFD);
3139     }
3140
3141
3142     /* print the probe results to output file */
3143     if (afsmon_output) {
3144         code = afsmon_cmOutput(output_filename, afsmon_detOutput);
3145         if (code) {
3146             fprintf(stderr,
3147                     "[ %s ] output to file %s returned error code=%d\n", rn,
3148                     output_filename, code);
3149         }
3150     }
3151
3152     /* Update current probe number and circular buffer index. if current 
3153      * probenum changed make sure it is only by 1 */
3154
3155     newProbeCycle = 0;
3156     if (xstat_cm_Results.probeNum != afsmon_cm_curr_probeNum) {
3157         if (xstat_cm_Results.probeNum == afsmon_cm_curr_probeNum + 1) {
3158             afsmon_cm_curr_probeNum++;
3159             newProbeCycle = 1;
3160             if (num_bufSlots)
3161                 afsmon_cm_curr_CBindex =
3162                     (afsmon_cm_curr_probeNum - 1) % num_bufSlots;
3163         } else {
3164             fprintf(stderr, "[ %s ] probe number %d-1 missed\n", rn,
3165                     xstat_cm_Results.probeNum);
3166             afsmon_Exit(115);
3167         }
3168     }
3169
3170     /* save the results of this probe in the CM buffer */
3171     if (num_bufSlots)
3172         save_CM_results_inCB(newProbeCycle);
3173
3174     /* store the results of the current probe in the cm data display structure.
3175      * if the current probe number changed, swap the current and previous display
3176      * structures. note that the display screen is updated from these structures 
3177      * and should start showing the data of the just completed probe cycle */
3178
3179     save_CM_data_forDisplay(&xstat_cm_Results);
3180
3181     return (0);
3182 }
3183
3184 /*-----------------------------------------------------------------------
3185  * init_fs_buffers()
3186  *
3187  * Description:
3188  *      Allocate and Initialize circular buffers for file servers.
3189  *
3190  * Returns:
3191  *      Success: 0
3192  *      Failure to allocate memory: exits afsmonitor.
3193  *----------------------------------------------------------------------*/
3194
3195 int
3196 init_fs_buffers(void)
3197 {                               /* init_fs_buffers() */
3198     static char rn[] = "init_fs_buffers";       /* routine name */
3199     struct afsmon_fs_Results_list *new_fslist_item;     /* ptr for new struct */
3200     struct afsmon_fs_Results_list *tmp_fslist_item;     /* temp ptr */
3201     struct xstat_fs_ProbeResults *new_fsPR;     /* ptr for new struct  */
3202     int i, j;
3203     int bufslot;
3204     int numfs;
3205
3206
3207     if (afsmon_debug) {
3208         fprintf(debugFD, "[ %s ] Called\n", rn);
3209         fflush(debugFD);
3210     }
3211
3212     /* allocate memory for the circular buffer of pointers */
3213
3214     afsmon_fs_ResultsCB = (struct afsmon_fs_Results_CBuffer *)
3215         malloc(sizeof(struct afsmon_fs_Results_CBuffer) * num_bufSlots);
3216
3217     /* initialize the fs circular buffer */
3218     for (i = 0; i < num_bufSlots; i++) {
3219         afsmon_fs_ResultsCB[i].list = (struct afsmon_fs_Results_list *)0;
3220         afsmon_fs_ResultsCB[i].probeNum = 0;
3221     }
3222
3223     /* create  a list of numFS items to store fs probe results for 
3224      * each slot in CB */
3225
3226     if (numFS) {                /* if we have file servers to monitor */
3227         for (bufslot = 0; bufslot < num_bufSlots; bufslot++) {
3228             numfs = numFS;      /* get the number of servers */
3229             while (numfs--) {
3230
3231                 /* if any of these mallocs fail we only need to free the memory we
3232                  * have allocated in this iteration. the rest of it which is in a 
3233                  * proper linked list will be freed in afsmon_Exit */
3234
3235                 /* allocate memory for an fs list item */
3236                 new_fslist_item = (struct afsmon_fs_Results_list *)
3237                     malloc(sizeof(struct afsmon_fs_Results_list));
3238                 if (new_fslist_item == (struct afsmon_fs_Results_list *)0)
3239                     return (-1);
3240
3241                 /* allocate memory to store xstat_fs_Results */
3242                 new_fsPR = (struct xstat_fs_ProbeResults *)
3243                     malloc(sizeof(struct xstat_fs_ProbeResults));
3244                 if (new_fsPR == (struct xstat_fs_ProbeResults *)0) {
3245                     free(new_fslist_item);
3246                     return (-1);
3247                 }
3248                 new_fsPR->connP = (struct xstat_fs_ConnectionInfo *)
3249                     malloc(sizeof(struct xstat_fs_ConnectionInfo));
3250                 if (new_fsPR->connP == (struct xstat_fs_ConnectionInfo *)0) {
3251                     free(new_fslist_item);
3252                     free(new_fsPR);
3253                     return (-1);
3254                 }
3255
3256                 /* >>>  need to allocate rx connection info structure here <<< */
3257
3258                 new_fsPR->data.AFS_CollData_val =
3259                     (afs_int32 *) malloc(XSTAT_FS_FULLPERF_RESULTS_LEN *
3260                                          sizeof(afs_int32));
3261                 if (new_fsPR->data.AFS_CollData_val == NULL) {
3262                     free(new_fslist_item);
3263                     free(new_fsPR->connP);
3264                     free(new_fsPR);
3265                     return (-1);
3266                 }
3267
3268                 /* initialize this list entry */
3269                 new_fslist_item->fsResults = new_fsPR;
3270                 new_fslist_item->empty = 1;
3271                 new_fslist_item->next = (struct afsmon_fs_Results_list *)0;
3272
3273                 /* store it at the end of the fs list in the current CB slot */
3274                 if (afsmon_fs_ResultsCB[bufslot].list ==
3275                     (struct afsmon_fs_Results_list *)0)
3276                     afsmon_fs_ResultsCB[bufslot].list = new_fslist_item;
3277                 else {
3278                     tmp_fslist_item = afsmon_fs_ResultsCB[bufslot].list;
3279                     j = 0;
3280                     while (tmp_fslist_item !=
3281                            (struct afsmon_fs_Results_list *)0) {
3282                         if (tmp_fslist_item->next ==
3283                             (struct afsmon_fs_Results_list *)0)
3284                             break;
3285                         tmp_fslist_item = tmp_fslist_item->next;
3286                         if (++j > numFS) {
3287                             /* something goofed. exit */
3288                             fprintf(stderr, "[ %s ] list creation error\n",
3289                                     rn);
3290                             return (-1);
3291                         }
3292                     }
3293                     tmp_fslist_item->next = new_fslist_item;
3294                 }
3295
3296             }                   /* while servers */
3297         }                       /* for each buffer slot */
3298     }                           /* if we have file servers to monitor */
3299     return (0);
3300 }
3301
3302 /*-----------------------------------------------------------------------
3303  * init_cm_buffers()
3304  *
3305  * Description:
3306  *      Allocate and Initialize circular buffers for cache managers.
3307  *
3308  * Returns:
3309  *      Success: 0
3310  *      Failure to allocate memory: exits afsmonitor.
3311  *----------------------------------------------------------------------*/
3312
3313 int
3314 init_cm_buffers(void)
3315 {                               /* init_cm_buffers() */
3316     static char rn[] = "init_cm_buffers";       /* routine name */
3317     struct afsmon_cm_Results_list *new_cmlist_item;     /* ptr for new struct */
3318     struct afsmon_cm_Results_list *tmp_cmlist_item;     /* temp ptr */
3319     struct xstat_cm_ProbeResults *new_cmPR;     /* ptr for new struct  */
3320     int i, j;
3321     int bufslot;
3322     int numcm;
3323
3324     if (afsmon_debug) {
3325         fprintf(debugFD, "[ %s ] Called\n", rn);
3326         fflush(debugFD);
3327     }
3328
3329     /* allocate memory for the circular buffer of pointers */
3330     afsmon_cm_ResultsCB = (struct afsmon_cm_Results_CBuffer *)
3331         malloc(sizeof(struct afsmon_cm_Results_CBuffer) * num_bufSlots);
3332
3333     /* initialize the fs circular buffer */
3334     for (i = 0; i < num_bufSlots; i++) {
3335         afsmon_cm_ResultsCB[i].list = (struct afsmon_cm_Results_list *)0;
3336         afsmon_cm_ResultsCB[i].probeNum = 0;
3337     }
3338
3339     /* create  a list of numCM items to store fs probe results for 
3340      * each slot in CB */
3341
3342     if (numCM) {                /* if we have file servers to monitor */
3343         for (bufslot = 0; bufslot < num_bufSlots; bufslot++) {
3344             numcm = numCM;      /* get the number of servers */
3345             while (numcm--) {
3346
3347                 /* if any of these mallocs fail we only need to free the memory we
3348                  * have allocated in this iteration. the rest of it which is in a 
3349                  * proper linked list will be freed in afsmon_Exit */
3350
3351                 /* allocate memory for an fs list item */
3352                 new_cmlist_item = (struct afsmon_cm_Results_list *)
3353                     malloc(sizeof(struct afsmon_cm_Results_list));
3354                 if (new_cmlist_item == (struct afsmon_cm_Results_list *)0)
3355                     return (-1);
3356
3357                 /* allocate memory to store xstat_cm_Results */
3358                 new_cmPR = (struct xstat_cm_ProbeResults *)
3359                     malloc(sizeof(struct xstat_cm_ProbeResults));
3360                 if (new_cmPR == (struct xstat_cm_ProbeResults *)0) {
3361                     free(new_cmlist_item);
3362                     return (-1);
3363                 }
3364                 new_cmPR->connP = (struct xstat_cm_ConnectionInfo *)
3365                     malloc(sizeof(struct xstat_cm_ConnectionInfo));
3366                 if (new_cmPR->connP == (struct xstat_cm_ConnectionInfo *)0) {
3367                     free(new_cmlist_item);
3368                     free(new_cmPR);
3369                     return (-1);
3370                 }
3371
3372                 /* >>>  need to allocate rx connection info structure here <<< */
3373
3374                 new_cmPR->data.AFSCB_CollData_val =
3375                     (afs_int32 *) malloc(XSTAT_CM_FULLPERF_RESULTS_LEN *
3376                                          sizeof(afs_int32));
3377                 if (new_cmPR->data.AFSCB_CollData_val == NULL) {
3378                     free(new_cmlist_item);
3379                     free(new_cmPR->connP);
3380                     free(new_cmPR);
3381                     return (-1);
3382                 }
3383
3384                 /* initialize this list entry */
3385                 new_cmlist_item->cmResults = new_cmPR;
3386                 new_cmlist_item->empty = 1;
3387                 new_cmlist_item->next = (struct afsmon_cm_Results_list *)0;
3388
3389                 /* store it at the end of the cm list in the current CB slot */
3390                 if (afsmon_cm_ResultsCB[bufslot].list ==
3391                     (struct afsmon_cm_Results_list *)0)
3392                     afsmon_cm_ResultsCB[bufslot].list = new_cmlist_item;
3393                 else {
3394                     tmp_cmlist_item = afsmon_cm_ResultsCB[bufslot].list;
3395                     j = 0;
3396                     while (tmp_cmlist_item !=
3397                            (struct afsmon_cm_Results_list *)0) {
3398                         if (tmp_cmlist_item->next ==
3399                             (struct afsmon_cm_Results_list *)0)
3400                             break;
3401                         tmp_cmlist_item = tmp_cmlist_item->next;
3402                         if (++j > numCM) {
3403                             /* something goofed. exit */
3404                             fprintf(stderr, "[ %s ] list creation error\n",
3405                                     rn);
3406             &nb