build/install-chroot.sh

   1 #!/bin/bash -e
   2
   3 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   4 # Use of this source code is governed by a BSD-style license that can be
   5 # found in the LICENSE file.
   6
   7 # This script installs Debian-derived distributions in a chroot environment.
   8 # It can for example be used to have an accurate 32bit build and test
   9 # environment when otherwise working on a 64bit machine.
  10 # N. B. it is unlikely that this script will ever work on anything other than a
  11 # Debian-derived system.
  12
  13 # Older Debian based systems had both "admin" and "adm" groups, with "admin"
  14 # apparently being used in more places. Newer distributions have standardized
  15 # on just the "adm" group. Check /etc/group for the preferred name of the
  16 # administrator group.
  17 admin=$(grep '^admin:' /etc/group >&/dev/null && echo admin || echo adm)
  18
  19 usage() {
  20   echo "usage: ${0##*/} [-m mirror] [-g group,...] [-s] [-c]"
  21   echo "-b dir       additional directories that should be bind mounted,"
  22   echo '             or "NONE".'
  23   echo "             Default: if local filesystems present, ask user for help"
  24   echo "-g group,... groups that can use the chroot unauthenticated"
  25   echo "             Default: '${admin}' and current user's group ('$(id -gn)')"
  26   echo "-l           List all installed chroot environments"
  27   echo "-m mirror    an alternate repository mirror for package downloads"
  28   echo "-s           configure default deb-srcs"
  29   echo "-c           always copy 64bit helper binaries to 32bit chroot"
  30   echo "-h           this help message"
  31 }
  32
  33 process_opts() {
  34   local OPTNAME OPTIND OPTERR OPTARG
  35   while getopts ":b:g:lm:sch" OPTNAME; do
  36     case "$OPTNAME" in
  37       b)
  38         if [ "${OPTARG}" = "NONE" -a -z "${bind_mounts}" ]; then
  39           bind_mounts="${OPTARG}"
  40         else
  41           if [ "${bind_mounts}" = "NONE" -o "${OPTARG}" = "${OPTARG#/}" -o \
  42                ! -d "${OPTARG}" ]; then
  43             echo "Invalid -b option(s)"
  44             usage
  45             exit 1
  46           fi
  47           bind_mounts="${bind_mounts}
  48 ${OPTARG} ${OPTARG} none rw,bind 0 0"
  49         fi
  50         ;;
  51       g)
  52         [ -n "${OPTARG}" ] &&
  53           chroot_groups="${chroot_groups}${chroot_groups:+,}${OPTARG}"
  54         ;;
  55       l)
  56         list_all_chroots
  57         exit
  58         ;;
  59       m)
  60         if [ -n "${mirror}" ]; then
  61           echo "You can only specify exactly one mirror location"
  62           usage
  63           exit 1
  64         fi
  65         mirror="$OPTARG"
  66         ;;
  67       s)
  68         add_srcs="y"
  69         ;;
  70       c)
  71         copy_64="y"
  72         ;;
  73       h)
  74         usage
  75         exit 0
  76         ;;
  77       \:)
  78         echo "'-$OPTARG' needs an argument."
  79         usage
  80         exit 1
  81         ;;
  82       *)
  83         echo "invalid command-line option: $OPTARG"
  84         usage
  85         exit 1
  86         ;;
  87     esac
  88   done
  89
  90   if [ $# -ge ${OPTIND} ]; then
  91     eval echo "Unexpected command line argument: \${${OPTIND}}"
  92     usage
  93     exit 1
  94   fi
  95 }
  96
  97 list_all_chroots() {
  98   for i in /var/lib/chroot/*; do
  99     i="${i##*/}"
 100     [ "${i}" = "*" ] && continue
 101     [ -x "/usr/local/bin/${i%bit}" ] || continue
 102     grep -qs "^\[${i%bit}\]\$" /etc/schroot/schroot.conf || continue
 103     [ -r "/etc/schroot/script-${i}" -a \
 104       -r "/etc/schroot/mount-${i}" ] || continue
 105     echo "${i%bit}"
 106   done
 107 }
 108
 109 getkey() {
 110   (
 111     trap 'stty echo -iuclc icanon 2>/dev/null' EXIT INT TERM QUIT HUP
 112     stty -echo iuclc -icanon 2>/dev/null
 113     dd count=1 bs=1 2>/dev/null
 114   )
 115 }
 116
 117 chr() {
 118   printf "\\$(printf '%03o' "$1")"
 119 }
 120
 121 ord() {
 122   printf '%d' $(printf '%c' "$1" | od -tu1 -An)
 123 }
 124
 125 is_network_drive() {
 126   stat -c %T -f "$1/" 2>/dev/null |
 127     egrep -qs '^nfs|cifs|smbfs'
 128 }
 129
 130 # Check that we are running as a regular user
 131 [ "$(id -nu)" = root ] && {
 132   echo "Run this script as a regular user and provide your \"sudo\""           \
 133        "password if requested" >&2
 134   exit 1
 135 }
 136
 137 process_opts "$@"
 138
 139 echo "This script will help you through the process of installing a"
 140 echo "Debian or Ubuntu distribution in a chroot environment. You will"
 141 echo "have to provide your \"sudo\" password when requested."
 142 echo
 143
 144 # Error handler
 145 trap 'exit 1' INT TERM QUIT HUP
 146 trap 'sudo apt-get clean; tput bel; echo; echo Failed' EXIT
 147
 148 # Install any missing applications that this script relies on. If these packages
 149 # are already installed, don't force another "apt-get install". That would
 150 # prevent them from being auto-removed, if they ever become eligible for that.
 151 # And as this script only needs the packages once, there is no good reason to
 152 # introduce a hard dependency on things such as dchroot and debootstrap.
 153 dep=
 154 for i in dchroot debootstrap libwww-perl; do
 155   [ -d /usr/share/doc/"$i" ] || dep="$dep $i"
 156 done
 157 [ -n "$dep" ] && sudo apt-get -y install $dep
 158 sudo apt-get -y install schroot
 159
 160 # Create directory for chroot
 161 sudo mkdir -p /var/lib/chroot
 162
 163 # Find chroot environments that can be installed with debootstrap
 164 targets="$(cd /usr/share/debootstrap/scripts
 165            ls | grep '^[a-z]*$')"
 166
 167 # Ask user to pick one of the available targets
 168 echo "The following targets are available to be installed in a chroot:"
 169 j=1; for i in $targets; do
 170   printf '%4d: %s\n' "$j" "$i"
 171   j=$(($j+1))
 172 done
 173 while :; do
 174   printf "Which target would you like to install: "
 175   read n
 176   [ "$n" -gt 0 -a "$n" -lt "$j" ] >&/dev/null && break
 177 done
 178 j=1; for i in $targets; do
 179   [ "$j" -eq "$n" ] && { distname="$i"; break; }
 180   j=$(($j+1))
 181 done
 182 echo
 183
 184 # On x86-64, ask whether the user wants to install x86-32 or x86-64
 185 archflag=
 186 arch=
 187 if [ "$(uname -m)" = x86_64 ]; then
 188   while :; do
 189     echo "You are running a 64bit kernel. This allows you to install either a"
 190     printf "32bit or a 64bit chroot environment. %s"                           \
 191            "Which one do you want (32, 64) "
 192     read arch
 193     [ "${arch}" == 32 -o "${arch}" == 64 ] && break
 194   done
 195   [ "${arch}" == 32 ] && archflag="--arch i386" || archflag="--arch amd64"
 196   arch="${arch}bit"
 197   echo
 198 fi
 199 target="${distname}${arch}"
 200
 201 # Don't accidentally overwrite an existing installation
 202 [ -d /var/lib/chroot/"${target}" ] && {
 203   while :; do
 204     echo "This chroot already exists on your machine."
 205     if schroot -l --all-sessions 2>&1 |
 206        sed 's/^session://' |
 207        grep -qs "^${target%bit}-"; then
 208       echo "And it appears to be in active use. Terminate all programs that"
 209       echo "are currently using the chroot environment and then re-run this"
 210       echo "script."
 211       echo "If you still get an error message, you might have stale mounts"
 212       echo "that you forgot to delete. You can always clean up mounts by"
 213       echo "executing \"${target%bit} -c\"."
 214       exit 1
 215     fi
 216     echo "I can abort installation, I can overwrite the existing chroot,"
 217     echo "or I can delete the old one and then exit. What would you like to"
 218     printf "do (a/o/d)? "
 219     read choice
 220     case "${choice}" in
 221       a|A) exit 1;;
 222       o|O) sudo rm -rf "/var/lib/chroot/${target}"; break;;
 223       d|D) sudo rm -rf "/var/lib/chroot/${target}"      \
 224                        "/usr/local/bin/${target%bit}"   \
 225                        "/etc/schroot/mount-${target}"   \
 226                        "/etc/schroot/script-${target}"
 227            sudo sed -ni '/^[[]'"${target%bit}"']$/,${
 228                          :1;n;/^[[]/b2;b1;:2;p;n;b2};p' \
 229                        "/etc/schroot/schroot.conf"
 230            trap '' INT TERM QUIT HUP
 231            trap '' EXIT
 232            echo "Deleted!"
 233            exit 0;;
 234     esac
 235   done
 236   echo
 237 }
 238 sudo mkdir -p /var/lib/chroot/"${target}"
 239
 240 # Offer to include additional standard repositories for Ubuntu-based chroots.
 241 alt_repos=
 242 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" && {
 243   while :; do
 244     echo "Would you like to add ${distname}-updates and ${distname}-security "
 245     printf "to the chroot's sources.list (y/n)? "
 246     read alt_repos
 247     case "${alt_repos}" in
 248       y|Y)
 249         alt_repos="y"
 250         break
 251       ;;
 252       n|N)
 253         break
 254       ;;
 255     esac
 256   done
 257   echo
 258 }
 259
 260 # Check for non-standard file system mount points and ask the user whether
 261 # they should be imported into the chroot environment
 262 # We limit to the first 26 mount points that much some basic heuristics,
 263 # because a) that allows us to enumerate choices with a single character,
 264 # and b) if we find more than 26 mount points, then these are probably
 265 # false-positives and something is very unusual about the system's
 266 # configuration. No need to spam the user with even more information that
 267 # is likely completely irrelevant.
 268 if [ -z "${bind_mounts}" ]; then
 269   mounts="$(awk '$2 != "/" && $2 !~ "^/boot" && $2 !~ "^/home" &&
 270                  $2 !~ "^/media" && $2 !~ "^/run" &&
 271                  ($3 ~ "ext[2-4]" || $3 == "reiserfs" || $3 == "btrfs" ||
 272                  $3 == "xfs" || $3 == "jfs" || $3 == "u?msdos" ||
 273                  $3 == "v?fat" || $3 == "hfs" || $3 == "ntfs" ||
 274                  $3 ~ "nfs[4-9]?" || $3 == "smbfs" || $3 == "cifs") {
 275                    print $2
 276                  }' /proc/mounts |
 277             head -n26)"
 278   if [ -n "${mounts}" ]; then
 279     echo "You appear to have non-standard mount points that you"
 280     echo "might want to import into the chroot environment:"
 281     echo
 282     sel=
 283     while :; do
 284       # Print a menu, listing all non-default mounts of local or network
 285       # file systems.
 286       j=1; for m in ${mounts}; do
 287         c="$(printf $(printf '\\%03o' $((64+$j))))"
 288         echo "$sel" | grep -qs $c &&
 289           state="mounted in chroot" || state="$(tput el)"
 290         printf "   $c) %-40s${state}\n" "$m"
 291         j=$(($j+1))
 292       done
 293       # Allow user to interactively (de-)select any of the entries
 294       echo
 295       printf "Select mount points that you want to be included or press %s" \
 296              "SPACE to continue"
 297       c="$(getkey | tr a-z A-Z)"
 298       [ "$c" == " " ] && { echo; echo; break; }
 299       if [ -z "$c" ] ||
 300          [ "$c" '<' 'A' -o $(ord "$c") -gt $((64 + $(ord "$j"))) ]; then
 301           # Invalid input, ring the console bell
 302           tput bel
 303       else
 304         # Toggle the selection for the given entry
 305         if echo "$sel" | grep -qs $c; then
 306           sel="$(printf "$sel" | sed "s/$c//")"
 307         else
 308           sel="$sel$c"
 309         fi
 310       fi
 311       # Reposition cursor to the top of the list of entries
 312       tput cuu $(($j + 1))
 313       echo
 314     done
 315   fi
 316   j=1; for m in ${mounts}; do
 317     c="$(chr $(($j + 64)))"
 318     if echo "$sel" | grep -qs $c; then
 319       bind_mounts="${bind_mounts}$m $m none rw,bind 0 0
 320 "
 321     fi
 322     j=$(($j+1))
 323   done
 324 fi
 325
 326 # Remove stale entry from /etc/schroot/schroot.conf. Entries start
 327 # with the target name in square brackets, followed by an arbitrary
 328 # number of lines. The entry stops when either the end of file has
 329 # been reached, or when the beginning of a new target is encountered.
 330 # This means, we cannot easily match for a range of lines in
 331 # "sed". Instead, we actually have to iterate over each line and check
 332 # whether it is the beginning of a new entry.
 333 sudo sed -ni '/^[[]'"${target%bit}"']$/,${:1;n;/^[[]/b2;b1;:2;p;n;b2};p'       \
 334          /etc/schroot/schroot.conf
 335
 336 # Download base system. This takes some time
 337 if [ -z "${mirror}" ]; then
 338  grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" &&
 339    mirror="http://archive.ubuntu.com/ubuntu" ||
 340    mirror="http://ftp.us.debian.org/debian"
 341 fi
 342
 343 sudo ${http_proxy:+http_proxy="${http_proxy}"} debootstrap ${archflag} \
 344     "${distname}" "/var/lib/chroot/${target}"  "$mirror"
 345
 346 # Add new entry to /etc/schroot/schroot.conf
 347 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" &&
 348   brand="Ubuntu" || brand="Debian"
 349 if [ -z "${chroot_groups}" ]; then
 350   chroot_groups="${admin},$(id -gn)"
 351 fi
 352 # Older versions of schroot wanted a "priority=" line, whereas recent
 353 # versions deprecate "priority=" and warn if they see it. We don't have
 354 # a good feature test, but scanning for the string "priority=" in the
 355 # existing "schroot.conf" file is a good indication of what to do.
 356 priority=$(grep -qs 'priority=' /etc/schroot/schroot.conf &&
 357            echo 'priority=3' || :)
 358 sudo sh -c 'cat >>/etc/schroot/schroot.conf' <<EOF
 359 [${target%bit}]
 360 description=${brand} ${distname} ${arch}
 361 type=directory
 362 directory=/var/lib/chroot/${target}
 363 users=root
 364 groups=${chroot_groups}
 365 root-groups=${chroot_groups}
 366 personality=linux$([ "${arch}" != 64bit ] && echo 32)
 367 script-config=script-${target}
 368 ${priority}
 369
 370 EOF
 371
 372 # Set up a list of mount points that is specific to this
 373 # chroot environment.
 374 sed '/^FSTAB=/s,"[^"]*","/etc/schroot/mount-'"${target}"'",' \
 375          /etc/schroot/script-defaults |
 376   sudo sh -c 'cat >/etc/schroot/script-'"${target}"
 377 sed '\,^/home[/[:space:]],s/\([,[:space:]]\)bind[[:space:]]/\1rbind /' \
 378   /etc/schroot/mount-defaults |
 379   sudo sh -c 'cat > /etc/schroot/mount-'"${target}"
 380
 381 # Add the extra mount points that the user told us about
 382 [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] &&
 383   printf "${bind_mounts}" |
 384     sudo sh -c 'cat >>/etc/schroot/mount-'"${target}"
 385
 386 # If this system has a "/media" mountpoint, import it into the chroot
 387 # environment. Most modern distributions use this mount point to
 388 # automatically mount devices such as CDROMs, USB sticks, etc...
 389 if [ -d /media ] &&
 390    ! grep -qs '^/media' /etc/schroot/mount-"${target}"; then
 391   echo '/media /media none rw,rbind 0 0' |
 392     sudo sh -c 'cat >>/etc/schroot/mount-'"${target}"
 393 fi
 394
 395 # Share /dev/shm, /run and /run/shm.
 396 grep -qs '^/dev/shm' /etc/schroot/mount-"${target}" ||
 397   echo '/dev/shm /dev/shm none rw,bind 0 0' |
 398     sudo sh -c 'cat >>/etc/schroot/mount-'"${target}"
 399 if [ ! -d "/var/lib/chroot/${target}/run" ] &&
 400    ! grep -qs '^/run' /etc/schroot/mount-"${target}"; then
 401   echo '/run /run none rw,bind 0 0' |
 402     sudo sh -c 'cat >>/etc/schroot/mount-'"${target}"
 403 fi
 404 if ! grep -qs '^/run/shm' /etc/schroot/mount-"${target}"; then
 405   { [ -d /run ] && echo '/run/shm /run/shm none rw,bind 0 0' ||
 406                    echo '/dev/shm /run/shm none rw,bind 0 0'; } |
 407     sudo sh -c 'cat >>/etc/schroot/mount-'"${target}"
 408 fi
 409
 410 # Set up a special directory that changes contents depending on the target
 411 # that is executing.
 412 d="$(readlink -f "${HOME}/chroot" 2>/dev/null || echo "${HOME}/chroot")"
 413 s="${d}/.${target}"
 414 echo "${s} ${d} none rw,bind 0 0" |
 415   sudo sh -c 'cat >>/etc/schroot/mount-'"${target}"
 416 mkdir -p "${s}"
 417
 418 # Install a helper script to launch commands in the chroot
 419 sudo sh -c 'cat >/usr/local/bin/'"${target%bit}" <<'EOF'
 420 #!/bin/bash
 421
 422 chroot="${0##*/}"
 423
 424 wrap() {
 425   # Word-wrap the text passed-in on stdin. Optionally, on continuation lines
 426   # insert the same number of spaces as the number of characters in the
 427   # parameter(s) passed to this function.
 428   # If the "fold" program cannot be found, or if the actual width of the
 429   # terminal cannot be determined, this function doesn't attempt to do any
 430   # wrapping.
 431   local f="$(type -P fold)"
 432   [ -z "${f}" ] && { cat; return; }
 433   local c="$(stty -a </dev/tty 2>/dev/null |
 434              sed 's/.*columns[[:space:]]*\([0-9]*\).*/\1/;t;d')"
 435   [ -z "${c}" ] && { cat; return; }
 436   local i="$(echo "$*"|sed 's/./ /g')"
 437   local j="$(printf %s "${i}"|wc -c)"
 438   if [ "${c}" -gt "${j}" ]; then
 439     dd bs=1 count="${j}" 2>/dev/null
 440     "${f}" -sw "$((${c}-${j}))" | sed '2,$s/^/'"${i}"'/'
 441   else
 442     "${f}" -sw "${c}"
 443   fi
 444 }
 445
 446 help() {
 447   echo "Usage ${0##*/} [-h|--help] [-c|--clean] [-C|--clean-all] [-l|--list] [--] args" | wrap "Usage ${0##*/} "
 448   echo "  help:      print this message"                                                | wrap "             "
 449   echo "  list:      list all known chroot environments"                                | wrap "             "
 450   echo "  clean:     remove all old chroot sessions for \"${chroot}\""                  | wrap "             "
 451   echo "  clean-all: remove all old chroot sessions for all environments"               | wrap "             "
 452   exit 0
 453 }
 454
 455 clean() {
 456   local s t rc
 457   rc=0
 458   for s in $(schroot -l --all-sessions); do
 459     if [ -n "$1" ]; then
 460       t="${s#session:}"
 461       [ "${t#${chroot}-}" == "${t}" ] && continue
 462     fi
 463     if ls -l /proc/*/{cwd,fd} 2>/dev/null |
 464        fgrep -qs "/var/lib/schroot/mount/${t}"; then
 465       echo "Session \"${t}\" still has active users, not cleaning up" | wrap
 466       rc=1
 467       continue
 468     fi
 469     sudo schroot -c "${s}" -e || rc=1
 470   done
 471   exit ${rc}
 472 }
 473
 474 list() {
 475   for e in $(schroot -l); do
 476     e="${e#chroot:}"
 477     [ -x "/usr/local/bin/${e}" ] || continue
 478     if schroot -l --all-sessions 2>/dev/null |
 479        sed 's/^session://' |
 480        grep -qs "^${e}-"; then
 481       echo "${e} is currently active"
 482     else
 483       echo "${e}"
 484     fi
 485   done
 486   exit 0
 487 }
 488
 489 while [ "$#" -ne 0 ]; do
 490   case "$1" in
 491     --)             shift; break;;
 492     -h|--help)      shift; help;;
 493     -l|--list)      shift; list;;
 494     -c|--clean)     shift; clean "${chroot}";;
 495     -C|--clean-all) shift; clean;;
 496     *)              break;;
 497   esac
 498 done
 499
 500 # Start a new chroot session and keep track of the session id. We inject this
 501 # id into all processes that run inside the chroot. Unless they go out of their
 502 # way to clear their environment, we can then later identify our child and
 503 # grand-child processes by scanning their environment.
 504 session="$(schroot -c "${chroot}" -b)"
 505 export CHROOT_SESSION_ID="${session}"
 506
 507 # Set GOMA_TMP_DIR for better handling of goma inside chroot.
 508 export GOMA_TMP_DIR="/tmp/goma_tmp_$CHROOT_SESSION_ID"
 509 mkdir -p "$GOMA_TMP_DIR"
 510
 511 if [ $# -eq 0 ]; then
 512   # Run an interactive shell session
 513   schroot -c "${session}" -r -p
 514 else
 515   # Run a command inside of the chroot environment
 516   p="$1"; shift
 517   schroot -c "${session}" -r -p "$p" -- "$@"
 518 fi
 519 rc=$?
 520
 521 # Compute the inode of the root directory inside of the chroot environment.
 522 i=$(schroot -c "${session}" -r -p ls -- -id /proc/self/root/. |
 523      awk '{ print $1 }') 2>/dev/null
 524 other_pids=
 525 while [ -n "$i" ]; do
 526   # Identify processes by the inode number of their root directory. Then
 527   # remove all processes that we know belong to other sessions. We use
 528   # "sort | uniq -u" to do what amounts to a "set substraction operation".
 529   pids=$({ ls -id1 /proc/*/root/. 2>/dev/null |
 530          sed -e 's,^[^0-9]*'$i'.*/\([1-9][0-9]*\)/.*$,\1,
 531                  t
 532                  d';
 533          echo "${other_pids}";
 534          echo "${other_pids}"; } | sort | uniq -u) >/dev/null 2>&1
 535   # Kill all processes that are still left running in the session. This is
 536   # typically an assortment of daemon processes that were started
 537   # automatically. They result in us being unable to tear down the session
 538   # cleanly.
 539   [ -z "${pids}" ] && break
 540   for j in $pids; do
 541     # Unfortunately, the way that schroot sets up sessions has the
 542     # side-effect of being unable to tell one session apart from another.
 543     # This can result in us attempting to kill processes in other sessions.
 544     # We make a best-effort to avoid doing so.
 545     k="$( ( xargs -0 -n1 </proc/$j/environ ) 2>/dev/null |
 546          sed 's/^CHROOT_SESSION_ID=/x/;t1;d;:1;q')"
 547     if [ -n "${k}" -a "${k#x}" != "${session}" ]; then
 548       other_pids="${other_pids}
 549 ${j}"
 550       continue
 551     fi
 552     kill -9 $pids
 553   done
 554 done
 555 # End the chroot session. This should clean up all temporary files. But if we
 556 # earlier failed to terminate all (daemon) processes inside of the session,
 557 # deleting the session could fail. When that happens, the user has to manually
 558 # clean up the stale files by invoking us with "--clean" after having killed
 559 # all running processes.
 560 schroot -c "${session}" -e
 561 # Since no goma processes are running, we can remove goma directory.
 562 rm -rf "$GOMA_TMP_DIR"
 563 exit $rc
 564 EOF
 565 sudo chown root:root /usr/local/bin/"${target%bit}"
 566 sudo chmod 755 /usr/local/bin/"${target%bit}"
 567
 568 # Add the standard Ubuntu update repositories if requested.
 569 [ "${alt_repos}" = "y" -a \
 570   -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
 571 sudo sed -i '/^deb .* [^ -]\+ main$/p
 572              s/^\(deb .* [^ -]\+\) main/\1-security main/
 573              p
 574              t1
 575              d
 576              :1;s/-security main/-updates main/
 577              t
 578              d' "/var/lib/chroot/${target}/etc/apt/sources.list"
 579
 580 # Add a few more repositories to the chroot
 581 [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
 582 sudo sed -i 's/ main$/ main restricted universe multiverse/' \
 583          "/var/lib/chroot/${target}/etc/apt/sources.list"
 584
 585 # Add the Ubuntu "partner" repository, if available
 586 if [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
 587    HEAD "http://archive.canonical.com/ubuntu/dists/${distname}/partner" \
 588    >&/dev/null; then
 589   sudo sh -c '
 590     echo "deb http://archive.canonical.com/ubuntu" \
 591          "'"${distname}"' partner" \
 592       >>"/var/lib/chroot/'"${target}"'/etc/apt/sources.list"'
 593 fi
 594
 595 # Add source repositories, if the user requested we do so
 596 [ "${add_srcs}" = "y" -a \
 597   -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
 598 sudo sed -i '/^deb[^-]/p
 599              s/^deb\([^-]\)/deb-src\1/' \
 600          "/var/lib/chroot/${target}/etc/apt/sources.list"
 601
 602 # Set apt proxy if host has set http_proxy
 603 if [ -n "${http_proxy}" ]; then
 604   sudo sh -c '
 605     echo "Acquire::http::proxy \"'"${http_proxy}"'\";" \
 606         >>"/var/lib/chroot/'"${target}"'/etc/apt/apt.conf"'
 607 fi
 608
 609 # Update packages
 610 sudo "/usr/local/bin/${target%bit}" /bin/sh -c '
 611   apt-get update; apt-get -y dist-upgrade' || :
 612
 613 # Install a couple of missing packages
 614 for i in debian-keyring ubuntu-keyring locales sudo; do
 615   [ -d "/var/lib/chroot/${target}/usr/share/doc/$i" ] ||
 616     sudo "/usr/local/bin/${target%bit}" apt-get -y install "$i" || :
 617 done
 618
 619 # Configure locales
 620 sudo "/usr/local/bin/${target%bit}" /bin/sh -c '
 621   l='"${LANG:-en_US}"'; l="${l%%.*}"
 622   [ -r /etc/locale.gen ] &&
 623     sed -i "s/^# \($l\)/\1/" /etc/locale.gen
 624   locale-gen $LANG en_US en_US.UTF-8' || :
 625
 626 # Enable multi-arch support, if available
 627 sudo "/usr/local/bin/${target%bit}" dpkg --assert-multi-arch >&/dev/null &&
 628   [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] && {
 629   sudo sed -i 's/ / [arch=amd64,i386] /' \
 630               "/var/lib/chroot/${target}/etc/apt/sources.list"
 631   [ -d /var/lib/chroot/${target}/etc/dpkg/dpkg.cfg.d/ ] &&
 632   sudo "/usr/local/bin/${target%bit}" dpkg --add-architecture \
 633       $([ "${arch}" = "32bit" ] && echo amd64 || echo i386) >&/dev/null ||
 634     echo foreign-architecture \
 635         $([ "${arch}" = "32bit" ] && echo amd64 || echo i386) |
 636       sudo sh -c \
 637         "cat >'/var/lib/chroot/${target}/etc/dpkg/dpkg.cfg.d/multiarch'"
 638 }
 639
 640 # Configure "sudo" package
 641 sudo "/usr/local/bin/${target%bit}" /bin/sh -c '
 642   egrep -qs '"'^$(id -nu) '"' /etc/sudoers ||
 643   echo '"'$(id -nu) ALL=(ALL) ALL'"' >>/etc/sudoers'
 644
 645 # Install a few more commonly used packages
 646 sudo "/usr/local/bin/${target%bit}" apt-get -y install                         \
 647   autoconf automake1.9 dpkg-dev g++-multilib gcc-multilib gdb less libtool     \
 648   lsof strace
 649
 650 # If running a 32bit environment on a 64bit machine, install a few binaries
 651 # as 64bit. This is only done automatically if the chroot distro is the same as
 652 # the host, otherwise there might be incompatibilities in build settings or
 653 # runtime dependencies. The user can force it with the '-c' flag.
 654 host_distro=$(grep -s DISTRIB_CODENAME /etc/lsb-release | \
 655   cut -d "=" -f 2)
 656 if [ "${copy_64}" = "y" -o \
 657     "${host_distro}" = "${distname}" -a "${arch}" = 32bit ] && \
 658     file /bin/bash 2>/dev/null | grep -q x86-64; then
 659   readlinepkg=$(sudo "/usr/local/bin/${target%bit}" sh -c \
 660     'apt-cache search "lib64readline.\$" | sort | tail -n 1 | cut -d " " -f 1')
 661   sudo "/usr/local/bin/${target%bit}" apt-get -y install                       \
 662     lib64expat1 lib64ncurses5 ${readlinepkg} lib64z1 lib64stdc++6
 663   dep=
 664   for i in binutils gdb; do
 665     [ -d /usr/share/doc/"$i" ] || dep="$dep $i"
 666   done
 667   [ -n "$dep" ] && sudo apt-get -y install $dep
 668   sudo mkdir -p "/var/lib/chroot/${target}/usr/local/lib/amd64"
 669   for i in libbfd libpython; do
 670     lib="$({ ldd /usr/bin/ld; ldd /usr/bin/gdb; } |
 671            grep -s "$i" | awk '{ print $3 }')"
 672     if [ -n "$lib" -a -r "$lib" ]; then
 673       sudo cp "$lib" "/var/lib/chroot/${target}/usr/local/lib/amd64"
 674     fi
 675   done
 676   for lib in libssl libcrypt; do
 677     for path in /usr/lib /usr/lib/x86_64-linux-gnu; do
 678       sudo cp $path/$lib* \
 679               "/var/lib/chroot/${target}/usr/local/lib/amd64/" >&/dev/null || :
 680     done
 681   done
 682   for i in gdb ld; do
 683     sudo cp /usr/bin/$i "/var/lib/chroot/${target}/usr/local/lib/amd64/"
 684     sudo sh -c "cat >'/var/lib/chroot/${target}/usr/local/bin/$i'" <<EOF
 685 #!/bin/sh
 686 exec /lib64/ld-linux-x86-64.so.2 --library-path /usr/local/lib/amd64 \
 687   /usr/local/lib/amd64/$i "\$@"
 688 EOF
 689     sudo chmod 755 "/var/lib/chroot/${target}/usr/local/bin/$i"
 690   done
 691 fi
 692
 693
 694 # If the install-build-deps.sh script can be found, offer to run it now
 695 script="$(dirname $(readlink -f "$0"))/install-build-deps.sh"
 696 if [ -x "${script}" ]; then
 697   while :; do
 698     echo
 699     echo "If you plan on building Chrome inside of the new chroot environment,"
 700     echo "you now have to install the build dependencies. Do you want me to"
 701     printf "start the script that does this for you (y/n)? "
 702     read install_deps
 703     case "${install_deps}" in
 704       y|Y)
 705         echo
 706         # We prefer running the script in-place, but this might not be
 707         # possible, if it lives on a network filesystem that denies
 708         # access to root.
 709         tmp_script=
 710         if ! sudo /usr/local/bin/"${target%bit}" \
 711             sh -c "[ -x '${script}' ]" >&/dev/null; then
 712           tmp_script="/tmp/${script##*/}"
 713           cp "${script}" "${tmp_script}"
 714         fi
 715         # Some distributions automatically start an instance of the system-
 716         # wide dbus daemon, cron daemon or of the logging daemon, when
 717         # installing the Chrome build depencies. This prevents the chroot
 718         # session from being closed.  So, we always try to shut down any running
 719         # instance of dbus and rsyslog.
 720         sudo /usr/local/bin/"${target%bit}" sh -c "${script} --no-lib32;
 721               rc=$?;
 722               /etc/init.d/cron stop >/dev/null 2>&1 || :;
 723               /etc/init.d/rsyslog stop >/dev/null 2>&1 || :;
 724               /etc/init.d/dbus stop >/dev/null 2>&1 || :;
 725               exit $rc"
 726         rc=$?
 727         [ -n "${tmp_script}" ] && rm -f "${tmp_script}"
 728         [ $rc -ne 0 ] && exit $rc
 729         break
 730       ;;
 731       n|N)
 732         break
 733       ;;
 734     esac
 735   done
 736   echo
 737 fi
 738
 739 # Check whether ~/chroot is on a (slow) network file system and offer to
 740 # relocate it. Also offer relocation, if the user appears to have multiple
 741 # spindles (as indicated by "${bind_mount}" being non-empty).
 742 # We only offer this option, if it doesn't look as if a chroot environment
 743 # is currently active. Otherwise, relocation is unlikely to work and it
 744 # can be difficult for the user to recover from the failed attempt to relocate
 745 # the ~/chroot directory.
 746 # We don't aim to solve this problem for every configuration,
 747 # but try to help with the common cases. For more advanced configuration
 748 # options, the user can always manually adjust things.
 749 mkdir -p "${HOME}/chroot/"
 750 if [ ! -h "${HOME}/chroot" ] &&
 751    ! egrep -qs '^[^[:space:]]*/chroot' /etc/fstab &&
 752    { [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] ||
 753      is_network_drive "${HOME}/chroot"; } &&
 754    ! egrep -qs '/var/lib/[^/]*chroot/.*/chroot' /proc/mounts; then
 755   echo "${HOME}/chroot is currently located on the same device as your"
 756   echo "home directory."
 757   echo "This might not be what you want. Do you want me to move it somewhere"
 758   echo "else?"
 759   # If the computer has multiple spindles, many users configure all or part of
 760   # the secondary hard disk to be writable by the primary user of this machine.
 761   # Make some reasonable effort to detect this type of configuration and
 762   # then offer a good location for where to put the ~/chroot directory.
 763   suggest=
 764   for i in $(echo "${bind_mounts}"|cut -d ' ' -f 1); do
 765     if [ -d "$i" -a -w "$i" -a \( ! -a "$i/chroot" -o -w "$i/chroot/." \) ] &&
 766        ! is_network_drive "$i"; then
 767       suggest="$i"
 768     else
 769       for j in "$i/"*; do
 770         if [ -d "$j" -a -w "$j" -a \
 771              \( ! -a "$j/chroot" -o -w "$j/chroot/." \) ] &&
 772            ! is_network_drive "$j"; then
 773           suggest="$j"
 774         else
 775           for k in "$j/"*; do
 776             if [ -d "$k" -a -w "$k" -a \
 777                  \( ! -a "$k/chroot" -o -w "$k/chroot/." \) ] &&
 778                ! is_network_drive "$k"; then
 779               suggest="$k"
 780               break
 781             fi
 782           done
 783         fi
 784         [ -n "${suggest}" ] && break
 785       done
 786     fi
 787     [ -n "${suggest}" ] && break
 788   done
 789   def_suggest="${HOME}"
 790   if [ -n "${suggest}" ]; then
 791     # For home directories that reside on network drives, make our suggestion
 792     # the default option. For home directories that reside on a local drive,
 793     # require that the user manually enters the new location.
 794     if is_network_drive "${HOME}"; then
 795       def_suggest="${suggest}"
 796     else
 797       echo "A good location would probably be in \"${suggest}\""
 798     fi
 799   fi
 800   while :; do
 801     printf "Physical location [${def_suggest}]: "
 802     read dir
 803     [ -z "${dir}" ] && dir="${def_suggest}"
 804     [ "${dir%%/}" == "${HOME%%/}" ] && break
 805     if ! [ -d "${dir}" -a -w "${dir}" ] ||
 806        [ -a "${dir}/chroot" -a ! -w "${dir}/chroot/." ]; then
 807       echo "Cannot write to ${dir}/chroot. Please try again"
 808     else
 809       mv "${HOME}/chroot" "${dir}/chroot"
 810       ln -s "${dir}/chroot" "${HOME}/chroot"
 811       for i in $(list_all_chroots); do
 812         sudo "$i" mkdir -p "${dir}/chroot"
 813       done
 814       sudo sed -i "s,${HOME}/chroot,${dir}/chroot,g" /etc/schroot/mount-*
 815       break
 816     fi
 817   done
 818 fi
 819
 820 # Clean up package files
 821 sudo schroot -c "${target%bit}" -p -- apt-get clean
 822 sudo apt-get clean
 823
 824 trap '' INT TERM QUIT HUP
 825 trap '' EXIT
 826
 827 # Let the user know what we did
 828 cat <<EOF
 829
 830
 831 Successfully installed ${distname} ${arch}
 832
 833 You can run programs inside of the chroot by invoking the
 834 "/usr/local/bin/${target%bit}" command.
 835
 836 This command can be used with arguments, in order to just run a single
 837 program inside of the chroot environment (e.g. "${target%bit} make chrome")
 838 or without arguments, in order to run an interactive shell session inside
 839 of the chroot environment.
 840
 841 If you need to run things as "root", you can use "sudo" (e.g. try
 842 "sudo ${target%bit} apt-get update").
 843
 844 Your home directory is shared between the host and the chroot. But I
 845 configured "${HOME}/chroot" to be private to the chroot environment.
 846 You can use it for files that need to differ between environments. This
 847 would be a good place to store binaries that you have built from your
 848 source files.
 849
 850 For Chrome, this probably means you want to make your "out" directory a
 851 symbolic link that points somewhere inside of "${HOME}/chroot".
 852
 853 You still need to run "gclient runhooks" whenever you switch from building
 854 outside of the chroot to inside of the chroot. But you will find that you
 855 don't have to repeatedly erase and then completely rebuild all your object
 856 and binary files.
 857
 858 EOF