native_client_sdk/src/tools/sel_ldr.py - chromium/src - Git at Google

 #!/usr/bin/env python
 # Copyright 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.

 """Wrapper script for launching application within the sel_ldr.
 """

 import argparse
 import os
 import subprocess
 import sys

 import create_nmf
 import getos

 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 NACL_SDK_ROOT = os.path.dirname(SCRIPT_DIR)

 if sys.version_info < (2, 7, 0):
   sys.stderr.write("python 2.7 or later is required run this script\n")
   sys.exit(1)


 class Error(Exception):
   pass


 def Log(msg):
   if Log.verbose:
     sys.stderr.write(str(msg) + '\n')
 Log.verbose = False


 def FindQemu():
   path = os.environ.get('PATH', '').split(os.pathsep)
   qemu_locations = [os.path.join(SCRIPT_DIR, 'qemu_arm'),
                     os.path.join(SCRIPT_DIR, 'qemu-arm')]
   qemu_locations += [os.path.join(p, 'qemu_arm') for p in path]
   qemu_locations += [os.path.join(p, 'qemu-arm') for p in path]
   # See if qemu is in any of these locations.
   qemu_bin = None
   for loc in qemu_locations:
     if os.path.isfile(loc) and os.access(loc, os.X_OK):
       qemu_bin = loc
       break
   return qemu_bin


 def main(argv):
   epilog = 'Example: sel_ldr.py my_nexe.nexe'
   parser = argparse.ArgumentParser(description=__doc__, epilog=epilog)
   parser.add_argument('-v', '--verbose', action='store_true',
                       help='Verbose output')
   parser.add_argument('-d', '--debug', action='store_true',
                       help='Enable debug stub')
   parser.add_argument('-e', '--exceptions', action='store_true',
                       help='Enable exception handling interface')
   parser.add_argument('-p', '--passthrough-environment', action='store_true',
                       help='Pass environment of host through to nexe')
   parser.add_argument('--debug-libs', action='store_true',
                       help='Legacy option, do not use')
   parser.add_argument('--config', default='Release',
                       help='Use a particular library configuration (normally '
                            'Debug or Release)')
   parser.add_argument('executable', help='executable (.nexe) to run')
   parser.add_argument('args', nargs='*', help='argument to pass to exectuable')
   parser.add_argument('--library-path',
                       help='Pass extra library paths')

   # To enable bash completion for this command first install optcomplete
   # and then add this line to your .bashrc:
   #  complete -F _optcomplete sel_ldr.py
   try:
     import optcomplete
     optcomplete.autocomplete(parser)
   except ImportError:
     pass

   options = parser.parse_args(argv)

   if options.verbose:
     Log.verbose = True

   osname = getos.GetPlatform()
   if not os.path.exists(options.executable):
     raise Error('executable not found: %s' % options.executable)
   if not os.path.isfile(options.executable):
     raise Error('not a file: %s' % options.executable)

   elf_arch, dynamic = create_nmf.ParseElfHeader(options.executable)

   if elf_arch == 'arm' and osname != 'linux':
     raise Error('Cannot run ARM executables under sel_ldr on ' + osname)

   arch_suffix = elf_arch.replace('-', '_')

   sel_ldr = os.path.join(SCRIPT_DIR, 'sel_ldr_%s' % arch_suffix)
   irt = os.path.join(SCRIPT_DIR, 'irt_core_%s.nexe' % arch_suffix)
   if osname == 'win':
     sel_ldr += '.exe'
   Log('ROOT    = %s' % NACL_SDK_ROOT)
   Log('SEL_LDR = %s' % sel_ldr)
   Log('IRT     = %s' % irt)
   cmd = [sel_ldr]

   if osname == 'linux':
     # Run sel_ldr under nacl_helper_bootstrap
     helper = os.path.join(SCRIPT_DIR, 'nacl_helper_bootstrap_%s' % arch_suffix)
     Log('HELPER  = %s' % helper)
     cmd.insert(0, helper)
     cmd.append('--r_debug=0xXXXXXXXXXXXXXXXX')
     cmd.append('--reserved_at_zero=0xXXXXXXXXXXXXXXXX')

   # This script is provided mostly as way to run binaries during testing, not
   # to run untrusted code in a production environment.  As such we want it be
   # as invisible as possible.  So we pass -q (quiet) to disable most of output
   # of sel_ldr itself, and -a (disable ACL) to enable local filesystem access.
   cmd += ['-q', '-a', '-B', irt]

   # Set the default NACLVERBOSITY level LOG_ERROR (-3).  This can still be
   # overridden in the environment if debug information is desired.  However
   # in most cases we don't want the application stdout/stderr polluted with
   # sel_ldr logging.
   if 'NACLVERBOSITY' not in os.environ and not options.verbose:
     os.environ['NACLVERBOSITY'] = "-3"

   if options.debug:
     cmd.append('-g')

   if options.exceptions:
     cmd.append('-e')

   if options.passthrough_environment:
     cmd.append('-p')

   if elf_arch == 'arm':
     # Use the QEMU arm emulator if available.
     qemu_bin = FindQemu()
     if not qemu_bin:
       raise Error('Cannot run ARM executables under sel_ldr without an emulator'
           '. Try installing QEMU (http://wiki.qemu.org/).')

     arm_libpath = os.path.join(NACL_SDK_ROOT, 'tools', 'lib', 'arm_trusted')
     if not os.path.isdir(arm_libpath):
       raise Error('Could not find ARM library path: %s' % arm_libpath)
     qemu = [qemu_bin, '-cpu', 'cortex-a8', '-L', arm_libpath]
     # '-Q' disables platform qualification, allowing arm binaries to run.
     cmd = qemu + cmd + ['-Q']

   if dynamic:
     if options.debug_libs:
       sys.stderr.write('warning: --debug-libs is deprecated (use --config).\n')
       options.config = 'Debug'

     sdk_lib_dir = os.path.join(NACL_SDK_ROOT, 'lib',
                                'glibc_%s' % arch_suffix, options.config)

     if elf_arch == 'x86-64':
       lib_subdir = 'lib'
       tcarch = 'x86'
       tcsubarch = 'x86_64'
       usr_arch = 'x86_64'
     elif elf_arch == 'arm':
       lib_subdir = 'lib'
       tcarch = 'arm'
       tcsubarch = 'arm'
       usr_arch = 'arm'
     elif elf_arch == 'x86-32':
       lib_subdir = 'lib32'
       tcarch = 'x86'
       tcsubarch = 'x86_64'
       usr_arch = 'i686'
     else:
       raise Error("Unknown arch: %s" % elf_arch)

     toolchain = '%s_%s_glibc' % (osname, tcarch)
     toolchain_dir = os.path.join(NACL_SDK_ROOT, 'toolchain', toolchain)
     interp_prefix = os.path.join(toolchain_dir, tcsubarch + '-nacl')
     lib_dir = os.path.join(interp_prefix, lib_subdir)
     usr_lib_dir = os.path.join(toolchain_dir, usr_arch + '-nacl', 'usr', 'lib')

     libpath = [usr_lib_dir, sdk_lib_dir, lib_dir]

     if options.config not in ['Debug', 'Release']:
       config_fallback = 'Release'
       if 'Debug' in options.config:
         config_fallback = 'Debug'
       libpath.append(os.path.join(NACL_SDK_ROOT, 'lib',
                      'glibc_%s' % arch_suffix, config_fallback))

     if options.library_path:
       libpath.extend([os.path.abspath(p) for p
                       in options.library_path.split(':')])
     libpath = ':'.join(libpath)
     if elf_arch == 'arm':
       ldso = os.path.join(SCRIPT_DIR, 'elf_loader_arm.nexe')
       cmd.append('-E')
       cmd.append('LD_LIBRARY_PATH=%s' % libpath)
       cmd.append(ldso)
       cmd.append('--interp-prefix')
       cmd.append(interp_prefix)
     else:
       ldso = os.path.join(lib_dir, 'runnable-ld.so')
       cmd.append(ldso)
       cmd.append('--library-path')
       cmd.append(libpath)
     Log('dynamic loader = %s' % ldso)


   # Append arguments for the executable itself.
   cmd.append(options.executable)
   cmd += options.args

   Log(cmd)
   return subprocess.call(cmd)


 if __name__ == '__main__':
   try:
     sys.exit(main(sys.argv[1:]))
   except Error as e:
     sys.stderr.write(str(e) + '\n')
     sys.exit(1)
	#!/usr/bin/env python
	# Copyright 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.

	"""Wrapper script for launching application within the sel_ldr.
	"""

	import argparse
	import os
	import subprocess
	import sys

	import create_nmf
	import getos

	SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
	NACL_SDK_ROOT = os.path.dirname(SCRIPT_DIR)

	if sys.version_info < (2, 7, 0):
	sys.stderr.write("python 2.7 or later is required run this script\n")
	sys.exit(1)


	class Error(Exception):
	pass


	def Log(msg):
	if Log.verbose:
	sys.stderr.write(str(msg) + '\n')
	Log.verbose = False


	def FindQemu():
	path = os.environ.get('PATH', '').split(os.pathsep)
	qemu_locations = [os.path.join(SCRIPT_DIR, 'qemu_arm'),
	os.path.join(SCRIPT_DIR, 'qemu-arm')]
	qemu_locations += [os.path.join(p, 'qemu_arm') for p in path]
	qemu_locations += [os.path.join(p, 'qemu-arm') for p in path]
	# See if qemu is in any of these locations.
	qemu_bin = None
	for loc in qemu_locations:
	if os.path.isfile(loc) and os.access(loc, os.X_OK):
	qemu_bin = loc
	break
	return qemu_bin


	def main(argv):
	epilog = 'Example: sel_ldr.py my_nexe.nexe'
	parser = argparse.ArgumentParser(description=__doc__, epilog=epilog)
	parser.add_argument('-v', '--verbose', action='store_true',
	help='Verbose output')
	parser.add_argument('-d', '--debug', action='store_true',
	help='Enable debug stub')
	parser.add_argument('-e', '--exceptions', action='store_true',
	help='Enable exception handling interface')
	parser.add_argument('-p', '--passthrough-environment', action='store_true',
	help='Pass environment of host through to nexe')
	parser.add_argument('--debug-libs', action='store_true',
	help='Legacy option, do not use')
	parser.add_argument('--config', default='Release',
	help='Use a particular library configuration (normally '
	'Debug or Release)')
	parser.add_argument('executable', help='executable (.nexe) to run')
	parser.add_argument('args', nargs='*', help='argument to pass to exectuable')
	parser.add_argument('--library-path',
	help='Pass extra library paths')

	# To enable bash completion for this command first install optcomplete
	# and then add this line to your .bashrc:
	# complete -F _optcomplete sel_ldr.py
	try:
	import optcomplete
	optcomplete.autocomplete(parser)
	except ImportError:
	pass

	options = parser.parse_args(argv)

	if options.verbose:
	Log.verbose = True

	osname = getos.GetPlatform()
	if not os.path.exists(options.executable):
	raise Error('executable not found: %s' % options.executable)
	if not os.path.isfile(options.executable):
	raise Error('not a file: %s' % options.executable)

	elf_arch, dynamic = create_nmf.ParseElfHeader(options.executable)

	if elf_arch == 'arm' and osname != 'linux':
	raise Error('Cannot run ARM executables under sel_ldr on ' + osname)

	arch_suffix = elf_arch.replace('-', '_')

	sel_ldr = os.path.join(SCRIPT_DIR, 'sel_ldr_%s' % arch_suffix)
	irt = os.path.join(SCRIPT_DIR, 'irt_core_%s.nexe' % arch_suffix)
	if osname == 'win':
	sel_ldr += '.exe'
	Log('ROOT = %s' % NACL_SDK_ROOT)
	Log('SEL_LDR = %s' % sel_ldr)
	Log('IRT = %s' % irt)
	cmd = [sel_ldr]

	if osname == 'linux':
	# Run sel_ldr under nacl_helper_bootstrap
	helper = os.path.join(SCRIPT_DIR, 'nacl_helper_bootstrap_%s' % arch_suffix)
	Log('HELPER = %s' % helper)
	cmd.insert(0, helper)
	cmd.append('--r_debug=0xXXXXXXXXXXXXXXXX')
	cmd.append('--reserved_at_zero=0xXXXXXXXXXXXXXXXX')

	# This script is provided mostly as way to run binaries during testing, not
	# to run untrusted code in a production environment. As such we want it be
	# as invisible as possible. So we pass -q (quiet) to disable most of output
	# of sel_ldr itself, and -a (disable ACL) to enable local filesystem access.
	cmd += ['-q', '-a', '-B', irt]

	# Set the default NACLVERBOSITY level LOG_ERROR (-3). This can still be
	# overridden in the environment if debug information is desired. However
	# in most cases we don't want the application stdout/stderr polluted with
	# sel_ldr logging.
	if 'NACLVERBOSITY' not in os.environ and not options.verbose:
	os.environ['NACLVERBOSITY'] = "-3"

	if options.debug:
	cmd.append('-g')

	if options.exceptions:
	cmd.append('-e')

	if options.passthrough_environment:
	cmd.append('-p')

	if elf_arch == 'arm':
	# Use the QEMU arm emulator if available.
	qemu_bin = FindQemu()
	if not qemu_bin:
	raise Error('Cannot run ARM executables under sel_ldr without an emulator'
	'. Try installing QEMU (http://wiki.qemu.org/).')

	arm_libpath = os.path.join(NACL_SDK_ROOT, 'tools', 'lib', 'arm_trusted')
	if not os.path.isdir(arm_libpath):
	raise Error('Could not find ARM library path: %s' % arm_libpath)
	qemu = [qemu_bin, '-cpu', 'cortex-a8', '-L', arm_libpath]
	# '-Q' disables platform qualification, allowing arm binaries to run.
	cmd = qemu + cmd + ['-Q']

	if dynamic:
	if options.debug_libs:
	sys.stderr.write('warning: --debug-libs is deprecated (use --config).\n')
	options.config = 'Debug'

	sdk_lib_dir = os.path.join(NACL_SDK_ROOT, 'lib',
	'glibc_%s' % arch_suffix, options.config)

	if elf_arch == 'x86-64':
	lib_subdir = 'lib'
	tcarch = 'x86'
	tcsubarch = 'x86_64'
	usr_arch = 'x86_64'
	elif elf_arch == 'arm':
	lib_subdir = 'lib'
	tcarch = 'arm'
	tcsubarch = 'arm'
	usr_arch = 'arm'
	elif elf_arch == 'x86-32':
	lib_subdir = 'lib32'
	tcarch = 'x86'
	tcsubarch = 'x86_64'
	usr_arch = 'i686'
	else:
	raise Error("Unknown arch: %s" % elf_arch)

	toolchain = '%s_%s_glibc' % (osname, tcarch)
	toolchain_dir = os.path.join(NACL_SDK_ROOT, 'toolchain', toolchain)
	interp_prefix = os.path.join(toolchain_dir, tcsubarch + '-nacl')
	lib_dir = os.path.join(interp_prefix, lib_subdir)
	usr_lib_dir = os.path.join(toolchain_dir, usr_arch + '-nacl', 'usr', 'lib')

	libpath = [usr_lib_dir, sdk_lib_dir, lib_dir]

	if options.config not in ['Debug', 'Release']:
	config_fallback = 'Release'
	if 'Debug' in options.config:
	config_fallback = 'Debug'
	libpath.append(os.path.join(NACL_SDK_ROOT, 'lib',
	'glibc_%s' % arch_suffix, config_fallback))

	if options.library_path:
	libpath.extend([os.path.abspath(p) for p
	in options.library_path.split(':')])
	libpath = ':'.join(libpath)
	if elf_arch == 'arm':
	ldso = os.path.join(SCRIPT_DIR, 'elf_loader_arm.nexe')
	cmd.append('-E')
	cmd.append('LD_LIBRARY_PATH=%s' % libpath)
	cmd.append(ldso)
	cmd.append('--interp-prefix')
	cmd.append(interp_prefix)
	else:
	ldso = os.path.join(lib_dir, 'runnable-ld.so')
	cmd.append(ldso)
	cmd.append('--library-path')
	cmd.append(libpath)
	Log('dynamic loader = %s' % ldso)


	# Append arguments for the executable itself.
	cmd.append(options.executable)
	cmd += options.args

	Log(cmd)
	return subprocess.call(cmd)


	if __name__ == '__main__':
	try:
	sys.exit(main(sys.argv[1:]))
	except Error as e:
	sys.stderr.write(str(e) + '\n')
	sys.exit(1)