coreboot-mirror
/
hpcorebootfe80
mirror of https://code.fe80.eu/microserver/coreboot.git
1
0
Fork 0
Code Issues Releases Wiki Activity

util: ipq40xx: Scripts to combine SBL and Coreboot ELFs 

The IPQ40xx Primary Boot Loader (PBL, i.e. Boot-ROM) expects an
ELF in the boot medium to load and boot. These scripts combine
the Secondary Boot Loader (SBL) and Coreboot ELF to an image as
expected by the PBL.

BUG=chrome-os-partner:49249
TEST=Able to boot and reach depthcharge
BRANCH=none

Change-Id: I5d02b7f1f58bb23d81a3e19fb9b78f3a999b89f3
Signed-off-by: Patrick Georgi <pgeorgi@chromium.org>
Original-Commit-Id: 819c7f2a810ca2880718ba14f2451f06eef4d98b
Original-Change-Id: I017207b2d4108de150853f421aa7bcfd0e12e9a4
Original-Signed-off-by: Varadarajan Narayanan <varada@codeaurora.org>
Original-Reviewed-on: https://chromium-review.googlesource.com/340181
Original-Commit-Ready: Nicolas Boichat <drinkcat@chromium.org>
Original-Reviewed-by: David Hendricks <dhendrix@chromium.org>
Reviewed-on: https://review.coreboot.org/14680
Tested-by: build bot (Jenkins)
Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
This commit is contained in:
Varadarajan Narayanan 2016-04-21 16:06:06 +05:30 committed by Patrick Georgi
parent c1ae7e9183
commit 2dfbd93ed6
2 changed files with 3030 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

714
util/ipqheader/createxbl.py Executable file
View File

