# @file # Script to Build EmulatorPkg 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 # ####################################################################################### # # Common Configuration # # ####################################################################################### # class CommonPlatform(): ''' Common settings for this platform. Define static data here and use for the different parts of stuart ''' PackagesSupported = ("EmulatorPkg",) ArchSupported = ("X64", "IA32") TargetsSupported = ("DEBUG", "RELEASE", "NOOPT") Scopes = ('emulatorpkg', 'edk2-build') WorkspaceRoot = os.path.realpath(os.path.join( os.path.dirname(os.path.abspath(__file__)), "..", "..")) # ####################################################################################### # # 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 ''' return CommonPlatform.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 (, ) ''' return (os.path.join("EmulatorPkg", "EmulatorPkg.dsc"), {}) # ####################################################################################### # # 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="X64", help="Optional - architecture to build. IA32 will use IA32 for Pei & Dxe. " "X64 will use X64 for both PEI and DXE.") 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", "EmulatorPkg/EmulatorPkg.dsc", "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 ''' return CommonPlatform.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 "EmulatorPkg_With_Run" return "EmulatorPkg" 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", "EmulatorPkg", "Platform Hardcoded") self.env.SetValue("TOOL_CHAIN_TAG", "VS2019", "Default Toolchain") # Add support for using the correct Platform Headers, tools, and Libs based on emulator architecture # requested to be built when building VS2019 or VS2017 if self.env.GetValue("TOOL_CHAIN_TAG") == "VS2019" or self.env.GetValue("TOOL_CHAIN_TAG") == "VS2017": key = self.env.GetValue("TOOL_CHAIN_TAG") + "_HOST" if self.env.GetValue("TARGET_ARCH") == "IA32": shell_environment.ShellEnvironment().set_shell_var(key, "x86") elif self.env.GetValue("TARGET_ARCH") == "X64": shell_environment.ShellEnvironment().set_shell_var(key, "x64") # Add support for using the correct Platform Headers, tools, and Libs based on emulator architecture # requested to be built when building on linux. if GetHostInfo().os.upper() == "LINUX": self.ConfigureLinuxDLinkPath() if GetHostInfo().os.upper() == "WINDOWS": self.env.SetValue("BLD_*_WIN_HOST_BUILD", "TRUE", "Trigger Windows host build") self.env.SetValue("MAKE_STARTUP_NSH", "FALSE", "Default to false") # I don't see what this does but it is in build.sh key = "BLD_*_BUILD_" + self.env.GetValue("TARGET_ARCH") self.env.SetValue(key, "TRUE", "match script in build.sh") return 0 def PlatformPreBuild(self): return 0 def PlatformPostBuild(self): return 0 def FlashRomImage(self): ''' Use the FlashRom Function to run the emulator. This gives an easy stuart command line to activate the emulator. ''' OutputPath = os.path.join(self.env.GetValue( "BUILD_OUTPUT_BASE"), self.env.GetValue("TARGET_ARCH")) if (self.env.GetValue("MAKE_STARTUP_NSH") == "TRUE"): f = open(os.path.join(OutputPath, "startup.nsh"), "w") f.write("BOOT SUCCESS !!! \n") # add commands here f.write("reset\n") f.close() if GetHostInfo().os.upper() == "WINDOWS": cmd = "WinHost.exe" elif GetHostInfo().os.upper() == "LINUX": cmd = "./Host" else: logging.critical("Unsupported Host") return -1 return RunCmd(cmd, "", workingdir=OutputPath) def ConfigureLinuxDLinkPath(self): ''' logic copied from build.sh to setup the correct libraries ''' if self.env.GetValue("TARGET_ARCH") == "IA32": LIB_NAMES = ["ld-linux.so.2", "libdl.so.2 crt1.o", "crti.o crtn.o"] LIB_SEARCH_PATHS = ["/usr/lib/i386-linux-gnu", "/usr/lib32", "/lib32", "/usr/lib", "/lib"] elif self.env.GetValue("TARGET_ARCH") == "X64": LIB_NAMES = ["ld-linux-x86-64.so.2", "libdl.so.2", "crt1.o", "crti.o", "crtn.o"] LIB_SEARCH_PATHS = ["/usr/lib/x86_64-linux-gnu", "/usr/lib64", "/lib64", "/usr/lib", "/lib"] HOST_DLINK_PATHS = "" for lname in LIB_NAMES: logging.debug(f"Looking for {lname}") for dname in LIB_SEARCH_PATHS: logging.debug(f"In {dname}") if os.path.isfile(os.path.join(dname, lname)): logging.debug(f"Found {lname} in {dname}") HOST_DLINK_PATHS += os.path.join( os.path.join(dname, lname)) + os.pathsep break HOST_DLINK_PATHS = HOST_DLINK_PATHS.rstrip(os.pathsep) logging.critical(f"Setting HOST_DLINK_PATHS to {HOST_DLINK_PATHS}") shell_environment.ShellEnvironment().set_shell_var( "HOST_DLINK_PATHS", HOST_DLINK_PATHS)