## @file | |
# This file contains the script to build UniversalPayload | |
# | |
# Copyright (c) 2021, Intel Corporation. All rights reserved.<BR> | |
# SPDX-License-Identifier: BSD-2-Clause-Patent | |
## | |
import argparse | |
import subprocess | |
import os | |
import shutil | |
import sys | |
from ctypes import * | |
sys.dont_write_bytecode = True | |
class UPLD_INFO_HEADER(LittleEndianStructure): | |
_pack_ = 1 | |
_fields_ = [ | |
('Identifier', ARRAY(c_char, 4)), | |
('HeaderLength', c_uint32), | |
('SpecRevision', c_uint16), | |
('Reserved', c_uint16), | |
('Revision', c_uint32), | |
('Attribute', c_uint32), | |
('Capability', c_uint32), | |
('ProducerId', ARRAY(c_char, 16)), | |
('ImageId', ARRAY(c_char, 16)), | |
] | |
def __init__(self): | |
self.Identifier = b'UPLD' | |
self.HeaderLength = sizeof(UPLD_INFO_HEADER) | |
self.HeaderRevision = 0x0075 | |
self.Revision = 0x0000010105 | |
self.ImageId = b'UEFI' | |
self.ProducerId = b'INTEL' | |
def RunCommand(cmd): | |
print(cmd) | |
p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,cwd=os.environ['WORKSPACE']) | |
while True: | |
line = p.stdout.readline() | |
if not line: | |
break | |
print(line.strip().decode(errors='ignore')) | |
p.communicate() | |
if p.returncode != 0: | |
print("- Failed - error happened when run command: %s"%cmd) | |
raise Exception("ERROR: when run command: %s"%cmd) | |
def BuildUniversalPayload(Args, MacroList): | |
BuildTarget = Args.Target | |
ToolChain = Args.ToolChain | |
ElfToolChain = 'CLANGDWARF' | |
EntryModuleInf = os.path.normpath("UefiPayloadPkg/UefiPayloadEntry/UniversalPayloadEntry.inf") | |
DscPath = os.path.normpath("UefiPayloadPkg/UefiPayloadPkg.dsc") | |
BuildDir = os.path.join(os.environ['WORKSPACE'], os.path.normpath("Build/UefiPayloadPkgX64")) | |
FvOutputDir = os.path.join(BuildDir, f"{BuildTarget}_{ToolChain}", os.path.normpath("FV/DXEFV.Fv")) | |
EntryOutputDir = os.path.join(BuildDir, f"{BuildTarget}_{ElfToolChain}", os.path.normpath("X64/UefiPayloadPkg/UefiPayloadEntry/UniversalPayloadEntry/DEBUG/UniversalPayloadEntry.dll")) | |
PayloadReportPath = os.path.join(BuildDir, "UefiUniversalPayload.txt") | |
ModuleReportPath = os.path.join(BuildDir, "UefiUniversalPayloadEntry.txt") | |
UpldInfoFile = os.path.join(BuildDir, "UniversalPayloadInfo.bin") | |
if "CLANG_BIN" in os.environ: | |
LlvmObjcopyPath = os.path.join(os.environ["CLANG_BIN"], "llvm-objcopy") | |
else: | |
LlvmObjcopyPath = "llvm-objcopy" | |
try: | |
RunCommand('"%s" --version'%LlvmObjcopyPath) | |
except: | |
print("- Failed - Please check if LLVM is installed or if CLANG_BIN is set correctly") | |
sys.exit(1) | |
Defines = "" | |
for key in MacroList: | |
Defines +=" -D {0}={1}".format(key, MacroList[key]) | |
# | |
# Building DXE core and DXE drivers as DXEFV. | |
# | |
BuildPayload = f"build -p {DscPath} -b {BuildTarget} -a X64 -t {ToolChain} -y {PayloadReportPath}" | |
BuildPayload += Defines | |
RunCommand(BuildPayload) | |
# | |
# Building Universal Payload entry. | |
# | |
BuildModule = f"build -p {DscPath} -b {BuildTarget} -a X64 -m {EntryModuleInf} -t {ElfToolChain} -y {ModuleReportPath}" | |
BuildModule += Defines | |
RunCommand(BuildModule) | |
# | |
# Buid Universal Payload Information Section ".upld_info" | |
# | |
upld_info_hdr = UPLD_INFO_HEADER() | |
upld_info_hdr.ImageId = Args.ImageId.encode()[:16] | |
fp = open(UpldInfoFile, 'wb') | |
fp.write(bytearray(upld_info_hdr)) | |
fp.close() | |
# | |
# Copy the DXEFV as a section in elf format Universal Payload entry. | |
# | |
remove_section = '"%s" -I elf64-x86-64 -O elf64-x86-64 --remove-section .upld_info --remove-section .upld.uefi_fv %s'%(LlvmObjcopyPath, EntryOutputDir) | |
add_section = '"%s" -I elf64-x86-64 -O elf64-x86-64 --add-section .upld_info=%s --add-section .upld.uefi_fv=%s %s'%(LlvmObjcopyPath, UpldInfoFile, FvOutputDir, EntryOutputDir) | |
set_section = '"%s" -I elf64-x86-64 -O elf64-x86-64 --set-section-alignment .upld.upld_info=16 --set-section-alignment .upld.uefi_fv=16 %s'%(LlvmObjcopyPath, EntryOutputDir) | |
RunCommand(remove_section) | |
RunCommand(add_section) | |
RunCommand(set_section) | |
shutil.copy (EntryOutputDir, os.path.join(BuildDir, 'UniversalPayload.elf')) | |
def main(): | |
parser = argparse.ArgumentParser(description='For building Universal Payload') | |
parser.add_argument('-t', '--ToolChain') | |
parser.add_argument('-b', '--Target', default='DEBUG') | |
parser.add_argument("-D", "--Macro", action="append", default=["UNIVERSAL_PAYLOAD=TRUE"]) | |
parser.add_argument('-i', '--ImageId', type=str, help='Specify payload ID (16 bytes maximal).', default ='UEFI') | |
MacroList = {} | |
args = parser.parse_args() | |
if args.Macro is not None: | |
for Argument in args.Macro: | |
if Argument.count('=') != 1: | |
print("Unknown variable passed in: %s"%Argument) | |
raise Exception("ERROR: Unknown variable passed in: %s"%Argument) | |
tokens = Argument.strip().split('=') | |
MacroList[tokens[0].upper()] = tokens[1] | |
BuildUniversalPayload(args, MacroList) | |
print ("Successfully build Universal Payload") | |
if __name__ == '__main__': | |
main() |