target-i386: fix pcmpxstrx equal-ordered (strstr) mode

[qemu.git] / scripts / simpletrace.py

diff --git a/scripts/simpletrace.py b/scripts/simpletrace.py
index 553a72709f99901b409085dd8ea5581985024405..3916c6d14ae80532cbc5e67d5cc29e9d115fa7c5 100755 (executable)
--- a/scripts/simpletrace.py
+++ b/scripts/simpletrace.py
@@ -9,85 +9,187 @@
 #
 # For help see docs/tracing.txt
 
 #
 # For help see docs/tracing.txt
 

-import sys

 import struct
 import re
 import struct
 import re

+import inspect
+from tracetool import _read_events, Event
+from tracetool.backend.simple import is_string

 
 header_event_id = 0xffffffffffffffff
 header_magic    = 0xf2b177cb0aa429b4
 
 header_event_id = 0xffffffffffffffff
 header_magic    = 0xf2b177cb0aa429b4

-header_version  = 0
-
-trace_fmt = '=QQQQQQQQ'
-trace_len = struct.calcsize(trace_fmt)
-event_re  = re.compile(r'(disable\s+)?([a-zA-Z0-9_]+)\(([^)]*)\).*')
-
-def err(msg):
-    sys.stderr.write(msg + '\n')
-    sys.exit(1)
-
-def parse_events(fobj):
-    """Parse a trace-events file."""
-
-    def get_argnames(args):
-        """Extract argument names from a parameter list."""
-        return tuple(arg.split()[-1].lstrip('*') for arg in args.split(','))
-
-    events = {}
-    event_num = 0
-    for line in fobj:
-        m = event_re.match(line.strip())
-        if m is None:
-            continue
-
-        disable, name, args = m.groups()
-        events[event_num] = (name,) + get_argnames(args)
-        event_num += 1
-    return events
-
-def read_record(fobj):
-    """Deserialize a trace record from a file."""
-    s = fobj.read(trace_len)
-    if len(s) != trace_len:
+dropped_event_id = 0xfffffffffffffffe
+
+log_header_fmt = '=QQQ'
+rec_header_fmt = '=QQII'
+
+def read_header(fobj, hfmt):
+    '''Read a trace record header'''
+    hlen = struct.calcsize(hfmt)
+    hdr = fobj.read(hlen)
+    if len(hdr) != hlen:

         return None
         return None

-    return struct.unpack(trace_fmt, s)
+    return struct.unpack(hfmt, hdr)

 
 

-def read_trace_file(fobj):
-    """Deserialize trace records from a file."""
-    header = read_record(fobj)
+def get_record(edict, rechdr, fobj):
+    """Deserialize a trace record from a file into a tuple (event_num, timestamp, pid, arg1, ..., arg6)."""
+    if rechdr is None:
+        return None
+    rec = (rechdr[0], rechdr[1], rechdr[3])
+    if rechdr[0] != dropped_event_id:
+        event_id = rechdr[0]
+        event = edict[event_id]
+        for type, name in event.args:
+            if is_string(type):
+                l = fobj.read(4)
+                (len,) = struct.unpack('=L', l)
+                s = fobj.read(len)
+                rec = rec + (s,)
+            else:
+                (value,) = struct.unpack('=Q', fobj.read(8))
+                rec = rec + (value,)
+    else:
+        (value,) = struct.unpack('=Q', fobj.read(8))
+        rec = rec + (value,)
+    return rec
+
+
+def read_record(edict, fobj):
+    """Deserialize a trace record from a file into a tuple (event_num, timestamp, pid, arg1, ..., arg6)."""
+    rechdr = read_header(fobj, rec_header_fmt)
+    return get_record(edict, rechdr, fobj) # return tuple of record elements
+
+def read_trace_header(fobj):
+    """Read and verify trace file header"""
+    header = read_header(fobj, log_header_fmt)

     if header is None or \
        header[0] != header_event_id or \
     if header is None or \
        header[0] != header_event_id or \

-       header[1] != header_magic or \
-       header[2] != header_version:
-        err('not a trace file or incompatible version')
-
+       header[1] != header_magic:
+        raise ValueError('Not a valid trace file!')
+
+    log_version = header[2]
+    if log_version not in [0, 2, 3]:
+        raise ValueError('Unknown version of tracelog format!')
+    if log_version != 3:
+        raise ValueError('Log format %d not supported with this QEMU release!'
+                         % log_version)
+
+def read_trace_records(edict, fobj):
+    """Deserialize trace records from a file, yielding record tuples (event_num, timestamp, pid, arg1, ..., arg6)."""

     while True:
     while True:

-        rec = read_record(fobj)
+        rec = read_record(edict, fobj)

         if rec is None:
             break
 
         yield rec
 
         if rec is None:
             break
 
         yield rec
 

