| #!/bin/bash |
| |
| # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| . "$(dirname "$0")/common.sh" || exit 1 |
| . "${SRC_ROOT}/platform/dev/toolchain_utils.sh" |
| |
| # Script must run inside the chroot |
| restart_in_chroot_if_needed "$@" |
| |
| assert_not_root_user |
| |
| # Developer-visible flags. |
| DEFINE_string board "$DEFAULT_BOARD" \ |
| "The name of the board to set up." |
| DEFINE_boolean default $FLAGS_FALSE \ |
| "Set board to the default board in your chroot" |
| DEFINE_boolean force $FLAGS_FALSE \ |
| "Force re-creating board root." |
| DEFINE_boolean usepkg $FLAGS_TRUE \ |
| "Use binary packages to bootstrap." |
| |
| FLAGS_HELP="usage: $(basename $0) [flags] |
| |
| setup_board sets up the sysroot for a particular board. This script is called |
| automatically when you run build_packages, so there is typically no need to |
| call it directly, unless you want to blow away your board (using --force). |
| " |
| show_help_if_requested "$@" |
| |
| # The following options are advanced options, only available to those willing |
| # to read the source code. They are not shown in help output, since they are |
| # not needed for the typical developer workflow. |
| DEFINE_string board_overlay "" \ |
| "Location of the board overlay." |
| DEFINE_boolean fast ${DEFAULT_FAST} "Call many emerges in parallel" |
| DEFINE_integer jobs -1 \ |
| "How many packages to build in parallel at maximum." |
| DEFINE_boolean latest_toolchain $FLAGS_FALSE \ |
| "Use the latest ebuild for all toolchain packages (gcc, binutils, libc, \ |
| kernel). This overrides the other toolchain version options." |
| DEFINE_string libc_version "[stable]" \ |
| "Version of libc to use." |
| DEFINE_string profile "" \ |
| "The portage configuration profile to use. Profile must be located in overlay-board/profiles" |
| DEFINE_boolean quiet $FLAGS_FALSE \ |
| "Don't print warnings when board already exists." |
| DEFINE_boolean skip_toolchain_update $FLAGS_FALSE \ |
| "Don't update toolchain automatically." |
| DEFINE_boolean skip_chroot_upgrade $FLAGS_FALSE \ |
| "Don't run the chroot upgrade automatically; use with care." |
| DEFINE_string toolchain "" \ |
| "Toolchain. For example: i686-pc-linux-gnu, armv7a-softfloat-linux-gnueabi" |
| DEFINE_string variant "" \ |
| "Board variant." |
| |
| # The --reuse_pkgs_from_local_boards flag tells Portage to share binary |
| # packages between boards that are built locally, so that the total time |
| # required to build several boards is reduced. This flag is only useful |
| # when you are not able to use remote binary packages, since remote binary |
| # packages are usually more up to date than anything you have locally. |
| DEFINE_boolean reuse_pkgs_from_local_boards $FLAGS_FALSE \ |
| "Bootstrap from local packages instead of remote packages." |
| |
| |
| # builds wrappers like equery-arm-generic. |
| # args: |
| # $1: command to wrap |
| # rest: extra arguments to pass to the command |
| generate_wrapper() { |
| local command="${1}" |
| shift |
| local extra_args="$@" |
| |
| |
| local target="/usr/local/bin/${command}-${BOARD_VARIANT}" |
| sudo_clobber "${target}" <<EOF |
| #!/bin/bash |
| |
| export CHROMEOS_ROOT="$GCLIENT_ROOT" |
| export CHOST="$FLAGS_toolchain" |
| export PORTAGE_CONFIGROOT="$BOARD_ROOT" |
| export SYSROOT="$BOARD_ROOT" |
| if [ -z "\$PORTAGE_USERNAME" ]; then |
| export PORTAGE_USERNAME=\$(basename \$HOME) |
| fi |
| export ROOT="$BOARD_ROOT" |
| exec sudo -E ${command} ${extra_args} "\$@" |
| EOF |
| sudo chmod +rx ${target} |
| sudo chown root:root ${target} |
| eval ${command^^}_WRAPPER="${target}" # ${foo^^} returns toupper($foo) |
| echo created wrapper ${target} |
| } |
| |
| generate_pkgconfig_wrapper() { |
| local target="/usr/local/bin/pkg-config-${BOARD_VARIANT}" |
| sudo_clobber "${target}" <<EOF |
| #!/bin/bash |
| |
| PKG_CONFIG_LIBDIR="${BOARD_ROOT}/usr/lib/pkgconfig:\ |
| ${BOARD_ROOT}/usr/lib64/pkgconfig:\ |
| ${BOARD_ROOT}/usr/share/pkgconfig" |
| export PKG_CONFIG_LIBDIR |
| |
| export PKG_CONFIG_SYSROOT_DIR="${BOARD_ROOT}" |
| |
| exec pkg-config "\$@" |
| EOF |
| sudo chmod a+rx ${target} |
| sudo chown root:root ${target} |
| echo created wrapper pkg-config |
| } |
| |
| # Checks whether the libc version installed in the board |
| # matches the one installed by the toolchain. |
| board_needs_libc_update() { |
| local board_version=$(. "${BOARD_SETUP}"; echo "${LIBC_VERSION}") |
| local toolchain_version=$(cross_get_version glibc) |
| if [[ "${board_version}" = "${toolchain_version}" ]]; then |
| return 1 |
| fi |
| return 0 |
| } |
| |
| # Get the version number of a toolchain package. |
| cross_get_version() { |
| local pkg="$1" |
| local toolchain="${2:-${FLAGS_toolchain}}" |
| local cpv="" |
| if [[ "$CHOST" != "${toolchain}" ]]; then |
| if [[ "$pkg" = "gcc" ]]; then |
| # Users can install multiple versions of gcc at once, so we need to call |
| # gcc-config to find out which installed version is selected. |
| local path=$(CTARGET=${toolchain} gcc-config -B || true) |
| cpv=$(portageq owners / $path | sed -e '/^\t/d') |
| else |
| cpv=$(portageq match / cross-${toolchain}/${pkg} || true) |
| fi |
| else |
| if [[ "$pkg" = binutils ]] ; then |
| cpv=$(portageq match / sys-devel/binutils || true) |
| elif [[ "$pkg" = glibc ]] ; then |
| cpv=$(portageq match / sys-libs/glibc || true) |
| elif [[ "$pkg" = gcc ]] ; then |
| cpv=$(portageq match / sys-devel/gcc || true) |
| else |
| die "Unknown pkg ${pkg}" |
| fi |
| fi |
| local cp=$(echo $cpv | sed -e 's/-r[0-9]*$//; s/-[^-]*$//') |
| local result="${cpv#$cp-}" |
| local count="$(echo $result | wc -w)" |
| if [ "$count" -gt "1" ]; then |
| die "Multiple versions of $pkg installed" |
| elif [ "$count" -lt "1" ]; then |
| die "Cannot find $pkg" |
| fi |
| echo $result |
| } |
| |
| install_toolchain_in_provided() { |
| local binutils_ver="$1" |
| local gcc_ver="$2" |
| local glibc_ver="$3" |
| # Tell portage that toolchain packages are already installed in the sysroot. |
| ( |
| echo sys-devel/gcc-$gcc_ver |
| echo sys-libs/glibc-$glibc_ver |
| ) | sudo_clobber "$BOARD_PROFILE/package.provided" |
| } |
| |
| # Install all of the stuff that depends on the toolchain versions |
| # into the board root. |
| install_toolchain_in_board() { |
| local binutils_ver=$(cross_get_version binutils) |
| local gcc_ver=$(cross_get_version gcc) |
| local libc_ver=$(cross_get_version glibc) |
| if [[ -z "$binutils_ver" || -z "$gcc_ver" || -z "$libc_ver" ]]; then |
| die "Cannot find toolchain to install into board root" |
| fi |
| echo "Installing the toolchain into the board root." |
| # Untar glibc to get most of the headers required to build. |
| LIBC_TAR="glibc-${libc_ver}.tbz2" |
| |
| # Install libc libraries. |
| if [ "${CHOST}" != "$FLAGS_toolchain" ] ; then |
| LIBC_PATH="${PKGDIR}/cross-${FLAGS_toolchain}/${LIBC_TAR}" |
| sudo tar jxpf "${LIBC_PATH}" -C "${BOARD_ROOT}" ./usr/${FLAGS_toolchain} --strip-components=3 |
| sudo mkdir -p ${BOARD_ROOT}/usr/lib/debug |
| sudo tar jxpf "${LIBC_PATH}" -C "${BOARD_ROOT}/usr/lib/debug" ./usr/lib/debug/usr/${FLAGS_toolchain} --strip-components=6 || warn "libc debug info not copied." |
| GCC_PKG=cross-${FLAGS_toolchain}/gcc-$gcc_ver |
| |
| # TODO(asharif): Remove this hack after a while. |
| BOARD_GCC_DIR="${BOARD_ROOT}/usr/lib/gcc" |
| if [[ -L "${BOARD_GCC_DIR}" ]] ; then |
| sudo rm -f "${BOARD_GCC_DIR}" |
| fi |
| copy_gcc_libs "${BOARD_ROOT}" "cross-$FLAGS_toolchain/gcc-$gcc_ver" |
| else |
| sudo mkdir -p ${BOARD_ROOT}/usr/lib64 |
| sudo ln -sf ${BOARD_ROOT}/usr/lib64 ${BOARD_ROOT}/usr/lib |
| sudo mkdir -p ${BOARD_ROOT}/lib64 |
| sudo ln -sf ${BOARD_ROOT}/lib64 ${BOARD_ROOT}/lib |
| LIBC_PATH="${PKGDIR}/sys-libs/${LIBC_TAR}" |
| sudo emerge --oneshot --nodeps -k --root=${BOARD_ROOT} =sys-libs/glibc-${libc_ver} |
| sudo mkdir -p ${BOARD_ROOT}/usr/lib/debug |
| # TODO: we have no debug |
| GCC_PKG=sys-devel/gcc-$gcc_ver |
| fi |
| |
| # Some header files are needed also for rpcbind (NFS support) |
| # TODO: Figure out a better way of doing this too? |
| sudo cp -a /usr/include/rpcsvc/mount.h "${BOARD_ROOT}/usr/include/rpcsvc" |
| sudo cp -a /usr/include/rpcsvc/rquota.h "${BOARD_ROOT}/usr/include/rpcsvc" |
| sudo cp -a /usr/include/rpcsvc/nfs_prot.h "${BOARD_ROOT}/usr/include/rpcsvc" |
| sudo cp -a /usr/include/rpcsvc/yppasswd.h "${BOARD_ROOT}/usr/include/rpcsvc" |
| |
| install_toolchain_in_provided "$binutils_ver" "$gcc_ver" "$libc_ver" |
| |
| # Configure new libc version in make.conf.board_setup. |
| sudo sed -i -e "/^LIBC_VERSION=/d" $BOARD_SETUP |
| echo "LIBC_VERSION=\"$libc_ver\"" | sudo_append $BOARD_SETUP |
| } |
| |
| # Print contents of $BOARD_ETC/make.conf.board. This file sources make.conf |
| # from each overlay, and then calculates the prebuilt URLs based on the |
| # various binhost configuration files. |
| print_board_make_conf() { |
| echo "# AUTO-GENERATED FILE. DO NOT EDIT." |
| echo |
| echo "# Source make.conf from each overlay." |
| local boto_config="" |
| for overlay in $BOARD_OVERLAY_LIST; do |
| if [[ -f "$overlay/make.conf" ]]; then |
| echo source "$overlay/make.conf" |
| fi |
| if [[ -f "$overlay/googlestorage_account.boto" ]]; then |
| boto_config="$overlay/googlestorage_account.boto" |
| fi |
| done |
| local chromeos_overlay="$SRC_ROOT/private-overlays/chromeos-overlay" |
| if [[ -f "$chromeos_overlay/googlestorage_account.boto" ]]; then |
| boto_config="$chromeos_overlay/googlestorage_account.boto" |
| fi |
| local gsutil_cmd='gsutil cp \"${URI}\" \"${DISTDIR}/${FILE}\"' |
| echo |
| echo FETCHCOMMAND_GS="\"bash -c 'BOTO_CONFIG=$boto_config $gsutil_cmd'\"" |
| echo RESUMECOMMAND_GS='"$FETCHCOMMAND_GS"' |
| echo |
| } |
| |
| print_binhost_config() { |
| if [ "$1" == "--local" ]; then |
| cros_generate_local_binhosts --board "${BOARD_VARIANT}" |
| echo 'PORTAGE_BINHOST="$LOCAL_BINHOST"' |
| return 0 |
| elif [ $# -ne 0 ]; then |
| die "Invalid arguments for print_binhost_config: $@" |
| fi |
| |
| local binhost_dir="$CHROMIUMOS_OVERLAY/chromeos/binhost/target" |
| local preflight_binhost="$binhost_dir/$BOARD-PREFLIGHT_BINHOST.conf" |
| local chrome_binhost_suffix="LATEST_RELEASE_CHROME_BINHOST.conf" |
| local chrome_binhost="$binhost_dir/$BOARD-$chrome_binhost_suffix" |
| if [[ $ARCH = x86 && ! -f "$preflight_binhost" ]]; then |
| preflight_binhost="$binhost_dir/x86-generic-PREFLIGHT_BINHOST.conf" |
| elif [[ $ARCH = amd64 && ! -f "$preflight_binhost" ]]; then |
| preflight_binhost="$binhost_dir/amd64-generic-PREFLIGHT_BINHOST.conf" |
| fi |
| if [[ $ARCH = x86 && ! -f "$chrome_binhost" ]]; then |
| chrome_binhost="$binhost_dir/x86-generic-$chrome_binhost_suffix" |
| elif [[ $ARCH = amd64 && ! -f "$chrome_binhost" ]]; then |
| chrome_binhost="$binhost_dir/amd64-generic-$chrome_binhost_suffix" |
| fi |
| |
| local partner_overlay="$SRC_ROOT/private-overlays/chromeos-partner-overlay" |
| local internal_binhost_dir="$partner_overlay/chromeos/binhost/target" |
| local internal_binhost="$internal_binhost_dir/$BOARD-PREFLIGHT_BINHOST.conf" |
| |
| cat <<'EOF' |
| # FULL_BINHOST is populated by the full builders. It is listed first because it |
| # is the lowest priority binhost. It is better to download packages from the |
| # preflight binhost because they are fresher packages. |
| PORTAGE_BINHOST="$FULL_BINHOST" |
| |
| EOF |
| |
| if [[ -f "$preflight_binhost" && -z "$IGNORE_PREFLIGHT_BINHOST" ]]; then |
| cat <<'EOF' |
| # PREFLIGHT_BINHOST is populated by the preflight builders. If the same |
| # package is provided by both the preflight and full binhosts, the package is |
| # downloaded from the preflight binhost. |
| EOF |
| echo source "$preflight_binhost" |
| echo 'PORTAGE_BINHOST="$PORTAGE_BINHOST $PREFLIGHT_BINHOST"' |
| echo |
| fi |
| |
| if [[ -f "$internal_binhost" && -z "$IGNORE_PREFLIGHT_BINHOST" ]]; then |
| cat <<'EOF' |
| # The internal PREFLIGHT_BINHOST is populated by the internal preflight |
| # builders. It takes priority over the public preflight binhost. |
| EOF |
| echo source "$internal_binhost" |
| echo 'PORTAGE_BINHOST="$PORTAGE_BINHOST $PREFLIGHT_BINHOST"' |
| echo |
| fi |
| |
| if [[ -f "$chrome_binhost" ]]; then |
| cat <<'EOF' |
| # LATEST_RELEASE_CHROME_BINHOST provides prebuilts for chromeos-chrome only. |
| EOF |
| echo source "$chrome_binhost" |
| echo 'PORTAGE_BINHOST="$PORTAGE_BINHOST $LATEST_RELEASE_CHROME_BINHOST"' |
| fi |
| } |
| |
| print_board_binhost_config() { |
| if [ "${FLAGS_reuse_pkgs_from_local_boards}" -eq "${FLAGS_TRUE}" ]; then |
| print_binhost_config --local |
| else |
| print_binhost_config |
| fi |
| } |
| |
| # Parse command line flags |
| FLAGS "$@" || exit 1 |
| eval set -- "${FLAGS_ARGV}" |
| |
| # Only now can we die on error. shflags functions leak non-zero error codes, |
| # so will die prematurely if 'switch_to_strict_mode' is specified before now. |
| switch_to_strict_mode |
| |
| if [ -z "$FLAGS_board" ] ; then |
| error "--board required." |
| exit 1 |
| fi |
| |
| get_board_and_variant $FLAGS_board $FLAGS_variant |
| |
| # Before we can run any tools, we need to update chroot |
| UPDATE_ARGS="--toolchain_boards=${BOARD}" |
| if [ "${FLAGS_fast}" -eq "${FLAGS_TRUE}" ]; then |
| UPDATE_ARGS+=" --fast" |
| else |
| UPDATE_ARGS+=" --nofast" |
| fi |
| if [ "${FLAGS_usepkg}" -eq "${FLAGS_TRUE}" ]; then |
| UPDATE_ARGS+=" --usepkg" |
| else |
| UPDATE_ARGS+=" --nousepkg" |
| fi |
| if [[ "${FLAGS_jobs}" -ne -1 ]]; then |
| UPDATE_ARGS+=" --jobs=${FLAGS_jobs}" |
| fi |
| if [ "${FLAGS_skip_toolchain_update}" -eq "${FLAGS_TRUE}" ]; then |
| UPDATE_ARGS+=" --skip_toolchain_update" |
| fi |
| if [ "${FLAGS_skip_chroot_upgrade}" -eq "${FLAGS_FALSE}" ] ; then |
| "${SRC_ROOT}/scripts"/update_chroot ${UPDATE_ARGS} |
| fi |
| |
| # |
| # Fetch the toolchain from the board overlay. |
| # |
| all_toolchains=( $(get_all_board_toolchains "${BOARD}") ) |
| : ${FLAGS_toolchain:=${all_toolchains[0]}} |
| |
| if [ -z "${FLAGS_toolchain}" ]; then |
| error "No toolchain specified in board overlay or on command line." |
| exit 1 |
| fi |
| |
| ARCH=$(get_board_arch "${BOARD}") || exit 1 |
| |
| case "$BOARD" in |
| *-host) |
| if [[ $FLAGS_usepkg -eq $FLAGS_TRUE ]]; then |
| die_notrace "host boards only support --nousepkg" |
| fi |
| HOST_BOARD=true |
| ;; |
| *) |
| HOST_BOARD=false |
| esac |
| # Locations we will need |
| BOARD_ROOT="/build/${BOARD_VARIANT}" |
| CROSSDEV_OVERLAY="/usr/local/portage/crossdev" |
| CHROMIUMOS_OVERLAY="/usr/local/portage/chromiumos" |
| CHROMIUMOS_CONFIG="${CHROMIUMOS_OVERLAY}/chromeos/config" |
| CHROMIUMOS_PROFILES="${CHROMIUMOS_OVERLAY}/profiles" |
| BOARD_ETC="${BOARD_ROOT}/etc" |
| BOARD_SETUP="${BOARD_ETC}/make.conf.board_setup" |
| BOARD_PROFILE="${BOARD_ETC}/portage/profile" |
| |
| # |
| # Construct board overlay list. |
| # |
| BOARD_OVERLAY_LIST=$(cros_overlay_list \ |
| --board "$BOARD" \ |
| --board_overlay "$FLAGS_board_overlay" \ |
| --variant "$VARIANT") |
| |
| eval $(portageq envvar -v CHOST PKGDIR) |
| |
| if [ -d "${BOARD_ROOT}" ] ; then |
| if [[ ${FLAGS_force} -eq ${FLAGS_TRUE} ]]; then |
| echo "--force set. Re-creating ${BOARD_ROOT}..." |
| # Removal takes long. Make it asynchronous. |
| TEMP_DIR=`mktemp -d` |
| sudo mv "${BOARD_ROOT}" "${TEMP_DIR}" |
| sudo rm -rf "${TEMP_DIR}" & |
| else |
| if ! ${HOST_BOARD}; then |
| { print_board_make_conf; print_board_binhost_config; } | \ |
| sudo_clobber $BOARD_ETC/make.conf.board |
| fi |
| if [[ ${FLAGS_quiet} -eq ${FLAGS_FALSE} ]]; then |
| warn "Board output directory '$BOARD_ROOT' already exists." |
| warn "Not setting up board root. " |
| warn "Use --force to clobber the board root and start again." |
| fi |
| if board_needs_libc_update; then |
| # Update the users libc in their board if needed. |
| echo "Updating libc in the board." |
| install_toolchain_in_board |
| fi |
| exit 0 |
| fi |
| fi |
| |
| sudo mkdir -p "${BOARD_ROOT}" "${BOARD_ETC}" "${BOARD_PROFILE}" |
| |
| if [ "${CHOST}" != "$FLAGS_toolchain" ] ; then |
| # TODO(cmasone): Do this more cleanly, if we figure out what "cleanly" means. |
| # Set up wrapper for pkg-config. Point a board-specific wrapper at the |
| # generic wrapper script created by crossdev-wrapper |
| sudo ln -sf "/usr/bin/cross-pkg-config" \ |
| "/usr/bin/${FLAGS_toolchain}-pkg-config" |
| fi |
| |
| # Setup the make.confs. We use the following: |
| # make.conf <- Overall target make.conf [arm, x86, etc. version] |
| # make.conf.board_setup <- Declares CHOST, ROOT, etc. |
| # make.conf.common <- Common settings across all targets |
| # make.conf.board <- Optional board-supplied make.conf |
| if ${HOST_BOARD}; then |
| sudo ln -sf "${CHROMIUMOS_CONFIG}/make.conf.${BOARD}" \ |
| "${BOARD_ETC}/make.conf" |
| sudo cp -f "/etc/make.conf.host_setup" "${BOARD_ETC}/" |
| |
| # Setting up symlinks for bootstrapping multilib. |
| # See http://crosbug.com/14498 |
| sudo mkdir -p "${BOARD_ROOT}/usr/lib64" "${BOARD_ROOT}/lib64" |
| sudo ln -sf lib64 "${BOARD_ROOT}/lib" |
| sudo ln -sf lib64 "${BOARD_ROOT}/usr/lib" |
| |
| # Copying some files for bootstrapping empty chroot. |
| # See http://crosbug.com/14499 |
| sudo mkdir -p ${BOARD_ETC}/xml/ |
| sudo cp /etc/xml/catalog ${BOARD_ETC}/xml/ |
| sudo mkdir -p ${BOARD_ETC}/init.d/ |
| sudo cp /etc/init.d/functions.sh ${BOARD_ETC}/init.d/ |
| fi |
| sudo ln -sf "${CHROMIUMOS_CONFIG}/make.conf.common-target" \ |
| "${BOARD_ETC}/make.conf.common" |
| cat <<EOF | sudo dd of="${BOARD_SETUP}" > /dev/null 2>&1 |
| # Created by setup_board |
| CHOST="${FLAGS_toolchain}" |
| ROOT="${BOARD_ROOT}/" |
| BOARD_OVERLAY="${BOARD_OVERLAY_LIST}" |
| MAKEOPTS="-j${NUM_JOBS}" |
| PKG_CONFIG="pkg-config-${BOARD_VARIANT}" |
| BOARD_USE="${BOARD_VARIANT}" |
| EOF |
| if ! ${HOST_BOARD}; then |
| sudo ln -sf "${CHROMIUMOS_CONFIG}/make.conf.${ARCH}-target" \ |
| "${BOARD_ETC}/make.conf" |
| print_board_make_conf | sudo_clobber $BOARD_ETC/make.conf.board |
| |
| # We install the toolchain related bits after the BOARD_ROOT, BOARD_PROFILE |
| # and BOARD_ETC directories have been created. |
| install_toolchain_in_board |
| fi |
| # Setup make.globals and the profile. |
| sudo touch /etc/make.conf.user |
| sudo ln -sf /etc/make.globals "${BOARD_ROOT}/etc/make.globals" |
| sudo ln -sf /etc/make.conf.user "${BOARD_ROOT}/etc/make.conf.user" |
| |
| # Select the profile to build based on the board and profile passed to |
| # setup_board. The developer can later change profiles by running |
| # cros_choose_profile manually. |
| if ! cros_choose_profile \ |
| --board "${FLAGS_board}" \ |
| --board_overlay "${FLAGS_board_overlay}" \ |
| --variant "${FLAGS_variant}" \ |
| --profile "${FLAGS_profile}"; then |
| error "Selecting profile failed, removing incomplete board directory!" |
| sudo rm -rf "${BOARD_ROOT}" |
| exit 1 |
| fi |
| |
| |
| for wrapper in 'emerge --root-deps' ebuild eclean equery portageq \ |
| qcheck qfile qlist ; do |
| generate_wrapper $wrapper |
| done |
| |
| generate_pkgconfig_wrapper |
| |
| CROS_WORKON_WRAPPER="/usr/local/bin/cros_workon-${BOARD_VARIANT}" |
| cat <<EOF | sudo dd of="$CROS_WORKON_WRAPPER" > /dev/null 2>&1 |
| #!/bin/bash |
| exec cros_workon --board ${BOARD_VARIANT} "\$@" |
| EOF |
| sudo chmod +x "$CROS_WORKON_WRAPPER" |
| |
| if ${HOST_BOARD}; then |
| EMERGE_CMD="emerge" |
| if [[ $FLAGS_fast -eq $FLAGS_TRUE ]]; then |
| EMERGE_CMD="${GCLIENT_ROOT}/chromite/bin/parallel_emerge" |
| fi |
| PACKAGES="system hard-host-depends world" |
| |
| # First, rebuild all packages from scratch. This is needed to make sure |
| # we rebuild all chroot packages. |
| sudo -E $EMERGE_CMD --emptytree --with-bdeps=y $PACKAGES |
| sudo eclean -d packages |
| |
| # Next, install our rebuilt packages into our separate root. |
| HOST_FLAGS="--root=$BOARD_ROOT --update --verbose --deep --root-deps" |
| HOST_FLAGS+=" --with-bdeps=y --newuse --jobs=$NUM_JOBS --usepkgonly" |
| sudo -E $EMERGE_CMD $HOST_FLAGS --select=y $PACKAGES |
| sudo cp -a "${PKGDIR}" $BOARD_ROOT/packages |
| |
| # Install cross-compilers. |
| COMPILERS=$(equery l cross-*/* --format='=$cpv') |
| sudo -E $EMERGE_CMD $HOST_FLAGS --select=n $COMPILERS |
| |
| # Setup needed symlinks for cross-compilers. |
| sudo mkdir -p $BOARD_ROOT/usr/local/portage |
| sudo cp -a ${CROSSDEV_OVERLAY} $BOARD_ROOT/usr/local/portage |
| |
| # Setup crossdev configuration for categories. |
| sudo cp -a /etc/portage/* $BOARD_ROOT/etc/portage |
| |
| # The new chroot should have gcc for each target. Make sure that |
| # the latest one is correctly selected. Ignore cat errors as not |
| # all overlays will have a toolchain.conf. |
| ALL_TARGETS=$(cros_setup_toolchains --show-board-cfg=sdk) |
| for target in ${ALL_TARGETS//,/ }; do |
| libc=$(eval $(crossdev --show-target-cfg "${target}"); echo ${libc_pn}) |
| if [[ ${libc} == "glibc" ]] ; then |
| # Install needed glibc tarball. |
| cross_target_path=/var/lib/portage/pkgs/cross-${target} |
| if [[ -e "$cross_target_path" ]] ; then |
| sudo mkdir -p ${BOARD_ROOT}${cross_target_path} |
| sudo cp -a ${cross_target_path}/glibc-* \ |
| ${BOARD_ROOT}${cross_target_path} |
| fi |
| fi |
| |
| CURRENT_GCC="$(gcc-config -c ${target})" |
| sudo ROOT=${BOARD_ROOT} gcc-config ${CURRENT_GCC} |
| CURRENT_BINUTILS="$(binutils-config -c ${target})" |
| sudo ROOT=${BOARD_ROOT} binutils-config ${CURRENT_BINUTILS} |
| done |
| |
| # Now cleanup paths referencing the ROOT from the *.la files. |
| sudo find $BOARD_ROOT -type f -name '*.la' | xargs sudo \ |
| sed -i -e "s|$BOARD_ROOT/|/|g" |
| else |
| # Now that the portageq-* wrappers have been created, we can add the binhost |
| # config to make.conf.board. |
| print_board_binhost_config | sudo_append $BOARD_ETC/make.conf.board |
| |
| # Emerge the kernel headers into the board build root. Use rdeps to |
| # avoid pulling any spurious DEPEND things in that we don't care about. |
| KERNEL_EMERGE_FLAGS="--select --quiet --root-deps=rdeps" |
| if [[ "${FLAGS_usepkg}" -eq "${FLAGS_TRUE}" || |
| "${FLAGS_reuse_pkgs_from_local_boards}" -eq "${FLAGS_TRUE}" ]]; then |
| KERNEL_EMERGE_FLAGS+=" --getbinpkg --usepkg" |
| fi |
| |
| sudo -E "${EMERGE_WRAPPER}" ${KERNEL_EMERGE_FLAGS} \ |
| sys-kernel/linux-headers |
| |
| unset KERNEL_EMERGE_FLAGS |
| fi |
| |
| if [ $FLAGS_default -eq $FLAGS_TRUE ] ; then |
| echo $BOARD_VARIANT > "$GCLIENT_ROOT/src/scripts/.default_board" |
| fi |
| |
| command_completed |
| echo "Done!" |
| echo "The SYSROOT is: ${BOARD_ROOT}" |
| |
| # NOTE: Printing the working-on ebuilds does not only serve the informative |
| # purpose. It also causes the ${BOARD_ROOT}/etc/portage/package.* files to be |
| # regenerated. |
| WORKING_ON=$(cros_workon --board=${FLAGS_board} list) |
| if [ -n "${WORKING_ON}" ]; then |
| echo |
| echo "Currently working on the following ebuilds for this board:" |
| echo "${WORKING_ON}" |
| fi |