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

     esac
     echo "TRACE_BACKEND=$trace_backend" >> $config_host_mak
     if test "$trace_backend" = "simple"; then
       echo "CONFIG_SIMPLE_TRACE=y" >> $config_host_mak
     fi
     echo "TOOLS=$tools" >> $config_host_mak
     echo "ROMS=$roms" >> $config_host_mak
     echo "MAKE=$make" >> $config_host_mak

     #include "json-parser.h"
     #include "osdep.h"
     #include "exec-all.h"
     #ifdef CONFIG_SIMPLE_TRACE
     #include "trace.h"
     #endif
     //#define DEBUG
     //#define DEBUG_COMPLETION
-...
         help_cmd(mon, qdict_get_try_str(qdict, "name"));
+    }
     #ifdef CONFIG_SIMPLE_TRACE
     static void do_change_trace_event_state(Monitor *mon, const QDict *qdict)
+    {
         const char *tp_name = qdict_get_str(qdict, "name");
         bool new_state = qdict_get_bool(qdict, "option");
         st_change_trace_event_state(tp_name, new_state);
+    }
     #endif
     static void user_monitor_complete(void *opaque, QObject *ret_data)
+    {
         MonitorCompletionData *data = (MonitorCompletionData *)opaque;
-...
+    }
     #endif
     #if defined(CONFIG_SIMPLE_TRACE)
     static void do_info_trace(Monitor *mon)
+    {
         st_print_trace((FILE *)mon, &monitor_fprintf);
+    }
     static void do_info_trace_events(Monitor *mon)
+    {
         st_print_trace_events((FILE *)mon, &monitor_fprintf);
+    }
     #endif
     /**
      * do_quit(): Quit QEMU execution
      */
-...
             .help       = "show roms",
             .mhandler.info = do_info_roms,
         },
     #if defined(CONFIG_SIMPLE_TRACE)
+        {
             .name       = "trace",
             .args_type  = "",
             .params     = "",
             .help       = "show current contents of trace buffer",
             .mhandler.info = do_info_trace,
         },
+        {
             .name       = "trace-events",
             .args_type  = "",
             .params     = "",
             .help       = "show available trace-events & their state",
             .mhandler.info = do_info_trace_events,
         },
     #endif
+        {
             .name       = NULL,
         },

     Output logs to @var{filename}.
     ETEXI
     #ifdef CONFIG_SIMPLE_TRACE
+        {
             .name       = "trace-event",
             .args_type  = "name:s,option:b",
             .params     = "name on|off",
             .help       = "changes status of a specific trace event",
             .mhandler.cmd = do_change_trace_event_state,
         },
     STEXI
     @item trace-event
     @findex trace-event
     changes status of a trace event
     ETEXI
     #endif
+        {
             .name       = "log",
             .args_type  = "items:s",
-...
     @end table
     ETEXI
     #ifdef CONFIG_SIMPLE_TRACE
     STEXI
     @item info trace
     show contents of trace buffer
     @item info trace-events
     show available trace events and their state
     ETEXI
     #endif
     HXCOMM DO NOT add new commands after 'info', move your addition before it!
     STEXI

          */
         clock_gettime(CLOCK_MONOTONIC, &ts);
         if (!trace_list[event].state) {
             return;
+        }
         rec->event = event;
         rec->timestamp_ns = ts.tv_sec * 1000000000LL + ts.tv_nsec;
         rec->x1 = x1;
-...
+    {
         atexit(st_flush_trace_buffer);
+    }
     void st_print_trace(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...))
+    {
         unsigned int i;
         for (i = 0; i < trace_idx; i++) {
             stream_printf(stream, "Event %lu : %lx %lx %lx %lx %lx\n",
                           trace_buf[i].event, trace_buf[i].x1, trace_buf[i].x2,
                           trace_buf[i].x3, trace_buf[i].x4, trace_buf[i].x5);
+        }
+    }
     void st_print_trace_events(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...))
+    {
         unsigned int i;
         for (i = 0; i < NR_TRACE_EVENTS; i++) {
             stream_printf(stream, "%s [Event ID %u] : state %u\n",
                           trace_list[i].tp_name, i, trace_list[i].state);
+        }
+    }
     static TraceEvent* find_trace_event_by_name(const char *tname)
+    {
         unsigned int i;
         if (!tname) {
             return NULL;
+        }
         for (i = 0; i < NR_TRACE_EVENTS; i++) {
             if (!strcmp(trace_list[i].tp_name, tname)) {
                 return &trace_list[i];
+            }
+        }
         return NULL; /* indicates end of list reached without a match */
+    }
     void st_change_trace_event_state(const char *tname, bool tstate)
+    {
         TraceEvent *tp;
         tp = find_trace_event_by_name(tname);
         if (tp) {
             tp->state = tstate;
+        }
+    }

     #define SIMPLETRACE_H
     #include <stdint.h>
     #include <stdbool.h>
     #include <stdio.h>
     typedef uint64_t TraceEventID;
     typedef struct {
         const char *tp_name;
         bool state;
     } TraceEvent;
     void trace0(TraceEventID event);
     void trace1(TraceEventID event, uint64_t x1);
     void trace2(TraceEventID event, uint64_t x1, uint64_t x2);
-...
     void trace4(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4);
     void trace5(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4, uint64_t x5);
     void trace6(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4, uint64_t x5, uint64_t x6);
     void st_print_trace(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...));
     void st_print_trace_events(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...));
     void st_change_trace_event_state(const char *tname, bool tstate);
     #endif /* SIMPLETRACE_H */

b/tracetool
169	169
170	170	linetoh_end_simple()
171	171	{
172		return
	172	cat <<EOF
	173	#define NR_TRACE_EVENTS $simple_event_num
	174	extern TraceEvent trace_list[NR_TRACE_EVENTS];
	175	EOF
173	176	}
174	177
175	178	linetoc_begin_simple()
176	179	{
177		return
	180	cat <<EOF
	181	#include "trace.h"
	182
	183	TraceEvent trace_list[] = {
	184	EOF
	185	simple_event_num=0
	186
178	187	}
179	188
180	189	linetoc_simple()
181	190	{
182		return
	191	local name
	192	name=$(get_name "$1")
	193	cat <<EOF
	194	{.tp_name = "$name", .state=0},
	195	EOF
	196	simple_event_num=$((simple_event_num + 1))
183	197	}
184	198
185	199	linetoc_end_simple()
186	200	{
187		return
	201	cat <<EOF
	202	};
	203	EOF
188	204	}
189	205
190	206	# Process stdin by calling begin, line, and end functions for the backend

Archipelago » qemu

Revision 22890ab5