Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
I probably had been drinking too much the day I have written this command... Sorry...
[simgrid.git] / src / xbt / log.c
1 /* $Id$ */
2
3 /* log - a generic logging facility in the spirit of log4j                  */
4
5 /* Copyright (c) 2003, 2004 Martin Quinson. All rights reserved.            */
6
7 /* This program is free software; you can redistribute it and/or modify it
8  * under the terms of the license (GNU LGPL) which comes with this package. */
9
10 #include <stdarg.h>
11 #include <ctype.h>
12
13 #include "xbt_modinter.h"
14
15 #include "xbt/misc.h"
16 #include "xbt/sysdep.h"
17 #include "xbt/log.h"
18 #include "xbt/error.h"
19 #include "xbt/dynar.h"
20
21 typedef struct {
22   char *catname;
23   e_xbt_log_priority_t thresh;
24 } s_xbt_log_setting_t,*xbt_log_setting_t;
25
26 static xbt_dynar_t xbt_log_settings=NULL;
27 static void _free_setting(void *s) {
28   xbt_log_setting_t set=(xbt_log_setting_t)s;
29   if (set) {
30     xbt_free(set->catname);
31 /*    xbt_free(set); FIXME: uncommenting this leads to segfault when more than one chunk is passed as gras-log */
32   }
33 }
34
35 const char *xbt_log_priority_names[8] = {
36   "NONE",
37   "TRACE",
38   "DEBUG",
39   "VERBOSE",
40   "INFO",
41   "WARNING",
42   "ERROR",
43   "CRITICAL"
44 };
45
46 s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = {
47   0, 0, 0,
48   "root", xbt_log_priority_uninitialized, 0,
49   NULL, 0
50 };
51
52 XBT_LOG_NEW_SUBCATEGORY(xbt,XBT_LOG_ROOT_CAT,"All XBT categories (simgrid toolbox)");
53 XBT_LOG_NEW_SUBCATEGORY(surf,XBT_LOG_ROOT_CAT,"All SURF categories");
54 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log,xbt,"Loggings from the logging mecanism itself");
55
56 void xbt_log_init(int *argc,char **argv, const char *defaultlog) {
57   int i,j;
58   char *opt;
59   int found=0;
60
61   /** Set logs and init log submodule */
62   for (i=1; i<*argc; i++) {
63     if (!strncmp(argv[i],"--gras-log=",strlen("--gras-log="))) {
64       found = 1;
65       opt=strchr(argv[i],'=');
66       opt++;
67       xbt_log_control_set(opt);
68       DEBUG1("Did apply '%s' as log setting",opt);
69       /*remove this from argv*/
70       for (j=i+1; j<*argc; j++) {
71         argv[j-1] = argv[j];
72       } 
73       argv[j-1] = NULL;
74       (*argc)--;
75       i--; /* compensate effect of next loop incrementation */
76     }
77   }
78   if (!found && defaultlog) {
79      xbt_log_control_set(defaultlog);
80   }
81 }
82
83 void xbt_log_exit(void) {
84   VERB0("Exiting log");
85   xbt_dynar_free(&xbt_log_settings);
86   VERB0("Exited log");
87 }
88
89 static void _apply_control(xbt_log_category_t cat) {
90   int cursor;
91   xbt_log_setting_t setting=NULL;
92   int found = 0;
93
94   if (!xbt_log_settings)
95     return;
96
97   xbt_assert0(cat,"NULL category");
98   xbt_assert(cat->name);
99
100   xbt_dynar_foreach(xbt_log_settings,cursor,setting) {
101     xbt_assert0(setting,"Damnit, NULL cat in the list");
102     xbt_assert1(setting->catname,"NULL setting(=%p)->catname",(void*)setting);
103
104     if (!strcmp(setting->catname,cat->name)) {
105       found = 1;
106
107       xbt_log_threshold_set(cat, setting->thresh);
108       xbt_dynar_cursor_rm(xbt_log_settings,&cursor);
109
110       if (cat->threshold <= xbt_log_priority_verbose) {
111         s_xbt_log_event_t _log_ev = 
112           {cat,xbt_log_priority_verbose,__FILE__,_XBT_GNUC_FUNCTION,__LINE__};
113         _xbt_log_event_log(&_log_ev,
114                  "Apply settings for category '%s': set threshold to %s (=%d)",
115                  cat->name, 
116                  xbt_log_priority_names[cat->threshold], cat->threshold);
117       }
118     }
119   }
120   if (!found && cat->threshold <= xbt_log_priority_verbose) {
121     s_xbt_log_event_t _log_ev = 
122       {cat,xbt_log_priority_verbose,__FILE__,_XBT_GNUC_FUNCTION,__LINE__};
123     _xbt_log_event_log(&_log_ev,
124                         "Category '%s': inherited threshold = %s (=%d)",
125                         cat->name,
126                         xbt_log_priority_names[cat->threshold], cat->threshold);
127   }
128
129 }
130
131 void _xbt_log_event_log( xbt_log_event_t ev, const char *fmt, ...) {
132   xbt_log_category_t cat = ev->cat;
133   va_start(ev->ap, fmt);
134   while(1) {
135     xbt_log_appender_t appender = cat->appender;
136     if (appender != NULL) {
137       appender->do_append(appender, ev, fmt);
138     }
139     if (!cat->willLogToParent)
140       break;
141
142     cat = cat->parent;
143   } 
144   va_end(ev->ap);
145 }
146
147 static void _cat_init(xbt_log_category_t category) {
148   if (category == &_XBT_LOGV(XBT_LOG_ROOT_CAT)) {
149     category->threshold = xbt_log_priority_info;
150     category->appender = xbt_log_default_appender;
151   } else {
152     xbt_log_parent_set(category, category->parent);
153   }
154   _apply_control(category);
155 }
156
157 /*
158  * This gets called the first time a category is referenced and performs the
159  * initialization. 
160  * Also resets threshold to inherited!
161  */
162 int _xbt_log_cat_init(e_xbt_log_priority_t priority,
163                        xbt_log_category_t   category) {
164     
165   _cat_init(category);
166         
167   return priority >= category->threshold;
168 }
169
170 void xbt_log_parent_set(xbt_log_category_t cat,
171                          xbt_log_category_t parent) {
172
173   xbt_assert0(cat,"NULL category to be given a parent");
174   xbt_assert1(parent,"The parent category of %s is NULL",cat->name);
175
176   /* unlink from current parent */
177   if (cat->threshold != xbt_log_priority_uninitialized) {
178     xbt_log_category_t* cpp = &parent->firstChild;
179     while(*cpp != cat && *cpp != NULL) {
180       cpp = &(*cpp)->nextSibling;
181     }
182     xbt_assert(*cpp == cat);
183     *cpp = cat->nextSibling;
184   }
185
186   /* Set new parent */
187   cat->parent = parent;
188   cat->nextSibling = parent->firstChild;
189   parent->firstChild = cat;
190
191   /* Make sure parent is initialized */
192   if (parent->threshold == xbt_log_priority_uninitialized) {
193     _cat_init(parent);
194   }
195     
196   /* Reset priority */
197   cat->threshold = parent->threshold;
198   cat->isThreshInherited = 1;
199 } /* log_setParent */
200
201 static void _set_inherited_thresholds(xbt_log_category_t cat) {
202   xbt_log_category_t child = cat->firstChild;
203   for( ; child != NULL; child = child->nextSibling) {
204     if (child->isThreshInherited) {
205       if (cat != &_XBT_LOGV(log))
206         VERB3("Set category threshold of %s to %s (=%d)",
207               child->name,xbt_log_priority_names[cat->threshold],cat->threshold);
208       child->threshold = cat->threshold;
209       _set_inherited_thresholds(child);
210     }
211   }
212 }
213
214 void xbt_log_threshold_set(xbt_log_category_t   cat,
215                             e_xbt_log_priority_t threshold) {
216   cat->threshold = threshold;
217   cat->isThreshInherited = 0;
218   _set_inherited_thresholds(cat);
219 }
220
221 static void _xbt_log_parse_setting(const char*        control_string,
222                                     xbt_log_setting_t set) {
223   const char *name, *dot, *eq;
224   
225   set->catname=NULL;
226   if (!*control_string) 
227     return;
228   DEBUG1("Parse log setting '%s'",control_string);
229
230   control_string += strspn(control_string, " ");
231   name = control_string;
232   control_string += strcspn(control_string, ".= ");
233   dot = control_string;
234   control_string += strcspn(control_string, "= ");
235   eq = control_string;
236   control_string += strcspn(control_string, " ");
237
238   xbt_assert1(*dot == '.' && *eq == '=',
239                "Invalid control string '%s'",control_string);
240
241   if (!strncmp(dot + 1, "thresh", min(eq - dot - 1,strlen("thresh")))) {
242     int i;
243     char *neweq=xbt_strdup(eq+1);
244     char *p=neweq-1;
245     
246     while (*(++p) != '\0') {
247       if (*p >= 'a' && *p <= 'z') {
248         *p-='a'-'A';
249       }
250     }
251     
252     DEBUG1("New priority name = %s",neweq);
253     for (i=0; i<xbt_log_priority_infinite-1; i++) {
254       if (!strncmp(xbt_log_priority_names[i],neweq,p-eq)) {
255         DEBUG1("This is priority %d",i);
256         break;
257       }
258     }
259     if (i<xbt_log_priority_infinite-1) {
260       set->thresh=i;
261     } else {
262       xbt_assert1(FALSE,"Unknown priority name: %s",eq+1);
263     }
264     xbt_free(neweq);
265   } else {
266     char buff[512];
267     snprintf(buff,min(512,eq - dot - 1),"%s",dot+1);
268     xbt_assert1(FALSE,"Unknown setting of the log category: %s",buff);
269   }
270   set->catname=(char*)xbt_malloc(dot - name+1);
271     
272   strncpy(set->catname,name,dot-name);
273   set->catname[dot-name]='\0'; /* Just in case */
274   DEBUG1("This is for cat '%s'", set->catname);
275 }
276
277 static xbt_error_t _xbt_log_cat_searchsub(xbt_log_category_t cat,char *name,
278                                             /*OUT*/xbt_log_category_t*whereto) {
279   xbt_error_t errcode;
280   xbt_log_category_t child;
281   
282   if (!strcmp(cat->name,name)) {
283     *whereto=cat;
284     return no_error;
285   }
286   for(child=cat->firstChild ; child != NULL; child = child->nextSibling) {
287     errcode=_xbt_log_cat_searchsub(child,name,whereto);
288     if (errcode==no_error)
289       return no_error;
290   }
291   return mismatch_error;
292 }
293
294 static void _cleanup_double_spaces(char *s) {
295   char *p = s;
296   int   e = 0;
297   
298   while (1) {
299     if (!*p)
300       goto end;
301     
302     if (!isspace(*p))
303       break;
304     
305     p++;
306   }
307   
308   e = 1;
309   
310   do {
311     if (e)
312       *s++ = *p;
313     
314     if (!*++p)
315       goto end;
316     
317     if (e ^ !isspace(*p))
318       if ((e = !e))
319         *s++ = ' ';
320   } while (1);
321
322  end:
323   *s = '\0';
324 }
325
326 /**
327  * xbt_log_control_set:
328  * @cs: What to parse
329  *
330  * Typically passed a command-line argument. The string has the syntax:
331  *
332  *      ( [category] "." [keyword] "=" value (" ")... )...
333  *
334  * where [category] is one the category names and keyword is one of the
335  * following:
336  *
337  *      thresh          value is an integer priority level. Sets the category's
338  *                        threshold priority.
339  *
340  * @warning
341  * This routine may only be called once and that must be before any other
342  * logging command! Typically, this is done from main().
343  */
344 void xbt_log_control_set(const char* control_string) {
345   xbt_error_t errcode;
346   xbt_log_setting_t set;
347   char *cs;
348   char *p;
349   int done = 0;
350   
351   DEBUG1("Parse log settings '%s'",control_string);
352   if (control_string == NULL)
353     return;
354   if (xbt_log_settings == NULL)
355     xbt_log_settings = xbt_dynar_new(sizeof(xbt_log_setting_t),
356                                        _free_setting);
357
358   set = xbt_new(s_xbt_log_setting_t,1);
359   cs=xbt_strdup(control_string);
360
361   _cleanup_double_spaces(cs);
362
363   while (!done) {
364     xbt_log_category_t cat;
365     
366     p=strrchr(cs,' ');
367     if (p) {
368       *p='\0';
369       *p++;
370     } else {
371       p=cs;
372       done = 1;
373     }
374     _xbt_log_parse_setting(p,set);
375     
376     errcode = _xbt_log_cat_searchsub(&_XBT_LOGV(root),set->catname,&cat);
377     if (errcode == mismatch_error) {
378       DEBUG0("Store for further application");
379       DEBUG1("push %p to the settings",(void*)set);
380       xbt_dynar_push(xbt_log_settings,&set);
381       /* malloc in advance the next slot */
382       set = xbt_new(s_xbt_log_setting_t,1);
383     } else {
384       DEBUG0("Apply directly");
385       xbt_free(set->catname);
386       xbt_log_threshold_set(cat,set->thresh);
387     }
388   }
389   xbt_free(set);
390   xbt_free(cs);
391
392
393 void xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app) {
394   cat->appender = app;
395 }
396