/ - Diff - qemu - Greek Research and Technology Network's projects

     trace-nested-$(CONFIG_TRACE_SIMPLE) += simple.o
     trace-obj-$(CONFIG_TRACE_SIMPLE) += qemu-timer-common.o
     trace-nested-y += control.o
     trace-obj-y += $(addprefix trace/, $(trace-nested-y))
     ######################################################################

     * trace-event NAME on|off
       Enable/disable a given trace event.
     The "-trace events=<file>" command line argument can be used to enable the
     events listed in <file> from the very beginning of the program. This file must
     contain one event name per line.
     == Trace backends ==
     The "tracetool" script automates tedious trace event code generation and also

         .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head),
         .desc = {
+            {
                 .name = "events",
                 .type = QEMU_OPT_STRING,
             },{
                 .name = "file",
                 .type = QEMU_OPT_STRING,
             },

     option will prevent QEMU from loading these configuration files at startup.
     ETEXI
     DEF("trace", HAS_ARG, QEMU_OPTION_trace,
         "-trace\n"
         "                Specify a trace file to log traces to\n",
         "-trace [events=<file>][,file=<file>]\n"
         "                specify tracing options\n",
         QEMU_ARCH_ALL)
     STEXI
     HXCOMM This line is not accurate, as the option is backend-specific but HX does
     HXCOMM not support conditional compilation of text.
     @item -trace
     HXCOMM This line is not accurate, as some sub-options are backend-specific but
     HXCOMM HX does not support conditional compilation of text.
     @item -trace [events=@var{file}][,file=@var{file}]
     @findex -trace
     Specify a trace file to log output traces to.
     This option is available only when using the @var{simple} tracing backend.
     Specify tracing options.
     @table @option
     @item events=@var{file}
     Immediately enable events listed in @var{file}.
     The file must contain one event name (as listed in the @var{trace-events} file)
     per line.
     This option is only available when using the @var{simple} tracing backend.
     @item file=@var{file}
     Log output traces to @var{file}.
     This option is only available when using the @var{simple} tracing backend.
     @end table
     ETEXI
     HXCOMM This is the last statement. Insert new options before this line!

     /*
      * Interface for configuring and controlling the state of tracing events.
+     *
      * Copyright (C) 2011 Lluís Vilanova <vilanova@ac.upc.edu>
+     *
      * This work is licensed under the terms of the GNU GPL, version 2.  See
      * the COPYING file in the top-level directory.
      */
     #include "trace/control.h"
     void trace_backend_init_events(const char *fname)
+    {
         if (fname == NULL) {
             return;
+        }
         FILE *fp = fopen(fname, "r");
         if (!fp) {
             fprintf(stderr, "error: could not open trace events file '%s': %s\n",
                     fname, strerror(errno));
             exit(1);
+        }
         char line_buf[1024];
         while (fgets(line_buf, sizeof(line_buf), fp)) {
             size_t len = strlen(line_buf);
             if (len > 1) {              /* skip empty lines */
                 line_buf[len - 1] = '\0';
                 if (!trace_event_set_state(line_buf, true)) {
                     fprintf(stderr,
                             "error: trace event '%s' does not exist\n", line_buf);
                     exit(1);
+                }
+            }
+        }
         if (fclose(fp) != 0) {
             fprintf(stderr, "error: closing file '%s': %s\n",
                     fname, strerror(errno));
             exit(1);
+        }
+    }

     /** Initialize the tracing backend.
+     *
      * @file Name of trace output file; may be NULL.
      *       Corresponds to commandline option "-trace file=...".
      * @events Name of file with events to be enabled at startup; may be NULL.
      *         Corresponds to commandline option "-trace events=...".
      * @file   Name of trace output file; may be NULL.
      *         Corresponds to commandline option "-trace file=...".
      * @return Whether the backend could be successfully initialized.
      */
     bool trace_backend_init(const char *file);
     bool trace_backend_init(const char *events, const char *file);
     /** Generic function to initialize the state of events.
+     *
      * @fname Name of file with events to enable; may be NULL.
      */
     void trace_backend_init_events(const char *fname);
     #endif  /* TRACE_CONTROL_H */

         return false;
+    }
     bool trace_backend_init(const char *file)
     bool trace_backend_init(const char *events, const char *file)
+    {
         if (events) {
             fprintf(stderr, "error: -trace events=...: "
                     "option not supported by the selected tracing backend\n");
             return false;
+        }
         if (file) {
             fprintf(stderr, "error: -trace file=...: "
                     "option not supported by the selected tracing backend\n");

b/trace/simple.c
331	331	return false;
332	332	}
333	333
334		bool trace_backend_init(const char *file)
	334	bool trace_backend_init(const char events, const char file)
335	335	{
336	336	pthread_t thread;
337	337	pthread_attr_t attr;
...	...
350	350	fprintf(stderr, "warning: unable to initialize simple trace backend\n");
351	351	} else {
352	352	atexit(st_flush_trace_buffer);
	353	trace_backend_init_events(events);
353	354	st_set_trace_file(file);
354	355	}
355	356

             .realloc = realloc_and_trace,
             .free = free_and_trace,
         };
         const char *trace_events = NULL;
         const char *trace_file = NULL;
         atexit(qemu_run_exit_notifiers);
-...
                     if (!opts) {
                         exit(1);
+                    }
                     trace_events = qemu_opt_get(opts, "events");
                     trace_file = qemu_opt_get(opts, "file");
                     break;
+                }
-...
             set_cpu_log(log_mask);
+        }
         if (!trace_backend_init(trace_file)) {
         if (!trace_backend_init(trace_events, trace_file)) {
             exit(1);
+        }

Archipelago » qemu