[qemu.git] / scripts / replay-dump.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Dump the contents of a recorded execution stream
#
#  Copyright (c) 2017 Alex BennÃ©e <[email protected]>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, see <http://www.gnu.org/licenses/>.

from __future__ import print_function
import argparse
import struct
from collections import namedtuple

# This mirrors some of the global replay state which some of the
# stream loading refers to. Some decoders may read the next event so
# we need handle that case. Calling reuse_event will ensure the next
# event is read from the cache rather than advancing the file.

class ReplayState(object):
    def __init__(self):
        self.event = -1
        self.event_count = 0
        self.already_read = False
        self.current_checkpoint = 0
        self.checkpoint = 0

    def set_event(self, ev):
        self.event = ev
        self.event_count += 1

    def get_event(self):
        self.already_read = False
        return self.event

    def reuse_event(self, ev):
        self.event = ev
        self.already_read = True

    def set_checkpoint(self):
        self.checkpoint = self.event - self.checkpoint_start

    def get_checkpoint(self):
        return self.checkpoint

replay_state = ReplayState()

# Simple read functions that mirror replay-internal.c
# The file-stream is big-endian and manually written out a byte at a time.

def read_byte(fin):
    "Read a single byte"
    return struct.unpack('>B', fin.read(1))[0]

def read_event(fin):
    "Read a single byte event, but save some state"
    if replay_state.already_read:
        return replay_state.get_event()
    else:
        replay_state.set_event(read_byte(fin))
        return replay_state.event

def read_word(fin):
    "Read a 16 bit word"
    return struct.unpack('>H', fin.read(2))[0]

def read_dword(fin):
    "Read a 32 bit word"
    return struct.unpack('>I', fin.read(4))[0]

def read_qword(fin):
    "Read a 64 bit word"
    return struct.unpack('>Q', fin.read(8))[0]

# Generic decoder structure
Decoder = namedtuple("Decoder", "eid name fn")

def call_decode(table, index, dumpfile):
    "Search decode table for next step"
    decoder = next((d for d in table if d.eid == index), None)
    if not decoder:
        print("Could not decode index: %d" % (index))
        print("Entry is: %s" % (decoder))
        print("Decode Table is:\n%s" % (table))
        return False
    else:
        return decoder.fn(decoder.eid, decoder.name, dumpfile)

# Print event
def print_event(eid, name, string=None, event_count=None):
    "Print event with count"
    if not event_count:
        event_count = replay_state.event_count

    if string:
        print("%d:%s(%d) %s" % (event_count, name, eid, string))
    else:
        print("%d:%s(%d)" % (event_count, name, eid))


# Decoders for each event type

def decode_unimp(eid, name, _unused_dumpfile):
    "Unimplimented decoder, will trigger exit"
    print("%s not handled - will now stop" % (name))
    return False

# Checkpoint decoder
def swallow_async_qword(eid, name, dumpfile):
    "Swallow a qword of data without looking at it"
    step_id = read_qword(dumpfile)
    print("  %s(%d) @ %d" % (name, eid, step_id))
    return True

async_decode_table = [ Decoder(0, "REPLAY_ASYNC_EVENT_BH", swallow_async_qword),
                       Decoder(1, "REPLAY_ASYNC_INPUT", decode_unimp),
                       Decoder(2, "REPLAY_ASYNC_INPUT_SYNC", decode_unimp),
                       Decoder(3, "REPLAY_ASYNC_CHAR_READ", decode_unimp),
                       Decoder(4, "REPLAY_ASYNC_EVENT_BLOCK", decode_unimp),
                       Decoder(5, "REPLAY_ASYNC_EVENT_NET", decode_unimp),
]
# See replay_read_events/replay_read_event
def decode_async(eid, name, dumpfile):
    """Decode an ASYNC event"""

    print_event(eid, name)

    async_event_kind = read_byte(dumpfile)
    async_event_checkpoint = read_byte(dumpfile)

    if async_event_checkpoint != replay_state.current_checkpoint:
        print("  mismatch between checkpoint %d and async data %d" % (
            replay_state.current_checkpoint, async_event_checkpoint))
        return True

    return call_decode(async_decode_table, async_event_kind, dumpfile)


def decode_instruction(eid, name, dumpfile):
    ins_diff = read_dword(dumpfile)
    print_event(eid, name, "0x%x" % (ins_diff))
    return True

def decode_audio_out(eid, name, dumpfile):
    audio_data = read_dword(dumpfile)
    print_event(eid, name, "%d" % (audio_data))
    return True