@ -0,0 +1,714 @@
#!/usr/bin/python
#============================================================================
#
#/** @file createxbl.py
#
# GENERAL DESCRIPTION
# Concatentates XBL segments into one ELF image
#
# Copyright (c) 2016, The Linux Foundation. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided
# with the distribution.
# * Neither the name of The Linux Foundation nor the names of its
# contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
# IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
#**/
#
#----------------------------------------------------------------------------
#
# EDIT HISTORY FOR FILE
#
# This section contains comments describing changes made to the module.
# Notice that changes are listed in reverse chronological order.
#
# when who what, where, why
# -------- --- ------------------------------------------------------
# 09/04/15 et Added -x and -d to embed xbl_sec ELF
# 02/11/15 ck Fixed missing elf type check in ZI OOB feature
# 11/04/14 ck Updated calls to mbn_tools functions
# 10/22/14 ck Added -z option to remove out of bounds ZI segments when converting from 64 to 32
# 10/10/14 ck Added -c option and logic to enable elf type swapping
# 09/12/14 ck Added single file logic
# 08/29/14 ck Added no_hash option
# 08/29/14 ck Refactored to use proper python arguments and cleaned code
# 06/16/14 niting xbl.mbn to xbl.elf
# 05/28/14 niting Initial revision
#
#============================================================================
from optparse import OptionParser
import os
import sys
import shutil
import mbn_tools
PAGE_SIZE = 4096
SEGMENT_ALIGN = 16
ELF32_HDR_SIZE = 52
ELF32_PHDR_SIZE = 32
ELF64_HDR_SIZE = 64
ELF64_PHDR_SIZE = 56
##############################################################################
# main
##############################################################################
def main():
parser = OptionParser(usage='usage: %prog [options] arguments')
parser.add_option("-f", "--first_filepath",
action="store", type="string", dest="elf_inp_file1",
help="First ELF file to merge.")
parser.add_option("-s", "--second_filepath",
action="store", type="string", dest="elf_inp_file2",
help="Second ELF file to merge.")
parser.add_option("-x", "--xbl_sec_filepath",
action="store", type="string", dest="elf_inp_xbl_sec",
help="Second ELF file to merge.")
parser.add_option("-o", "--output_filepath",
action="store", type="string", dest="binary_out",
help="Merged filename and path.")
parser.add_option("-a", "--first_elf_arch",
action="store", type="string", dest="elf_1_arch",
help="First (and output) ELF file architecture. '32' or '64'")
parser.add_option("-b", "--second_elf_arch",
action="store", type="string", dest="elf_2_arch",
help="Second ELF file architecture. '32' or '64'")
parser.add_option("-d", "--xbl_sec_elf_arch",
action="store", type="string", dest="elf_xbl_sec_arch",
help="xbl_sec file architecture. '32' or '64'")
parser.add_option("-c", "--output_elf_arch",
action="store", type="string", dest="elf_out_arch",
help="Output ELF file architecture. '32' or '64'" + \
" If not given defaults to first file arch.")
parser.add_option("-n", "--no_hash",
action="store_true", dest="hash_image",
help="Disables hashing of image after merging.")
parser.add_option("-z", "--zi_out_of_bounds",
action="store_true", dest="zi_oob",
help="Removes ZI segments that have addresses greater" + \
" than 32 bits when converting from a 64 to 32 bit ELF")
(options, args) = parser.parse_args()
if not options.elf_inp_file1:
parser.error('First ELF filename not given')
if not options.binary_out:
parser.error('Output filename not given')
if not options.elf_1_arch:
parser.error('First ELF architecture not given')
if (not options.elf_1_arch == '64') and (not options.elf_1_arch == '32'):
parser.error('Invalid First ELF architecture given')
# Only evaluate elf_2_arch if two files are given for merging
if options.elf_inp_file2:
if (not options.elf_2_arch == '64') and (not options.elf_2_arch == '32'):
parser.error('Invalid Second ELF architecture given')
# Only evaluate elf_xbl_sec_arch if file is given
if options.elf_inp_xbl_sec:
if (not options.elf_xbl_sec_arch == '64') and (not options.elf_xbl_sec_arch == '32'):
parser.error('Invalid xbl_sec ELF architecture given')
# If output file architecture is given ensure it is either '32' or '64'
if options.elf_out_arch:
if (not options.elf_out_arch == '64') and (not options.elf_out_arch == '32'):
parser.error('Invalid Output ELF architecture given')
gen_dict = {}
elf_inp_file1 = options.elf_inp_file1
# It is valid for only one file to be "merged". This essentially just
# strips off the section names. If second file name is not given then
# set elf_inp_file2 to ""
if options.elf_inp_file2:
elf_inp_file2 = options.elf_inp_file2
else:
elf_inp_file2 = ""
# Do same for xbl_sec
elf_inp_xbl_sec = options.elf_inp_xbl_sec if options.elf_inp_xbl_sec else ""
binary_out = options.binary_out
if options.elf_1_arch == '64':
is_elf1_64_bit = True
else:
is_elf1_64_bit = False
# If second filename is not given then set is_elf2_64_bit to false so it
# can be passed even though it is not used.
if options.elf_inp_file2:
if options.elf_2_arch == '64':
is_elf2_64_bit = True
else:
is_elf2_64_bit = False
else:
is_elf2_64_bit = False
if options.elf_inp_xbl_sec:
if options.elf_xbl_sec_arch == '64':
is_elf_xbl_sec_64_bit = True
else:
is_elf_xbl_sec_64_bit = False
else:
is_elf_xbl_sec_64_bit = False
# If output ELF arch is given then set is_out_elf_64_bit accordingly.
# If not then default to be input1's setting
if options.elf_out_arch:
if options.elf_out_arch == '64':
is_out_elf_64_bit = True
else:
is_out_elf_64_bit = False
else:
is_out_elf_64_bit = is_elf1_64_bit
# Store ZI Out of Bounds value
if not options.zi_oob:
zi_oob_enabled = False
else:
zi_oob_enabled = True
mbn_type = 'elf'
header_format = 'reg'
gen_dict['IMAGE_KEY_IMAGE_ID'] = mbn_tools.ImageType.APPSBL_IMG
#gen_dict['IMAGE_KEY_IMAGE_SOURCE'] = 0
#gen_dict['IMAGE_KEY_IMAGE_DEST'] = 0
gen_dict['IMAGE_KEY_MBN_TYPE'] = mbn_type
image_header_secflag = 'non_secure'
source_base = os.path.splitext(str(binary_out))[0]
target_base = os.path.splitext(str(binary_out))[0]
merged_elf = source_base + "_merged.elf"
source_elf = source_base + "_nohash.elf"
target_hash = target_base + ".hash"
target_hash_hd = target_base + "_hash.hd"
target_phdr_elf = target_base + "_phdr.pbn"
target_nonsec = target_base + "_combined_hash.mbn"
#print "Input file 1:", elf_inp_file1
#print "Input file 2:", elf_inp_file2
#print "Output file:", binary_out
merge_elfs([],
elf_inp_file1,
elf_inp_file2,
elf_inp_xbl_sec,
merged_elf,
is_elf1_64_bit,
is_elf2_64_bit,
is_elf_xbl_sec_64_bit,
is_out_elf_64_bit,
zi_oob_enabled)
# Hash the image if user did not explicitly say not to
if options.hash_image:
# Just copy the merged elf to the final output name
shutil.move(merged_elf, binary_out)
else:
shutil.copy(merged_elf, source_elf)
# Create hash table
rv = mbn_tools.pboot_gen_elf([],
source_elf,
target_hash,
elf_out_file_name = target_phdr_elf,
secure_type = image_header_secflag)
if rv:
raise RuntimeError, "Failed to run pboot_gen_elf"
# Create hash table header
rv = mbn_tools.image_header([],
gen_dict,
target_hash,
target_hash_hd,
image_header_secflag,
elf_file_name = source_elf)
if rv:
raise RuntimeError, "Failed to create image header for hash segment"
files_to_cat_in_order = [target_hash_hd, target_hash]
mbn_tools.concat_files (target_nonsec, files_to_cat_in_order)
# Add the hash segment into the ELF
mbn_tools.pboot_add_hash([],
target_phdr_elf,
target_nonsec,
binary_out)
return
##############################################################################
# roundup
##############################################################################
def roundup(x, precision):
return x if x % precision == 0 else (x + precision - (x % precision))
##############################################################################
# merge_elfs
##############################################################################
def merge_elfs(env,
elf_in_file_name1,
elf_in_file_name2,
elf_in_file_xbl_sec,
elf_out_file_name,
is_elf1_64_bit,
is_elf2_64_bit,
is_elf_xbl_sec_64_bit,
is_out_elf_64_bit,
zi_oob_enabled):
[elf_header1, phdr_table1] = \
mbn_tools.preprocess_elf_file(elf_in_file_name1)
# Check to make sure second file path exists before using
if elf_in_file_name2 != "":
[elf_header2, phdr_table2] = \
mbn_tools.preprocess_elf_file(elf_in_file_name2)
# Check to make sure xbl_sec file path exists before using
if elf_in_file_xbl_sec != "":
[elf_headerxblsec, phdr_tablexblsec] = \
mbn_tools.preprocess_elf_file(elf_in_file_xbl_sec)
# Open Files
elf_in_fp1 = mbn_tools.OPEN(elf_in_file_name1, "rb")
if elf_in_file_name2 != "":
elf_in_fp2 = mbn_tools.OPEN(elf_in_file_name2, "rb")
if elf_in_file_xbl_sec != "":
elf_in_fpxblsec = mbn_tools.OPEN(elf_in_file_xbl_sec, "rb")
if elf_out_file_name is not None:
elf_out_fp = mbn_tools.OPEN(elf_out_file_name, "wb+")
# Calculate the new program header size. This is dependant on the output
# ELF type and number of program headers going into output.
if is_out_elf_64_bit:
phdr_total_size = elf_header1.e_phnum * ELF64_PHDR_SIZE
phdr_total_count = elf_header1.e_phnum
else:
phdr_total_size = elf_header1.e_phnum * ELF32_PHDR_SIZE
phdr_total_count = elf_header1.e_phnum
# This logic only applies if two files are to be merged
if elf_in_file_name2 != "":
if is_out_elf_64_bit:
phdr_total_size += elf_header2.e_phnum * ELF64_PHDR_SIZE
phdr_total_count += elf_header2.e_phnum
else:
phdr_total_size += elf_header2.e_phnum * ELF32_PHDR_SIZE
phdr_total_count += elf_header2.e_phnum
# Account for xbl_sec header if included
if elf_in_file_xbl_sec != "":
phdr_total_count += 1
if is_out_elf_64_bit:
phdr_total_size += ELF64_PHDR_SIZE
else:
phdr_total_size += ELF32_PHDR_SIZE
# Create a new ELF header for the output file
if is_out_elf_64_bit:
out_elf_header = mbn_tools.Elf64_Ehdr('\0' * ELF64_HDR_SIZE)
out_elf_header.e_phoff = ELF64_HDR_SIZE
out_elf_header.e_ehsize = ELF64_HDR_SIZE
out_elf_header.e_phentsize = ELF64_PHDR_SIZE
out_elf_header.e_machine = 183
out_elf_header.e_ident = str('\x7f' + 'E' + 'L' + 'F' + \
'\x02' + \
'\x01' + \
'\x01' + \
'\x00' + \
'\x00' + \
('\x00' * 7))
out_elf_header.e_entry = elf_header1.e_entry
else:
out_elf_header = mbn_tools.Elf32_Ehdr('\0' * ELF32_HDR_SIZE)
out_elf_header.e_phoff = ELF32_HDR_SIZE
out_elf_header.e_ehsize = ELF32_HDR_SIZE
out_elf_header.e_phentsize = ELF32_PHDR_SIZE
out_elf_header.e_machine = 40
out_elf_header.e_entry = elf_header1.e_entry
out_elf_header.e_ident = str('\x7f' + 'E' + 'L' + 'F' + \
'\x01' + \
'\x01' + \
'\x01' + \
'\x00' + \
'\x00' + \
('\x00' * 7))
# Address needs to be verified that it is not greater than 32 bits
# as it is possible to go from a 64 bit elf to 32.
if (elf_header1.e_entry > 0xFFFFFFFF):
print "ERROR: File 1's entry point is too large to convert."
exit()
out_elf_header.e_entry = elf_header1.e_entry
# Common header entries
out_elf_header.e_type = 2
out_elf_header.e_version = 1
out_elf_header.e_shoff = 0
out_elf_header.e_flags = 0
out_elf_header.e_shentsize = 0
out_elf_header.e_shnum = 0
out_elf_header.e_shstrndx = 0
# If ZI OOB is enabled then it is possible that a segment could be discarded
# Scan for that instance and handle before setting e_phnum and writing header
# Ensure ELF output is 32 bit
if zi_oob_enabled == True and is_out_elf_64_bit == False:
for i in range(len(phdr_table1)):
if (phdr_table1[i].p_vaddr > 0xFFFFFFFF) or \
(phdr_table1[i].p_paddr > 0xFFFFFFFF):
if phdr_table1[i].p_filesz == 0:
phdr_total_count = phdr_total_count - 1
if elf_in_file_name2 != "":
for i in range(len(phdr_table2)):
if (phdr_table2[i].p_vaddr > 0xFFFFFFFF) or \
(phdr_table2[i].p_paddr > 0xFFFFFFFF):
if phdr_table2[i].p_filesz == 0:
phdr_total_count = phdr_total_count - 1
# Do not include xbl_sec in above calculation
# xbl_sec is to be treated as a single blob
# Now it is ok to populate the ELF header and write it out
out_elf_header.e_phnum = phdr_total_count
# write elf header
if is_out_elf_64_bit == False:
elf_out_fp.write(mbn_tools.Elf32_Ehdr.getPackedData(out_elf_header))
else:
elf_out_fp.write(mbn_tools.Elf64_Ehdr.getPackedData(out_elf_header))
phdr_offset = out_elf_header.e_phoff # offset of where to put next phdr
# offset the start of the segments just after the program headers
segment_offset = roundup(out_elf_header.e_phoff + phdr_total_size, PAGE_SIZE)
# Output first elf data
for i in range(elf_header1.e_phnum):
curr_phdr = phdr_table1[i]
# Copy program header piece by piece to ensure possible conversion success
if is_out_elf_64_bit == True:
# Converting from 32 to 64 elf requires no data size validation
new_phdr = mbn_tools.Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
new_phdr.p_type = curr_phdr.p_type
new_phdr.p_offset = segment_offset
new_phdr.p_vaddr = curr_phdr.p_vaddr
new_phdr.p_paddr = curr_phdr.p_paddr
new_phdr.p_filesz = curr_phdr.p_filesz
new_phdr.p_memsz = curr_phdr.p_memsz
new_phdr.p_flags = curr_phdr.p_flags
new_phdr.p_align = curr_phdr.p_align
else:
# Converting from 64 to 32 elf requires data size validation
# Note that there is an option to discard a segment if it is only ZI
# and its address is greater than 32 bits
new_phdr = mbn_tools.Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
new_phdr.p_type = curr_phdr.p_type
new_phdr.p_offset = segment_offset
if curr_phdr.p_vaddr > 0xFFFFFFFF:
if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
continue
else:
print "ERROR: File 1 VAddr is too large for conversion."
exit()
new_phdr.p_vaddr = curr_phdr.p_vaddr
if curr_phdr.p_paddr > 0xFFFFFFFF:
if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
continue
else:
print "ERROR: File 1 PAddr is too large for conversion."
exit()
new_phdr.p_paddr = curr_phdr.p_paddr
if curr_phdr.p_filesz > 0xFFFFFFFF:
print "ERROR: File 1 Filesz is too large for conversion."
exit()
new_phdr.p_filesz = curr_phdr.p_filesz
if curr_phdr.p_memsz > 0xFFFFFFFF:
print "ERROR: File 1 Memsz is too large for conversion."
exit()
new_phdr.p_memsz = curr_phdr.p_memsz
if curr_phdr.p_flags > 0xFFFFFFFF:
print "ERROR: File 1 Flags is too large for conversion."
exit()
new_phdr.p_flags = curr_phdr.p_flags
if curr_phdr.p_align > 0xFFFFFFFF:
print "ERROR: File 1 Align is too large for conversion."
exit()
new_phdr.p_align = curr_phdr.p_align
#print "i=",i
#print "phdr_offset=", phdr_offset
# update output file location to next phdr location
elf_out_fp.seek(phdr_offset)
# increment phdr_offset to next location
phdr_offset += out_elf_header.e_phentsize
inp_data_offset = curr_phdr.p_offset # used to read data from input file
# print "inp_data_offset="
# print inp_data_offset
#
# print "curr_phdr.p_offset="
# print curr_phdr.p_offset
#
# print "curr_phdr.p_filesz="
# print curr_phdr.p_filesz
# output current phdr
if is_out_elf_64_bit == False:
elf_out_fp.write(mbn_tools.Elf32_Phdr.getPackedData(new_phdr))
else:
elf_out_fp.write(mbn_tools.Elf64_Phdr.getPackedData(new_phdr))
# Copy the ELF segment
bytes_written = mbn_tools.file_copy_offset(elf_in_fp1,
inp_data_offset,
elf_out_fp,
new_phdr.p_offset,
new_phdr.p_filesz)
# update data segment offset to be aligned after previous segment
segment_offset += roundup(new_phdr.p_filesz, SEGMENT_ALIGN);
elf_in_fp1.close()
# Output second elf data if applicable
if elf_in_file_name2 != "":
for i in range(elf_header2.e_phnum):
curr_phdr = phdr_table2[i]
# Copy program header piece by piece to ensure possible conversion success
if is_out_elf_64_bit == True:
# Converting from 32 to 64 elf requires no data size validation
new_phdr = mbn_tools.Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
new_phdr.p_type = curr_phdr.p_type
new_phdr.p_offset = segment_offset
new_phdr.p_vaddr = curr_phdr.p_vaddr
new_phdr.p_paddr = curr_phdr.p_paddr
new_phdr.p_filesz = curr_phdr.p_filesz
new_phdr.p_memsz = curr_phdr.p_memsz
new_phdr.p_flags = curr_phdr.p_flags
new_phdr.p_align = curr_phdr.p_align
else:
# Converting from 64 to 32 elf requires data size validation
# Note that there is an option to discard a segment if it is only ZI
# and its address is greater than 32 bits
new_phdr = mbn_tools.Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
new_phdr.p_type = curr_phdr.p_type
new_phdr.p_offset = segment_offset
if curr_phdr.p_vaddr > 0xFFFFFFFF:
if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
continue
else:
print "ERROR: File 2 VAddr is too large for conversion."
exit()
new_phdr.p_vaddr = curr_phdr.p_vaddr
if curr_phdr.p_paddr > 0xFFFFFFFF:
if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
continue
else:
print "ERROR: File 2 PAddr is too large for conversion."
exit()
new_phdr.p_paddr = curr_phdr.p_paddr
if curr_phdr.p_filesz > 0xFFFFFFFF:
print "ERROR: File 2 Filesz is too large for conversion."
exit()
new_phdr.p_filesz = curr_phdr.p_filesz
if curr_phdr.p_memsz > 0xFFFFFFFF:
print "ERROR: File 2 Memsz is too large for conversion."
exit()
new_phdr.p_memsz = curr_phdr.p_memsz
if curr_phdr.p_flags > 0xFFFFFFFF:
print "ERROR: File 2 Flags is too large for conversion."
exit()
new_phdr.p_flags = curr_phdr.p_flags
if curr_phdr.p_align > 0xFFFFFFFF:
print "ERROR: File 2 Align is too large for conversion."
exit()
new_phdr.p_align = curr_phdr.p_align
# print "i=",i
# print "phdr_offset=", phdr_offset
# update output file location to next phdr location
elf_out_fp.seek(phdr_offset)
# increment phdr_offset to next location
phdr_offset += out_elf_header.e_phentsize
inp_data_offset = curr_phdr.p_offset # used to read data from input file
# print "inp_data_offset="
# print inp_data_offset
#
# print "curr_phdr.p_offset="
# print curr_phdr.p_offset
#
# print "curr_phdr.p_filesz="
# print curr_phdr.p_filesz
# output current phdr
if is_out_elf_64_bit == False:
elf_out_fp.write(mbn_tools.Elf32_Phdr.getPackedData(new_phdr))
else:
elf_out_fp.write(mbn_tools.Elf64_Phdr.getPackedData(new_phdr))
# Copy the ELF segment
bytes_written = mbn_tools.file_copy_offset(elf_in_fp2,
inp_data_offset,
elf_out_fp,
new_phdr.p_offset,
new_phdr.p_filesz)
# update data segment offset to be aligned after previous segment
segment_offset += roundup(new_phdr.p_filesz, SEGMENT_ALIGN);
elf_in_fp2.close()
# Embed xbl_sec image if provided
if elf_in_file_xbl_sec != "":
# Scan pheaders in xbl_sec for segment that contains entry point address
entry_seg_offset = -1
entry_addr = elf_headerxblsec.e_entry
for i in range(elf_headerxblsec.e_phnum):
phdr = phdr_tablexblsec[i]
max_addr = phdr.p_vaddr + phdr.p_memsz
if phdr.p_vaddr <= entry_addr <= max_addr:
entry_seg_offset = phdr.p_offset
break
if entry_seg_offset == -1:
print "Error: Failed to find entry point in any segment!"
exit()
# magical equation for program header's phys and virt addr
phys_virt_addr = entry_addr - entry_seg_offset
if is_out_elf_64_bit:
# Converting from 32 to 64 elf requires no data size validation
new_phdr = mbn_tools.Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
new_phdr.p_type = 0x1
new_phdr.p_offset = segment_offset
new_phdr.p_vaddr = phys_virt_addr
new_phdr.p_paddr = phys_virt_addr
new_phdr.p_filesz = os.path.getsize(elf_in_file_xbl_sec)
new_phdr.p_memsz = new_phdr.p_filesz
new_phdr.p_flags = 0x5
new_phdr.p_align = 0x1000
else:
# Converting from 64 to 32 elf requires data size validation
# Don't discard the segment containing xbl_sec, simply error out
# if the address is greater than 32 bits
new_phdr = mbn_tools.Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
new_phdr.p_type = 0x1 #
new_phdr.p_offset = segment_offset
new_phdr.p_flags = 0x5
new_phdr.p_align = 0x1000
if phys_virt_addr > 0xFFFFFFFF:
if zi_oob_enabled == False or curr_phdr.p_filesz != 0:
print "ERROR: File xbl_sec VAddr or PAddr is too large for conversion."
exit()
new_phdr.p_vaddr = phys_virt_addr
new_phdr.p_paddr = phys_virt_addr
if os.path.getsize(elf_in_file_xbl_sec) > 0xFFFFFFFF:
print "ERROR: File xbl_sec Filesz is too large for conversion."
exit()
new_phdr.p_filesz = os.path.getsize(elf_in_file_xbl_sec)
new_phdr.p_memsz = new_phdr.p_filesz
# update output file location to next phdr location
elf_out_fp.seek(phdr_offset)
# increment phdr_offset to next location
phdr_offset += out_elf_header.e_phentsize
# Copy entire xbl_sec file, so start from byte 0
inp_data_offset = 0
# Output xbl_sec's phdr
elf_in_file_xbl_sec
if is_out_elf_64_bit == False:
elf_out_fp.write(mbn_tools.Elf32_Phdr.getPackedData(new_phdr))
else:
elf_out_fp.write(mbn_tools.Elf64_Phdr.getPackedData(new_phdr))
# Copy the ENTIRE xbl_sec image
bytes_written = mbn_tools.file_copy_offset(elf_in_fpxblsec,
inp_data_offset,
elf_out_fp,
new_phdr.p_offset,
new_phdr.p_filesz)
# update data segment offset to be aligned after previous segment
# Not necessary, unless appending more pheaders after this point
segment_offset += roundup(new_phdr.p_filesz, SEGMENT_ALIGN);
elf_in_fpxblsec.close()
elf_out_fp.close()
return 0
main()

2316
util/ipqheader/mbn_tools.py Executable file
View File

File diff suppressed because it is too large Load Diff