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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Dump the contents of a recorded execution stream
#
#  Copyright (c) 2017 Alex Bennée <alex.bennee@linaro.org>
#
# 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.1 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/>.

import argparse
import struct
from collections import namedtuple
from os import path

# 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]

def read_array(fin):
    "Read a sized array"
    size = read_dword(fin)
    data = fin.read(size)
    return data

# 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):
    "Unimplemented decoder, will trigger exit"
    print("%s not handled - will now stop" % (name))
    return False

def decode_plain(eid, name, _unused_dumpfile):
    "Plain events without additional data"
    print_event(eid, name, "no data")
    return True

# 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)

total_insns = 0

def decode_instruction(eid, name, dumpfile):
    global total_insns
    ins_diff = read_dword(dumpfile)
    total_insns += ins_diff
    print_event(eid, name, "+ %d -> %d" % (ins_diff, total_insns))
    return True

def decode_char_write(eid, name, dumpfile):
    res = read_dword(dumpfile)
    offset = read_dword(dumpfile)
    print_event(eid, name, "%d -> %d" % (offset, res))
    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

def decode_random(eid, name, dumpfile):
    ret = read_dword(dumpfile)
    data = read_array(dumpfile)
    print_event(eid, "%d bytes of random data" % len(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_plain),
                  Decoder(3, "EVENT_ASYNC", decode_async),
                  Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
                  Decoder(5, "EVENT_CHAR_WRITE", decode_char_write),
                  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_plain),
                  Decoder(3, "EVENT_ASYNC", decode_async),
                  Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
                  Decoder(5, "EVENT_CHAR_WRITE", decode_char_write),
                  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_char_write),
                  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),
]

