| # SPDX-License-Identifier: GPL-2.0+ |
| # Copyright 2019 Google LLC |
| # Written by Simon Glass <sjg@chromium.org> |
| |
| """Support for coreboot's CBFS format |
| |
| CBFS supports a header followed by a number of files, generally targeted at SPI |
| flash. |
| |
| The format is somewhat defined by documentation in the coreboot tree although |
| it is necessary to rely on the C structures and source code (mostly cbfstool) |
| to fully understand it. |
| |
| Currently supported: raw and stage types with compression, padding empty areas |
| with empty files, fixed-offset files |
| """ |
| |
| from collections import OrderedDict |
| import io |
| import struct |
| import sys |
| |
| from binman import comp_util |
| from binman import elf |
| from patman import command |
| from patman import tools |
| |
| # Set to True to enable printing output while working |
| DEBUG = False |
| |
| # Set to True to enable output from running cbfstool for debugging |
| VERBOSE = False |
| |
| # The master header, at the start of the CBFS |
| HEADER_FORMAT = '>IIIIIIII' |
| HEADER_LEN = 0x20 |
| HEADER_MAGIC = 0x4f524243 |
| HEADER_VERSION1 = 0x31313131 |
| HEADER_VERSION2 = 0x31313132 |
| |
| # The file header, at the start of each file in the CBFS |
| FILE_HEADER_FORMAT = b'>8sIIII' |
| FILE_HEADER_LEN = 0x18 |
| FILE_MAGIC = b'LARCHIVE' |
| FILENAME_ALIGN = 16 # Filename lengths are aligned to this |
| |
| # A stage header containing information about 'stage' files |
| # Yes this is correct: this header is in litte-endian format |
| STAGE_FORMAT = '<IQQII' |
| STAGE_LEN = 0x1c |
| |
| # An attribute describring the compression used in a file |
| ATTR_COMPRESSION_FORMAT = '>IIII' |
| ATTR_COMPRESSION_LEN = 0x10 |
| |
| # Attribute tags |
| # Depending on how the header was initialised, it may be backed with 0x00 or |
| # 0xff. Support both. |
| FILE_ATTR_TAG_UNUSED = 0 |
| FILE_ATTR_TAG_UNUSED2 = 0xffffffff |
| FILE_ATTR_TAG_COMPRESSION = 0x42435a4c |
| FILE_ATTR_TAG_HASH = 0x68736148 |
| FILE_ATTR_TAG_POSITION = 0x42435350 # PSCB |
| FILE_ATTR_TAG_ALIGNMENT = 0x42434c41 # ALCB |
| FILE_ATTR_TAG_PADDING = 0x47444150 # PDNG |
| |
| # This is 'the size of bootblock reserved in firmware image (cbfs.txt)' |
| # Not much more info is available, but we set it to 4, due to this comment in |
| # cbfstool.c: |
| # This causes 4 bytes to be left out at the end of the image, for two reasons: |
| # 1. The cbfs master header pointer resides there |
| # 2. Ssme cbfs implementations assume that an image that resides below 4GB has |
| # a bootblock and get confused when the end of the image is at 4GB == 0. |
| MIN_BOOTBLOCK_SIZE = 4 |
| |
| # Files start aligned to this boundary in the CBFS |
| ENTRY_ALIGN = 0x40 |
| |
| # CBFSs must declare an architecture since much of the logic is designed with |
| # x86 in mind. The effect of setting this value is not well documented, but in |
| # general x86 is used and this makes use of a boot block and an image that ends |
| # at the end of 32-bit address space. |
| ARCHITECTURE_UNKNOWN = 0xffffffff |
| ARCHITECTURE_X86 = 0x00000001 |
| ARCHITECTURE_ARM = 0x00000010 |
| ARCHITECTURE_AARCH64 = 0x0000aa64 |
| ARCHITECTURE_MIPS = 0x00000100 |
| ARCHITECTURE_RISCV = 0xc001d0de |
| ARCHITECTURE_PPC64 = 0x407570ff |
| |
| ARCH_NAMES = { |
| ARCHITECTURE_UNKNOWN : 'unknown', |
| ARCHITECTURE_X86 : 'x86', |
| ARCHITECTURE_ARM : 'arm', |
| ARCHITECTURE_AARCH64 : 'arm64', |
| ARCHITECTURE_MIPS : 'mips', |
| ARCHITECTURE_RISCV : 'riscv', |
| ARCHITECTURE_PPC64 : 'ppc64', |
| } |
| |
| # File types. Only supported ones are included here |
| TYPE_CBFSHEADER = 0x02 # Master header, HEADER_FORMAT |
| TYPE_STAGE = 0x10 # Stage, holding an executable, see STAGE_FORMAT |
| TYPE_RAW = 0x50 # Raw file, possibly compressed |
| TYPE_EMPTY = 0xffffffff # Empty data |
| |
| # Compression types |
| COMPRESS_NONE, COMPRESS_LZMA, COMPRESS_LZ4 = range(3) |
| |
| COMPRESS_NAMES = { |
| COMPRESS_NONE : 'none', |
| COMPRESS_LZMA : 'lzma', |
| COMPRESS_LZ4 : 'lz4', |
| } |
| |
| def find_arch(find_name): |
| """Look up an architecture name |
| |
| Args: |
| find_name: Architecture name to find |
| |
| Returns: |
| ARCHITECTURE_... value or None if not found |
| """ |
| for arch, name in ARCH_NAMES.items(): |
| if name == find_name: |
| return arch |
| return None |
| |
| def find_compress(find_name): |
| """Look up a compression algorithm name |
| |
| Args: |
| find_name: Compression algorithm name to find |
| |
| Returns: |
| COMPRESS_... value or None if not found |
| """ |
| for compress, name in COMPRESS_NAMES.items(): |
| if name == find_name: |
| return compress |
| return None |
| |
| def compress_name(compress): |
| """Look up the name of a compression algorithm |
| |
| Args: |
| compress: Compression algorithm number to find (COMPRESS_...) |
| |
| Returns: |
| Compression algorithm name (string) |
| |
| Raises: |
| KeyError if the algorithm number is invalid |
| """ |
| return COMPRESS_NAMES[compress] |
| |
| def align_int(val, align): |
| """Align a value up to the given alignment |
| |
| Args: |
| val: Integer value to align |
| align: Integer alignment value (e.g. 4 to align to 4-byte boundary) |
| |
| Returns: |
| integer value aligned to the required boundary, rounding up if necessary |
| """ |
| return int((val + align - 1) / align) * align |
| |
| def align_int_down(val, align): |
| """Align a value down to the given alignment |
| |
| Args: |
| val: Integer value to align |
| align: Integer alignment value (e.g. 4 to align to 4-byte boundary) |
| |
| Returns: |
| integer value aligned to the required boundary, rounding down if |
| necessary |
| """ |
| return int(val / align) * align |
| |
| def _pack_string(instr): |
| """Pack a string to the required aligned size by adding padding |
| |
| Args: |
| instr: String to process |
| |
| Returns: |
| String with required padding (at least one 0x00 byte) at the end |
| """ |
| val = tools.ToBytes(instr) |
| pad_len = align_int(len(val) + 1, FILENAME_ALIGN) |
| return val + tools.GetBytes(0, pad_len - len(val)) |
| |
| |
| class CbfsFile(object): |
| """Class to represent a single CBFS file |
| |
| This is used to hold the information about a file, including its contents. |
| Use the get_data_and_offset() method to obtain the raw output for writing to |
| CBFS. |
| |
| Properties: |
| name: Name of file |
| offset: Offset of file data from start of file header |
| cbfs_offset: Offset of file data in bytes from start of CBFS, or None to |
| place this file anyway |
| data: Contents of file, uncompressed |
| orig_data: Original data added to the file, possibly compressed |
| data_len: Length of (possibly compressed) data in bytes |
| ftype: File type (TYPE_...) |
| compression: Compression type (COMPRESS_...) |
| memlen: Length of data in memory, i.e. the uncompressed length, None if |
| no compression algortihm is selected |
| load: Load address in memory if known, else None |
| entry: Entry address in memory if known, else None. This is where |
| execution starts after the file is loaded |
| base_address: Base address to use for 'stage' files |
| erase_byte: Erase byte to use for padding between the file header and |
| contents (used for empty files) |
| size: Size of the file in bytes (used for empty files) |
| """ |
| def __init__(self, name, ftype, data, cbfs_offset, compress=COMPRESS_NONE): |
| self.name = name |
| self.offset = None |
| self.cbfs_offset = cbfs_offset |
| self.data = data |
| self.orig_data = data |
| self.ftype = ftype |
| self.compress = compress |
| self.memlen = None |
| self.load = None |
| self.entry = None |
| self.base_address = None |
| self.data_len = len(data) |
| self.erase_byte = None |
| self.size = None |
| |
| def decompress(self): |
| """Handle decompressing data if necessary""" |
| indata = self.data |
| if self.compress == COMPRESS_LZ4: |
| data = comp_util.decompress(indata, 'lz4', with_header=False) |
| elif self.compress == COMPRESS_LZMA: |
| data = comp_util.decompress(indata, 'lzma', with_header=False) |
| else: |
| data = indata |
| self.memlen = len(data) |
| self.data = data |
| self.data_len = len(indata) |
| |
| @classmethod |
| def stage(cls, base_address, name, data, cbfs_offset): |
| """Create a new stage file |
| |
| Args: |
| base_address: Int base address for memory-mapping of ELF file |
| name: String file name to put in CBFS (does not need to correspond |
| to the name that the file originally came from) |
| data: Contents of file |
| cbfs_offset: Offset of file data in bytes from start of CBFS, or |
| None to place this file anyway |
| |
| Returns: |
| CbfsFile object containing the file information |
| """ |
| cfile = CbfsFile(name, TYPE_STAGE, data, cbfs_offset) |
| cfile.base_address = base_address |
| return cfile |
| |
| @classmethod |
| def raw(cls, name, data, cbfs_offset, compress): |
| """Create a new raw file |
| |
| Args: |
| name: String file name to put in CBFS (does not need to correspond |
| to the name that the file originally came from) |
| data: Contents of file |
| cbfs_offset: Offset of file data in bytes from start of CBFS, or |
| None to place this file anyway |
| compress: Compression algorithm to use (COMPRESS_...) |
| |
| Returns: |
| CbfsFile object containing the file information |
| """ |
| return CbfsFile(name, TYPE_RAW, data, cbfs_offset, compress) |
| |
| @classmethod |
| def empty(cls, space_to_use, erase_byte): |
| """Create a new empty file of a given size |
| |
| Args: |
| space_to_use:: Size of available space, which must be at least as |
| large as the alignment size for this CBFS |
| erase_byte: Byte to use for contents of file (repeated through the |
| whole file) |
| |
| Returns: |
| CbfsFile object containing the file information |
| """ |
| cfile = CbfsFile('', TYPE_EMPTY, b'', None) |
| cfile.size = space_to_use - FILE_HEADER_LEN - FILENAME_ALIGN |
| cfile.erase_byte = erase_byte |
| return cfile |
| |
| def calc_start_offset(self): |
| """Check if this file needs to start at a particular offset in CBFS |
| |
| Returns: |
| None if the file can be placed anywhere, or |
| the largest offset where the file could start (integer) |
| """ |
| if self.cbfs_offset is None: |
| return None |
| return self.cbfs_offset - self.get_header_len() |
| |
| def get_header_len(self): |
| """Get the length of headers required for a file |
| |
| This is the minimum length required before the actual data for this file |
| could start. It might start later if there is padding. |
| |
| Returns: |
| Total length of all non-data fields, in bytes |
| """ |
| name = _pack_string(self.name) |
| hdr_len = len(name) + FILE_HEADER_LEN |
| if self.ftype == TYPE_STAGE: |
| pass |
| elif self.ftype == TYPE_RAW: |
| hdr_len += ATTR_COMPRESSION_LEN |
| elif self.ftype == TYPE_EMPTY: |
| pass |
| else: |
| raise ValueError('Unknown file type %#x\n' % self.ftype) |
| return hdr_len |
| |
| def get_data_and_offset(self, offset=None, pad_byte=None): |
| """Obtain the contents of the file, in CBFS format and the offset of |
| the data within the file |
| |
| Returns: |
| tuple: |
| bytes representing the contents of this file, packed and aligned |
| for directly inserting into the final CBFS output |
| offset to the file data from the start of the returned data. |
| """ |
| name = _pack_string(self.name) |
| hdr_len = len(name) + FILE_HEADER_LEN |
| attr_pos = 0 |
| content = b'' |
| attr = b'' |
| pad = b'' |
| data = self.data |
| if self.ftype == TYPE_STAGE: |
| elf_data = elf.DecodeElf(data, self.base_address) |
| content = struct.pack(STAGE_FORMAT, self.compress, |
| elf_data.entry, elf_data.load, |
| len(elf_data.data), elf_data.memsize) |
| data = elf_data.data |
| elif self.ftype == TYPE_RAW: |
| orig_data = data |
| if self.compress == COMPRESS_LZ4: |
| data = comp_util.compress(orig_data, 'lz4', with_header=False) |
| elif self.compress == COMPRESS_LZMA: |
| data = comp_util.compress(orig_data, 'lzma', with_header=False) |
| self.memlen = len(orig_data) |
| self.data_len = len(data) |
| attr = struct.pack(ATTR_COMPRESSION_FORMAT, |
| FILE_ATTR_TAG_COMPRESSION, ATTR_COMPRESSION_LEN, |
| self.compress, self.memlen) |
| elif self.ftype == TYPE_EMPTY: |
| data = tools.GetBytes(self.erase_byte, self.size) |
| else: |
| raise ValueError('Unknown type %#x when writing\n' % self.ftype) |
| if attr: |
| attr_pos = hdr_len |
| hdr_len += len(attr) |
| if self.cbfs_offset is not None: |
| pad_len = self.cbfs_offset - offset - hdr_len |
| if pad_len < 0: # pragma: no cover |
| # Test coverage of this is not available since this should never |
| # happen. It indicates that get_header_len() provided an |
| # incorrect value (too small) so that we decided that we could |
| # put this file at the requested place, but in fact a previous |
| # file extends far enough into the CBFS that this is not |
| # possible. |
| raise ValueError("Internal error: CBFS file '%s': Requested offset %#x but current output position is %#x" % |
| (self.name, self.cbfs_offset, offset)) |
| pad = tools.GetBytes(pad_byte, pad_len) |
| hdr_len += pad_len |
| |
| # This is the offset of the start of the file's data, |
| size = len(content) + len(data) |
| hdr = struct.pack(FILE_HEADER_FORMAT, FILE_MAGIC, size, |
| self.ftype, attr_pos, hdr_len) |
| |
| # Do a sanity check of the get_header_len() function, to ensure that it |
| # stays in lockstep with this function |
| expected_len = self.get_header_len() |
| actual_len = len(hdr + name + attr) |
| if expected_len != actual_len: # pragma: no cover |
| # Test coverage of this is not available since this should never |
| # happen. It probably indicates that get_header_len() is broken. |
| raise ValueError("Internal error: CBFS file '%s': Expected headers of %#x bytes, got %#d" % |
| (self.name, expected_len, actual_len)) |
| return hdr + name + attr + pad + content + data, hdr_len |
| |
| |
| class CbfsWriter(object): |
| """Class to handle writing a Coreboot File System (CBFS) |
| |
| Usage is something like: |
| |
| cbw = CbfsWriter(size) |
| cbw.add_file_raw('u-boot', tools.ReadFile('u-boot.bin')) |
| ... |
| data, cbfs_offset = cbw.get_data_and_offset() |
| |
| Attributes: |
| _master_name: Name of the file containing the master header |
| _size: Size of the filesystem, in bytes |
| _files: Ordered list of files in the CBFS, each a CbfsFile |
| _arch: Architecture of the CBFS (ARCHITECTURE_...) |
| _bootblock_size: Size of the bootblock, typically at the end of the CBFS |
| _erase_byte: Byte to use for empty space in the CBFS |
| _align: Alignment to use for files, typically ENTRY_ALIGN |
| _base_address: Boot block offset in bytes from the start of CBFS. |
| Typically this is located at top of the CBFS. It is 0 when there is |
| no boot block |
| _header_offset: Offset of master header in bytes from start of CBFS |
| _contents_offset: Offset of first file header |
| _hdr_at_start: True if the master header is at the start of the CBFS, |
| instead of the end as normal for x86 |
| _add_fileheader: True to add a fileheader around the master header |
| """ |
| def __init__(self, size, arch=ARCHITECTURE_X86): |
| """Set up a new CBFS |
| |
| This sets up all properties to default values. Files can be added using |
| add_file_raw(), etc. |
| |
| Args: |
| size: Size of CBFS in bytes |
| arch: Architecture to declare for CBFS |
| """ |
| self._master_name = 'cbfs master header' |
| self._size = size |
| self._files = OrderedDict() |
| self._arch = arch |
| self._bootblock_size = 0 |
| self._erase_byte = 0xff |
| self._align = ENTRY_ALIGN |
| self._add_fileheader = False |
| if self._arch == ARCHITECTURE_X86: |
| # Allow 4 bytes for the header pointer. That holds the |
| # twos-compliment negative offset of the master header in bytes |
| # measured from one byte past the end of the CBFS |
| self._base_address = self._size - max(self._bootblock_size, |
| MIN_BOOTBLOCK_SIZE) |
| self._header_offset = self._base_address - HEADER_LEN |
| self._contents_offset = 0 |
| self._hdr_at_start = False |
| else: |
| # For non-x86, different rules apply |
| self._base_address = 0 |
| self._header_offset = align_int(self._base_address + |
| self._bootblock_size, 4) |
| self._contents_offset = align_int(self._header_offset + |
| FILE_HEADER_LEN + |
| self._bootblock_size, self._align) |
| self._hdr_at_start = True |
| |
| def _skip_to(self, fd, offset): |
| """Write out pad bytes until a given offset |
| |
| Args: |
| fd: File objext to write to |
| offset: Offset to write to |
| """ |
| if fd.tell() > offset: |
| raise ValueError('No space for data before offset %#x (current offset %#x)' % |
| (offset, fd.tell())) |
| fd.write(tools.GetBytes(self._erase_byte, offset - fd.tell())) |
| |
| def _pad_to(self, fd, offset): |
| """Write out pad bytes and/or an empty file until a given offset |
| |
| Args: |
| fd: File objext to write to |
| offset: Offset to write to |
| """ |
| self._align_to(fd, self._align) |
| upto = fd.tell() |
| if upto > offset: |
| raise ValueError('No space for data before pad offset %#x (current offset %#x)' % |
| (offset, upto)) |
| todo = align_int_down(offset - upto, self._align) |
| if todo: |
| cbf = CbfsFile.empty(todo, self._erase_byte) |
| fd.write(cbf.get_data_and_offset()[0]) |
| self._skip_to(fd, offset) |
| |
| def _align_to(self, fd, align): |
| """Write out pad bytes until a given alignment is reached |
| |
| This only aligns if the resulting output would not reach the end of the |
| CBFS, since we want to leave the last 4 bytes for the master-header |
| pointer. |
| |
| Args: |
| fd: File objext to write to |
| align: Alignment to require (e.g. 4 means pad to next 4-byte |
| boundary) |
| """ |
| offset = align_int(fd.tell(), align) |
| if offset < self._size: |
| self._skip_to(fd, offset) |
| |
| def add_file_stage(self, name, data, cbfs_offset=None): |
| """Add a new stage file to the CBFS |
| |
| Args: |
| name: String file name to put in CBFS (does not need to correspond |
| to the name that the file originally came from) |
| data: Contents of file |
| cbfs_offset: Offset of this file's data within the CBFS, in bytes, |
| or None to place this file anywhere |
| |
| Returns: |
| CbfsFile object created |
| """ |
| cfile = CbfsFile.stage(self._base_address, name, data, cbfs_offset) |
| self._files[name] = cfile |
| return cfile |
| |
| def add_file_raw(self, name, data, cbfs_offset=None, |
| compress=COMPRESS_NONE): |
| """Create a new raw file |
| |
| Args: |
| name: String file name to put in CBFS (does not need to correspond |
| to the name that the file originally came from) |
| data: Contents of file |
| cbfs_offset: Offset of this file's data within the CBFS, in bytes, |
| or None to place this file anywhere |
| compress: Compression algorithm to use (COMPRESS_...) |
| |
| Returns: |
| CbfsFile object created |
| """ |
| cfile = CbfsFile.raw(name, data, cbfs_offset, compress) |
| self._files[name] = cfile |
| return cfile |
| |
| def _write_header(self, fd, add_fileheader): |
| """Write out the master header to a CBFS |
| |
| Args: |
| fd: File object |
| add_fileheader: True to place the master header in a file header |
| record |
| """ |
| if fd.tell() > self._header_offset: |
| raise ValueError('No space for header at offset %#x (current offset %#x)' % |
| (self._header_offset, fd.tell())) |
| if not add_fileheader: |
| self._pad_to(fd, self._header_offset) |
| hdr = struct.pack(HEADER_FORMAT, HEADER_MAGIC, HEADER_VERSION2, |
| self._size, self._bootblock_size, self._align, |
| self._contents_offset, self._arch, 0xffffffff) |
| if add_fileheader: |
| name = _pack_string(self._master_name) |
| fd.write(struct.pack(FILE_HEADER_FORMAT, FILE_MAGIC, len(hdr), |
| TYPE_CBFSHEADER, 0, |
| FILE_HEADER_LEN + len(name))) |
| fd.write(name) |
| self._header_offset = fd.tell() |
| fd.write(hdr) |
| self._align_to(fd, self._align) |
| else: |
| fd.write(hdr) |
| |
| def get_data(self): |
| """Obtain the full contents of the CBFS |
| |
| Thhis builds the CBFS with headers and all required files. |
| |
| Returns: |
| 'bytes' type containing the data |
| """ |
| fd = io.BytesIO() |
| |
| # THe header can go at the start in some cases |
| if self._hdr_at_start: |
| self._write_header(fd, add_fileheader=self._add_fileheader) |
| self._skip_to(fd, self._contents_offset) |
| |
| # Write out each file |
| for cbf in self._files.values(): |
| # Place the file at its requested place, if any |
| offset = cbf.calc_start_offset() |
| if offset is not None: |
| self._pad_to(fd, align_int_down(offset, self._align)) |
| pos = fd.tell() |
| data, data_offset = cbf.get_data_and_offset(pos, self._erase_byte) |
| fd.write(data) |
| self._align_to(fd, self._align) |
| cbf.calced_cbfs_offset = pos + data_offset |
| if not self._hdr_at_start: |
| self._write_header(fd, add_fileheader=self._add_fileheader) |
| |
| # Pad to the end and write a pointer to the CBFS master header |
| self._pad_to(fd, self._base_address or self._size - 4) |
| rel_offset = self._header_offset - self._size |
| fd.write(struct.pack('<I', rel_offset & 0xffffffff)) |
| |
| return fd.getvalue() |
| |
| |
| class CbfsReader(object): |
| """Class to handle reading a Coreboot File System (CBFS) |
| |
| Usage is something like: |
| cbfs = cbfs_util.CbfsReader(data) |
| cfile = cbfs.files['u-boot'] |
| self.WriteFile('u-boot.bin', cfile.data) |
| |
| Attributes: |
| files: Ordered list of CbfsFile objects |
| align: Alignment to use for files, typically ENTRT_ALIGN |
| stage_base_address: Base address to use when mapping ELF files into the |
| CBFS for TYPE_STAGE files. If this is larger than the code address |
| of the ELF file, then data at the start of the ELF file will not |
| appear in the CBFS. Currently there are no tests for behaviour as |
| documentation is sparse |
| magic: Integer magic number from master header (HEADER_MAGIC) |
| version: Version number of CBFS (HEADER_VERSION2) |
| rom_size: Size of CBFS |
| boot_block_size: Size of boot block |
| cbfs_offset: Offset of the first file in bytes from start of CBFS |
| arch: Architecture of CBFS file (ARCHITECTURE_...) |
| """ |
| def __init__(self, data, read=True): |
| self.align = ENTRY_ALIGN |
| self.arch = None |
| self.boot_block_size = None |
| self.cbfs_offset = None |
| self.files = OrderedDict() |
| self.magic = None |
| self.rom_size = None |
| self.stage_base_address = 0 |
| self.version = None |
| self.data = data |
| if read: |
| self.read() |
| |
| def read(self): |
| """Read all the files in the CBFS and add them to self.files""" |
| with io.BytesIO(self.data) as fd: |
| # First, get the master header |
| if not self._find_and_read_header(fd, len(self.data)): |
| raise ValueError('Cannot find master header') |
| fd.seek(self.cbfs_offset) |
| |
| # Now read in the files one at a time |
| while True: |
| cfile = self._read_next_file(fd) |
| if cfile: |
| self.files[cfile.name] = cfile |
| elif cfile is False: |
| break |
| |
| def _find_and_read_header(self, fd, size): |
| """Find and read the master header in the CBFS |
| |
| This looks at the pointer word at the very end of the CBFS. This is an |
| offset to the header relative to the size of the CBFS, which is assumed |
| to be known. Note that the offset is in *little endian* format. |
| |
| Args: |
| fd: File to read from |
| size: Size of file |
| |
| Returns: |
| True if header was found, False if not |
| """ |
| orig_pos = fd.tell() |
| fd.seek(size - 4) |
| rel_offset, = struct.unpack('<I', fd.read(4)) |
| pos = (size + rel_offset) & 0xffffffff |
| fd.seek(pos) |
| found = self._read_header(fd) |
| if not found: |
| print('Relative offset seems wrong, scanning whole image') |
| for pos in range(0, size - HEADER_LEN, 4): |
| fd.seek(pos) |
| found = self._read_header(fd) |
| if found: |
| break |
| fd.seek(orig_pos) |
| return found |
| |
| def _read_next_file(self, fd): |
| """Read the next file from a CBFS |
| |
| Args: |
| fd: File to read from |
| |
| Returns: |
| CbfsFile object, if found |
| None if no object found, but data was parsed (e.g. TYPE_CBFSHEADER) |
| False if at end of CBFS and reading should stop |
| """ |
| file_pos = fd.tell() |
| data = fd.read(FILE_HEADER_LEN) |
| if len(data) < FILE_HEADER_LEN: |
| print('File header at %#x ran out of data' % file_pos) |
| return False |
| magic, size, ftype, attr, offset = struct.unpack(FILE_HEADER_FORMAT, |
| data) |
| if magic != FILE_MAGIC: |
| return False |
| pos = fd.tell() |
| name = self._read_string(fd) |
| if name is None: |
| print('String at %#x ran out of data' % pos) |
| return False |
| |
| if DEBUG: |
| print('name', name) |
| |
| # If there are attribute headers present, read those |
| compress = self._read_attr(fd, file_pos, attr, offset) |
| if compress is None: |
| return False |
| |
| # Create the correct CbfsFile object depending on the type |
| cfile = None |
| cbfs_offset = file_pos + offset |
| fd.seek(cbfs_offset, io.SEEK_SET) |
| if ftype == TYPE_CBFSHEADER: |
| self._read_header(fd) |
| elif ftype == TYPE_STAGE: |
| data = fd.read(STAGE_LEN) |
| cfile = CbfsFile.stage(self.stage_base_address, name, b'', |
| cbfs_offset) |
| (cfile.compress, cfile.entry, cfile.load, cfile.data_len, |
| cfile.memlen) = struct.unpack(STAGE_FORMAT, data) |
| cfile.data = fd.read(cfile.data_len) |
| elif ftype == TYPE_RAW: |
| data = fd.read(size) |
| cfile = CbfsFile.raw(name, data, cbfs_offset, compress) |
| cfile.decompress() |
| if DEBUG: |
| print('data', data) |
| elif ftype == TYPE_EMPTY: |
| # Just read the data and discard it, since it is only padding |
| fd.read(size) |
| cfile = CbfsFile('', TYPE_EMPTY, b'', cbfs_offset) |
| else: |
| raise ValueError('Unknown type %#x when reading\n' % ftype) |
| if cfile: |
| cfile.offset = offset |
| |
| # Move past the padding to the start of a possible next file. If we are |
| # already at an alignment boundary, then there is no padding. |
| pad = (self.align - fd.tell() % self.align) % self.align |
| fd.seek(pad, io.SEEK_CUR) |
| return cfile |
| |
| @classmethod |
| def _read_attr(cls, fd, file_pos, attr, offset): |
| """Read attributes from the file |
| |
| CBFS files can have attributes which are things that cannot fit into the |
| header. The only attributes currently supported are compression and the |
| unused tag. |
| |
| Args: |
| fd: File to read from |
| file_pos: Position of file in fd |
| attr: Offset of attributes, 0 if none |
| offset: Offset of file data (used to indicate the end of the |
| attributes) |
| |
| Returns: |
| Compression to use for the file (COMPRESS_...) |
| """ |
| compress = COMPRESS_NONE |
| if not attr: |
| return compress |
| attr_size = offset - attr |
| fd.seek(file_pos + attr, io.SEEK_SET) |
| while attr_size: |
| pos = fd.tell() |
| hdr = fd.read(8) |
| if len(hdr) < 8: |
| print('Attribute tag at %x ran out of data' % pos) |
| return None |
| atag, alen = struct.unpack(">II", hdr) |
| data = hdr + fd.read(alen - 8) |
| if atag == FILE_ATTR_TAG_COMPRESSION: |
| # We don't currently use this information |
| atag, alen, compress, _decomp_size = struct.unpack( |
| ATTR_COMPRESSION_FORMAT, data) |
| elif atag == FILE_ATTR_TAG_UNUSED2: |
| break |
| else: |
| print('Unknown attribute tag %x' % atag) |
| attr_size -= len(data) |
| return compress |
| |
| def _read_header(self, fd): |
| """Read the master header |
| |
| Reads the header and stores the information obtained into the member |
| variables. |
| |
| Args: |
| fd: File to read from |
| |
| Returns: |
| True if header was read OK, False if it is truncated or has the |
| wrong magic or version |
| """ |
| pos = fd.tell() |
| data = fd.read(HEADER_LEN) |
| if len(data) < HEADER_LEN: |
| print('Header at %x ran out of data' % pos) |
| return False |
| (self.magic, self.version, self.rom_size, self.boot_block_size, |
| self.align, self.cbfs_offset, self.arch, _) = struct.unpack( |
| HEADER_FORMAT, data) |
| return self.magic == HEADER_MAGIC and ( |
| self.version == HEADER_VERSION1 or |
| self.version == HEADER_VERSION2) |
| |
| @classmethod |
| def _read_string(cls, fd): |
| """Read a string from a file |
| |
| This reads a string and aligns the data to the next alignment boundary |
| |
| Args: |
| fd: File to read from |
| |
| Returns: |
| string read ('str' type) encoded to UTF-8, or None if we ran out of |
| data |
| """ |
| val = b'' |
| while True: |
| data = fd.read(FILENAME_ALIGN) |
| if len(data) < FILENAME_ALIGN: |
| return None |
| pos = data.find(b'\0') |
| if pos == -1: |
| val += data |
| else: |
| val += data[:pos] |
| break |
| return val.decode('utf-8') |