1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
#!/usr/bin/env python
# Copyright (c) 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Install Debian Wheezy sysroots for building chromium.
"""
# The sysroot is needed to ensure that binaries will run on Debian Wheezy,
# the oldest supported linux distribution. This script can be run manually but
# is more often run as part of gclient hooks. When run from hooks this script
# in a no-op on non-linux platforms.
# The sysroot image could be constructed from scratch based on the current
# state or Debian Wheezy but for consistency we currently use a pre-built root
# image. The image will normally need to be rebuilt every time chrome's build
# dependencies are changed.
import hashlib
import platform
import optparse
import os
import re
import shutil
import subprocess
import sys
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(os.path.dirname(os.path.dirname(SCRIPT_DIR)))
import detect_host_arch
import gyp_chromium
import gyp_environment
URL_PREFIX = 'https://commondatastorage.googleapis.com'
URL_PATH = 'chrome-linux-sysroot/toolchain'
REVISION_AMD64 = 'c52471d9dec240c8d0a88fa98aa1eefeee32e22f'
REVISION_ARM = 'c52471d9dec240c8d0a88fa98aa1eefeee32e22f'
REVISION_I386 = 'c52471d9dec240c8d0a88fa98aa1eefeee32e22f'
REVISION_MIPS = 'c52471d9dec240c8d0a88fa98aa1eefeee32e22f'
TARBALL_AMD64 = 'debian_wheezy_amd64_sysroot.tgz'
TARBALL_ARM = 'debian_wheezy_arm_sysroot.tgz'
TARBALL_I386 = 'debian_wheezy_i386_sysroot.tgz'
TARBALL_MIPS = 'debian_wheezy_mips_sysroot.tgz'
TARBALL_AMD64_SHA1SUM = 'ca4ed6e7c9e333b046be19d38584a11f6785eea6'
TARBALL_ARM_SHA1SUM = '1fab0c2b1e93a933ddc593df3b43872b0ba5ded2'
TARBALL_I386_SHA1SUM = '80c48c303319af2284e4a104c882d888af75ba81'
TARBALL_MIPS_SHA1SUM = '01da32a35288627e05cfca193b7f3659531c6f7d'
SYSROOT_DIR_AMD64 = 'debian_wheezy_amd64-sysroot'
SYSROOT_DIR_ARM = 'debian_wheezy_arm-sysroot'
SYSROOT_DIR_I386 = 'debian_wheezy_i386-sysroot'
SYSROOT_DIR_MIPS = 'debian_wheezy_mips-sysroot'
valid_archs = ('arm', 'i386', 'amd64', 'mips')
class Error(Exception):
pass
def GetSha1(filename):
sha1 = hashlib.sha1()
with open(filename, 'rb') as f:
while True:
# Read in 1mb chunks, so it doesn't all have to be loaded into memory.
chunk = f.read(1024*1024)
if not chunk:
break
sha1.update(chunk)
return sha1.hexdigest()
def DetectHostArch():
# Figure out host arch using build/detect_host_arch.py and
# set target_arch to host arch
detected_host_arch = detect_host_arch.HostArch()
if detected_host_arch == 'x64':
return 'amd64'
elif detected_host_arch == 'ia32':
return 'i386'
elif detected_host_arch == 'arm':
return 'arm'
elif detected_host_arch == 'mips':
return 'mips'
raise Error('Unrecognized host arch: %s' % detected_host_arch)
def DetectTargetArch():
"""Attempt for determine target architecture.
This works by looking for target_arch in GYP_DEFINES.
"""
# TODO(agrieve): Make this script not depend on GYP_DEFINES so that it works
# with GN as well.
gyp_environment.SetEnvironment()
supplemental_includes = gyp_chromium.GetSupplementalFiles()
gyp_defines = gyp_chromium.GetGypVars(supplemental_includes)
target_arch = gyp_defines.get('target_arch')
if target_arch == 'x64':
return 'amd64'
elif target_arch == 'ia32':
return 'i386'
elif target_arch == 'arm':
return 'arm'
elif target_arch == 'arm64':
return 'arm64'
elif target_arch == 'mipsel':
return 'mips'
elif target_arch:
raise Error('Unrecognized target_arch: %s' % target_arch)
return None
def InstallDefaultSysroots():
"""Install the default set of sysroot images.
This includes at least the sysroot for host architecture, and the 32-bit
sysroot for building the v8 snapshot image. It can also include the cross
compile sysroot for ARM/MIPS if cross compiling environment can be detected.
"""
host_arch = DetectHostArch()
InstallSysroot(host_arch)
if host_arch == 'amd64':
InstallSysroot('i386')
# Finally, if we can detect a non-standard target_arch such as ARM or
# MIPS, then install the sysroot too.
# Don't attampt to install arm64 since this is currently and android-only
# architecture.
target_arch = DetectTargetArch()
if target_arch and target_arch not in (host_arch, 'i386', 'arm64'):
InstallSysroot(target_arch)
def main(args):
parser = optparse.OptionParser('usage: %prog [OPTIONS]', description=__doc__)
parser.add_option('--running-as-hook', action='store_true',
default=False, help='Used when running from gclient hooks.'
' Installs default sysroot images.')
parser.add_option('--arch', type='choice', choices=valid_archs,
help='Sysroot architecture: %s' % ', '.join(valid_archs))
options, _ = parser.parse_args(args)
if options.running_as_hook and not sys.platform.startswith('linux'):
return 0
if options.running_as_hook:
InstallDefaultSysroots()
else:
if not options.arch:
print 'You much specify either --arch or --running-as-hook'
return 1
InstallSysroot(options.arch)
return 0
def InstallSysroot(target_arch):
# The sysroot directory should match the one specified in build/common.gypi.
# TODO(thestig) Consider putting this else where to avoid having to recreate
# it on every build.
linux_dir = os.path.dirname(SCRIPT_DIR)
if target_arch == 'amd64':
sysroot = os.path.join(linux_dir, SYSROOT_DIR_AMD64)
tarball_filename = TARBALL_AMD64
tarball_sha1sum = TARBALL_AMD64_SHA1SUM
revision = REVISION_AMD64
elif target_arch == 'arm':
sysroot = os.path.join(linux_dir, SYSROOT_DIR_ARM)
tarball_filename = TARBALL_ARM
tarball_sha1sum = TARBALL_ARM_SHA1SUM
revision = REVISION_ARM
elif target_arch == 'i386':
sysroot = os.path.join(linux_dir, SYSROOT_DIR_I386)
tarball_filename = TARBALL_I386
tarball_sha1sum = TARBALL_I386_SHA1SUM
revision = REVISION_I386
elif target_arch == 'mips':
sysroot = os.path.join(linux_dir, SYSROOT_DIR_MIPS)
tarball_filename = TARBALL_MIPS
tarball_sha1sum = TARBALL_MIPS_SHA1SUM
revision = REVISION_MIPS
else:
raise Error('Unknown architecture: %s' % target_arch)
url = '%s/%s/%s/%s' % (URL_PREFIX, URL_PATH, revision, tarball_filename)
stamp = os.path.join(sysroot, '.stamp')
if os.path.exists(stamp):
with open(stamp) as s:
if s.read() == url:
print 'Debian Wheezy %s root image already up-to-date: %s' % \
(target_arch, sysroot)
return
print 'Installing Debian Wheezy %s root image: %s' % (target_arch, sysroot)
if os.path.isdir(sysroot):
shutil.rmtree(sysroot)
os.mkdir(sysroot)
tarball = os.path.join(sysroot, tarball_filename)
print 'Downloading %s' % url
sys.stdout.flush()
sys.stderr.flush()
subprocess.check_call(
['curl', '--fail', '--retry', '3', '-L', url, '-o', tarball])
sha1sum = GetSha1(tarball)
if sha1sum != tarball_sha1sum:
raise Error('Tarball sha1sum is wrong.'
'Expected %s, actual: %s' % (tarball_sha1sum, sha1sum))
subprocess.check_call(['tar', 'xf', tarball, '-C', sysroot])
os.remove(tarball)
with open(stamp, 'w') as s:
s.write(url)
if __name__ == '__main__':
try:
sys.exit(main(sys.argv[1:]))
except Error as e:
sys.stderr.write(str(e) + '\n')
sys.exit(1)
|
