git.gag.com Git - fw/openocd/blob - src/helper/log.c

   1 /***************************************************************************\r
   2  *   Copyright (C) 2005 by Dominic Rath                                    *\r
   3  *   Dominic.Rath@gmx.de                                                   *\r
   4  *                                                                         *\r
   5  *   This program is free software; you can redistribute it and/or modify  *\r
   6  *   it under the terms of the GNU General Public License as published by  *\r
   7  *   the Free Software Foundation; either version 2 of the License, or     *\r
   8  *   (at your option) any later version.                                   *\r
   9  *                                                                         *\r
  10  *   This program is distributed in the hope that it will be useful,       *\r
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r
  13  *   GNU General Public License for more details.                          *\r
  14  *                                                                         *\r
  15  *   You should have received a copy of the GNU General Public License     *\r
  16  *   along with this program; if not, write to the                         *\r
  17  *   Free Software Foundation, Inc.,                                       *\r
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *\r
  19  ***************************************************************************/\r
  20 #ifdef HAVE_CONFIG_H\r
  21 #include "config.h"\r
  22 #endif\r
  23 \r
  24 #include "log.h"\r
  25 #include "configuration.h"\r
  26 \r
  27 #include <stdio.h>\r
  28 #include <stdlib.h>\r
  29 #include <string.h>\r
  30 #include <stdarg.h>\r
  31 #include <time.h>\r
  32 \r
  33 int debug_level = -1;\r
  34 \r
  35 static FILE* log_output;\r
  36 static log_callback_t *log_callbacks = NULL;\r
  37 \r
  38 static time_t start;\r
  39 \r
  40 static char *log_strings[5] =\r
  41 {\r
  42         "User:   ",\r
  43         "Error:  ",\r
  44         "Warning:",\r
  45         "Info:   ",\r
  46         "Debug:  "\r
  47 };\r
  48 \r
  49 void log_printf(enum log_levels level, const char *file, int line, const char *function, const char *format, ...)\r
  50 {\r
  51         static int count = 0;\r
  52         count++;\r
  53         va_list args;\r
  54         char buffer[512];\r
  55         log_callback_t *cb;\r
  56 \r
  57         if (level > debug_level)\r
  58                 return;\r
  59 \r
  60         va_start(args, format);\r
  61         vsnprintf(buffer, 512, format, args);\r
  62         va_end(args);\r
  63 \r
  64         if (level == LOG_OUTPUT)\r
  65         {\r
  66                 /* do not prepend any headers, just print out what we were given and return */\r
  67                 fputs(buffer, log_output);\r
  68                 fflush(log_output);\r
  69                 return;\r
  70         }\r
  71 \r
  72         char *f = strrchr(file, '/');\r
  73         if (f != NULL)\r
  74                 file = f + 1;\r
  75 \r
  76         if (debug_level >= LOG_DEBUG)\r
  77         {\r
  78                 /* print with count and time information */\r
  79                 time_t t=time(NULL)-start;\r
  80                 fprintf(log_output, "%s %d %ld %s:%d %s(): %s\n", log_strings[level+1], count, t, file, line, function, buffer);\r
  81         }\r
  82         else\r
  83         {\r
  84                 /* do not print count and time */\r
  85                 fprintf(log_output, "%s %s:%d %s(): %s\n", log_strings[level+1], file, line, function, buffer);\r
  86         }\r
  87 \r
  88         fflush(log_output);\r
  89         \r
  90         /* Never forward LOG_DEBUG, too verbose and they can be found in the log if need be */\r
  91         if (level <= LOG_INFO)\r
  92         {\r
  93                 for (cb = log_callbacks; cb; cb = cb->next)\r
  94                 {\r
  95                         va_start(args, format);\r
  96                         cb->fn(cb->priv, file, line, function, format, args);\r
  97                         va_end(args);\r
  98                 }\r
  99         }\r
 100 }\r
 101 \r
 102 /* change the current debug level on the fly\r
 103  * 0: only ERRORS\r
 104  * 1: + WARNINGS\r
 105  * 2: + INFORMATIONAL MSGS\r
 106  * 3: + DEBUG MSGS\r
 107  */\r
 108 int handle_debug_level_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
 109 {\r
 110         if (argc == 0)\r
 111                 command_print(cmd_ctx, "debug_level: %i", debug_level);\r
 112 \r
 113         if (argc > 0)\r
 114                 debug_level = strtoul(args[0], NULL, 0);\r
 115 \r
 116         if (debug_level < 0)\r
 117                 debug_level = 0;\r
 118 \r
 119         if (debug_level > 3)\r
 120                 debug_level = 3;\r
 121 \r
 122         return ERROR_OK;\r
 123 }\r
 124 \r
 125 int handle_log_output_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
 126 {\r
 127         if (argc == 1)\r
 128         {\r
 129                 FILE* file = fopen(args[0], "w");\r
 130                 \r
 131                 if (file)\r
 132                 {\r
 133                         log_output = file;\r
 134                 }\r
 135         }\r
 136 \r
 137         return ERROR_OK;\r
 138 }\r
 139 \r
 140 int log_register_commands(struct command_context_s *cmd_ctx)\r
 141 {\r
 142         start = time(NULL);\r
 143         register_command(cmd_ctx, NULL, "log_output", handle_log_output_command,\r
 144                 COMMAND_ANY, "redirect logging to <file> (default: stderr)");\r
 145         register_command(cmd_ctx, NULL, "debug_level", handle_debug_level_command,\r
 146                 COMMAND_ANY, "adjust debug level <0-3>");\r
 147 \r
 148         return ERROR_OK;\r
 149 }\r
 150 \r
 151 int log_init(struct command_context_s *cmd_ctx)\r
 152 {\r
 153         /* set defaults for daemon configuration, if not set by cmdline or cfgfile */\r
 154         if (debug_level == -1)\r
 155                 debug_level = LOG_INFO;\r
 156         \r
 157         if (log_output == NULL)\r
 158         {\r
 159                 log_output = stderr;\r
 160         }\r
 161         \r
 162         return ERROR_OK;\r
 163 }\r
 164         \r
 165 int set_log_output(struct command_context_s *cmd_ctx, FILE *output)\r
 166 {\r
 167         log_output = output;\r
 168         return ERROR_OK;\r
 169 }\r
 170 \r
 171 /* add/remove log callback handler */\r
 172 int log_add_callback(log_callback_fn fn, void *priv)\r
 173 {\r
 174         log_callback_t *cb;\r
 175 \r
 176         /* prevent the same callback to be registered more than once, just for sure */\r
 177         for (cb = log_callbacks; cb; cb = cb->next)\r
 178         {\r
 179                 if (cb->fn == fn && cb->priv == priv)\r
 180                         return ERROR_INVALID_ARGUMENTS;\r
 181         }\r
 182 \r
 183         /* alloc memory, it is safe just to return in case of an error, no need for the caller to check this */\r
 184         if ((cb = malloc(sizeof(log_callback_t))) == NULL)\r
 185                 return ERROR_BUF_TOO_SMALL;\r
 186 \r
 187         /* add item to the beginning of the linked list */\r
 188         cb->fn = fn;\r
 189         cb->priv = priv;\r
 190         cb->next = log_callbacks;\r
 191         log_callbacks = cb;\r
 192 \r
 193         return ERROR_OK;\r
 194 }\r
 195 \r
 196 int log_remove_callback(log_callback_fn fn, void *priv)\r
 197 {\r
 198         log_callback_t *cb, **p;\r
 199 \r
 200         for (p = &log_callbacks; cb = *p; p = &(*p)->next)\r
 201         {\r
 202             if (cb->fn == fn && cb->priv == priv)\r
 203             {\r
 204                 *p = cb->next;\r
 205                         free(cb);\r
 206                         return ERROR_OK;\r
 207                 }\r
 208         }\r
 209 \r
 210         /* no such item */\r
 211         return ERROR_INVALID_ARGUMENTS;\r
 212 }\r
 213 \r
 214 /* return allocated string w/printf() result */\r
 215 char *alloc_printf(const char *fmt, va_list ap)\r
 216 {\r
 217         char *string = NULL;\r
 218         \r
 219         /* start by 0 to exercise all the code paths. Need minimum 2 bytes to\r
 220          * fit 1 char and 0 terminator. */\r
 221         int size = 0;\r
 222         int first = 1;\r
 223         for (;;)\r
 224         {\r
 225                 if ((string == NULL) || (!first))\r
 226                 {\r
 227                         size = size * 2 + 2;\r
 228                         char *t = string;\r
 229                         string = realloc(string, size);\r
 230                         if (string == NULL)\r
 231                         {\r
 232                                 if (t != NULL)\r
 233                                         free(t);\r
 234                                 return NULL;\r
 235                         }\r
 236                 }\r
 237         \r
 238             int ret;\r
 239             ret = vsnprintf(string, size, fmt, ap);\r
 240             /* NB! The result of the vsnprintf() might be an *EMPTY* string! */\r
 241             if ((ret >= 0) && ((ret + 1) < size))\r
 242             {\r
 243                 return string;\r
 244             }\r
 245             /* there was just enough or not enough space, allocate more. */\r
 246             first = 0;\r
 247         }\r
 248 }\r