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[8];
  19
  20 static double format_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() - format_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 #undef check_overflow
 176 #define check_overflow \
 177   if (p-ev->buffer > XBT_LOG_BUFF_SIZE) { /* buffer overflow */ \
 178   xbt_log_layout_format_dynamic(l,ev,msg_fmt,app); \
 179   return;\
 180   }
 181 static void xbt_log_layout_format_doit(xbt_log_layout_t l,
 182                                        xbt_log_event_t ev,
 183                                        const char *msg_fmt,
 184                                        xbt_log_appender_t app)
 185 {
 186   char *p, *q;
 187   int precision = -1;
 188
 189   if (format_begin_of_time < 0)
 190     format_begin_of_time = gras_os_time();
 191
 192   p = ev->buffer;
 193   q = l->data;
 194
 195   while (*q != '\0') {
 196     if (*q == '%') {
 197       q++;
 198     handle_modifier:
 199       switch (*q) {
 200       case '\0':
 201         fprintf(stderr, "Layout format (%s) ending with %%\n",
 202                 (char *) l->data);
 203         abort();
 204       case '%':
 205         *p++ = '%';
 206         break;
 207       case 'n':                /* platform-dependant line separator (LOG4J compliant) */
 208         p += snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "\n");
 209         check_overflow;
 210         break;
 211       case 'e':                /* plain space (SimGrid extension) */
 212         p += snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), " ");
 213         check_overflow;
 214         break;
 215
 216       case '.':                /* precision specifyier */
 217         q++;
 218         q += sscanf(q, "%d", &precision);
 219         goto handle_modifier;
 220
 221       case 'c':                /* category name; LOG4J compliant
 222                                    should accept a precision postfix to show the hierarchy */
 223         if (precision == -1) {
 224           p +=
 225             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 226                      ev->cat->name);
 227           check_overflow;
 228         } else {
 229           p +=
 230             sprintf(p, "%.*s",
 231                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 232                               precision), ev->cat->name);
 233           check_overflow;
 234           precision = -1;
 235         }
 236         break;
 237       case 'p':                /* priority name; LOG4J compliant */
 238         if (precision == -1) {
 239           p +=
 240             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 241                      xbt_log_priority_names[ev->priority]);
 242           check_overflow;
 243         } else {
 244           p +=
 245             sprintf(p, "%.*s",
 246                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 247                               precision),
 248                     xbt_log_priority_names[ev->priority]);
 249           check_overflow;
 250           precision = -1;
 251         }
 252         break;
 253
 254       case 'h':                /* host name; SimGrid extension */
 255         if (precision == -1) {
 256           p +=
 257             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 258                      gras_os_myname());
 259           check_overflow;
 260         } else {
 261           p +=
 262             sprintf(p, "%.*s",
 263                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 264                               precision), gras_os_myname());
 265           check_overflow;
 266           precision = -1;
 267         }
 268         break;
 269       case 't':                /* thread name; LOG4J compliant */
 270         if (precision == -1) {
 271           p +=
 272             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 273                      xbt_thread_self_name());
 274           check_overflow;
 275         } else {
 276           p +=
 277             sprintf(p, "%.*s",
 278                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 279                               precision), xbt_thread_self_name());
 280           check_overflow;
 281           precision = -1;
 282         }
 283         break;
 284       case 'P':                /* process name; SimGrid extension */
 285         if (precision == -1) {
 286           p +=
 287             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 288                      xbt_procname());
 289           check_overflow;
 290         } else {
 291           p +=
 292             sprintf(p, "%.*s",
 293                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 294                               precision), xbt_procname());
 295           check_overflow;
 296           precision = -1;
 297         }
 298         break;
 299       case 'i':                /* process PID name; SimGrid extension */
 300         if (precision == -1) {
 301           p +=
 302             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%d",
 303                      (*xbt_getpid) ());
 304           check_overflow;
 305         } else {
 306           p +=
 307             sprintf(p, "%.*d",
 308                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 309                               precision), (*xbt_getpid) ());
 310           check_overflow;
 311           precision = -1;
 312         }
 313         break;
 314
 315       case 'F':                /* file name; LOG4J compliant */
 316         if (precision == -1) {
 317           p +=
 318             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 319                      ev->fileName);
 320           check_overflow;
 321         } else {
 322           p +=
 323             sprintf(p, "%.*s",
 324                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 325                               precision), ev->fileName);
 326           check_overflow;
 327           precision = -1;
 328         }
 329         break;
 330       case 'l':                /* location; LOG4J compliant */
 331         if (precision == -1) {
 332           p +=
 333             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s:%d",
 334                      ev->fileName, ev->lineNum);
 335           check_overflow;
 336         } else {
 337           p +=
 338             snprintf(p,
 339                      (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 340                                precision), "%s:%d", ev->fileName,
 341                      ev->lineNum);
 342           check_overflow;
 343           precision = -1;
 344         }
 345         break;
 346       case 'L':                /* line number; LOG4J compliant */
 347         if (precision == -1) {
 348           p +=
 349             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%d",
 350                      ev->lineNum);
 351           check_overflow;
 352         } else {
 353           p +=
 354             sprintf(p, "%.*d",
 355                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 356                               precision), ev->lineNum);
 357           check_overflow;
 358           precision = -1;
 359         }
 360         break;
 361       case 'M':                /* method (ie, function) name; LOG4J compliant */
 362         if (precision == -1) {
 363           p +=
 364             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 365                      ev->functionName);
 366           check_overflow;
 367         } else {
 368           p +=
 369             sprintf(p, "%.*s",
 370                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 371                               precision), ev->functionName);
 372           check_overflow;
 373           precision = -1;
 374         }
 375         break;
 376       case 'b':                /* backtrace; called %throwable in LOG4J */
 377       case 'B':                /* short backtrace; called %throwable{short} in LOG4J */
 378 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)
 379         {
 380           xbt_ex_t e;
 381           int i;
 382
 383           e.used = backtrace((void **) e.bt, XBT_BACKTRACE_SIZE);
 384           e.bt_strings = NULL;
 385           e.msg = NULL;
 386           e.remote = 0;
 387           xbt_backtrace_current(&e);
 388           if (*q == 'B') {
 389             if (precision == -1) {
 390               p +=
 391                 snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s",
 392                          e.bt_strings[2] + 8);
 393               check_overflow;
 394             } else {
 395               p +=
 396                 sprintf(p, "%.*s",
 397                         (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 398                                   precision), e.bt_strings[2] + 8);
 399               check_overflow;
 400               precision = -1;
 401             }
 402           } else {
 403             for (i = 2; i < e.used; i++)
 404               if (precision == -1) {
 405                 p +=
 406                   snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%s\n",
 407                            e.bt_strings[i] + 8);
 408                 check_overflow;
 409               } else {
 410                 p +=
 411                   sprintf(p, "%.*s\n",
 412                           (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 413                                     precision), e.bt_strings[i] + 8);
 414                 check_overflow;
 415                 precision = -1;
 416               }
 417           }
 418
 419           xbt_ex_free(e);
 420         }
 421 #else
 422         p +=
 423           snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 424                    "(no backtrace on this arch)");
 425         check_overflow;
 426 #endif
 427         break;
 428
 429       case 'd':                /* date; LOG4J compliant */
 430         if (precision == -1) {
 431           p +=
 432             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%f",
 433                      gras_os_time());
 434           check_overflow;
 435         } else {
 436           p +=
 437             sprintf(p, "%.*f",
 438                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 439                               precision), gras_os_time());
 440           check_overflow;
 441           precision = -1;
 442         }
 443         break;
 444       case 'r':                /* application age; LOG4J compliant */
 445         if (precision == -1) {
 446           p +=
 447             snprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), "%f",
 448                      gras_os_time() - format_begin_of_time);
 449           check_overflow;
 450         } else {
 451           p +=
 452             sprintf(p, "%.*f",
 453                     (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 454                               precision), gras_os_time() - format_begin_of_time);
 455           check_overflow;
 456           precision = -1;
 457         }
 458         break;
 459
 460       case 'm':                /* user-provided message; LOG4J compliant */
 461         if (precision == -1) {
 462           p +=
 463             vsnprintf(p, XBT_LOG_BUFF_SIZE - (p - ev->buffer), msg_fmt,
 464                       ev->ap);
 465           check_overflow;
 466         } else {
 467           p +=
 468             vsnprintf(p,
 469                       (int) MIN(XBT_LOG_BUFF_SIZE - (p - ev->buffer),
 470                                 precision), msg_fmt, ev->ap);
 471           check_overflow;
 472           precision = -1;
 473         }
 474         break;
 475
 476       default:
 477         fprintf(stderr, ERRMSG, *q, (char *) l->data);
 478         abort();
 479       }
 480       q++;
 481     } else {
 482       *(p++) = *(q++);
 483       check_overflow;
 484     }
 485   }
 486   *p = '\0';
 487   app->do_append(app, ev->buffer);
 488 }
 489
 490 static void xbt_log_layout_format_free(xbt_log_layout_t lay)
 491 {
 492   free(lay->data);
 493 }
 494
 495 xbt_log_layout_t xbt_log_layout_format_new(char *arg)
 496 {
 497   xbt_log_layout_t res = xbt_new0(s_xbt_log_layout_t, 1);
 498   res->do_layout = xbt_log_layout_format_doit;
 499   res->free_ = xbt_log_layout_format_free;
 500   res->data = xbt_strdup((char *) arg);
 501   return res;
 502 }