ArmVirtPkg/PlatformCI/PlatformBuildLib.py - third_party/edk2 - Git at Google

 # @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"
         # Provides Rng services to the Guest VM
         args += " -device virtio-rng-pci"

         # 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
	# @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"
	# Provides Rng services to the Guest VM
	args += " -device virtio-rng-pci"

	# 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