f9807747b5f4f780743e2d871f9ace0022b2cb18
[openocd.git] / src / helper / log.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2010 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
23 ***************************************************************************/
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include "log.h"
30 #include "command.h"
31 #include "time_support.h"
32
33 #include <stdarg.h>
34
35 #ifdef _DEBUG_FREE_SPACE_
36 #ifdef HAVE_MALLOC_H
37 #include <malloc.h>
38 #else
39 #error "malloc.h is required to use --enable-malloc-logging"
40 #endif
41 #endif
42
43 int debug_level = -1;
44
45 static FILE *log_output;
46 static struct log_callback *log_callbacks;
47
48 static int64_t last_time;
49 static int64_t current_time;
50
51 static int64_t start;
52
53 static const char * const log_strings[6] = {
54 "User : ",
55 "Error: ",
56 "Warn : ", /* want a space after each colon, all same width, colons aligned */
57 "Info : ",
58 "Debug: ",
59 "Debug: "
60 };
61
62 static int count;
63
64 /* forward the log to the listeners */
65 static void log_forward(const char *file, unsigned line, const char *function, const char *string)
66 {
67 struct log_callback *cb, *next;
68 cb = log_callbacks;
69 /* DANGER!!!! the log callback can remove itself!!!! */
70 while (cb) {
71 next = cb->next;
72 cb->fn(cb->priv, file, line, function, string);
73 cb = next;
74 }
75 }
76
77 /* The log_puts() serves two somewhat different goals:
78 *
79 * - logging
80 * - feeding low-level info to the user in GDB or Telnet
81 *
82 * The latter dictates that strings without newline are not logged, lest there
83 * will be *MANY log lines when sending one char at the time(e.g.
84 * target_request.c).
85 *
86 */
87 static void log_puts(enum log_levels level,
88 const char *file,
89 int line,
90 const char *function,
91 const char *string)
92 {
93 char *f;
94 if (level == LOG_LVL_OUTPUT) {
95 /* do not prepend any headers, just print out what we were given and return */
96 fputs(string, log_output);
97 fflush(log_output);
98 return;
99 }
100
101 f = strrchr(file, '/');
102 if (f != NULL)
103 file = f + 1;
104
105 if (strlen(string) > 0) {
106 if (debug_level >= LOG_LVL_DEBUG) {
107 /* print with count and time information */
108 int64_t t = timeval_ms() - start;
109 #ifdef _DEBUG_FREE_SPACE_
110 struct mallinfo info;
111 info = mallinfo();
112 #endif
113 fprintf(log_output, "%s%d %" PRId64 " %s:%d %s()"
114 #ifdef _DEBUG_FREE_SPACE_
115 " %d"
116 #endif
117 ": %s", log_strings[level + 1], count, t, file, line, function,
118 #ifdef _DEBUG_FREE_SPACE_
119 info.fordblks,
120 #endif
121 string);
122 } else {
123 /* if we are using gdb through pipes then we do not want any output
124 * to the pipe otherwise we get repeated strings */
125 fprintf(log_output, "%s%s",
126 (level > LOG_LVL_USER) ? log_strings[level + 1] : "", string);
127 }
128 } else {
129 /* Empty strings are sent to log callbacks to keep e.g. gdbserver alive, here we do
130 *nothing. */
131 }
132
133 fflush(log_output);
134
135 /* Never forward LOG_LVL_DEBUG, too verbose and they can be found in the log if need be */
136 if (level <= LOG_LVL_INFO)
137 log_forward(file, line, function, string);
138 }
139
140 void log_printf(enum log_levels level,
141 const char *file,
142 unsigned line,
143 const char *function,
144 const char *format,
145 ...)
146 {
147 char *string;
148 va_list ap;
149
150 count++;
151 if (level > debug_level)
152 return;
153
154 va_start(ap, format);
155
156 string = alloc_vprintf(format, ap);
157 if (string != NULL) {
158 log_puts(level, file, line, function, string);
159 free(string);
160 }
161
162 va_end(ap);
163 }
164
165 void log_vprintf_lf(enum log_levels level, const char *file, unsigned line,
166 const char *function, const char *format, va_list args)
167 {
168 char *tmp;
169
170 count++;
171
172 if (level > debug_level)
173 return;
174
175 tmp = alloc_vprintf(format, args);
176
177 if (!tmp)
178 return;
179
180 /*
181 * Note: alloc_vprintf() guarantees that the buffer is at least one
182 * character longer.
183 */
184 strcat(tmp, "\n");
185 log_puts(level, file, line, function, tmp);
186 free(tmp);
187 }
188
189 void log_printf_lf(enum log_levels level,
190 const char *file,
191 unsigned line,
192 const char *function,
193 const char *format,
194 ...)
195 {
196 va_list ap;
197
198 va_start(ap, format);
199 log_vprintf_lf(level, file, line, function, format, ap);
200 va_end(ap);
201 }
202
203 COMMAND_HANDLER(handle_debug_level_command)
204 {
205 if (CMD_ARGC == 1) {
206 int new_level;
207 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], new_level);
208 if ((new_level > LOG_LVL_DEBUG_IO) || (new_level < LOG_LVL_SILENT)) {
209 LOG_ERROR("level must be between %d and %d", LOG_LVL_SILENT, LOG_LVL_DEBUG_IO);
210 return ERROR_COMMAND_SYNTAX_ERROR;
211 }
212 debug_level = new_level;
213 } else if (CMD_ARGC > 1)
214 return ERROR_COMMAND_SYNTAX_ERROR;
215
216 command_print(CMD_CTX, "debug_level: %i", debug_level);
217
218 return ERROR_OK;
219 }
220
221 COMMAND_HANDLER(handle_log_output_command)
222 {
223 if (CMD_ARGC == 1) {
224 FILE *file = fopen(CMD_ARGV[0], "w");
225 if (file == NULL) {
226 LOG_ERROR("failed to open output log '%s'", CMD_ARGV[0]);
227 return ERROR_FAIL;
228 }
229 if (log_output != stderr && log_output != NULL) {
230 /* Close previous log file, if it was open and wasn't stderr. */
231 fclose(log_output);
232 }
233 log_output = file;
234 }
235
236 return ERROR_OK;
237 }
238
239 static struct command_registration log_command_handlers[] = {
240 {
241 .name = "log_output",
242 .handler = handle_log_output_command,
243 .mode = COMMAND_ANY,
244 .help = "redirect logging to a file (default: stderr)",
245 .usage = "file_name",
246 },
247 {
248 .name = "debug_level",
249 .handler = handle_debug_level_command,
250 .mode = COMMAND_ANY,
251 .help = "Sets the verbosity level of debugging output. "
252 "0 shows errors only; 1 adds warnings; "
253 "2 (default) adds other info; 3 adds debugging; "
254 "4 adds extra verbose debugging.",
255 .usage = "number",
256 },
257 COMMAND_REGISTRATION_DONE
258 };
259
260 int log_register_commands(struct command_context *cmd_ctx)
261 {
262 return register_commands(cmd_ctx, NULL, log_command_handlers);
263 }
264
265 void log_init(void)
266 {
267 /* set defaults for daemon configuration,
268 * if not set by cmdline or cfgfile */
269 if (debug_level == -1)
270 debug_level = LOG_LVL_INFO;
271
272 char *debug_env = getenv("OPENOCD_DEBUG_LEVEL");
273 if (NULL != debug_env) {
274 int value;
275 int retval = parse_int(debug_env, &value);
276 if (ERROR_OK == retval &&
277 debug_level >= LOG_LVL_SILENT &&
278 debug_level <= LOG_LVL_DEBUG_IO)
279 debug_level = value;
280 }
281
282 if (log_output == NULL)
283 log_output = stderr;
284
285 start = last_time = timeval_ms();
286 }
287
288 int set_log_output(struct command_context *cmd_ctx, FILE *output)
289 {
290 log_output = output;
291 return ERROR_OK;
292 }
293
294 /* add/remove log callback handler */
295 int log_add_callback(log_callback_fn fn, void *priv)
296 {
297 struct log_callback *cb;
298
299 /* prevent the same callback to be registered more than once, just for sure */
300 for (cb = log_callbacks; cb; cb = cb->next) {
301 if (cb->fn == fn && cb->priv == priv)
302 return ERROR_COMMAND_SYNTAX_ERROR;
303 }
304
305 /* alloc memory, it is safe just to return in case of an error, no need for the caller to
306 *check this */
307 cb = malloc(sizeof(struct log_callback));
308 if (cb == NULL)
309 return ERROR_BUF_TOO_SMALL;
310
311 /* add item to the beginning of the linked list */
312 cb->fn = fn;
313 cb->priv = priv;
314 cb->next = log_callbacks;
315 log_callbacks = cb;
316
317 return ERROR_OK;
318 }
319
320 int log_remove_callback(log_callback_fn fn, void *priv)
321 {
322 struct log_callback *cb, **p;
323
324 for (p = &log_callbacks; (cb = *p); p = &(*p)->next) {
325 if (cb->fn == fn && cb->priv == priv) {
326 *p = cb->next;
327 free(cb);
328 return ERROR_OK;
329 }
330 }
331
332 /* no such item */
333 return ERROR_COMMAND_SYNTAX_ERROR;
334 }
335
336 /* return allocated string w/printf() result */
337 char *alloc_vprintf(const char *fmt, va_list ap)
338 {
339 va_list ap_copy;
340 int len;
341 char *string;
342
343 /* determine the length of the buffer needed */
344 va_copy(ap_copy, ap);
345 len = vsnprintf(NULL, 0, fmt, ap_copy);
346 va_end(ap_copy);
347
348 /* allocate and make room for terminating zero. */
349 /* FIXME: The old version always allocated at least one byte extra and
350 * other code depend on that. They should be probably be fixed, but for
351 * now reserve the extra byte. */
352 string = malloc(len + 2);
353 if (string == NULL)
354 return NULL;
355
356 /* do the real work */
357 vsnprintf(string, len + 1, fmt, ap);
358
359 return string;
360 }
361
362 char *alloc_printf(const char *format, ...)
363 {
364 char *string;
365 va_list ap;
366 va_start(ap, format);
367 string = alloc_vprintf(format, ap);
368 va_end(ap);
369 return string;
370 }
371
372 /* Code must return to the server loop before 1000ms has returned or invoke
373 * this function.
374 *
375 * The GDB connection will time out if it spends >2000ms and you'll get nasty
376 * error messages from GDB:
377 *
378 * Ignoring packet error, continuing...
379 * Reply contains invalid hex digit 116
380 *
381 * While it is possible use "set remotetimeout" to more than the default 2000ms
382 * in GDB, OpenOCD guarantees that it sends keep-alive packages on the
383 * GDB protocol and it is a bug in OpenOCD not to either return to the server
384 * loop or invoke keep_alive() every 1000ms.
385 *
386 * This function will send a keep alive packet if >500ms has passed since last time
387 * it was invoked.
388 *
389 * Note that this function can be invoked often, so it needs to be relatively
390 * fast when invoked more often than every 500ms.
391 *
392 */
393 void keep_alive()
394 {
395 current_time = timeval_ms();
396 if (current_time-last_time > 1000) {
397 extern int gdb_actual_connections;
398
399 if (gdb_actual_connections)
400 LOG_WARNING("keep_alive() was not invoked in the "
401 "1000ms timelimit. GDB alive packet not "
402 "sent! (%" PRId64 "). Workaround: increase "
403 "\"set remotetimeout\" in GDB",
404 current_time-last_time);
405 else
406 LOG_DEBUG("keep_alive() was not invoked in the "
407 "1000ms timelimit (%" PRId64 "). This may cause "
408 "trouble with GDB connections.",
409 current_time-last_time);
410 }
411 if (current_time-last_time > 500) {
412 /* this will keep the GDB connection alive */
413 LOG_USER_N("%s", "");
414
415 /* DANGER!!!! do not add code to invoke e.g. target event processing,
416 * jim timer processing, etc. it can cause infinite recursion +
417 * jim event callbacks need to happen at a well defined time,
418 * not anywhere keep_alive() is invoked.
419 *
420 * These functions should be invoked at a well defined spot in server.c
421 */
422
423 last_time = current_time;
424 }
425 }
426
427 /* reset keep alive timer without sending message */
428 void kept_alive()
429 {
430 current_time = timeval_ms();
431 last_time = current_time;
432 }
433
434 /* if we sleep for extended periods of time, we must invoke keep_alive() intermittantly */
435 void alive_sleep(uint64_t ms)
436 {
437 uint64_t napTime = 10;
438 for (uint64_t i = 0; i < ms; i += napTime) {
439 uint64_t sleep_a_bit = ms - i;
440 if (sleep_a_bit > napTime)
441 sleep_a_bit = napTime;
442
443 usleep(sleep_a_bit * 1000);
444 keep_alive();
445 }
446 }
447
448 void busy_sleep(uint64_t ms)
449 {
450 uint64_t then = timeval_ms();
451 while (timeval_ms() - then < ms) {
452 /*
453 * busy wait
454 */
455 }
456 }

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)