log: add const qualifier to commands struct
[openocd.git] / src / helper / log.c
index 68b29a203b5cda1f27f2e4d9287551db332731b0..90653c41d47ed7db0ca67a26c61f0fe1c630b220 100644 (file)
@@ -2,7 +2,7 @@
  *   Copyright (C) 2005 by Dominic Rath                                    *
  *   Dominic.Rath@gmx.de                                                   *
  *                                                                         *
- *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
+ *   Copyright (C) 2007-2010 Øyvind Harboe                                 *
  *   oyvind.harboe@zylin.com                                               *
  *                                                                         *
  *   Copyright (C) 2008 by Spencer Oliver                                  *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "log.h"
+#include "command.h"
 #include "time_support.h"
-// @todo the inclusion of server.h here is a layering violation
-#include "server.h"
 
 #include <stdarg.h>
 
 
 int debug_level = -1;
 
-static FILElog_output;
-static log_callback_t *log_callbacks = NULL;
+static FILE *log_output;
+static struct log_callback *log_callbacks;
 
-static long long last_time;
-static long long current_time;
+static int64_t last_time;
+static int64_t current_time;
 
-static long long start;
+static int64_t start;
 
-static char *log_strings[5] =
-{
+static const char * const log_strings[6] = {
        "User : ",
        "Error: ",
-       "Warn : ",  /* want a space after each colon, all same width, colons aligned */
+       "Warn : ",      /* want a space after each colon, all same width, colons aligned */
        "Info : ",
+       "Debug: ",
        "Debug: "
 };
 
+static int count;
 
-static int count = 0;
+/* forward the log to the listeners */
+static void log_forward(const char *file, unsigned line, const char *function, const char *string)
+{
+       struct log_callback *cb, *next;
+       cb = log_callbacks;
+       /* DANGER!!!! the log callback can remove itself!!!! */
+       while (cb) {
+               next = cb->next;
+               cb->fn(cb->priv, file, line, function, string);
+               cb = next;
+       }
+}
 
-/* The log_puts() serves to somewhat different goals:
+/* The log_puts() serves two somewhat different goals:
  *
  * - logging
  * - feeding low-level info to the user in GDB or Telnet
@@ -74,11 +84,14 @@ static int count = 0;
  * target_request.c).
  *
  */
-static void log_puts(enum log_levels level, const char *file, int line, const char *function, const char *string)
+static void log_puts(enum log_levels level,
+       const char *file,
+       int line,
+       const char *function,
+       const char *string)
 {
        char *f;
-       if (level == LOG_LVL_OUTPUT)
-       {
+       if (level == LOG_LVL_OUTPUT) {
                /* do not prepend any headers, just print out what we were given and return */
                fputs(string, log_output);
                fflush(log_output);
@@ -89,61 +102,47 @@ static void log_puts(enum log_levels level, const char *file, int line, const ch
        if (f != NULL)
                file = f + 1;
 
-       if (strchr(string, '\n') != NULL)
-       {
-               if (debug_level >= LOG_LVL_DEBUG)
-               {
+       if (strlen(string) > 0) {
+               if (debug_level >= LOG_LVL_DEBUG) {
                        /* print with count and time information */
-                       int t = (int)(timeval_ms()-start);
+                       int64_t t = timeval_ms() - start;
 #ifdef _DEBUG_FREE_SPACE_
                        struct mallinfo info;
                        info = mallinfo();
 #endif
-                       fprintf(log_output, "%s%d %d %s:%d %s()"
+                       fprintf(log_output, "%s%d %" PRId64 " %s:%d %s()"
 #ifdef _DEBUG_FREE_SPACE_
-                                       " %d"
+                               " %d"
 #endif
-                                       ": %s", log_strings[level+1], count, t, file, line, function,
+                               ": %s", log_strings[level + 1], count, t, file, line, function,
 #ifdef _DEBUG_FREE_SPACE_
-                                       info.fordblks,
+                               info.fordblks,
 #endif
-                                       string);
-               }
-               else if (server_use_pipes == 0)
-               {
+                               string);
+               } else {
                        /* if we are using gdb through pipes then we do not want any output
                         * to the pipe otherwise we get repeated strings */
-                       if (strcmp(string, "\n") != 0)
-                       {
-                               /* print human readable output - but skip empty lines */
-                               fprintf(log_output, "%s%s",
-                                               (level > LOG_LVL_USER)?log_strings[level+1]:"", string);
-                       }
+                       fprintf(log_output, "%s%s",
+                               (level > LOG_LVL_USER) ? log_strings[level + 1] : "", string);
                }
-       } else
-       {
-               /* only entire lines are logged. Otherwise it's
-                * single chars intended for the log callbacks. */
+       } else {
+               /* Empty strings are sent to log callbacks to keep e.g. gdbserver alive, here we do
+                *nothing. */
        }
 
        fflush(log_output);
 
        /* Never forward LOG_LVL_DEBUG, too verbose and they can be found in the log if need be */
        if (level <= LOG_LVL_INFO)
-       {
-               log_callback_t *cb, *next;
-               cb = log_callbacks;
-               /* DANGER!!!! the log callback can remove itself!!!! */
-               while (cb)
-               {
-                       next = cb->next;
-                       cb->fn(cb->priv, file, line, function, string);
-                       cb = next;
-               }
-       }
+               log_forward(file, line, function, string);
 }
 
-void log_printf(enum log_levels level, const char *file, int line, const char *function, const char *format, ...)
+void log_printf(enum log_levels level,
+       const char *file,
+       unsigned line,
+       const char *function,
+       const char *format,
+       ...)
 {
        char *string;
        va_list ap;
@@ -155,8 +154,7 @@ void log_printf(enum log_levels level, const char *file, int line, const char *f
        va_start(ap, format);
 
        string = alloc_vprintf(format, ap);
-       if (string != NULL)
-       {
+       if (string != NULL) {
                log_puts(level, file, line, function, string);
                free(string);
        }
@@ -164,107 +162,130 @@ void log_printf(enum log_levels level, const char *file, int line, const char *f
        va_end(ap);
 }
 
-void log_printf_lf(enum log_levels level, const char *file, int line, const char *function, const char *format, ...)
+void log_vprintf_lf(enum log_levels level, const char *file, unsigned line,
+               const char *function, const char *format, va_list args)
 {
-       char *string;
-       va_list ap;
+       char *tmp;
 
        count++;
+
        if (level > debug_level)
                return;
 
-       va_start(ap, format);
+       tmp = alloc_vprintf(format, args);
 
-       string = alloc_vprintf(format, ap);
-       if (string != NULL)
-       {
-               strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
-               log_puts(level, file, line, function, string);
-               free(string);
-       }
+       if (!tmp)
+               return;
 
-       va_end(ap);
+       /*
+        * Note: alloc_vprintf() guarantees that the buffer is at least one
+        * character longer.
+        */
+       strcat(tmp, "\n");
+       log_puts(level, file, line, function, tmp);
+       free(tmp);
 }
 
-/* change the current debug level on the fly
- * 0: only ERRORS
- * 1: + WARNINGS
- * 2: + INFORMATIONAL MSGS
- * 3: + DEBUG MSGS
- */
-int handle_debug_level_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+void log_printf_lf(enum log_levels level,
+       const char *file,
+       unsigned line,
+       const char *function,
+       const char *format,
+       ...)
 {
-       if (argc == 1)
-       {
-               unsigned new_level;
-               int retval = parse_uint(args[0], &new_level);
-               if (ERROR_OK != retval)
-                       return retval;
-               debug_level = MIN(new_level, LOG_LVL_DEBUG);
-       }
-       else if (argc > 1)
-               return ERROR_COMMAND_SYNTAX_ERROR;
+       va_list ap;
 
-       if (debug_level >= LOG_LVL_DEBUG && server_use_pipes == 1)
-       {
-               /* if we are enabling debug info then we need to write to a log file
-                * otherwise the pipe will get full and cause issues with gdb */
-               FILE* file = fopen("openocd.log", "w");
-               if (file)
-               {
-                       log_output = file;
-                       LOG_WARNING("enabling log output as we are using pipes");
+       va_start(ap, format);
+       log_vprintf_lf(level, file, line, function, format, ap);
+       va_end(ap);
+}
+
+COMMAND_HANDLER(handle_debug_level_command)
+{
+       if (CMD_ARGC == 1) {
+               int new_level;
+               COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], new_level);
+               if ((new_level > LOG_LVL_DEBUG_IO) || (new_level < LOG_LVL_SILENT)) {
+                       LOG_ERROR("level must be between %d and %d", LOG_LVL_SILENT, LOG_LVL_DEBUG_IO);
+                       return ERROR_COMMAND_SYNTAX_ERROR;
                }
-       }
+               debug_level = new_level;
+       } else if (CMD_ARGC > 1)
+               return ERROR_COMMAND_SYNTAX_ERROR;
 
-       command_print(cmd_ctx, "debug_level: %i", debug_level);
+       command_print(CMD_CTX, "debug_level: %i", debug_level);
 
        return ERROR_OK;
 }
 
-int handle_log_output_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_log_output_command)
 {
-       if (argc == 1)
-       {
-               FILE* file = fopen(args[0], "w");
-
-               if (file)
-               {
-                       log_output = file;
+       if (CMD_ARGC == 1) {
+               FILE *file = fopen(CMD_ARGV[0], "w");
+               if (file == NULL) {
+                       LOG_ERROR("failed to open output log '%s'", CMD_ARGV[0]);
+                       return ERROR_FAIL;
                }
+               if (log_output != stderr && log_output != NULL) {
+                       /* Close previous log file, if it was open and wasn't stderr. */
+                       fclose(log_output);
+               }
+               log_output = file;
        }
 
        return ERROR_OK;
 }
 
-int log_register_commands(struct command_context_s *cmd_ctx)
-{
-       start = timeval_ms();
-       register_command(cmd_ctx, NULL, "log_output", handle_log_output_command,
-               COMMAND_ANY, "redirect logging to <file> (default: stderr)");
-       register_command(cmd_ctx, NULL, "debug_level", handle_debug_level_command,
-               COMMAND_ANY, "adjust debug level <0-3>");
+static const struct command_registration log_command_handlers[] = {
+       {
+               .name = "log_output",
+               .handler = handle_log_output_command,
+               .mode = COMMAND_ANY,
+               .help = "redirect logging to a file (default: stderr)",
+               .usage = "file_name",
+       },
+       {
+               .name = "debug_level",
+               .handler = handle_debug_level_command,
+               .mode = COMMAND_ANY,
+               .help = "Sets the verbosity level of debugging output. "
+                       "0 shows errors only; 1 adds warnings; "
+                       "2 (default) adds other info; 3 adds debugging; "
+                       "4 adds extra verbose debugging.",
+               .usage = "number",
+       },
+       COMMAND_REGISTRATION_DONE
+};
 
-       return ERROR_OK;
+int log_register_commands(struct command_context *cmd_ctx)
+{
+       return register_commands(cmd_ctx, NULL, log_command_handlers);
 }
 
-int log_init(struct command_context_s *cmd_ctx)
+void log_init(void)
 {
-       /* set defaults for daemon configuration, if not set by cmdline or cfgfile */
+       /* set defaults for daemon configuration,
+        * if not set by cmdline or cfgfile */
        if (debug_level == -1)
                debug_level = LOG_LVL_INFO;
 
+       char *debug_env = getenv("OPENOCD_DEBUG_LEVEL");
+       if (NULL != debug_env) {
+               int value;
+               int retval = parse_int(debug_env, &value);
+               if (ERROR_OK == retval &&
+                               debug_level >= LOG_LVL_SILENT &&
+                               debug_level <= LOG_LVL_DEBUG_IO)
+                               debug_level = value;
+       }
+
        if (log_output == NULL)
-       {
                log_output = stderr;
-       }
 
        start = last_time = timeval_ms();
-
-       return ERROR_OK;
 }
 
-int set_log_output(struct command_context_s *cmd_ctx, FILE *output)
+int set_log_output(struct command_context *cmd_ctx, FILE *output)
 {
        log_output = output;
        return ERROR_OK;
@@ -273,17 +294,18 @@ int set_log_output(struct command_context_s *cmd_ctx, FILE *output)
 /* add/remove log callback handler */
 int log_add_callback(log_callback_fn fn, void *priv)
 {
-       log_callback_t *cb;
+       struct log_callback *cb;
 
        /* prevent the same callback to be registered more than once, just for sure */
-       for (cb = log_callbacks; cb; cb = cb->next)
-       {
+       for (cb = log_callbacks; cb; cb = cb->next) {
                if (cb->fn == fn && cb->priv == priv)
-                       return ERROR_INVALID_ARGUMENTS;
+                       return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
-       /* alloc memory, it is safe just to return in case of an error, no need for the caller to check this */
-       if ((cb = malloc(sizeof(log_callback_t))) == NULL)
+       /* alloc memory, it is safe just to return in case of an error, no need for the caller to
+        *check this */
+       cb = malloc(sizeof(struct log_callback));
+       if (cb == NULL)
                return ERROR_BUF_TOO_SMALL;
 
        /* add item to the beginning of the linked list */
@@ -297,12 +319,10 @@ int log_add_callback(log_callback_fn fn, void *priv)
 
 int log_remove_callback(log_callback_fn fn, void *priv)
 {
-       log_callback_t *cb, **p;
+       struct log_callback *cb, **p;
 
-       for (p = &log_callbacks; (cb = *p); p = &(*p)->next)
-       {
-               if (cb->fn == fn && cb->priv == priv)
-               {
+       for (p = &log_callbacks; (cb = *p); p = &(*p)->next) {
+               if (cb->fn == fn && cb->priv == priv) {
                        *p = cb->next;
                        free(cb);
                        return ERROR_OK;
@@ -310,43 +330,32 @@ int log_remove_callback(log_callback_fn fn, void *priv)
        }
 
        /* no such item */
-       return ERROR_INVALID_ARGUMENTS;
+       return ERROR_COMMAND_SYNTAX_ERROR;
 }
 
 /* return allocated string w/printf() result */
 char *alloc_vprintf(const char *fmt, va_list ap)
 {
-       /* no buffer at the beginning, force realloc to do the job */
-       char *string = NULL;
-
-       /* start with buffer size suitable for typical messages */
-       int size = 128;
+       va_list ap_copy;
+       int len;
+       char *string;
 
-       for (;;)
-       {
-               char *t = string;
-               va_list ap_copy;
-               int ret;
-               string = realloc(string, size);
-               if (string == NULL)
-               {
-                       if (t != NULL)
-                               free(t);
-                       return NULL;
-               }
+       /* determine the length of the buffer needed */
+       va_copy(ap_copy, ap);
+       len = vsnprintf(NULL, 0, fmt, ap_copy);
+       va_end(ap_copy);
 
-               va_copy(ap_copy, ap);
+       /* allocate and make room for terminating zero. */
+       /* FIXME: The old version always allocated at least one byte extra and
+        * other code depend on that. They should be probably be fixed, but for
+        * now reserve the extra byte. */
+       string = malloc(len + 2);
+       if (string == NULL)
+               return NULL;
 
-               ret = vsnprintf(string, size, fmt, ap_copy);
-               /* NB! The result of the vsnprintf() might be an *EMPTY* string! */
-               if ((ret >= 0) && ((ret + 1) < size))
-                       break;
+       /* do the real work */
+       vsnprintf(string, len + 1, fmt, ap);
 
-               /* there was just enough or not enough space, allocate more in the next round */
-               size *= 2; /* double the buffer size */
-       }
-
-       /* the returned buffer is by principle guaranteed to be at least one character longer */
        return string;
 }
 
@@ -384,24 +393,22 @@ char *alloc_printf(const char *format, ...)
 void keep_alive()
 {
        current_time = timeval_ms();
-       if (current_time-last_time>1000)
-       {
+       if (current_time-last_time > 1000) {
                extern int gdb_actual_connections;
 
                if (gdb_actual_connections)
                        LOG_WARNING("keep_alive() was not invoked in the "
                                "1000ms timelimit. GDB alive packet not "
-                               "sent! (%lld). Workaround: increase "
+                               "sent! (%" PRId64 "). Workaround: increase "
                                "\"set remotetimeout\" in GDB",
                                current_time-last_time);
                else
                        LOG_DEBUG("keep_alive() was not invoked in the "
-                               "1000ms timelimit (%lld). This may cause "
+                               "1000ms timelimit (%" PRId64 "). This may cause "
                                "trouble with GDB connections.",
                                current_time-last_time);
        }
-       if (current_time-last_time>500)
-       {
+       if (current_time-last_time > 500) {
                /* this will keep the GDB connection alive */
                LOG_USER_N("%s", "");
 
@@ -425,28 +432,25 @@ void kept_alive()
 }
 
 /* if we sleep for extended periods of time, we must invoke keep_alive() intermittantly */
-void alive_sleep(int ms)
+void alive_sleep(uint64_t ms)
 {
-       int i;
-       int napTime = 10;
-       for (i = 0; i<ms; i += napTime)
-       {
-               int sleep_a_bit = ms-i;
-               if (sleep_a_bit>napTime)
-               {
+       uint64_t napTime = 10;
+       for (uint64_t i = 0; i < ms; i += napTime) {
+               uint64_t sleep_a_bit = ms - i;
+               if (sleep_a_bit > napTime)
                        sleep_a_bit = napTime;
-               }
-               usleep(sleep_a_bit*1000);
+
+               usleep(sleep_a_bit * 1000);
                keep_alive();
        }
 }
 
-void busy_sleep(int ms)
+void busy_sleep(uint64_t ms)
 {
-       long long then;
-       then = timeval_ms();
-       while ((timeval_ms()-then)<ms)
-       {
-               /* busy wait */
+       uint64_t then = timeval_ms();
+       while (timeval_ms() - then < ms) {
+               /*
+                * busy wait
+                */
        }
 }

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)