v12_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
                  Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
                  Decoder(2, "EVENT_EXCEPTION", decode_plain),
                  Decoder(3, "EVENT_ASYNC", decode_async),
                  Decoder(4, "EVENT_ASYNC", decode_async),
                  Decoder(5, "EVENT_ASYNC", decode_async),
                  Decoder(6, "EVENT_ASYNC", decode_async),
                  Decoder(6, "EVENT_ASYNC", decode_async),
                  Decoder(8, "EVENT_ASYNC", decode_async),
                  Decoder(9, "EVENT_ASYNC", decode_async),
                  Decoder(10, "EVENT_ASYNC", decode_async),
                  Decoder(11, "EVENT_SHUTDOWN", decode_unimp),
                  Decoder(12, "EVENT_SHUTDOWN_HOST_ERR", decode_unimp),
                  Decoder(13, "EVENT_SHUTDOWN_HOST_QMP_QUIT", decode_unimp),
                  Decoder(14, "EVENT_SHUTDOWN_HOST_QMP_RESET", decode_unimp),
                  Decoder(14, "EVENT_SHUTDOWN_HOST_SIGNAL", decode_unimp),
                  Decoder(15, "EVENT_SHUTDOWN_HOST_UI", decode_unimp),
                  Decoder(16, "EVENT_SHUTDOWN_GUEST_SHUTDOWN", decode_unimp),
                  Decoder(17, "EVENT_SHUTDOWN_GUEST_RESET", decode_unimp),
                  Decoder(18, "EVENT_SHUTDOWN_GUEST_PANIC", decode_unimp),
                  Decoder(19, "EVENT_SHUTDOWN_GUEST_SUBSYSTEM_RESET", decode_unimp),
                  Decoder(20, "EVENT_SHUTDOWN_GUEST_SNAPSHOT_LOAD", decode_unimp),
                  Decoder(21, "EVENT_SHUTDOWN___MAX", decode_unimp),
                  Decoder(22, "EVENT_CHAR_WRITE", decode_char_write),
                  Decoder(23, "EVENT_CHAR_READ_ALL", decode_unimp),
                  Decoder(24, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
                  Decoder(25, "EVENT_AUDIO_IN", decode_unimp),
                  Decoder(26, "EVENT_AUDIO_OUT", decode_audio_out),
                  Decoder(27, "EVENT_RANDOM", decode_random),
                  Decoder(28, "EVENT_CLOCK_HOST", decode_clock),
                  Decoder(29, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
                  Decoder(30, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
                  Decoder(31, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
                  Decoder(32, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
                  Decoder(33, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
                  Decoder(34, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
                  Decoder(35, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
                  Decoder(36, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
                  Decoder(37, "EVENT_CP_INIT", decode_checkpoint_init),
                  Decoder(38, "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")
    dumpsize = path.getsize(filename)
    # read and throwaway the header
    version = read_dword(dumpfile)
    junk = read_qword(dumpfile)

    # see REPLAY_VERSION
    print("HEADER: version 0x%x" % (version))

    if version == 0xe0200c:
        event_decode_table = v12_event_table
        replay_state.checkpoint_start = 30
    elif 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)
    except Exception as inst:
        print(f"error {inst}")

    finally:
        print(f"Reached {dumpfile.tell()} of {dumpsize} bytes")
        dumpfile.close()

if __name__ == "__main__":
    args = parse_arguments()
    decode_file(args.file)
Commit	Line	Data
3d004a37	1	#!/usr/bin/env python3
821c1130 AB	2	# -- coding: utf-8 --
	3	#
	4	# Dump the contents of a recorded execution stream
	5	#
49ebe9b1	6	# Copyright (c) 2017 Alex Bennée <alex.bennee@linaro.org>
821c1130 AB	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
61f3c91a	11	# version 2.1 of the License, or (at your option) any later version.
821c1130 AB	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
	21	import argparse
	22	import struct
	23	from collections import namedtuple
fcc8c529	24	from os import path
821c1130 AB	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
fcc8c529 AB	86	def read_array(fin):
	87	"Read a sized array"
	88	size = read_dword(fin)
	89	data = fin.read(size)
	90	return data
	91
821c1130 AB	92	# Generic decoder structure
	93	Decoder = namedtuple("Decoder", "eid name fn")
	94
	95	def call_decode(table, index, dumpfile):
	96	"Search decode table for next step"
	97	decoder = next((d for d in table if d.eid == index), None)
	98	if not decoder:
f03868bd EH	99	print("Could not decode index: %d" % (index))
	100	print("Entry is: %s" % (decoder))
	101	print("Decode Table is:\n%s" % (table))
821c1130 AB	102	return False
	103	else:
	104	return decoder.fn(decoder.eid, decoder.name, dumpfile)
	105
	106	# Print event
	107	def print_event(eid, name, string=None, event_count=None):
	108	"Print event with count"
	109	if not event_count:
	110	event_count = replay_state.event_count
	111
	112	if string:
f03868bd	113	print("%d:%s(%d) %s" % (event_count, name, eid, string))
821c1130	114	else:
f03868bd	115	print("%d:%s(%d)" % (event_count, name, eid))
821c1130 AB	116
	117
	118	# Decoders for each event type
	119
	120	def decode_unimp(eid, name, _unused_dumpfile):
d30b5bc9	121	"Unimplemented decoder, will trigger exit"
f03868bd	122	print("%s not handled - will now stop" % (name))
821c1130 AB	123	return False
821c1130 AB	124
fcc8c529 AB	125	def decode_plain(eid, name, _unused_dumpfile):
	126	"Plain events without additional data"
	127	print_event(eid, name, "no data")
	128	return True
	129
821c1130 AB	130	# Checkpoint decoder
	131	def swallow_async_qword(eid, name, dumpfile):
	132	"Swallow a qword of data without looking at it"
	133	step_id = read_qword(dumpfile)
f03868bd	134	print(" %s(%d) @ %d" % (name, eid, step_id))
821c1130 AB	135	return True
	136
	137	async_decode_table = [ Decoder(0, "REPLAY_ASYNC_EVENT_BH", swallow_async_qword),
	138	Decoder(1, "REPLAY_ASYNC_INPUT", decode_unimp),
	139	Decoder(2, "REPLAY_ASYNC_INPUT_SYNC", decode_unimp),
	140	Decoder(3, "REPLAY_ASYNC_CHAR_READ", decode_unimp),
	141	Decoder(4, "REPLAY_ASYNC_EVENT_BLOCK", decode_unimp),
	142	Decoder(5, "REPLAY_ASYNC_EVENT_NET", decode_unimp),
	143	]
	144	# See replay_read_events/replay_read_event
	145	def decode_async(eid, name, dumpfile):
	146	"""Decode an ASYNC event"""
	147
	148	print_event(eid, name)
	149
	150	async_event_kind = read_byte(dumpfile)
	151	async_event_checkpoint = read_byte(dumpfile)
	152
	153	if async_event_checkpoint != replay_state.current_checkpoint:
f03868bd EH	154	print(" mismatch between checkpoint %d and async data %d" % (
f03868bd EH	155	replay_state.current_checkpoint, async_event_checkpoint))
821c1130 AB	156	return True
	157
	158	return call_decode(async_decode_table, async_event_kind, dumpfile)
	159
41e17cc8	160	total_insns = 0
821c1130 AB	161
821c1130 AB	162	def decode_instruction(eid, name, dumpfile):
41e17cc8	163	global total_insns
821c1130	164	ins_diff = read_dword(dumpfile)
41e17cc8 AB	165	total_insns += ins_diff
41e17cc8 AB	166	print_event(eid, name, "+ %d -> %d" % (ins_diff, total_insns))
821c1130 AB	167	return True
821c1130 AB	168
fcc8c529 AB	169	def decode_char_write(eid, name, dumpfile):
	170	res = read_dword(dumpfile)
	171	offset = read_dword(dumpfile)
	172	print_event(eid, name, "%d -> %d" % (offset, res))
	173	return True
	174
821c1130 AB	175	def decode_audio_out(eid, name, dumpfile):
	176	audio_data = read_dword(dumpfile)
	177	print_event(eid, name, "%d" % (audio_data))
	178	return True
	179
	180	def decode_checkpoint(eid, name, dumpfile):
	181	"""Decode a checkpoint.
	182
	183	Checkpoints contain a series of async events with their own specific data.
	184	"""
	185	replay_state.set_checkpoint()
	186	# save event count as we peek ahead
	187	event_number = replay_state.event_count
	188	next_event = read_event(dumpfile)
	189
	190	# if the next event is EVENT_ASYNC there are a bunch of
	191	# async events to read, otherwise we are done
	192	if next_event != 3:
	193	print_event(eid, name, "no additional data", event_number)
	194	else:
	195	print_event(eid, name, "more data follows", event_number)
	196
	197	replay_state.reuse_event(next_event)
	198	return True
	199
	200	def decode_checkpoint_init(eid, name, dumpfile):
	201	print_event(eid, name)
	202	return True
	203
	204	def decode_interrupt(eid, name, dumpfile):
	205	print_event(eid, name)
	206	return True
	207
	208	def decode_clock(eid, name, dumpfile):
	209	clock_data = read_qword(dumpfile)
	210	print_event(eid, name, "0x%x" % (clock_data))
	211	return True
	212
fcc8c529 AB	213	def decode_random(eid, name, dumpfile):
	214	ret = read_dword(dumpfile)
	215	data = read_array(dumpfile)
	216	print_event(eid, "%d bytes of random data" % len(data))
	217	return True
821c1130 AB	218
	219	# pre-MTTCG merge
	220	v5_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
	221	Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
fcc8c529	222	Decoder(2, "EVENT_EXCEPTION", decode_plain),
821c1130 AB	223	Decoder(3, "EVENT_ASYNC", decode_async),
821c1130 AB	224	Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
fcc8c529	225	Decoder(5, "EVENT_CHAR_WRITE", decode_char_write),
821c1130 AB	226	Decoder(6, "EVENT_CHAR_READ_ALL", decode_unimp),
	227	Decoder(7, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
	228	Decoder(8, "EVENT_CLOCK_HOST", decode_clock),
	229	Decoder(9, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
	230	Decoder(10, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
	231	Decoder(11, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
	232	Decoder(12, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
	233	Decoder(13, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
	234	Decoder(14, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
	235	Decoder(15, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
	236	Decoder(16, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
	237	Decoder(17, "EVENT_CP_INIT", decode_checkpoint_init),
	238	Decoder(18, "EVENT_CP_RESET", decode_checkpoint),
	239	]
	240
	241	# post-MTTCG merge, AUDIO support added
	242	v6_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
	243	Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
fcc8c529	244	Decoder(2, "EVENT_EXCEPTION", decode_plain),
821c1130 AB	245	Decoder(3, "EVENT_ASYNC", decode_async),
821c1130 AB	246	Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
fcc8c529	247	Decoder(5, "EVENT_CHAR_WRITE", decode_char_write),
821c1130 AB	248	Decoder(6, "EVENT_CHAR_READ_ALL", decode_unimp),
	249	Decoder(7, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
	250	Decoder(8, "EVENT_AUDIO_OUT", decode_audio_out),
	251	Decoder(9, "EVENT_AUDIO_IN", decode_unimp),
	252	Decoder(10, "EVENT_CLOCK_HOST", decode_clock),
	253	Decoder(11, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
	254	Decoder(12, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
	255	Decoder(13, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
	256	Decoder(14, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
	257	Decoder(15, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
	258	Decoder(16, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
	259	Decoder(17, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
	260	Decoder(18, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
	261	Decoder(19, "EVENT_CP_INIT", decode_checkpoint_init),
	262	Decoder(20, "EVENT_CP_RESET", decode_checkpoint),
	263	]
	264
	265	# Shutdown cause added
	266	v7_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
	267	Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
	268	Decoder(2, "EVENT_EXCEPTION", decode_unimp),
	269	Decoder(3, "EVENT_ASYNC", decode_async),
	270	Decoder(4, "EVENT_SHUTDOWN", decode_unimp),
	271	Decoder(5, "EVENT_SHUTDOWN_HOST_ERR", decode_unimp),
	272	Decoder(6, "EVENT_SHUTDOWN_HOST_QMP", decode_unimp),
	273	Decoder(7, "EVENT_SHUTDOWN_HOST_SIGNAL", decode_unimp),
	274	Decoder(8, "EVENT_SHUTDOWN_HOST_UI", decode_unimp),
	275	Decoder(9, "EVENT_SHUTDOWN_GUEST_SHUTDOWN", decode_unimp),
	276	Decoder(10, "EVENT_SHUTDOWN_GUEST_RESET", decode_unimp),
	277	Decoder(11, "EVENT_SHUTDOWN_GUEST_PANIC", decode_unimp),
	278	Decoder(12, "EVENT_SHUTDOWN___MAX", decode_unimp),
fcc8c529	279	Decoder(13, "EVENT_CHAR_WRITE", decode_char_write),
821c1130 AB	280	Decoder(14, "EVENT_CHAR_READ_ALL", decode_unimp),
	281	Decoder(15, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
	282	Decoder(16, "EVENT_AUDIO_OUT", decode_audio_out),
	283	Decoder(17, "EVENT_AUDIO_IN", decode_unimp),
	284	Decoder(18, "EVENT_CLOCK_HOST", decode_clock),
	285	Decoder(19, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
	286	Decoder(20, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
	287	Decoder(21, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
	288	Decoder(22, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
	289	Decoder(23, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
	290	Decoder(24, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
	291	Decoder(25, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
	292	Decoder(26, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
	293	Decoder(27, "EVENT_CP_INIT", decode_checkpoint_init),
	294	Decoder(28, "EVENT_CP_RESET", decode_checkpoint),
	295	]
	296
fcc8c529 AB	297	v12_event_table = [Decoder(0, "EVENT_INSTRUCTION", decode_instruction),
	298	Decoder(1, "EVENT_INTERRUPT", decode_interrupt),
	299	Decoder(2, "EVENT_EXCEPTION", decode_plain),
	300	Decoder(3, "EVENT_ASYNC", decode_async),
	301	Decoder(4, "EVENT_ASYNC", decode_async),
	302	Decoder(5, "EVENT_ASYNC", decode_async),
	303	Decoder(6, "EVENT_ASYNC", decode_async),
	304	Decoder(6, "EVENT_ASYNC", decode_async),
	305	Decoder(8, "EVENT_ASYNC", decode_async),
	306	Decoder(9, "EVENT_ASYNC", decode_async),
	307	Decoder(10, "EVENT_ASYNC", decode_async),
	308	Decoder(11, "EVENT_SHUTDOWN", decode_unimp),
	309	Decoder(12, "EVENT_SHUTDOWN_HOST_ERR", decode_unimp),
	310	Decoder(13, "EVENT_SHUTDOWN_HOST_QMP_QUIT", decode_unimp),
	311	Decoder(14, "EVENT_SHUTDOWN_HOST_QMP_RESET", decode_unimp),
	312	Decoder(14, "EVENT_SHUTDOWN_HOST_SIGNAL", decode_unimp),
	313	Decoder(15, "EVENT_SHUTDOWN_HOST_UI", decode_unimp),
	314	Decoder(16, "EVENT_SHUTDOWN_GUEST_SHUTDOWN", decode_unimp),
	315	Decoder(17, "EVENT_SHUTDOWN_GUEST_RESET", decode_unimp),
	316	Decoder(18, "EVENT_SHUTDOWN_GUEST_PANIC", decode_unimp),
	317	Decoder(19, "EVENT_SHUTDOWN_GUEST_SUBSYSTEM_RESET", decode_unimp),
	318	Decoder(20, "EVENT_SHUTDOWN_GUEST_SNAPSHOT_LOAD", decode_unimp),
	319	Decoder(21, "EVENT_SHUTDOWN___MAX", decode_unimp),
	320	Decoder(22, "EVENT_CHAR_WRITE", decode_char_write),
	321	Decoder(23, "EVENT_CHAR_READ_ALL", decode_unimp),
	322	Decoder(24, "EVENT_CHAR_READ_ALL_ERROR", decode_unimp),
	323	Decoder(25, "EVENT_AUDIO_IN", decode_unimp),
	324	Decoder(26, "EVENT_AUDIO_OUT", decode_audio_out),
	325	Decoder(27, "EVENT_RANDOM", decode_random),
	326	Decoder(28, "EVENT_CLOCK_HOST", decode_clock),
	327	Decoder(29, "EVENT_CLOCK_VIRTUAL_RT", decode_clock),
	328	Decoder(30, "EVENT_CP_CLOCK_WARP_START", decode_checkpoint),
	329	Decoder(31, "EVENT_CP_CLOCK_WARP_ACCOUNT", decode_checkpoint),
	330	Decoder(32, "EVENT_CP_RESET_REQUESTED", decode_checkpoint),
	331	Decoder(33, "EVENT_CP_SUSPEND_REQUESTED", decode_checkpoint),
	332	Decoder(34, "EVENT_CP_CLOCK_VIRTUAL", decode_checkpoint),
	333	Decoder(35, "EVENT_CP_CLOCK_HOST", decode_checkpoint),
	334	Decoder(36, "EVENT_CP_CLOCK_VIRTUAL_RT", decode_checkpoint),
	335	Decoder(37, "EVENT_CP_INIT", decode_checkpoint_init),
	336	Decoder(38, "EVENT_CP_RESET", decode_checkpoint),
	337	]
	338
821c1130 AB	339	def parse_arguments():
	340	"Grab arguments for script"
	341	parser = argparse.ArgumentParser()
	342	parser.add_argument("-f", "--file", help='record/replay dump to read from',
	343	required=True)
	344	return parser.parse_args()
	345
	346	def decode_file(filename):
	347	"Decode a record/replay dump"
	348	dumpfile = open(filename, "rb")
fcc8c529	349	dumpsize = path.getsize(filename)
821c1130 AB	350	# read and throwaway the header
	351	version = read_dword(dumpfile)
	352	junk = read_qword(dumpfile)
	353
fcc8c529	354	# see REPLAY_VERSION
f03868bd	355	print("HEADER: version 0x%x" % (version))
821c1130	356
fcc8c529 AB	357	if version == 0xe0200c:
	358	event_decode_table = v12_event_table
	359	replay_state.checkpoint_start = 30
	360	elif version == 0xe02007:
821c1130 AB	361	event_decode_table = v7_event_table
	362	replay_state.checkpoint_start = 12
	363	elif version == 0xe02006:
	364	event_decode_table = v6_event_table
	365	replay_state.checkpoint_start = 12
	366	else:
	367	event_decode_table = v5_event_table
	368	replay_state.checkpoint_start = 10
	369
	370	try:
	371	decode_ok = True
	372	while decode_ok:
	373	event = read_event(dumpfile)
fcc8c529 AB	374	decode_ok = call_decode(event_decode_table, event,
	375	dumpfile)
	376	except Exception as inst:
	377	print(f"error {inst}")
	378
821c1130	379	finally:
fcc8c529	380	print(f"Reached {dumpfile.tell()} of {dumpsize} bytes")
821c1130 AB	381	dumpfile.close()
	382
	383	if __name__ == "__main__":
	384	args = parse_arguments()
	385	decode_file(args.file)