9b3d4f28f0
Currently, unlike OVMF, ArmVirtQemu does not display any graphics, only the QEMU monitor. Graphics are helpful to confirm booting into an OS is successful, interacting with the EFI shell while getting separate logging messages, etc. This patch adds the QEMU parameters to launch a graphical window and add a USB keyboard and mouse, which is modeled as a tablet as it tracks better in QEMU than a generic mouse. virtio-gpu-pci is chosen as the graphics device as it is recommended by QEMU for the ARM virtual platform. The graphics and USB input devices will only be added to QEMU when QEMU_HEADLESS == FALSE, so CI builds will not attempt to use the graphics and if a user does not want graphics, they can add QEMU_HEADLESS=TRUE to the build cmdline. Signed-off-by: Oliver Smith-Denny <osde@linux.microsoft.com> Reviewed-by: Ard Biesheuvel <ardb@kernel.org>
267 lines
11 KiB
Python
267 lines
11 KiB
Python
# @file
|
|
# Script to Build ArmVirtPkg UEFI firmware
|
|
#
|
|
# Copyright (c) Microsoft Corporation.
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
##
|
|
import os
|
|
import logging
|
|
import io
|
|
|
|
from edk2toolext.environment import shell_environment
|
|
from edk2toolext.environment.uefi_build import UefiBuilder
|
|
from edk2toolext.invocables.edk2_platform_build import BuildSettingsManager
|
|
from edk2toolext.invocables.edk2_setup import SetupSettingsManager, RequiredSubmodule
|
|
from edk2toolext.invocables.edk2_update import UpdateSettingsManager
|
|
from edk2toolext.invocables.edk2_pr_eval import PrEvalSettingsManager
|
|
from edk2toollib.utility_functions import RunCmd
|
|
from edk2toollib.utility_functions import GetHostInfo
|
|
|
|
|
|
# ####################################################################################### #
|
|
# Configuration for Update & Setup #
|
|
# ####################################################################################### #
|
|
|
|
|
|
class SettingsManager(UpdateSettingsManager, SetupSettingsManager, PrEvalSettingsManager):
|
|
|
|
def GetPackagesSupported(self):
|
|
''' return iterable of edk2 packages supported by this build.
|
|
These should be edk2 workspace relative paths '''
|
|
return CommonPlatform.PackagesSupported
|
|
|
|
def GetArchitecturesSupported(self):
|
|
''' return iterable of edk2 architectures supported by this build '''
|
|
return CommonPlatform.ArchSupported
|
|
|
|
def GetTargetsSupported(self):
|
|
''' return iterable of edk2 target tags supported by this build '''
|
|
return CommonPlatform.TargetsSupported
|
|
|
|
def GetRequiredSubmodules(self):
|
|
''' return iterable containing RequiredSubmodule objects.
|
|
If no RequiredSubmodules return an empty iterable
|
|
'''
|
|
rs = []
|
|
|
|
# intentionally declare this one with recursive false to avoid overhead
|
|
rs.append(RequiredSubmodule(
|
|
"CryptoPkg/Library/OpensslLib/openssl", False))
|
|
|
|
# To avoid maintenance of this file for every new submodule
|
|
# lets just parse the .gitmodules and add each if not already in list.
|
|
# The GetRequiredSubmodules is designed to allow a build to optimize
|
|
# the desired submodules but it isn't necessary for this repository.
|
|
result = io.StringIO()
|
|
ret = RunCmd("git", "config --file .gitmodules --get-regexp path", workingdir=self.GetWorkspaceRoot(), outstream=result)
|
|
# Cmd output is expected to look like:
|
|
# submodule.CryptoPkg/Library/OpensslLib/openssl.path CryptoPkg/Library/OpensslLib/openssl
|
|
# submodule.SoftFloat.path ArmPkg/Library/ArmSoftFloatLib/berkeley-softfloat-3
|
|
if ret == 0:
|
|
for line in result.getvalue().splitlines():
|
|
_, _, path = line.partition(" ")
|
|
if path is not None:
|
|
if path not in [x.path for x in rs]:
|
|
rs.append(RequiredSubmodule(path, True)) # add it with recursive since we don't know
|
|
return rs
|
|
|
|
def SetArchitectures(self, list_of_requested_architectures):
|
|
''' Confirm the requests architecture list is valid and configure SettingsManager
|
|
to run only the requested architectures.
|
|
|
|
Raise Exception if a list_of_requested_architectures is not supported
|
|
'''
|
|
unsupported = set(list_of_requested_architectures) - \
|
|
set(self.GetArchitecturesSupported())
|
|
if(len(unsupported) > 0):
|
|
errorString = (
|
|
"Unsupported Architecture Requested: " + " ".join(unsupported))
|
|
logging.critical(errorString)
|
|
raise Exception(errorString)
|
|
self.ActualArchitectures = list_of_requested_architectures
|
|
|
|
def GetWorkspaceRoot(self):
|
|
''' get WorkspacePath '''
|
|
return CommonPlatform.WorkspaceRoot
|
|
|
|
def GetActiveScopes(self):
|
|
''' return tuple containing scopes that should be active for this process '''
|
|
|
|
scopes = CommonPlatform.Scopes
|
|
ActualToolChainTag = shell_environment.GetBuildVars().GetValue("TOOL_CHAIN_TAG", "")
|
|
|
|
if GetHostInfo().os.upper() == "LINUX" and ActualToolChainTag.upper().startswith("GCC"):
|
|
if "AARCH64" in self.ActualArchitectures:
|
|
scopes += ("gcc_aarch64_linux",)
|
|
if "ARM" in self.ActualArchitectures:
|
|
scopes += ("gcc_arm_linux",)
|
|
return scopes
|
|
|
|
def FilterPackagesToTest(self, changedFilesList: list, potentialPackagesList: list) -> list:
|
|
''' Filter other cases that this package should be built
|
|
based on changed files. This should cover things that can't
|
|
be detected as dependencies. '''
|
|
build_these_packages = []
|
|
possible_packages = potentialPackagesList.copy()
|
|
for f in changedFilesList:
|
|
# BaseTools files that might change the build
|
|
if "BaseTools" in f:
|
|
if os.path.splitext(f) not in [".txt", ".md"]:
|
|
build_these_packages = possible_packages
|
|
break
|
|
|
|
# if the azure pipeline platform template file changed
|
|
if "platform-build-run-steps.yml" in f:
|
|
build_these_packages = possible_packages
|
|
break
|
|
|
|
|
|
return build_these_packages
|
|
|
|
def GetPlatformDscAndConfig(self) -> tuple:
|
|
''' If a platform desires to provide its DSC then Policy 4 will evaluate if
|
|
any of the changes will be built in the dsc.
|
|
|
|
The tuple should be (<workspace relative path to dsc file>, <input dictionary of dsc key value pairs>)
|
|
'''
|
|
return (CommonPlatform.DscName, {})
|
|
|
|
|
|
# ####################################################################################### #
|
|
# Actual Configuration for Platform Build #
|
|
# ####################################################################################### #
|
|
|
|
|
|
class PlatformBuilder(UefiBuilder, BuildSettingsManager):
|
|
def __init__(self):
|
|
UefiBuilder.__init__(self)
|
|
|
|
def AddCommandLineOptions(self, parserObj):
|
|
''' Add command line options to the argparser '''
|
|
parserObj.add_argument('-a', "--arch", dest="build_arch", type=str, default="AARCH64",
|
|
help="Optional - Architecture to build. Default = AARCH64")
|
|
|
|
def RetrieveCommandLineOptions(self, args):
|
|
''' Retrieve command line options from the argparser '''
|
|
|
|
shell_environment.GetBuildVars().SetValue(
|
|
"TARGET_ARCH", args.build_arch.upper(), "From CmdLine")
|
|
|
|
shell_environment.GetBuildVars().SetValue(
|
|
"ACTIVE_PLATFORM", CommonPlatform.DscName, "From CmdLine")
|
|
|
|
def GetWorkspaceRoot(self):
|
|
''' get WorkspacePath '''
|
|
return CommonPlatform.WorkspaceRoot
|
|
|
|
def GetPackagesPath(self):
|
|
''' Return a list of workspace relative paths that should be mapped as edk2 PackagesPath '''
|
|
return ()
|
|
|
|
def GetActiveScopes(self):
|
|
''' return tuple containing scopes that should be active for this process '''
|
|
scopes = CommonPlatform.Scopes
|
|
ActualToolChainTag = shell_environment.GetBuildVars().GetValue("TOOL_CHAIN_TAG", "")
|
|
Arch = shell_environment.GetBuildVars().GetValue("TARGET_ARCH", "")
|
|
|
|
if GetHostInfo().os.upper() == "LINUX" and ActualToolChainTag.upper().startswith("GCC"):
|
|
if "AARCH64" == Arch:
|
|
scopes += ("gcc_aarch64_linux",)
|
|
elif "ARM" == Arch:
|
|
scopes += ("gcc_arm_linux",)
|
|
return scopes
|
|
|
|
def GetName(self):
|
|
''' Get the name of the repo, platform, or product being build '''
|
|
''' Used for naming the log file, among others '''
|
|
# check the startup nsh flag and if set then rename the log file.
|
|
# this helps in CI so we don't overwrite the build log since running
|
|
# uses the stuart_build command.
|
|
if(shell_environment.GetBuildVars().GetValue("MAKE_STARTUP_NSH", "FALSE") == "TRUE"):
|
|
return "ArmVirtPkg_With_Run"
|
|
return "ArmVirtPkg"
|
|
|
|
def GetLoggingLevel(self, loggerType):
|
|
''' Get the logging level for a given type
|
|
base == lowest logging level supported
|
|
con == Screen logging
|
|
txt == plain text file logging
|
|
md == markdown file logging
|
|
'''
|
|
return logging.DEBUG
|
|
|
|
def SetPlatformEnv(self):
|
|
logging.debug("PlatformBuilder SetPlatformEnv")
|
|
self.env.SetValue("PRODUCT_NAME", "ArmVirtQemu", "Platform Hardcoded")
|
|
self.env.SetValue("MAKE_STARTUP_NSH", "FALSE", "Default to false")
|
|
self.env.SetValue("QEMU_HEADLESS", "FALSE", "Default to false")
|
|
return 0
|
|
|
|
def PlatformPreBuild(self):
|
|
return 0
|
|
|
|
def PlatformPostBuild(self):
|
|
return 0
|
|
|
|
def FlashRomImage(self):
|
|
VirtualDrive = os.path.join(self.env.GetValue(
|
|
"BUILD_OUTPUT_BASE"), "VirtualDrive")
|
|
os.makedirs(VirtualDrive, exist_ok=True)
|
|
OutputPath_FV = os.path.join(
|
|
self.env.GetValue("BUILD_OUTPUT_BASE"), "FV")
|
|
Built_FV = os.path.join(OutputPath_FV, "QEMU_EFI.fd")
|
|
|
|
# pad fd to 64mb
|
|
with open(Built_FV, "ab") as fvfile:
|
|
fvfile.seek(0, os.SEEK_END)
|
|
additional = b'\0' * ((64 * 1024 * 1024)-fvfile.tell())
|
|
fvfile.write(additional)
|
|
|
|
# QEMU must be on that path
|
|
|
|
# Unique Command and Args parameters per ARCH
|
|
if (self.env.GetValue("TARGET_ARCH").upper() == "AARCH64"):
|
|
cmd = "qemu-system-aarch64"
|
|
args = "-M virt"
|
|
args += " -cpu cortex-a57" # emulate cpu
|
|
elif(self.env.GetValue("TARGET_ARCH").upper() == "ARM"):
|
|
cmd = "qemu-system-arm"
|
|
args = "-M virt,highmem=off"
|
|
args += " -cpu cortex-a15" # emulate cpu
|
|
else:
|
|
raise NotImplementedError()
|
|
|
|
# Common Args
|
|
args += CommonPlatform.FvQemuArg + Built_FV # path to fw
|
|
args += " -m 1024" # 1gb memory
|
|
# turn off network
|
|
args += " -net none"
|
|
# Serial messages out
|
|
args += " -serial stdio"
|
|
# Mount disk with startup.nsh
|
|
args += f" -drive file=fat:rw:{VirtualDrive},format=raw,media=disk"
|
|
|
|
# Conditional Args
|
|
if (self.env.GetValue("QEMU_HEADLESS").upper() == "TRUE"):
|
|
args += " -display none" # no graphics
|
|
else:
|
|
args += " -device virtio-gpu-pci" # add recommended QEMU graphics device
|
|
args += " -device qemu-xhci,id=usb" # add USB support for below devices
|
|
args += " -device usb-tablet,id=input0,bus=usb.0,port=1" # add a usb mouse
|
|
args += " -device usb-kbd,id=input1,bus=usb.0,port=2" # add a usb keyboard
|
|
|
|
if (self.env.GetValue("MAKE_STARTUP_NSH").upper() == "TRUE"):
|
|
f = open(os.path.join(VirtualDrive, "startup.nsh"), "w")
|
|
f.write("BOOT SUCCESS !!! \n")
|
|
# add commands here
|
|
f.write("reset -s\n")
|
|
f.close()
|
|
|
|
ret = RunCmd(cmd, args)
|
|
|
|
if ret == 0xc0000005:
|
|
# for some reason getting a c0000005 on successful return
|
|
return 0
|
|
|
|
return ret
|