Revamp cbmem.py to use the coreboot tables.
This change makes significant changes to cbmem.py to make it use the coreboot tables to find the memory console and timestamp areas instead of looking for the in memory table TOC structure. That appears to be more robust and gets cbmem.py working again after some unrelated changes that affected memory layout. It also introduces some small infrastructure to make accessing C style structures in physical memory easier and more transparent. Change-Id: I51833055a50c2d76423520ba6e059bf8fc50adea Signed-off-by: Gabe Black <gabeblack@google.com> Reviewed-on: http://review.coreboot.org/762 Tested-by: build bot (Jenkins) Reviewed-by: Ronald G. Minnich <rminnich@gmail.com>
This commit is contained in:
Gabe Black
Stefan Reinauer
parent
67aa3d6b87
commit
5d3438de41
|
|
@ -33,29 +33,46 @@ console sections.
|
|||
'''
|
||||
|
||||
import mmap
|
||||
import re
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
# These definitions follow src/include/cbmem.h
|
||||
CBMEM_MAGIC = 0x434f5245
|
||||
CBMEM_MAX_ENTRIES = 16
|
||||
def get_phys_mem(addr, size):
|
||||
'''Read size bytes from address addr by mmaping /dev/mem'''
|
||||
|
||||
CBMEM_ENTRY_FORMAT = '@LLQQ'
|
||||
CONSOLE_HEADER_FORMAT = '@LL'
|
||||
TIMESTAMP_HEADER_FORMAT = '@QLL'
|
||||
TIMESTAMP_ENTRY_FORMAT = '@LQ'
|
||||
mf = open("/dev/mem")
|
||||
delta = addr % 4096
|
||||
mm = mmap.mmap(mf.fileno(), size + delta,
|
||||
mmap.MAP_PRIVATE, offset=(addr - delta))
|
||||
buf = mm.read(size + delta)
|
||||
mf.close()
|
||||
return buf[delta:]
|
||||
|
||||
mf_fileno = 0 # File number of the file providing access to memory.
|
||||
# This class and metaclass make it easier to define and access structures
|
||||
# which live in physical memory. To use them, inherit from CStruct and define
|
||||
# a class member called struct_members which is a tuple of pairs. The first
|
||||
# item in the pair is the type format specifier that should be used with
|
||||
# struct.unpack to read that member from memory. The second item is the name
|
||||
# that member should have in the resulting object.
|
||||
|
||||
def align_up(base, alignment):
|
||||
'''Increment to the alignment boundary.
|
||||
class MetaCStruct(type):
|
||||
def __init__(cls, name, bases, dct):
|
||||
struct_members = dct["struct_members"]
|
||||
cls.struct_fmt = "@"
|
||||
for char, name in struct_members:
|
||||
cls.struct_fmt += char
|
||||
cls.struct_len = struct.calcsize(cls.struct_fmt)
|
||||
super(MetaCStruct, cls).__init__(name, bases, dct)
|
||||
|
||||
Return the next integer larger than 'base' and divisible by 'alignment'.
|
||||
'''
|
||||
class CStruct(object):
|
||||
__metaclass__ = MetaCStruct
|
||||
struct_members = ()
|
||||
|
||||
return base + alignment - base % alignment
|
||||
def __init__(self, addr):
|
||||
self.raw_memory = get_phys_mem(addr, self.struct_len)
|
||||
values = struct.unpack(self.struct_fmt, self.raw_memory)
|
||||
names = (name for char, name in self.struct_members)
|
||||
for name, value in zip(names, values):
|
||||
setattr(self, name, value)
|
||||
|
||||
def normalize_timer(value, freq):
|
||||
'''Convert timer reading into microseconds.
|
||||
|
|
@ -96,109 +113,141 @@ def get_cpu_freq():
|
|||
# Convert reading into Hertz
|
||||
return float(freq_str) * 1000.0
|
||||
|
||||
def get_mem_size():
|
||||
'''Retrieve amount of memory available to the CPU from /proc/meminfo.'''
|
||||
mult = {
|
||||
'kB': 1024
|
||||
}
|
||||
meminfo = open('/proc/meminfo').read()
|
||||
m = re.search('MemTotal:.*\n', meminfo)
|
||||
mem_string = re.search('MemTotal:.*\n', meminfo).group(0)
|
||||
(_, size, mult_name) = mem_string.split()
|
||||
return int(size) * mult[mult_name]
|
||||
|
||||
def parse_mem_at(addr, format):
|
||||
'''Read and parse a memory location.
|
||||
|
||||
This function reads memory at the passed in address, parses it according
|
||||
to the passed in format specification and returns a list of values.
|
||||
|
||||
The first value in the list is the size of data matching the format
|
||||
expression, and the rest of the elements of the list are the actual values
|
||||
retrieved using the format.
|
||||
'''
|
||||
|
||||
size = struct.calcsize(format)
|
||||
delta = addr % 4096 # mmap requires the offset to be page size aligned.
|
||||
mm = mmap.mmap(mf_fileno, size + delta,
|
||||
mmap.MAP_PRIVATE, offset=(addr - delta))
|
||||
buf = mm.read(size + delta)
|
||||
mm.close()
|
||||
rv = [size,] + list(struct.unpack(format, buf[delta:size + delta + 1]))
|
||||
return rv
|
||||
|
||||
def dprint(text):
|
||||
'''Debug print function.
|
||||
|
||||
Edit it to get the debug output.
|
||||
'''
|
||||
|
||||
if False:
|
||||
print text
|
||||
|
||||
def process_timers(base):
|
||||
'''Scan the array of timestamps found in CBMEM at address base.
|
||||
|
||||
For each timestamp print the timer ID and the value in microseconds.
|
||||
'''
|
||||
|
||||
(step, base_time, max_entr, entr) = parse_mem_at(
|
||||
base, TIMESTAMP_HEADER_FORMAT)
|
||||
class TimestampHeader(CStruct):
|
||||
struct_members = (
|
||||
("Q", "base_time"),
|
||||
("L", "max_entr"),
|
||||
("L", "entr")
|
||||
)
|
||||
|
||||
print('\ntime base %d, total entries %d' % (base_time, entr))
|
||||
class TimestampEntry(CStruct):
|
||||
struct_members = (
|
||||
("L", "timer_id"),
|
||||
("Q", "timer_value")
|
||||
)
|
||||
|
||||
header = TimestampHeader(base)
|
||||
print('\ntime base %d, total entries %d' % (header.base_time, header.entr))
|
||||
clock_freq = get_cpu_freq()
|
||||
base = base + step
|
||||
for i in range(entr):
|
||||
(step, timer_id, timer_value) = parse_mem_at(
|
||||
base, TIMESTAMP_ENTRY_FORMAT)
|
||||
print '%d:%s ' % (timer_id, normalize_timer(timer_value, clock_freq)),
|
||||
base = base + step
|
||||
base = base + header.struct_len
|
||||
for i in range(header.entr):
|
||||
timestamp = TimestampEntry(base)
|
||||
print '%d:%s ' % (timestamp.timer_id,
|
||||
normalize_timer(timestamp.timer_value, clock_freq)),
|
||||
base = base + timestamp.struct_len
|
||||
print
|
||||
|
||||
def process_console(base):
|
||||
'''Dump the console log buffer contents found at address base.'''
|
||||
|
||||
(step, size, cursor) = parse_mem_at(base, CONSOLE_HEADER_FORMAT)
|
||||
print 'cursor at %d\n' % cursor
|
||||
class ConsoleHeader(CStruct):
|
||||
struct_members = (
|
||||
("L", "size"),
|
||||
("L", "cursor")
|
||||
)
|
||||
|
||||
cons_string_format = '%ds' % min(cursor, size)
|
||||
(_, cons_text) = parse_mem_at(base + step, cons_string_format)
|
||||
header = ConsoleHeader(base)
|
||||
print 'cursor at %d\n' % header.cursor
|
||||
|
||||
cons_addr = base + header.struct_len
|
||||
cons_length = min(header.cursor, header.size)
|
||||
cons_text = get_phys_mem(cons_addr, cons_length)
|
||||
print cons_text
|
||||
print '\n'
|
||||
|
||||
mem_alignment = 1024 * 1024 * 1024 # 1 GBytes
|
||||
table_alignment = 128 * 1024
|
||||
def ipchksum(buf):
|
||||
'''Checksumming function used on the coreboot tables. The buffer being
|
||||
checksummed is summed up as if it was an array of 16 bit unsigned
|
||||
integers. If there are an odd number of bytes, the last element is zero
|
||||
extended.'''
|
||||
|
||||
mem_size = get_mem_size()
|
||||
size = len(buf)
|
||||
odd = size % 2
|
||||
fmt = "<%dH" % ((size - odd) / 2)
|
||||
if odd:
|
||||
fmt += "B"
|
||||
shorts = struct.unpack(fmt, buf)
|
||||
checksum = sum(shorts)
|
||||
checksum = (checksum >> 16) + (checksum & 0xffff)
|
||||
checksum += (checksum >> 16)
|
||||
checksum = ~checksum & 0xffff
|
||||
return checksum
|
||||
|
||||
# start at memory address aligned at 128K.
|
||||
offset = align_up(mem_size, table_alignment)
|
||||
def parse_tables(base, length):
|
||||
'''Find the coreboot tables in memory and process whatever we can.'''
|
||||
|
||||
dprint('mem_size %x offset %x' %(mem_size, offset))
|
||||
mf = open("/dev/mem")
|
||||
mf_fileno = mf.fileno()
|
||||
class CBTableHeader(CStruct):
|
||||
struct_members = (
|
||||
("4s", "signature"),
|
||||
("I", "header_bytes"),
|
||||
("I", "header_checksum"),
|
||||
("I", "table_bytes"),
|
||||
("I", "table_checksum"),
|
||||
("I", "table_entries")
|
||||
)
|
||||
|
||||
while offset % mem_alignment: # do not cross the 1G boundary while searching
|
||||
(step, magic, mid, base, size) = parse_mem_at(offset, CBMEM_ENTRY_FORMAT)
|
||||
if magic == CBMEM_MAGIC:
|
||||
offset = offset + step
|
||||
break
|
||||
offset += table_alignment
|
||||
else:
|
||||
print 'Did not find the CBMEM'
|
||||
sys.exit(0)
|
||||
class CBTableEntry(CStruct):
|
||||
struct_members = (
|
||||
("I", "tag"),
|
||||
("I", "size")
|
||||
)
|
||||
|
||||
for i in (range(1, CBMEM_MAX_ENTRIES)):
|
||||
(_, magic, mid, base, size) = parse_mem_at(offset, CBMEM_ENTRY_FORMAT)
|
||||
if mid == 0:
|
||||
break
|
||||
class CBTableForward(CBTableEntry):
|
||||
struct_members = CBTableEntry.struct_members + (
|
||||
("Q", "forward"),
|
||||
)
|
||||
|
||||
print '%x, %x, %x' % (mid, base, size)
|
||||
if mid == 0x54494d45:
|
||||
process_timers(base)
|
||||
if mid == 0x434f4e53:
|
||||
process_console(base)
|
||||
class CBMemTab(CBTableEntry):
|
||||
struct_members = CBTableEntry.struct_members + (
|
||||
("L", "cbmem_tab"),
|
||||
)
|
||||
|
||||
offset = offset + step
|
||||
for addr in range(base, base + length, 16):
|
||||
header = CBTableHeader(addr)
|
||||
if header.signature == "LBIO":
|
||||
break
|
||||
else:
|
||||
return -1
|
||||
|
||||
mf.close()
|
||||
if header.header_bytes == 0:
|
||||
return -1
|
||||
|
||||
if ipchksum(header.raw_memory) != 0:
|
||||
print "Bad header checksum"
|
||||
return -1
|
||||
|
||||
addr += header.header_bytes
|
||||
table = get_phys_mem(addr, header.table_bytes)
|
||||
if ipchksum(table) != header.table_checksum:
|
||||
print "Bad table checksum"
|
||||
return -1
|
||||
|
||||
for i in range(header.table_entries):
|
||||
entry = CBTableEntry(addr)
|
||||
if entry.tag == 0x11: # Forwarding entry
|
||||
return parse_tables(CBTableForward(addr).forward, length)
|
||||
elif entry.tag == 0x16: # Timestamps
|
||||
process_timers(CBMemTab(addr).cbmem_tab)
|
||||
elif entry.tag == 0x17: # CBMEM console
|
||||
process_console(CBMemTab(addr).cbmem_tab)
|
||||
|
||||
addr += entry.size
|
||||
|
||||
return 0
|
||||
|
||||
def main():
|
||||
for base, length in (0x00000000, 0x1000), (0x000f0000, 0x1000):
|
||||
if parse_tables(base, length):
|
||||
break
|
||||
else:
|
||||
print "Didn't find the coreboot tables"
|
||||
return 0
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
|
|
|
|||
Loading…
Reference in New Issue