X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/84eafe2f81ab7b7db83308e32ded2b164f219f4e..3e8755b31f40edd05eb6679b4c5571083020545a:/src/xbt/log.c diff --git a/src/xbt/log.c b/src/xbt/log.c index e55a4c0a07..595576add4 100644 --- a/src/xbt/log.c +++ b/src/xbt/log.c @@ -8,32 +8,34 @@ /* This program is free software; you can redistribute it and/or modify it under the terms of the license (GNU LGPL) which comes with this package. */ -#include "Core/core_interface.h" -#include "gras_private.h" #include -#include #include -#ifndef MIN -#define MIN(a,b) ((a) < (b) ? (a) : (b)) -#endif +#include "xbt_modinter.h" + +#include "xbt/misc.h" +#include "xbt/sysdep.h" +#include "xbt/log.h" +#include "xbt/error.h" +#include "xbt/dynar.h" typedef struct { char *catname; - gras_log_priority_t thresh; -} gras_log_setting_t; + e_xbt_log_priority_t thresh; +} s_xbt_log_setting_t,*xbt_log_setting_t; -static gras_dynar_t *gras_log_settings=NULL; +static xbt_dynar_t xbt_log_settings=NULL; static void _free_setting(void *s) { - gras_log_setting_t *set=(gras_log_setting_t*)s; + xbt_log_setting_t set=(xbt_log_setting_t)s; if (set) { - free(set->catname); - free(set); + xbt_free(set->catname); +/* xbt_free(set); FIXME: uncommenting this leads to segfault when more than one chunk is passed as gras-log */ } } -const char *gras_log_priority_names[8] = { +const char *xbt_log_priority_names[8] = { "NONE", + "TRACE", "DEBUG", "VERBOSE", "INFO", @@ -42,62 +44,66 @@ const char *gras_log_priority_names[8] = { "CRITICAL" }; -gras_log_category_t _GRAS_LOGV(GRAS_LOG_ROOT_CAT) = { +s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = { 0, 0, 0, - "root", gras_log_priority_uninitialized, 0, + "root", xbt_log_priority_uninitialized, 0, NULL, 0 }; -GRAS_LOG_NEW_SUBCATEGORY(GRAS,GRAS_LOG_ROOT_CAT); -GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(log,GRAS); + +XBT_LOG_NEW_SUBCATEGORY(gras,XBT_LOG_ROOT_CAT,"All GRAS categories"); +XBT_LOG_NEW_SUBCATEGORY(xbt,XBT_LOG_ROOT_CAT,"All XBT categories (gras toolbox)"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log,xbt,"Loggings from the logging mecanism itself"); -static void _apply_control(gras_log_category_t* cat) { +static void _apply_control(xbt_log_category_t cat) { int cursor; - gras_log_setting_t *setting=NULL; + xbt_log_setting_t setting=NULL; int found = 0; - if (!gras_log_settings) + if (!xbt_log_settings) return; - gras_assert0(cat,"NULL category"); - gras_assert(cat->name); + xbt_assert0(cat,"NULL category"); + xbt_assert(cat->name); - gras_dynar_foreach(gras_log_settings,cursor,setting) { - gras_assert0(setting,"Damnit, NULL cat in the list"); - gras_assert1(setting->catname,"NULL setting(=%p)->catname",setting); + xbt_dynar_foreach(xbt_log_settings,cursor,setting) { + xbt_assert0(setting,"Damnit, NULL cat in the list"); + xbt_assert1(setting->catname,"NULL setting(=%p)->catname",(void*)setting); if (!strcmp(setting->catname,cat->name)) { found = 1; - gras_log_threshold_set(cat, setting->thresh); - gras_dynar_cursor_rm(gras_log_settings,&cursor); + xbt_log_threshold_set(cat, setting->thresh); + xbt_dynar_cursor_rm(xbt_log_settings,&cursor); - if (cat->threshold <= gras_log_priority_verbose) { - gras_log_event_t _log_ev = - {cat,gras_log_priority_verbose,__FILE__,__FUNCTION__,__LINE__, - "Apply settings for category '%s': set threshold to %s (=%d)",}; - _gras_log_event_log(&_log_ev, cat->name, - gras_log_priority_names[cat->threshold], cat->threshold); + if (cat->threshold <= xbt_log_priority_verbose) { + s_xbt_log_event_t _log_ev = + {cat,xbt_log_priority_verbose,__FILE__,_XBT_GNUC_FUNCTION,__LINE__}; + _xbt_log_event_log(&_log_ev, + "Apply settings for category '%s': set threshold to %s (=%d)", + cat->name, + xbt_log_priority_names[cat->threshold], cat->threshold); } } } - if (!found && cat->threshold <= gras_log_priority_verbose) { - gras_log_event_t _log_ev = - {cat,gras_log_priority_verbose,__FILE__,__FUNCTION__,__LINE__, - "Category '%s': inherited threshold = %s (=%d)",}; - _gras_log_event_log(&_log_ev, cat->name, - gras_log_priority_names[cat->threshold], cat->threshold); + if (!found && cat->threshold <= xbt_log_priority_verbose) { + s_xbt_log_event_t _log_ev = + {cat,xbt_log_priority_verbose,__FILE__,_XBT_GNUC_FUNCTION,__LINE__}; + _xbt_log_event_log(&_log_ev, + "Category '%s': inherited threshold = %s (=%d)", + cat->name, + xbt_log_priority_names[cat->threshold], cat->threshold); } } -void _gras_log_event_log( gras_log_event_t* ev, ...) { - gras_log_category_t* cat = ev->cat; - va_start(ev->ap, ev); +void _xbt_log_event_log( xbt_log_event_t ev, const char *fmt, ...) { + xbt_log_category_t cat = ev->cat; + va_start(ev->ap, fmt); while(1) { - gras_log_appender_t* appender = cat->appender; + xbt_log_appender_t appender = cat->appender; if (appender != NULL) { - appender->do_append(appender, ev); + appender->do_append(appender, ev, fmt); } if (!cat->willLogToParent) break; @@ -107,12 +113,12 @@ void _gras_log_event_log( gras_log_event_t* ev, ...) { va_end(ev->ap); } -static void _cat_init(gras_log_category_t* category) { - if (category == &_GRAS_LOGV(GRAS_LOG_ROOT_CAT)) { - category->threshold = gras_log_priority_info; - category->appender = gras_log_default_appender; +static void _cat_init(xbt_log_category_t category) { + if (category == &_XBT_LOGV(XBT_LOG_ROOT_CAT)) { + category->threshold = xbt_log_priority_info; + category->appender = xbt_log_default_appender; } else { - gras_log_parent_set(category, category->parent); + xbt_log_parent_set(category, category->parent); } _apply_control(category); } @@ -122,72 +128,72 @@ static void _cat_init(gras_log_category_t* category) { * initialization. * Also resets threshold to inherited! */ -int _gras_log_cat_init(gras_log_priority_t priority, - gras_log_category_t* category) { +int _xbt_log_cat_init(e_xbt_log_priority_t priority, + xbt_log_category_t category) { _cat_init(category); return priority >= category->threshold; } -void gras_log_parent_set(gras_log_category_t* cat, - gras_log_category_t* parent) { +void xbt_log_parent_set(xbt_log_category_t cat, + xbt_log_category_t parent) { - gras_assert0(cat,"NULL category to be given a parent"); - gras_assert1(parent,"The parent category of %s is NULL",cat->name); + xbt_assert0(cat,"NULL category to be given a parent"); + xbt_assert1(parent,"The parent category of %s is NULL",cat->name); - // unlink from current parent - if (cat->threshold != gras_log_priority_uninitialized) { - gras_log_category_t** cpp = &parent->firstChild; + /* unlink from current parent */ + if (cat->threshold != xbt_log_priority_uninitialized) { + xbt_log_category_t* cpp = &parent->firstChild; while(*cpp != cat && *cpp != NULL) { cpp = &(*cpp)->nextSibling; } - assert(*cpp == cat); + xbt_assert(*cpp == cat); *cpp = cat->nextSibling; } - // Set new parent + /* Set new parent */ cat->parent = parent; cat->nextSibling = parent->firstChild; parent->firstChild = cat; - // Make sure parent is initialized - if (parent->threshold == gras_log_priority_uninitialized) { + /* Make sure parent is initialized */ + if (parent->threshold == xbt_log_priority_uninitialized) { _cat_init(parent); } - // Reset priority + /* Reset priority */ cat->threshold = parent->threshold; cat->isThreshInherited = 1; -} // log_setParent +} /* log_setParent */ -static void _set_inherited_thresholds(gras_log_category_t* cat) { - gras_log_category_t* child = cat->firstChild; +static void _set_inherited_thresholds(xbt_log_category_t cat) { + xbt_log_category_t child = cat->firstChild; for( ; child != NULL; child = child->nextSibling) { if (child->isThreshInherited) { - if (cat != &_GRAS_LOGV(log)) + if (cat != &_XBT_LOGV(log)) VERB3("Set category threshold of %s to %s (=%d)", - child->name,gras_log_priority_names[cat->threshold],cat->threshold); + child->name,xbt_log_priority_names[cat->threshold],cat->threshold); child->threshold = cat->threshold; _set_inherited_thresholds(child); } } } -void gras_log_threshold_set(gras_log_category_t* cat, - gras_log_priority_t threshold) { +void xbt_log_threshold_set(xbt_log_category_t cat, + e_xbt_log_priority_t threshold) { cat->threshold = threshold; cat->isThreshInherited = 0; _set_inherited_thresholds(cat); } -static gras_error_t _gras_log_parse_setting(const char* control_string, - gras_log_setting_t *set) { +static void _xbt_log_parse_setting(const char* control_string, + xbt_log_setting_t set) { const char *name, *dot, *eq; set->catname=NULL; if (!*control_string) - return no_error; + return; DEBUG1("Parse log setting '%s'",control_string); control_string += strspn(control_string, " "); @@ -198,12 +204,12 @@ static gras_error_t _gras_log_parse_setting(const char* control_string, eq = control_string; control_string += strcspn(control_string, " "); - gras_assert1(*dot == '.' && *eq == '=', + xbt_assert1(*dot == '.' && *eq == '=', "Invalid control string '%s'",control_string); - if (!strncmp(dot + 1, "thresh", MIN(eq - dot - 1,strlen("thresh")))) { + if (!strncmp(dot + 1, "thresh", min(eq - dot - 1,strlen("thresh")))) { int i; - char *neweq=strdup(eq+1); + char *neweq=xbt_strdup(eq+1); char *p=neweq-1; while (*(++p) != '\0') { @@ -213,42 +219,41 @@ static gras_error_t _gras_log_parse_setting(const char* control_string, } DEBUG1("New priority name = %s",neweq); - for (i=0; i<6; i++) { - if (!strncmp(gras_log_priority_names[i],neweq,p-eq)) { + for (i=0; ithresh=i; } else { - gras_assert1(FALSE,"Unknown priority name: %s",eq+1); + xbt_assert1(FALSE,"Unknown priority name: %s",eq+1); } - free(neweq); + xbt_free(neweq); } else { char buff[512]; - snprintf(buff,MIN(512,eq - dot - 1),"%s",dot+1); - gras_assert1(FALSE,"Unknown setting of the log category: %s",buff); + snprintf(buff,min(512,eq - dot - 1),"%s",dot+1); + xbt_assert1(FALSE,"Unknown setting of the log category: %s",buff); } - if (!(set->catname=malloc(dot - name+1))) - RAISE_MALLOC; + set->catname=(char*)xbt_malloc(dot - name+1); strncpy(set->catname,name,dot-name); set->catname[dot-name]='\0'; /* Just in case */ DEBUG1("This is for cat '%s'", set->catname); - return no_error; } -static gras_error_t _gras_log_cat_searchsub(gras_log_category_t *cat,char *name,gras_log_category_t**whereto) { - gras_error_t errcode; - gras_log_category_t *child; +static xbt_error_t _xbt_log_cat_searchsub(xbt_log_category_t cat,char *name, + /*OUT*/xbt_log_category_t*whereto) { + xbt_error_t errcode; + xbt_log_category_t child; if (!strcmp(cat->name,name)) { *whereto=cat; return no_error; } for(child=cat->firstChild ; child != NULL; child = child->nextSibling) { - errcode=_gras_log_cat_searchsub(child,name,whereto); + errcode=_xbt_log_cat_searchsub(child,name,whereto); if (errcode==no_error) return no_error; } @@ -288,9 +293,8 @@ static void _cleanup_double_spaces(char *s) { } /** - * gras_log_control_set: + * xbt_log_control_set: * @cs: What to parse - * @Returns: malloc_error or no_error * * Typically passed a command-line argument. The string has the syntax: * @@ -306,29 +310,27 @@ static void _cleanup_double_spaces(char *s) { * This routine may only be called once and that must be before any other * logging command! Typically, this is done from main(). */ -gras_error_t gras_log_control_set(const char* control_string) { - gras_error_t errcode; - gras_log_setting_t *set; +void xbt_log_control_set(const char* control_string) { + xbt_error_t errcode; + xbt_log_setting_t set; char *cs; char *p; int done = 0; DEBUG1("Parse log settings '%s'",control_string); if (control_string == NULL) - return no_error; - if (gras_log_settings == NULL) - TRY(gras_dynar_new(&gras_log_settings,sizeof(gras_log_setting_t*), - _free_setting)); + return; + if (xbt_log_settings == NULL) + xbt_log_settings = xbt_dynar_new(sizeof(xbt_log_setting_t), + _free_setting); - if (!(set = malloc(sizeof(gras_log_setting_t)))) - RAISE_MALLOC; + set = xbt_new(s_xbt_log_setting_t,1); + cs=xbt_strdup(control_string); - if (!(cs=strdup(control_string))) - RAISE_MALLOC; _cleanup_double_spaces(cs); while (!done) { - gras_log_category_t *cat; + xbt_log_category_t cat; p=strrchr(cs,' '); if (p) { @@ -338,40 +340,31 @@ gras_error_t gras_log_control_set(const char* control_string) { p=cs; done = 1; } - errcode = _gras_log_parse_setting(p,set); - if (errcode != no_error) { - free(set); - free(cs); - } + _xbt_log_parse_setting(p,set); - TRYCATCH(_gras_log_cat_searchsub(&_GRAS_LOGV(root),set->catname,&cat), - mismatch_error); + errcode = _xbt_log_cat_searchsub(&_XBT_LOGV(root),set->catname,&cat); if (errcode == mismatch_error) { DEBUG0("Store for further application"); - DEBUG1("push %p to the settings",set); - TRY(gras_dynar_push(gras_log_settings,&set)); + DEBUG1("push %p to the settings",(void*)set); + xbt_dynar_push(xbt_log_settings,&set); /* malloc in advance the next slot */ - if (!(set = malloc(sizeof(gras_log_setting_t)))) { - free(cs); - RAISE_MALLOC; - } + set = xbt_new(s_xbt_log_setting_t,1); } else { DEBUG0("Apply directly"); - free(set->catname); - gras_log_threshold_set(cat,set->thresh); + xbt_free(set->catname); + xbt_log_threshold_set(cat,set->thresh); } } - free(set); - free(cs); - return no_error; + xbt_free(set); + xbt_free(cs); } -void gras_log_appender_set(gras_log_category_t* cat, gras_log_appender_t* app) { +void xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app) { cat->appender = app; } -void gras_log_exit(void) { +void xbt_log_exit(void) { VERB0("Exiting log"); - gras_dynar_free(gras_log_settings); + xbt_dynar_free(&xbt_log_settings); VERB0("Exited log"); }