OLD | NEW |
| (Empty) |
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 "/etc/schroot/${target}" | |
228 sudo sed -ni '/^[[]'"${target%bit}"']$/,${ | |
229 :1;n;/^[[]/b2;b1;:2;p;n;b2};p' \ | |
230 "/etc/schroot/schroot.conf" | |
231 trap '' INT TERM QUIT HUP | |
232 trap '' EXIT | |
233 echo "Deleted!" | |
234 exit 0;; | |
235 esac | |
236 done | |
237 echo | |
238 } | |
239 sudo mkdir -p /var/lib/chroot/"${target}" | |
240 | |
241 # Offer to include additional standard repositories for Ubuntu-based chroots. | |
242 alt_repos= | |
243 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" && { | |
244 while :; do | |
245 echo "Would you like to add ${distname}-updates and ${distname}-security " | |
246 printf "to the chroot's sources.list (y/n)? " | |
247 read alt_repos | |
248 case "${alt_repos}" in | |
249 y|Y) | |
250 alt_repos="y" | |
251 break | |
252 ;; | |
253 n|N) | |
254 break | |
255 ;; | |
256 esac | |
257 done | |
258 echo | |
259 } | |
260 | |
261 # Check for non-standard file system mount points and ask the user whether | |
262 # they should be imported into the chroot environment | |
263 # We limit to the first 26 mount points that much some basic heuristics, | |
264 # because a) that allows us to enumerate choices with a single character, | |
265 # and b) if we find more than 26 mount points, then these are probably | |
266 # false-positives and something is very unusual about the system's | |
267 # configuration. No need to spam the user with even more information that | |
268 # is likely completely irrelevant. | |
269 if [ -z "${bind_mounts}" ]; then | |
270 mounts="$(awk '$2 != "/" && $2 !~ "^/boot" && $2 !~ "^/home" && | |
271 $2 !~ "^/media" && $2 !~ "^/run" && | |
272 ($3 ~ "ext[2-4]" || $3 == "reiserfs" || $3 == "btrfs" || | |
273 $3 == "xfs" || $3 == "jfs" || $3 == "u?msdos" || | |
274 $3 == "v?fat" || $3 == "hfs" || $3 == "ntfs" || | |
275 $3 ~ "nfs[4-9]?" || $3 == "smbfs" || $3 == "cifs") { | |
276 print $2 | |
277 }' /proc/mounts | | |
278 head -n26)" | |
279 if [ -n "${mounts}" ]; then | |
280 echo "You appear to have non-standard mount points that you" | |
281 echo "might want to import into the chroot environment:" | |
282 echo | |
283 sel= | |
284 while :; do | |
285 # Print a menu, listing all non-default mounts of local or network | |
286 # file systems. | |
287 j=1; for m in ${mounts}; do | |
288 c="$(printf $(printf '\\%03o' $((64+$j))))" | |
289 echo "$sel" | grep -qs $c && | |
290 state="mounted in chroot" || state="$(tput el)" | |
291 printf " $c) %-40s${state}\n" "$m" | |
292 j=$(($j+1)) | |
293 done | |
294 # Allow user to interactively (de-)select any of the entries | |
295 echo | |
296 printf "Select mount points that you want to be included or press %s" \ | |
297 "SPACE to continue" | |
298 c="$(getkey | tr a-z A-Z)" | |
299 [ "$c" == " " ] && { echo; echo; break; } | |
300 if [ -z "$c" ] || | |
301 [ "$c" '<' 'A' -o $(ord "$c") -gt $((64 + $(ord "$j"))) ]; then | |
302 # Invalid input, ring the console bell | |
303 tput bel | |
304 else | |
305 # Toggle the selection for the given entry | |
306 if echo "$sel" | grep -qs $c; then | |
307 sel="$(printf "$sel" | sed "s/$c//")" | |
308 else | |
309 sel="$sel$c" | |
310 fi | |
311 fi | |
312 # Reposition cursor to the top of the list of entries | |
313 tput cuu $(($j + 1)) | |
314 echo | |
315 done | |
316 fi | |
317 j=1; for m in ${mounts}; do | |
318 c="$(chr $(($j + 64)))" | |
319 if echo "$sel" | grep -qs $c; then | |
320 bind_mounts="${bind_mounts}$m $m none rw,bind 0 0 | |
321 " | |
322 fi | |
323 j=$(($j+1)) | |
324 done | |
325 fi | |
326 | |
327 # Remove stale entry from /etc/schroot/schroot.conf. Entries start | |
328 # with the target name in square brackets, followed by an arbitrary | |
329 # number of lines. The entry stops when either the end of file has | |
330 # been reached, or when the beginning of a new target is encountered. | |
331 # This means, we cannot easily match for a range of lines in | |
332 # "sed". Instead, we actually have to iterate over each line and check | |
333 # whether it is the beginning of a new entry. | |
334 sudo sed -ni '/^[[]'"${target%bit}"']$/,${:1;n;/^[[]/b2;b1;:2;p;n;b2};p' \ | |
335 /etc/schroot/schroot.conf | |
336 | |
337 # Download base system. This takes some time | |
338 if [ -z "${mirror}" ]; then | |
339 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" && | |
340 mirror="http://archive.ubuntu.com/ubuntu" || | |
341 mirror="http://ftp.us.debian.org/debian" | |
342 fi | |
343 | |
344 sudo ${http_proxy:+http_proxy="${http_proxy}"} debootstrap ${archflag} \ | |
345 "${distname}" "/var/lib/chroot/${target}" "$mirror" | |
346 | |
347 # Add new entry to /etc/schroot/schroot.conf | |
348 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" && | |
349 brand="Ubuntu" || brand="Debian" | |
350 if [ -z "${chroot_groups}" ]; then | |
351 chroot_groups="${admin},$(id -gn)" | |
352 fi | |
353 | |
354 if [ -d '/etc/schroot/default' ]; then | |
355 new_version=1 | |
356 fstab="/etc/schroot/${target}/fstab" | |
357 else | |
358 new_version=0 | |
359 fstab="/etc/schroot/mount-${target}" | |
360 fi | |
361 | |
362 if [ "$new_version" = "1" ]; then | |
363 sudo cp -ar /etc/schroot/default /etc/schroot/${target} | |
364 | |
365 sudo sh -c 'cat >>/etc/schroot/schroot.conf' <<EOF | |
366 [${target%bit}] | |
367 description=${brand} ${distname} ${arch} | |
368 type=directory | |
369 directory=/var/lib/chroot/${target} | |
370 users=root | |
371 groups=${chroot_groups} | |
372 root-groups=${chroot_groups} | |
373 personality=linux$([ "${arch}" != 64bit ] && echo 32) | |
374 profile=${target} | |
375 | |
376 EOF | |
377 [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] && | |
378 printf "${bind_mounts}" | | |
379 sudo sh -c "cat >>${fstab}" | |
380 else | |
381 # Older versions of schroot wanted a "priority=" line, whereas recent | |
382 # versions deprecate "priority=" and warn if they see it. We don't have | |
383 # a good feature test, but scanning for the string "priority=" in the | |
384 # existing "schroot.conf" file is a good indication of what to do. | |
385 priority=$(grep -qs 'priority=' /etc/schroot/schroot.conf && | |
386 echo 'priority=3' || :) | |
387 sudo sh -c 'cat >>/etc/schroot/schroot.conf' <<EOF | |
388 [${target%bit}] | |
389 description=${brand} ${distname} ${arch} | |
390 type=directory | |
391 directory=/var/lib/chroot/${target} | |
392 users=root | |
393 groups=${chroot_groups} | |
394 root-groups=${chroot_groups} | |
395 personality=linux$([ "${arch}" != 64bit ] && echo 32) | |
396 script-config=script-${target} | |
397 ${priority} | |
398 | |
399 EOF | |
400 | |
401 # Set up a list of mount points that is specific to this | |
402 # chroot environment. | |
403 sed '/^FSTAB=/s,"[^"]*","'"${fstab}"'",' \ | |
404 /etc/schroot/script-defaults | | |
405 sudo sh -c 'cat >/etc/schroot/script-'"${target}" | |
406 sed '\,^/home[/[:space:]],s/\([,[:space:]]\)bind[[:space:]]/\1rbind /' \ | |
407 /etc/schroot/mount-defaults | | |
408 sudo sh -c "cat > ${fstab}" | |
409 fi | |
410 | |
411 # Add the extra mount points that the user told us about | |
412 [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] && | |
413 printf "${bind_mounts}" | | |
414 sudo sh -c 'cat >>'"${fstab}" | |
415 | |
416 # If this system has a "/media" mountpoint, import it into the chroot | |
417 # environment. Most modern distributions use this mount point to | |
418 # automatically mount devices such as CDROMs, USB sticks, etc... | |
419 if [ -d /media ] && | |
420 ! grep -qs '^/media' "${fstab}"; then | |
421 echo '/media /media none rw,rbind 0 0' | | |
422 sudo sh -c 'cat >>'"${fstab}" | |
423 fi | |
424 | |
425 # Share /dev/shm, /run and /run/shm. | |
426 grep -qs '^/dev/shm' "${fstab}" || | |
427 echo '/dev/shm /dev/shm none rw,bind 0 0' | | |
428 sudo sh -c 'cat >>'"${fstab}" | |
429 if [ ! -d "/var/lib/chroot/${target}/run" ] && | |
430 ! grep -qs '^/run' "${fstab}"; then | |
431 echo '/run /run none rw,bind 0 0' | | |
432 sudo sh -c 'cat >>'"${fstab}" | |
433 fi | |
434 if ! grep -qs '^/run/shm' "${fstab}"; then | |
435 { [ -d /run ] && echo '/run/shm /run/shm none rw,bind 0 0' || | |
436 echo '/dev/shm /run/shm none rw,bind 0 0'; } | | |
437 sudo sh -c 'cat >>'"${fstab}" | |
438 fi | |
439 | |
440 # Set up a special directory that changes contents depending on the target | |
441 # that is executing. | |
442 d="$(readlink -f "${HOME}/chroot" 2>/dev/null || echo "${HOME}/chroot")" | |
443 s="${d}/.${target}" | |
444 echo "${s} ${d} none rw,bind 0 0" | | |
445 sudo sh -c 'cat >>'"${target}" | |
446 mkdir -p "${s}" | |
447 | |
448 # Install a helper script to launch commands in the chroot | |
449 sudo sh -c 'cat >/usr/local/bin/'"${target%bit}" <<'EOF' | |
450 #!/bin/bash | |
451 | |
452 chroot="${0##*/}" | |
453 | |
454 wrap() { | |
455 # Word-wrap the text passed-in on stdin. Optionally, on continuation lines | |
456 # insert the same number of spaces as the number of characters in the | |
457 # parameter(s) passed to this function. | |
458 # If the "fold" program cannot be found, or if the actual width of the | |
459 # terminal cannot be determined, this function doesn't attempt to do any | |
460 # wrapping. | |
461 local f="$(type -P fold)" | |
462 [ -z "${f}" ] && { cat; return; } | |
463 local c="$(stty -a </dev/tty 2>/dev/null | | |
464 sed 's/.*columns[[:space:]]*\([0-9]*\).*/\1/;t;d')" | |
465 [ -z "${c}" ] && { cat; return; } | |
466 local i="$(echo "$*"|sed 's/./ /g')" | |
467 local j="$(printf %s "${i}"|wc -c)" | |
468 if [ "${c}" -gt "${j}" ]; then | |
469 dd bs=1 count="${j}" 2>/dev/null | |
470 "${f}" -sw "$((${c}-${j}))" | sed '2,$s/^/'"${i}"'/' | |
471 else | |
472 "${f}" -sw "${c}" | |
473 fi | |
474 } | |
475 | |
476 help() { | |
477 echo "Usage ${0##*/} [-h|--help] [-c|--clean] [-C|--clean-all] [-l|--list] [--
] args" | wrap "Usage ${0##*/} " | |
478 echo " help: print this message"
| wrap " " | |
479 echo " list: list all known chroot environments"
| wrap " " | |
480 echo " clean: remove all old chroot sessions for \"${chroot}\""
| wrap " " | |
481 echo " clean-all: remove all old chroot sessions for all environments"
| wrap " " | |
482 exit 0 | |
483 } | |
484 | |
485 clean() { | |
486 local s t rc | |
487 rc=0 | |
488 for s in $(schroot -l --all-sessions); do | |
489 if [ -n "$1" ]; then | |
490 t="${s#session:}" | |
491 [ "${t#${chroot}-}" == "${t}" ] && continue | |
492 fi | |
493 if ls -l /proc/*/{cwd,fd} 2>/dev/null | | |
494 fgrep -qs "/var/lib/schroot/mount/${t}"; then | |
495 echo "Session \"${t}\" still has active users, not cleaning up" | wrap | |
496 rc=1 | |
497 continue | |
498 fi | |
499 sudo schroot -c "${s}" -e || rc=1 | |
500 done | |
501 exit ${rc} | |
502 } | |
503 | |
504 list() { | |
505 for e in $(schroot -l); do | |
506 e="${e#chroot:}" | |
507 [ -x "/usr/local/bin/${e}" ] || continue | |
508 if schroot -l --all-sessions 2>/dev/null | | |
509 sed 's/^session://' | | |
510 grep -qs "^${e}-"; then | |
511 echo "${e} is currently active" | |
512 else | |
513 echo "${e}" | |
514 fi | |
515 done | |
516 exit 0 | |
517 } | |
518 | |
519 while [ "$#" -ne 0 ]; do | |
520 case "$1" in | |
521 --) shift; break;; | |
522 -h|--help) shift; help;; | |
523 -l|--list) shift; list;; | |
524 -c|--clean) shift; clean "${chroot}";; | |
525 -C|--clean-all) shift; clean;; | |
526 *) break;; | |
527 esac | |
528 done | |
529 | |
530 # Start a new chroot session and keep track of the session id. We inject this | |
531 # id into all processes that run inside the chroot. Unless they go out of their | |
532 # way to clear their environment, we can then later identify our child and | |
533 # grand-child processes by scanning their environment. | |
534 session="$(schroot -c "${chroot}" -b)" | |
535 export CHROOT_SESSION_ID="${session}" | |
536 | |
537 # Set GOMA_TMP_DIR for better handling of goma inside chroot. | |
538 export GOMA_TMP_DIR="/tmp/goma_tmp_$CHROOT_SESSION_ID" | |
539 mkdir -p "$GOMA_TMP_DIR" | |
540 | |
541 if [ $# -eq 0 ]; then | |
542 # Run an interactive shell session | |
543 schroot -c "${session}" -r -p | |
544 else | |
545 # Run a command inside of the chroot environment | |
546 p="$1"; shift | |
547 schroot -c "${session}" -r -p "$p" -- "$@" | |
548 fi | |
549 rc=$? | |
550 | |
551 # Compute the inode of the root directory inside of the chroot environment. | |
552 i=$(schroot -c "${session}" -r -p ls -- -id /proc/self/root/. | | |
553 awk '{ print $1 }') 2>/dev/null | |
554 other_pids= | |
555 while [ -n "$i" ]; do | |
556 # Identify processes by the inode number of their root directory. Then | |
557 # remove all processes that we know belong to other sessions. We use | |
558 # "sort | uniq -u" to do what amounts to a "set substraction operation". | |
559 pids=$({ ls -id1 /proc/*/root/. 2>/dev/null | | |
560 sed -e 's,^[^0-9]*'$i'.*/\([1-9][0-9]*\)/.*$,\1, | |
561 t | |
562 d'; | |
563 echo "${other_pids}"; | |
564 echo "${other_pids}"; } | sort | uniq -u) >/dev/null 2>&1 | |
565 # Kill all processes that are still left running in the session. This is | |
566 # typically an assortment of daemon processes that were started | |
567 # automatically. They result in us being unable to tear down the session | |
568 # cleanly. | |
569 [ -z "${pids}" ] && break | |
570 for j in $pids; do | |
571 # Unfortunately, the way that schroot sets up sessions has the | |
572 # side-effect of being unable to tell one session apart from another. | |
573 # This can result in us attempting to kill processes in other sessions. | |
574 # We make a best-effort to avoid doing so. | |
575 k="$( ( xargs -0 -n1 </proc/$j/environ ) 2>/dev/null | | |
576 sed 's/^CHROOT_SESSION_ID=/x/;t1;d;:1;q')" | |
577 if [ -n "${k}" -a "${k#x}" != "${session}" ]; then | |
578 other_pids="${other_pids} | |
579 ${j}" | |
580 continue | |
581 fi | |
582 kill -9 $pids | |
583 done | |
584 done | |
585 # End the chroot session. This should clean up all temporary files. But if we | |
586 # earlier failed to terminate all (daemon) processes inside of the session, | |
587 # deleting the session could fail. When that happens, the user has to manually | |
588 # clean up the stale files by invoking us with "--clean" after having killed | |
589 # all running processes. | |
590 schroot -c "${session}" -e | |
591 # Since no goma processes are running, we can remove goma directory. | |
592 rm -rf "$GOMA_TMP_DIR" | |
593 exit $rc | |
594 EOF | |
595 sudo chown root:root /usr/local/bin/"${target%bit}" | |
596 sudo chmod 755 /usr/local/bin/"${target%bit}" | |
597 | |
598 # Add the standard Ubuntu update repositories if requested. | |
599 [ "${alt_repos}" = "y" -a \ | |
600 -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] && | |
601 sudo sed -i '/^deb .* [^ -]\+ main$/p | |
602 s/^\(deb .* [^ -]\+\) main/\1-security main/ | |
603 p | |
604 t1 | |
605 d | |
606 :1;s/-security main/-updates main/ | |
607 t | |
608 d' "/var/lib/chroot/${target}/etc/apt/sources.list" | |
609 | |
610 # Add a few more repositories to the chroot | |
611 [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] && | |
612 sudo sed -i 's/ main$/ main restricted universe multiverse/' \ | |
613 "/var/lib/chroot/${target}/etc/apt/sources.list" | |
614 | |
615 # Add the Ubuntu "partner" repository, if available | |
616 if [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] && | |
617 HEAD "http://archive.canonical.com/ubuntu/dists/${distname}/partner" \ | |
618 >&/dev/null; then | |
619 sudo sh -c ' | |
620 echo "deb http://archive.canonical.com/ubuntu" \ | |
621 "'"${distname}"' partner" \ | |
622 >>"/var/lib/chroot/'"${target}"'/etc/apt/sources.list"' | |
623 fi | |
624 | |
625 # Add source repositories, if the user requested we do so | |
626 [ "${add_srcs}" = "y" -a \ | |
627 -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] && | |
628 sudo sed -i '/^deb[^-]/p | |
629 s/^deb\([^-]\)/deb-src\1/' \ | |
630 "/var/lib/chroot/${target}/etc/apt/sources.list" | |
631 | |
632 # Set apt proxy if host has set http_proxy | |
633 if [ -n "${http_proxy}" ]; then | |
634 sudo sh -c ' | |
635 echo "Acquire::http::proxy \"'"${http_proxy}"'\";" \ | |
636 >>"/var/lib/chroot/'"${target}"'/etc/apt/apt.conf"' | |
637 fi | |
638 | |
639 # Update packages | |
640 sudo "/usr/local/bin/${target%bit}" /bin/sh -c ' | |
641 apt-get update; apt-get -y dist-upgrade' || : | |
642 | |
643 # Install a couple of missing packages | |
644 for i in debian-keyring ubuntu-keyring locales sudo; do | |
645 [ -d "/var/lib/chroot/${target}/usr/share/doc/$i" ] || | |
646 sudo "/usr/local/bin/${target%bit}" apt-get -y install "$i" || : | |
647 done | |
648 | |
649 # Configure locales | |
650 sudo "/usr/local/bin/${target%bit}" /bin/sh -c ' | |
651 l='"${LANG:-en_US}"'; l="${l%%.*}" | |
652 [ -r /etc/locale.gen ] && | |
653 sed -i "s/^# \($l\)/\1/" /etc/locale.gen | |
654 locale-gen $LANG en_US en_US.UTF-8' || : | |
655 | |
656 # Enable multi-arch support, if available | |
657 sudo "/usr/local/bin/${target%bit}" dpkg --assert-multi-arch >&/dev/null && | |
658 [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] && { | |
659 sudo sed -i 's/ / [arch=amd64,i386] /' \ | |
660 "/var/lib/chroot/${target}/etc/apt/sources.list" | |
661 [ -d /var/lib/chroot/${target}/etc/dpkg/dpkg.cfg.d/ ] && | |
662 sudo "/usr/local/bin/${target%bit}" dpkg --add-architecture \ | |
663 $([ "${arch}" = "32bit" ] && echo amd64 || echo i386) >&/dev/null || | |
664 echo foreign-architecture \ | |
665 $([ "${arch}" = "32bit" ] && echo amd64 || echo i386) | | |
666 sudo sh -c \ | |
667 "cat >'/var/lib/chroot/${target}/etc/dpkg/dpkg.cfg.d/multiarch'" | |
668 } | |
669 | |
670 # Configure "sudo" package | |
671 sudo "/usr/local/bin/${target%bit}" /bin/sh -c ' | |
672 egrep -qs '"'^$(id -nu) '"' /etc/sudoers || | |
673 echo '"'$(id -nu) ALL=(ALL) ALL'"' >>/etc/sudoers' | |
674 | |
675 # Install a few more commonly used packages | |
676 sudo "/usr/local/bin/${target%bit}" apt-get -y install \ | |
677 autoconf automake1.9 dpkg-dev g++-multilib gcc-multilib gdb less libtool \ | |
678 lsof strace | |
679 | |
680 # If running a 32bit environment on a 64bit machine, install a few binaries | |
681 # as 64bit. This is only done automatically if the chroot distro is the same as | |
682 # the host, otherwise there might be incompatibilities in build settings or | |
683 # runtime dependencies. The user can force it with the '-c' flag. | |
684 host_distro=$(grep -s DISTRIB_CODENAME /etc/lsb-release | \ | |
685 cut -d "=" -f 2) | |
686 if [ "${copy_64}" = "y" -o \ | |
687 "${host_distro}" = "${distname}" -a "${arch}" = 32bit ] && \ | |
688 file /bin/bash 2>/dev/null | grep -q x86-64; then | |
689 readlinepkg=$(sudo "/usr/local/bin/${target%bit}" sh -c \ | |
690 'apt-cache search "lib64readline.\$" | sort | tail -n 1 | cut -d " " -f 1') | |
691 sudo "/usr/local/bin/${target%bit}" apt-get -y install \ | |
692 lib64expat1 lib64ncurses5 ${readlinepkg} lib64z1 lib64stdc++6 | |
693 dep= | |
694 for i in binutils gdb; do | |
695 [ -d /usr/share/doc/"$i" ] || dep="$dep $i" | |
696 done | |
697 [ -n "$dep" ] && sudo apt-get -y install $dep | |
698 sudo mkdir -p "/var/lib/chroot/${target}/usr/local/lib/amd64" | |
699 for i in libbfd libpython; do | |
700 lib="$({ ldd /usr/bin/ld; ldd /usr/bin/gdb; } | | |
701 grep -s "$i" | awk '{ print $3 }')" | |
702 if [ -n "$lib" -a -r "$lib" ]; then | |
703 sudo cp "$lib" "/var/lib/chroot/${target}/usr/local/lib/amd64" | |
704 fi | |
705 done | |
706 for lib in libssl libcrypt; do | |
707 for path in /usr/lib /usr/lib/x86_64-linux-gnu; do | |
708 sudo cp $path/$lib* \ | |
709 "/var/lib/chroot/${target}/usr/local/lib/amd64/" >&/dev/null || : | |
710 done | |
711 done | |
712 for i in gdb ld; do | |
713 sudo cp /usr/bin/$i "/var/lib/chroot/${target}/usr/local/lib/amd64/" | |
714 sudo sh -c "cat >'/var/lib/chroot/${target}/usr/local/bin/$i'" <<EOF | |
715 #!/bin/sh | |
716 exec /lib64/ld-linux-x86-64.so.2 --library-path /usr/local/lib/amd64 \ | |
717 /usr/local/lib/amd64/$i "\$@" | |
718 EOF | |
719 sudo chmod 755 "/var/lib/chroot/${target}/usr/local/bin/$i" | |
720 done | |
721 fi | |
722 | |
723 | |
724 # If the install-build-deps.sh script can be found, offer to run it now | |
725 script="$(dirname $(readlink -f "$0"))/install-build-deps.sh" | |
726 if [ -x "${script}" ]; then | |
727 while :; do | |
728 echo | |
729 echo "If you plan on building Chrome inside of the new chroot environment," | |
730 echo "you now have to install the build dependencies. Do you want me to" | |
731 printf "start the script that does this for you (y/n)? " | |
732 read install_deps | |
733 case "${install_deps}" in | |
734 y|Y) | |
735 echo | |
736 # We prefer running the script in-place, but this might not be | |
737 # possible, if it lives on a network filesystem that denies | |
738 # access to root. | |
739 tmp_script= | |
740 if ! sudo /usr/local/bin/"${target%bit}" \ | |
741 sh -c "[ -x '${script}' ]" >&/dev/null; then | |
742 tmp_script="/tmp/${script##*/}" | |
743 cp "${script}" "${tmp_script}" | |
744 fi | |
745 # Some distributions automatically start an instance of the system- | |
746 # wide dbus daemon, cron daemon or of the logging daemon, when | |
747 # installing the Chrome build depencies. This prevents the chroot | |
748 # session from being closed. So, we always try to shut down any running | |
749 # instance of dbus and rsyslog. | |
750 sudo /usr/local/bin/"${target%bit}" sh -c "${script}; | |
751 rc=$?; | |
752 /etc/init.d/cron stop >/dev/null 2>&1 || :; | |
753 /etc/init.d/rsyslog stop >/dev/null 2>&1 || :; | |
754 /etc/init.d/dbus stop >/dev/null 2>&1 || :; | |
755 exit $rc" | |
756 rc=$? | |
757 [ -n "${tmp_script}" ] && rm -f "${tmp_script}" | |
758 [ $rc -ne 0 ] && exit $rc | |
759 break | |
760 ;; | |
761 n|N) | |
762 break | |
763 ;; | |
764 esac | |
765 done | |
766 echo | |
767 fi | |
768 | |
769 # Check whether ~/chroot is on a (slow) network file system and offer to | |
770 # relocate it. Also offer relocation, if the user appears to have multiple | |
771 # spindles (as indicated by "${bind_mount}" being non-empty). | |
772 # We only offer this option, if it doesn't look as if a chroot environment | |
773 # is currently active. Otherwise, relocation is unlikely to work and it | |
774 # can be difficult for the user to recover from the failed attempt to relocate | |
775 # the ~/chroot directory. | |
776 # We don't aim to solve this problem for every configuration, | |
777 # but try to help with the common cases. For more advanced configuration | |
778 # options, the user can always manually adjust things. | |
779 mkdir -p "${HOME}/chroot/" | |
780 if [ ! -h "${HOME}/chroot" ] && | |
781 ! egrep -qs '^[^[:space:]]*/chroot' /etc/fstab && | |
782 { [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] || | |
783 is_network_drive "${HOME}/chroot"; } && | |
784 ! egrep -qs '/var/lib/[^/]*chroot/.*/chroot' /proc/mounts; then | |
785 echo "${HOME}/chroot is currently located on the same device as your" | |
786 echo "home directory." | |
787 echo "This might not be what you want. Do you want me to move it somewhere" | |
788 echo "else?" | |
789 # If the computer has multiple spindles, many users configure all or part of | |
790 # the secondary hard disk to be writable by the primary user of this machine. | |
791 # Make some reasonable effort to detect this type of configuration and | |
792 # then offer a good location for where to put the ~/chroot directory. | |
793 suggest= | |
794 for i in $(echo "${bind_mounts}"|cut -d ' ' -f 1); do | |
795 if [ -d "$i" -a -w "$i" -a \( ! -a "$i/chroot" -o -w "$i/chroot/." \) ] && | |
796 ! is_network_drive "$i"; then | |
797 suggest="$i" | |
798 else | |
799 for j in "$i/"*; do | |
800 if [ -d "$j" -a -w "$j" -a \ | |
801 \( ! -a "$j/chroot" -o -w "$j/chroot/." \) ] && | |
802 ! is_network_drive "$j"; then | |
803 suggest="$j" | |
804 else | |
805 for k in "$j/"*; do | |
806 if [ -d "$k" -a -w "$k" -a \ | |
807 \( ! -a "$k/chroot" -o -w "$k/chroot/." \) ] && | |
808 ! is_network_drive "$k"; then | |
809 suggest="$k" | |
810 break | |
811 fi | |
812 done | |
813 fi | |
814 [ -n "${suggest}" ] && break | |
815 done | |
816 fi | |
817 [ -n "${suggest}" ] && break | |
818 done | |
819 def_suggest="${HOME}" | |
820 if [ -n "${suggest}" ]; then | |
821 # For home directories that reside on network drives, make our suggestion | |
822 # the default option. For home directories that reside on a local drive, | |
823 # require that the user manually enters the new location. | |
824 if is_network_drive "${HOME}"; then | |
825 def_suggest="${suggest}" | |
826 else | |
827 echo "A good location would probably be in \"${suggest}\"" | |
828 fi | |
829 fi | |
830 while :; do | |
831 printf "Physical location [${def_suggest}]: " | |
832 read dir | |
833 [ -z "${dir}" ] && dir="${def_suggest}" | |
834 [ "${dir%%/}" == "${HOME%%/}" ] && break | |
835 if ! [ -d "${dir}" -a -w "${dir}" ] || | |
836 [ -a "${dir}/chroot" -a ! -w "${dir}/chroot/." ]; then | |
837 echo "Cannot write to ${dir}/chroot. Please try again" | |
838 else | |
839 mv "${HOME}/chroot" "${dir}/chroot" | |
840 ln -s "${dir}/chroot" "${HOME}/chroot" | |
841 for i in $(list_all_chroots); do | |
842 sudo "$i" mkdir -p "${dir}/chroot" | |
843 done | |
844 sudo sed -i "s,${HOME}/chroot,${dir}/chroot,g" /etc/schroot/mount-* | |
845 break | |
846 fi | |
847 done | |
848 fi | |
849 | |
850 # Clean up package files | |
851 sudo schroot -c "${target%bit}" -p -- apt-get clean | |
852 sudo apt-get clean | |
853 | |
854 trap '' INT TERM QUIT HUP | |
855 trap '' EXIT | |
856 | |
857 # Let the user know what we did | |
858 cat <<EOF | |
859 | |
860 | |
861 Successfully installed ${distname} ${arch} | |
862 | |
863 You can run programs inside of the chroot by invoking the | |
864 "/usr/local/bin/${target%bit}" command. | |
865 | |
866 This command can be used with arguments, in order to just run a single | |
867 program inside of the chroot environment (e.g. "${target%bit} make chrome") | |
868 or without arguments, in order to run an interactive shell session inside | |
869 of the chroot environment. | |
870 | |
871 If you need to run things as "root", you can use "sudo" (e.g. try | |
872 "sudo ${target%bit} apt-get update"). | |
873 | |
874 Your home directory is shared between the host and the chroot. But I | |
875 configured "${HOME}/chroot" to be private to the chroot environment. | |
876 You can use it for files that need to differ between environments. This | |
877 would be a good place to store binaries that you have built from your | |
878 source files. | |
879 | |
880 For Chrome, this probably means you want to make your "out" directory a | |
881 symbolic link that points somewhere inside of "${HOME}/chroot". | |
882 | |
883 You still need to run "gclient runhooks" whenever you switch from building | |
884 outside of the chroot to inside of the chroot. But you will find that you | |
885 don't have to repeatedly erase and then completely rebuild all your object | |
886 and binary files. | |
887 | |
888 EOF | |
OLD | NEW |