mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-05 19:10:13 +00:00
4583c00236
The patman directory has a number of modules which are used by other tools in U-Boot. This makes it hard to package the tools using pypi since the common files must be copied along with the tool that uses them. To address this, move these files into a new u_boot_pylib library. This can be packaged separately and listed as a dependency of each tool. Signed-off-by: Simon Glass <sjg@chromium.org>
562 lines
19 KiB
Python
562 lines
19 KiB
Python
# SPDX-License-Identifier: GPL-2.0+
|
|
# Copyright (c) 2016 Google, Inc
|
|
# Written by Simon Glass <sjg@chromium.org>
|
|
#
|
|
# Handle various things related to ELF images
|
|
#
|
|
|
|
from collections import namedtuple, OrderedDict
|
|
import io
|
|
import os
|
|
import re
|
|
import shutil
|
|
import struct
|
|
import tempfile
|
|
|
|
from u_boot_pylib import command
|
|
from u_boot_pylib import tools
|
|
from u_boot_pylib import tout
|
|
|
|
ELF_TOOLS = True
|
|
try:
|
|
from elftools.elf.elffile import ELFFile
|
|
from elftools.elf.elffile import ELFError
|
|
from elftools.elf.sections import SymbolTableSection
|
|
except: # pragma: no cover
|
|
ELF_TOOLS = False
|
|
|
|
# BSYM in little endian, keep in sync with include/binman_sym.h
|
|
BINMAN_SYM_MAGIC_VALUE = 0x4d595342
|
|
|
|
# Information about an EFL symbol:
|
|
# section (str): Name of the section containing this symbol
|
|
# address (int): Address of the symbol (its value)
|
|
# size (int): Size of the symbol in bytes
|
|
# weak (bool): True if the symbol is weak
|
|
# offset (int or None): Offset of the symbol's data in the ELF file, or None if
|
|
# not known
|
|
Symbol = namedtuple('Symbol', ['section', 'address', 'size', 'weak', 'offset'])
|
|
|
|
# Information about an ELF file:
|
|
# data: Extracted program contents of ELF file (this would be loaded by an
|
|
# ELF loader when reading this file
|
|
# load: Load address of code
|
|
# entry: Entry address of code
|
|
# memsize: Number of bytes in memory occupied by loading this ELF file
|
|
ElfInfo = namedtuple('ElfInfo', ['data', 'load', 'entry', 'memsize'])
|
|
|
|
|
|
def GetSymbols(fname, patterns):
|
|
"""Get the symbols from an ELF file
|
|
|
|
Args:
|
|
fname: Filename of the ELF file to read
|
|
patterns: List of regex patterns to search for, each a string
|
|
|
|
Returns:
|
|
None, if the file does not exist, or Dict:
|
|
key: Name of symbol
|
|
value: Hex value of symbol
|
|
"""
|
|
stdout = tools.run('objdump', '-t', fname)
|
|
lines = stdout.splitlines()
|
|
if patterns:
|
|
re_syms = re.compile('|'.join(patterns))
|
|
else:
|
|
re_syms = None
|
|
syms = {}
|
|
syms_started = False
|
|
for line in lines:
|
|
if not line or not syms_started:
|
|
if 'SYMBOL TABLE' in line:
|
|
syms_started = True
|
|
line = None # Otherwise code coverage complains about 'continue'
|
|
continue
|
|
if re_syms and not re_syms.search(line):
|
|
continue
|
|
|
|
space_pos = line.find(' ')
|
|
value, rest = line[:space_pos], line[space_pos + 1:]
|
|
flags = rest[:7]
|
|
parts = rest[7:].split()
|
|
section, size = parts[:2]
|
|
if len(parts) > 2:
|
|
name = parts[2] if parts[2] != '.hidden' else parts[3]
|
|
syms[name] = Symbol(section, int(value, 16), int(size, 16),
|
|
flags[1] == 'w', None)
|
|
|
|
# Sort dict by address
|
|
return OrderedDict(sorted(syms.items(), key=lambda x: x[1].address))
|
|
|
|
def _GetFileOffset(elf, addr):
|
|
"""Get the file offset for an address
|
|
|
|
Args:
|
|
elf (ELFFile): ELF file to check
|
|
addr (int): Address to search for
|
|
|
|
Returns
|
|
int: Offset of that address in the ELF file, or None if not valid
|
|
"""
|
|
for seg in elf.iter_segments():
|
|
seg_end = seg['p_vaddr'] + seg['p_filesz']
|
|
if seg.header['p_type'] == 'PT_LOAD':
|
|
if addr >= seg['p_vaddr'] and addr < seg_end:
|
|
return addr - seg['p_vaddr'] + seg['p_offset']
|
|
|
|
def GetFileOffset(fname, addr):
|
|
"""Get the file offset for an address
|
|
|
|
Args:
|
|
fname (str): Filename of ELF file to check
|
|
addr (int): Address to search for
|
|
|
|
Returns
|
|
int: Offset of that address in the ELF file, or None if not valid
|
|
"""
|
|
if not ELF_TOOLS:
|
|
raise ValueError("Python: No module named 'elftools'")
|
|
with open(fname, 'rb') as fd:
|
|
elf = ELFFile(fd)
|
|
return _GetFileOffset(elf, addr)
|
|
|
|
def GetSymbolFromAddress(fname, addr):
|
|
"""Get the symbol at a particular address
|
|
|
|
Args:
|
|
fname (str): Filename of ELF file to check
|
|
addr (int): Address to search for
|
|
|
|
Returns:
|
|
str: Symbol name, or None if no symbol at that address
|
|
"""
|
|
if not ELF_TOOLS:
|
|
raise ValueError("Python: No module named 'elftools'")
|
|
with open(fname, 'rb') as fd:
|
|
elf = ELFFile(fd)
|
|
syms = GetSymbols(fname, None)
|
|
for name, sym in syms.items():
|
|
if sym.address == addr:
|
|
return name
|
|
|
|
def GetSymbolFileOffset(fname, patterns):
|
|
"""Get the symbols from an ELF file
|
|
|
|
Args:
|
|
fname: Filename of the ELF file to read
|
|
patterns: List of regex patterns to search for, each a string
|
|
|
|
Returns:
|
|
None, if the file does not exist, or Dict:
|
|
key: Name of symbol
|
|
value: Hex value of symbol
|
|
"""
|
|
if not ELF_TOOLS:
|
|
raise ValueError("Python: No module named 'elftools'")
|
|
|
|
syms = {}
|
|
with open(fname, 'rb') as fd:
|
|
elf = ELFFile(fd)
|
|
|
|
re_syms = re.compile('|'.join(patterns))
|
|
for section in elf.iter_sections():
|
|
if isinstance(section, SymbolTableSection):
|
|
for symbol in section.iter_symbols():
|
|
if not re_syms or re_syms.search(symbol.name):
|
|
addr = symbol.entry['st_value']
|
|
syms[symbol.name] = Symbol(
|
|
section.name, addr, symbol.entry['st_size'],
|
|
symbol.entry['st_info']['bind'] == 'STB_WEAK',
|
|
_GetFileOffset(elf, addr))
|
|
|
|
# Sort dict by address
|
|
return OrderedDict(sorted(syms.items(), key=lambda x: x[1].address))
|
|
|
|
def GetSymbolAddress(fname, sym_name):
|
|
"""Get a value of a symbol from an ELF file
|
|
|
|
Args:
|
|
fname: Filename of the ELF file to read
|
|
patterns: List of regex patterns to search for, each a string
|
|
|
|
Returns:
|
|
Symbol value (as an integer) or None if not found
|
|
"""
|
|
syms = GetSymbols(fname, [sym_name])
|
|
sym = syms.get(sym_name)
|
|
if not sym:
|
|
return None
|
|
return sym.address
|
|
|
|
def GetPackString(sym, msg):
|
|
"""Get the struct.pack/unpack string to use with a given symbol
|
|
|
|
Args:
|
|
sym (Symbol): Symbol to check. Only the size member is checked
|
|
@msg (str): String which indicates the entry being processed, used for
|
|
errors
|
|
|
|
Returns:
|
|
str: struct string to use, .e.g. '<I'
|
|
|
|
Raises:
|
|
ValueError: Symbol has an unexpected size
|
|
"""
|
|
if sym.size == 4:
|
|
return '<I'
|
|
elif sym.size == 8:
|
|
return '<Q'
|
|
else:
|
|
raise ValueError('%s has size %d: only 4 and 8 are supported' %
|
|
(msg, sym.size))
|
|
|
|
def GetSymbolOffset(elf_fname, sym_name, base_sym=None):
|
|
"""Read the offset of a symbol compared to base symbol
|
|
|
|
This is useful for obtaining the value of a single symbol relative to the
|
|
base of a binary blob.
|
|
|
|
Args:
|
|
elf_fname: Filename of the ELF file to read
|
|
sym_name (str): Name of symbol to read
|
|
base_sym (str): Base symbol to sue to calculate the offset (or None to
|
|
use '__image_copy_start'
|
|
|
|
Returns:
|
|
int: Offset of the symbol relative to the base symbol
|
|
"""
|
|
if not base_sym:
|
|
base_sym = '__image_copy_start'
|
|
fname = tools.get_input_filename(elf_fname)
|
|
syms = GetSymbols(fname, [base_sym, sym_name])
|
|
base = syms[base_sym].address
|
|
val = syms[sym_name].address
|
|
return val - base
|
|
|
|
def LookupAndWriteSymbols(elf_fname, entry, section, is_elf=False,
|
|
base_sym=None):
|
|
"""Replace all symbols in an entry with their correct values
|
|
|
|
The entry contents is updated so that values for referenced symbols will be
|
|
visible at run time. This is done by finding out the symbols offsets in the
|
|
entry (using the ELF file) and replacing them with values from binman's data
|
|
structures.
|
|
|
|
Args:
|
|
elf_fname: Filename of ELF image containing the symbol information for
|
|
entry
|
|
entry: Entry to process
|
|
section: Section which can be used to lookup symbol values
|
|
base_sym: Base symbol marking the start of the image
|
|
"""
|
|
if not base_sym:
|
|
base_sym = '__image_copy_start'
|
|
fname = tools.get_input_filename(elf_fname)
|
|
syms = GetSymbols(fname, ['image', 'binman'])
|
|
if is_elf:
|
|
if not ELF_TOOLS:
|
|
msg = ("Section '%s': entry '%s'" %
|
|
(section.GetPath(), entry.GetPath()))
|
|
raise ValueError(f'{msg}: Cannot write symbols to an ELF file without Python elftools')
|
|
new_syms = {}
|
|
with open(fname, 'rb') as fd:
|
|
elf = ELFFile(fd)
|
|
for name, sym in syms.items():
|
|
offset = _GetFileOffset(elf, sym.address)
|
|
new_syms[name] = Symbol(sym.section, sym.address, sym.size,
|
|
sym.weak, offset)
|
|
syms = new_syms
|
|
|
|
if not syms:
|
|
tout.debug('LookupAndWriteSymbols: no syms')
|
|
return
|
|
base = syms.get(base_sym)
|
|
if not base and not is_elf:
|
|
tout.debug('LookupAndWriteSymbols: no base')
|
|
return
|
|
base_addr = 0 if is_elf else base.address
|
|
for name, sym in syms.items():
|
|
if name.startswith('_binman'):
|
|
msg = ("Section '%s': Symbol '%s'\n in entry '%s'" %
|
|
(section.GetPath(), name, entry.GetPath()))
|
|
if is_elf:
|
|
# For ELF files, use the file offset
|
|
offset = sym.offset
|
|
else:
|
|
# For blobs use the offset of the symbol, calculated by
|
|
# subtracting the base address which by definition is at the
|
|
# start
|
|
offset = sym.address - base.address
|
|
if offset < 0 or offset + sym.size > entry.contents_size:
|
|
raise ValueError('%s has offset %x (size %x) but the contents '
|
|
'size is %x' % (entry.GetPath(), offset,
|
|
sym.size,
|
|
entry.contents_size))
|
|
pack_string = GetPackString(sym, msg)
|
|
if name == '_binman_sym_magic':
|
|
value = BINMAN_SYM_MAGIC_VALUE
|
|
else:
|
|
# Look up the symbol in our entry tables.
|
|
value = section.GetImage().LookupImageSymbol(name, sym.weak,
|
|
msg, base_addr)
|
|
if value is None:
|
|
value = -1
|
|
pack_string = pack_string.lower()
|
|
value_bytes = struct.pack(pack_string, value)
|
|
tout.debug('%s:\n insert %s, offset %x, value %x, length %d' %
|
|
(msg, name, offset, value, len(value_bytes)))
|
|
entry.data = (entry.data[:offset] + value_bytes +
|
|
entry.data[offset + sym.size:])
|
|
|
|
def GetSymbolValue(sym, data, msg):
|
|
"""Get the value of a symbol
|
|
|
|
This can only be used on symbols with an integer value.
|
|
|
|
Args:
|
|
sym (Symbol): Symbol to check
|
|
data (butes): Data for the ELF file - the symbol data appears at offset
|
|
sym.offset
|
|
@msg (str): String which indicates the entry being processed, used for
|
|
errors
|
|
|
|
Returns:
|
|
int: Value of the symbol
|
|
|
|
Raises:
|
|
ValueError: Symbol has an unexpected size
|
|
"""
|
|
pack_string = GetPackString(sym, msg)
|
|
value = struct.unpack(pack_string, data[sym.offset:sym.offset + sym.size])
|
|
return value[0]
|
|
|
|
def MakeElf(elf_fname, text, data):
|
|
"""Make an elf file with the given data in a single section
|
|
|
|
The output file has a several section including '.text' and '.data',
|
|
containing the info provided in arguments.
|
|
|
|
Args:
|
|
elf_fname: Output filename
|
|
text: Text (code) to put in the file's .text section
|
|
data: Data to put in the file's .data section
|
|
"""
|
|
outdir = tempfile.mkdtemp(prefix='binman.elf.')
|
|
s_file = os.path.join(outdir, 'elf.S')
|
|
|
|
# Spilt the text into two parts so that we can make the entry point two
|
|
# bytes after the start of the text section
|
|
text_bytes1 = ['\t.byte\t%#x' % byte for byte in text[:2]]
|
|
text_bytes2 = ['\t.byte\t%#x' % byte for byte in text[2:]]
|
|
data_bytes = ['\t.byte\t%#x' % byte for byte in data]
|
|
with open(s_file, 'w') as fd:
|
|
print('''/* Auto-generated C program to produce an ELF file for testing */
|
|
|
|
.section .text
|
|
.code32
|
|
.globl _start
|
|
.type _start, @function
|
|
%s
|
|
_start:
|
|
%s
|
|
.ident "comment"
|
|
|
|
.comm fred,8,4
|
|
|
|
.section .empty
|
|
.globl _empty
|
|
_empty:
|
|
.byte 1
|
|
|
|
.globl ernie
|
|
.data
|
|
.type ernie, @object
|
|
.size ernie, 4
|
|
ernie:
|
|
%s
|
|
''' % ('\n'.join(text_bytes1), '\n'.join(text_bytes2), '\n'.join(data_bytes)),
|
|
file=fd)
|
|
lds_file = os.path.join(outdir, 'elf.lds')
|
|
|
|
# Use a linker script to set the alignment and text address.
|
|
with open(lds_file, 'w') as fd:
|
|
print('''/* Auto-generated linker script to produce an ELF file for testing */
|
|
|
|
PHDRS
|
|
{
|
|
text PT_LOAD ;
|
|
data PT_LOAD ;
|
|
empty PT_LOAD FLAGS ( 6 ) ;
|
|
note PT_NOTE ;
|
|
}
|
|
|
|
SECTIONS
|
|
{
|
|
. = 0xfef20000;
|
|
ENTRY(_start)
|
|
.text . : SUBALIGN(0)
|
|
{
|
|
*(.text)
|
|
} :text
|
|
.data : {
|
|
*(.data)
|
|
} :data
|
|
_bss_start = .;
|
|
.empty : {
|
|
*(.empty)
|
|
} :empty
|
|
/DISCARD/ : {
|
|
*(.note.gnu.property)
|
|
}
|
|
.note : {
|
|
*(.comment)
|
|
} :note
|
|
.bss _bss_start (OVERLAY) : {
|
|
*(.bss)
|
|
}
|
|
}
|
|
''', file=fd)
|
|
# -static: Avoid requiring any shared libraries
|
|
# -nostdlib: Don't link with C library
|
|
# -Wl,--build-id=none: Don't generate a build ID, so that we just get the
|
|
# text section at the start
|
|
# -m32: Build for 32-bit x86
|
|
# -T...: Specifies the link script, which sets the start address
|
|
cc, args = tools.get_target_compile_tool('cc')
|
|
args += ['-static', '-nostdlib', '-Wl,--build-id=none', '-m32', '-T',
|
|
lds_file, '-o', elf_fname, s_file]
|
|
stdout = command.output(cc, *args)
|
|
shutil.rmtree(outdir)
|
|
|
|
def DecodeElf(data, location):
|
|
"""Decode an ELF file and return information about it
|
|
|
|
Args:
|
|
data: Data from ELF file
|
|
location: Start address of data to return
|
|
|
|
Returns:
|
|
ElfInfo object containing information about the decoded ELF file
|
|
"""
|
|
file_size = len(data)
|
|
with io.BytesIO(data) as fd:
|
|
elf = ELFFile(fd)
|
|
data_start = 0xffffffff;
|
|
data_end = 0;
|
|
mem_end = 0;
|
|
virt_to_phys = 0;
|
|
|
|
for i in range(elf.num_segments()):
|
|
segment = elf.get_segment(i)
|
|
if segment['p_type'] != 'PT_LOAD' or not segment['p_memsz']:
|
|
skipped = 1 # To make code-coverage see this line
|
|
continue
|
|
start = segment['p_paddr']
|
|
mend = start + segment['p_memsz']
|
|
rend = start + segment['p_filesz']
|
|
data_start = min(data_start, start)
|
|
data_end = max(data_end, rend)
|
|
mem_end = max(mem_end, mend)
|
|
if not virt_to_phys:
|
|
virt_to_phys = segment['p_paddr'] - segment['p_vaddr']
|
|
|
|
output = bytearray(data_end - data_start)
|
|
for i in range(elf.num_segments()):
|
|
segment = elf.get_segment(i)
|
|
if segment['p_type'] != 'PT_LOAD' or not segment['p_memsz']:
|
|
skipped = 1 # To make code-coverage see this line
|
|
continue
|
|
start = segment['p_paddr']
|
|
offset = 0
|
|
if start < location:
|
|
offset = location - start
|
|
start = location
|
|
# A legal ELF file can have a program header with non-zero length
|
|
# but zero-length file size and a non-zero offset which, added
|
|
# together, are greater than input->size (i.e. the total file size).
|
|
# So we need to not even test in the case that p_filesz is zero.
|
|
# Note: All of this code is commented out since we don't have a test
|
|
# case for it.
|
|
size = segment['p_filesz']
|
|
#if not size:
|
|
#continue
|
|
#end = segment['p_offset'] + segment['p_filesz']
|
|
#if end > file_size:
|
|
#raise ValueError('Underflow copying out the segment. File has %#x bytes left, segment end is %#x\n',
|
|
#file_size, end)
|
|
output[start - data_start:start - data_start + size] = (
|
|
segment.data()[offset:])
|
|
return ElfInfo(output, data_start, elf.header['e_entry'] + virt_to_phys,
|
|
mem_end - data_start)
|
|
|
|
def UpdateFile(infile, outfile, start_sym, end_sym, insert):
|
|
tout.notice("Creating file '%s' with data length %#x (%d) between symbols '%s' and '%s'" %
|
|
(outfile, len(insert), len(insert), start_sym, end_sym))
|
|
syms = GetSymbolFileOffset(infile, [start_sym, end_sym])
|
|
if len(syms) != 2:
|
|
raise ValueError("Expected two symbols '%s' and '%s': got %d: %s" %
|
|
(start_sym, end_sym, len(syms),
|
|
','.join(syms.keys())))
|
|
|
|
size = syms[end_sym].offset - syms[start_sym].offset
|
|
if len(insert) > size:
|
|
raise ValueError("Not enough space in '%s' for data length %#x (%d); size is %#x (%d)" %
|
|
(infile, len(insert), len(insert), size, size))
|
|
|
|
data = tools.read_file(infile)
|
|
newdata = data[:syms[start_sym].offset]
|
|
newdata += insert + tools.get_bytes(0, size - len(insert))
|
|
newdata += data[syms[end_sym].offset:]
|
|
tools.write_file(outfile, newdata)
|
|
tout.info('Written to offset %#x' % syms[start_sym].offset)
|
|
|
|
def read_loadable_segments(data):
|
|
"""Read segments from an ELF file
|
|
|
|
Args:
|
|
data (bytes): Contents of file
|
|
|
|
Returns:
|
|
tuple:
|
|
list of segments, each:
|
|
int: Segment number (0 = first)
|
|
int: Start address of segment in memory
|
|
bytes: Contents of segment
|
|
int: entry address for image
|
|
|
|
Raises:
|
|
ValueError: elftools is not available
|
|
"""
|
|
if not ELF_TOOLS:
|
|
raise ValueError("Python: No module named 'elftools'")
|
|
with io.BytesIO(data) as inf:
|
|
try:
|
|
elf = ELFFile(inf)
|
|
except ELFError as err:
|
|
raise ValueError(err)
|
|
entry = elf.header['e_entry']
|
|
segments = []
|
|
for i in range(elf.num_segments()):
|
|
segment = elf.get_segment(i)
|
|
if segment['p_type'] != 'PT_LOAD' or not segment['p_memsz']:
|
|
skipped = 1 # To make code-coverage see this line
|
|
continue
|
|
start = segment['p_offset']
|
|
rend = start + segment['p_filesz']
|
|
segments.append((i, segment['p_paddr'], data[start:rend]))
|
|
return segments, entry
|
|
|
|
def is_valid(data):
|
|
"""Check if some binary data is a valid ELF file
|
|
|
|
Args:
|
|
data (bytes): Bytes to check
|
|
|
|
Returns:
|
|
bool: True if a valid Elf file, False if not
|
|
"""
|
|
try:
|
|
DecodeElf(data, 0)
|
|
return True
|
|
except ELFError:
|
|
return False
|