Fixed a minor UMR purify turned up
[dyninst.git] / paradyn / src / met / metMain.C
1
2 /* metMain contains the functions that are called by the parser to support the
3  * configuration language.  The functions are:
4  *
5  *     metDoProcess(..) - start a process
6  *     metDoDaemon (..) - start a daemon
7  *     metDoTunable(..) - set a tunable constant value
8  *     metDoVisi(..) - declare a visi
9  */
10
11 /*
12  * $Log: metMain.C,v $
13  * Revision 1.16  1995/03/30 15:32:37  jcargill
14  * Fixed a minor UMR purify turned up
15  *
16  * Revision 1.15  1995/02/27  18:59:02  tamches
17  * The use of tunable constants has changed to reflect the new
18  * "tunableConstantRegistry" class and the new TCthread.
19  *
20  * Revision 1.14  1995/02/16  08:24:18  markc
21  * Changed Boolean to bool.
22  * Changed calls to igen functions to use strings/vectors rather than
23  * char*'s/arrays
24  *
25  * Revision 1.13  1995/02/07  21:59:52  newhall
26  * added a force option to the visualization definition, this specifies
27  * if the visi should be started before metric/focus menuing
28  * removed compiler warnings
29  *
30  * Revision 1.12  1994/12/21  07:38:43  tamches
31  * Removed uses of tunableConstant::allConstants, which became a private
32  * class variable.
33  *
34  * Revision 1.11  1994/12/21  05:50:15  tamches
35  * Used the new tunableConstant::findTunableConstant() instead of
36  * manually tinkering with tunable constant internal vrbles, which
37  * is no longer allowed.
38  *
39  * Revision 1.10  1994/11/03  02:46:47  krisna
40  * removed bare prototype for gethostname
41  *
42  * Revision 1.9  1994/10/10  02:52:51  newhall
43  * removed the default visi: HISTOGRAM_REALTIME
44  *
45  * Revision 1.8  1994/09/25  01:55:08  newhall
46  * changed arguments to VMAddNewVisualization
47  *
48  * Revision 1.7  1994/09/22  01:22:05  markc
49  * Set default args
50  *
51  * Revision 1.6  1994/08/22  15:53:23  markc
52  * Config language version 2.
53  *
54  * Revision 1.2  1994/07/07  13:10:41  markc
55  * Turned off debugging printfs.
56  *
57  * Revision 1.1  1994/07/07  03:25:25  markc
58  * Configuration language parser.
59  *
60  */
61
62 #include "paradyn/src/met/metParse.h"
63 #include "../TCthread/tunableConst.h"
64
65 #include <stdio.h>
66 #include <fcntl.h>
67 #include <string.h>
68 #include <stdlib.h>
69 #include <unistd.h>
70 #include "paradyn/src/pdMain/paradyn.h"
71 #include "util/h/rpcUtil.h"
72
73 extern int yyparse();
74 extern int yyrestart(FILE *);
75
76 int open_N_parse(char *file);
77
78 // open the config file and parse it
79 // return -1 on failure to open file
80 // else return yyparse result
81
82 int open_N_parse (char *file)
83 {
84   int res;
85   FILE *f;
86   static int been_here = 0;
87
88   f = fopen (file, "r");
89   if (f) {
90     if (!been_here) { 
91       been_here = 1;
92       yyin = f;
93       res = yyparse();
94       fclose(f);
95       return res;
96     } else {
97       res = yyrestart(f);
98       res = yyparse();
99       fclose(f);
100       return res;
101     }
102   }
103   return -1;
104 }
105
106 char *makeName(char *prefix, char *suffix)
107 {
108   char *result;
109   int len;
110
111   if (!prefix || !suffix)
112     return ((char*) 0);
113
114   len = strlen(prefix) + strlen(suffix) + 2;
115
116   result = new char[len];
117   if (!result)
118     return ((char*) 0);
119
120   strcpy(result, prefix);
121   strcat(result, suffix);
122   return result;
123 }
124
125 // parse the 3 files (system, user, application)
126
127 int metMain(char *userFile)
128 {
129   // return yyparse();
130   int yy1=0, yy2=0, yy3=0;
131   char *home, *proot, *fname, *cwd;
132
133   // empty the lists
134   tunableMet::allTunables.removeAll();
135   daemonMet::allDaemons.removeAll();
136   visiMet::allVisis.removeAll();
137   processMet::allProcs.removeAll();
138
139   proot = getenv("PARADYN_ROOT");
140   if (proot) {
141     fname = makeName(proot, "/Paradynrc");
142     yy1 = open_N_parse(fname);
143     delete [] fname;
144   } else {
145     cwd = getenv("cwd");
146     if (cwd) {
147       fname = makeName(cwd, "/Paradynrc");
148       yy1 = open_N_parse(fname);
149       delete [] fname;
150     }
151   }
152
153   home = getenv("HOME");
154   if (home) {
155     fname = makeName(home, "/.Paradynrc");
156     yy2 = open_N_parse(fname);
157     delete [] fname;
158   }
159
160   if (userFile) {
161     yy3 = open_N_parse(userFile);
162   }
163
164   return (yy2 + yy1 + yy3);
165 }
166
167 static void define_daemon (daemonMet *the_dm)
168 {
169   // daemons cannot define any arguments
170   // just use the first word in the command 'sentence' for exec
171   vector<string> argv;
172   assert(RPCgetArg(argv, the_dm->command));
173   string program = argv[0];
174
175   if (!dataMgr->defineDaemon(context, program.string_of(), the_dm->execDir,
176                              the_dm->user, the_dm->name, the_dm->host,
177                              the_dm->flavor))
178     ; // print error message
179 }
180
181 int metDoDaemon()
182 {
183   daemonMet def;
184   static int been_done=0;
185   List<daemonMet*> walk;
186
187   // the default daemons
188   if (!been_done) {
189     char nmStr[20] = "pvmd", cmdStr[20] = "paradyndPVM";
190     def.name = nmStr;
191     def.command = cmdStr;
192     def.flavor = metPVM;
193     define_daemon(&def);
194     
195     strcpy(nmStr, "defd");
196     strcpy(cmdStr, "paradynd");
197     def.flavor = metUNIX;
198     define_daemon(&def);
199
200     strcpy(nmStr, "cm5d");
201     strcpy(cmdStr, "paradyndCM5");
202     def.flavor = metCM5;
203     define_daemon(&def);
204
205     strcpy(nmStr, "simd");
206     strcpy(cmdStr, "paradyndSIM");
207     def.flavor = metUNIX;
208     define_daemon(&def);
209     def.command = 0; def.name =0;
210     been_done = 1;
211   }
212
213   for (walk=daemonMet::allDaemons; *walk; walk++)
214     define_daemon(*walk);
215   return 1;
216 }
217
218
219 static void add_visi(visiMet *the_vm)
220 {
221   vector<string> argv;
222   assert(RPCgetArg(argv, the_vm->command));
223   int argc = argv.size();
224   char **av = new char*[argc+1];
225   av[argc] = NULL;
226   // TODO -- is there a memory leak here
227   for (unsigned ve=0; ve<argc; ve++)
228     av[ve] = P_strdup(argv[ve].string_of());
229
230   // the strings created here are used, not copied in the VM
231   vmMgr->VMAddNewVisualization(the_vm->name, argc, av, the_vm->force, NULL, 0);
232 }
233
234 int metDoVisi()
235 {
236   visiMet vm;
237   static int been_done = 0;
238   List<visiMet*> walk;
239
240 /*
241   if (!been_done) {
242     char nmStr[20] = "HISTOGRAM_REALTIME", cmdStr[10] = "rthist";
243     vm.name = nmStr;
244     vm.command = cmdStr;
245     add_visi(&vm);
246     vm.command=0; vm.name=0;
247     been_done = 1;
248   }
249 */
250
251   for (walk=visiMet::allVisis; *walk; walk++)
252     add_visi(*walk);
253   return 1;
254 }
255
256 static void start_process(processMet *the_ps)
257 {
258   vector<string> argv;
259   assert(RPCgetArg(argv, the_ps->command));
260
261   if (!dataMgr->addExecutable(context,
262                               the_ps->host,
263                               the_ps->user,
264                               the_ps->daemon,
265                               the_ps->execDir,
266                               &argv))
267     ; // print error message
268 }
269
270 int metDoProcess()
271 {
272   List<processMet*> walk;
273   for (walk=processMet::allProcs; *walk; walk++) 
274     start_process(*walk);
275   return 1;
276 }
277
278 void set_tunable (tunableMet *the_ts)
279 {
280   if (!tunableConstantRegistry::existsTunableConstant(the_ts->name))
281      return;
282
283   if (tunableConstantRegistry::getTunableConstantType(the_ts->name) == tunableBoolean) {
284      if (!the_ts->useBvalue) {
285         // type mismatch?
286         return;
287      }
288
289      tunableConstantRegistry::setBoolTunableConstant(the_ts->name, (bool)the_ts->Bvalue);
290   }
291   else {
292      if (the_ts->useBvalue) {
293         // type mismatch?
294         return;
295      }
296
297      tunableConstantRegistry::setFloatTunableConstant(the_ts->name, the_ts->Fvalue);
298   }
299   
300 //  tunableConstant *curr = tunableConstant::findTunableConstant(the_ts->name);
301 //  if (curr == NULL)
302 //     return;
303 //
304 //  if ((curr->getType() == tunableFloat) && !the_ts->useBvalue) {
305 //    tunableFloatConstant *fConst = (tunableFloatConstant*) curr;
306 //    if (!fConst->setValue(the_ts->Fvalue)) {
307 //      ; // error
308 //    }
309 //  } else if ((curr->getType() == tunableBoolean) && the_ts->useBvalue) {
310 //    tunableBooleanConstant *bConst = (tunableBooleanConstant*) curr;
311 //    if (!bConst->setValue((Boolean)the_ts->Bvalue)) {
312 //       ; // error 
313 //    }
314 //  } else {
315 //    ;
316 //    // unknown tunableConst type or type mismatch
317 //  }
318
319 }
320
321 int metDoTunable()
322 {
323   List<tunableMet*> walk;
324
325   for (walk=tunableMet::allTunables; *walk; walk++)
326     set_tunable(*walk);
327   return 1;
328 }