def decode_checkpoint(eid, name, dumpfile):
    """Decode a checkpoint.

    Checkpoints contain a series of async events with their own specific data.
    """
    replay_state.set_checkpoint()
    # save event count as we peek ahead
    event_number = replay_state.event_count
    next_event = read_event(dumpfile)

    # if the next event is EVENT_ASYNC there are a bunch of
    # async events to read, otherwise we are done
    if next_event != 3:
        print_event(eid, name, "no additional data", event_number)
    else:
        print_event(eid, name, "more data follows", event_number)

    replay_state.reuse_event(next_event)
    return True

def decode_checkpoint_init(eid, name, dumpfile):
    print_event(eid, name)
    return True

def decode_interrupt(eid, name, dumpfile):
    print_event(eid, name)
    return True

def decode_clock(eid, name, dumpfile):
    clock_data = read_qword(dumpfile)
    print_event(eid, name, "0x%x" % (clock_data))
    return True


# pre-MTTCG merge
v5_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
                  Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
                  Decoder(2, "EVENT_EXCEPTION", decode_unimp),
                  Decoder(3, "EVENT_ASYNC", decode_async),
                  Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
                  Decoder(5, "EVENT_CHAR_WRITE", decode_unimp),
                  Decoder(6, "EVENT_CHAR_READ_ALL", decode_unimp),
                  Decoder(7, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
                  Decoder(8, "EVENT_CLOCK_HOST", decode_clock),
                  Decoder(9, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
                  Decoder(10, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
                  Decoder(11, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
                  Decoder(12, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
                  Decoder(13, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
                  Decoder(14, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
                  Decoder(15, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
                  Decoder(16, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
                  Decoder(17, "EVENT_CP_INIT", decode_checkpoint_init),
                  Decoder(18, "EVENT_CP_RESET", decode_checkpoint),
]

# post-MTTCG merge, AUDIO support added
v6_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
                  Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
                  Decoder(2, "EVENT_EXCEPTION", decode_unimp),
                  Decoder(3, "EVENT_ASYNC", decode_async),
                  Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
                  Decoder(5, "EVENT_CHAR_WRITE", decode_unimp),
                  Decoder(6, "EVENT_CHAR_READ_ALL", decode_unimp),
                  Decoder(7, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
                  Decoder(8, "EVENT_AUDIO_OUT", decode_audio_out),
                  Decoder(9, "EVENT_AUDIO_IN", decode_unimp),
                  Decoder(10, "EVENT_CLOCK_HOST", decode_clock),
                  Decoder(11, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
                  Decoder(12, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
                  Decoder(13, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
                  Decoder(14, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
                  Decoder(15, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
                  Decoder(16, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
                  Decoder(17, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
                  Decoder(18, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
                  Decoder(19, "EVENT_CP_INIT", decode_checkpoint_init),
                  Decoder(20, "EVENT_CP_RESET", decode_checkpoint),
]

# Shutdown cause added
v7_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
                  Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
                  Decoder(2, "EVENT_EXCEPTION", decode_unimp),
                  Decoder(3, "EVENT_ASYNC", decode_async),
                  Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
                  Decoder(5, "EVENT_SHUTDOWN_HOST_ERR", decode_unimp),
                  Decoder(6, "EVENT_SHUTDOWN_HOST_QMP", decode_unimp),
                  Decoder(7, "EVENT_SHUTDOWN_HOST_SIGNAL", decode_unimp),
                  Decoder(8, "EVENT_SHUTDOWN_HOST_UI", decode_unimp),
                  Decoder(9, "EVENT_SHUTDOWN_GUEST_SHUTDOWN", decode_unimp),
                  Decoder(10, "EVENT_SHUTDOWN_GUEST_RESET", decode_unimp),
                  Decoder(11, "EVENT_SHUTDOWN_GUEST_PANIC", decode_unimp),
                  Decoder(12, "EVENT_SHUTDOWN___MAX", decode_unimp),
                  Decoder(13, "EVENT_CHAR_WRITE", decode_unimp),
                  Decoder(14, "EVENT_CHAR_READ_ALL", decode_unimp),
                  Decoder(15, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
                  Decoder(16, "EVENT_AUDIO_OUT", decode_audio_out),
                  Decoder(17, "EVENT_AUDIO_IN", decode_unimp),
                  Decoder(18, "EVENT_CLOCK_HOST", decode_clock),
                  Decoder(19, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
                  Decoder(20, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
                  Decoder(21, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
                  Decoder(22, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
                  Decoder(23, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
                  Decoder(24, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
                  Decoder(25, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
                  Decoder(26, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
                  Decoder(27, "EVENT_CP_INIT", decode_checkpoint_init),
                  Decoder(28, "EVENT_CP_RESET", decode_checkpoint),
]

def parse_arguments():
    "Grab arguments for script"
    parser = argparse.ArgumentParser()
    parser.add_argument("-f", "--file", help='record/replay dump to read from',
                        required=True)
    return parser.parse_args()

def decode_file(filename):
    "Decode a record/replay dump"
    dumpfile = open(filename, "rb")

    # read and throwaway the header
    version = read_dword(dumpfile)
    junk = read_qword(dumpfile)

    print("HEADER: version 0x%x" % (version))

    if version == 0xe02007:
        event_decode_table = v7_event_table
        replay_state.checkpoint_start = 12
    elif version == 0xe02006:
        event_decode_table = v6_event_table
        replay_state.checkpoint_start = 12
    else:
        event_decode_table = v5_event_table
        replay_state.checkpoint_start = 10

    try:
        decode_ok = True
        while decode_ok:
            event = read_event(dumpfile)
            decode_ok = call_decode(event_decode_table, event, dumpfile)
    finally:
        dumpfile.close()

if __name__ == "__main__":
    args = parse_arguments()
    decode_file(args.file)
Commit	Line	Data
821c1130 AB	1	#!/usr/bin/env python
	2	# -- coding: utf-8 --
	3	#
	4	# Dump the contents of a recorded execution stream
	5	#
	6	# Copyright (c) 2017 Alex BennÃ©e <[email protected]>
	7	#
	8	# This library is free software; you can redistribute it and/or
	9	# modify it under the terms of the GNU Lesser General Public
	10	# License as published by the Free Software Foundation; either
	11	# version 2 of the License, or (at your option) any later version.
	12	#
	13	# This library is distributed in the hope that it will be useful,
	14	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	# Lesser General Public License for more details.
	17	#
	18	# You should have received a copy of the GNU Lesser General Public
	19	# License along with this library; if not, see <http://www.gnu.org/licenses/>.
	20
f03868bd	21	from __future__ import print_function
821c1130 AB	22	import argparse
	23	import struct
	24	from collections import namedtuple
	25
	26	# This mirrors some of the global replay state which some of the
	27	# stream loading refers to. Some decoders may read the next event so
	28	# we need handle that case. Calling reuse_event will ensure the next
	29	# event is read from the cache rather than advancing the file.
	30
	31	class ReplayState(object):
	32	def __init__(self):
	33	self.event = -1
	34	self.event_count = 0
	35	self.already_read = False
	36	self.current_checkpoint = 0
	37	self.checkpoint = 0
	38
	39	def set_event(self, ev):
	40	self.event = ev
	41	self.event_count += 1
	42
	43	def get_event(self):
	44	self.already_read = False
	45	return self.event
	46
	47	def reuse_event(self, ev):
	48	self.event = ev
	49	self.already_read = True
	50
	51	def set_checkpoint(self):
	52	self.checkpoint = self.event - self.checkpoint_start
	53
	54	def get_checkpoint(self):
	55	return self.checkpoint
	56
	57	replay_state = ReplayState()
	58
	59	# Simple read functions that mirror replay-internal.c
	60	# The file-stream is big-endian and manually written out a byte at a time.
	61
	62	def read_byte(fin):
	63	"Read a single byte"
	64	return struct.unpack('>B', fin.read(1))[0]
	65
	66	def read_event(fin):
	67	"Read a single byte event, but save some state"
	68	if replay_state.already_read:
	69	return replay_state.get_event()
	70	else:
	71	replay_state.set_event(read_byte(fin))
	72	return replay_state.event
	73
	74	def read_word(fin):
	75	"Read a 16 bit word"
	76	return struct.unpack('>H', fin.read(2))[0]
	77
	78	def read_dword(fin):
	79	"Read a 32 bit word"
	80	return struct.unpack('>I', fin.read(4))[0]
	81
	82	def read_qword(fin):
	83	"Read a 64 bit word"
	84	return struct.unpack('>Q', fin.read(8))[0]
	85
86	# Generic decoder structure
87	Decoder = namedtuple("Decoder", "eid name fn")
88
89	def call_decode(table, index, dumpfile):
90	"Search decode table for next step"
91	decoder = next((d for d in table if d.eid == index), None)
92	if not decoder:
f03868bd EH	93	print("Could not decode index: %d" % (index))
	94	print("Entry is: %s" % (decoder))
	95	print("Decode Table is:\n%s" % (table))
821c1130 AB	96	return False
	97	else:
	98	return decoder.fn(decoder.eid, decoder.name, dumpfile)
	99
	100	# Print event
	101	def print_event(eid, name, string=None, event_count=None):
	102	"Print event with count"
	103	if not event_count:
	104	event_count = replay_state.event_count
	105
	106	if string:
f03868bd	107	print("%d:%s(%d) %s" % (event_count, name, eid, string))
821c1130	108	else:
f03868bd	109	print("%d:%s(%d)" % (event_count, name, eid))
821c1130 AB	110
	111
	112	# Decoders for each event type
	113
	114	def decode_unimp(eid, name, _unused_dumpfile):
	115	"Unimplimented decoder, will trigger exit"
f03868bd	116	print("%s not handled - will now stop" % (name))
821c1130 AB	117	return False
	118
	119	# Checkpoint decoder
	120	def swallow_async_qword(eid, name, dumpfile):
	121	"Swallow a qword of data without looking at it"
	122	step_id = read_qword(dumpfile)
f03868bd	123	print(" %s(%d) @ %d" % (name, eid, step_id))
821c1130 AB	124	return True
	125
	126	async_decode_table = [ Decoder(0, "REPLAY_ASYNC_EVENT_BH", swallow_async_qword),
	127	Decoder(1, "REPLAY_ASYNC_INPUT", decode_unimp),
	128	Decoder(2, "REPLAY_ASYNC_INPUT_SYNC", decode_unimp),
	129	Decoder(3, "REPLAY_ASYNC_CHAR_READ", decode_unimp),
	130	Decoder(4, "REPLAY_ASYNC_EVENT_BLOCK", decode_unimp),
	131	Decoder(5, "REPLAY_ASYNC_EVENT_NET", decode_unimp),
	132	]
	133	# See replay_read_events/replay_read_event
	134	def decode_async(eid, name, dumpfile):
	135	"""Decode an ASYNC event"""
	136
	137	print_event(eid, name)
	138
	139	async_event_kind = read_byte(dumpfile)
	140	async_event_checkpoint = read_byte(dumpfile)
	141
	142	if async_event_checkpoint != replay_state.current_checkpoint:
f03868bd EH	143	print(" mismatch between checkpoint %d and async data %d" % (
f03868bd EH	144	replay_state.current_checkpoint, async_event_checkpoint))
821c1130 AB	145	return True
	146
	147	return call_decode(async_decode_table, async_event_kind, dumpfile)
	148
	149
	150	def decode_instruction(eid, name, dumpfile):
	151	ins_diff = read_dword(dumpfile)
	152	print_event(eid, name, "0x%x" % (ins_diff))
	153	return True
	154
	155	def decode_audio_out(eid, name, dumpfile):
	156	audio_data = read_dword(dumpfile)
	157	print_event(eid, name, "%d" % (audio_data))
	158	return True
	159
	160	def decode_checkpoint(eid, name, dumpfile):
	161	"""Decode a checkpoint.
	162
	163	Checkpoints contain a series of async events with their own specific data.
	164	"""
	165	replay_state.set_checkpoint()
	166	# save event count as we peek ahead
	167	event_number = replay_state.event_count
	168	next_event = read_event(dumpfile)
	169
	170	# if the next event is EVENT_ASYNC there are a bunch of
	171	# async events to read, otherwise we are done
	172	if next_event != 3:
	173	print_event(eid, name, "no additional data", event_number)
	174	else:
	175	print_event(eid, name, "more data follows", event_number)
	176
	177	replay_state.reuse_event(next_event)
	178	return True
	179
	180	def decode_checkpoint_init(eid, name, dumpfile):
	181	print_event(eid, name)
	182	return True
	183
	184	def decode_interrupt(eid, name, dumpfile):
	185	print_event(eid, name)
	186	return True
	187
	188	def decode_clock(eid, name, dumpfile):
	189	clock_data = read_qword(dumpfile)
	190	print_event(eid, name, "0x%x" % (clock_data))
	191	return True
	192
	193
	194	# pre-MTTCG merge
	195	v5_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
	196	Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
	197	Decoder(2, "EVENT_EXCEPTION", decode_unimp),
	198	Decoder(3, "EVENT_ASYNC", decode_async),
	199	Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
	200	Decoder(5, "EVENT_CHAR_WRITE", decode_unimp),
	201	Decoder(6, "EVENT_CHAR_READ_ALL", decode_unimp),
	202	Decoder(7, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
	203	Decoder(8, "EVENT_CLOCK_HOST", decode_clock),
	204	Decoder(9, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
	205	Decoder(10, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
	206	Decoder(11, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
	207	Decoder(12, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
	208	Decoder(13, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
209	Decoder(14, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
210	Decoder(15, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
211	Decoder(16, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
212	Decoder(17, "EVENT_CP_INIT", decode_checkpoint_init),
213	Decoder(18, "EVENT_CP_RESET", decode_checkpoint),
214	]
215
216	# post-MTTCG merge, AUDIO support added
217	v6_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
218	Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
219	Decoder(2, "EVENT_EXCEPTION", decode_unimp),
220	Decoder(3, "EVENT_ASYNC", decode_async),
221	Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
222	Decoder(5, "EVENT_CHAR_WRITE", decode_unimp),
223	Decoder(6, "EVENT_CHAR_READ_ALL", decode_unimp),
224	Decoder(7, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
225	Decoder(8, "EVENT_AUDIO_OUT", decode_audio_out),
226	Decoder(9, "EVENT_AUDIO_IN", decode_unimp),
227	Decoder(10, "EVENT_CLOCK_HOST", decode_clock),
228	Decoder(11, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
229	Decoder(12, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
230	Decoder(13, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
231	Decoder(14, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
232	Decoder(15, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
233	Decoder(16, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
234	Decoder(17, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
235	Decoder(18, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
236	Decoder(19, "EVENT_CP_INIT", decode_checkpoint_init),
237	Decoder(20, "EVENT_CP_RESET", decode_checkpoint),
238	]
239
240	# Shutdown cause added
241	v7_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
242	Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
243	Decoder(2, "EVENT_EXCEPTION", decode_unimp),
244	Decoder(3, "EVENT_ASYNC", decode_async),
245	Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
246	Decoder(5, "EVENT_SHUTDOWN_HOST_ERR", decode_unimp),
247	Decoder(6, "EVENT_SHUTDOWN_HOST_QMP", decode_unimp),
248	Decoder(7, "EVENT_SHUTDOWN_HOST_SIGNAL", decode_unimp),
249	Decoder(8, "EVENT_SHUTDOWN_HOST_UI", decode_unimp),
250	Decoder(9, "EVENT_SHUTDOWN_GUEST_SHUTDOWN", decode_unimp),
251	Decoder(10, "EVENT_SHUTDOWN_GUEST_RESET", decode_unimp),
252	Decoder(11, "EVENT_SHUTDOWN_GUEST_PANIC", decode_unimp),
253	Decoder(12, "EVENT_SHUTDOWN___MAX", decode_unimp),
254	Decoder(13, "EVENT_CHAR_WRITE", decode_unimp),
255	Decoder(14, "EVENT_CHAR_READ_ALL", decode_unimp),
256	Decoder(15, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
257	Decoder(16, "EVENT_AUDIO_OUT", decode_audio_out),
258	Decoder(17, "EVENT_AUDIO_IN", decode_unimp),
259	Decoder(18, "EVENT_CLOCK_HOST", decode_clock),
260	Decoder(19, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
261	Decoder(20, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
262	Decoder(21, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
263	Decoder(22, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
264	Decoder(23, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
265	Decoder(24, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
266	Decoder(25, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
267	Decoder(26, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
268	Decoder(27, "EVENT_CP_INIT", decode_checkpoint_init),
269	Decoder(28, "EVENT_CP_RESET", decode_checkpoint),
270	]
271
272	def parse_arguments():
273	"Grab arguments for script"
274	parser = argparse.ArgumentParser()
275	parser.add_argument("-f", "--file", help='record/replay dump to read from',
276	required=True)
277	return parser.parse_args()
278
279	def decode_file(filename):
280	"Decode a record/replay dump"
281	dumpfile = open(filename, "rb")
282
283	# read and throwaway the header
284	version = read_dword(dumpfile)
285	junk = read_qword(dumpfile)
286
f03868bd	287	print("HEADER: version 0x%x" % (version))
821c1130 AB	288
	289	if version == 0xe02007:
	290	event_decode_table = v7_event_table
	291	replay_state.checkpoint_start = 12
	292	elif version == 0xe02006:
	293	event_decode_table = v6_event_table
	294	replay_state.checkpoint_start = 12
	295	else:
	296	event_decode_table = v5_event_table
	297	replay_state.checkpoint_start = 10
	298
	299	try:
	300	decode_ok = True
	301	while decode_ok:
	302	event = read_event(dumpfile)
	303	decode_ok = call_decode(event_decode_table, event, dumpfile)
	304	finally:
	305	dumpfile.close()
	306
	307	if __name__ == "__main__":
	308	args = parse_arguments()
	309	decode_file(args.file)