src/xbt/xbt_log_layout_format.c

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