def dump(dump_path, memory, debug_info, target_family):
global ee_names
ee_names = ee_names_family[target_family]
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['rpm_core_dump'].vartype
rpm_core_dump = decode_object('rpm_core_dump', address, dump_type, memory,
debug_info)
#import pdb; pdb.set_trace()
rpm = cast(rpm_core_dump.rpmserver_state, 'SystemData', memory, debug_info)
'''
rpm_type = rpm_core_dump._find_basic_type(debug_info.variables['rpm'].die)
rpm_type = rpm_core_dump._unwrap(rpm_type) # "dereference" the type--rpm_core_dump already points at the state itself
rpm_type = rpm_core_dump._find_basic_type(rpm_type)
rpm_state = rpm_core_dump.rpmserver_state.address
rpm = decode_object('rpm', rpm_state, None, memory, debug_info, die=rpm_type)
'''
#save_logger_level = logging.getLogger('dwarf').getEffectiveLevel()
#logging.getLogger('dwarf').setLevel(logging.DEBUG)
dump_ee_status(dump_path, rpm, memory, debug_info)
#logging.getLogger('dwarf').setLevel(save_logger_level)
dump_ee_requests(dump_path, rpm, memory, debug_info)
dump_resource_requests(dump_path, rpm, memory, debug_info)
dump_lookup_table(dump_path, rpm, memory, debug_info)
dump_estimate_cache(dump_path, rpm, memory, debug_info)
def dump(dump_path, memory, debug_info):
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['rpm_core_dump'].vartype
rpm_core_dump = decode_object('rpm_core_dump', address, dump_type, memory,
debug_info)
dev_num = rpm_core_dump.hw_version.parts.device_number
rpm = cast(rpm_core_dump.rpmserver_state, 'SystemData', memory, debug_info)
if 'rpm_image_section_array' not in debug_info.variables:
print_p('\t rpm_image_section_array not found in debug')
else:
try:
rbcpr_type = debug_info.variables['rbcpr_stats_header'].vartype
rbcpr_address = debug_info.variables[
'rpm_image_section_array'].address
rbcpr_address = rbcpr_address + 24
rbcpr_stats = decode_object('rbcpr_stats', rbcpr_address,
rbcpr_type, memory, debug_info)
except:
rbcpr_die = debug_info.variables['rbcpr_stats_header'].die
rbcpr_address = debug_info.variables[
'rpm_image_section_array'].address
rbcpr_address = rbcpr_address + 24
rbcpr_stats = decode_object('rbcpr_stats',
rbcpr_address,
None,
memory,
debug_info,
die=rbcpr_die)
dump_rbcpr(dump_path, rpm, rbcpr_stats, memory, debug_info, dev_num)
def dump(dump_path, memory, debug_info, ocimem_load, pmic_rtc_load):
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['rpm_core_dump'].vartype
rpm_core_dump = decode_object('rpm_core_dump', address, dump_type, memory, debug_info)
#import pdb; pdb.set_trace()
rpm = cast(rpm_core_dump.rpmserver_state, 'SystemData', memory, debug_info)
#save_logger_level = update_logger(logging.DEBUG, logging)
dump_wdog(dump_path, rpm, memory, debug_info, ocimem_load, pmic_rtc_load)
def dump(dump_path, memory, debug_info):
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['rpm_core_dump'].vartype
rpm_core_dump = decode_object('rpm_core_dump', address, dump_type, memory, debug_info)
#import pdb; pdb.set_trace()
rpm = cast(rpm_core_dump.rpmserver_state, 'SystemData', memory, debug_info)
#save_logger_level = logging.getLogger('dwarf').getEffectiveLevel()
#print(save_logger_level)
#logging.getLogger('dwarf').setLevel(logging.DEBUG)
#print(logging.getLogger('dwarf').getEffectiveLevel())
dump_railway(dump_path, rpm, memory, debug_info)
def dump(dump_path, memory, debug_info):
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['rpm_core_dump'].vartype
rpm_core_dump = decode_object('rpm_core_dump', address, dump_type, memory, debug_info)
npa_type = debug_info.variables['npa'].vartype
npa_state = rpm_core_dump.npa_state.address
npa = decode_object('npa', npa_state, npa_type, memory, debug_info)
dump_file = open(os.path.join(dump_path, 'npa-dump.txt'), 'w')
link = npa.resources
while link.address != 0:
dump_link(dump_file, link)
link = link.next
def dump(debug_data): #dump_path, memory, debug_info):
memory = debug_data['rpm_memory']
debug_info = debug_data['debug_info']
dump_path = debug_data['dump_path']
debug_data['printer'].p("Dumping sleep stats...")
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['aop_core_dump'].vartype
aop_core_dump = decode_object('aop_core_dump', address, dump_type, memory,
debug_info)
rpm = 0 #cast(aop_core_dump.rpmserver_state, 'SystemData', memory, debug_info)
if (check_member('sleep_stats', aop_core_dump)):
#sleep_stats in in core dump
sleep = aop_core_dump.sleep_stats
sleep = cast(sleep, 'sleep_stats_type', memory, debug_info)
else:
try:
sleep_type = debug_info.variables['sleep_stats'].die
except:
sleep_file_name = os.path.join(dump_path, 'sleep_stats.txt')
with open(sleep_file_name, 'w') as sleep_file:
print(
"\n !!! SLEEP_STATS DOES NOT EXIST, SLEEP IS LIKELY NOT ENABLED !!! \n",
file=sleep_file)
return
try:
#not in core dump, but elf is close enough to provide a correct pointer
sleep_address = debug_info.variables[
'sleep_stats'].address # FIXME: get right address by magic
sleep = decode_object('sleep_stats',
sleep_address,
None,
memory,
debug_info,
die=sleep_type)
except:
sleep_file_name = os.path.join(dump_path, 'sleep_stats.txt')
with open(sleep_file_name, 'w') as sleep_file:
print(
"\n !!! SLEEP_STATS DOES NOT EXIST, SLEEP IS LIKELY NOT ENABLED !!! \n",
file=sleep_file)
return
dump_sleep(dump_path, rpm, sleep, memory, debug_info)
def dump(dump_path, memory, debug_info):
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['rpm_core_dump'].vartype
rpm_core_dump = decode_object('rpm_core_dump', address, dump_type, memory,
debug_info)
rpm = cast(rpm_core_dump.rpmserver_state, 'SystemData', memory, debug_info)
if (check_member('sleep_stats', rpm_core_dump)):
#sleep_stats in in core dump
sleep = rpm_core_dump.sleep_stats
sleep = cast(sleep, 'sleep_stats_type', memory, debug_info)
else:
try:
#not in core dump, but elf is close enough to provide a correct pointer
sleep_type = debug_info.variables['sleep_stats'].die
sleep_address = debug_info.variables[
'sleep_stats'].address # FIXME: get right address by magic
sleep = decode_object('sleep_stats',
sleep_address,
None,
memory,
debug_info,
die=sleep_type)
except:
#not correct in elf, find absolute address (very hacky)
sleep_type = debug_info.variables['sleep_stats'].die
sleep_address = find_value(0x0019DBA0, 4, 0x00190000, 0x0019FFFF,
memory)
sleep = decode_object('sleep_stats',
sleep_address,
None,
memory,
debug_info,
die=sleep_type)
'''
print(debug_info.variables['sleep_stats'].die)
#sleep_address = 0x0019DBA0
sleep_address = debug_info.variables['sleep_stats'].address
sleep = decode_object('sleep_stats', sleep_address, sleep_type, memory, debug_info)
'''
#save_logger_level = update_logger(logging.DEBUG, logging)
dump_sleep(dump_path, rpm, sleep, memory, debug_info)
def dump(debug_data): #dump_path, memory, debug_info):
memory = debug_data['rpm_memory']
debug_info = debug_data['debug_info']
dump_path = debug_data['dump_path']
debug_data['printer'].p("Dumping Frequency switch info...")
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['aop_core_dump'].vartype
aop_core_dump = decode_object('aop_core_dump', address, dump_type, memory, debug_info)
rpm = 0#cast(aop_core_dump.rpmserver_state, 'SystemData', memory, debug_info)
if (check_member('freq_switch_table_ptr ', aop_core_dump)):
#freq_switch_table_ptr in in core dump
freq_switch = aop_core_dump.freq_switch_table_ptr
freq_switch = cast(freq_switch, 'ddr_stats_type', memory, debug_info)
else:
try:
freq_switch_type = debug_info.variables['freq_switch_table_ptr'].die
except:
freq_switch_file_name = os.path.join(dump_path, 'ddr_stats.txt')
with open(freq_switch_file_name, 'a') as freq_switch_file:
print("\n !!! FREQ SWITCH INFO DOES NOT EXIST !!! \n", file=freq_switch_file)
return
try:
#not in core dump, but elf is close enough to provide a correct pointer
freq_switch_address = debug_info.variables['freq_switch_table_ptr'].address # FIXME: get right address by magic
freq_switch = decode_object('freq_switch_table_ptr', freq_switch_address, None, memory, debug_info, die=freq_switch_type)
except:
freq_switch_file_name = os.path.join(dump_path, 'ddr_stats.txt')
with open(freq_switch_file_name, 'a') as freq_switch_file:
print("\n !!! FREQ SWITCH INFO DOES NOT EXIST !!! \n", file=freq_switch_file)
return
#import pdb; pdb.set_trace()
dump_ddr(dump_path, rpm, freq_switch, memory, debug_info)
def dump(debug_data): #dump_path, memory, debug_info):
global dump_error
dump_error = 0
memory = debug_data['rpm_memory']
debug_info = debug_data['debug_info']
dump_path = debug_data['dump_path']
reclaim = debug_data['reclaim_pool']
debug_data['printer'].p("Dumping NPA state...")
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['aop_core_dump'].vartype
aop_core_dump = decode_object('aop_core_dump', address, dump_type, memory,
debug_info)
unpa_type = debug_info.variables['unpa'].die
unpa_address = debug_info.variables['unpa'].address
unpa = decode_object('unpa',
unpa_address,
None,
memory,
debug_info,
die=unpa_type)
dump_file = open(os.path.join(dump_path, 'npa-dump.txt'), 'w')
link = unpa.resources
while link.address != 0:
dump_link(dump_file, link, reclaim)
link = link.next
if dump_error != 0:
debug_data['printer'].p(
"\t...Non-critical errors occured in processing dump, continuing")
else:
debug_data['printer'].p("\t...DONE")
def dump_bcm_vts(dump_path, memory, target, debug_info, fill_char,
bcm_json_dir):
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['aop_core_dump'].vartype
aop_core_dump = decode_object('aop_core_dump', address, dump_type, memory,
debug_info)
json_file_name = os.path.join(bcm_json_dir, str(target) + "/VCD.json")
with open(json_file_name, 'r') as data_file:
data = json.load(data_file)
####################################################################################################################
if (check_member('global_ddr_cfg ', aop_core_dump)):
ddr_cfg = aop_core_dump.global_ddr_cfg
ddr_cfg = cast(ddr_cfg, 'DDRCfgType', memory, debug_info)
else:
try:
ddr_cfg_address = debug_info.variables['global_ddr_cfg'].die
except:
ddr_file_name = os.path.join(dump_path, 'ddr_stats.txt')
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_CFG DOES NOT EXIST !!! \n", file=ddr_file)
try:
#not in core dump, but elf is close enough to provide a correct pointer
ddr_gbl_address = debug_info.variables[
'global_ddr_cfg'].address # FIXME: get right address by magic
ddr_cfg = decode_object('global_ddr_cfg',
ddr_gbl_address,
None,
memory,
debug_info,
die=ddr_cfg_address)
except:
#not correct in elf, find absolute address (very hacky)
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_cfg DOES NOT EXIST !!! \n", file=ddr_file)
####################################################################################################################
if (check_member('ddr_status', aop_core_dump)):
#ddr_status in in core dump
ddr_status = aop_core_dump.ddr_status
ddr_status = cast(ddr_status, 'ddr_state', memory,
debug_info) ###################################
else:
try:
freq_switch_address = debug_info.variables[
'ddr_status'].die ###################################
except:
ddr_file_name = os.path.join(dump_path, 'ddr_stats.txt')
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_STATUS DOES NOT EXIST !!! \n", file=ddr_file)
return
try:
#not in core dump, but elf is close enough to provide a correct pointer
ddr_status_address = debug_info.variables[
'ddr_status'].address # FIXME: get right address by magic
ddr_status = decode_object('ddr_status',
ddr_status_address,
None,
memory,
debug_info,
die=freq_switch_address)
except:
#not correct in elf, find absolute address (very hacky)
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_STATUS DOES NOT EXIST !!! \n", file=ddr_file)
####################################################################################################################
dump_path = os.path.join(dump_path, 'reqs_for_resources')
if not os.path.exists(dump_path):
os.makedirs(dump_path)
bcm_file_name = os.path.join(dump_path, 'bcm_vt.txt')
summary_file_name = os.path.join(dump_path, 'rpmh_summary.txt')
with open(bcm_file_name, 'w') as bcm_file, open(summary_file_name,
'a') as summary_file:
print("\n\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
print("\t| VCD | Nodes |",
file=bcm_file)
print("\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
for x in range(0, no_vcds):
print("\t|{0:>5d}|{1:>41s}|".format(x, vcd_map_table[x]),
file=bcm_file)
print("\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
print("\n ~~BCM Status Front End~~", file=bcm_file)
print(
"\n\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
print(
"\t| VCD | AGG_BW | Final_CP | AGG_CP | DDR MGR Override AGG_CP | Freq_khz |",
file=bcm_file)
print(
"\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
for x in range(0, no_vcds):
address = bcm_status_fe + (0x4 * x)
fe_data = memory.read(address, 4)
fe_status = struct.unpack('<L', fe_data)[0]
agg_cp = fe_status & 0xF
final_cp = ((fe_status >> 4) & 0xF)
agg_bw = ((fe_status >> 16) & 0x3FFF)
# if x==0: #mc
# for x in range(0, ddr_cfg.nNumMCStates):
# if (ddr_cfg.pMCCfg[x].clk_idx==agg_cp):
# frq=ddr_cfg.pMCCfg[x].freq_khz
# elif x==1: #shub
# for y in range(0, ddr_cfg.nNumSHUBStates):
# if (ddr_cfg.pSHUBCfg[y].clk_idx==agg_cp):
# frq=ddr_cfg.pSHUBCfg[y].freq_khz
ddr_mc_cp = hex(ddr_status.current_mc_cp)
ddr_shub_cp = hex(ddr_status.current_shub_cp)
flag = 0
for key, value in data.items():
if (data[key]["VCD Index"] == x):
if (x == 0):
v5 = str(ddr_mc_cp)
if (ddr_mc_cp != 0x0):
flag = 1
var_print = key
v1 = hex(agg_bw)
v2 = hex(final_cp)
v3 = hex(agg_cp)
v4 = str(x) + ":"
for y in data[key]["Clock Domains"]:
print(
"\t|{0:3s}{1:>20s}|{2:>8s}|{3:>10s}|{4:>8s}|{5:>25s}|{6:30s}: {7:>17s}|"
.format(v4, var_print, v1, v2, v3, v5,
y["domain"], (str(y["freq"][int(
ddr_mc_cp,
16)]).split(":")[1])[3:-2]),
file=bcm_file)
var_print = ""
v1 = ""
v2 = ""
v3 = ""
v4 = ""
v5 = ""
elif (x == 1):
v5 = str(ddr_shub_cp)
if (ddr_shub_cp != 0x0):
flag = 1
var_print = key
v1 = hex(agg_bw)
v2 = hex(final_cp)
v3 = hex(agg_cp)
v4 = str(x) + ":"
for y in data[key]["Clock Domains"]:
print(
"\t|{0:3s}{1:>20s}|{2:>8s}|{3:>10s}|{4:>8s}|{5:>25s}|{6:30s}: {7:>17s}|"
.format(v4, var_print, v1, v2, v3, v5,
y["domain"], (str(y["freq"][int(
ddr_shub_cp,
16)]).split(":")[1])[3:-2]),
file=bcm_file)
var_print = ""
v1 = ""
v2 = ""
v3 = ""
v4 = ""
v5 = ""
else:
v5 = "NA"
if (agg_cp != 0):
flag = 1
var_print = key
v1 = hex(agg_bw)
v2 = hex(final_cp)
v3 = hex(agg_cp)
v4 = str(x) + ":"
for y in data[key]["Clock Domains"]:
print(
"\t|{0:3s}{1:>20s}|{2:>8s}|{3:>10s}|{4:>8s}|{5:>25s}|{6:30s}: {7:>17s}|"
.format(
v4, var_print, v1, v2, v3, v5,
y["domain"],
(str(y["freq"][agg_cp]).split(":")[1]
)[3:-2]),
file=bcm_file)
var_print = ""
v1 = ""
v2 = ""
v3 = ""
v4 = ""
v5 = ""
if (flag == 0):
v6 = str(x) + ":"
print("\t|{0:<23s}|{1:>8s}|{2:>10s}|{3:>8s}|{4:>25s}|{5:50s}|".
format(v6, hex(agg_bw), hex(final_cp), hex(agg_cp), "NA",
""),
file=bcm_file)
print(
"\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
print("\n ~~BCM Status Back End~~", file=bcm_file)
print(
"\n\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
print(
"\t| VCD | Clk_dest_state | Combined_CP | SW_CP_SNAP | Written_CP | CURR_CP |",
file=bcm_file)
print(
"\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
for x in range(0, no_vcds):
address = bcm_status_be + (0x4 * x)
fe_data = memory.read(address, 4)
fe_status = struct.unpack('<L', fe_data)[0]
curr_cp = fe_status & 0xF
written_cp = ((fe_status >> 4) & 0xF)
sw_cp = ((fe_status >> 8) & 0xF)
combined_cp = ((fe_status >> 12) & 0xF)
clk_dest = ((fe_status >> 16) & 0xF)
print("\t|{0:>5d}|{1:>16s}|{2:>13s}|{3:>12s}|{4:>12s}|{5:>9s}|".
format(x, hex(clk_dest), hex(combined_cp), hex(sw_cp),
hex(written_cp), hex(curr_cp)),
file=bcm_file)
print(
"\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
print("\n ~~BCM Back End Sequencer~~", file=bcm_file)
print("\n ~~BCM Status~~", file=summary_file)
print("\n\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~", file=bcm_file)
print("\t| VCD | SEQ_CURR_PC | IDLE |", file=bcm_file)
print("\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", file=bcm_file)
for x in range(0, no_vcds):
address = bcm_status_be_seq + (0x4 * x)
fe_data = memory.read(address, 4)
fe_status = struct.unpack('<L', fe_data)[0]
seq_state = fe_status & 0x1
curr_pc = ((fe_status >> 8) & 0xFF)
print("\t|{0:>5d}|{1:>8s}|{2:>10s}|".format(
x, hex(curr_pc), hex(seq_state)),
file=bcm_file)
if seq_state:
print("\tVCD %d is Idle" % (x), file=summary_file)
else:
print("\tVCD %d is Busy" % (x), file=summary_file)
print("\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", file=bcm_file)
print("\n\n ~~BCM Resource Summary~~", file=bcm_file)
#import pdb; pdb.set_trace()
for regs in range(0, no_regs):
if bcm_map_table[regs] == ' ':
continue
print('\n\n\t BCM [%d] : %s ' % (regs, bcm_map_table[regs]),
file=bcm_file)
print("\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
print("\t\t| DRV | ID | Valid | AB | IB |",
file=bcm_file)
print("\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
file=bcm_file)
for drv in range(0, no_drv):
address = vt_base_address + (0x10000 * drv) + (0x4 * regs)
bcm_data = memory.read(address, 4)
bcm_vt = struct.unpack('<L', bcm_data)[0]
vote_valid = ((bcm_vt >> 29) & 0x1)
vote_x = ((bcm_vt >> 14) & 0x3FFF)
vote_y = (bcm_vt & 0x3FFF)
if bcm_vt != 0:
print("\t\t|{0:>10s}|{1:>4d}|{2:>7d}|{3:>8s}|{4:>8s}|".
format((targ_spec_config[target]['drv'][drv]), drv,
vote_valid, hex(vote_x), hex(vote_y)),
file=bcm_file)
BCM_votetable[regs][drv] = [vote_valid, vote_x, vote_y]
def dump(debug_data
): #dump_path, parse_path, memory, debug_info, target, branch):
memory = debug_data['rpm_memory']
debug_info = debug_data['debug_info']
dump_path = debug_data['dump_path']
parse_path = debug_data['args'].parser
target = debug_data['target']
branch = debug_data['branch']
parse_tbl = debug_data['parser_tbl']
debug_data['printer'].p("Dumping ulogs...")
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['aop_core_dump'].vartype
aop_core_dump = decode_object('aop_core_dump', address, dump_type, memory,
debug_info)
rpm_ulogContext_type = debug_info.variables['rpm_ulogContext'].vartype
ulog_state = aop_core_dump.ulog_state.address
rpm_ulogContext = decode_object('rpm_ulogContext', ulog_state,
rpm_ulogContext_type, memory, debug_info)
log = rpm_ulogContext.logHead
if log.address == 0:
logger.error(
'Failed to find any RPM ulogs (rpm_ulogContext.logHead == NULL)!')
return
if log.version != 0x1000:
logger.error(
'This script only knows how to dump RPM ULog version 0x1000 (Originating July 2012)'
)
if log.version in [2, 3, 4]:
logger.error('It appears your logs are version %d' % log.version)
else:
logger.error(
'Your log version (%d) is unknown to this script. Is your log corrupted?'
% log.version)
return
while log.address != 0:
log_name = ''.join(
itertools.takewhile(lambda c: c != '\0',
(chr(c) for c in log.name)))
log_enabled = (log.logStatus & 0x2) != 0
if not log_enabled:
logger.debug('Not dumping ulog (disabled): %d' % log_name)
continue
use_64_bit_timestamps = (log.feature_flags1 & 0x1) != 0
logger.debug('Dumping ulog: %s' % log_name)
log_file_name = os.path.join(dump_path, '%s.ulog' % log_name)
with open(log_file_name, 'w') as log_file:
log_buffer = log.buffer
log_size = log.bufSize
log_mask = log.bufSizeMask
read = log.readWriter
readers_read = log.read
write = log.write
bytes_in_log = write - read
if bytes_in_log > log_size:
logger.warning(
'While parsing ulog "%s" -> reported log size %d bigger than the expected log size %d'
% (log_name, bytes_in_log, log_size))
logger.warning(
'The most common cause of this is memory corruption, under-voltage, or writes to unpowered RAM.'
)
logger.warning(
'Will try to continue with this ULog decode, but results may be unpredictable.'
)
while read < write:
# Advance past the message format value
read = read + 2
# Read the number of bytes in this message
msg_length = log_buffer[read & log_mask] + (log_buffer[
(read + 1) & log_mask] << 8)
# Back up to the format for later
read = read - 2
# Handle the current ULog message
dump_ulog_msg(log_file, log_buffer, log_mask, read, msg_length)
# Move our read pointer past the message we just finished (and 4 byte align it)
read = read + ((msg_length + 3) & 0xFFFFFFFC)
log = log.next
# Now run the second-stage parsing script, if applicable.
rpm_external_log = os.path.join(dump_path, 'AOP External Log.ulog')
if os.path.exists(rpm_external_log):
print_p('\t\tPost-processing the AOP "external" log...')
parser = parse_path + 'aop_log_hfam.py'
parser2 = parse_tbl + 'tracer_event_tbl.h'
parser_params = [
'python', parser, '-f', rpm_external_log, '-t', target, '-tbl',
parser2
] #, '-b', branch]
try:
pretty_output = subprocess.check_output(parser_params)
pretty_output = pretty_output.replace('\r\n', '\n')
except subprocess.CalledProcessError:
pretty_output = '<failed to run log parser>\n'
with open(os.path.join(dump_path, 'aop-rawts.txt'), 'w') as pretty_log:
pretty_log.write(pretty_output)
try:
parser_params = parser_params + ['-p']
raw_output = subprocess.check_output(parser_params)
raw_output = raw_output.replace('\r\n', '\n')
except subprocess.CalledProcessError:
raw_output = '<failed to run log parser>\n'
with open(os.path.join(dump_path, 'aop-log.txt'), 'w') as raw_log:
raw_log.write(raw_output)
#import pdb; pdb.set_trace()
# Now run the second-stage parsing script, if applicable.
ddr_external_log = os.path.join(dump_path, 'AOP DDR Log.ulog')
if os.path.exists(rpm_external_log):
print_p('\t\tPost-processing the AOP "DDR" log...')
parser = parse_path + 'aop_log_hfam.py'
parser2 = parse_tbl + 'tracer_event_tbl.h'
parser_params = [
'python', parser, '-f', ddr_external_log, '-t', target, '-tbl',
parser2
] #, '-b', branch]
try:
pretty_output = subprocess.check_output(parser_params)
pretty_output = pretty_output.replace('\r\n', '\n')
except subprocess.CalledProcessError:
pretty_output = '<failed to run log parser>\n'
with open(os.path.join(dump_path, 'ddr-rawts.txt'), 'w') as pretty_log:
pretty_log.write(pretty_output)
try:
parser_params = parser_params + ['-p']
raw_output = subprocess.check_output(parser_params)
raw_output = raw_output.replace('\r\n', '\n')
except subprocess.CalledProcessError:
raw_output = '<failed to run log parser>\n'
with open(os.path.join(dump_path, 'ddr-log.txt'), 'w') as raw_log:
raw_log.write(raw_output)
def dump(debug_data): #dump_path, memory, debug_info):
memory = debug_data['rpm_memory']
debug_info = debug_data['debug_info']
dump_path = debug_data['dump_path']
debug_data['printer'].p("Dumping DDR stats...")
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['aop_core_dump'].vartype
aop_core_dump = decode_object('aop_core_dump', address, dump_type, memory,
debug_info)
if (check_member('ddr_stats', aop_core_dump)):
#ddr_stats in in core dump
ddr = aop_core_dump.ddr_stats
ddr = cast(ddr, 'ddr_stats_type', memory, debug_info)
else:
try:
freq_switch_address = debug_info.variables['ddr_stats'].die
except:
ddr_file_name = os.path.join(dump_path, 'ddr_stats.txt')
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_STATS DOES NOT EXIST !!! \n", file=ddr_file)
return
try:
#not in core dump, but elf is close enough to provide a correct pointer
ddr_address = debug_info.variables[
'ddr_stats'].address # FIXME: get right address by magic
ddr = decode_object('ddr_stats',
ddr_address,
None,
memory,
debug_info,
die=freq_switch_address)
except:
#not correct in elf, find absolute address (very hacky)
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_STATS DOES NOT EXIST !!! \n", file=ddr_file)
return
################################################################################################################################
#import pdb; pdb.set_trace()
if (check_member('ddr_status', aop_core_dump)):
#ddr_status in in core dump
ddr_status = aop_core_dump.ddr_status
ddr_status = cast(ddr_status, 'ddr_state', memory,
debug_info) ###################################
else:
try:
freq_switch_address = debug_info.variables[
'ddr_status'].die ###################################
except:
ddr_file_name = os.path.join(dump_path, 'ddr_stats.txt')
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_STATUS DOES NOT EXIST !!! \n",
file=ddr_file)
return
try:
#not in core dump, but elf is close enough to provide a correct pointer
ddr_status_address = debug_info.variables[
'ddr_status'].address # FIXME: get right address by magic
ddr_status = decode_object('ddr_status',
ddr_status_address,
None,
memory,
debug_info,
die=freq_switch_address)
except:
#not correct in elf, find absolute address (very hacky)
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_STATUS DOES NOT EXIST !!! \n",
file=ddr_file)
return
################################################################################################################################
if (check_member('global_ddr_cfg ', aop_core_dump)):
#global_ddr_cfg in in core dump
ddr_cfg = aop_core_dump.global_ddr_cfg
ddr_cfg = cast(ddr_cfg, 'DDRCfgType', memory, debug_info)
else:
try:
ddr_cfg_address = debug_info.variables['global_ddr_cfg'].die
except:
ddr_file_name = os.path.join(dump_path, 'ddr_stats.txt')
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_CFG DOES NOT EXIST !!! \n", file=ddr_file)
return
try:
#not in core dump, but elf is close enough to provide a correct pointer
ddr_gbl_address = debug_info.variables[
'global_ddr_cfg'].address # FIXME: get right address by magic
ddr_cfg = decode_object('global_ddr_cfg',
ddr_gbl_address,
None,
memory,
debug_info,
die=ddr_cfg_address)
except:
#not correct in elf, find absolute address (very hacky)
with open(ddr_file_name, 'w') as ddr_file:
print("\n !!! DDR_cfg DOES NOT EXIST !!! \n", file=ddr_file)
return
#import pdb; pdb.set_trace()
#save_logger_level = update_logger(logging.DEBUG, logging)
dump_ddr(dump_path, ddr_cfg, ddr, ddr_status, memory, debug_info)
def dump(debug_data): #dump_path, memory, debug_info, base_address):
memory = debug_data['rpm_memory']
debug_info = debug_data['debug_info']
dump_path = debug_data['dump_path']
base_address = debug_data['image_strings_addr']
global chip_version
dump = open(os.path.join(dump_path, 'aop-summary.txt'), 'w')
try:
chipFamilyNum_die = debug_info.variables['chipFamilyNum'].die
chipDeviceNum_die = debug_info.variables['chipDeviceNum'].die
chipMinor_die = debug_info.variables['chipMinor'].die
chipMajor_die = debug_info.variables['chipMajor'].die
except:
print("\n !!! ChipInfoCtxt DOES NOT EXIST !!! \n", file=ddr_file)
return
try:
#not in core dump, but elf is close enough to provide a correct pointer
chipFamilyNum_address = debug_info.variables['chipFamilyNum'].address # FIXME: get right address by magic
chipFamilyNum = decode_object('chipFamilyNum', chipFamilyNum_address, None, memory, debug_info, die=chipFamilyNum_die)
chipDeviceNum_address = debug_info.variables['chipDeviceNum'].address # FIXME: get right address by magic
chipDeviceNum = decode_object('chipDeviceNum', chipDeviceNum_address, None, memory, debug_info, die=chipDeviceNum_die)
chipMinor_address = debug_info.variables['chipMinor'].address # FIXME: get right address by magic
chipMinor = decode_object('chipMinor', chipMinor_address, None, memory, debug_info, die=chipMinor_die)
chipMajor_address = debug_info.variables['chipMajor'].address # FIXME: get right address by magic
chipMajor = decode_object('chipMajor', chipMajor_address, None, memory, debug_info, die=chipMajor_die)
except:
print("\n !!! ChipInfoCtxt DOES NOT EXIST !!! \n", file=ddr_file)
return
chip_version = chipMajor
version_address_start = base_address + 0x0
version_address_end = version_address_start + 0x1000
#regex to match the RPM branch name:
regex = '^AOP\.HO\.\d\.\d.*(?=-)'
address = locate_core_dump(memory, debug_info)
dump_type = debug_info.variables['aop_core_dump'].vartype
aop_core_dump = decode_object('aop_core_dump', address, dump_type, memory, debug_info)
chip_name = '<unknown device -> family %d device %d>' % (chipFamilyNum, chipDeviceNum)
target_chip = chips.get(chipFamilyNum, {}).get(chipDeviceNum, {})
chip_name = target_chip.get('MSM_ID', chip_name)
print('\nCollected from %s %d.%d\n' % (chip_name, chipMajor, chipMinor), file=dump)
rpm_ver_type = debug_info.variables['aop_core_dump'].vartype
#rpm_build_date_type = debug_info.variables['gBuildDate'].die
#rpm_build_date_address = debug_info.variables['gBuildDate'].address
#rpm_build_time_type = debug_info.variables['gBuildTime'].die
#rpm_build_time_address = debug_info.variables['gBuildTime'].address
#rpm_build_date = decode_object('gBuildDate', rpm_build_date_address, None, memory, debug_info, die=rpm_build_date_type)
#rpm_build_time = decode_object('gBuildTime', rpm_build_time_address, None, memory, debug_info, die=rpm_build_time_type)
#
#QC_IMAGE_VERSION = find_version_info("QC_IMAGE_VERSION_STRING=",version_address_start, version_address_end, memory)
#print("QC_IMAGE_VERSION_STRING: %s" % QC_IMAGE_VERSION, file=dump)
#print("IMAGE_VARIANT_STRING: %s" % find_version_info("IMAGE_VARIANT_STRING=",version_address_start, version_address_end, memory), file=dump)
#print("OEM_IMAGE_VERSION_STRING: %s" % find_version_info("OEM_IMAGE_VERSION_STRING=",version_address_start, version_address_end, memory), file=dump)
#
#print("\nBuild Date: %s" % pointer_to_str(rpm_build_date), file=dump)
#print("Build Time: %s" % pointer_to_str(rpm_build_time), file=dump)
if aop_core_dump.dumped_at == 0:
print('\nThe AOP is ok.', file=dump)
# return chip name and RPM branch
return [target_chip.get('num', '????')]#, re.compile(regex).match(QC_IMAGE_VERSION).group()]
print('\nThe AOP crashed (@ time = 0x%x)' % aop_core_dump.dumped_at, file=dump)
xpsr = aop_core_dump.registers.xPSR
ipsr = xpsr & 0xff
if ipsr == 0:
print('\tNot in an exception context; vanilla fatal error scenario.', file=dump)
elif ipsr < 16:
fault_types = {
2 : 'NMI',
3 : 'Hard Fault',
4 : 'Memory Management Fault',
5 : 'Bus Fault',
6 : 'Usage Fault',
11 : 'SVCall',
12 : 'Debug Monitor',
14 : 'PendSV',
15 : 'SysTick',
}
print('\tIn a fault context -> %s' % fault_types[ipsr], file=dump)
else:
print('\tFatal error inside ISR #%d' % (ipsr - 16), file=dump)
def decode_bitfield(name, bit_definitions, data, joiner = ' | '):
known_bits = 0
for id in bit_definitions:
known_bits |= (1 << id)
unknown_data = data - (data & known_bits)
string = joiner.join(['[' + bit_definitions[x] + ']' for x in bit_definitions if (1 << x) & data])
if unknown_data:
if string:
string += ' ...and '
multi_or_single = ''
if log(unknown_data, 2) != int(log(unknown_data, 2)):
multi_or_single = 's'
string += 'unknown %s%s 0x%0.8x' % (name, multi_or_single, unknown_data)
return string
fault_regs = aop_core_dump.fault_detail
shcas_bits = {
0 : 'Memory fault in progress',
1 : 'Bus fault in progress',
3 : 'Usage fault in progress',
7 : 'SVCall in progress',
8 : 'Debug Monitor in progress',
10 : 'PendSV in progress',
11 : 'SysTick in progress',
12 : 'Usage fault pended',
13 : 'Memory management fault pended',
14 : 'Bus fault pended',
15 : 'SVCall pended',
16 : 'Memory management fault enabled (this is not a problem)',
17 : 'Bus fault enabled (this is not a problem)',
18 : 'Usage fault enabled (this is not a problem)',
}
print('\nSystem handler status {\n\t%s\n}' % decode_bitfield('bits', shcas_bits, fault_regs.SystemHandlerCtrlAndState, '\n\t'), file=dump)
cfs_bits = {
0 : 'Attempt to fetch an instruction from a non-executable region.',
1 : 'Attempt to load or store a location that does not permit it.',
3 : 'Unstacking from an exception return has caused one or more access violations.',
4 : 'Stacking for an exception has caused one or more access violations.',
7 : 'Memory manage address register (MMAR) is valid.',
8 : 'Instruction bus error.',
9 : 'Precise data bus error.',
10 : 'Imprecise data bus error.',
11 : 'Unstack from exception has caused one or more bus errors.',
12 : 'Stacking for exception has caused one or more bus errors.',
15 : 'Bus fault address register (BFAR) is valid.',
16 : 'Undefined instruction exception.',
17 : 'Invalid state exception.',
18 : 'Illegal attempt to load EXC_RETURN into PC.',
19 : 'Attempt to use a coprocessor instruction.',
24 : 'Unaligned memory access.',
25 : 'Divide by zero.',
}
print('\nConfigurable fault status {\n\t%s\n}' % decode_bitfield('bits', cfs_bits, fault_regs.ConfigurableFaultStatus, '\n\t'), file=dump)
hfs_bits = {
0 : 'Fault on vector table read during exception processing.',
30 : 'Hard Fault activated because a configurable fault was received and cannot activate because of priority or it is disabled.',
31 : 'Fault related to debug.',
}
print('\nHard fault status {\n\t%s\n}' % decode_bitfield('bits', hfs_bits, fault_regs.HardFaultStatus, '\n\t'), file=dump)
dfs_bits = {
0 : 'Halt requested by NVIC.',
1 : 'BKPT instruction execution.',
2 : 'DWT match.',
3 : 'Vector fetch occurred.',
4 : 'EDBGRQ signal asserted.',
}
print('\nDebug fault status {\n\t%s\n}' % decode_bitfield('bits', hfs_bits, fault_regs.DebugFaultStatus, '\n\t'), file=dump)
if 0 != (fault_regs.ConfigurableFaultStatus & (1 << 7)):
print('\nMemory manage fault address: 0x%0.8x' % fault_regs.MemManageAddress, file=dump)
if 0 != (fault_regs.ConfigurableFaultStatus & (1 << 15)):
print('\nMemory manage fault address: 0x%0.8x' % fault_regs.BusFaultAddress, file=dump)
print('\nAuxilary fault address register: 0x%0.8x' % fault_regs.AuxFaultStatus, file=dump)
dump.close()
# return chip name and RPM branch
return [target_chip.get('num', '????')]#, re.compile(regex).match(QC_IMAGE_VERSION).group()]