-class Formatter(object):
-    def __init__(self, events):
-        self.events = events
-        self.last_timestamp = None
-
-    def format_record(self, rec):
-        if self.last_timestamp is None:
-            self.last_timestamp = rec[1]
-        delta_ns = rec[1] - self.last_timestamp
-        self.last_timestamp = rec[1]
-
-        event = self.events[rec[0]]
-        fields = [event[0], '%0.3f' % (delta_ns / 1000.0)]
-        for i in xrange(1, len(event)):
-            fields.append('%s=0x%x' % (event[i], rec[i + 1]))
-        return ' '.join(fields)
-
-if len(sys.argv) != 3:
-    err('usage: %s <trace-events> <trace-file>' % sys.argv[0])
-
-events = parse_events(open(sys.argv[1], 'r'))
-formatter = Formatter(events)
-for rec in read_trace_file(open(sys.argv[2], 'rb')):
-    print formatter.format_record(rec)
+class Analyzer(object):
+    """A trace file analyzer which processes trace records.
+
+    An analyzer can be passed to run() or process().  The begin() method is
+    invoked, then each trace record is processed, and finally the end() method
+    is invoked.
+
+    If a method matching a trace event name exists, it is invoked to process
+    that trace record.  Otherwise the catchall() method is invoked."""
+
+    def begin(self):
+        """Called at the start of the trace."""
+        pass
+
+    def catchall(self, event, rec):
+        """Called if no specific method for processing a trace event has been found."""
+        pass
+
+    def end(self):
+        """Called at the end of the trace."""
+        pass
+
+def process(events, log, analyzer, read_header=True):
+    """Invoke an analyzer on each event in a log."""
+    if isinstance(events, str):
+        events = _read_events(open(events, 'r'))
+    if isinstance(log, str):
+        log = open(log, 'rb')
+
+    if read_header:
+        read_trace_header(log)
+
+    dropped_event = Event.build("Dropped_Event(uint64_t num_events_dropped)")
+    edict = {dropped_event_id: dropped_event}
+
+    for num, event in enumerate(events):
+        edict[num] = event
+
+    def build_fn(analyzer, event):
+        if isinstance(event, str):
+            return analyzer.catchall
+
+        fn = getattr(analyzer, event.name, None)
+        if fn is None:
+            return analyzer.catchall
+
+        event_argcount = len(event.args)
+        fn_argcount = len(inspect.getargspec(fn)[0]) - 1
+        if fn_argcount == event_argcount + 1:
+            # Include timestamp as first argument
+            return lambda _, rec: fn(*((rec[1:2],) + rec[3:3 + event_argcount]))
+        elif fn_argcount == event_argcount + 2:
+            # Include timestamp and pid
+            return lambda _, rec: fn(*rec[1:3 + event_argcount])
+        else:
+            # Just arguments, no timestamp or pid
+            return lambda _, rec: fn(*rec[3:3 + event_argcount])
+
+    analyzer.begin()
+    fn_cache = {}
+    for rec in read_trace_records(edict, log):
+        event_num = rec[0]
+        event = edict[event_num]
+        if event_num not in fn_cache:
+            fn_cache[event_num] = build_fn(analyzer, event)
+        fn_cache[event_num](event, rec)
+    analyzer.end()
+
+def run(analyzer):
+    """Execute an analyzer on a trace file given on the command-line.
+
+    This function is useful as a driver for simple analysis scripts.  More
+    advanced scripts will want to call process() instead."""
+    import sys
+
+    read_header = True
+    if len(sys.argv) == 4 and sys.argv[1] == '--no-header':
+        read_header = False
+        del sys.argv[1]
+    elif len(sys.argv) != 3:
+        sys.stderr.write('usage: %s [--no-header] <trace-events> ' \
+                         '<trace-file>\n' % sys.argv[0])
+        sys.exit(1)
+
+    events = _read_events(open(sys.argv[1], 'r'))
+    process(events, sys.argv[2], analyzer, read_header=read_header)
+
+if __name__ == '__main__':
+    class Formatter(Analyzer):
+        def __init__(self):
+            self.last_timestamp = None
+
+        def catchall(self, event, rec):
+            timestamp = rec[1]
+            if self.last_timestamp is None:
+                self.last_timestamp = timestamp
+            delta_ns = timestamp - self.last_timestamp
+            self.last_timestamp = timestamp
+
+            fields = [event.name, '%0.3f' % (delta_ns / 1000.0),
+                      'pid=%d' % rec[2]]
+            i = 3
+            for type, name in event.args:
+                if is_string(type):
+                    fields.append('%s=%s' % (name, rec[i]))
+                else:
+                    fields.append('%s=0x%x' % (name, rec[i]))
+                i += 1
+            print ' '.join(fields)
+
+    run(Formatter())