| #!/usr/bin/env python2 |
| """Script to bootstrap the chroot using new toolchain. |
| |
| This script allows you to build/install a customized version of gcc/binutils, |
| either by specifying branch or a local directory. |
| |
| This script must be executed outside chroot. |
| |
| Below is some typical usage - |
| |
| ## Build gcc located at /local/gcc/dir and do a bootstrap using the new |
| ## compiler for the chromeos root. The script tries to find a valid chromeos |
| ## tree all the way up from your current working directory. |
| ./build_tool.py --gcc_dir=/loca/gcc/dir --bootstrap |
| |
| ## Build binutils, using remote branch "mobile_toolchain_v17" and do a |
| ## bootstrap using the new binutils for the chromeos root. The script tries to |
| ## find a valid chromeos tree all the way up from your current working |
| ## directory. |
| ./build_tool.py --binutils_branch=cros/mobile_toolchain_v17 \ |
| --chromeos_root=/chromeos/dir --bootstrap |
| |
| ## Same as above except only do it for board daisy - no bootstrapping involved. |
| ./build_tool.py --binutils_branch=cros/mobile_toolchain_v16 \ |
| --chromeos_root=/chromeos/dir --board=daisy |
| """ |
| |
| from __future__ import print_function |
| |
| __author__ = 'shenhan@google.com (Han Shen)' |
| |
| import argparse |
| import os |
| import re |
| import sys |
| |
| from cros_utils import command_executer |
| from cros_utils import logger |
| from cros_utils import misc |
| import repo_to_repo |
| |
| REPO_PATH_PATTERN = 'src/third_party/{0}' |
| TEMP_BRANCH_NAME = 'internal_testing_branch_no_use' |
| CHROMIUMOS_OVERLAY_PATH = 'src/third_party/chromiumos-overlay' |
| EBUILD_PATH_PATTERN = 'src/third_party/chromiumos-overlay/sys-devel/{0}' |
| |
| |
| class Bootstrapper(object): |
| """Class that handles bootstrap process.""" |
| |
| def __init__(self, |
| chromeos_root, |
| ndk_dir, |
| gcc_branch=None, |
| gcc_dir=None, |
| binutils_branch=None, |
| binutils_dir=None, |
| board=None, |
| disable_2nd_bootstrap=False, |
| setup_tool_ebuild_file_only=False): |
| self._chromeos_root = chromeos_root |
| self._ndk_dir = ndk_dir |
| |
| self._gcc_branch = gcc_branch |
| self._gcc_branch_tree = None |
| self._gcc_dir = gcc_dir |
| self._gcc_ebuild_file = None |
| self._gcc_ebuild_file_name = None |
| |
| self._binutils_branch = binutils_branch |
| self._binutils_branch_tree = None |
| self._binutils_dir = binutils_dir |
| self._binutils_ebuild_file = None |
| self._binutils_ebuild_file_name = None |
| |
| self._setup_tool_ebuild_file_only = setup_tool_ebuild_file_only |
| |
| self._ce = command_executer.GetCommandExecuter() |
| self._logger = logger.GetLogger() |
| self._board = board |
| self._disable_2nd_bootstrap = disable_2nd_bootstrap |
| |
| def IsTreeSame(self, t1, t2): |
| diff = 'diff -qr -x .git -x .svn "{0}" "{1}"'.format(t1, t2) |
| if self._ce.RunCommand(diff, print_to_console=False) == 0: |
| self._logger.LogOutput('"{0}" and "{1}" are the same."'.format(t1, t2)) |
| return True |
| self._logger.LogWarning('"{0}" and "{1}" are different."'.format(t1, t2)) |
| return False |
| |
| def SubmitToLocalBranch(self): |
| """Copy source code to the chromium source tree and submit it locally.""" |
| if self._gcc_dir: |
| if not self.SubmitToolToLocalBranch( |
| tool_name='gcc', tool_dir=self._gcc_dir): |
| return False |
| self._gcc_branch = TEMP_BRANCH_NAME |
| |
| if self._binutils_dir: |
| if not self.SubmitToolToLocalBranch( |
| tool_name='binutils', tool_dir=self._binutils_dir): |
| return False |
| self._binutils_branch = TEMP_BRANCH_NAME |
| |
| return True |
| |
| def SubmitToolToLocalBranch(self, tool_name, tool_dir): |
| """Copy the source code to local chromium source tree. |
| |
| Args: |
| tool_name: either 'gcc' or 'binutils' |
| tool_dir: the tool source dir to be used |
| |
| Returns: |
| True if all succeeded False otherwise. |
| """ |
| |
| # The next few steps creates an internal branch to sync with the tool dir |
| # user provided. |
| chrome_tool_dir = self.GetChromeOsToolDir(tool_name) |
| |
| # 0. Test to see if git tree is free of local changes. |
| if not misc.IsGitTreeClean(chrome_tool_dir): |
| self._logger.LogError( |
| 'Git repository "{0}" not clean, aborted.'.format(chrome_tool_dir)) |
| return False |
| |
| # 1. Checkout/create a (new) branch for testing. |
| command = 'cd "{0}" && git checkout -B {1}'.format(chrome_tool_dir, |
| TEMP_BRANCH_NAME) |
| ret = self._ce.RunCommand(command) |
| if ret: |
| self._logger.LogError('Failed to create a temp branch for test, aborted.') |
| return False |
| |
| if self.IsTreeSame(tool_dir, chrome_tool_dir): |
| self._logger.LogOutput('"{0}" and "{1}" are the same, sync skipped.'. |
| format(tool_dir, chrome_tool_dir)) |
| return True |
| |
| # 2. Sync sources from user provided tool dir to chromiumos tool git. |
| local_tool_repo = repo_to_repo.FileRepo(tool_dir) |
| chrome_tool_repo = repo_to_repo.GitRepo(chrome_tool_dir, TEMP_BRANCH_NAME) |
| chrome_tool_repo.SetRoot(chrome_tool_dir) |
| # Delete all stuff except '.git' before start mapping. |
| self._ce.RunCommand( |
| 'cd {0} && find . -maxdepth 1 -not -name ".git" -not -name "." ' |
| r'\( -type f -exec rm {{}} \; -o ' |
| r' -type d -exec rm -fr {{}} \; \)'.format(chrome_tool_dir)) |
| local_tool_repo.MapSources(chrome_tool_repo.GetRoot()) |
| |
| # 3. Ensure after sync tree is the same. |
| if self.IsTreeSame(tool_dir, chrome_tool_dir): |
| self._logger.LogOutput('Sync successfully done.') |
| else: |
| self._logger.LogError('Sync not successful, aborted.') |
| return False |
| |
| # 4. Commit all changes. |
| # 4.1 Try to get some information about the tool dir we are using. |
| cmd = 'cd {0} && git log -1 --pretty=oneline'.format(tool_dir) |
| tool_dir_extra_info = None |
| ret, tool_dir_extra_info, _ = self._ce.RunCommandWOutput( |
| cmd, print_to_console=False) |
| commit_message = 'Synced with tool source tree at - "{0}".'.format(tool_dir) |
| if not ret: |
| commit_message += '\nGit log for {0}:\n{1}'.format( |
| tool_dir, tool_dir_extra_info.strip()) |
| |
| if chrome_tool_repo.CommitLocally(commit_message): |
| self._logger.LogError('Commit to local branch "{0}" failed, aborted.'. |
| format(TEMP_BRANCH_NAME)) |
| return False |
| return True |
| |
| def CheckoutBranch(self): |
| """Checkout working branch for the tools. |
| |
| Returns: |
| True: if operation succeeds. |
| """ |
| |
| if self._gcc_branch: |
| rv = self.CheckoutToolBranch('gcc', self._gcc_branch) |
| if rv: |
| self._gcc_branch_tree = rv |
| else: |
| return False |
| |
| if self._binutils_branch: |
| rv = self.CheckoutToolBranch('binutils', self._binutils_branch) |
| if rv: |
| self._binutils_branch_tree = rv |
| else: |
| return False |
| |
| return True |
| |
| def CheckoutToolBranch(self, tool_name, tool_branch): |
| """Checkout the tool branch for a certain tool. |
| |
| Args: |
| tool_name: either 'gcc' or 'binutils' |
| tool_branch: tool branch to use |
| |
| Returns: |
| True: if operation succeeds. Otherwise False. |
| """ |
| |
| chrome_tool_dir = self.GetChromeOsToolDir(tool_name) |
| command = 'cd "{0}" && git checkout {1}'.format(chrome_tool_dir, |
| tool_branch) |
| if not self._ce.RunCommand(command, print_to_console=True): |
| # Get 'TREE' value of this commit |
| command = ('cd "{0}" && git cat-file -p {1} ' |
| '| grep -E "^tree [a-f0-9]+$" ' |
| '| cut -d" " -f2').format(chrome_tool_dir, tool_branch) |
| ret, stdout, _ = self._ce.RunCommandWOutput( |
| command, print_to_console=False) |
| # Pipe operation always has a zero return value. So need to check if |
| # stdout is valid. |
| if not ret and stdout and re.match('[0-9a-h]{40}', |
| stdout.strip(), re.IGNORECASE): |
| tool_branch_tree = stdout.strip() |
| self._logger.LogOutput('Find tree for {0} branch "{1}" - "{2}"'.format( |
| tool_name, tool_branch, tool_branch_tree)) |
| return tool_branch_tree |
| self._logger.LogError(('Failed to checkout "{0}" or failed to ' |
| 'get tree value, aborted.').format(tool_branch)) |
| return None |
| |
| def FindEbuildFile(self): |
| """Find the ebuild files for the tools. |
| |
| Returns: |
| True: if operation succeeds. |
| """ |
| |
| if self._gcc_branch: |
| (rv, ef, efn) = self.FindToolEbuildFile('gcc') |
| if rv: |
| self._gcc_ebuild_file = ef |
| self._gcc_ebuild_file_name = efn |
| else: |
| return False |
| |
| if self._binutils_branch: |
| (rv, ef, efn) = self.FindToolEbuildFile('binutils') |
| if rv: |
| self._binutils_ebuild_file = ef |
| self._binutils_ebuild_file_name = efn |
| else: |
| return False |
| |
| return True |
| |
| def FindToolEbuildFile(self, tool_name): |
| """Find ebuild file for a specific tool. |
| |
| Args: |
| tool_name: either "gcc" or "binutils". |
| |
| Returns: |
| A triplet that consisits of whether operation succeeds or not, |
| tool ebuild file full path and tool ebuild file name. |
| """ |
| |
| # To get the active gcc ebuild file, we need a workable chroot first. |
| if not os.path.exists( |
| os.path.join(self._chromeos_root, 'chroot')) and self._ce.RunCommand( |
| 'cd "{0}" && cros_sdk --create'.format(self._chromeos_root)): |
| self._logger.LogError(('Failed to install a initial chroot, aborted.\n' |
| 'If previous bootstrap failed, do a ' |
| '"cros_sdk --delete" to remove ' |
| 'in-complete chroot.')) |
| return (False, None, None) |
| |
| rv, stdout, _ = self._ce.ChrootRunCommandWOutput( |
| self._chromeos_root, |
| 'equery w sys-devel/{0}'.format(tool_name), |
| print_to_console=True) |
| if rv: |
| self._logger.LogError( |
| ('Failed to execute inside chroot ' |
| '"equery w sys-devel/{0}", aborted.').format(tool_name)) |
| return (False, None, None) |
| m = re.match(r'^.*/({0}/(.*\.ebuild))$'.format( |
| EBUILD_PATH_PATTERN.format(tool_name)), stdout) |
| if not m: |
| self._logger.LogError( |
| ('Failed to find {0} ebuild file, aborted. ' |
| 'If previous bootstrap failed, do a "cros_sdk --delete" to remove ' |
| 'in-complete chroot.').format(tool_name)) |
| return (False, None, None) |
| tool_ebuild_file = os.path.join(self._chromeos_root, m.group(1)) |
| tool_ebuild_file_name = m.group(2) |
| |
| return (True, tool_ebuild_file, tool_ebuild_file_name) |
| |
| def InplaceModifyEbuildFile(self): |
| """Modify the ebuild file. |
| |
| Returns: |
| True if operation succeeds. |
| """ |
| |
| # Note we shall not use remote branch name (eg. "cros/gcc.gnu.org/...") in |
| # CROS_WORKON_COMMIT, we have to use GITHASH. So we call GitGetCommitHash on |
| # tool_branch. |
| tool = None |
| toolbranch = None |
| if self._gcc_branch: |
| tool = 'gcc' |
| toolbranch = self._gcc_branch |
| tooltree = self._gcc_branch_tree |
| toolebuild = self._gcc_ebuild_file |
| elif self._binutils_branch: |
| tool = 'binutils' |
| toolbranch = self._binutils_branch |
| tooltree = self._binutils_branch_tree |
| toolebuild = self._binutils_ebuild_file |
| |
| assert tool |
| |
| # An example for the following variables would be: |
| # tooldir = '~/android/master-ndk/toolchain/gcc/gcc-4.9' |
| # tool_branch_githash = xxxxx |
| # toolcomponents = toolchain/gcc |
| tooldir = self.GetChromeOsToolDir(tool) |
| toolgithash = misc.GitGetCommitHash(tooldir, toolbranch) |
| if not toolgithash: |
| return False |
| toolcomponents = 'toolchain/{}'.format(tool) |
| return self.InplaceModifyToolEbuildFile(toolcomponents, toolgithash, |
| tooltree, toolebuild) |
| |
| @staticmethod |
| def ResetToolEbuildFile(chromeos_root, tool_name): |
| """Reset tool ebuild file to clean state. |
| |
| Args: |
| chromeos_root: chromeos source tree |
| tool_name: either "gcc" or "binutils" |
| |
| Returns: |
| True if operation succeds. |
| """ |
| rv = misc.GetGitChangesAsList( |
| os.path.join(chromeos_root, CHROMIUMOS_OVERLAY_PATH), |
| path=('sys-devel/{0}/{0}-*.ebuild'.format(tool_name)), |
| staged=False) |
| if rv: |
| cmd = 'cd {0} && git checkout --'.format( |
| os.path.join(chromeos_root, CHROMIUMOS_OVERLAY_PATH)) |
| for g in rv: |
| cmd += ' ' + g |
| rv = command_executer.GetCommandExecuter().RunCommand(cmd) |
| if rv: |
| logger.GetLogger().LogWarning( |
| 'Failed to reset the ebuild file. Please refer to log above.') |
| return False |
| else: |
| logger.GetLogger().LogWarning( |
| 'Note - did not find any modified {0} ebuild file.'.format(tool_name)) |
| # Fall through |
| return True |
| |
| def GetChromeOsToolDir(self, tool_name): |
| """Return the chromeos git dir for a specific tool. |
| |
| Note, after we unified ChromeOs and Android, the tool dir is under |
| ndk_dir/toolchain/[gcc,binutils]. |
| |
| Args: |
| tool_name: either 'gcc' or 'binutils'. |
| |
| Returns: |
| Absolute git path for the tool. |
| """ |
| |
| tool_toppath = os.path.join(self._ndk_dir, 'toolchain', tool_name) |
| # There may be sub-directories like 'binutils-2.25', 'binutils-2.24', |
| # 'gcc-4.9', 'gcc-4.8', etc. find the newest binutils version. |
| cmd = ('find {} -maxdepth 1 -type d -name "{}-*" ' |
| '| sort -r | head -1').format(tool_toppath, tool_name) |
| rv, out, _ = self._ce.RunCommandWOutput(cmd, print_to_console=False) |
| if rv: |
| return None |
| repo = out.strip() |
| |
| # cros-workon eclass expects every CROS_WORKON_PROJECT ends with ".git". |
| self._ce.RunCommand(('cd $(dirname {0}) && ' |
| 'ln -sf $(basename {0}) $(basename {0}).git').format( |
| repo, print_to_console=True)) |
| return repo |
| |
| def InplaceModifyToolEbuildFile(self, tool_components, tool_branch_githash, |
| tool_branch_tree, tool_ebuild_file): |
| """Using sed to fill properly values into the ebuild file. |
| |
| Args: |
| tool_components: either "toolchain/gcc" or "toolchain/binutils" |
| tool_branch_githash: githash for tool_branch |
| tool_branch_tree: treeish for the tool branch |
| tool_ebuild_file: tool ebuild file |
| |
| Returns: |
| True: if operation succeeded. |
| """ |
| |
| command = ('sed -i ' |
| '-e \'/^CROS_WORKON_REPO=".*"/i' |
| ' # The following line is modified by script.\' ' |
| '-e \'s!^CROS_WORKON_REPO=".*"$!CROS_WORKON_REPO="{0}"!\' ' |
| '-e \'/^CROS_WORKON_PROJECT=".*"/i' |
| ' # The following line is modified by script.\' ' |
| '-e \'s!^CROS_WORKON_PROJECT=.*$!CROS_WORKON_PROJECT="{1}"!\' ' |
| '-e \'/^CROS_WORKON_COMMIT=".*"/i' |
| ' # The following line is modified by script.\' ' |
| '-e \'s!^CROS_WORKON_COMMIT=".*"$!CROS_WORKON_COMMIT="{2}"!\' ' |
| '-e \'/^CROS_WORKON_TREE=".*"/i' |
| ' # The following line is modified by script.\' ' |
| '-e \'s!^CROS_WORKON_TREE=".*"$!CROS_WORKON_TREE="{3}"!\' ' |
| '{4}').format('/home/{}/ndk-root'.format(os.environ['USER']), |
| tool_components, tool_branch_githash, |
| tool_branch_tree, tool_ebuild_file) |
| rv = self._ce.RunCommand(command) |
| if rv: |
| self._logger.LogError( |
| 'Failed to modify commit and tree value for "{0}"", aborted.'.format( |
| tool_ebuild_file)) |
| return False |
| |
| # Warn that the ebuild file has been modified. |
| self._logger.LogWarning( |
| ('Ebuild file "{0}" is modified, to revert the file - \n' |
| 'bootstrap_compiler.py --chromeos_root={1} ' |
| '--reset_tool_ebuild_file').format(tool_ebuild_file, |
| self._chromeos_root)) |
| return True |
| |
| def DoBuildForBoard(self): |
| """Build tool for a specific board. |
| |
| Returns: |
| True if operation succeeds. |
| """ |
| |
| if self._gcc_branch: |
| if not self.DoBuildToolForBoard('gcc'): |
| return False |
| if self._binutils_branch: |
| if not self.DoBuildToolForBoard('binutils'): |
| return False |
| return True |
| |
| def DoBuildToolForBoard(self, tool_name): |
| """Build a specific tool for a specific board. |
| |
| Args: |
| tool_name: either "gcc" or "binutils" |
| |
| Returns: |
| True if operation succeeds. |
| """ |
| |
| chroot_ndk_root = os.path.join(self._chromeos_root, 'chroot', 'home', |
| os.environ['USER'], 'ndk-root') |
| self._ce.RunCommand('mkdir -p {}'.format(chroot_ndk_root)) |
| if self._ce.RunCommand( |
| 'sudo mount --bind {} {}'.format(self._ndk_dir, chroot_ndk_root)): |
| self._logger.LogError('Failed to mount ndk dir into chroot') |
| return False |
| |
| try: |
| boards_to_build = self._board.split(',') |
| target_built = set() |
| failed = [] |
| for board in boards_to_build: |
| if board == 'host': |
| command = 'sudo emerge sys-devel/{0}'.format(tool_name) |
| else: |
| target = misc.GetCtargetFromBoard(board, self._chromeos_root) |
| if not target: |
| self._logger.LogError( |
| 'Unsupported board "{0}", skip.'.format(board)) |
| failed.append(board) |
| continue |
| # Skip this board if we have already built for a board that has the |
| # same target. |
| if target in target_built: |
| self._logger.LogWarning( |
| 'Skipping toolchain for board "{}"'.format(board)) |
| continue |
| target_built.add(target) |
| command = 'sudo emerge cross-{0}/{1}'.format(target, tool_name) |
| |
| rv = self._ce.ChrootRunCommand( |
| self._chromeos_root, command, print_to_console=True) |
| if rv: |
| self._logger.LogError( |
| 'Build {0} failed for {1}, aborted.'.format(tool_name, board)) |
| failed.append(board) |
| else: |
| self._logger.LogOutput( |
| 'Successfully built {0} for board {1}.'.format(tool_name, board)) |
| finally: |
| # Make sure we un-mount ndk-root before we leave here, regardless of the |
| # build result of the tool. Otherwise we may inadvertently delete ndk-root |
| # dir, which is not part of the chroot and could be disastrous. |
| if chroot_ndk_root: |
| if self._ce.RunCommand('sudo umount {}'.format(chroot_ndk_root)): |
| self._logger.LogWarning( |
| ('Failed to umount "{}", please check ' |
| 'before deleting chroot.').format(chroot_ndk_root)) |
| |
| # Clean up soft links created during build. |
| self._ce.RunCommand('cd {}/toolchain/{} && git clean -df'.format( |
| self._ndk_dir, tool_name)) |
| |
| if failed: |
| self._logger.LogError( |
| 'Failed to build {0} for the following board(s): "{1}"'.format( |
| tool_name, ' '.join(failed))) |
| return False |
| # All boards build successfully |
| return True |
| |
| def DoBootstrapping(self): |
| """Do bootstrapping the chroot. |
| |
| This step firstly downloads a prestine sdk, then use this sdk to build the |
| new sdk, finally use the new sdk to build every host package. |
| |
| Returns: |
| True if operation succeeds. |
| """ |
| |
| logfile = os.path.join(self._chromeos_root, 'bootstrap.log') |
| command = 'cd "{0}" && cros_sdk --delete --bootstrap |& tee "{1}"'.format( |
| self._chromeos_root, logfile) |
| rv = self._ce.RunCommand(command, print_to_console=True) |
| if rv: |
| self._logger.LogError( |
| 'Bootstrapping failed, log file - "{0}"\n'.format(logfile)) |
| return False |
| |
| self._logger.LogOutput('Bootstrap succeeded.') |
| return True |
| |
| def BuildAndInstallAmd64Host(self): |
| """Build amd64-host (host) packages. |
| |
| Build all host packages in the newly-bootstrapped 'chroot' using *NEW* |
| toolchain. |
| |
| So actually we perform 2 builds of all host packages - |
| 1. build new toolchain using old toolchain and build all host packages |
| using the newly built toolchain |
| 2. build the new toolchain again but using new toolchain built in step 1, |
| and build all host packages using the newly built toolchain |
| |
| Returns: |
| True if operation succeeds. |
| """ |
| |
| cmd = 'cd {0} && cros_sdk -- -- ./build_sdk_board'.format( |
| self._chromeos_root) |
| rv = self._ce.RunCommand(cmd, print_to_console=True) |
| if rv: |
| self._logger.LogError('Build amd64-host failed.') |
| return False |
| |
| # Package amd64-host into 'built-sdk.tar.xz'. |
| sdk_package = os.path.join(self._chromeos_root, 'built-sdk.tar.xz') |
| cmd = ('cd {0}/chroot/build/amd64-host && sudo XZ_OPT="-e9" ' |
| 'tar --exclude="usr/lib/debug/*" --exclude="packages/*" ' |
| '--exclude="tmp/*" --exclude="usr/local/build/autotest/*" ' |
| '--sparse -I xz -vcf {1} . && sudo chmod a+r {1}').format( |
| self._chromeos_root, sdk_package) |
| rv = self._ce.RunCommand(cmd, print_to_console=True) |
| if rv: |
| self._logger.LogError('Failed to create "built-sdk.tar.xz".') |
| return False |
| |
| # Install amd64-host into a new chroot. |
| cmd = ('cd {0} && cros_sdk --chroot new-sdk-chroot --download --replace ' |
| '--nousepkg --url file://{1}').format(self._chromeos_root, |
| sdk_package) |
| rv = self._ce.RunCommand(cmd, print_to_console=True) |
| if rv: |
| self._logger.LogError('Failed to install "built-sdk.tar.xz".') |
| return False |
| self._logger.LogOutput( |
| 'Successfully installed built-sdk.tar.xz into a new chroot.\nAll done.') |
| |
| # Rename the newly created new-sdk-chroot to chroot. |
| cmd = ('cd {0} && sudo mv chroot chroot-old && ' |
| 'sudo mv new-sdk-chroot chroot').format(self._chromeos_root) |
| rv = self._ce.RunCommand(cmd, print_to_console=True) |
| return rv == 0 |
| |
| def Do(self): |
| """Entrance of the class. |
| |
| Returns: |
| True if everything is ok. |
| """ |
| |
| if (self.SubmitToLocalBranch() and self.CheckoutBranch() and |
| self.FindEbuildFile() and self.InplaceModifyEbuildFile()): |
| if self._setup_tool_ebuild_file_only: |
| # Everything is done, we are good. |
| ret = True |
| else: |
| if self._board: |
| ret = self.DoBuildForBoard() |
| else: |
| # This implies '--bootstrap'. |
| ret = (self.DoBootstrapping() and (self._disable_2nd_bootstrap or |
| self.BuildAndInstallAmd64Host())) |
| else: |
| ret = False |
| return ret |
| |
| |
| def Main(argv): |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| '-c', |
| '--chromeos_root', |
| dest='chromeos_root', |
| help=('Optional. ChromeOs root dir. ' |
| 'When not specified, chromeos root will be deduced' |
| ' from current working directory.')) |
| parser.add_argument( |
| '--ndk_dir', |
| dest='ndk_dir', |
| help=('Topmost android ndk dir, required. ' |
| 'Do not need to include the "toolchain/*" part.')) |
| parser.add_argument( |
| '--gcc_branch', |
| dest='gcc_branch', |
| help=('The branch to test against. ' |
| 'This branch must be a local branch ' |
| 'inside "src/third_party/gcc". ' |
| 'Notice, this must not be used with "--gcc_dir".')) |
| parser.add_argument( |
| '--binutils_branch', |
| dest='binutils_branch', |
| help=('The branch to test against binutils. ' |
| 'This branch must be a local branch ' |
| 'inside "src/third_party/binutils". ' |
| 'Notice, this must not be used with ' |
| '"--binutils_dir".')) |
| parser.add_argument( |
| '-g', |
| '--gcc_dir', |
| dest='gcc_dir', |
| help=('Use a local gcc tree to do bootstrapping. ' |
| 'Notice, this must not be used with ' |
| '"--gcc_branch".')) |
| parser.add_argument( |
| '--binutils_dir', |
| dest='binutils_dir', |
| help=('Use a local binutils tree to do bootstrapping. ' |
| 'Notice, this must not be used with ' |
| '"--binutils_branch".')) |
| parser.add_argument( |
| '--fixperm', |
| dest='fixperm', |
| default=False, |
| action='store_true', |
| help=('Fix the (notorious) permission error ' |
| 'while trying to bootstrap the chroot. ' |
| 'Note this takes an extra 10-15 minutes ' |
| 'and is only needed once per chromiumos tree.')) |
| parser.add_argument( |
| '--setup_tool_ebuild_file_only', |
| dest='setup_tool_ebuild_file_only', |
| default=False, |
| action='store_true', |
| help=('Setup gcc and/or binutils ebuild file ' |
| 'to pick up the branch (--gcc/binutils_branch) or ' |
| 'use gcc and/or binutils source ' |
| '(--gcc/binutils_dir) and exit. Keep chroot as is.' |
| ' This should not be used with ' |
| '--gcc/binutils_dir/branch options.')) |
| parser.add_argument( |
| '--reset_tool_ebuild_file', |
| dest='reset_tool_ebuild_file', |
| default=False, |
| action='store_true', |
| help=('Reset the modification that is done by this ' |
| 'script. Note, when this script is running, it ' |
| 'will modify the active gcc/binutils ebuild file. ' |
| 'Use this option to reset (what this script has ' |
| 'done) and exit. This should not be used with -- ' |
| 'gcc/binutils_dir/branch options.')) |
| parser.add_argument( |
| '--board', |
| dest='board', |
| default=None, |
| help=('Only build toolchain for specific board(s). ' |
| 'Use "host" to build for host. ' |
| 'Use "," to seperate multiple boards. ' |
| 'This does not perform a chroot bootstrap.')) |
| parser.add_argument( |
| '--bootstrap', |
| dest='bootstrap', |
| default=False, |
| action='store_true', |
| help=('Performs a chroot bootstrap. ' |
| 'Note, this will *destroy* your current chroot.')) |
| parser.add_argument( |
| '--disable-2nd-bootstrap', |
| dest='disable_2nd_bootstrap', |
| default=False, |
| action='store_true', |
| help=('Disable a second bootstrap ' |
| '(build of amd64-host stage).')) |
| |
| options = parser.parse_args(argv) |
| # Trying to deduce chromeos root from current directory. |
| if not options.chromeos_root: |
| logger.GetLogger().LogOutput('Trying to deduce chromeos root ...') |
| wdir = os.getcwd() |
| while wdir and wdir != '/': |
| if misc.IsChromeOsTree(wdir): |
| logger.GetLogger().LogOutput('Find chromeos_root: {}'.format(wdir)) |
| options.chromeos_root = wdir |
| break |
| wdir = os.path.dirname(wdir) |
| |
| if not options.chromeos_root: |
| parser.error('Missing or failing to deduce mandatory option "--chromeos".') |
| return 1 |
| |
| options.chromeos_root = os.path.abspath( |
| os.path.expanduser(options.chromeos_root)) |
| |
| if not os.path.isdir(options.chromeos_root): |
| logger.GetLogger().LogError( |
| '"{0}" does not exist.'.format(options.chromeos_root)) |
| return 1 |
| |
| options.ndk_dir = os.path.expanduser(options.ndk_dir) |
| if not options.ndk_dir: |
| parser.error('Missing mandatory option "--ndk_dir".') |
| return 1 |
| |
| # Some tolerance regarding user input. We only need the ndk_root part, do not |
| # include toolchain/(gcc|binutils)/ part in this option. |
| options.ndk_dir = re.sub('/toolchain(/gcc|/binutils)?/?$', '', |
| options.ndk_dir) |
| |
| if not (os.path.isdir(options.ndk_dir) and |
| os.path.isdir(os.path.join(options.ndk_dir, 'toolchain'))): |
| logger.GetLogger().LogError( |
| '"toolchain" directory not found under "{0}".'.format(options.ndk_dir)) |
| return 1 |
| |
| if options.fixperm: |
| # Fix perm error before continuing. |
| cmd = (r'sudo find "{0}" \( -name ".cache" -type d -prune \) -o ' |
| r'\( -name "chroot" -type d -prune \) -o ' |
| r'\( -type f -exec chmod a+r {{}} \; \) -o ' |
| r'\( -type d -exec chmod a+rx {{}} \; \)' |
| ).format(options.chromeos_root) |
| logger.GetLogger().LogOutput( |
| 'Fixing perm issues for chromeos root, this might take some time.') |
| command_executer.GetCommandExecuter().RunCommand(cmd) |
| |
| if options.reset_tool_ebuild_file: |
| if (options.gcc_dir or options.gcc_branch or options.binutils_dir or |
| options.binutils_branch): |
| logger.GetLogger().LogWarning( |
| 'Ignoring any "--gcc/binutils_dir" and/or "--gcc/binutils_branch".') |
| if options.setup_tool_ebuild_file_only: |
| logger.GetLogger().LogError( |
| ('Conflict options "--reset_tool_ebuild_file" ' |
| 'and "--setup_tool_ebuild_file_only".')) |
| return 1 |
| rv = Bootstrapper.ResetToolEbuildFile(options.chromeos_root, 'gcc') |
| rv1 = Bootstrapper.ResetToolEbuildFile(options.chromeos_root, 'binutils') |
| return 0 if (rv and rv1) else 1 |
| |
| if options.gcc_dir: |
| options.gcc_dir = os.path.abspath(os.path.expanduser(options.gcc_dir)) |
| if not os.path.isdir(options.gcc_dir): |
| logger.GetLogger().LogError( |
| '"{0}" does not exist.'.format(options.gcc_dir)) |
| return 1 |
| |
| if options.gcc_branch and options.gcc_dir: |
| parser.error('Only one of "--gcc_dir" and "--gcc_branch" can be specified.') |
| return 1 |
| |
| if options.binutils_dir: |
| options.binutils_dir = os.path.abspath( |
| os.path.expanduser(options.binutils_dir)) |
| if not os.path.isdir(options.binutils_dir): |
| logger.GetLogger().LogError( |
| '"{0}" does not exist.'.format(options.binutils_dir)) |
| return 1 |
| |
| if options.binutils_branch and options.binutils_dir: |
| parser.error('Only one of "--binutils_dir" and ' |
| '"--binutils_branch" can be specified.') |
| return 1 |
| |
| if (not (options.binutils_branch or options.binutils_dir or |
| options.gcc_branch or options.gcc_dir)): |
| parser.error(('At least one of "--gcc_dir", "--gcc_branch", ' |
| '"--binutils_dir" and "--binutils_branch" must ' |
| 'be specified.')) |
| return 1 |
| |
| if not options.board and not options.bootstrap: |
| parser.error('You must specify either "--board" or "--bootstrap".') |
| return 1 |
| |
| if (options.board and options.bootstrap and |
| not options.setup_tool_ebuild_file_only): |
| parser.error('You must specify only one of "--board" and "--bootstrap".') |
| return 1 |
| |
| if not options.bootstrap and options.disable_2nd_bootstrap: |
| parser.error('"--disable-2nd-bootstrap" has no effect ' |
| 'without specifying "--bootstrap".') |
| return 1 |
| |
| if Bootstrapper( |
| options.chromeos_root, |
| options.ndk_dir, |
| gcc_branch=options.gcc_branch, |
| gcc_dir=options.gcc_dir, |
| binutils_branch=options.binutils_branch, |
| binutils_dir=options.binutils_dir, |
| board=options.board, |
| disable_2nd_bootstrap=options.disable_2nd_bootstrap, |
| setup_tool_ebuild_file_only=options.setup_tool_ebuild_file_only).Do(): |
| return 0 |
| return 1 |
| |
| |
| if __name__ == '__main__': |
| retval = Main(sys.argv[1:]) |
| sys.exit(retval) |
