src/xbt/xbt_log_layout_format.c

   1 /* $Id$ */
   2
   3 /* layout_simple - a dumb log layout                                        */
   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 "portable.h"           /* execinfo when available */
  11 #include "xbt/sysdep.h"
  12 #include "xbt/strbuff.h"
  13 #include "xbt/log_private.h"
  14 #include "gras/virtu.h"         /* gras_os_myname (KILLME) */
  15 #include "xbt/synchro.h"        /* xbt_thread_self_name */
  16 #include <stdio.h>
  17
  18 extern const char *xbt_log_priority_names[7];
  19
  20 static double begin_of_time = -1;
  21
  22 #define append1(fmt,fmt2,elm)                                         \
  23   do {                                                               \
  24     if (precision == -1) {                                        \
  25       xbt_strbuff_append(buff, tmp=bprintf(fmt,elm));            \
  26       free(tmp);                                                 \
  27     } else {                                                      \
  28       xbt_strbuff_append(buff, tmp=bprintf(fmt2,precision,elm)); \
  29       free(tmp);                                                 \
  30       precision = -1;                                            \
  31     }                                                         \
  32   } while (0)
  33 #define append2(fmt,elm,elm2)                                         \
  34   do {                                                               \
  35     xbt_strbuff_append(buff, tmp=bprintf(fmt,elm,elm2));          \
  36     free(tmp);                                                    \
  37     precision = -1;                                               \
  38   } while (0)
  39
  40 #define ERRMSG "Unknown %%%c sequence in layout format (%s).\nKnown sequences:\n"                       \
  41   "  what:        %%m: user message  %%c: log category  %%p: log priority\n"                      \
  42   "  where:\n"                                                                                    \
  43   "    source:    %%F: file          %%L: line          %%M: function  %%l: location (%%F:%%L)\n" \
  44   "    runtime:   %%h: hostname      %%t: thread        %%P: process   %%i: PID\n"                \
  45   "    backtrace: %%b: full          %%B: short\n"                                                \
  46   "  when:        %%d: date          %%r: app. age\n"                                             \
  47   "  other:       %%%%: %%             %%n: new line      %%e: plain space\n"
  48
  49
  50 static void xbt_log_layout_format_dynamic(xbt_log_layout_t l,
  51                                           xbt_log_event_t ev,
  52                                           const char *fmt,
  53                                           xbt_log_appender_t app)
  54 {
  55   xbt_strbuff_t buff = xbt_strbuff_new();
  56   int precision = -1;
  57   char *q = l->data;
  58   char *tmp;
  59   char *tmp2;
  60   int vres;                     /* shut gcc up, but ignored */
  61
  62   while (*q != '\0') {
  63     if (*q == '%') {
  64       q++;
  65     handle_modifier:
  66       switch (*q) {
  67       case '\0':
  68         fprintf(stderr, "Layout format (%s) ending with %%\n",
  69                 (char *) l->data);
  70         abort();
  71       case '%':
  72         xbt_strbuff_append(buff, "%");
  73         break;
  74       case 'n':                /* platform-dependant line separator (LOG4J compliant) */
  75         xbt_strbuff_append(buff, "\n");
  76         break;
  77       case 'e':                /* plain space (SimGrid extension) */
  78         xbt_strbuff_append(buff, " ");
  79         break;
  80
  81       case '.':                /* precision specifyier */
  82         q++;
  83         q += sscanf(q, "%d", &precision);
  84         goto handle_modifier;
  85
  86       case 'c':                /* category name; LOG4J compliant
  87                                    should accept a precision postfix to show the hierarchy */
  88         append1("%s", "%.*s", ev->cat->name);
  89         break;
  90       case 'p':                /* priority name; LOG4J compliant */
  91         append1("%s", "%.*s", xbt_log_priority_names[ev->priority]);
  92         break;
  93
  94       case 'h':                /* host name; SimGrid extension */
  95         append1("%s", "%.*s", gras_os_myname());
  96         break;
  97       case 't':                /* thread name; LOG4J compliant */
  98         append1("%s", "%.*s", xbt_thread_self_name());
  99         break;
 100       case 'P':                /* process name; SimGrid extension */
 101         append1("%s", "%.*s", xbt_procname());
 102         break;
 103       case 'i':                /* process PID name; SimGrid extension */
 104         append1("%d", "%.*d", (*xbt_getpid) ());
 105         break;
 106
 107       case 'F':                /* file name; LOG4J compliant */
 108         append1("%s", "%.*s", ev->fileName);
 109         break;
 110       case 'l':                /* location; LOG4J compliant */
 111         append2("%s:%d", ev->fileName, ev->lineNum);
 112         precision = -1;         /* Ignored */
 113         break;
 114       case 'L':                /* line number; LOG4J compliant */
 115         append1("%d", "%.*d", ev->lineNum);
 116         break;
 117       case 'M':                /* method (ie, function) name; LOG4J compliant */
 118         append1("%s", "%.*s", ev->functionName);
 119         break;
 120       case 'b':                /* backtrace; called %throwable in LOG4J */
 121       case 'B':                /* short backtrace; called %throwable{short} in LOG4J */
 122 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)
 123         {
 124           xbt_ex_t e;
 125           int i;
 126
 127           e.used = backtrace((void **) e.bt, XBT_BACKTRACE_SIZE);
 128           e.bt_strings = NULL;
 129           e.msg = NULL;
 130           e.remote = 0;
 131           xbt_backtrace_current(&e);
 132           if (*q == 'B') {
 133             append1("%s", "%.*s", e.bt_strings[2] + 8);
 134           } else {
 135             for (i = 2; i < e.used; i++)
 136               append1("%s\n", "%.*s\n", e.bt_strings[i] + 8);
 137           }
 138
 139           xbt_ex_free(e);
 140         }
 141 #else
 142         append1("%s", "%.*s", "(no backtrace on this arch)");
 143 #endif
 144         break;
 145
 146       case 'd':                /* date; LOG4J compliant */
 147         append1("%f", "%.*f", gras_os_time());
 148         break;
 149       case 'r':                /* application age; LOG4J compliant */
 150         append1("%f", "%.*f", gras_os_time() - begin_of_time);
 151         break;
 152
 153       case 'm':                /* user-provided message; LOG4J compliant */
 154         vres = vasprintf(&tmp2, fmt, ev->ap_copy);
 155         append1("%s", "%.*s", tmp2);
 156         free(tmp2);
 157         break;
 158
 159       default:
 160         fprintf(stderr, ERRMSG, *q, (char *) l->data);
 161         abort();
 162       }
 163       q++;
 164     } else {
 165       char tmp2[2];
 166       tmp2[0] = *(q++);
 167       tmp2[1] = '\0';
 168       xbt_strbuff_append(buff, tmp2);
 169     }
 170   }
 171   app->do_append(app, buff->data);
 172   xbt_strbuff_free(buff);
 173 }
 174
 175 #define check_overflow \
 176   if (p-ev->buffer > XBT_LOG_BUFF_SIZE) { /* buffer overflow */ \
 177   xbt_log_layout_format_dynamic(l,ev,msg_fmt,app); \
 178   return;\
 179   }
 180 static void xbt_log_layout_format_doit(xbt_log_layout_t l,
 181                                        xbt_log_event_t ev,
 182                                        const char *msg_fmt,
 183                                        xbt_log_appender_t app)
 184 {
 185   char *p, *q;
 186   int precision = -1;
 187
 188   if (begin_of_time < 0)
 189     begin_of_time = gras_os_time();
 190
 191   p = ev->buffer;
 192   q = l->data;
 193
 194   while (*q != '\0') {
 195     if (*q == '%') {
 196       q++;
 197     handle_modifier:
 198       switch (*q) {
 199       case '\0':
 200         fprintf(stderr, "Layout format (%s) ending with %%\n",
 201                 (char *) l->data);
 202         abort();
 203       case '%':
 204         *p++ = '%';
 205         break;
 206       case 'n':                /* platform-dependant line separator (LOG4J compliant) */
 207         p += snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "\n");
 208         check_overflow;
 209         break;
 210       case 'e':                /* plain space (SimGrid extension) */
 211         p += snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), " ");
 212         check_overflow;
 213         break;
 214
 215       case '.':                /* precision specifyier */
 216         q++;
 217         q += sscanf(q, "%d", &precision);
 218         goto handle_modifier;
 219
 220       case 'c':                /* category name; LOG4J compliant
 221                                    should accept a precision postfix to show the hierarchy */
 222         if (precision == -1) {
 223           p +=
 224             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 225                      ev->cat->name);
 226           check_overflow;
 227         } else {
 228           p +=
 229             sprintf(p, "%.*s",
 230                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 231                               precision), ev->cat->name);
 232           check_overflow;
 233           precision = -1;
 234         }
 235         break;
 236       case 'p':                /* priority name; LOG4J compliant */
 237         if (precision == -1) {
 238           p +=
 239             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 240                      xbt_log_priority_names[ev->priority]);
 241           check_overflow;
 242         } else {
 243           p +=
 244             sprintf(p, "%.*s",
 245                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 246                               precision),
 247                     xbt_log_priority_names[ev->priority]);
 248           check_overflow;
 249           precision = -1;
 250         }
 251         break;
 252
 253       case 'h':                /* host name; SimGrid extension */
 254         if (precision == -1) {
 255           p +=
 256             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 257                      gras_os_myname());
 258           check_overflow;
 259         } else {
 260           p +=
 261             sprintf(p, "%.*s",
 262                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 263                               precision), gras_os_myname());
 264           check_overflow;
 265           precision = -1;
 266         }
 267         break;
 268       case 't':                /* thread name; LOG4J compliant */
 269         if (precision == -1) {
 270           p +=
 271             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 272                      xbt_thread_self_name());
 273           check_overflow;
 274         } else {
 275           p +=
 276             sprintf(p, "%.*s",
 277                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 278                               precision), xbt_thread_self_name());
 279           check_overflow;
 280           precision = -1;
 281         }
 282         break;
 283       case 'P':                /* process name; SimGrid extension */
 284         if (precision == -1) {
 285           p +=
 286             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 287                      xbt_procname());
 288           check_overflow;
 289         } else {
 290           p +=
 291             sprintf(p, "%.*s",
 292                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 293                               precision), xbt_procname());
 294           check_overflow;
 295           precision = -1;
 296         }
 297         break;
 298       case 'i':                /* process PID name; SimGrid extension */
 299         if (precision == -1) {
 300           p +=
 301             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%d",
 302                      (*xbt_getpid) ());
 303           check_overflow;
 304         } else {
 305           p +=
 306             sprintf(p, "%.*d",
 307                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 308                               precision), (*xbt_getpid) ());
 309           check_overflow;
 310           precision = -1;
 311         }
 312         break;
 313
 314       case 'F':                /* file name; LOG4J compliant */
 315         if (precision == -1) {
 316           p +=
 317             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 318                      ev->fileName);
 319           check_overflow;
 320         } else {
 321           p +=
 322             sprintf(p, "%.*s",
 323                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 324                               precision), ev->fileName);
 325           check_overflow;
 326           precision = -1;
 327         }
 328         break;
 329       case 'l':                /* location; LOG4J compliant */
 330         if (precision == -1) {
 331           p +=
 332             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s:%d",
 333                      ev->fileName, ev->lineNum);
 334           check_overflow;
 335         } else {
 336           p +=
 337             snprintf(p,
 338                      (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 339                                precision), "%s:%d", ev->fileName,
 340                      ev->lineNum);
 341           check_overflow;
 342           precision = -1;
 343         }
 344         break;
 345       case 'L':                /* line number; LOG4J compliant */
 346         if (precision == -1) {
 347           p +=
 348             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%d",
 349                      ev->lineNum);
 350           check_overflow;
 351         } else {
 352           p +=
 353             sprintf(p, "%.*d",
 354                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 355                               precision), ev->lineNum);
 356           check_overflow;
 357           precision = -1;
 358         }
 359         break;
 360       case 'M':                /* method (ie, function) name; LOG4J compliant */
 361         if (precision == -1) {
 362           p +=
 363             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 364                      ev->functionName);
 365           check_overflow;
 366         } else {
 367           p +=
 368             sprintf(p, "%.*s",
 369                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 370                               precision), ev->functionName);
 371           check_overflow;
 372           precision = -1;
 373         }
 374         break;
 375       case 'b':                /* backtrace; called %throwable in LOG4J */
 376       case 'B':                /* short backtrace; called %throwable{short} in LOG4J */
 377 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)
 378         {
 379           xbt_ex_t e;
 380           int i;
 381
 382           e.used = backtrace((void **) e.bt, XBT_BACKTRACE_SIZE);
 383           e.bt_strings = NULL;
 384           e.msg = NULL;
 385           e.remote = 0;
 386           xbt_backtrace_current(&e);
 387           if (*q == 'B') {
 388             if (precision == -1) {
 389               p +=
 390                 snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 391                          e.bt_strings[2] + 8);
 392               check_overflow;
 393             } else {
 394               p +=
 395                 sprintf(p, "%.*s",
 396                         (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 397                                   precision), e.bt_strings[2] + 8);
 398               check_overflow;
 399               precision = -1;
 400             }
 401           } else {
 402             for (i = 2; i < e.used; i++)
 403               if (precision == -1) {
 404                 p +=
 405                   snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s\n",
 406                            e.bt_strings[i] + 8);
 407                 check_overflow;
 408               } else {
 409                 p +=
 410                   sprintf(p, "%.*s\n",
 411                           (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 412                                     precision), e.bt_strings[i] + 8);
 413                 check_overflow;
 414                 precision = -1;
 415               }
 416           }
 417
 418           xbt_ex_free(e);
 419         }
 420 #else
 421         p +=
 422           snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 423                    "(no backtrace on this arch)");
 424         check_overflow;
 425 #endif
 426         break;
 427
 428       case 'd':                /* date; LOG4J compliant */
 429         if (precision == -1) {
 430           p +=
 431             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%f",
 432                      gras_os_time());
 433           check_overflow;
 434         } else {
 435           p +=
 436             sprintf(p, "%.*f",
 437                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 438                               precision), gras_os_time());
 439           check_overflow;
 440           precision = -1;
 441         }
 442         break;
 443       case 'r':                /* application age; LOG4J compliant */
 444         if (precision == -1) {
 445           p +=
 446             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%f",
 447                      gras_os_time() - begin_of_time);
 448           check_overflow;
 449         } else {
 450           p +=
 451             sprintf(p, "%.*f",
 452                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 453                               precision), gras_os_time() - begin_of_time);
 454           check_overflow;
 455           precision = -1;
 456         }
 457         break;
 458
 459       case 'm':                /* user-provided message; LOG4J compliant */
 460         if (precision == -1) {
 461           p +=
 462             vsnprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), msg_fmt,
 463                       ev->ap);
 464           check_overflow;
 465         } else {
 466           p +=
 467             vsnprintf(p,
 468                       (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 469                                 precision), msg_fmt, ev->ap);
 470           check_overflow;
 471           precision = -1;
 472         }
 473         break;
 474
 475       default:
 476         fprintf(stderr, ERRMSG, *q, (char *) l->data);
 477         abort();
 478       }
 479       q++;
 480     } else {
 481       *(p++) = *(q++);
 482       check_overflow;
 483     }
 484   }
 485   *p = '\0';
 486   app->do_append(app, ev->buffer);
 487 }
 488
 489 static void xbt_log_layout_format_free(xbt_log_layout_t lay)
 490 {
 491   free(lay->data);
 492 }
 493
 494 xbt_log_layout_t xbt_log_layout_format_new(char *arg)
 495 {
 496   xbt_log_layout_t res = xbt_new0(s_xbt_log_layout_t, 1);
 497   res->do_layout = xbt_log_layout_format_doit;
 498   res->free_ = xbt_log_layout_format_free;
 499   res->data = xbt_strdup((char *) arg);
 500   return res;
 501 }