Clone of chromium aad1ce808763f59c7a3753e08f1500a104ecc6fd refs/remotes/origin/HEAD
diff --git a/tools/android/OWNERS b/tools/android/OWNERS new file mode 100644 index 0000000..f8370f6 --- /dev/null +++ b/tools/android/OWNERS
@@ -0,0 +1,4 @@ +digit@chromium.org +michaelbai@chromium.org +wangxianzhu@chromium.org +yfriedman@chromium.org
diff --git a/tools/android/adb_reboot/adb_reboot.c b/tools/android/adb_reboot/adb_reboot.c new file mode 100644 index 0000000..d414dd5 --- /dev/null +++ b/tools/android/adb_reboot/adb_reboot.c
@@ -0,0 +1,43 @@ +// 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. + +#include <sys/types.h> +#include <sys/stat.h> +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <unistd.h> + +int main(int argc, char ** argv) { + int i = fork(); + struct stat ft; + time_t ct; + + if (i < 0) { + printf("fork error"); + return 1; + } + if (i > 0) + return 0; + + /* child (daemon) continues */ + int j; + for (j = 0; j < sysconf(_SC_OPEN_MAX); j++) + close(j); + + setsid(); /* obtain a new process group */ + + while (1) { + sleep(120); + + stat("/sdcard/host_heartbeat", &ft); + time(&ct); + if (ct - ft.st_mtime > 120) { + /* File was not touched for some time. */ + system("su -c reboot"); + } + } + + return 0; +}
diff --git a/tools/android/adb_reboot/adb_reboot.gyp b/tools/android/adb_reboot/adb_reboot.gyp new file mode 100644 index 0000000..85134b9 --- /dev/null +++ b/tools/android/adb_reboot/adb_reboot.gyp
@@ -0,0 +1,14 @@ +# 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. +{ + 'targets': [ + { + 'target_name': 'adb_reboot', + 'type': 'executable', + 'sources': [ + 'adb_reboot.c', + ], + }, + ], +}
diff --git a/tools/android/adb_remote_setup.sh b/tools/android/adb_remote_setup.sh new file mode 100755 index 0000000..87c6601 --- /dev/null +++ b/tools/android/adb_remote_setup.sh
@@ -0,0 +1,95 @@ +#!/bin/bash +# Copyright 2014 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. + +# URL from which the latest version of this script can be downloaded. +script_url="http://src.chromium.org/svn/trunk/src/tools/android/adb_remote_setup.sh" + +# Replaces this file with the latest version of the script and runs it. +update-self() { + local script="${BASH_SOURCE[0]}" + local new_script="${script}.new" + local updater_script="${script}.updater" + curl -sSf -o "$new_script" "$script_url" || return + chmod +x "$new_script" || return + + # Replace this file with the newly downloaded script. + cat > "$updater_script" << EOF +#!/bin/bash +if mv "$new_script" "$script"; then + rm -- "$updater_script" +else + echo "Note: script update failed." +fi +ADB_REMOTE_SETUP_NO_UPDATE=1 exec /bin/bash "$script" $@ +EOF + exec /bin/bash "$updater_script" "$@" +} + +if [[ "$ADB_REMOTE_SETUP_NO_UPDATE" -ne 1 ]]; then + update-self "$@" || echo 'Note: script update failed' +fi + +if [[ $# -ne 1 && $# -ne 2 ]]; then + cat <<'EOF' +Usage: adb_remote_setup.sh REMOTE_HOST [REMOTE_ADB] + +Configures adb on a remote machine to communicate with a device attached to the +local machine. This is useful for installing APKs, running tests, etc while +working remotely. + +Arguments: + REMOTE_HOST hostname of remote machine + REMOTE_ADB path to adb on the remote machine (you can omit this if adb is in + the remote host's path) +EOF + exit 1 +fi + +remote_host="$1" +remote_adb="${2:-adb}" + +# Ensure adb is in the local machine's path. +if ! which adb >/dev/null; then + echo "error: adb must be in your local machine's path." + exit 1 +fi + +if which kinit >/dev/null; then + # Allow ssh to succeed without typing your password multiple times. + kinit -R || kinit +fi + +# Ensure local and remote versions of adb are the same. +remote_adb_version=$(ssh "$remote_host" "$remote_adb version") +local_adb_version=$(adb version) +if [[ "$local_adb_version" != "$remote_adb_version" ]]; then + echo >&2 + echo "WARNING: local adb is not the same version as remote adb." >&2 + echo "This should be fixed since it may result in protocol errors." >&2 + echo " local adb: $local_adb_version" >&2 + echo " remote adb: $remote_adb_version" >&2 + echo >&2 + sleep 5 +fi + +# Kill the adb server on the remote host. +ssh "$remote_host" "$remote_adb kill-server" + +# Start the adb server locally. +adb start-server + +# Forward various ports from the remote host to the local host: +# 5037: adb +# 8001: http server +# 9031: sync server +# 10000: net unittests +# 10201: net unittests +ssh -C \ + -R 5037:localhost:5037 \ + -L 8001:localhost:8001 \ + -L 9031:localhost:9031 \ + -R 10000:localhost:10000 \ + -R 10201:localhost:10201 \ + "$remote_host"
diff --git a/tools/android/android_tools.gyp b/tools/android/android_tools.gyp new file mode 100644 index 0000000..84de85c --- /dev/null +++ b/tools/android/android_tools.gyp
@@ -0,0 +1,52 @@ +# Copyright (c) 2012 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. + +{ + 'targets': [ + # Intermediate target grouping the android tools needed to run native + # unittests and instrumentation test apks. + { + 'target_name': 'android_tools', + 'type': 'none', + 'dependencies': [ + 'adb_reboot/adb_reboot.gyp:adb_reboot', + 'file_poller/file_poller.gyp:file_poller', + 'forwarder2/forwarder.gyp:forwarder2', + 'md5sum/md5sum.gyp:md5sum', + 'purge_ashmem/purge_ashmem.gyp:purge_ashmem', + 'run_pie/run_pie.gyp:run_pie', + '../../tools/telemetry/telemetry.gyp:*#host', + ], + }, + { + 'target_name': 'heap_profiler', + 'type': 'none', + 'dependencies': [ + 'heap_profiler/heap_profiler.gyp:heap_dump', + 'heap_profiler/heap_profiler.gyp:heap_profiler', + ], + }, + { + 'target_name': 'memdump', + 'type': 'none', + 'dependencies': [ + 'memdump/memdump.gyp:memdump', + ], + }, + { + 'target_name': 'memconsumer', + 'type': 'none', + 'dependencies': [ + 'memconsumer/memconsumer.gyp:memconsumer', + ], + }, + { + 'target_name': 'ps_ext', + 'type': 'none', + 'dependencies': [ + 'ps_ext/ps_ext.gyp:ps_ext', + ], + }, + ], +}
diff --git a/tools/android/asan/asan_device_setup.sh b/tools/android/asan/asan_device_setup.sh new file mode 100755 index 0000000..5948f2b --- /dev/null +++ b/tools/android/asan/asan_device_setup.sh
@@ -0,0 +1,194 @@ +#!/bin/bash -e +#===- lib/asan/scripts/asan_device_setup.py -----------------------------------===# +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +# Prepare Android device to run ASan applications. +# +#===------------------------------------------------------------------------===# + + +HERE="$(cd "$(dirname "$0")" && pwd)" + +revert=no +extra_options= +device= +lib= + +function usage { + echo "usage: $0 [--revert] [--device device-id] [--lib path] [--extra_options options]" + echo " --revert: Uninstall ASan from the device." + echo " --lib: Path to ASan runtime library." + echo " --extra_options: Extra ASAN_OPTIONS." + echo " --device: Install to the given device. Use 'adb devices' to find" + echo " device-id." + echo + exit 1 +} + +while [[ $# > 0 ]]; do + case $1 in + --revert) + revert=yes + ;; + --extra-options) + shift + if [[ $# == 0 ]]; then + echo "--extra-options requires an argument." + exit 1 + fi + extra_options="$1" + ;; + --lib) + shift + if [[ $# == 0 ]]; then + echo "--lib requires an argument." + exit 1 + fi + lib="$1" + ;; + --device) + shift + if [[ $# == 0 ]]; then + echo "--device requires an argument." + exit 1 + fi + device="$1" + ;; + *) + usage + ;; + esac + shift +done + +ADB=${ADB:-adb} +if [[ x$device != x ]]; then + ADB="$ADB -s $device" +fi + +ASAN_RT="libclang_rt.asan-arm-android.so" + +if [[ x$revert == xyes ]]; then + echo '>> Uninstalling ASan' + $ADB root + $ADB wait-for-device + $ADB remount + $ADB shell mv /system/bin/app_process.real /system/bin/app_process + $ADB shell rm /system/bin/asanwrapper + $ADB shell rm /system/lib/$ASAN_RT + + echo '>> Restarting shell' + $ADB shell stop + $ADB shell start + + echo '>> Done' + exit 0 +fi + +if [[ -d "$lib" ]]; then + ASAN_RT_PATH="$lib" +elif [[ -f "$lib" && "$lib" == *"$ASAN_RT" ]]; then + ASAN_RT_PATH=$(dirname "$lib") +elif [[ -f "$HERE/$ASAN_RT" ]]; then + ASAN_RT_PATH="$HERE" +elif [[ $(basename "$HERE") == "bin" ]]; then + # We could be in the toolchain's base directory. + # Consider ../lib and ../lib/clang/$VERSION/lib/linux. + P=$(ls "$HERE"/../lib/"$ASAN_RT" "$HERE"/../lib/clang/*/lib/linux/"$ASAN_RT" 2>/dev/null | sort | tail -1) + if [[ -n "$P" ]]; then + ASAN_RT_PATH="$(dirname "$P")" + fi +fi + +if [[ -z "$ASAN_RT_PATH" || ! -f "$ASAN_RT_PATH/$ASAN_RT" ]]; then + echo "ASan runtime library not found" + exit 1 +fi + +TMPDIRBASE=$(mktemp -d) +TMPDIROLD="$TMPDIRBASE/old" +TMPDIR="$TMPDIRBASE/new" +mkdir "$TMPDIROLD" + +echo '>> Remounting /system rw' +$ADB root +$ADB wait-for-device +$ADB remount + +echo '>> Copying files from the device' +$ADB pull /system/bin/app_process "$TMPDIROLD" +$ADB pull /system/bin/app_process.real "$TMPDIROLD" || true +$ADB pull /system/bin/asanwrapper "$TMPDIROLD" || true +$ADB pull /system/lib/libclang_rt.asan-arm-android.so "$TMPDIROLD" || true +cp -r "$TMPDIROLD" "$TMPDIR" + +if ! [[ -f "$TMPDIR/app_process" ]]; then + echo "app_process missing???" + exit 1 +fi + +if [[ -f "$TMPDIR/app_process.real" ]]; then + echo "app_process.real exists, updating the wrapper" +else + echo "app_process.real missing, new installation" + mv "$TMPDIR/app_process" "$TMPDIR/app_process.real" +fi + +echo '>> Generating wrappers' + +cp "$ASAN_RT_PATH/$ASAN_RT" "$TMPDIR/" + +# FIXME: alloc_dealloc_mismatch=0 prevents a failure in libdvm startup, +# which may or may not be a real bug (probably not). +ASAN_OPTIONS=start_deactivated=1,alloc_dealloc_mismatch=0 +if [[ x$extra_options != x ]] ; then + ASAN_OPTIONS="$ASAN_OPTIONS,$extra_options" +fi + +# Zygote wrapper. +cat <<EOF >"$TMPDIR/app_process" +#!/system/bin/sh +ASAN_OPTIONS=$ASAN_OPTIONS \\ +LD_PRELOAD=libclang_rt.asan-arm-android.so \\ +exec /system/bin/app_process.real \$@ + +EOF + +# General command-line tool wrapper (use for anything that's not started as +# zygote). +cat <<EOF >"$TMPDIR/asanwrapper" +#!/system/bin/sh +LD_PRELOAD=libclang_rt.asan-arm-android.so \\ +exec \$@ + +EOF + +if ! ( cd "$TMPDIRBASE" && diff -qr old/ new/ ) ; then + echo '>> Pushing files to the device' + $ADB push "$TMPDIR/$ASAN_RT" /system/lib/ + $ADB push "$TMPDIR/app_process" /system/bin/app_process + $ADB push "$TMPDIR/app_process.real" /system/bin/app_process.real + $ADB push "$TMPDIR/asanwrapper" /system/bin/asanwrapper + $ADB shell chown root.shell \ + /system/bin/app_process \ + /system/bin/app_process.real \ + /system/bin/asanwrapper + $ADB shell chmod 755 \ + /system/bin/app_process \ + /system/bin/app_process.real \ + /system/bin/asanwrapper + + echo '>> Restarting shell (asynchronous)' + $ADB shell stop + $ADB shell start + + echo '>> Please wait until the device restarts' +else + echo '>> Device is up to date' +fi + +rm -r "$TMPDIRBASE"
diff --git a/tools/android/checkstyle/checkstyle.py b/tools/android/checkstyle/checkstyle.py new file mode 100644 index 0000000..25f202f --- /dev/null +++ b/tools/android/checkstyle/checkstyle.py
@@ -0,0 +1,69 @@ +# 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. + +"""Script that is used by PRESUBMIT.py to run style checks on Java files.""" + +import os +import subprocess + + +CHROMIUM_SRC = os.path.normpath( + os.path.join(os.path.dirname(__file__), + os.pardir, os.pardir, os.pardir)) +CHECKSTYLE_ROOT = os.path.join(CHROMIUM_SRC, 'third_party', 'checkstyle', + 'checkstyle-5.7-all.jar') + + +def RunCheckstyle(input_api, output_api, style_file): + if not os.path.exists(style_file): + file_error = (' Java checkstyle configuration file is missing: ' + + style_file) + return [output_api.PresubmitError(file_error)] + + # Filter out non-Java files and files that were deleted. + java_files = [x.LocalPath() for x in input_api.AffectedFiles(False, False) + if os.path.splitext(x.LocalPath())[1] == '.java'] + if not java_files: + return [] + + # Run checkstyle + checkstyle_env = os.environ.copy() + checkstyle_env['JAVA_CMD'] = 'java' + try: + check = subprocess.Popen(['java', '-cp', + CHECKSTYLE_ROOT, + 'com.puppycrawl.tools.checkstyle.Main', '-c', + style_file] + java_files, + stdout=subprocess.PIPE, env=checkstyle_env) + stdout, _ = check.communicate() + if check.returncode == 0: + return [] + except OSError as e: + import errno + if e.errno == errno.ENOENT: + install_error = (' checkstyle is not installed. Please run ' + 'build/install-build-deps-android.sh') + return [output_api.PresubmitPromptWarning(install_error)] + + # Remove non-error values from stdout + errors = stdout.splitlines() + + if errors and errors[0] == 'Starting audit...': + del errors[0] + if errors and errors[-1] == 'Audit done.': + del errors[-1] + + # Filter out warnings + errors = [x for x in errors if 'warning: ' not in x] + if not errors: + return [] + + local_path = input_api.PresubmitLocalPath() + output = [] + for error in errors: + # Change the full file path to relative path in the output lines + full_path, end = error.split(':', 1) + rel_path = os.path.relpath(full_path, local_path) + output.append(' %s:%s' % (rel_path, end)) + return [output_api.PresubmitPromptWarning('\n'.join(output))]
diff --git a/tools/android/checkstyle/chromium-style-5.0.xml b/tools/android/checkstyle/chromium-style-5.0.xml new file mode 100644 index 0000000..bc40f87 --- /dev/null +++ b/tools/android/checkstyle/chromium-style-5.0.xml
@@ -0,0 +1,183 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.3//EN" "http://www.puppycrawl.com/dtds/configuration_1_3.dtd"> + +<!-- + See installation instructions: https://sites.google.com/a/chromium.org/dev/checkstyle +--> +<module name="Checker"> + <property name="severity" value="warning"/> + <property name="charset" value="UTF-8"/> + <module name="TreeWalker"> + <module name="AvoidStarImport"> + <property name="severity" value="error"/> + </module> + <module name="IllegalCatch"> + <property name="severity" value="warning"/> + </module> + <module name="RedundantImport"> + <message key="import.redundant" value="Redundant import: {0}. Use :JavaImportOrganize (ECLIM) or Ctrl+Shift+O (Eclipse) to sort imports"/> + <property name="severity" value="error"/> + </module> + <module name="UnusedImports"> + <property name="severity" value="error"/> + <property name="processJavadoc" value="true"/> + <message key="import.unused" value="Unused import: {0}. Use :JavaImportOrganize (ECLIM) or Ctrl+Shift+O (Eclipse) to sort imports"/> + </module> + <module name="JavadocType"> + <property name="severity" value="error"/> + <property name="tokens" value="INTERFACE_DEF, CLASS_DEF"/> + <property name="scope" value="public"/> + <message key="javadoc.missing" value="Public classes and interfaces require JavaDoc comments."/> + </module> + <module name="JavadocMethod"> + <property name="severity" value="warning"/> + <property name="scope" value="public"/> + <property name="allowMissingParamTags" value="true"/> + <property name="allowMissingPropertyJavadoc" value="true"/> + <property name="allowMissingReturnTag" value="true"/> + <property name="allowMissingThrowsTags" value="true"/> + </module> + <module name="PackageName"> + <property name="severity" value="error"/> + <property name="format" value="^[a-z]+(\.[a-z][a-z0-9_]{1,})*$"/> + </module> + <module name="SimplifyBooleanExpression"> + <property name="severity" value="error"/> + </module> + <module name="SimplifyBooleanReturn"> + <property name="severity" value="error"/> + </module> + <module name="TypeName"> + <property name="severity" value="error"/> + </module> + <module name="ConstantName"> + <property name="severity" value="error"/> + <property name="format" value="^([A-Z][A-Z0-9]*(_[A-Z0-9]+)*)|(s[A-Z][a-zA-Z0-9]*)$"/> + <message key="name.invalidPattern" value="Static final field names must either be all caps (e.g. int HEIGHT_PX) for 'true' constants, or start with s (e.g. AtomicInteger sNextId or Runnable sSuspendTask) for fields with mutable state or that don't 'feel' like constants."/> + </module> + <!-- Non-public, non-static field names start with m. --> + <module name="MemberName"> + <property name="severity" value="error"/> + <property name="format" value="^m[A-Z][a-zA-Z0-9]*$"/> + <property name="applyToPublic" value="false"/> + <message key="name.invalidPattern" value="Non-public, non-static field names start with m."/> + </module> + <!-- Static field names start with s. --> + <module name="StaticVariableName"> + <property name="severity" value="error"/> + <property name="format" value="^s[A-Z][a-zA-Z0-9]*$"/> + <property name="applyToPublic" value="false"/> + <message key="name.invalidPattern" value="Static field names start with s."/> + </module> + <module name="MethodName"> + <property name="severity" value="error"/> + <property name="format" value="^[a-z][a-zA-Z0-9_]*$"/> + <message key="name.invalidPattern" value="Method names should start with a lower case letter (e.g. getWidth())"/> + </module> + <module name="ParameterName"> + <property name="severity" value="error"/> + </module> + <module name="LocalFinalVariableName"> + <property name="severity" value="error"/> + <property name="format" value="^m|s|((([ms][a-z0-9])|([a-ln-rt-z]))[a-zA-Z0-9]*)$"/> + <message key="name.invalidPattern" value="Local variables should be camel-cased (e.g. int minWidth = 4)."/> + </module> + <module name="LocalVariableName"> + <property name="severity" value="error"/> + <property name="format" value="^m|s|((([ms][a-z0-9])|([a-ln-rt-z]))[a-zA-Z0-9]*)$"/> + <message key="name.invalidPattern" value="Local variables should be camel-cased (e.g. int minWidth = 4)."/> + </module> + <module name="LineLength"> + <property name="severity" value="error"/> + <property name="ignorePattern" value="^import.*$" /> + <property name="max" value="100"/> + </module> + <module name="LeftCurly"> + <property name="severity" value="error"/> + </module> + <module name="RightCurly"> + <property name="severity" value="error"/> + </module> + <module name="NeedBraces"> + <property name="severity" value="warning"/> + <property name="tokens" value="LITERAL_FOR, LITERAL_WHILE, LITERAL_DO"/> + </module> + <module name="EmptyBlock"> + <property name="severity" value="error"/> + <property name="option" value="text"/> + <metadata name="altname" value="EmptyCatchBlock"/> + </module> + <module name="UpperEll"> + <property name="severity" value="error"/> + </module> + <module name="FallThrough"> + <property name="severity" value="error"/> + <property name="reliefPattern" value=".*"/> + </module> + <module name="ModifierOrder"> + <property name="severity" value="error"/> + </module> + <module name="WhitespaceAround"> + <property name="severity" value="error"/> + <property name="tokens" value="ASSIGN, BAND, BAND_ASSIGN, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN, BXOR, BXOR_ASSIGN, COLON, DIV, DIV_ASSIGN, EQUAL, GE, GT, LAND, LE, LITERAL_ASSERT, LITERAL_CATCH, LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_FOR, LITERAL_IF, LITERAL_RETURN, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE, LOR, LT, MINUS, MINUS_ASSIGN, MOD, MOD_ASSIGN, NOT_EQUAL, PLUS, PLUS_ASSIGN, QUESTION, SL, SLIST, SL_ASSIGN, SR, SR_ASSIGN, STAR, STAR_ASSIGN, TYPE_EXTENSION_AND" /> + <property name="allowEmptyConstructors" value="true"/> + <property name="allowEmptyMethods" value="true"/> + </module> + <module name="WhitespaceAfter"> + <property name="severity" value="error"/> + <property name="tokens" value="COMMA, SEMI, TYPECAST"/> + </module> + <module name="NoWhitespaceAfter"> + <property name="severity" value="error"/> + <property name="tokens" value="BNOT, DEC, DOT, INC, LNOT, UNARY_MINUS, UNARY_PLUS"/> + </module> + <module name="NoWhitespaceBefore"> + <property name="severity" value="error"/> + <property name="allowLineBreaks" value="true"/> + <property name="tokens" value="SEMI, DOT, POST_DEC, POST_INC"/> + </module> + <module name="EmptyStatement"> + <property name="severity" value="error"/> + </module> + <module name="NoFinalizer"> + <property name="severity" value="warning"/> + </module> + <module name="ParenPad"> + <property name="severity" value="error"/> + </module> + <module name="ImportOrder"> + <property name="severity" value="error"/> + <message key="import.ordering" value="Wrong order for {0} import. Use :JavaImportOrganize (ECLIM) or Ctrl+Shift+O (Eclipse) to sort imports"/> + <property name="groups" value="android, com, dalvik, gov, junit, libcore, net, org, java, javax"/> + <property name="ordered" value="true"/> + <property name="option" value="top"/> + <property name="separated" value="true"/> + </module> + <!-- TODO(aurimas): make indentation an error once https://github.com/checkstyle/checkstyle/issues/255 is fixed. --> + <module name="Indentation"> + <property name="severity" value="warning"/> + <property name="basicOffset" value="4"/> + <property name="throwsIndent" value="8"/> + </module> + </module> + <module name="FileTabCharacter"> + <property name="severity" value="error"/> + </module> + <module name="RegexpSingleline"> + <property name="format" value="((//.*)|(\*.*))FIXME"/> + <property name="message" value="TODO is preferred to FIXME. e.g. "TODO(johndoe):"/> + </module> + <module name="RegexpSingleline"> + <property name="format" value="((//.*)|(\*.*))(?<!TODO\(.{0,100})(TODO[^(])|(TODO\([^)]*$)"/> + <property name="message" value="All TODOs should be named. e.g. "TODO(johndoe):"/> + </module> + <module name="RegexpSingleline"> + <property name="severity" value="error"/> + <property name="format" value="[ \t]+$"/> + <property name="message" value="Trailing whitespace"/> + </module> + <module name="RegexpHeader"> + <property name="severity" value="error"/> + <property name="header" value="^// Copyright 20\d\d The Chromium Authors. All rights reserved.$\n^// Use of this source code is governed by a BSD-style license that can be$\n^// found in the LICENSE file.$"/> + </module> +</module>
diff --git a/tools/android/common/adb_connection.cc b/tools/android/common/adb_connection.cc new file mode 100644 index 0000000..9985a3a --- /dev/null +++ b/tools/android/common/adb_connection.cc
@@ -0,0 +1,107 @@ +// Copyright (c) 2012 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. + +#include "tools/android/common/adb_connection.h" + +#include <arpa/inet.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <unistd.h> + +#include "base/logging.h" +#include "base/posix/eintr_wrapper.h" +#include "tools/android/common/net.h" + +namespace tools { +namespace { + +void CloseSocket(int fd) { + if (fd >= 0) { + int old_errno = errno; + close(fd); + errno = old_errno; + } +} + +} // namespace + +int ConnectAdbHostSocket(const char* forward_to) { + // ADB port forward request format: HHHHtcp:port:address. + // HHHH is the hexidecimal length of the "tcp:port:address" part. + const size_t kBufferMaxLength = 30; + const size_t kLengthOfLength = 4; + const size_t kAddressMaxLength = kBufferMaxLength - kLengthOfLength; + + const char kAddressPrefix[] = { 't', 'c', 'p', ':' }; + size_t address_length = arraysize(kAddressPrefix) + strlen(forward_to); + if (address_length > kBufferMaxLength - kLengthOfLength) { + LOG(ERROR) << "Forward to address is too long: " << forward_to; + return -1; + } + + char request[kBufferMaxLength]; + memcpy(request + kLengthOfLength, kAddressPrefix, arraysize(kAddressPrefix)); + memcpy(request + kLengthOfLength + arraysize(kAddressPrefix), + forward_to, strlen(forward_to)); + + char length_buffer[kLengthOfLength + 1]; + snprintf(length_buffer, arraysize(length_buffer), "%04X", + static_cast<int>(address_length)); + memcpy(request, length_buffer, kLengthOfLength); + + int host_socket = socket(AF_INET, SOCK_STREAM, 0); + if (host_socket < 0) { + LOG(ERROR) << "Failed to create adb socket: " << strerror(errno); + return -1; + } + + DisableNagle(host_socket); + + const int kAdbPort = 5037; + sockaddr_in addr; + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + addr.sin_port = htons(kAdbPort); + if (HANDLE_EINTR(connect(host_socket, reinterpret_cast<sockaddr*>(&addr), + sizeof(addr))) < 0) { + LOG(ERROR) << "Failed to connect adb socket: " << strerror(errno); + CloseSocket(host_socket); + return -1; + } + + size_t bytes_remaining = address_length + kLengthOfLength; + size_t bytes_sent = 0; + while (bytes_remaining > 0) { + int ret = HANDLE_EINTR(send(host_socket, request + bytes_sent, + bytes_remaining, 0)); + if (ret < 0) { + LOG(ERROR) << "Failed to send request: " << strerror(errno); + CloseSocket(host_socket); + return -1; + } + + bytes_sent += ret; + bytes_remaining -= ret; + } + + const size_t kAdbStatusLength = 4; + char response[kBufferMaxLength]; + int response_length = HANDLE_EINTR(recv(host_socket, response, + kBufferMaxLength, 0)); + if (response_length < kAdbStatusLength || + strncmp("OKAY", response, kAdbStatusLength) != 0) { + LOG(ERROR) << "Bad response from ADB: length: " << response_length + << " data: " << DumpBinary(response, response_length); + CloseSocket(host_socket); + return -1; + } + + return host_socket; +} + +} // namespace tools
diff --git a/tools/android/common/adb_connection.h b/tools/android/common/adb_connection.h new file mode 100644 index 0000000..3fa0fb3 --- /dev/null +++ b/tools/android/common/adb_connection.h
@@ -0,0 +1,18 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_COMMON_ADB_CONNECTION_H_ +#define TOOLS_ANDROID_COMMON_ADB_CONNECTION_H_ + +namespace tools { + +// Creates a socket that can forward to a host socket through ADB. +// The format of forward_to is <port>:<ip_address>. +// Returns the socket handle, or -1 on any error. +int ConnectAdbHostSocket(const char* forward_to); + +} // namespace tools + +#endif // TOOLS_ANDROID_COMMON_ADB_CONNECTION_H_ +
diff --git a/tools/android/common/common.gyp b/tools/android/common/common.gyp new file mode 100644 index 0000000..8622625 --- /dev/null +++ b/tools/android/common/common.gyp
@@ -0,0 +1,26 @@ +# Copyright (c) 2012 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. + +{ + 'targets': [ + { + 'target_name': 'android_tools_common', + 'type': 'static_library', + 'toolsets': ['host', 'target'], + 'include_dirs': [ + '..', + '../../..', + ], + 'sources': [ + 'adb_connection.cc', + 'adb_connection.h', + 'daemon.cc', + 'daemon.h', + 'net.cc', + 'net.h', + ], + }, + ], +} +
diff --git a/tools/android/common/daemon.cc b/tools/android/common/daemon.cc new file mode 100644 index 0000000..699c615 --- /dev/null +++ b/tools/android/common/daemon.cc
@@ -0,0 +1,75 @@ +// Copyright (c) 2012 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. + +#include "tools/android/common/daemon.h" + +#include <errno.h> +#include <signal.h> +#include <stdio.h> +#include <sys/types.h> +#include <unistd.h> + +#include "base/command_line.h" +#include "base/logging.h" + +namespace { + +const char kNoSpawnDaemon[] = "D"; + +int g_exit_status = 0; + +void Exit(int unused) { + _exit(g_exit_status); +} + +void CloseFileDescriptor(int fd) { + int old_errno = errno; + close(fd); + errno = old_errno; +} + +} // namespace + +namespace tools { + +bool HasHelpSwitch(const CommandLine& command_line) { + return command_line.HasSwitch("h") || command_line.HasSwitch("help"); +} + +bool HasNoSpawnDaemonSwitch(const CommandLine& command_line) { + return command_line.HasSwitch(kNoSpawnDaemon); +} + +void ShowHelp(const char* program, + const char* extra_title, + const char* extra_descriptions) { + printf("Usage: %s [-%s] %s\n" + " -%s stops from spawning a daemon process\n%s", + program, kNoSpawnDaemon, extra_title, kNoSpawnDaemon, + extra_descriptions); +} + +void SpawnDaemon(int exit_status) { + g_exit_status = exit_status; + signal(SIGUSR1, Exit); + + if (fork()) { + // In parent process. + sleep(10); // Wait for the child process to finish setsid(). + NOTREACHED(); + } + + // In child process. + setsid(); // Detach the child process from its parent. + kill(getppid(), SIGUSR1); // Inform the parent process to exit. + + // Close the standard input and outputs, otherwise the process may block + // adbd when the shell exits. + // Comment out these lines if you want to see outputs for debugging. + CloseFileDescriptor(0); + CloseFileDescriptor(1); + CloseFileDescriptor(2); +} + +} // namespace tools
diff --git a/tools/android/common/daemon.h b/tools/android/common/daemon.h new file mode 100644 index 0000000..99faf72 --- /dev/null +++ b/tools/android/common/daemon.h
@@ -0,0 +1,30 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_COMMON_DAEMON_H_ +#define TOOLS_ANDROID_COMMON_DAEMON_H_ + +namespace base { +class CommandLine; +} + +namespace tools { + +bool HasHelpSwitch(const base::CommandLine& command_line); + +bool HasNoSpawnDaemonSwitch(const base::CommandLine& command_line); + +void ShowHelp(const char* program, + const char* extra_title, + const char* extra_descriptions); + +// Spawns a daemon process and exits the current process with exit_status. +// Any code executed after this function returns will be executed in the +// spawned daemon process. +void SpawnDaemon(int exit_status); + +} // namespace tools + +#endif // TOOLS_ANDROID_COMMON_DAEMON_H_ +
diff --git a/tools/android/common/net.cc b/tools/android/common/net.cc new file mode 100644 index 0000000..3b9ef15 --- /dev/null +++ b/tools/android/common/net.cc
@@ -0,0 +1,40 @@ +// Copyright (c) 2012 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. + +#include "tools/android/common/net.h" + +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <sys/socket.h> +#include <sys/types.h> + +#include "base/strings/stringprintf.h" + +namespace tools { + +int DisableNagle(int socket) { + int on = 1; + return setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)); +} + +int DeferAccept(int socket) { + int on = 1; + return setsockopt(socket, IPPROTO_TCP, TCP_DEFER_ACCEPT, &on, sizeof(on)); +} + +std::string DumpBinary(const char* buffer, size_t length) { + std::string result = "["; + for (int i = 0; i < length; ++i) { + base::StringAppendF(&result, "%02x,", + static_cast<unsigned char>(buffer[i])); + } + + if (length) + result.erase(result.length() - 1); + + return result + "]"; +} + +} // namespace tools +
diff --git a/tools/android/common/net.h b/tools/android/common/net.h new file mode 100644 index 0000000..e361954 --- /dev/null +++ b/tools/android/common/net.h
@@ -0,0 +1,25 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_COMMON_NET_H_ +#define TOOLS_ANDROID_COMMON_NET_H_ + +#include <string> + +namespace tools { + +// DisableNagle can improve TCP transmission performance. Both Chrome net stack +// and adb tool use it. +int DisableNagle(int socket); + +// Wake up listener only when data arrive. +int DeferAccept(int socket); + +// Dumps a binary buffer into a string in a human-readable format. +std::string DumpBinary(const char* buffer, size_t length); + +} // namespace tools + +#endif // TOOLS_ANDROID_COMMON_NET_H_ +
diff --git a/tools/android/file_poller/file_poller.cc b/tools/android/file_poller/file_poller.cc new file mode 100644 index 0000000..c73db8b --- /dev/null +++ b/tools/android/file_poller/file_poller.cc
@@ -0,0 +1,207 @@ +// Copyright 2014 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. + +// When run with 2 or more arguments the file_poller tool will open a port on +// the device, print it on its standard output and then start collect file +// contents. The first argument is the polling rate in Hz, and the following +// arguments are file to poll. +// When run with the port of an already running file_poller, the tool will +// contact the first instance, retrieve the sample and print those on its +// standard output. This will also terminate the first instance. + +#include <errno.h> +#include <fcntl.h> +#include <netinet/in.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/types.h> +#include <unistd.h> + +#include "base/logging.h" + +// Context containing the files to poll and the polling rate. +struct Context { + size_t nb_files; + int* file_fds; + int poll_rate; +}; + +// Write from the buffer to the given file descriptor. +void safe_write(int fd, const char* buffer, int size) { + const char* index = buffer; + size_t to_write = size; + while (to_write > 0) { + int written = write(fd, index, to_write); + if (written < 0) + PLOG(FATAL); + index += written; + to_write -= written; + } +} + +// Transfer the content of a file descriptor to another. +void transfer_to_fd(int fd_in, int fd_out) { + char buffer[1024]; + int n; + while ((n = read(fd_in, buffer, sizeof(buffer))) > 0) + safe_write(fd_out, buffer, n); +} + +// Transfer the content of a file descriptor to a buffer. +int transfer_to_buffer(int fd_in, char* bufffer, size_t size) { + char* index = bufffer; + size_t to_read = size; + int n; + while (to_read > 0 && ((n = read(fd_in, index, to_read)) > 0)) { + index += n; + to_read -= n; + } + if (n < 0) + PLOG(FATAL); + return size - to_read; +} + +// Try to open the file at the given path for reading. Exit in case of failure. +int checked_open(const char* path) { + int fd = open(path, O_RDONLY); + if (fd < 0) + PLOG(FATAL); + return fd; +} + +void transfer_measurement(int fd_in, int fd_out, bool last) { + char buffer[1024]; + if (lseek(fd_in, 0, SEEK_SET) < 0) + PLOG(FATAL); + int n = transfer_to_buffer(fd_in, buffer, sizeof(buffer)); + safe_write(fd_out, buffer, n - 1); + safe_write(fd_out, last ? "\n" : " ", 1); +} + +// Acquire a sample and save it to the given file descriptor. +void acquire_sample(int fd, const Context& context) { + struct timeval tv; + gettimeofday(&tv, NULL); + char buffer[1024]; + int n = snprintf(buffer, sizeof(buffer), "%d.%06d ", tv.tv_sec, tv.tv_usec); + safe_write(fd, buffer, n); + + for (int i = 0; i < context.nb_files; ++i) + transfer_measurement(context.file_fds[i], fd, i == (context.nb_files - 1)); +} + +void poll_content(const Context& context) { + // Create and bind the socket so that the port can be written to stdout. + int sockfd = socket(AF_INET, SOCK_STREAM, 0); + struct sockaddr_in socket_info; + socket_info.sin_family = AF_INET; + socket_info.sin_addr.s_addr = htonl(INADDR_ANY); + socket_info.sin_port = htons(0); + if (bind(sockfd, (struct sockaddr*)&socket_info, sizeof(socket_info)) < 0) + PLOG(FATAL); + socklen_t size = sizeof(socket_info); + getsockname(sockfd, (struct sockaddr*)&socket_info, &size); + printf("%d\n", ntohs(socket_info.sin_port)); + // Using a pipe to ensure child is diconnected from the terminal before + // quitting. + int pipes[2]; + pipe(pipes); + pid_t pid = fork(); + if (pid < 0) + PLOG(FATAL); + if (pid != 0) { + close(pipes[1]); + // Not expecting any data to be received. + read(pipes[0], NULL, 1); + signal(SIGCHLD, SIG_IGN); + return; + } + + // Detach from terminal. + setsid(); + close(STDIN_FILENO); + close(STDOUT_FILENO); + close(STDERR_FILENO); + close(pipes[0]); + + // Start listening for incoming connection. + if (listen(sockfd, 1) < 0) + PLOG(FATAL); + + // Signal the parent that it can now safely exit. + close(pipes[1]); + + // Prepare file to store the samples. + int fd; + char filename[] = "/data/local/tmp/fileXXXXXX"; + fd = mkstemp(filename); + unlink(filename); + + // Collect samples until a client connect on the socket. + fd_set rfds; + struct timeval timeout; + do { + acquire_sample(fd, context); + timeout.tv_sec = 0; + timeout.tv_usec = 1000000 / context.poll_rate; + FD_ZERO(&rfds); + FD_SET(sockfd, &rfds); + } while (select(sockfd + 1, &rfds, NULL, NULL, &timeout) == 0); + + // Collect a final sample. + acquire_sample(fd, context); + + // Send the result back. + struct sockaddr_in remote_socket_info; + int rfd = accept(sockfd, (struct sockaddr*)&remote_socket_info, &size); + if (rfd < 0) + PLOG(FATAL); + if (lseek(fd, 0, SEEK_SET) < 0) + PLOG(FATAL); + transfer_to_fd(fd, rfd); +} + +void content_collection(int port) { + int sockfd = socket(AF_INET, SOCK_STREAM, 0); + // Connect to localhost. + struct sockaddr_in socket_info; + socket_info.sin_family = AF_INET; + socket_info.sin_addr.s_addr = htonl(0x7f000001); + socket_info.sin_port = htons(port); + if (connect(sockfd, (struct sockaddr*)&socket_info, sizeof(socket_info)) < + 0) { + PLOG(FATAL); + } + transfer_to_fd(sockfd, STDOUT_FILENO); +} + +int main(int argc, char** argv) { + if (argc == 1) { + fprintf(stderr, + "Usage: \n" + " %s port\n" + " %s rate FILE...\n", + argv[0], + argv[0]); + exit(EXIT_FAILURE); + } + if (argc == 2) { + // Argument is the port to connect to. + content_collection(atoi(argv[1])); + } else { + // First argument is the poll frequency, in Hz, following arguments are the + // file to poll. + Context context; + context.poll_rate = atoi(argv[1]); + context.nb_files = argc - 2; + context.file_fds = new int[context.nb_files]; + for (int i = 2; i < argc; ++i) + context.file_fds[i - 2] = checked_open(argv[i]); + poll_content(context); + } + return EXIT_SUCCESS; +}
diff --git a/tools/android/file_poller/file_poller.gyp b/tools/android/file_poller/file_poller.gyp new file mode 100644 index 0000000..097344d --- /dev/null +++ b/tools/android/file_poller/file_poller.gyp
@@ -0,0 +1,18 @@ +# Copyright 2014 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. + +{ + 'targets': [ + { + 'target_name': 'file_poller', + 'type': 'executable', + 'dependencies': [ + '../../../base/base.gyp:base', + ], + 'sources': [ + 'file_poller.cc', + ], + }, + ], +}
diff --git a/tools/android/find_unused_resources.py b/tools/android/find_unused_resources.py new file mode 100755 index 0000000..1e8fa48 --- /dev/null +++ b/tools/android/find_unused_resources.py
@@ -0,0 +1,145 @@ +#!/usr/bin/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. + +"""Lists unused Java strings and other resources.""" + +import optparse +import re +import subprocess +import sys + + +def GetLibraryResources(r_txt_paths): + """Returns the resources packaged in a list of libraries. + + Args: + r_txt_paths: paths to each library's generated R.txt file which lists the + resources it contains. + + Returns: + The resources in the libraries as a list of tuples (type, name). Example: + [('drawable', 'arrow'), ('layout', 'month_picker'), ...] + """ + resources = [] + for r_txt_path in r_txt_paths: + with open(r_txt_path, 'r') as f: + for line in f: + line = line.strip() + if not line: + continue + data_type, res_type, name, _ = line.split(None, 3) + assert data_type in ('int', 'int[]') + # Hide attrs, which are redundant with styleables and always appear + # unused, and hide ids, which are innocuous even if unused. + if res_type in ('attr', 'id'): + continue + resources.append((res_type, name)) + return resources + + +def GetUsedResources(source_paths, resource_types): + """Returns the types and names of resources used in Java or resource files. + + Args: + source_paths: a list of files or folders collectively containing all the + Java files, resource files, and the AndroidManifest.xml. + resource_types: a list of resource types to look for. Example: + ['string', 'drawable'] + + Returns: + The resources referenced by the Java and resource files as a list of tuples + (type, name). Example: + [('drawable', 'app_icon'), ('layout', 'month_picker'), ...] + """ + type_regex = '|'.join(map(re.escape, resource_types)) + patterns = [r'@(())(%s)/(\w+)' % type_regex, + r'\b((\w+\.)*)R\.(%s)\.(\w+)' % type_regex] + resources = [] + for pattern in patterns: + p = subprocess.Popen( + ['grep', '-REIhoe', pattern] + source_paths, + stdout=subprocess.PIPE) + grep_out, grep_err = p.communicate() + # Check stderr instead of return code, since return code is 1 when no + # matches are found. + assert not grep_err, 'grep failed' + matches = re.finditer(pattern, grep_out) + for match in matches: + package = match.group(1) + if package == 'android.': + continue + type_ = match.group(3) + name = match.group(4) + resources.append((type_, name)) + return resources + + +def FormatResources(resources): + """Formats a list of resources for printing. + + Args: + resources: a list of resources, given as (type, name) tuples. + """ + return '\n'.join(['%-12s %s' % (t, n) for t, n in sorted(resources)]) + + +def ParseArgs(args): + parser = optparse.OptionParser() + parser.add_option('-v', help='Show verbose output', action='store_true') + parser.add_option('-s', '--source-path', help='Specify a source folder path ' + '(e.g. ui/android/java)', action='append', default=[]) + parser.add_option('-r', '--r-txt-path', help='Specify a "first-party" R.txt ' + 'file (e.g. out/Debug/content_shell_apk/R.txt)', + action='append', default=[]) + parser.add_option('-t', '--third-party-r-txt-path', help='Specify an R.txt ' + 'file for a third party library', action='append', + default=[]) + options, args = parser.parse_args(args=args) + if args: + parser.error('positional arguments not allowed') + if not options.source_path: + parser.error('at least one source folder path must be specified with -s') + if not options.r_txt_path: + parser.error('at least one R.txt path must be specified with -r') + return (options.v, options.source_path, options.r_txt_path, + options.third_party_r_txt_path) + + +def main(args=None): + verbose, source_paths, r_txt_paths, third_party_r_txt_paths = ParseArgs(args) + defined_resources = (set(GetLibraryResources(r_txt_paths)) - + set(GetLibraryResources(third_party_r_txt_paths))) + resource_types = list(set([r[0] for r in defined_resources])) + used_resources = set(GetUsedResources(source_paths, resource_types)) + unused_resources = defined_resources - used_resources + undefined_resources = used_resources - defined_resources + + # aapt dump fails silently. Notify the user if things look wrong. + if not defined_resources: + print >> sys.stderr, ( + 'Warning: No resources found. Did you provide the correct R.txt paths?') + if not used_resources: + print >> sys.stderr, ( + 'Warning: No resources referenced from Java or resource files. Did you ' + 'provide the correct source paths?') + if undefined_resources: + print >> sys.stderr, ( + 'Warning: found %d "undefined" resources that are referenced by Java ' + 'files or by other resources, but are not defined anywhere. Run with ' + '-v to see them.' % len(undefined_resources)) + + if verbose: + print '%d undefined resources:' % len(undefined_resources) + print FormatResources(undefined_resources), '\n' + print '%d resources defined:' % len(defined_resources) + print FormatResources(defined_resources), '\n' + print '%d used resources:' % len(used_resources) + print FormatResources(used_resources), '\n' + print '%d unused resources:' % len(unused_resources) + print FormatResources(unused_resources) + + +if __name__ == '__main__': + main()
diff --git a/tools/android/findbugs_plugin/README b/tools/android/findbugs_plugin/README new file mode 100644 index 0000000..3ba3f53 --- /dev/null +++ b/tools/android/findbugs_plugin/README
@@ -0,0 +1,15 @@ +This is the FindBugs plugin for chrome on android. + +Currently it detects: +- synchronized method +- synchronized 'this' + +We don't want the synchronized method and synchronized 'this' to be +used, the exception is the synchronized method defined in Android +API. + +The plugin jar file was prebuilt and checked in, to rebuild the +plugin, you need ant, and run below command, the new jar file will +be in lib directory. + +ant install
diff --git a/tools/android/findbugs_plugin/build.xml b/tools/android/findbugs_plugin/build.xml new file mode 100644 index 0000000..09ee13c --- /dev/null +++ b/tools/android/findbugs_plugin/build.xml
@@ -0,0 +1,48 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Copyright (c) 2012 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. +--> + +<project name="findbugs_plugin" basedir="."> + + <description> + Build findbugs_plugin for Chromium Android + </description> + <property name="src.dir" location="src" /> + <property name="lib.dir" location="../../../third_party/findbugs/lib" /> + <property name="bin.dir" location="lib" /> + <property name="intermediate.dir" location="intermediate" /> + <property name="jar.name" value="chromiumPlugin.jar" /> + + <path id="classpath.id"> + <fileset dir="${lib.dir}"> + <include name="**/*.jar" /> + </fileset> + </path> + + <target name="makedir"> + <mkdir dir="${intermediate.dir}" /> + <mkdir dir="${bin.dir}" /> + </target> + + <target name="findbugs_plugin_classes" depends="makedir"> + <javac srcdir="${src.dir}" destdir="${intermediate.dir}" + classpathref="classpath.id" includeantruntime="false" /> + </target> + + <target name="copy_xml_files" depends="makedir"> + <copy file="messages.xml" todir="${intermediate.dir}" /> + <copy file="findbugs.xml" todir="${intermediate.dir}" /> + </target> + + <target name="findbugs_plugin_jar" depends="findbugs_plugin_classes, copy_xml_files"> + <jar destfile="${bin.dir}/${jar.name}" basedir="${intermediate.dir}"> + </jar> + </target> + + <target name="install" depends="findbugs_plugin_jar"> + <delete dir="${intermediate.dir}" /> + </target> +</project>
diff --git a/tools/android/findbugs_plugin/findbugs.xml b/tools/android/findbugs_plugin/findbugs.xml new file mode 100644 index 0000000..43b1f34 --- /dev/null +++ b/tools/android/findbugs_plugin/findbugs.xml
@@ -0,0 +1,18 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Copyright (c) 2012 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. +--> + +<FindbugsPlugin xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:noNamespaceSchemaLocation="findbugsplugin.xsd" + pluginid="SynchronizedThisDetector" + provider="chromium" + website="http://code.google.com/p/chromium/wiki/UseFindBugsForAndroid"> + <Detector class="org.chromium.tools.findbugs.plugin.SynchronizedThisDetector" reports="CHROMIUM_SYNCHRONIZED_THIS" /> + <BugPattern type="CHROMIUM_SYNCHRONIZED_THIS" abbrev="CST" category="CORRECTNESS"/> + + <Detector class="org.chromium.tools.findbugs.plugin.SynchronizedMethodDetector" reports="CHROMIUM_SYNCHRONIZED_METHOD" /> + <BugPattern type="CHROMIUM_SYNCHRONIZED_METHOD" abbrev="CSM" category="CORRECTNESS"/> +</FindbugsPlugin>
diff --git a/tools/android/findbugs_plugin/findbugs_plugin.gyp b/tools/android/findbugs_plugin/findbugs_plugin.gyp new file mode 100644 index 0000000..16d06e6 --- /dev/null +++ b/tools/android/findbugs_plugin/findbugs_plugin.gyp
@@ -0,0 +1,16 @@ +# Copyright (c) 2012 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. + +{ + 'targets': [ + { + 'target_name': 'findbugs_plugin_test', + 'type': 'none', + 'variables': { + 'java_in_dir': 'test/java/', + }, + 'includes': [ '../../../build/java.gypi' ], + } + ] +}
diff --git a/tools/android/findbugs_plugin/lib/chromiumPlugin.jar b/tools/android/findbugs_plugin/lib/chromiumPlugin.jar new file mode 100644 index 0000000..6ccf61b --- /dev/null +++ b/tools/android/findbugs_plugin/lib/chromiumPlugin.jar Binary files differ
diff --git a/tools/android/findbugs_plugin/messages.xml b/tools/android/findbugs_plugin/messages.xml new file mode 100644 index 0000000..aea983b --- /dev/null +++ b/tools/android/findbugs_plugin/messages.xml
@@ -0,0 +1,56 @@ +<?xml version="1.0" encoding="UTF-8"?> + +<!-- + Copyright (c) 2012 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. +--> + +<MessageCollection xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:noNamespaceSchemaLocation="messagecollection.xsd"> + + <Plugin> + <ShortDescription>Chromium FindBugs Plugin </ShortDescription> + <Details>Adds style checks enforced in the chromium project.</Details> + </Plugin> + + <Detector class="org.chromium.tools.findbugs.plugin.SynchronizedThisDetector"> + <Details> + <![CDATA[ + Shouldn't use synchronized(this). + ]]> + </Details> + + </Detector> + + <BugPattern type="CHROMIUM_SYNCHRONIZED_THIS"> + <ShortDescription>Shouldn't use synchronized(this)</ShortDescription> + <LongDescription>Shouldn't use synchronized(this), please narrow down the synchronization scope.</LongDescription> + <Details> +<![CDATA[ +<p>Shouldn't use synchronized(this), please narrow down the synchronization scope.</p> +]]> + </Details> + </BugPattern> + + <Detector class="org.chromium.tools.findbugs.plugin.SynchronizedMethodDetector"> + <Details> + <![CDATA[ + Shouldn't use synchronized method. + ]]> + </Details> + + </Detector> + + <BugPattern type="CHROMIUM_SYNCHRONIZED_METHOD"> + <ShortDescription>Shouldn't use synchronized method</ShortDescription> + <LongDescription>Shouldn't use synchronized method, please narrow down the synchronization scope.</LongDescription> + <Details> +<![CDATA[ +<p>Shouldn't use synchronized method, please narrow down the synchronization scope.</p> +]]> + </Details> + </BugPattern> + + <BugCode abbrev="CHROMIUM">CHROMIUM</BugCode> +</MessageCollection>
diff --git a/tools/android/findbugs_plugin/src/org/chromium/tools/findbugs/plugin/SynchronizedMethodDetector.java b/tools/android/findbugs_plugin/src/org/chromium/tools/findbugs/plugin/SynchronizedMethodDetector.java new file mode 100644 index 0000000..d1d7614 --- /dev/null +++ b/tools/android/findbugs_plugin/src/org/chromium/tools/findbugs/plugin/SynchronizedMethodDetector.java
@@ -0,0 +1,37 @@ +// Copyright 2012 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. + +package org.chromium.tools.findbugs.plugin; + +import org.apache.bcel.classfile.Code; + +import edu.umd.cs.findbugs.BugInstance; +import edu.umd.cs.findbugs.BugReporter; +import edu.umd.cs.findbugs.bcel.OpcodeStackDetector; + +/** + * This class detects the synchronized method. + */ +public class SynchronizedMethodDetector extends OpcodeStackDetector { + private BugReporter mBugReporter; + + public SynchronizedMethodDetector(BugReporter bugReporter) { + this.mBugReporter = bugReporter; + } + + @Override + public void visit(Code code) { + if (getMethod().isSynchronized()) { + mBugReporter.reportBug(new BugInstance(this, "CHROMIUM_SYNCHRONIZED_METHOD", + NORMAL_PRIORITY) + .addClassAndMethod(this) + .addSourceLine(this)); + } + super.visit(code); + } + + @Override + public void sawOpcode(int arg0) { + } +}
diff --git a/tools/android/findbugs_plugin/src/org/chromium/tools/findbugs/plugin/SynchronizedThisDetector.java b/tools/android/findbugs_plugin/src/org/chromium/tools/findbugs/plugin/SynchronizedThisDetector.java new file mode 100644 index 0000000..9a4e5e1 --- /dev/null +++ b/tools/android/findbugs_plugin/src/org/chromium/tools/findbugs/plugin/SynchronizedThisDetector.java
@@ -0,0 +1,73 @@ +// Copyright 2012 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. + +package org.chromium.tools.findbugs.plugin; + +import org.apache.bcel.classfile.Code; + +import edu.umd.cs.findbugs.BugInstance; +import edu.umd.cs.findbugs.BugReporter; +import edu.umd.cs.findbugs.bcel.OpcodeStackDetector; + +/** + * This class detects the synchronized(this). + * + * The pattern of byte code of synchronized(this) is + * aload_0 # Load the 'this' pointer on top of stack + * dup # Duplicate the 'this' pointer + * astore_x # Store this for late use, it might be astore. + * monitorenter + */ +public class SynchronizedThisDetector extends OpcodeStackDetector { + private static final int PATTERN[] = {ALOAD_0, DUP, 0xff, 0xff, MONITORENTER}; + + private int mStep = 0; + private BugReporter mBugReporter; + + public SynchronizedThisDetector(BugReporter bugReporter) { + mBugReporter = bugReporter; + } + + @Override + public void visit(Code code) { + mStep = 0; + super.visit(code); + } + + @Override + public void sawOpcode(int seen) { + if (PATTERN[mStep] == seen) { + mStep++; + if (mStep == PATTERN.length) { + mBugReporter.reportBug(new BugInstance(this, "CHROMIUM_SYNCHRONIZED_THIS", + NORMAL_PRIORITY) + .addClassAndMethod(this) + .addSourceLine(this)); + mStep = 0; + return; + } + } else if (mStep == 2) { + // This could be astore_x + switch (seen) { + case ASTORE_0: + case ASTORE_1: + case ASTORE_2: + case ASTORE_3: + mStep += 2; + break; + case ASTORE: + mStep++; + break; + default: + mStep = 0; + break; + } + } else if (mStep == 3) { + // Could be any byte following the ASTORE. + mStep++; + } else { + mStep = 0; + } + } +}
diff --git a/tools/android/findbugs_plugin/test/expected_result.txt b/tools/android/findbugs_plugin/test/expected_result.txt new file mode 100644 index 0000000..076b007 --- /dev/null +++ b/tools/android/findbugs_plugin/test/expected_result.txt
@@ -0,0 +1,3 @@ +M C CSM: Shouldn't use synchronized method, please narrow down the synchronization scope. At SimpleSynchronizedMethod.java +M C CSM: Shouldn't use synchronized method, please narrow down the synchronization scope. At SimpleSynchronizedStaticMethod.java +M C CST: Shouldn't use synchronized(this), please narrow down the synchronization scope. At SimpleSynchronizedThis.java
diff --git a/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedMethod.java b/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedMethod.java new file mode 100644 index 0000000..ded7848 --- /dev/null +++ b/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedMethod.java
@@ -0,0 +1,17 @@ +// Copyright 2012 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. + +package org.chromium.tools.findbugs.plugin; + +/** + * This class has synchronized method and is used to test + * SynchronizedMethodDetector. + */ +class SimpleSynchronizedMethod { + private int mCounter = 0; + + synchronized void synchronizedMethod() { + mCounter++; + } +}
diff --git a/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedStaticMethod.java b/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedStaticMethod.java new file mode 100644 index 0000000..d652dbe --- /dev/null +++ b/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedStaticMethod.java
@@ -0,0 +1,16 @@ +// Copyright 2012 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. + +package org.chromium.tools.findbugs.plugin; + +/** + * This class is used to test SynchronizedMethodDetector + */ +class SimpleSynchronizedStaticMethod { + private static int sCounter = 0; + + static synchronized void synchronizedStaticMethod() { + sCounter++; + } +}
diff --git a/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedThis.java b/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedThis.java new file mode 100644 index 0000000..9125155 --- /dev/null +++ b/tools/android/findbugs_plugin/test/java/src/org/chromium/tools/findbugs/plugin/SimpleSynchronizedThis.java
@@ -0,0 +1,19 @@ +// Copyright 2012 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. + +package org.chromium.tools.findbugs.plugin; + +/** + * This class has synchronized(this) statement and is used to test + * SynchronizedThisDetector. + */ +class SimpleSynchronizedThis { + private int mCounter = 0; + + void synchronizedThis() { + synchronized (this) { + mCounter++; + } + } +}
diff --git a/tools/android/findbugs_plugin/test/run_findbugs_plugin_tests.py b/tools/android/findbugs_plugin/test/run_findbugs_plugin_tests.py new file mode 100755 index 0000000..c2e1531 --- /dev/null +++ b/tools/android/findbugs_plugin/test/run_findbugs_plugin_tests.py
@@ -0,0 +1,44 @@ +#!/usr/bin/env python +# +# Copyright (c) 2012 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. + +# This is used to test the findbugs plugin, it calls +# build/android/pylib/utils/findbugs.py to analyze the classes in +# org.chromium.tools.findbugs.plugin package, and expects to get the same +# issue with those in expected_result.txt. +# +# Useful command line: +# --rebaseline to generate the expected_result.txt, please make sure don't +# remove the expected result of exsting tests. + + +import optparse +import os +import sys + +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), + '..', '..', '..', '..', + 'build', 'android'))) + +from pylib import constants +from pylib.utils import findbugs + + +def main(argv): + parser = findbugs.GetCommonParser() + + options, _ = parser.parse_args() + + if not options.known_bugs: + options.known_bugs = os.path.join(constants.DIR_SOURCE_ROOT, 'tools', + 'android', 'findbugs_plugin', 'test', + 'expected_result.txt') + if not options.only_analyze: + options.only_analyze = 'org.chromium.tools.findbugs.plugin.*' + + return findbugs.Run(options) + +if __name__ == '__main__': + sys.exit(main(sys.argv))
diff --git a/tools/android/forwarder/forwarder.cc b/tools/android/forwarder/forwarder.cc new file mode 100644 index 0000000..fe49903 --- /dev/null +++ b/tools/android/forwarder/forwarder.cc
@@ -0,0 +1,426 @@ +// Copyright (c) 2012 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. + +#include <errno.h> +#include <fcntl.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <pthread.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/select.h> +#include <sys/socket.h> +#include <sys/wait.h> +#include <unistd.h> + +#include "base/command_line.h" +#include "base/logging.h" +#include "base/posix/eintr_wrapper.h" +#include "tools/android/common/adb_connection.h" +#include "tools/android/common/daemon.h" +#include "tools/android/common/net.h" + +namespace { + +const pthread_t kInvalidThread = static_cast<pthread_t>(-1); +volatile bool g_killed = false; + +void CloseSocket(int fd) { + if (fd >= 0) { + int old_errno = errno; + close(fd); + errno = old_errno; + } +} + +class Buffer { + public: + Buffer() + : bytes_read_(0), + write_offset_(0) { + } + + bool CanRead() { + return bytes_read_ == 0; + } + + bool CanWrite() { + return write_offset_ < bytes_read_; + } + + int Read(int fd) { + int ret = -1; + if (CanRead()) { + ret = HANDLE_EINTR(read(fd, buffer_, kBufferSize)); + if (ret > 0) + bytes_read_ = ret; + } + return ret; + } + + int Write(int fd) { + int ret = -1; + if (CanWrite()) { + ret = HANDLE_EINTR(write(fd, buffer_ + write_offset_, + bytes_read_ - write_offset_)); + if (ret > 0) { + write_offset_ += ret; + if (write_offset_ == bytes_read_) { + write_offset_ = 0; + bytes_read_ = 0; + } + } + } + return ret; + } + + private: + // A big buffer to let our file-over-http bridge work more like real file. + static const int kBufferSize = 1024 * 128; + int bytes_read_; + int write_offset_; + char buffer_[kBufferSize]; + + DISALLOW_COPY_AND_ASSIGN(Buffer); +}; + +class Server; + +struct ForwarderThreadInfo { + ForwarderThreadInfo(Server* a_server, int a_forwarder_index) + : server(a_server), + forwarder_index(a_forwarder_index) { + } + Server* server; + int forwarder_index; +}; + +struct ForwarderInfo { + time_t start_time; + int socket1; + time_t socket1_last_byte_time; + size_t socket1_bytes; + int socket2; + time_t socket2_last_byte_time; + size_t socket2_bytes; +}; + +class Server { + public: + Server() + : thread_(kInvalidThread), + socket_(-1) { + memset(forward_to_, 0, sizeof(forward_to_)); + memset(&forwarders_, 0, sizeof(forwarders_)); + } + + int GetFreeForwarderIndex() { + for (int i = 0; i < kMaxForwarders; i++) { + if (forwarders_[i].start_time == 0) + return i; + } + return -1; + } + + void DisposeForwarderInfo(int index) { + forwarders_[index].start_time = 0; + } + + ForwarderInfo* GetForwarderInfo(int index) { + return &forwarders_[index]; + } + + void DumpInformation() { + LOG(INFO) << "Server information: " << forward_to_; + LOG(INFO) << "No.: age up(bytes,idle) down(bytes,idle)"; + int count = 0; + time_t now = time(NULL); + for (int i = 0; i < kMaxForwarders; i++) { + const ForwarderInfo& info = forwarders_[i]; + if (info.start_time) { + count++; + LOG(INFO) << count << ": " << now - info.start_time << " up(" + << info.socket1_bytes << "," + << now - info.socket1_last_byte_time << " down(" + << info.socket2_bytes << "," + << now - info.socket2_last_byte_time << ")"; + } + } + } + + void Shutdown() { + if (socket_ >= 0) + shutdown(socket_, SHUT_RDWR); + } + + bool InitSocket(const char* arg); + + void StartThread() { + pthread_create(&thread_, NULL, ServerThread, this); + } + + void JoinThread() { + if (thread_ != kInvalidThread) + pthread_join(thread_, NULL); + } + + private: + static void* ServerThread(void* arg); + + // There are 3 kinds of threads that will access the array: + // 1. Server thread will get a free ForwarderInfo and initialize it; + // 2. Forwarder threads will dispose the ForwarderInfo when it finishes; + // 3. Main thread will iterate and print the forwarders. + // Using an array is not optimal, but can avoid locks or other complex + // inter-thread communication. + static const int kMaxForwarders = 512; + ForwarderInfo forwarders_[kMaxForwarders]; + + pthread_t thread_; + int socket_; + char forward_to_[40]; + + DISALLOW_COPY_AND_ASSIGN(Server); +}; + +// Forwards all outputs from one socket to another socket. +void* ForwarderThread(void* arg) { + ForwarderThreadInfo* thread_info = + reinterpret_cast<ForwarderThreadInfo*>(arg); + Server* server = thread_info->server; + int index = thread_info->forwarder_index; + delete thread_info; + ForwarderInfo* info = server->GetForwarderInfo(index); + int socket1 = info->socket1; + int socket2 = info->socket2; + int nfds = socket1 > socket2 ? socket1 + 1 : socket2 + 1; + fd_set read_fds; + fd_set write_fds; + Buffer buffer1; + Buffer buffer2; + + while (!g_killed) { + FD_ZERO(&read_fds); + if (buffer1.CanRead()) + FD_SET(socket1, &read_fds); + if (buffer2.CanRead()) + FD_SET(socket2, &read_fds); + + FD_ZERO(&write_fds); + if (buffer1.CanWrite()) + FD_SET(socket2, &write_fds); + if (buffer2.CanWrite()) + FD_SET(socket1, &write_fds); + + if (HANDLE_EINTR(select(nfds, &read_fds, &write_fds, NULL, NULL)) <= 0) { + LOG(ERROR) << "Select error: " << strerror(errno); + break; + } + + int now = time(NULL); + if (FD_ISSET(socket1, &read_fds)) { + info->socket1_last_byte_time = now; + int bytes = buffer1.Read(socket1); + if (bytes <= 0) + break; + info->socket1_bytes += bytes; + } + if (FD_ISSET(socket2, &read_fds)) { + info->socket2_last_byte_time = now; + int bytes = buffer2.Read(socket2); + if (bytes <= 0) + break; + info->socket2_bytes += bytes; + } + if (FD_ISSET(socket1, &write_fds)) { + if (buffer2.Write(socket1) <= 0) + break; + } + if (FD_ISSET(socket2, &write_fds)) { + if (buffer1.Write(socket2) <= 0) + break; + } + } + + CloseSocket(socket1); + CloseSocket(socket2); + server->DisposeForwarderInfo(index); + return NULL; +} + +// Listens to a server socket. On incoming request, forward it to the host. +// static +void* Server::ServerThread(void* arg) { + Server* server = reinterpret_cast<Server*>(arg); + while (!g_killed) { + int forwarder_index = server->GetFreeForwarderIndex(); + if (forwarder_index < 0) { + LOG(ERROR) << "Too many forwarders"; + continue; + } + + struct sockaddr_in addr; + socklen_t addr_len = sizeof(addr); + int socket = HANDLE_EINTR(accept(server->socket_, + reinterpret_cast<sockaddr*>(&addr), + &addr_len)); + if (socket < 0) { + LOG(ERROR) << "Failed to accept: " << strerror(errno); + break; + } + tools::DisableNagle(socket); + + int host_socket = tools::ConnectAdbHostSocket(server->forward_to_); + if (host_socket >= 0) { + // Set NONBLOCK flag because we use select(). + fcntl(socket, F_SETFL, fcntl(socket, F_GETFL) | O_NONBLOCK); + fcntl(host_socket, F_SETFL, fcntl(host_socket, F_GETFL) | O_NONBLOCK); + + ForwarderInfo* forwarder_info = server->GetForwarderInfo(forwarder_index); + time_t now = time(NULL); + forwarder_info->start_time = now; + forwarder_info->socket1 = socket; + forwarder_info->socket1_last_byte_time = now; + forwarder_info->socket1_bytes = 0; + forwarder_info->socket2 = host_socket; + forwarder_info->socket2_last_byte_time = now; + forwarder_info->socket2_bytes = 0; + + pthread_t thread; + pthread_create(&thread, NULL, ForwarderThread, + new ForwarderThreadInfo(server, forwarder_index)); + } else { + // Close the unused client socket which is failed to connect to host. + CloseSocket(socket); + } + } + + CloseSocket(server->socket_); + server->socket_ = -1; + return NULL; +} + +// Format of arg: <Device port>[:<Forward to port>:<Forward to address>] +bool Server::InitSocket(const char* arg) { + char* endptr; + int local_port = static_cast<int>(strtol(arg, &endptr, 10)); + if (local_port < 0) + return false; + + if (*endptr != ':') { + snprintf(forward_to_, sizeof(forward_to_), "%d:127.0.0.1", local_port); + } else { + strncpy(forward_to_, endptr + 1, sizeof(forward_to_) - 1); + } + + socket_ = socket(AF_INET, SOCK_STREAM, 0); + if (socket_ < 0) { + perror("server socket"); + return false; + } + tools::DisableNagle(socket_); + + sockaddr_in addr; + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + addr.sin_port = htons(local_port); + int reuse_addr = 1; + setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, + &reuse_addr, sizeof(reuse_addr)); + tools::DeferAccept(socket_); + if (HANDLE_EINTR(bind(socket_, reinterpret_cast<sockaddr*>(&addr), + sizeof(addr))) < 0 || + HANDLE_EINTR(listen(socket_, 5)) < 0) { + perror("server bind"); + CloseSocket(socket_); + socket_ = -1; + return false; + } + + if (local_port == 0) { + socklen_t addrlen = sizeof(addr); + if (getsockname(socket_, reinterpret_cast<sockaddr*>(&addr), &addrlen) + != 0) { + perror("get listen address"); + CloseSocket(socket_); + socket_ = -1; + return false; + } + local_port = ntohs(addr.sin_port); + } + + printf("Forwarding device port %d to host %s\n", local_port, forward_to_); + return true; +} + +int g_server_count = 0; +Server* g_servers = NULL; + +void KillHandler(int unused) { + g_killed = true; + for (int i = 0; i < g_server_count; i++) + g_servers[i].Shutdown(); +} + +void DumpInformation(int unused) { + for (int i = 0; i < g_server_count; i++) + g_servers[i].DumpInformation(); +} + +} // namespace + +int main(int argc, char** argv) { + printf("Android device to host TCP forwarder\n"); + printf("Like 'adb forward' but in the reverse direction\n"); + + CommandLine command_line(argc, argv); + CommandLine::StringVector server_args = command_line.GetArgs(); + if (tools::HasHelpSwitch(command_line) || server_args.empty()) { + tools::ShowHelp( + argv[0], + "<Device port>[:<Forward to port>:<Forward to address>] ...", + " <Forward to port> default is <Device port>\n" + " <Forward to address> default is 127.0.0.1\n" + "If <Device port> is 0, a port will by dynamically allocated.\n"); + return 0; + } + + g_servers = new Server[server_args.size()]; + g_server_count = 0; + int failed_count = 0; + for (size_t i = 0; i < server_args.size(); i++) { + if (!g_servers[g_server_count].InitSocket(server_args[i].c_str())) { + printf("Couldn't start forwarder server for port spec: %s\n", + server_args[i].c_str()); + ++failed_count; + } else { + ++g_server_count; + } + } + + if (g_server_count == 0) { + printf("No forwarder servers could be started. Exiting.\n"); + delete [] g_servers; + return failed_count; + } + + if (!tools::HasNoSpawnDaemonSwitch(command_line)) + tools::SpawnDaemon(failed_count); + + signal(SIGTERM, KillHandler); + signal(SIGUSR2, DumpInformation); + + for (int i = 0; i < g_server_count; i++) + g_servers[i].StartThread(); + for (int i = 0; i < g_server_count; i++) + g_servers[i].JoinThread(); + g_server_count = 0; + delete [] g_servers; + + return 0; +} +
diff --git a/tools/android/forwarder/forwarder.gyp b/tools/android/forwarder/forwarder.gyp new file mode 100644 index 0000000..1df518b --- /dev/null +++ b/tools/android/forwarder/forwarder.gyp
@@ -0,0 +1,43 @@ +# Copyright (c) 2012 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. + +{ + 'targets': [ + { + 'target_name': 'forwarder', + 'type': 'none', + 'dependencies': [ + 'forwarder_symbols', + ], + 'actions': [ + { + 'action_name': 'strip_forwarder', + 'inputs': ['<(PRODUCT_DIR)/forwarder_symbols'], + 'outputs': ['<(PRODUCT_DIR)/forwarder'], + 'action': [ + '<(android_strip)', + '--strip-unneeded', + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + }, + ], + }, { + 'target_name': 'forwarder_symbols', + 'type': 'executable', + 'dependencies': [ + '../../../base/base.gyp:base', + '../common/common.gyp:android_tools_common', + ], + 'include_dirs': [ + '../../..', + ], + 'sources': [ + 'forwarder.cc', + ], + }, + ], +} +
diff --git a/tools/android/forwarder2/command.cc b/tools/android/forwarder2/command.cc new file mode 100644 index 0000000..9b0aa24 --- /dev/null +++ b/tools/android/forwarder2/command.cc
@@ -0,0 +1,96 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/command.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "base/logging.h" +#include "base/safe_strerror_posix.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/string_piece.h" +#include "tools/android/forwarder2/socket.h" + +using base::StringPiece; + +namespace { + + +// Command format: +// <port>:<type> +// +// Where: +// <port> is a 5-chars zero-padded ASCII decimal integer +// matching the target port for the command (e.g. +// '08080' for port 8080) +// <type> is a 3-char zero-padded ASCII decimal integer +// matching a command::Type value (e.g. 002 for +// ACK). +// The column (:) is used as a separator for easier reading. +const int kPortStringSize = 5; +const int kCommandTypeStringSize = 2; +// Command string size also includes the ':' separator char. +const int kCommandStringSize = kPortStringSize + kCommandTypeStringSize + 1; + +} // namespace + +namespace forwarder2 { + +bool ReadCommand(Socket* socket, + int* port_out, + command::Type* command_type_out) { + char command_buffer[kCommandStringSize + 1]; + // To make logging easier. + command_buffer[kCommandStringSize] = '\0'; + + int bytes_read = socket->ReadNumBytes(command_buffer, kCommandStringSize); + if (bytes_read != kCommandStringSize) { + if (bytes_read < 0) + LOG(ERROR) << "Read() error: " << safe_strerror(errno); + else if (!bytes_read) + LOG(ERROR) << "Read() error, endpoint was unexpectedly closed."; + else + LOG(ERROR) << "Read() error, not enough data received from the socket."; + return false; + } + + StringPiece port_str(command_buffer, kPortStringSize); + if (!StringToInt(port_str, port_out)) { + LOG(ERROR) << "Could not parse the command port string: " + << port_str; + return false; + } + + StringPiece command_type_str( + &command_buffer[kPortStringSize + 1], kCommandTypeStringSize); + int command_type; + if (!StringToInt(command_type_str, &command_type)) { + LOG(ERROR) << "Could not parse the command type string: " + << command_type_str; + return false; + } + *command_type_out = static_cast<command::Type>(command_type); + return true; +} + +bool SendCommand(command::Type command, int port, Socket* socket) { + char buffer[kCommandStringSize + 1]; + int len = snprintf(buffer, sizeof(buffer), "%05d:%02d", port, command); + CHECK_EQ(len, kCommandStringSize); + // Write the full command minus the leading \0 char. + return socket->WriteNumBytes(buffer, len) == len; +} + +bool ReceivedCommand(command::Type command, Socket* socket) { + int port; + command::Type received_command; + if (!ReadCommand(socket, &port, &received_command)) + return false; + return received_command == command; +} + +} // namespace forwarder
diff --git a/tools/android/forwarder2/command.h b/tools/android/forwarder2/command.h new file mode 100644 index 0000000..8e222ef --- /dev/null +++ b/tools/android/forwarder2/command.h
@@ -0,0 +1,48 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_COMMAND_H_ +#define TOOLS_ANDROID_FORWARDER2_COMMAND_H_ + +#include "base/basictypes.h" + +namespace forwarder2 { + +class Socket; + +namespace command { + +enum Type { + ACCEPT_ERROR = 0, + ACCEPT_SUCCESS, + ACK, + ADB_DATA_SOCKET_ERROR, + ADB_DATA_SOCKET_SUCCESS, + BIND_ERROR, + BIND_SUCCESS, + DATA_CONNECTION, + HOST_SERVER_ERROR, + HOST_SERVER_SUCCESS, + KILL_ALL_LISTENERS, + LISTEN, + UNLISTEN, + UNLISTEN_ERROR, + UNLISTEN_SUCCESS, +}; + +} // namespace command + +bool ReadCommand(Socket* socket, + int* port_out, + command::Type* command_type_out); + +// Helper function to read the command from the |socket| and return true if the +// |command| is equal to the given command parameter. +bool ReceivedCommand(command::Type command, Socket* socket); + +bool SendCommand(command::Type command, int port, Socket* socket); + +} // namespace forwarder + +#endif // TOOLS_ANDROID_FORWARDER2_COMMAND_H_
diff --git a/tools/android/forwarder2/common.cc b/tools/android/forwarder2/common.cc new file mode 100644 index 0000000..3b7387d --- /dev/null +++ b/tools/android/forwarder2/common.cc
@@ -0,0 +1,28 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/common.h" + +#include <errno.h> +#include <unistd.h> + +#include "base/logging.h" +#include "base/posix/eintr_wrapper.h" +#include "base/safe_strerror_posix.h" + +namespace forwarder2 { + +void PError(const char* msg) { + LOG(ERROR) << msg << ": " << safe_strerror(errno); +} + +void CloseFD(int fd) { + const int errno_copy = errno; + if (IGNORE_EINTR(close(fd)) < 0) { + PError("close"); + errno = errno_copy; + } +} + +} // namespace forwarder2
diff --git a/tools/android/forwarder2/common.h b/tools/android/forwarder2/common.h new file mode 100644 index 0000000..43de57b --- /dev/null +++ b/tools/android/forwarder2/common.h
@@ -0,0 +1,89 @@ +// Copyright (c) 2012 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. + +// Common helper functions/classes used both in the host and device forwarder. + +#ifndef TOOLS_ANDROID_FORWARDER2_COMMON_H_ +#define TOOLS_ANDROID_FORWARDER2_COMMON_H_ + +#include <stdarg.h> +#include <stdio.h> +#include <errno.h> + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "base/logging.h" +#include "base/posix/eintr_wrapper.h" + +// Preserving errno for Close() is important because the function is very often +// used in cleanup code, after an error occurred, and it is very easy to pass an +// invalid file descriptor to close() in this context, or more rarely, a +// spurious signal might make close() return -1 + setting errno to EINTR, +// masking the real reason for the original error. This leads to very unpleasant +// debugging sessions. +#define PRESERVE_ERRNO_HANDLE_EINTR(Func) \ + do { \ + int local_errno = errno; \ + (void) HANDLE_EINTR(Func); \ + errno = local_errno; \ + } while (false); + +// Wrapper around RAW_LOG() which is signal-safe. The only purpose of this macro +// is to avoid documenting uses of RawLog(). +#define SIGNAL_SAFE_LOG(Level, Msg) \ + RAW_LOG(Level, Msg); + +namespace forwarder2 { + +// Note that the two following functions are not signal-safe. + +// Chromium logging-aware implementation of libc's perror(). +void PError(const char* msg); + +// Closes the provided file descriptor and logs an error if it failed. +void CloseFD(int fd); + +// Helps build a formatted C-string allocated in a fixed-size array. This is +// useful in signal handlers where base::StringPrintf() can't be used safely +// (due to its use of LOG()). +template <int BufferSize> +class FixedSizeStringBuilder { + public: + FixedSizeStringBuilder() { + Reset(); + } + + const char* buffer() const { return buffer_; } + + void Reset() { + buffer_[0] = 0; + write_ptr_ = buffer_; + } + + // Returns the number of bytes appended to the underlying buffer or -1 if it + // failed. + int Append(const char* format, ...) PRINTF_FORMAT(/* + 1 for 'this' */ 2, 3) { + if (write_ptr_ >= buffer_ + BufferSize) + return -1; + va_list ap; + va_start(ap, format); + const int bytes_written = vsnprintf( + write_ptr_, BufferSize - (write_ptr_ - buffer_), format, ap); + va_end(ap); + if (bytes_written > 0) + write_ptr_ += bytes_written; + return bytes_written; + } + + private: + char* write_ptr_; + char buffer_[BufferSize]; + + COMPILE_ASSERT(BufferSize >= 1, Size_of_buffer_must_be_at_least_one); + DISALLOW_COPY_AND_ASSIGN(FixedSizeStringBuilder); +}; + +} // namespace forwarder2 + +#endif // TOOLS_ANDROID_FORWARDER2_COMMON_H_
diff --git a/tools/android/forwarder2/daemon.cc b/tools/android/forwarder2/daemon.cc new file mode 100644 index 0000000..19a1054 --- /dev/null +++ b/tools/android/forwarder2/daemon.cc
@@ -0,0 +1,290 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/daemon.h" + +#include <errno.h> +#include <fcntl.h> +#include <signal.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> + +#include <cstdlib> +#include <cstring> +#include <string> + +#include "base/basictypes.h" +#include "base/files/file_path.h" +#include "base/files/file_util.h" +#include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/posix/eintr_wrapper.h" +#include "base/safe_strerror_posix.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/stringprintf.h" +#include "tools/android/forwarder2/common.h" +#include "tools/android/forwarder2/socket.h" + +namespace forwarder2 { +namespace { + +const int kBufferSize = 256; + +// Timeout constant used for polling when connecting to the daemon's Unix Domain +// Socket and also when waiting for its death when it is killed. +const int kNumTries = 100; +const int kIdleTimeMSec = 20; + +void InitLoggingForDaemon(const std::string& log_file) { + logging::LoggingSettings settings; + settings.logging_dest = + log_file.empty() ? + logging::LOG_TO_SYSTEM_DEBUG_LOG : logging::LOG_TO_FILE; + settings.log_file = log_file.c_str(); + settings.lock_log = logging::DONT_LOCK_LOG_FILE; + CHECK(logging::InitLogging(settings)); +} + +bool RunServerAcceptLoop(const std::string& welcome_message, + Socket* server_socket, + Daemon::ServerDelegate* server_delegate) { + bool failed = false; + for (;;) { + scoped_ptr<Socket> client_socket(new Socket()); + if (!server_socket->Accept(client_socket.get())) { + if (server_socket->DidReceiveEvent()) + break; + PError("Accept()"); + failed = true; + break; + } + if (!client_socket->Write(welcome_message.c_str(), + welcome_message.length() + 1)) { + PError("Write()"); + failed = true; + continue; + } + server_delegate->OnClientConnected(client_socket.Pass()); + } + return !failed; +} + +void SigChildHandler(int signal_number) { + DCHECK_EQ(signal_number, SIGCHLD); + int status; + pid_t child_pid = waitpid(-1 /* any child */, &status, WNOHANG); + if (child_pid < 0) { + PError("waitpid"); + return; + } + if (child_pid == 0) + return; + if (WIFEXITED(status) && WEXITSTATUS(status) == 0) + return; + // Avoid using StringAppendF() since it's unsafe in a signal handler due to + // its use of LOG(). + FixedSizeStringBuilder<256> string_builder; + string_builder.Append("Daemon (pid=%d) died unexpectedly with ", child_pid); + if (WIFEXITED(status)) + string_builder.Append("status %d.", WEXITSTATUS(status)); + else if (WIFSIGNALED(status)) + string_builder.Append("signal %d.", WTERMSIG(status)); + else + string_builder.Append("unknown reason."); + SIGNAL_SAFE_LOG(ERROR, string_builder.buffer()); +} + +// Note that 0 is written to |lock_owner_pid| in case the file is not locked. +bool GetFileLockOwnerPid(int fd, pid_t* lock_owner_pid) { + struct flock lock_info = {}; + lock_info.l_type = F_WRLCK; + lock_info.l_whence = SEEK_CUR; + const int ret = HANDLE_EINTR(fcntl(fd, F_GETLK, &lock_info)); + if (ret < 0) { + if (errno == EBADF) { + // Assume that the provided file descriptor corresponding to the PID file + // was valid until the daemon removed this file. + *lock_owner_pid = 0; + return true; + } + PError("fcntl"); + return false; + } + if (lock_info.l_type == F_UNLCK) { + *lock_owner_pid = 0; + return true; + } + CHECK_EQ(F_WRLCK /* exclusive lock */, lock_info.l_type); + *lock_owner_pid = lock_info.l_pid; + return true; +} + +scoped_ptr<Socket> ConnectToUnixDomainSocket( + const std::string& socket_name, + int tries_count, + int idle_time_msec, + const std::string& expected_welcome_message) { + for (int i = 0; i < tries_count; ++i) { + scoped_ptr<Socket> socket(new Socket()); + if (!socket->ConnectUnix(socket_name)) { + if (idle_time_msec) + usleep(idle_time_msec * 1000); + continue; + } + char buf[kBufferSize]; + DCHECK(expected_welcome_message.length() + 1 <= sizeof(buf)); + memset(buf, 0, sizeof(buf)); + if (socket->Read(buf, expected_welcome_message.length() + 1) < 0) { + perror("read"); + continue; + } + if (expected_welcome_message != buf) { + LOG(ERROR) << "Unexpected message read from daemon: " << buf; + break; + } + return socket.Pass(); + } + return scoped_ptr<Socket>(); +} + +} // namespace + +Daemon::Daemon(const std::string& log_file_path, + const std::string& identifier, + ClientDelegate* client_delegate, + ServerDelegate* server_delegate, + GetExitNotifierFDCallback get_exit_fd_callback) + : log_file_path_(log_file_path), + identifier_(identifier), + client_delegate_(client_delegate), + server_delegate_(server_delegate), + get_exit_fd_callback_(get_exit_fd_callback) { + DCHECK(client_delegate_); + DCHECK(server_delegate_); + DCHECK(get_exit_fd_callback_); +} + +Daemon::~Daemon() {} + +bool Daemon::SpawnIfNeeded() { + const int kSingleTry = 1; + const int kNoIdleTime = 0; + scoped_ptr<Socket> client_socket = ConnectToUnixDomainSocket( + identifier_, kSingleTry, kNoIdleTime, identifier_); + if (!client_socket) { + switch (fork()) { + case -1: + PError("fork()"); + return false; + // Child. + case 0: { + if (setsid() < 0) { // Detach the child process from its parent. + PError("setsid()"); + exit(1); + } + InitLoggingForDaemon(log_file_path_); + CloseFD(STDIN_FILENO); + CloseFD(STDOUT_FILENO); + CloseFD(STDERR_FILENO); + const int null_fd = open("/dev/null", O_RDWR); + CHECK_EQ(null_fd, STDIN_FILENO); + CHECK_EQ(dup(null_fd), STDOUT_FILENO); + CHECK_EQ(dup(null_fd), STDERR_FILENO); + Socket command_socket; + if (!command_socket.BindUnix(identifier_)) { + scoped_ptr<Socket> client_socket = ConnectToUnixDomainSocket( + identifier_, kSingleTry, kNoIdleTime, identifier_); + if (client_socket.get()) { + // The daemon was spawned by a concurrent process. + exit(0); + } + PError("bind()"); + exit(1); + } + server_delegate_->Init(); + command_socket.AddEventFd(get_exit_fd_callback_()); + return RunServerAcceptLoop( + identifier_, &command_socket, server_delegate_); + } + default: + break; + } + } + // Parent. + // Install the custom SIGCHLD handler. + sigset_t blocked_signals_set; + if (sigprocmask(0 /* first arg ignored */, NULL, &blocked_signals_set) < 0) { + PError("sigprocmask()"); + return false; + } + struct sigaction old_action; + struct sigaction new_action; + memset(&new_action, 0, sizeof(new_action)); + new_action.sa_handler = SigChildHandler; + new_action.sa_flags = SA_NOCLDSTOP; + sigemptyset(&new_action.sa_mask); + if (sigaction(SIGCHLD, &new_action, &old_action) < 0) { + PError("sigaction()"); + return false; + } + // Connect to the daemon's Unix Domain Socket. + bool failed = false; + if (!client_socket) { + client_socket = ConnectToUnixDomainSocket( + identifier_, kNumTries, kIdleTimeMSec, identifier_); + if (!client_socket) { + LOG(ERROR) << "Could not connect to daemon's Unix Daemon socket"; + failed = true; + } + } + if (!failed) + client_delegate_->OnDaemonReady(client_socket.get()); + // Restore the previous signal action for SIGCHLD. + if (sigaction(SIGCHLD, &old_action, NULL) < 0) { + PError("sigaction"); + failed = true; + } + return !failed; +} + +bool Daemon::Kill() { + pid_t daemon_pid = Socket::GetUnixDomainSocketProcessOwner(identifier_); + if (daemon_pid < 0) { + LOG(ERROR) << "No forwarder daemon seems to be running"; + return true; + } + if (kill(daemon_pid, SIGTERM) < 0) { + if (errno == ESRCH /* invalid PID */) { + // The daemon exited for some reason (e.g. kill by a process other than + // us) right before the call to kill() above. + LOG(ERROR) << "Could not kill daemon with PID " << daemon_pid; + return true; + } + PError("kill"); + return false; + } + for (int i = 0; i < kNumTries; ++i) { + const pid_t previous_pid = daemon_pid; + daemon_pid = Socket::GetUnixDomainSocketProcessOwner(identifier_); + if (daemon_pid < 0) + return true; + // Since we are polling we might not see the 'daemon exited' event if + // another daemon was spawned during our idle period. + if (daemon_pid != previous_pid) { + LOG(WARNING) << "Daemon (pid=" << previous_pid + << ") was successfully killed but a new daemon (pid=" + << daemon_pid << ") seems to be running now."; + return true; + } + usleep(kIdleTimeMSec * 1000); + } + LOG(ERROR) << "Timed out while killing daemon. " + "It might still be tearing down."; + return false; +} + +} // namespace forwarder2
diff --git a/tools/android/forwarder2/daemon.h b/tools/android/forwarder2/daemon.h new file mode 100644 index 0000000..4b05ea4 --- /dev/null +++ b/tools/android/forwarder2/daemon.h
@@ -0,0 +1,75 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_DAEMON_H_ +#define TOOLS_ANDROID_FORWARDER2_DAEMON_H_ + +#include <string> + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" + +namespace forwarder2 { + +class Socket; + +// Provides a way to spawn a daemon and communicate with it. +class Daemon { + public: + // Callback used by the daemon to shutdown properly. See pipe_notifier.h for + // more details. + typedef int (*GetExitNotifierFDCallback)(); + + class ClientDelegate { + public: + virtual ~ClientDelegate() {} + + // Called after the daemon is ready to receive commands. + virtual void OnDaemonReady(Socket* daemon_socket) = 0; + }; + + class ServerDelegate { + public: + virtual ~ServerDelegate() {} + + // Called after the daemon bound its Unix Domain Socket. This can be used to + // setup signal handlers or perform global initialization. + virtual void Init() = 0; + + virtual void OnClientConnected(scoped_ptr<Socket> client_socket) = 0; + }; + + // |identifier| should be a unique string identifier. It is used to + // bind/connect the underlying Unix Domain Socket. + // Note that this class does not take ownership of |client_delegate| and + // |server_delegate|. + Daemon(const std::string& log_file_path, + const std::string& identifier, + ClientDelegate* client_delegate, + ServerDelegate* server_delegate, + GetExitNotifierFDCallback get_exit_fd_callback); + + ~Daemon(); + + // Returns whether the daemon was successfully spawned. Note that this does + // not necessarily mean that the current process was forked in case the daemon + // is already running. + bool SpawnIfNeeded(); + + // Kills the daemon and blocks until it exited. Returns whether it succeeded. + bool Kill(); + + private: + const std::string log_file_path_; + const std::string identifier_; + ClientDelegate* const client_delegate_; + ServerDelegate* const server_delegate_; + const GetExitNotifierFDCallback get_exit_fd_callback_; + + DISALLOW_COPY_AND_ASSIGN(Daemon); +}; + +} // namespace forwarder2 + +#endif // TOOLS_ANDROID_FORWARDER2_DAEMON_H_
diff --git a/tools/android/forwarder2/device_controller.cc b/tools/android/forwarder2/device_controller.cc new file mode 100644 index 0000000..a4cb9c7 --- /dev/null +++ b/tools/android/forwarder2/device_controller.cc
@@ -0,0 +1,158 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/device_controller.h" + +#include <utility> + +#include "base/basictypes.h" +#include "base/bind.h" +#include "base/callback_helpers.h" +#include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/message_loop/message_loop_proxy.h" +#include "base/single_thread_task_runner.h" +#include "tools/android/forwarder2/command.h" +#include "tools/android/forwarder2/device_listener.h" +#include "tools/android/forwarder2/socket.h" +#include "tools/android/forwarder2/util.h" + +namespace forwarder2 { + +// static +scoped_ptr<DeviceController> DeviceController::Create( + const std::string& adb_unix_socket, + int exit_notifier_fd) { + scoped_ptr<DeviceController> device_controller; + scoped_ptr<Socket> host_socket(new Socket()); + if (!host_socket->BindUnix(adb_unix_socket)) { + PLOG(ERROR) << "Could not BindAndListen DeviceController socket on port " + << adb_unix_socket << ": "; + return device_controller.Pass(); + } + LOG(INFO) << "Listening on Unix Domain Socket " << adb_unix_socket; + device_controller.reset( + new DeviceController(host_socket.Pass(), exit_notifier_fd)); + return device_controller.Pass(); +} + +DeviceController::~DeviceController() { + DCHECK(construction_task_runner_->RunsTasksOnCurrentThread()); +} + +void DeviceController::Start() { + AcceptHostCommandSoon(); +} + +DeviceController::DeviceController(scoped_ptr<Socket> host_socket, + int exit_notifier_fd) + : host_socket_(host_socket.Pass()), + exit_notifier_fd_(exit_notifier_fd), + construction_task_runner_(base::MessageLoopProxy::current()), + weak_ptr_factory_(this) { + host_socket_->AddEventFd(exit_notifier_fd); +} + +void DeviceController::AcceptHostCommandSoon() { + base::MessageLoopProxy::current()->PostTask( + FROM_HERE, + base::Bind(&DeviceController::AcceptHostCommandInternal, + base::Unretained(this))); +} + +void DeviceController::AcceptHostCommandInternal() { + scoped_ptr<Socket> socket(new Socket); + if (!host_socket_->Accept(socket.get())) { + if (!host_socket_->DidReceiveEvent()) + PLOG(ERROR) << "Could not Accept DeviceController socket"; + else + LOG(INFO) << "Received exit notification"; + return; + } + base::ScopedClosureRunner accept_next_client( + base::Bind(&DeviceController::AcceptHostCommandSoon, + base::Unretained(this))); + // So that |socket| doesn't block on read if it has notifications. + socket->AddEventFd(exit_notifier_fd_); + int port; + command::Type command; + if (!ReadCommand(socket.get(), &port, &command)) { + LOG(ERROR) << "Invalid command received."; + return; + } + const ListenersMap::iterator listener_it = listeners_.find(port); + DeviceListener* const listener = listener_it == listeners_.end() + ? static_cast<DeviceListener*>(NULL) : listener_it->second.get(); + switch (command) { + case command::LISTEN: { + if (listener != NULL) { + LOG(WARNING) << "Already forwarding port " << port + << ". Attempting to restart the listener.\n"; + DeleteRefCountedValueInMapFromIterator(listener_it, &listeners_); + } + scoped_ptr<DeviceListener> new_listener( + DeviceListener::Create( + socket.Pass(), port, + base::Bind(&DeviceController::DeleteListenerOnError, + weak_ptr_factory_.GetWeakPtr()))); + if (!new_listener) + return; + new_listener->Start(); + // |port| can be zero, to allow dynamically allocated port, so instead, we + // call DeviceListener::listener_port() to retrieve the currently + // allocated port to this new listener. + const int listener_port = new_listener->listener_port(); + listeners_.insert( + std::make_pair(listener_port, + linked_ptr<DeviceListener>(new_listener.release()))); + LOG(INFO) << "Forwarding device port " << listener_port << " to host."; + break; + } + case command::DATA_CONNECTION: + if (listener == NULL) { + LOG(ERROR) << "Data Connection command received, but " + << "listener has not been set up yet for port " << port; + // After this point it is assumed that, once we close our Adb Data + // socket, the Adb forwarder command will propagate the closing of + // sockets all the way to the host side. + break; + } + listener->SetAdbDataSocket(socket.Pass()); + break; + case command::UNLISTEN: + LOG(INFO) << "Unmapping port " << port; + if (!listener) { + LOG(ERROR) << "No listener found for port " << port; + SendCommand(command::UNLISTEN_ERROR, port, socket.get()); + break; + } + DeleteRefCountedValueInMapFromIterator(listener_it, &listeners_); + SendCommand(command::UNLISTEN_SUCCESS, port, socket.get()); + break; + default: + // TODO(felipeg): add a KillAllListeners command. + LOG(ERROR) << "Invalid command received. Port: " << port + << " Command: " << command; + } +} + +// static +void DeviceController::DeleteListenerOnError( + const base::WeakPtr<DeviceController>& device_controller_ptr, + scoped_ptr<DeviceListener> device_listener) { + DeviceListener* const listener = device_listener.release(); + DeviceController* const controller = device_controller_ptr.get(); + if (!controller) { + // |listener| was already deleted by the controller that did have its + // ownership. + return; + } + DCHECK(controller->construction_task_runner_->RunsTasksOnCurrentThread()); + bool listener_did_exist = DeleteRefCountedValueInMap( + listener->listener_port(), &controller->listeners_); + DCHECK(listener_did_exist); + // Note that |listener| was deleted by DeleteRefCountedValueInMap(). +} + +} // namespace forwarder
diff --git a/tools/android/forwarder2/device_controller.h b/tools/android/forwarder2/device_controller.h new file mode 100644 index 0000000..567a08d --- /dev/null +++ b/tools/android/forwarder2/device_controller.h
@@ -0,0 +1,71 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_DEVICE_CONTROLLER_H_ +#define TOOLS_ANDROID_FORWARDER2_DEVICE_CONTROLLER_H_ + +#include <string> + +#include "base/basictypes.h" +#include "base/containers/hash_tables.h" +#include "base/memory/linked_ptr.h" +#include "base/memory/ref_counted.h" +#include "base/memory/scoped_ptr.h" +#include "base/memory/weak_ptr.h" +#include "tools/android/forwarder2/socket.h" + +namespace base { +class SingleThreadTaskRunner; +} // namespace base + +namespace forwarder2 { + +class DeviceListener; + +// There is a single DeviceController per device_forwarder process, and it is in +// charge of managing all active redirections on the device side (one +// DeviceListener each). +class DeviceController { + public: + static scoped_ptr<DeviceController> Create(const std::string& adb_unix_socket, + int exit_notifier_fd); + ~DeviceController(); + + void Start(); + + private: + typedef base::hash_map< + int /* port */, linked_ptr<DeviceListener> > ListenersMap; + + DeviceController(scoped_ptr<Socket> host_socket, int exit_notifier_fd); + + void AcceptHostCommandSoon(); + void AcceptHostCommandInternal(); + + // Note that this can end up being called after the DeviceController is + // destroyed which is why a weak pointer is used. + static void DeleteListenerOnError( + const base::WeakPtr<DeviceController>& device_controller_ptr, + scoped_ptr<DeviceListener> device_listener); + + const scoped_ptr<Socket> host_socket_; + // Used to notify the controller to exit. + const int exit_notifier_fd_; + // Lets ensure DeviceListener instances are deleted on the thread they were + // created on. + const scoped_refptr<base::SingleThreadTaskRunner> construction_task_runner_; + ListenersMap listeners_; + + //WeakPtrFactory's documentation says: + // Member variables should appear before the WeakPtrFactory, to ensure + // that any WeakPtrs to Controller are invalidated before its members + // variable's destructors are executed, rendering them invalid. + base::WeakPtrFactory<DeviceController> weak_ptr_factory_; + + DISALLOW_COPY_AND_ASSIGN(DeviceController); +}; + +} // namespace forwarder + +#endif // TOOLS_ANDROID_FORWARDER2_DEVICE_CONTROLLER_H_
diff --git a/tools/android/forwarder2/device_forwarder_main.cc b/tools/android/forwarder2/device_forwarder_main.cc new file mode 100644 index 0000000..cad46f4 --- /dev/null +++ b/tools/android/forwarder2/device_forwarder_main.cc
@@ -0,0 +1,169 @@ +// Copyright (c) 2012 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. + +#include <signal.h> +#include <stdlib.h> + +#include <iostream> +#include <string> + +#include "base/at_exit.h" +#include "base/bind.h" +#include "base/command_line.h" +#include "base/compiler_specific.h" +#include "base/logging.h" +#include "base/strings/string_piece.h" +#include "base/strings/stringprintf.h" +#include "base/threading/thread.h" +#include "tools/android/forwarder2/common.h" +#include "tools/android/forwarder2/daemon.h" +#include "tools/android/forwarder2/device_controller.h" +#include "tools/android/forwarder2/pipe_notifier.h" + +namespace forwarder2 { +namespace { + +// Leaky global instance, accessed from the signal handler. +forwarder2::PipeNotifier* g_notifier = NULL; + +const int kBufSize = 256; + +const char kUnixDomainSocketPath[] = "chrome_device_forwarder"; +const char kDaemonIdentifier[] = "chrome_device_forwarder_daemon"; + +void KillHandler(int /* unused */) { + CHECK(g_notifier); + if (!g_notifier->Notify()) + exit(1); +} + +// Lets the daemon fetch the exit notifier file descriptor. +int GetExitNotifierFD() { + DCHECK(g_notifier); + return g_notifier->receiver_fd(); +} + +class ServerDelegate : public Daemon::ServerDelegate { + public: + ServerDelegate() : initialized_(false) {} + + virtual ~ServerDelegate() { + if (!controller_thread_.get()) + return; + // The DeviceController instance, if any, is constructed on the controller + // thread. Make sure that it gets deleted on that same thread. Note that + // DeleteSoon() is not used here since it would imply reading |controller_| + // from the main thread while it's set on the internal thread. + controller_thread_->message_loop_proxy()->PostTask( + FROM_HERE, + base::Bind(&ServerDelegate::DeleteControllerOnInternalThread, + base::Unretained(this))); + } + + void DeleteControllerOnInternalThread() { + DCHECK( + controller_thread_->message_loop_proxy()->RunsTasksOnCurrentThread()); + controller_.reset(); + } + + // Daemon::ServerDelegate: + virtual void Init() OVERRIDE { + DCHECK(!g_notifier); + g_notifier = new forwarder2::PipeNotifier(); + signal(SIGTERM, KillHandler); + signal(SIGINT, KillHandler); + controller_thread_.reset(new base::Thread("controller_thread")); + controller_thread_->Start(); + } + + virtual void OnClientConnected(scoped_ptr<Socket> client_socket) OVERRIDE { + if (initialized_) { + client_socket->WriteString("OK"); + return; + } + controller_thread_->message_loop()->PostTask( + FROM_HERE, + base::Bind(&ServerDelegate::StartController, base::Unretained(this), + GetExitNotifierFD(), base::Passed(&client_socket))); + initialized_ = true; + } + + private: + void StartController(int exit_notifier_fd, scoped_ptr<Socket> client_socket) { + DCHECK(!controller_.get()); + scoped_ptr<DeviceController> controller( + DeviceController::Create(kUnixDomainSocketPath, exit_notifier_fd)); + if (!controller.get()) { + client_socket->WriteString( + base::StringPrintf("ERROR: Could not initialize device controller " + "with ADB socket path: %s", + kUnixDomainSocketPath)); + return; + } + controller_.swap(controller); + controller_->Start(); + client_socket->WriteString("OK"); + client_socket->Close(); + } + + scoped_ptr<DeviceController> controller_; + scoped_ptr<base::Thread> controller_thread_; + bool initialized_; +}; + +class ClientDelegate : public Daemon::ClientDelegate { + public: + ClientDelegate() : has_failed_(false) {} + + bool has_failed() const { return has_failed_; } + + // Daemon::ClientDelegate: + virtual void OnDaemonReady(Socket* daemon_socket) OVERRIDE { + char buf[kBufSize]; + const int bytes_read = daemon_socket->Read( + buf, sizeof(buf) - 1 /* leave space for null terminator */); + CHECK_GT(bytes_read, 0); + DCHECK(bytes_read < sizeof(buf)); + buf[bytes_read] = 0; + base::StringPiece msg(buf, bytes_read); + if (msg.starts_with("ERROR")) { + LOG(ERROR) << msg; + has_failed_ = true; + return; + } + } + + private: + bool has_failed_; +}; + +int RunDeviceForwarder(int argc, char** argv) { + CommandLine::Init(argc, argv); // Needed by logging. + const bool kill_server = CommandLine::ForCurrentProcess()->HasSwitch( + "kill-server"); + if ((kill_server && argc != 2) || (!kill_server && argc != 1)) { + std::cerr << "Usage: device_forwarder [--kill-server]" << std::endl; + return 1; + } + base::AtExitManager at_exit_manager; // Used by base::Thread. + ClientDelegate client_delegate; + ServerDelegate daemon_delegate; + const char kLogFilePath[] = ""; // Log to logcat. + Daemon daemon(kLogFilePath, kDaemonIdentifier, &client_delegate, + &daemon_delegate, &GetExitNotifierFD); + + if (kill_server) + return !daemon.Kill(); + + if (!daemon.SpawnIfNeeded()) + return 1; + return client_delegate.has_failed(); +} + +} // namespace +} // namespace forwarder2 + +int main(int argc, char** argv) { + return forwarder2::RunDeviceForwarder(argc, argv); +}
diff --git a/tools/android/forwarder2/device_listener.cc b/tools/android/forwarder2/device_listener.cc new file mode 100644 index 0000000..b48a746 --- /dev/null +++ b/tools/android/forwarder2/device_listener.cc
@@ -0,0 +1,130 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/device_listener.h" + +#include "base/bind.h" +#include "base/bind_helpers.h" +#include "base/callback.h" +#include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/message_loop/message_loop_proxy.h" +#include "base/single_thread_task_runner.h" +#include "tools/android/forwarder2/command.h" +#include "tools/android/forwarder2/forwarder.h" +#include "tools/android/forwarder2/socket.h" + +namespace forwarder2 { + +// static +scoped_ptr<DeviceListener> DeviceListener::Create( + scoped_ptr<Socket> host_socket, + int listener_port, + const ErrorCallback& error_callback) { + scoped_ptr<Socket> listener_socket(new Socket()); + scoped_ptr<DeviceListener> device_listener; + if (!listener_socket->BindTcp("", listener_port)) { + LOG(ERROR) << "Device could not bind and listen to local port " + << listener_port; + SendCommand(command::BIND_ERROR, listener_port, host_socket.get()); + return device_listener.Pass(); + } + // In case the |listener_port_| was zero, GetPort() will return the + // currently (non-zero) allocated port for this socket. + listener_port = listener_socket->GetPort(); + SendCommand(command::BIND_SUCCESS, listener_port, host_socket.get()); + device_listener.reset( + new DeviceListener(listener_socket.Pass(), host_socket.Pass(), + listener_port, error_callback)); + return device_listener.Pass(); +} + +DeviceListener::~DeviceListener() { + DCHECK(deletion_task_runner_->RunsTasksOnCurrentThread()); + deletion_notifier_.Notify(); +} + +void DeviceListener::Start() { + thread_.Start(); + AcceptNextClientSoon(); +} + +void DeviceListener::SetAdbDataSocket(scoped_ptr<Socket> adb_data_socket) { + thread_.message_loop_proxy()->PostTask( + FROM_HERE, + base::Bind(&DeviceListener::OnAdbDataSocketReceivedOnInternalThread, + base::Unretained(this), base::Passed(&adb_data_socket))); +} + +DeviceListener::DeviceListener(scoped_ptr<Socket> listener_socket, + scoped_ptr<Socket> host_socket, + int port, + const ErrorCallback& error_callback) + : self_deleter_helper_(this, error_callback), + listener_socket_(listener_socket.Pass()), + host_socket_(host_socket.Pass()), + listener_port_(port), + deletion_task_runner_(base::MessageLoopProxy::current()), + thread_("DeviceListener") { + CHECK(host_socket_.get()); + DCHECK(deletion_task_runner_.get()); + host_socket_->AddEventFd(deletion_notifier_.receiver_fd()); + listener_socket_->AddEventFd(deletion_notifier_.receiver_fd()); +} + +void DeviceListener::AcceptNextClientSoon() { + thread_.message_loop_proxy()->PostTask( + FROM_HERE, + base::Bind(&DeviceListener::AcceptClientOnInternalThread, + base::Unretained(this))); +} + +void DeviceListener::AcceptClientOnInternalThread() { + device_data_socket_.reset(new Socket()); + if (!listener_socket_->Accept(device_data_socket_.get())) { + if (listener_socket_->DidReceiveEvent()) { + LOG(INFO) << "Received exit notification, stopped accepting clients."; + OnInternalThreadError(); + return; + } + LOG(WARNING) << "Could not Accept in ListenerSocket."; + SendCommand(command::ACCEPT_ERROR, listener_port_, host_socket_.get()); + OnInternalThreadError(); + return; + } + SendCommand(command::ACCEPT_SUCCESS, listener_port_, host_socket_.get()); + if (!ReceivedCommand(command::HOST_SERVER_SUCCESS, + host_socket_.get())) { + SendCommand(command::ACK, listener_port_, host_socket_.get()); + LOG(ERROR) << "Host could not connect to server."; + device_data_socket_->Close(); + if (host_socket_->has_error()) { + LOG(ERROR) << "Adb Control connection lost. " + << "Listener port: " << listener_port_; + OnInternalThreadError(); + return; + } + // It can continue if the host forwarder could not connect to the host + // server but the control connection is still alive (no errors). The device + // acknowledged that (above), and it can re-try later. + AcceptNextClientSoon(); + return; + } +} + +void DeviceListener::OnAdbDataSocketReceivedOnInternalThread( + scoped_ptr<Socket> adb_data_socket) { + DCHECK(adb_data_socket); + SendCommand(command::ADB_DATA_SOCKET_SUCCESS, listener_port_, + host_socket_.get()); + forwarders_manager_.CreateAndStartNewForwarder( + device_data_socket_.Pass(), adb_data_socket.Pass()); + AcceptNextClientSoon(); +} + +void DeviceListener::OnInternalThreadError() { + self_deleter_helper_.MaybeSelfDeleteSoon(); +} + +} // namespace forwarder
diff --git a/tools/android/forwarder2/device_listener.h b/tools/android/forwarder2/device_listener.h new file mode 100644 index 0000000..c7724f4 --- /dev/null +++ b/tools/android/forwarder2/device_listener.h
@@ -0,0 +1,106 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_DEVICE_LISTENER_H_ +#define TOOLS_ANDROID_FORWARDER2_DEVICE_LISTENER_H_ + +#include "base/basictypes.h" +#include "base/callback.h" +#include "base/compiler_specific.h" +#include "base/logging.h" +#include "base/memory/ref_counted.h" +#include "base/memory/scoped_ptr.h" +#include "base/threading/thread.h" +#include "tools/android/forwarder2/forwarders_manager.h" +#include "tools/android/forwarder2/pipe_notifier.h" +#include "tools/android/forwarder2/self_deleter_helper.h" +#include "tools/android/forwarder2/socket.h" + +namespace base { +class SingleThreadTaskRunner; +} // namespace base + +namespace forwarder2 { + +class Forwarder; + +// A DeviceListener instance is used in the device_forwarder program to bind to +// a specific device-side |port| and wait for client connections. When a +// connection happens, it informs the corresponding HostController instance +// running on the host, through |host_socket|. Then the class expects a call to +// its SetAdbDataSocket() method (performed by the device controller) once the +// host opened a new connection to the device. When this happens, a new internal +// Forwarder instance is started. +// Note that instances of this class are owned by the device controller which +// creates and destroys them on the same thread. In case an internal error +// happens on the DeviceListener's internal thread, the DeviceListener +// can also self-delete by executing the user-provided callback on the thread +// the DeviceListener was created on. +// Note that the DeviceListener's destructor joins its internal thread (i.e. +// waits for its completion) which means that the internal thread is guaranteed +// not to be running anymore once the object is deleted. +class DeviceListener { + public: + // Callback that is used for self-deletion on error to let the device + // controller perform some additional cleanup work (e.g. removing the device + // listener instance from its internal map before deleting it). + typedef base::Callback<void (scoped_ptr<DeviceListener>)> ErrorCallback; + + static scoped_ptr<DeviceListener> Create(scoped_ptr<Socket> host_socket, + int port, + const ErrorCallback& error_callback); + + ~DeviceListener(); + + void Start(); + + void SetAdbDataSocket(scoped_ptr<Socket> adb_data_socket); + + int listener_port() const { return listener_port_; } + + private: + DeviceListener(scoped_ptr<Socket> listener_socket, + scoped_ptr<Socket> host_socket, + int port, + const ErrorCallback& error_callback); + + // Pushes an AcceptClientOnInternalThread() task to the internal thread's + // message queue in order to wait for a new client soon. + void AcceptNextClientSoon(); + + void AcceptClientOnInternalThread(); + + void OnAdbDataSocketReceivedOnInternalThread( + scoped_ptr<Socket> adb_data_socket); + + void OnInternalThreadError(); + + SelfDeleterHelper<DeviceListener> self_deleter_helper_; + // Used for the listener thread to be notified on destruction. We have one + // notifier per Listener thread since each Listener thread may be requested to + // exit for different reasons independently from each other and independent + // from the main program, ex. when the host requests to forward/listen the + // same port again. Both the |host_socket_| and |listener_socket_| must share + // the same receiver file descriptor from |deletion_notifier_| and it is set + // in the constructor. + PipeNotifier deletion_notifier_; + // The local device listener socket for accepting connections from the local + // port (listener_port_). + const scoped_ptr<Socket> listener_socket_; + // The listener socket for sending control commands. + const scoped_ptr<Socket> host_socket_; + scoped_ptr<Socket> device_data_socket_; + const int listener_port_; + // Task runner used for deletion set at construction time (i.e. the object is + // deleted on the same thread it is created on). + scoped_refptr<base::SingleThreadTaskRunner> deletion_task_runner_; + base::Thread thread_; + ForwardersManager forwarders_manager_; + + DISALLOW_COPY_AND_ASSIGN(DeviceListener); +}; + +} // namespace forwarder + +#endif // TOOLS_ANDROID_FORWARDER2_DEVICE_LISTENER_H_
diff --git a/tools/android/forwarder2/forwarder.cc b/tools/android/forwarder2/forwarder.cc new file mode 100644 index 0000000..1e0bcd0 --- /dev/null +++ b/tools/android/forwarder2/forwarder.cc
@@ -0,0 +1,255 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/forwarder.h" + +#include "base/basictypes.h" +#include "base/logging.h" +#include "base/posix/eintr_wrapper.h" +#include "tools/android/forwarder2/socket.h" + +namespace forwarder2 { +namespace { + +const int kBufferSize = 32 * 1024; + +} // namespace + + +// Helper class to buffer reads and writes from one socket to another. +// Each implements a small buffer connected two one input socket, and +// one output socket. +// +// socket_from_ ---> [BufferedCopier] ---> socket_to_ +// +// These objects are used in a pair to handle duplex traffic, as in: +// +// ------> [BufferedCopier_1] ---> +// / \ +// socket_1 * * socket_2 +// \ / +// <------ [BufferedCopier_2] <---- +// +// When a BufferedCopier is in the READING state (see below), it only listens +// to events on its input socket, and won't detect when its output socket +// disconnects. To work around this, its peer will call its Close() method +// when that happens. + +class Forwarder::BufferedCopier { + public: + // Possible states: + // READING - Empty buffer and Waiting for input. + // WRITING - Data in buffer, and waiting for output. + // CLOSING - Like WRITING, but do not try to read after that. + // CLOSED - Completely closed. + // + // State transitions are: + // + // T01: READING ---[receive data]---> WRITING + // T02: READING ---[error on input socket]---> CLOSED + // T03: READING ---[Close() call]---> CLOSED + // + // T04: WRITING ---[write partial data]---> WRITING + // T05: WRITING ---[write all data]----> READING + // T06: WRITING ---[error on output socket]----> CLOSED + // T07: WRITING ---[Close() call]---> CLOSING + // + // T08: CLOSING ---[write partial data]---> CLOSING + // T09: CLOSING ---[write all data]----> CLOSED + // T10: CLOSING ---[Close() call]---> CLOSING + // T11: CLOSING ---[error on output socket] ---> CLOSED + // + enum State { + STATE_READING = 0, + STATE_WRITING = 1, + STATE_CLOSING = 2, + STATE_CLOSED = 3, + }; + + // Does NOT own the pointers. + BufferedCopier(Socket* socket_from, Socket* socket_to) + : socket_from_(socket_from), + socket_to_(socket_to), + bytes_read_(0), + write_offset_(0), + peer_(NULL), + state_(STATE_READING) {} + + // Sets the 'peer_' field pointing to the other BufferedCopier in a pair. + void SetPeer(BufferedCopier* peer) { + DCHECK(!peer_); + peer_ = peer; + } + + bool is_closed() const { return state_ == STATE_CLOSED; } + + // Gently asks to close a buffer. Called either by the peer or the forwarder. + void Close() { + switch (state_) { + case STATE_READING: + state_ = STATE_CLOSED; // T03 + break; + case STATE_WRITING: + state_ = STATE_CLOSING; // T07 + break; + case STATE_CLOSING: + break; // T10 + case STATE_CLOSED: + ; + } + } + + // Call this before select(). This updates |read_fds|, + // |write_fds| and |max_fd| appropriately *if* the buffer isn't closed. + void PrepareSelect(fd_set* read_fds, fd_set* write_fds, int* max_fd) { + int fd; + switch (state_) { + case STATE_READING: + DCHECK(bytes_read_ == 0); + DCHECK(write_offset_ == 0); + fd = socket_from_->fd(); + if (fd < 0) { + ForceClose(); // T02 + return; + } + FD_SET(fd, read_fds); + break; + + case STATE_WRITING: + case STATE_CLOSING: + DCHECK(bytes_read_ > 0); + DCHECK(write_offset_ < bytes_read_); + fd = socket_to_->fd(); + if (fd < 0) { + ForceClose(); // T06 + return; + } + FD_SET(fd, write_fds); + break; + + case STATE_CLOSED: + return; + } + *max_fd = std::max(*max_fd, fd); + } + + // Call this after a select() call to operate over the buffer. + void ProcessSelect(const fd_set& read_fds, const fd_set& write_fds) { + int fd, ret; + switch (state_) { + case STATE_READING: + fd = socket_from_->fd(); + if (fd < 0) { + state_ = STATE_CLOSED; // T02 + return; + } + if (!FD_ISSET(fd, &read_fds)) + return; + + ret = socket_from_->NonBlockingRead(buffer_, kBufferSize); + if (ret <= 0) { + ForceClose(); // T02 + return; + } + bytes_read_ = ret; + write_offset_ = 0; + state_ = STATE_WRITING; // T01 + break; + + case STATE_WRITING: + case STATE_CLOSING: + fd = socket_to_->fd(); + if (fd < 0) { + ForceClose(); // T06 + T11 + return; + } + if (!FD_ISSET(fd, &write_fds)) + return; + + ret = socket_to_->NonBlockingWrite(buffer_ + write_offset_, + bytes_read_ - write_offset_); + if (ret <= 0) { + ForceClose(); // T06 + T11 + return; + } + + write_offset_ += ret; + if (write_offset_ < bytes_read_) + return; // T08 + T04 + + write_offset_ = 0; + bytes_read_ = 0; + if (state_ == STATE_CLOSING) { + ForceClose(); // T09 + return; + } + state_ = STATE_READING; // T05 + break; + + case STATE_CLOSED: + ; + } + } + + private: + // Internal method used to close the buffer and notify the peer, if any. + void ForceClose() { + if (peer_) { + peer_->Close(); + peer_ = NULL; + } + state_ = STATE_CLOSED; + } + + // Not owned. + Socket* socket_from_; + Socket* socket_to_; + + int bytes_read_; + int write_offset_; + BufferedCopier* peer_; + State state_; + char buffer_[kBufferSize]; + + DISALLOW_COPY_AND_ASSIGN(BufferedCopier); +}; + +Forwarder::Forwarder(scoped_ptr<Socket> socket1, + scoped_ptr<Socket> socket2) + : socket1_(socket1.Pass()), + socket2_(socket2.Pass()), + buffer1_(new BufferedCopier(socket1_.get(), socket2_.get())), + buffer2_(new BufferedCopier(socket2_.get(), socket1_.get())) { + buffer1_->SetPeer(buffer2_.get()); + buffer2_->SetPeer(buffer1_.get()); +} + +Forwarder::~Forwarder() { + DCHECK(thread_checker_.CalledOnValidThread()); +} + +void Forwarder::RegisterFDs(fd_set* read_fds, fd_set* write_fds, int* max_fd) { + DCHECK(thread_checker_.CalledOnValidThread()); + buffer1_->PrepareSelect(read_fds, write_fds, max_fd); + buffer2_->PrepareSelect(read_fds, write_fds, max_fd); +} + +void Forwarder::ProcessEvents(const fd_set& read_fds, const fd_set& write_fds) { + DCHECK(thread_checker_.CalledOnValidThread()); + buffer1_->ProcessSelect(read_fds, write_fds); + buffer2_->ProcessSelect(read_fds, write_fds); +} + +bool Forwarder::IsClosed() const { + DCHECK(thread_checker_.CalledOnValidThread()); + return buffer1_->is_closed() && buffer2_->is_closed(); +} + +void Forwarder::Shutdown() { + DCHECK(thread_checker_.CalledOnValidThread()); + buffer1_->Close(); + buffer2_->Close(); +} + +} // namespace forwarder2
diff --git a/tools/android/forwarder2/forwarder.gyp b/tools/android/forwarder2/forwarder.gyp new file mode 100644 index 0000000..fbf5eba --- /dev/null +++ b/tools/android/forwarder2/forwarder.gyp
@@ -0,0 +1,70 @@ +# Copyright (c) 2012 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. + +{ + 'targets': [ + { + 'target_name': 'forwarder2', + 'type': 'none', + 'dependencies': [ + 'device_forwarder', + 'host_forwarder#host', + ], + # For the component build, ensure dependent shared libraries are stripped + # and put alongside forwarder to simplify pushing to the device. + 'variables': { + 'output_dir': '<(PRODUCT_DIR)/forwarder_dist/', + 'native_binary': '<(PRODUCT_DIR)/device_forwarder', + }, + 'includes': ['../../../build/android/native_app_dependencies.gypi'], + }, + { + 'target_name': 'device_forwarder', + 'type': 'executable', + 'toolsets': ['target'], + 'dependencies': [ + '../../../base/base.gyp:base', + '../common/common.gyp:android_tools_common', + ], + 'include_dirs': [ + '../../..', + ], + 'sources': [ + 'command.cc', + 'common.cc', + 'daemon.cc', + 'device_controller.cc', + 'device_forwarder_main.cc', + 'device_listener.cc', + 'forwarder.cc', + 'forwarders_manager.cc', + 'pipe_notifier.cc', + 'socket.cc', + ], + }, + { + 'target_name': 'host_forwarder', + 'type': 'executable', + 'toolsets': ['host'], + 'dependencies': [ + '../../../base/base.gyp:base', + '../common/common.gyp:android_tools_common', + ], + 'include_dirs': [ + '../../..', + ], + 'sources': [ + 'command.cc', + 'common.cc', + 'daemon.cc', + 'forwarder.cc', + 'forwarders_manager.cc', + 'host_controller.cc', + 'host_forwarder_main.cc', + 'pipe_notifier.cc', + 'socket.cc', + ], + }, + ], +}
diff --git a/tools/android/forwarder2/forwarder.h b/tools/android/forwarder2/forwarder.h new file mode 100644 index 0000000..0be86fc --- /dev/null +++ b/tools/android/forwarder2/forwarder.h
@@ -0,0 +1,47 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_FORWARDER_H_ +#define TOOLS_ANDROID_FORWARDER2_FORWARDER_H_ + +#include <sys/select.h> + +#include "base/memory/scoped_ptr.h" +#include "base/threading/thread_checker.h" + +namespace forwarder2 { + +class Socket; + +// Internal class that forwards traffic between |socket1| and |socket2|. Note +// that this class is not thread-safe. +class Forwarder { + public: + Forwarder(scoped_ptr<Socket> socket1, scoped_ptr<Socket> socket2); + + ~Forwarder(); + + void RegisterFDs(fd_set* read_fds, fd_set* write_fds, int* max_fd); + + void ProcessEvents(const fd_set& read_fds, const fd_set& write_fds); + + bool IsClosed() const; + + void Shutdown(); + + private: + class BufferedCopier; + + base::ThreadChecker thread_checker_; + const scoped_ptr<Socket> socket1_; + const scoped_ptr<Socket> socket2_; + // Copies data from socket1 to socket2. + const scoped_ptr<BufferedCopier> buffer1_; + // Copies data from socket2 to socket1. + const scoped_ptr<BufferedCopier> buffer2_; +}; + +} // namespace forwarder2 + +#endif // TOOLS_ANDROID_FORWARDER2_FORWARDER_H_
diff --git a/tools/android/forwarder2/forwarders_manager.cc b/tools/android/forwarder2/forwarders_manager.cc new file mode 100644 index 0000000..1795cb5 --- /dev/null +++ b/tools/android/forwarder2/forwarders_manager.cc
@@ -0,0 +1,132 @@ +// 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. + +#include "tools/android/forwarder2/forwarders_manager.h" + +#include <sys/select.h> +#include <unistd.h> + +#include <algorithm> + +#include "base/basictypes.h" +#include "base/bind.h" +#include "base/callback_helpers.h" +#include "base/location.h" +#include "base/logging.h" +#include "base/message_loop/message_loop_proxy.h" +#include "base/posix/eintr_wrapper.h" +#include "tools/android/forwarder2/forwarder.h" +#include "tools/android/forwarder2/socket.h" + +namespace forwarder2 { + +ForwardersManager::ForwardersManager() : thread_("ForwardersManagerThread") { + thread_.Start(); + WaitForEventsOnInternalThreadSoon(); +} + + +ForwardersManager::~ForwardersManager() { + deletion_notifier_.Notify(); +} + +void ForwardersManager::CreateAndStartNewForwarder(scoped_ptr<Socket> socket1, + scoped_ptr<Socket> socket2) { + // Note that the internal Forwarder vector is populated on the internal thread + // which is the only thread from which it's accessed. + thread_.message_loop_proxy()->PostTask( + FROM_HERE, + base::Bind(&ForwardersManager::CreateNewForwarderOnInternalThread, + base::Unretained(this), base::Passed(&socket1), + base::Passed(&socket2))); + + // Guarantees that the CreateNewForwarderOnInternalThread callback posted to + // the internal thread gets executed immediately. + wakeup_notifier_.Notify(); +} + +void ForwardersManager::CreateNewForwarderOnInternalThread( + scoped_ptr<Socket> socket1, + scoped_ptr<Socket> socket2) { + DCHECK(thread_.message_loop_proxy()->RunsTasksOnCurrentThread()); + forwarders_.push_back(new Forwarder(socket1.Pass(), socket2.Pass())); +} + +void ForwardersManager::WaitForEventsOnInternalThreadSoon() { + thread_.message_loop_proxy()->PostTask( + FROM_HERE, + base::Bind(&ForwardersManager::WaitForEventsOnInternalThread, + base::Unretained(this))); +} + +void ForwardersManager::WaitForEventsOnInternalThread() { + DCHECK(thread_.message_loop_proxy()->RunsTasksOnCurrentThread()); + fd_set read_fds; + fd_set write_fds; + + FD_ZERO(&read_fds); + FD_ZERO(&write_fds); + + // Populate the file descriptor sets. + int max_fd = -1; + for (ScopedVector<Forwarder>::iterator it = forwarders_.begin(); + it != forwarders_.end(); ++it) { + Forwarder* const forwarder = *it; + forwarder->RegisterFDs(&read_fds, &write_fds, &max_fd); + } + + const int notifier_fds[] = { + wakeup_notifier_.receiver_fd(), + deletion_notifier_.receiver_fd(), + }; + + for (int i = 0; i < arraysize(notifier_fds); ++i) { + const int notifier_fd = notifier_fds[i]; + DCHECK_GT(notifier_fd, -1); + FD_SET(notifier_fd, &read_fds); + max_fd = std::max(max_fd, notifier_fd); + } + + const int ret = HANDLE_EINTR( + select(max_fd + 1, &read_fds, &write_fds, NULL, NULL)); + if (ret < 0) { + PLOG(ERROR) << "select"; + return; + } + + const bool must_shutdown = FD_ISSET( + deletion_notifier_.receiver_fd(), &read_fds); + if (must_shutdown && forwarders_.empty()) + return; + + base::ScopedClosureRunner wait_for_events_soon( + base::Bind(&ForwardersManager::WaitForEventsOnInternalThreadSoon, + base::Unretained(this))); + + if (FD_ISSET(wakeup_notifier_.receiver_fd(), &read_fds)) { + // Note that the events on FDs other than the wakeup notifier one, if any, + // will be processed upon the next select(). + wakeup_notifier_.Reset(); + return; + } + + // Notify the Forwarder instances and remove the ones that are closed. + for (size_t i = 0; i < forwarders_.size(); ) { + Forwarder* const forwarder = forwarders_[i]; + forwarder->ProcessEvents(read_fds, write_fds); + + if (must_shutdown) + forwarder->Shutdown(); + + if (!forwarder->IsClosed()) { + ++i; + continue; + } + + std::swap(forwarders_[i], forwarders_.back()); + forwarders_.pop_back(); + } +} + +} // namespace forwarder2
diff --git a/tools/android/forwarder2/forwarders_manager.h b/tools/android/forwarder2/forwarders_manager.h new file mode 100644 index 0000000..4c6dea6 --- /dev/null +++ b/tools/android/forwarder2/forwarders_manager.h
@@ -0,0 +1,45 @@ +// 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_FORWARDERS_MANAGER_H_ +#define TOOLS_ANDROID_FORWARDER2_FORWARDERS_MANAGER_H_ + +#include "base/memory/scoped_ptr.h" +#include "base/memory/scoped_vector.h" +#include "base/threading/thread.h" +#include "tools/android/forwarder2/pipe_notifier.h" + +namespace forwarder2 { + +class Forwarder; +class Socket; + +// Creates, owns and notifies Forwarder instances on its own internal thread. +class ForwardersManager { + public: + ForwardersManager(); + + // Must be called on the thread the constructor was called on. + ~ForwardersManager(); + + // Can be called on any thread. + void CreateAndStartNewForwarder(scoped_ptr<Socket> socket1, + scoped_ptr<Socket> socket2); + + private: + void CreateNewForwarderOnInternalThread(scoped_ptr<Socket> socket1, + scoped_ptr<Socket> socket2); + + void WaitForEventsOnInternalThreadSoon(); + void WaitForEventsOnInternalThread(); + + ScopedVector<Forwarder> forwarders_; + PipeNotifier deletion_notifier_; + PipeNotifier wakeup_notifier_; + base::Thread thread_; +}; + +} // namespace forwarder2 + +#endif // TOOLS_ANDROID_FORWARDER2_FORWARDERS_MANAGER_H_
diff --git a/tools/android/forwarder2/host_controller.cc b/tools/android/forwarder2/host_controller.cc new file mode 100644 index 0000000..94e63ec --- /dev/null +++ b/tools/android/forwarder2/host_controller.cc
@@ -0,0 +1,170 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/host_controller.h" + +#include <string> + +#include "base/basictypes.h" +#include "base/bind.h" +#include "base/bind_helpers.h" +#include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "tools/android/forwarder2/command.h" +#include "tools/android/forwarder2/forwarder.h" +#include "tools/android/forwarder2/socket.h" + +namespace forwarder2 { + +// static +scoped_ptr<HostController> HostController::Create( + int device_port, + int host_port, + int adb_port, + int exit_notifier_fd, + const ErrorCallback& error_callback) { + scoped_ptr<HostController> host_controller; + scoped_ptr<PipeNotifier> delete_controller_notifier(new PipeNotifier()); + scoped_ptr<Socket> adb_control_socket(new Socket()); + adb_control_socket->AddEventFd(exit_notifier_fd); + adb_control_socket->AddEventFd(delete_controller_notifier->receiver_fd()); + if (!adb_control_socket->ConnectTcp(std::string(), adb_port)) { + LOG(ERROR) << "Could not connect HostController socket on port: " + << adb_port; + return host_controller.Pass(); + } + // Send the command to the device start listening to the "device_forward_port" + bool send_command_success = SendCommand( + command::LISTEN, device_port, adb_control_socket.get()); + CHECK(send_command_success); + int device_port_allocated; + command::Type command; + if (!ReadCommand( + adb_control_socket.get(), &device_port_allocated, &command) || + command != command::BIND_SUCCESS) { + LOG(ERROR) << "Device binding error using port " << device_port; + return host_controller.Pass(); + } + host_controller.reset( + new HostController( + device_port_allocated, host_port, adb_port, exit_notifier_fd, + error_callback, adb_control_socket.Pass(), + delete_controller_notifier.Pass())); + return host_controller.Pass(); +} + +HostController::~HostController() { + DCHECK(deletion_task_runner_->RunsTasksOnCurrentThread()); + delete_controller_notifier_->Notify(); +} + +void HostController::Start() { + thread_.Start(); + ReadNextCommandSoon(); +} + +HostController::HostController( + int device_port, + int host_port, + int adb_port, + int exit_notifier_fd, + const ErrorCallback& error_callback, + scoped_ptr<Socket> adb_control_socket, + scoped_ptr<PipeNotifier> delete_controller_notifier) + : self_deleter_helper_(this, error_callback), + device_port_(device_port), + host_port_(host_port), + adb_port_(adb_port), + global_exit_notifier_fd_(exit_notifier_fd), + adb_control_socket_(adb_control_socket.Pass()), + delete_controller_notifier_(delete_controller_notifier.Pass()), + deletion_task_runner_(base::MessageLoopProxy::current()), + thread_("HostControllerThread") { +} + +void HostController::ReadNextCommandSoon() { + thread_.message_loop_proxy()->PostTask( + FROM_HERE, + base::Bind(&HostController::ReadCommandOnInternalThread, + base::Unretained(this))); +} + +void HostController::ReadCommandOnInternalThread() { + if (!ReceivedCommand(command::ACCEPT_SUCCESS, adb_control_socket_.get())) { + LOG(ERROR) << "Did not receive ACCEPT_SUCCESS for port: " + << host_port_; + OnInternalThreadError(); + return; + } + // Try to connect to host server. + scoped_ptr<Socket> host_server_data_socket(new Socket()); + if (!host_server_data_socket->ConnectTcp(std::string(), host_port_)) { + LOG(ERROR) << "Could not Connect HostServerData socket on port: " + << host_port_; + SendCommand( + command::HOST_SERVER_ERROR, device_port_, adb_control_socket_.get()); + if (ReceivedCommand(command::ACK, adb_control_socket_.get())) { + // It can continue if the host forwarder could not connect to the host + // server but the device acknowledged that, so that the device could + // re-try later. + ReadNextCommandSoon(); + return; + } + OnInternalThreadError(); + return; + } + LOG(INFO) << "Will send HOST_SERVER_SUCCESS: " << host_port_; + SendCommand( + command::HOST_SERVER_SUCCESS, device_port_, adb_control_socket_.get()); + StartForwarder(host_server_data_socket.Pass()); + ReadNextCommandSoon(); +} + +void HostController::StartForwarder( + scoped_ptr<Socket> host_server_data_socket) { + scoped_ptr<Socket> adb_data_socket(new Socket()); + if (!adb_data_socket->ConnectTcp("", adb_port_)) { + LOG(ERROR) << "Could not connect AdbDataSocket on port: " << adb_port_; + OnInternalThreadError(); + return; + } + // Open the Adb data connection, and send a command with the + // |device_forward_port| as a way for the device to identify the connection. + SendCommand(command::DATA_CONNECTION, device_port_, adb_data_socket.get()); + + // Check that the device received the new Adb Data Connection. Note that this + // check is done through the |adb_control_socket_| that is handled in the + // DeviceListener thread just after the call to WaitForAdbDataSocket(). + if (!ReceivedCommand(command::ADB_DATA_SOCKET_SUCCESS, + adb_control_socket_.get())) { + LOG(ERROR) << "Device could not handle the new Adb Data Connection."; + OnInternalThreadError(); + return; + } + forwarders_manager_.CreateAndStartNewForwarder( + host_server_data_socket.Pass(), adb_data_socket.Pass()); +} + +void HostController::OnInternalThreadError() { + UnmapPortOnDevice(); + self_deleter_helper_.MaybeSelfDeleteSoon(); +} + +void HostController::UnmapPortOnDevice() { + Socket socket; + if (!socket.ConnectTcp("", adb_port_)) { + LOG(ERROR) << "Could not connect to device on port " << adb_port_; + return; + } + if (!SendCommand(command::UNLISTEN, device_port_, &socket)) { + LOG(ERROR) << "Could not send unmap command for port " << device_port_; + return; + } + if (!ReceivedCommand(command::UNLISTEN_SUCCESS, &socket)) { + LOG(ERROR) << "Unamp command failed for port " << device_port_; + return; + } +} + +} // namespace forwarder2
diff --git a/tools/android/forwarder2/host_controller.h b/tools/android/forwarder2/host_controller.h new file mode 100644 index 0000000..d228bcc --- /dev/null +++ b/tools/android/forwarder2/host_controller.h
@@ -0,0 +1,96 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_HOST_CONTROLLER_H_ +#define TOOLS_ANDROID_FORWARDER2_HOST_CONTROLLER_H_ + +#include <string> + +#include "base/basictypes.h" +#include "base/callback.h" +#include "base/compiler_specific.h" +#include "base/memory/scoped_ptr.h" +#include "base/memory/weak_ptr.h" +#include "base/threading/thread.h" +#include "tools/android/forwarder2/forwarders_manager.h" +#include "tools/android/forwarder2/pipe_notifier.h" +#include "tools/android/forwarder2/self_deleter_helper.h" +#include "tools/android/forwarder2/socket.h" + +namespace forwarder2 { + +// This class partners with DeviceController and has the same lifetime and +// threading characteristics as DeviceListener. In a nutshell, this class +// operates on its own thread and is destroyed on the thread it was constructed +// on. The class' deletion can happen in two different ways: +// - Its destructor was called by its owner (HostControllersManager). +// - Its internal thread requested self-deletion after an error happened. In +// this case the owner (HostControllersManager) is notified on the +// construction thread through the provided ErrorCallback invoked with the +// HostController instance. When this callback is invoked, it's up to the +// owner to delete the instance. +class HostController { + public: + // Callback used for self-deletion when an error happens so that the client + // can perform some cleanup work before deleting the HostController instance. + typedef base::Callback<void (scoped_ptr<HostController>)> ErrorCallback; + + // If |device_port| is zero then a dynamic port is allocated (and retrievable + // through device_port() below). + static scoped_ptr<HostController> Create(int device_port, + int host_port, + int adb_port, + int exit_notifier_fd, + const ErrorCallback& error_callback); + + ~HostController(); + + // Starts the internal controller thread. + void Start(); + + int adb_port() const { return adb_port_; } + + int device_port() const { return device_port_; } + + private: + HostController(int device_port, + int host_port, + int adb_port, + int exit_notifier_fd, + const ErrorCallback& error_callback, + scoped_ptr<Socket> adb_control_socket, + scoped_ptr<PipeNotifier> delete_controller_notifier); + + void ReadNextCommandSoon(); + void ReadCommandOnInternalThread(); + + void StartForwarder(scoped_ptr<Socket> host_server_data_socket); + + // Note that this gets also called when ~HostController() is invoked. + void OnInternalThreadError(); + + void UnmapPortOnDevice(); + + SelfDeleterHelper<HostController> self_deleter_helper_; + const int device_port_; + const int host_port_; + const int adb_port_; + // Used to notify the controller when the process is killed. + const int global_exit_notifier_fd_; + scoped_ptr<Socket> adb_control_socket_; + // Used to cancel the pending blocking IO operations when the host controller + // instance is deleted. + scoped_ptr<PipeNotifier> delete_controller_notifier_; + // Task runner used for deletion set at deletion time (i.e. the object is + // deleted on the same thread it is created on). + const scoped_refptr<base::SingleThreadTaskRunner> deletion_task_runner_; + base::Thread thread_; + ForwardersManager forwarders_manager_; + + DISALLOW_COPY_AND_ASSIGN(HostController); +}; + +} // namespace forwarder2 + +#endif // TOOLS_ANDROID_FORWARDER2_HOST_CONTROLLER_H_
diff --git a/tools/android/forwarder2/host_forwarder_main.cc b/tools/android/forwarder2/host_forwarder_main.cc new file mode 100644 index 0000000..59571b6 --- /dev/null +++ b/tools/android/forwarder2/host_forwarder_main.cc
@@ -0,0 +1,460 @@ +// Copyright (c) 2012 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. + +#include <errno.h> +#include <signal.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> + +#include <cstdio> +#include <iostream> +#include <limits> +#include <string> +#include <utility> +#include <vector> + +#include "base/at_exit.h" +#include "base/basictypes.h" +#include "base/bind.h" +#include "base/command_line.h" +#include "base/compiler_specific.h" +#include "base/containers/hash_tables.h" +#include "base/files/file_path.h" +#include "base/files/file_util.h" +#include "base/logging.h" +#include "base/memory/linked_ptr.h" +#include "base/memory/scoped_vector.h" +#include "base/memory/weak_ptr.h" +#include "base/pickle.h" +#include "base/safe_strerror_posix.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/string_piece.h" +#include "base/strings/string_split.h" +#include "base/strings/string_util.h" +#include "base/strings/stringprintf.h" +#include "base/task_runner.h" +#include "base/threading/thread.h" +#include "tools/android/forwarder2/common.h" +#include "tools/android/forwarder2/daemon.h" +#include "tools/android/forwarder2/host_controller.h" +#include "tools/android/forwarder2/pipe_notifier.h" +#include "tools/android/forwarder2/socket.h" +#include "tools/android/forwarder2/util.h" + +namespace forwarder2 { +namespace { + +const char kLogFilePath[] = "/tmp/host_forwarder_log"; +const char kDaemonIdentifier[] = "chrome_host_forwarder_daemon"; + +const char kKillServerCommand[] = "kill-server"; +const char kForwardCommand[] = "forward"; + +const int kBufSize = 256; + +// Needs to be global to be able to be accessed from the signal handler. +PipeNotifier* g_notifier = NULL; + +// Lets the daemon fetch the exit notifier file descriptor. +int GetExitNotifierFD() { + DCHECK(g_notifier); + return g_notifier->receiver_fd(); +} + +void KillHandler(int signal_number) { + char buf[kBufSize]; + if (signal_number != SIGTERM && signal_number != SIGINT) { + snprintf(buf, sizeof(buf), "Ignoring unexpected signal %d.", signal_number); + SIGNAL_SAFE_LOG(WARNING, buf); + return; + } + snprintf(buf, sizeof(buf), "Received signal %d.", signal_number); + SIGNAL_SAFE_LOG(WARNING, buf); + static int s_kill_handler_count = 0; + CHECK(g_notifier); + // If for some reason the forwarder get stuck in any socket waiting forever, + // we can send a SIGKILL or SIGINT three times to force it die + // (non-nicely). This is useful when debugging. + ++s_kill_handler_count; + if (!g_notifier->Notify() || s_kill_handler_count > 2) + exit(1); +} + +// Manages HostController instances. There is one HostController instance for +// each connection being forwarded. Note that forwarding can happen with many +// devices (identified with a serial id). +class HostControllersManager { + public: + HostControllersManager() + : weak_ptr_factory_(this), + controllers_(new HostControllerMap()), + has_failed_(false) { + } + + ~HostControllersManager() { + if (!thread_.get()) + return; + // Delete the controllers on the thread they were created on. + thread_->message_loop_proxy()->DeleteSoon( + FROM_HERE, controllers_.release()); + } + + void HandleRequest(const std::string& device_serial, + int device_port, + int host_port, + scoped_ptr<Socket> client_socket) { + // Lazy initialize so that the CLI process doesn't get this thread created. + InitOnce(); + thread_->message_loop_proxy()->PostTask( + FROM_HERE, + base::Bind( + &HostControllersManager::HandleRequestOnInternalThread, + base::Unretained(this), device_serial, device_port, host_port, + base::Passed(&client_socket))); + } + + bool has_failed() const { return has_failed_; } + + private: + typedef base::hash_map< + std::string, linked_ptr<HostController> > HostControllerMap; + + static std::string MakeHostControllerMapKey(int adb_port, int device_port) { + return base::StringPrintf("%d:%d", adb_port, device_port); + } + + void InitOnce() { + if (thread_.get()) + return; + at_exit_manager_.reset(new base::AtExitManager()); + thread_.reset(new base::Thread("HostControllersManagerThread")); + thread_->Start(); + } + + // Invoked when a HostController instance reports an error (e.g. due to a + // device connectivity issue). Note that this could be called after the + // controller manager was destroyed which is why a weak pointer is used. + static void DeleteHostController( + const base::WeakPtr<HostControllersManager>& manager_ptr, + scoped_ptr<HostController> host_controller) { + HostController* const controller = host_controller.release(); + HostControllersManager* const manager = manager_ptr.get(); + if (!manager) { + // Note that |controller| is not leaked in this case since the host + // controllers manager owns the controllers. If the manager was deleted + // then all the controllers (including |controller|) were also deleted. + return; + } + DCHECK(manager->thread_->message_loop_proxy()->RunsTasksOnCurrentThread()); + // Note that this will delete |controller| which is owned by the map. + DeleteRefCountedValueInMap( + MakeHostControllerMapKey( + controller->adb_port(), controller->device_port()), + manager->controllers_.get()); + } + + void HandleRequestOnInternalThread(const std::string& device_serial, + int device_port, + int host_port, + scoped_ptr<Socket> client_socket) { + const int adb_port = GetAdbPortForDevice(device_serial); + if (adb_port < 0) { + SendMessage( + "ERROR: could not get adb port for device. You might need to add " + "'adb' to your PATH or provide the device serial id.", + client_socket.get()); + return; + } + if (device_port < 0) { + // Remove the previously created host controller. + const std::string controller_key = MakeHostControllerMapKey( + adb_port, -device_port); + const bool controller_did_exist = DeleteRefCountedValueInMap( + controller_key, controllers_.get()); + SendMessage( + !controller_did_exist ? "ERROR: could not unmap port" : "OK", + client_socket.get()); + + RemoveAdbPortForDeviceIfNeeded(device_serial); + return; + } + if (host_port < 0) { + SendMessage("ERROR: missing host port", client_socket.get()); + return; + } + const bool use_dynamic_port_allocation = device_port == 0; + if (!use_dynamic_port_allocation) { + const std::string controller_key = MakeHostControllerMapKey( + adb_port, device_port); + if (controllers_->find(controller_key) != controllers_->end()) { + LOG(INFO) << "Already forwarding device port " << device_port + << " to host port " << host_port; + SendMessage(base::StringPrintf("%d:%d", device_port, host_port), + client_socket.get()); + return; + } + } + // Create a new host controller. + scoped_ptr<HostController> host_controller( + HostController::Create( + device_port, host_port, adb_port, GetExitNotifierFD(), + base::Bind(&HostControllersManager::DeleteHostController, + weak_ptr_factory_.GetWeakPtr()))); + if (!host_controller.get()) { + has_failed_ = true; + SendMessage("ERROR: Connection to device failed.", client_socket.get()); + return; + } + // Get the current allocated port. + device_port = host_controller->device_port(); + LOG(INFO) << "Forwarding device port " << device_port << " to host port " + << host_port; + const std::string msg = base::StringPrintf("%d:%d", device_port, host_port); + if (!SendMessage(msg, client_socket.get())) + return; + host_controller->Start(); + controllers_->insert( + std::make_pair(MakeHostControllerMapKey(adb_port, device_port), + linked_ptr<HostController>(host_controller.release()))); + } + + void RemoveAdbPortForDeviceIfNeeded(const std::string& device_serial) { + base::hash_map<std::string, int>::const_iterator it = + device_serial_to_adb_port_map_.find(device_serial); + if (it == device_serial_to_adb_port_map_.end()) + return; + + int port = it->second; + const std::string prefix = base::StringPrintf("%d:", port); + for (HostControllerMap::const_iterator others = controllers_->begin(); + others != controllers_->end(); ++others) { + if (others->first.find(prefix) == 0U) + return; + } + // No other port is being forwarded to this device: + // - Remove it from our internal serial -> adb port map. + // - Remove from "adb forward" command. + LOG(INFO) << "Device " << device_serial << " has no more ports."; + device_serial_to_adb_port_map_.erase(device_serial); + const std::string serial_part = device_serial.empty() ? + std::string() : std::string("-s ") + device_serial; + const std::string command = base::StringPrintf( + "adb %s forward --remove tcp:%d", + serial_part.c_str(), + port); + const int ret = system(command.c_str()); + LOG(INFO) << command << " ret: " << ret; + // Wait for the socket to be fully unmapped. + const std::string port_mapped_cmd = base::StringPrintf( + "lsof -nPi:%d", + port); + const int poll_interval_us = 500 * 1000; + int retries = 3; + while (retries) { + const int port_unmapped = system(port_mapped_cmd.c_str()); + LOG(INFO) << "Device " << device_serial << " port " << port << " unmap " + << port_unmapped; + if (port_unmapped) + break; + --retries; + usleep(poll_interval_us); + } + } + + int GetAdbPortForDevice(const std::string& device_serial) { + base::hash_map<std::string, int>::const_iterator it = + device_serial_to_adb_port_map_.find(device_serial); + if (it != device_serial_to_adb_port_map_.end()) + return it->second; + Socket bind_socket; + CHECK(bind_socket.BindTcp("127.0.0.1", 0)); + const int port = bind_socket.GetPort(); + bind_socket.Close(); + const std::string serial_part = device_serial.empty() ? + std::string() : std::string("-s ") + device_serial; + const std::string command = base::StringPrintf( + "adb %s forward tcp:%d localabstract:chrome_device_forwarder", + serial_part.c_str(), + port); + LOG(INFO) << command; + const int ret = system(command.c_str()); + if (ret < 0 || !WIFEXITED(ret) || WEXITSTATUS(ret) != 0) + return -1; + device_serial_to_adb_port_map_[device_serial] = port; + return port; + } + + bool SendMessage(const std::string& msg, Socket* client_socket) { + bool result = client_socket->WriteString(msg); + DCHECK(result); + if (!result) + has_failed_ = true; + return result; + } + + base::WeakPtrFactory<HostControllersManager> weak_ptr_factory_; + base::hash_map<std::string, int> device_serial_to_adb_port_map_; + scoped_ptr<HostControllerMap> controllers_; + bool has_failed_; + scoped_ptr<base::AtExitManager> at_exit_manager_; // Needed by base::Thread. + scoped_ptr<base::Thread> thread_; +}; + +class ServerDelegate : public Daemon::ServerDelegate { + public: + ServerDelegate() : has_failed_(false) {} + + bool has_failed() const { + return has_failed_ || controllers_manager_.has_failed(); + } + + // Daemon::ServerDelegate: + virtual void Init() OVERRIDE { + LOG(INFO) << "Starting host process daemon (pid=" << getpid() << ")"; + DCHECK(!g_notifier); + g_notifier = new PipeNotifier(); + signal(SIGTERM, KillHandler); + signal(SIGINT, KillHandler); + } + + virtual void OnClientConnected(scoped_ptr<Socket> client_socket) OVERRIDE { + char buf[kBufSize]; + const int bytes_read = client_socket->Read(buf, sizeof(buf)); + if (bytes_read <= 0) { + if (client_socket->DidReceiveEvent()) + return; + PError("Read()"); + has_failed_ = true; + return; + } + const Pickle command_pickle(buf, bytes_read); + PickleIterator pickle_it(command_pickle); + std::string device_serial; + CHECK(pickle_it.ReadString(&device_serial)); + int device_port; + if (!pickle_it.ReadInt(&device_port)) { + client_socket->WriteString("ERROR: missing device port"); + return; + } + int host_port; + if (!pickle_it.ReadInt(&host_port)) + host_port = -1; + controllers_manager_.HandleRequest( + device_serial, device_port, host_port, client_socket.Pass()); + } + + private: + bool has_failed_; + HostControllersManager controllers_manager_; + + DISALLOW_COPY_AND_ASSIGN(ServerDelegate); +}; + +class ClientDelegate : public Daemon::ClientDelegate { + public: + ClientDelegate(const Pickle& command_pickle) + : command_pickle_(command_pickle), + has_failed_(false) { + } + + bool has_failed() const { return has_failed_; } + + // Daemon::ClientDelegate: + virtual void OnDaemonReady(Socket* daemon_socket) OVERRIDE { + // Send the forward command to the daemon. + CHECK_EQ(command_pickle_.size(), + daemon_socket->WriteNumBytes(command_pickle_.data(), + command_pickle_.size())); + char buf[kBufSize]; + const int bytes_read = daemon_socket->Read( + buf, sizeof(buf) - 1 /* leave space for null terminator */); + CHECK_GT(bytes_read, 0); + DCHECK(bytes_read < sizeof(buf)); + buf[bytes_read] = 0; + base::StringPiece msg(buf, bytes_read); + if (msg.starts_with("ERROR")) { + LOG(ERROR) << msg; + has_failed_ = true; + return; + } + printf("%s\n", buf); + } + + private: + const Pickle command_pickle_; + bool has_failed_; +}; + +void ExitWithUsage() { + std::cerr << "Usage: host_forwarder [options]\n\n" + "Options:\n" + " --serial-id=[0-9A-Z]{16}]\n" + " --map DEVICE_PORT HOST_PORT\n" + " --unmap DEVICE_PORT\n" + " --kill-server\n"; + exit(1); +} + +int PortToInt(const std::string& s) { + int value; + // Note that 0 is a valid port (used for dynamic port allocation). + if (!base::StringToInt(s, &value) || value < 0 || + value > std::numeric_limits<uint16>::max()) { + LOG(ERROR) << "Could not convert string " << s << " to port"; + ExitWithUsage(); + } + return value; +} + +int RunHostForwarder(int argc, char** argv) { + CommandLine::Init(argc, argv); + const CommandLine& cmd_line = *CommandLine::ForCurrentProcess(); + bool kill_server = false; + + Pickle pickle; + pickle.WriteString( + cmd_line.HasSwitch("serial-id") ? + cmd_line.GetSwitchValueASCII("serial-id") : std::string()); + + const std::vector<std::string> args = cmd_line.GetArgs(); + if (cmd_line.HasSwitch("kill-server")) { + kill_server = true; + } else if (cmd_line.HasSwitch("unmap")) { + if (args.size() != 1) + ExitWithUsage(); + // Note the minus sign below. + pickle.WriteInt(-PortToInt(args[0])); + } else if (cmd_line.HasSwitch("map")) { + if (args.size() != 2) + ExitWithUsage(); + pickle.WriteInt(PortToInt(args[0])); + pickle.WriteInt(PortToInt(args[1])); + } else { + ExitWithUsage(); + } + + if (kill_server && args.size() > 0) + ExitWithUsage(); + + ClientDelegate client_delegate(pickle); + ServerDelegate daemon_delegate; + Daemon daemon( + kLogFilePath, kDaemonIdentifier, &client_delegate, &daemon_delegate, + &GetExitNotifierFD); + + if (kill_server) + return !daemon.Kill(); + if (!daemon.SpawnIfNeeded()) + return 1; + + return client_delegate.has_failed() || daemon_delegate.has_failed(); +} + +} // namespace +} // namespace forwarder2 + +int main(int argc, char** argv) { + return forwarder2::RunHostForwarder(argc, argv); +}
diff --git a/tools/android/forwarder2/pipe_notifier.cc b/tools/android/forwarder2/pipe_notifier.cc new file mode 100644 index 0000000..02842bd --- /dev/null +++ b/tools/android/forwarder2/pipe_notifier.cc
@@ -0,0 +1,54 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/pipe_notifier.h" + +#include <fcntl.h> +#include <unistd.h> +#include <sys/socket.h> +#include <sys/types.h> + +#include "base/logging.h" +#include "base/posix/eintr_wrapper.h" +#include "base/safe_strerror_posix.h" + +namespace forwarder2 { + +PipeNotifier::PipeNotifier() { + int pipe_fd[2]; + int ret = pipe(pipe_fd); + CHECK_EQ(0, ret); + receiver_fd_ = pipe_fd[0]; + sender_fd_ = pipe_fd[1]; + fcntl(sender_fd_, F_SETFL, O_NONBLOCK); +} + +PipeNotifier::~PipeNotifier() { + close(receiver_fd_); + close(sender_fd_); +} + +bool PipeNotifier::Notify() { + CHECK_NE(-1, sender_fd_); + errno = 0; + int ret = HANDLE_EINTR(write(sender_fd_, "1", 1)); + if (ret < 0) { + PLOG(ERROR) << "write"; + return false; + } + return true; +} + +void PipeNotifier::Reset() { + char c; + int ret = HANDLE_EINTR(read(receiver_fd_, &c, 1)); + if (ret < 0) { + PLOG(ERROR) << "read"; + return; + } + DCHECK_EQ(1, ret); + DCHECK_EQ('1', c); +} + +} // namespace forwarder
diff --git a/tools/android/forwarder2/pipe_notifier.h b/tools/android/forwarder2/pipe_notifier.h new file mode 100644 index 0000000..aadb269 --- /dev/null +++ b/tools/android/forwarder2/pipe_notifier.h
@@ -0,0 +1,37 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_PIPE_NOTIFIER_H_ +#define TOOLS_ANDROID_FORWARDER2_PIPE_NOTIFIER_H_ + +#include "base/basictypes.h" + +namespace forwarder2 { + +// Helper class used to create a unix pipe that sends notifications to the +// |receiver_fd_| file descriptor when called |Notify()|. This should be used +// by the main thread to notify other threads that it must exit. +// The |receiver_fd_| can be put into a fd_set and used in a select together +// with a socket waiting to accept or read. +class PipeNotifier { + public: + PipeNotifier(); + ~PipeNotifier(); + + bool Notify(); + + int receiver_fd() const { return receiver_fd_; } + + void Reset(); + + private: + int sender_fd_; + int receiver_fd_; + + DISALLOW_COPY_AND_ASSIGN(PipeNotifier); +}; + +} // namespace forwarder + +#endif // TOOLS_ANDROID_FORWARDER2_PIPE_NOTIFIER_H_
diff --git a/tools/android/forwarder2/self_deleter_helper.h b/tools/android/forwarder2/self_deleter_helper.h new file mode 100644 index 0000000..d96903d --- /dev/null +++ b/tools/android/forwarder2/self_deleter_helper.h
@@ -0,0 +1,141 @@ +// 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_SELF_DELETER_HELPER_H_ +#define TOOLS_ANDROID_FORWARDER2_SELF_DELETER_HELPER_H_ + +#include "base/basictypes.h" +#include "base/bind.h" +#include "base/callback.h" +#include "base/location.h" +#include "base/logging.h" +#include "base/memory/ref_counted.h" +#include "base/memory/scoped_ptr.h" +#include "base/memory/weak_ptr.h" +#include "base/message_loop/message_loop_proxy.h" + +namespace base { + +class SingleThreadTaskRunner; + +} // namespace base + +namespace forwarder2 { + +// Helper template class to be used in the following case: +// * T is the type of an object that implements some work through an internal +// or worker thread. +// * T wants the internal thread to invoke deletion of its own instance, on +// the thread where the instance was created. +// +// To make this easier, do something like: +// 1) Add a SelfDeleteHelper<T> member to your class T, and default-initialize +// it in its constructor. +// 2) In the internal thread, to trigger self-deletion, call the +// MaybeDeleteSoon() method on this member. +// +// MaybeDeleteSoon() posts a task on the message loop where the T instance was +// created to delete it. The task will be safely ignored if the instance is +// otherwise deleted. +// +// Usage example: +// class Object { +// public: +// typedef base::Callback<void (scoped_ptr<Object>)> ErrorCallback; +// +// Object(const ErrorCallback& error_callback) +// : self_deleter_helper_(this, error_callback) { +// } +// +// void StartWork() { +// // Post a callback to DoSomethingOnWorkerThread() below to another +// // thread. +// } +// +// void DoSomethingOnWorkerThread() { +// ... +// if (error_happened) +// self_deleter_helper_.MaybeDeleteSoon(); +// } +// +// private: +// SelfDeleterHelper<MySelfDeletingClass> self_deleter_helper_; +// }; +// +// class ObjectOwner { +// public: +// ObjectOwner() +// : object_(new Object(base::Bind(&ObjectOwner::DeleteObjectOnError, +// base::Unretained(this))) { +// // To keep this example simple base::Unretained(this) is used above but +// // note that in a real world scenario the client would have to make sure +// // that the ObjectOwner instance is still alive when +// // DeleteObjectOnError() gets called below. This can be achieved by +// // using a WeakPtr<ObjectOwner> for instance. +// } +// +// void StartWork() { +// object_->StartWork(); +// } +// +// private: +// void DeleteObjectOnError(scoped_ptr<Object> object) { +// DCHECK(thread_checker_.CalledOnValidThread()); +// DCHECK_EQ(object_, object); +// // Do some extra work with |object| before it gets deleted... +// object_.reset(); +// ignore_result(object.release()); +// } +// +// base::ThreadChecker thread_checker_; +// scoped_ptr<Object> object_; +// }; +// +template <typename T> +class SelfDeleterHelper { + public: + typedef base::Callback<void (scoped_ptr<T>)> DeletionCallback; + + SelfDeleterHelper(T* self_deleting_object, + const DeletionCallback& deletion_callback) + : construction_runner_(base::MessageLoopProxy::current()), + self_deleting_object_(self_deleting_object), + deletion_callback_(deletion_callback), + weak_ptr_factory_(this) { + } + + ~SelfDeleterHelper() { + DCHECK(construction_runner_->RunsTasksOnCurrentThread()); + } + + void MaybeSelfDeleteSoon() { + DCHECK(!construction_runner_->RunsTasksOnCurrentThread()); + construction_runner_->PostTask( + FROM_HERE, + base::Bind(&SelfDeleterHelper::SelfDelete, + weak_ptr_factory_.GetWeakPtr())); + } + + private: + void SelfDelete() { + DCHECK(construction_runner_->RunsTasksOnCurrentThread()); + deletion_callback_.Run(make_scoped_ptr(self_deleting_object_)); + } + + const scoped_refptr<base::SingleThreadTaskRunner> construction_runner_; + T* const self_deleting_object_; + const DeletionCallback deletion_callback_; + + //WeakPtrFactory's documentation says: + // Member variables should appear before the WeakPtrFactory, to ensure + // that any WeakPtrs to Controller are invalidated before its members + // variable's destructors are executed, rendering them invalid. + base::WeakPtrFactory<SelfDeleterHelper<T> > weak_ptr_factory_; + + DISALLOW_COPY_AND_ASSIGN(SelfDeleterHelper); +}; + +} // namespace forwarder2 + +#endif // TOOLS_ANDROID_FORWARDER2_SELF_DELETER_HELPER_H_
diff --git a/tools/android/forwarder2/socket.cc b/tools/android/forwarder2/socket.cc new file mode 100644 index 0000000..9feac84 --- /dev/null +++ b/tools/android/forwarder2/socket.cc
@@ -0,0 +1,448 @@ +// Copyright (c) 2012 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. + +#include "tools/android/forwarder2/socket.h" + +#include <arpa/inet.h> +#include <fcntl.h> +#include <netdb.h> +#include <netinet/in.h> +#include <stdio.h> +#include <string.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <unistd.h> + +#include "base/logging.h" +#include "base/posix/eintr_wrapper.h" +#include "base/safe_strerror_posix.h" +#include "tools/android/common/net.h" +#include "tools/android/forwarder2/common.h" + +namespace { +const int kNoTimeout = -1; +const int kConnectTimeOut = 10; // Seconds. + +bool FamilyIsTCP(int family) { + return family == AF_INET || family == AF_INET6; +} +} // namespace + +namespace forwarder2 { + +bool Socket::BindUnix(const std::string& path) { + errno = 0; + if (!InitUnixSocket(path) || !BindAndListen()) { + Close(); + return false; + } + return true; +} + +bool Socket::BindTcp(const std::string& host, int port) { + errno = 0; + if (!InitTcpSocket(host, port) || !BindAndListen()) { + Close(); + return false; + } + return true; +} + +bool Socket::ConnectUnix(const std::string& path) { + errno = 0; + if (!InitUnixSocket(path) || !Connect()) { + Close(); + return false; + } + return true; +} + +bool Socket::ConnectTcp(const std::string& host, int port) { + errno = 0; + if (!InitTcpSocket(host, port) || !Connect()) { + Close(); + return false; + } + return true; +} + +Socket::Socket() + : socket_(-1), + port_(0), + socket_error_(false), + family_(AF_INET), + addr_ptr_(reinterpret_cast<sockaddr*>(&addr_.addr4)), + addr_len_(sizeof(sockaddr)) { + memset(&addr_, 0, sizeof(addr_)); +} + +Socket::~Socket() { + Close(); +} + +void Socket::Shutdown() { + if (!IsClosed()) { + PRESERVE_ERRNO_HANDLE_EINTR(shutdown(socket_, SHUT_RDWR)); + } +} + +void Socket::Close() { + if (!IsClosed()) { + CloseFD(socket_); + socket_ = -1; + } +} + +bool Socket::InitSocketInternal() { + socket_ = socket(family_, SOCK_STREAM, 0); + if (socket_ < 0) { + PLOG(ERROR) << "socket"; + return false; + } + tools::DisableNagle(socket_); + int reuse_addr = 1; + setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &reuse_addr, + sizeof(reuse_addr)); + if (!SetNonBlocking()) + return false; + return true; +} + +bool Socket::SetNonBlocking() { + const int flags = fcntl(socket_, F_GETFL); + if (flags < 0) { + PLOG(ERROR) << "fcntl"; + return false; + } + if (flags & O_NONBLOCK) + return true; + if (fcntl(socket_, F_SETFL, flags | O_NONBLOCK) < 0) { + PLOG(ERROR) << "fcntl"; + return false; + } + return true; +} + +bool Socket::InitUnixSocket(const std::string& path) { + static const size_t kPathMax = sizeof(addr_.addr_un.sun_path); + // For abstract sockets we need one extra byte for the leading zero. + if (path.size() + 2 /* '\0' */ > kPathMax) { + LOG(ERROR) << "The provided path is too big to create a unix " + << "domain socket: " << path; + return false; + } + family_ = PF_UNIX; + addr_.addr_un.sun_family = family_; + // Copied from net/socket/unix_domain_socket_posix.cc + // Convert the path given into abstract socket name. It must start with + // the '\0' character, so we are adding it. |addr_len| must specify the + // length of the structure exactly, as potentially the socket name may + // have '\0' characters embedded (although we don't support this). + // Note that addr_.addr_un.sun_path is already zero initialized. + memcpy(addr_.addr_un.sun_path + 1, path.c_str(), path.size()); + addr_len_ = path.size() + offsetof(struct sockaddr_un, sun_path) + 1; + addr_ptr_ = reinterpret_cast<sockaddr*>(&addr_.addr_un); + return InitSocketInternal(); +} + +bool Socket::InitTcpSocket(const std::string& host, int port) { + port_ = port; + if (host.empty()) { + // Use localhost: INADDR_LOOPBACK + family_ = AF_INET; + addr_.addr4.sin_family = family_; + addr_.addr4.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + } else if (!Resolve(host)) { + return false; + } + CHECK(FamilyIsTCP(family_)) << "Invalid socket family."; + if (family_ == AF_INET) { + addr_.addr4.sin_port = htons(port_); + addr_ptr_ = reinterpret_cast<sockaddr*>(&addr_.addr4); + addr_len_ = sizeof(addr_.addr4); + } else if (family_ == AF_INET6) { + addr_.addr6.sin6_port = htons(port_); + addr_ptr_ = reinterpret_cast<sockaddr*>(&addr_.addr6); + addr_len_ = sizeof(addr_.addr6); + } + return InitSocketInternal(); +} + +bool Socket::BindAndListen() { + errno = 0; + if (HANDLE_EINTR(bind(socket_, addr_ptr_, addr_len_)) < 0 || + HANDLE_EINTR(listen(socket_, SOMAXCONN)) < 0) { + PLOG(ERROR) << "bind/listen"; + SetSocketError(); + return false; + } + if (port_ == 0 && FamilyIsTCP(family_)) { + SockAddr addr; + memset(&addr, 0, sizeof(addr)); + socklen_t addrlen = 0; + sockaddr* addr_ptr = NULL; + uint16* port_ptr = NULL; + if (family_ == AF_INET) { + addr_ptr = reinterpret_cast<sockaddr*>(&addr.addr4); + port_ptr = &addr.addr4.sin_port; + addrlen = sizeof(addr.addr4); + } else if (family_ == AF_INET6) { + addr_ptr = reinterpret_cast<sockaddr*>(&addr.addr6); + port_ptr = &addr.addr6.sin6_port; + addrlen = sizeof(addr.addr6); + } + errno = 0; + if (getsockname(socket_, addr_ptr, &addrlen) != 0) { + PLOG(ERROR) << "getsockname"; + SetSocketError(); + return false; + } + port_ = ntohs(*port_ptr); + } + return true; +} + +bool Socket::Accept(Socket* new_socket) { + DCHECK(new_socket != NULL); + if (!WaitForEvent(READ, kNoTimeout)) { + SetSocketError(); + return false; + } + errno = 0; + int new_socket_fd = HANDLE_EINTR(accept(socket_, NULL, NULL)); + if (new_socket_fd < 0) { + SetSocketError(); + return false; + } + tools::DisableNagle(new_socket_fd); + new_socket->socket_ = new_socket_fd; + if (!new_socket->SetNonBlocking()) + return false; + return true; +} + +bool Socket::Connect() { + DCHECK(fcntl(socket_, F_GETFL) & O_NONBLOCK); + errno = 0; + if (HANDLE_EINTR(connect(socket_, addr_ptr_, addr_len_)) < 0 && + errno != EINPROGRESS) { + SetSocketError(); + return false; + } + // Wait for connection to complete, or receive a notification. + if (!WaitForEvent(WRITE, kConnectTimeOut)) { + SetSocketError(); + return false; + } + int socket_errno; + socklen_t opt_len = sizeof(socket_errno); + if (getsockopt(socket_, SOL_SOCKET, SO_ERROR, &socket_errno, &opt_len) < 0) { + PLOG(ERROR) << "getsockopt()"; + SetSocketError(); + return false; + } + if (socket_errno != 0) { + LOG(ERROR) << "Could not connect to host: " << safe_strerror(socket_errno); + SetSocketError(); + return false; + } + return true; +} + +bool Socket::Resolve(const std::string& host) { + struct addrinfo hints; + struct addrinfo* res; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags |= AI_CANONNAME; + + int errcode = getaddrinfo(host.c_str(), NULL, &hints, &res); + if (errcode != 0) { + errno = 0; + SetSocketError(); + freeaddrinfo(res); + return false; + } + family_ = res->ai_family; + switch (res->ai_family) { + case AF_INET: + memcpy(&addr_.addr4, + reinterpret_cast<sockaddr_in*>(res->ai_addr), + sizeof(sockaddr_in)); + break; + case AF_INET6: + memcpy(&addr_.addr6, + reinterpret_cast<sockaddr_in6*>(res->ai_addr), + sizeof(sockaddr_in6)); + break; + } + freeaddrinfo(res); + return true; +} + +int Socket::GetPort() { + if (!FamilyIsTCP(family_)) { + LOG(ERROR) << "Can't call GetPort() on an unix domain socket."; + return 0; + } + return port_; +} + +int Socket::ReadNumBytes(void* buffer, size_t num_bytes) { + int bytes_read = 0; + int ret = 1; + while (bytes_read < num_bytes && ret > 0) { + ret = Read(static_cast<char*>(buffer) + bytes_read, num_bytes - bytes_read); + if (ret >= 0) + bytes_read += ret; + } + return bytes_read; +} + +void Socket::SetSocketError() { + socket_error_ = true; + DCHECK_NE(EAGAIN, errno); + DCHECK_NE(EWOULDBLOCK, errno); + Close(); +} + +int Socket::Read(void* buffer, size_t buffer_size) { + if (!WaitForEvent(READ, kNoTimeout)) { + SetSocketError(); + return 0; + } + int ret = HANDLE_EINTR(read(socket_, buffer, buffer_size)); + if (ret < 0) { + PLOG(ERROR) << "read"; + SetSocketError(); + } + return ret; +} + +int Socket::NonBlockingRead(void* buffer, size_t buffer_size) { + DCHECK(fcntl(socket_, F_GETFL) & O_NONBLOCK); + int ret = HANDLE_EINTR(read(socket_, buffer, buffer_size)); + if (ret < 0) { + PLOG(ERROR) << "read"; + SetSocketError(); + } + return ret; +} + +int Socket::Write(const void* buffer, size_t count) { + if (!WaitForEvent(WRITE, kNoTimeout)) { + SetSocketError(); + return 0; + } + int ret = HANDLE_EINTR(send(socket_, buffer, count, MSG_NOSIGNAL)); + if (ret < 0) { + PLOG(ERROR) << "send"; + SetSocketError(); + } + return ret; +} + +int Socket::NonBlockingWrite(const void* buffer, size_t count) { + DCHECK(fcntl(socket_, F_GETFL) & O_NONBLOCK); + int ret = HANDLE_EINTR(send(socket_, buffer, count, MSG_NOSIGNAL)); + if (ret < 0) { + PLOG(ERROR) << "send"; + SetSocketError(); + } + return ret; +} + +int Socket::WriteString(const std::string& buffer) { + return WriteNumBytes(buffer.c_str(), buffer.size()); +} + +void Socket::AddEventFd(int event_fd) { + Event event; + event.fd = event_fd; + event.was_fired = false; + events_.push_back(event); +} + +bool Socket::DidReceiveEventOnFd(int fd) const { + for (size_t i = 0; i < events_.size(); ++i) + if (events_[i].fd == fd) + return events_[i].was_fired; + return false; +} + +bool Socket::DidReceiveEvent() const { + for (size_t i = 0; i < events_.size(); ++i) + if (events_[i].was_fired) + return true; + return false; +} + +int Socket::WriteNumBytes(const void* buffer, size_t num_bytes) { + int bytes_written = 0; + int ret = 1; + while (bytes_written < num_bytes && ret > 0) { + ret = Write(static_cast<const char*>(buffer) + bytes_written, + num_bytes - bytes_written); + if (ret >= 0) + bytes_written += ret; + } + return bytes_written; +} + +bool Socket::WaitForEvent(EventType type, int timeout_secs) { + if (socket_ == -1) + return true; + DCHECK(fcntl(socket_, F_GETFL) & O_NONBLOCK); + fd_set read_fds; + fd_set write_fds; + FD_ZERO(&read_fds); + FD_ZERO(&write_fds); + if (type == READ) + FD_SET(socket_, &read_fds); + else + FD_SET(socket_, &write_fds); + for (size_t i = 0; i < events_.size(); ++i) + FD_SET(events_[i].fd, &read_fds); + timeval tv = {}; + timeval* tv_ptr = NULL; + if (timeout_secs > 0) { + tv.tv_sec = timeout_secs; + tv.tv_usec = 0; + tv_ptr = &tv; + } + int max_fd = socket_; + for (size_t i = 0; i < events_.size(); ++i) + if (events_[i].fd > max_fd) + max_fd = events_[i].fd; + if (HANDLE_EINTR( + select(max_fd + 1, &read_fds, &write_fds, NULL, tv_ptr)) <= 0) { + PLOG(ERROR) << "select"; + return false; + } + bool event_was_fired = false; + for (size_t i = 0; i < events_.size(); ++i) { + if (FD_ISSET(events_[i].fd, &read_fds)) { + events_[i].was_fired = true; + event_was_fired = true; + } + } + return !event_was_fired; +} + +// static +pid_t Socket::GetUnixDomainSocketProcessOwner(const std::string& path) { + Socket socket; + if (!socket.ConnectUnix(path)) + return -1; + ucred ucred; + socklen_t len = sizeof(ucred); + if (getsockopt(socket.socket_, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == -1) { + CHECK_NE(ENOPROTOOPT, errno); + return -1; + } + return ucred.pid; +} + +} // namespace forwarder2
diff --git a/tools/android/forwarder2/socket.h b/tools/android/forwarder2/socket.h new file mode 100644 index 0000000..6047a1c --- /dev/null +++ b/tools/android/forwarder2/socket.h
@@ -0,0 +1,152 @@ +// Copyright (c) 2012 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_SOCKET_H_ +#define TOOLS_ANDROID_FORWARDER2_SOCKET_H_ + +#include <fcntl.h> +#include <netinet/in.h> +#include <sys/socket.h> +#include <sys/un.h> + +#include <string> +#include <vector> + +#include "base/basictypes.h" + +namespace forwarder2 { + +// Wrapper class around unix socket api. Can be used to create, bind or +// connect to both Unix domain sockets and TCP sockets. +// TODO(pliard): Split this class into TCPSocket and UnixDomainSocket. +class Socket { + public: + Socket(); + ~Socket(); + + bool BindUnix(const std::string& path); + bool BindTcp(const std::string& host, int port); + bool ConnectUnix(const std::string& path); + bool ConnectTcp(const std::string& host, int port); + + // Just a wrapper around unix socket shutdown(), see man 2 shutdown. + void Shutdown(); + + // Just a wrapper around unix socket close(), see man 2 close. + void Close(); + bool IsClosed() const { return socket_ < 0; } + + int fd() const { return socket_; } + + bool Accept(Socket* new_socket); + + // Returns the port allocated to this socket or zero on error. + int GetPort(); + + // Just a wrapper around unix read() function. + // Reads up to buffer_size, but may read less then buffer_size. + // Returns the number of bytes read. + int Read(void* buffer, size_t buffer_size); + + // Non-blocking version of Read() above. This must be called after a + // successful call to select(). The socket must also be in non-blocking mode + // before calling this method. + int NonBlockingRead(void* buffer, size_t buffer_size); + + // Wrapper around send(). + int Write(const void* buffer, size_t count); + + // Same as NonBlockingRead() but for writing. + int NonBlockingWrite(const void* buffer, size_t count); + + // Calls Read() multiple times until num_bytes is written to the provided + // buffer. No bounds checking is performed. + // Returns number of bytes read, which can be different from num_bytes in case + // of errror. + int ReadNumBytes(void* buffer, size_t num_bytes); + + // Calls Write() multiple times until num_bytes is written. No bounds checking + // is performed. Returns number of bytes written, which can be different from + // num_bytes in case of errror. + int WriteNumBytes(const void* buffer, size_t num_bytes); + + // Calls WriteNumBytes for the given std::string. Note that the null + // terminator is not written to the socket. + int WriteString(const std::string& buffer); + + bool has_error() const { return socket_error_; } + + // |event_fd| must be a valid pipe file descriptor created from the + // PipeNotifier and must live (not be closed) at least as long as this socket + // is alive. + void AddEventFd(int event_fd); + + // Returns whether Accept() or Connect() was interrupted because the socket + // received an external event fired through the provided fd. + bool DidReceiveEventOnFd(int fd) const; + + bool DidReceiveEvent() const; + + static pid_t GetUnixDomainSocketProcessOwner(const std::string& path); + + private: + enum EventType { + READ, + WRITE + }; + + union SockAddr { + // IPv4 sockaddr + sockaddr_in addr4; + // IPv6 sockaddr + sockaddr_in6 addr6; + // Unix Domain sockaddr + sockaddr_un addr_un; + }; + + struct Event { + int fd; + bool was_fired; + }; + + bool SetNonBlocking(); + + // If |host| is empty, use localhost. + bool InitTcpSocket(const std::string& host, int port); + bool InitUnixSocket(const std::string& path); + bool BindAndListen(); + bool Connect(); + + bool Resolve(const std::string& host); + bool InitSocketInternal(); + void SetSocketError(); + + // Waits until either the Socket or the |exit_notifier_fd_| has received an + // event. + bool WaitForEvent(EventType type, int timeout_secs); + + int socket_; + int port_; + bool socket_error_; + + // Family of the socket (PF_INET, PF_INET6 or PF_UNIX). + int family_; + + SockAddr addr_; + + // Points to one of the members of the above union depending on the family. + sockaddr* addr_ptr_; + // Length of one of the members of the above union depending on the family. + socklen_t addr_len_; + + // Used to listen for external events (e.g. process received a SIGTERM) while + // blocking on I/O operations. + std::vector<Event> events_; + + DISALLOW_COPY_AND_ASSIGN(Socket); +}; + +} // namespace forwarder + +#endif // TOOLS_ANDROID_FORWARDER2_SOCKET_H_
diff --git a/tools/android/forwarder2/util.h b/tools/android/forwarder2/util.h new file mode 100644 index 0000000..9947628 --- /dev/null +++ b/tools/android/forwarder2/util.h
@@ -0,0 +1,36 @@ +// 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. + +#ifndef TOOLS_ANDROID_FORWARDER2_UTIL_H_ +#define TOOLS_ANDROID_FORWARDER2_UTIL_H_ + +#include "base/logging.h" + +namespace forwarder2 { + +// Safely deletes a ref-counted value in a provided map by unlinking the object +// from the map before deleting it in case its destructor would access the map. +// Deletion will only happen by definition if the object's refcount is set to 1 +// before this function gets called. Returns whether the element could be found +// in the map. +template <typename Map, typename K> +bool DeleteRefCountedValueInMap(const K& key, Map* map) { + const typename Map::iterator it = map->find(key); + if (it == map->end()) + return false; + DeleteRefCountedValueInMapFromIterator(it, map); + return true; +} + +// See DeleteRefCountedValuetInMap() above. +template <typename Map, typename Iterator> +void DeleteRefCountedValueInMapFromIterator(Iterator it, Map* map) { + DCHECK(it != map->end()); + const typename Map::value_type::second_type shared_ptr_copy = it->second; + map->erase(it); +} + +} // namespace forwarder2 + +#endif // TOOLS_ANDROID_FORWARDER2_UTIL_H_
diff --git a/tools/android/heap_profiler/DEPS b/tools/android/heap_profiler/DEPS new file mode 100644 index 0000000..458e541 --- /dev/null +++ b/tools/android/heap_profiler/DEPS
@@ -0,0 +1,3 @@ +include_rules = [ + "+third_party/bsdtrees", +]
diff --git a/tools/android/heap_profiler/heap_dump.c b/tools/android/heap_profiler/heap_dump.c new file mode 100644 index 0000000..5d468da --- /dev/null +++ b/tools/android/heap_profiler/heap_dump.c
@@ -0,0 +1,350 @@ +// Copyright 2014 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. + +// The client dump tool for libheap_profiler. It attaches to a process (given +// its pid) and dumps all the libheap_profiler tracking information in JSON. +// The JSON output looks like this: +// { +// "total_allocated": 908748493, # Total bytes allocated and not freed. +// "num_allocs": 37542, # Number of allocations. +// "num_stacks": 3723, # Number of allocation call-sites. +// "allocs": # Optional. Printed only with the -x arg. +// { +// "beef1234": {"l": 17, "f": 1, "s": "1a"}, +// ^ ^ ^ ^ Index of the corresponding entry in the +// | | | next "stacks" section. Essentially a ref +// | | | to the call site that created the alloc. +// | | | +// | | +-------> Flags (last arg of heap_profiler_alloc). +// | +----------------> Length of the Alloc. +// +-----------------------------> Start address of the Alloc (hex). +// }, +// "stacks": +// { +// "1a": {"l": 17, "f": [1074792772, 1100849864, 1100850688, ...]}, +// ^ ^ ^ +// | | +-----> Stack frames (absolute virtual addresses). +// | +--------------> Bytes allocated and not freed by the call site. +// +---------------------> Index of the entry (as for "allocs" xref). +// Indexes are hex and might not be monotonic. + +#include <errno.h> +#include <fcntl.h> +#include <inttypes.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <sys/ptrace.h> +#include <sys/stat.h> + +#include "tools/android/heap_profiler/heap_profiler.h" + + +static void lseek_abs(int fd, size_t off); +static void read_proc_cmdline(char* cmdline, int size); +static ssize_t read_safe(int fd, void* buf, size_t count); + +static int pid; + + +static int dump_process_heap( + int mem_fd, + FILE* fmaps, + bool dump_also_allocs, + bool pedantic, // Enable pedantic consistency checks on memory counters. + char* comment) { + HeapStats stats; + time_t tm; + char cmdline[512]; + + tm = time(NULL); + read_proc_cmdline(cmdline, sizeof(cmdline)); + + // Look for the mmap which contains the HeapStats in the target process vmem. + // On Linux/Android, the libheap_profiler mmaps explicitly /dev/zero. The + // region furthermore starts with a magic marker to disambiguate. + bool stats_mmap_found = false; + for (;;) { + char line[1024]; + if (fgets(line, sizeof(line), fmaps) == NULL) + break; + + uintptr_t start; + uintptr_t end; + char map_file[32]; + int ret = sscanf(line, "%"SCNxPTR"-%"SCNxPTR" rw-p %*s %*s %*s %31s", + &start, &end, map_file); + const size_t size = end - start + 1; + if (ret != 3 || strcmp(map_file, "/dev/zero") != 0 || size < sizeof(stats)) + continue; + + // The mmap looks promising. Let's check for the magic marker. + lseek_abs(mem_fd, start); + ssize_t rsize = read_safe(mem_fd, &stats, sizeof(stats)); + + if (rsize == -1) { + perror("read"); + return -1; + } + + if (rsize < sizeof(stats)) + continue; + + if (stats.magic_start == HEAP_PROFILER_MAGIC_MARKER) { + stats_mmap_found = true; + break; + } + } + + if (!stats_mmap_found) { + fprintf(stderr, "Could not find the HeapStats area. " + "It looks like libheap_profiler is not loaded.\n"); + return -1; + } + + // Print JSON-formatted output. + printf("{\n"); + printf(" \"pid\": %d,\n", pid); + printf(" \"time\": %ld,\n", tm); + printf(" \"comment\": \"%s\",\n", comment); + printf(" \"cmdline\": \"%s\",\n", cmdline); + printf(" \"pagesize\": %d,\n", getpagesize()); + printf(" \"total_allocated\": %zu,\n", stats.total_alloc_bytes); + printf(" \"num_allocs\": %"PRIu32",\n", stats.num_allocs); + printf(" \"num_stacks\": %"PRIu32",\n", stats.num_stack_traces); + + uint32_t dbg_counted_allocs = 0; + size_t dbg_counted_total_alloc_bytes = 0; + bool prepend_trailing_comma = false; // JSON syntax, I hate you. + uint32_t i; + + // Dump the optional allocation table. + if (dump_also_allocs) { + printf(" \"allocs\": {"); + lseek_abs(mem_fd, (uintptr_t) stats.allocs); + for (i = 0; i < stats.max_allocs; ++i) { + Alloc alloc; + if (read_safe(mem_fd, &alloc, sizeof(alloc)) != sizeof(alloc)) { + fprintf(stderr, "ERROR: cannot read allocation table\n"); + perror("read"); + return -1; + } + + // Skip empty (i.e. freed) entries. + if (alloc.start == 0 && alloc.end == 0) + continue; + + if (alloc.end < alloc.start) { + fprintf(stderr, "ERROR: found inconsistent alloc.\n"); + return -1; + } + + size_t alloc_size = alloc.end - alloc.start + 1; + size_t stack_idx = ( + (uintptr_t) alloc.st - (uintptr_t) stats.stack_traces) / + sizeof(StacktraceEntry); + dbg_counted_total_alloc_bytes += alloc_size; + ++dbg_counted_allocs; + + if (prepend_trailing_comma) + printf(","); + prepend_trailing_comma = true; + printf("\"%"PRIxPTR"\": {\"l\": %zu, \"f\": %"PRIu32", \"s\": \"%zx\"}", + alloc.start, alloc_size, alloc.flags, stack_idx); + } + printf("},\n"); + + if (pedantic && dbg_counted_allocs != stats.num_allocs) { + fprintf(stderr, + "ERROR: inconsistent alloc count (%"PRIu32" vs %"PRIu32").\n", + dbg_counted_allocs, stats.num_allocs); + return -1; + } + + if (pedantic && dbg_counted_total_alloc_bytes != stats.total_alloc_bytes) { + fprintf(stderr, "ERROR: inconsistent alloc totals (%zu vs %zu).\n", + dbg_counted_total_alloc_bytes, stats.total_alloc_bytes); + return -1; + } + } + + // Dump the distinct stack traces. + printf(" \"stacks\": {"); + prepend_trailing_comma = false; + dbg_counted_total_alloc_bytes = 0; + lseek_abs(mem_fd, (uintptr_t) stats.stack_traces); + for (i = 0; i < stats.max_stack_traces; ++i) { + StacktraceEntry st; + if (read_safe(mem_fd, &st, sizeof(st)) != sizeof(st)) { + fprintf(stderr, "ERROR: cannot read stack trace table\n"); + perror("read"); + return -1; + } + + // Skip empty (i.e. freed) entries. + if (st.alloc_bytes == 0) + continue; + + dbg_counted_total_alloc_bytes += st.alloc_bytes; + + if (prepend_trailing_comma) + printf(","); + prepend_trailing_comma = true; + + printf("\"%"PRIx32"\":{\"l\": %zu, \"f\": [", i, st.alloc_bytes); + size_t n = 0; + for (;;) { + printf("%" PRIuPTR, st.frames[n]); + ++n; + if (n == HEAP_PROFILER_MAX_DEPTH || st.frames[n] == 0) + break; + else + printf(","); + } + printf("]}"); + } + printf("}\n}\n"); + + if (pedantic && dbg_counted_total_alloc_bytes != stats.total_alloc_bytes) { + fprintf(stderr, "ERROR: inconsistent stacks totals (%zu vs %zu).\n", + dbg_counted_total_alloc_bytes, stats.total_alloc_bytes); + return -1; + } + + fflush(stdout); + return 0; +} + +// Unfortunately lseek takes a *signed* offset, which is unsuitable for large +// files like /proc/X/mem on 64-bit. +static void lseek_abs(int fd, size_t off) { +#define OFF_T_MAX ((off_t) ~(((uint64_t) 1) << (8 * sizeof(off_t) - 1))) + if (off <= OFF_T_MAX) { + lseek(fd, (off_t) off, SEEK_SET); + return; + } + lseek(fd, (off_t) OFF_T_MAX, SEEK_SET); + lseek(fd, (off_t) (off - OFF_T_MAX), SEEK_CUR); +} + +static ssize_t read_safe(int fd, void* buf, size_t count) { + ssize_t res; + size_t bytes_read = 0; + if (count < 0) + return -1; + do { + do { + res = read(fd, buf + bytes_read, count - bytes_read); + } while (res == -1 && errno == EINTR); + if (res <= 0) + break; + bytes_read += res; + } while (bytes_read < count); + return bytes_read ? bytes_read : res; +} + +static int open_proc_mem_fd() { + char path[64]; + snprintf(path, sizeof(path), "/proc/%d/mem", pid); + int mem_fd = open(path, O_RDONLY); + if (mem_fd < 0) { + fprintf(stderr, "Could not attach to target process virtual memory.\n"); + perror("open"); + } + return mem_fd; +} + +static FILE* open_proc_maps() { + char path[64]; + snprintf(path, sizeof(path), "/proc/%d/maps", pid); + FILE* fmaps = fopen(path, "r"); + if (fmaps == NULL) { + fprintf(stderr, "Could not open %s.\n", path); + perror("fopen"); + } + return fmaps; +} + +static void read_proc_cmdline(char* cmdline, int size) { + char path[64]; + snprintf(path, sizeof(path), "/proc/%d/cmdline", pid); + int cmdline_fd = open(path, O_RDONLY); + if (cmdline_fd < 0) { + fprintf(stderr, "Could not open %s.\n", path); + perror("open"); + cmdline[0] = '\0'; + return; + } + int length = read_safe(cmdline_fd, cmdline, size); + if (length < 0) { + fprintf(stderr, "Could not read %s.\n", path); + perror("read"); + length = 0; + } + close(cmdline_fd); + cmdline[length] = '\0'; +} + +int main(int argc, char** argv) { + char c; + int ret = 0; + bool dump_also_allocs = false; + bool pedantic = true; + char comment[1024] = { '\0' }; + + while (((c = getopt(argc, argv, "xnc:")) & 0x80) == 0) { + switch (c) { + case 'x': + dump_also_allocs = true; + break; + case 'n': + pedantic = false; + break; + case 'c': + strlcpy(comment, optarg, sizeof(comment)); + break; + } + } + + if (optind >= argc) { + printf("Usage: %s [-n] [-x] [-c comment] pid\n" + " -n: Skip pedantic checks on dump consistency.\n" + " -x: Extended dump, includes individual allocations.\n" + " -c: Appends the given comment to the JSON dump.\n", + argv[0]); + return -1; + } + + pid = atoi(argv[optind]); + + if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) == -1) { + perror("ptrace"); + return -1; + } + + // Wait for the process to actually freeze. + waitpid(pid, NULL, 0); + + int mem_fd = open_proc_mem_fd(); + if (mem_fd < 0) + ret = -1; + + FILE* fmaps = open_proc_maps(); + if (fmaps == NULL) + ret = -1; + + if (ret == 0) + ret = dump_process_heap(mem_fd, fmaps, dump_also_allocs, pedantic, comment); + + ptrace(PTRACE_DETACH, pid, NULL, NULL); + + // Cleanup. + fflush(stdout); + close(mem_fd); + fclose(fmaps); + return ret; +}
diff --git a/tools/android/heap_profiler/heap_profiler.c b/tools/android/heap_profiler/heap_profiler.c new file mode 100644 index 0000000..aef63ba --- /dev/null +++ b/tools/android/heap_profiler/heap_profiler.c
@@ -0,0 +1,397 @@ +// Copyright 2014 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. + +// This is a OS-independent* module which purpose is tracking allocations and +// their call sites (stack traces). It is able to deal with hole punching +// (read: munmap). Also, it has low overhead and its presence in the system its +// barely noticeable, even if tracing *all* the processes. +// This module does NOT know how to deal with stack unwinding. The caller must +// do that and pass the addresses of the unwound stack. +// * (Modulo three lines for mutexes.) +// +// Exposed API: +// void heap_profiler_init(HeapStats*); +// void heap_profiler_alloc(addr, size, stack_frames, depth, flags); +// void heap_profiler_free(addr, size); (size == 0 means free entire region). +// +// The profiling information is tracked into two data structures: +// 1) A RB-Tree of non-overlapping VM regions (allocs) sorted by their start +// addr. Each entry tracks the start-end addresses and points to the stack +// trace which created that allocation (see below). +// 2) A (hash) table of stack traces. In general the #allocations >> #call sites +// which create those allocations. In order to avoid duplicating the latter, +// they are stored distinctly in this hash table and used by reference. +// +// / Process virtual address space \ +// +------+ +------+ +------+ +// |Alloc1| |Alloc2| |Alloc3| <- Allocs (a RB-Tree underneath) +// +------+ +------+ +------+ +// Len: 12 Len: 4 Len: 4 +// | | | stack_traces +// | | | +-----------+--------------+ +// | | | | Alloc tot | stack frames + +// | | | +-----------+--------------+ +// +------------|-------------+------------> | 16 | 0x1234 .... | +// | +-----------+--------------+ +// +--------------------------> | 4 | 0x5678 .... | +// +-----------+--------------+ +// (A hash-table underneath) +// +// Final note: the memory for both 1) and 2) entries is carved out from two +// static pools (i.e. stack_traces and allocs). The pools are treated as +// a sbrk essentially, and are kept compact by reusing freed elements (hence +// having a freelist for each of them). +// +// All the internal (static) functions here assume that the |lock| is held. + +#include <assert.h> +#include <string.h> + +// Platform-dependent mutex boilerplate. +#if defined(__linux__) || defined(__ANDROID__) +#include <pthread.h> +#define DEFINE_MUTEX(x) pthread_mutex_t x = PTHREAD_MUTEX_INITIALIZER +#define LOCK_MUTEX(x) pthread_mutex_lock(&x) +#define UNLOCK_MUTEX(x) pthread_mutex_unlock(&x) +#else +#error OS not supported. +#endif + +#include "tools/android/heap_profiler/heap_profiler.h" + + +static DEFINE_MUTEX(lock); + +// |stats| contains the global tracking metadata and is the entry point which +// is read by the heap_dump tool. +static HeapStats* stats; + +// +---------------------------------------------------------------------------+ +// + Stack traces hash-table + +// +---------------------------------------------------------------------------+ +#define ST_ENTRIES_MAX (64 * 1024) +#define ST_HASHTABLE_BUCKETS (64 * 1024) /* Must be a power of 2. */ + +static StacktraceEntry stack_traces[ST_ENTRIES_MAX]; +static StacktraceEntry* stack_traces_freelist; +static StacktraceEntry* stack_traces_ht[ST_HASHTABLE_BUCKETS]; + +// Looks up a stack trace from the stack frames. Creates a new one if necessary. +static StacktraceEntry* record_stacktrace(uintptr_t* frames, uint32_t depth) { + if (depth == 0) + return NULL; + + if (depth > HEAP_PROFILER_MAX_DEPTH) + depth = HEAP_PROFILER_MAX_DEPTH; + + uint32_t i; + uintptr_t hash = 0; + for (i = 0; i < depth; ++i) + hash = (hash << 1) ^ (frames[i]); + const uint32_t slot = hash & (ST_HASHTABLE_BUCKETS - 1); + StacktraceEntry* st = stack_traces_ht[slot]; + + // Look for an existing entry in the hash-table. + const size_t frames_length = depth * sizeof(uintptr_t); + while (st != NULL && st->hash != hash && + memcmp(frames, st->frames, frames_length) != 0) { + st = st->next; + } + + // If not found, create a new one from the stack_traces array and add it to + // the hash-table. + if (st == NULL) { + // Get a free element either from the freelist or from the pool. + if (stack_traces_freelist != NULL) { + st = stack_traces_freelist; + stack_traces_freelist = stack_traces_freelist->next; + } else if (stats->max_stack_traces < ST_ENTRIES_MAX) { + st = &stack_traces[stats->max_stack_traces]; + ++stats->max_stack_traces; + } else { + return NULL; + } + + memset(st, 0, sizeof(*st)); + memcpy(st->frames, frames, frames_length); + st->hash = hash; + st->next = stack_traces_ht[slot]; + stack_traces_ht[slot] = st; + ++stats->num_stack_traces; + } + + return st; +} + +// Frees up a stack trace and appends it to the corresponding freelist. +static void free_stacktrace(StacktraceEntry* st) { + assert(st->alloc_bytes == 0); + const uint32_t slot = st->hash & (ST_HASHTABLE_BUCKETS - 1); + + // The expected load factor of the hash-table is very low. Frees should be + // pretty rare. Hence don't bother with a doubly linked list, might cost more. + StacktraceEntry** prev = &stack_traces_ht[slot]; + while (*prev != st) + prev = &((*prev)->next); + + // Remove from the hash-table bucket. + assert(*prev == st); + *prev = st->next; + + // Add to the freelist. + st->next = stack_traces_freelist; + stack_traces_freelist = st; + --stats->num_stack_traces; +} + +// +---------------------------------------------------------------------------+ +// + Allocs RB-tree + +// +---------------------------------------------------------------------------+ +#define ALLOCS_ENTRIES_MAX (256 * 1024) + +static Alloc allocs[ALLOCS_ENTRIES_MAX]; +static Alloc* allocs_freelist; +static RB_HEAD(HeapEntriesTree, Alloc) allocs_tree = + RB_INITIALIZER(&allocs_tree); + +// Comparator used by the RB-Tree (mind the overflow, avoid arith on addresses). +static int allocs_tree_cmp(Alloc *alloc_1, Alloc *alloc_2) { + if (alloc_1->start < alloc_2->start) + return -1; + if (alloc_1->start > alloc_2->start) + return 1; + return 0; +} + +RB_PROTOTYPE(HeapEntriesTree, Alloc, rb_node, allocs_tree_cmp); +RB_GENERATE(HeapEntriesTree, Alloc, rb_node, allocs_tree_cmp); + +// Allocates a new Alloc and inserts it in the tree. +static Alloc* insert_alloc( + uintptr_t start, uintptr_t end, StacktraceEntry* st, uint32_t flags) { + Alloc* alloc = NULL; + + // First of all, get a free element either from the freelist or from the pool. + if (allocs_freelist != NULL) { + alloc = allocs_freelist; + allocs_freelist = alloc->next_free; + } else if (stats->max_allocs < ALLOCS_ENTRIES_MAX) { + alloc = &allocs[stats->max_allocs]; + ++stats->max_allocs; + } else { + return NULL; // OOM. + } + + alloc->start = start; + alloc->end = end; + alloc->st = st; + alloc->flags = flags; + alloc->next_free = NULL; + RB_INSERT(HeapEntriesTree, &allocs_tree, alloc); + ++stats->num_allocs; + return alloc; +} + +// Deletes all the allocs in the range [addr, addr+size[ dealing with partial +// frees and hole punching. Note that in the general case this function might +// need to deal with very unfortunate cases, as below: +// +// Alloc tree begin: [Alloc 1]----[Alloc 2]-------[Alloc 3][Alloc 4]---[Alloc 5] +// Deletion range: [xxxxxxxxxxxxxxxxxxxx] +// Alloc tree end: [Alloc 1]----[Al.2]----------------------[Al.4]---[Alloc 5] +// Alloc3 has to be deleted and Alloc 2,4 shrunk. +static uint32_t delete_allocs_in_range(void* addr, size_t size) { + uintptr_t del_start = (uintptr_t) addr; + uintptr_t del_end = del_start + size - 1; + uint32_t flags = 0; + + Alloc* alloc = NULL; + Alloc* next_alloc = RB_ROOT(&allocs_tree); + + // Lookup the first (by address) relevant Alloc to initiate the deletion walk. + // At the end of the loop next_alloc is either: + // - the closest alloc starting before (or exactly at) the start of the + // deletion range (i.e. addr == del_start). + // - the first alloc inside the deletion range. + // - the first alloc after the deletion range iff the range was already empty + // (in this case the next loop will just bail out doing nothing). + // - NULL: iff the entire tree is empty (as above). + while (next_alloc != NULL) { + alloc = next_alloc; + if (alloc->start > del_start) { + next_alloc = RB_LEFT(alloc, rb_node); + } else if (alloc->end < del_start) { + next_alloc = RB_RIGHT(alloc, rb_node); + } else { // alloc->start <= del_start && alloc->end >= del_start + break; + } + } + + // Now scan the allocs linearly deleting chunks (or eventually whole allocs) + // until passing the end of the deleting region. + next_alloc = alloc; + while (next_alloc != NULL) { + alloc = next_alloc; + next_alloc = RB_NEXT(HeapEntriesTree, &allocs_tree, alloc); + + if (size != 0) { + // In the general case we stop passed the end of the deletion range. + if (alloc->start > del_end) + break; + + // This deals with the case of the first Alloc laying before the range. + if (alloc->end < del_start) + continue; + } else { + // size == 0 is a special case. It means deleting only the alloc which + // starts exactly at |del_start| if any (for dealing with free(ptr)). + if (alloc->start > del_start) + break; + if (alloc->start < del_start) + continue; + del_end = alloc->end; + } + + // Reached this point the Alloc must overlap (partially or completely) with + // the deletion range. + assert(!(alloc->start > del_end || alloc->end < del_start)); + + StacktraceEntry* st = alloc->st; + flags |= alloc->flags; + uintptr_t freed_bytes = 0; // Bytes freed in this cycle. + + if (del_start <= alloc->start) { + if (del_end >= alloc->end) { + // Complete overlap. Delete full Alloc. Note: the range might might + // still overlap with the next allocs. + // Begin: ------[alloc.start alloc.end]-[next alloc] + // Del range: [xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] + // Result: ---------------------------------[next alloc] + // [next alloc] will be shrinked on the next iteration. + freed_bytes = alloc->end - alloc->start + 1; + RB_REMOVE(HeapEntriesTree, &allocs_tree, alloc); + + // Clean-up, so heap_dump can tell this is a free entry and skip it. + alloc->start = alloc->end = 0; + alloc->st = NULL; + + // Put in the freelist. + alloc->next_free = allocs_freelist; + allocs_freelist = alloc; + --stats->num_allocs; + } else { + // Partial overlap at beginning. Cut first part and shrink the alloc. + // Begin: ------[alloc.start alloc.end]-[next alloc] + // Del range: [xxxxxx] + // Result: ------------[start alloc.end]-[next alloc] + freed_bytes = del_end - alloc->start + 1; + alloc->start = del_end + 1; + // No need to update the tree even if we changed the key. The keys are + // still monotonic (because the ranges are guaranteed to not overlap). + } + } else { + if (del_end >= alloc->end) { + // Partial overlap at end. Cut last part and shrink the alloc left. + // Begin: ------[alloc.start alloc.end]-[next alloc] + // Del range: [xxxxxxxx] + // Result: ------[alloc.start alloc.end]-----[next alloc] + // [next alloc] will be shrinked on the next iteration. + freed_bytes = alloc->end - del_start + 1; + alloc->end = del_start - 1; + } else { + // Hole punching. Requires creating an extra alloc. + // Begin: ------[alloc.start alloc.end]-[next alloc] + // Del range: [xxx] + // Result: ------[ alloc 1 ]-----[ alloc 2 ]-[next alloc] + freed_bytes = del_end - del_start + 1; + const uintptr_t old_end = alloc->end; + alloc->end = del_start - 1; + + // In case of OOM, don't count the 2nd alloc we failed to allocate. + if (insert_alloc(del_end + 1, old_end, st, alloc->flags) == NULL) + freed_bytes += (old_end - del_end); + } + } + // Now update the StackTraceEntry the Alloc was pointing to, eventually + // freeing it up. + assert(st->alloc_bytes >= freed_bytes); + st->alloc_bytes -= freed_bytes; + if (st->alloc_bytes == 0) + free_stacktrace(st); + stats->total_alloc_bytes -= freed_bytes; + } + return flags; +} + +// +---------------------------------------------------------------------------+ +// + Library entry points (refer to heap_profiler.h for API doc). + +// +---------------------------------------------------------------------------+ +void heap_profiler_free(void* addr, size_t size, uint32_t* old_flags) { + assert(size == 0 || ((uintptr_t) addr + (size - 1)) >= (uintptr_t) addr); + + LOCK_MUTEX(lock); + uint32_t flags = delete_allocs_in_range(addr, size); + UNLOCK_MUTEX(lock); + + if (old_flags != NULL) + *old_flags = flags; +} + +void heap_profiler_alloc(void* addr, size_t size, uintptr_t* frames, + uint32_t depth, uint32_t flags) { + if (depth > HEAP_PROFILER_MAX_DEPTH) + depth = HEAP_PROFILER_MAX_DEPTH; + + if (size == 0) // Apps calling malloc(0), sometimes it happens. + return; + + const uintptr_t start = (uintptr_t) addr; + const uintptr_t end = start + (size - 1); + assert(start <= end); + + LOCK_MUTEX(lock); + + delete_allocs_in_range(addr, size); + + StacktraceEntry* st = record_stacktrace(frames, depth); + if (st != NULL) { + Alloc* alloc = insert_alloc(start, end, st, flags); + if (alloc != NULL) { + st->alloc_bytes += size; + stats->total_alloc_bytes += size; + } + } + + UNLOCK_MUTEX(lock); +} + +void heap_profiler_init(HeapStats* heap_stats) { + LOCK_MUTEX(lock); + + assert(stats == NULL); + stats = heap_stats; + memset(stats, 0, sizeof(HeapStats)); + stats->magic_start = HEAP_PROFILER_MAGIC_MARKER; + stats->allocs = &allocs[0]; + stats->stack_traces = &stack_traces[0]; + + UNLOCK_MUTEX(lock); +} + +void heap_profiler_cleanup(void) { + LOCK_MUTEX(lock); + + assert(stats != NULL); + memset(stack_traces, 0, sizeof(StacktraceEntry) * stats->max_stack_traces); + memset(stack_traces_ht, 0, sizeof(stack_traces_ht)); + stack_traces_freelist = NULL; + + memset(allocs, 0, sizeof(Alloc) * stats->max_allocs); + allocs_freelist = NULL; + RB_INIT(&allocs_tree); + + stats = NULL; + + UNLOCK_MUTEX(lock); +}
diff --git a/tools/android/heap_profiler/heap_profiler.gyp b/tools/android/heap_profiler/heap_profiler.gyp new file mode 100644 index 0000000..50e6797 --- /dev/null +++ b/tools/android/heap_profiler/heap_profiler.gyp
@@ -0,0 +1,75 @@ +# Copyright 2014 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. + +{ + 'targets': [ + { + # libheap_profiler is the library that will be preloaded in the Android + # Zygote and contains the black magic to hook malloc/mmap calls. + 'target_name': 'heap_profiler', + 'type': 'shared_library', + 'include_dirs': [ '../../..' ], + 'sources': [ 'heap_profiler_hooks_android.c' ], + 'dependencies': [ 'heap_profiler_core' ], + }, + { + # heap_profiler_core contains only the tracking metadata code without any + # hooks. It is required by both the hprof library itself and the unittest. + 'target_name': 'heap_profiler_core', + 'type': 'static_library', + 'sources': [ + 'heap_profiler.c', + 'heap_profiler.h', + ], + 'include_dirs': [ '../../..' ], + }, + { + 'target_name': 'heap_dump', + 'type': 'executable', + 'sources': [ 'heap_dump.c' ], + 'include_dirs': [ '../../..' ], + }, + { + 'target_name': 'heap_profiler_unittests', + 'type': '<(gtest_target_type)', + 'sources': [ 'heap_profiler_unittest.cc' ], + 'dependencies': [ + 'heap_profiler_core', + '../../../testing/android/native_test.gyp:native_test_native_code', + '../../../testing/gtest.gyp:gtest', + '../../../testing/gtest.gyp:gtest_main', + ], + 'include_dirs': [ '../../..' ], + }, + { + 'target_name': 'heap_profiler_unittests_apk', + 'type': 'none', + 'dependencies': [ + 'heap_profiler_unittests', + ], + 'variables': { + 'test_suite_name': 'heap_profiler_unittests', + }, + 'includes': [ '../../../build/apk_test.gypi' ], + }, + { + 'target_name': 'heap_profiler_integrationtest', + 'type': 'executable', + 'sources': [ 'heap_profiler_integrationtest.cc' ], + 'dependencies': [ '../../../testing/gtest.gyp:gtest' ], + 'include_dirs': [ '../../..' ], + }, + { + 'target_name': 'heap_profiler_integrationtest_stripped', + 'type': 'none', + 'dependencies': [ 'heap_profiler_integrationtest' ], + 'actions': [{ + 'action_name': 'strip heap_profiler_integrationtest', + 'inputs': [ '<(PRODUCT_DIR)/heap_profiler_integrationtest' ], + 'outputs': [ '<(PRODUCT_DIR)/heap_profiler_integrationtest_stripped' ], + 'action': [ '<(android_strip)', '<@(_inputs)', '-o', '<@(_outputs)' ], + }], + }, + ], +}
diff --git a/tools/android/heap_profiler/heap_profiler.h b/tools/android/heap_profiler/heap_profiler.h new file mode 100644 index 0000000..491081d --- /dev/null +++ b/tools/android/heap_profiler/heap_profiler.h
@@ -0,0 +1,90 @@ +// Copyright 2014 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. + +#ifndef TOOLS_ANDROID_HEAP_PROFILER_HEAP_PROFILER_H_ +#define TOOLS_ANDROID_HEAP_PROFILER_HEAP_PROFILER_H_ + +#include <stdint.h> +#include "third_party/bsdtrees/tree.h" + +#define HEAP_PROFILER_MAGIC_MARKER 0x42beef42L +#define HEAP_PROFILER_MAX_DEPTH 12 + +// The allocation is a result of a system malloc() invocation. +#define HEAP_PROFILER_FLAGS_MALLOC 1 + +// The allocation is a result of a mmap() invocation. +#define HEAP_PROFILER_FLAGS_MMAP 2 // Allocation performed through mmap. + +// Only in the case of FLAGS_MMAP: The mmap is not anonymous (i.e. file backed). +#define HEAP_PROFILER_FLAGS_MMAP_FILE 4 + +// Android only: allocation made by the Zygote (before forking). +#define HEAP_PROFILER_FLAGS_IN_ZYGOTE 8 + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct StacktraceEntry { + uintptr_t frames[HEAP_PROFILER_MAX_DEPTH]; // Absolute addrs of stack frames. + uint32_t hash; // H(frames), used to keep these entries in a hashtable. + + // Total number of bytes allocated through this code path. It is equal to the + // sum of Alloc instances' length which .bt == this. + size_t alloc_bytes; + + // |next| has a dual purpose. When the entry is used (hence in the hashtable), + // this is a ptr to the next item in the same bucket. When the entry is free, + // this is a ptr to the next entry in the freelist. + struct StacktraceEntry* next; +} StacktraceEntry; + +// Represents a contiguous range of virtual memory which has been allocated by +// a give code path (identified by the corresponding StacktraceEntry). +typedef struct Alloc { + RB_ENTRY(Alloc) rb_node; // Anchor for the RB-tree; + uintptr_t start; + uintptr_t end; + uint32_t flags; // See HEAP_PROFILER_FLAGS_*. + StacktraceEntry* st; // NULL == free entry. + struct Alloc* next_free; +} Alloc; + +typedef struct { + uint32_t magic_start; // The magic marker used to locate the stats mmap. + uint32_t num_allocs; // The total number of allocation entries present. + uint32_t max_allocs; // The max number of items in |allocs|. + uint32_t num_stack_traces; // The total number of stack traces present. + uint32_t max_stack_traces; // The max number of items in |stack_traces|. + size_t total_alloc_bytes; // Total allocation bytes tracked. + Alloc* allocs; // Start of the the Alloc pool. + StacktraceEntry* stack_traces; // Start of the StacktraceEntry pool. +} HeapStats; + +// Initialize the heap_profiler. The caller has to allocate the HeapStats +// "superblock", since the way it is mapped is platform-specific. +void heap_profiler_init(HeapStats* heap_stats); + +// Records and allocation. The caller must unwind the stack and pass the +// frames array. Flags are optionals and don't affect the behavior of the +// library (they're just kept along and dumped). +void heap_profiler_alloc(void* addr, + size_t size, + uintptr_t* frames, + uint32_t depth, + uint32_t flags); + +// Frees any allocation (even partial) overlapping with the given range. +// If old_flags != NULL, it will be filled with the flags of the deleted allocs. +void heap_profiler_free(void* addr, size_t size, uint32_t* old_flags); + +// Cleans up the HeapStats and all the internal data structures. +void heap_profiler_cleanup(void); + +#ifdef __cplusplus +} +#endif + +#endif // TOOLS_ANDROID_HEAP_PROFILER_HEAP_PROFILER_H_
diff --git a/tools/android/heap_profiler/heap_profiler_hooks_android.c b/tools/android/heap_profiler/heap_profiler_hooks_android.c new file mode 100644 index 0000000..1480780 --- /dev/null +++ b/tools/android/heap_profiler/heap_profiler_hooks_android.c
@@ -0,0 +1,209 @@ +// Copyright 2014 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. + +#include <dlfcn.h> +#include <errno.h> +#include <fcntl.h> +#include <stdbool.h> +#include <stdlib.h> +#include <string.h> +#include <sys/mman.h> +#include <unistd.h> +#include <unwind.h> + +#include "tools/android/heap_profiler/heap_profiler.h" + +#define HEAP_PROFILER_EXPORT __attribute__((visibility("default"))) + + +static inline __attribute__((always_inline)) +uint32_t get_backtrace(uintptr_t* frames, uint32_t max_depth); + +// Function pointers typedefs for the hooked symbols. +typedef void* (*mmap_t)(void*, size_t, int, int, int, off_t); +typedef void* (*mmap2_t)(void*, size_t, int, int, int, off_t); +typedef void* (*mmap64_t)(void*, size_t, int, int, int, off64_t); +typedef void* (*mremap_t)(void*, size_t, size_t, unsigned long); +typedef int (*munmap_t)(void*, size_t); +typedef void* (*malloc_t)(size_t); +typedef void* (*calloc_t)(size_t, size_t); +typedef void* (*realloc_t)(void*, size_t); +typedef void (*free_t)(void*); + +// And their actual definitions. +static mmap_t real_mmap; +static mmap2_t real_mmap2; +static mmap64_t real_mmap64; +static mremap_t real_mremap; +static munmap_t real_munmap; +static malloc_t real_malloc; +static calloc_t real_calloc; +static realloc_t real_realloc; +static free_t real_free; +static int* has_forked_off_zygote; + +HEAP_PROFILER_EXPORT const HeapStats* heap_profiler_stats_for_tests; + +// +---------------------------------------------------------------------------+ +// + Initialization of heap_profiler and lookup of hooks' addresses + +// +---------------------------------------------------------------------------+ +__attribute__((constructor)) +static void initialize() { + real_mmap = (mmap_t) dlsym(RTLD_NEXT, "mmap"); + real_mmap2 = (mmap_t) dlsym(RTLD_NEXT, "mmap2"); + real_mmap64 = (mmap64_t) dlsym(RTLD_NEXT, "mmap64"); + real_mremap = (mremap_t) dlsym(RTLD_NEXT, "mremap"); + real_munmap = (munmap_t) dlsym(RTLD_NEXT, "munmap"); + real_malloc = (malloc_t) dlsym(RTLD_NEXT, "malloc"); + real_calloc = (calloc_t) dlsym(RTLD_NEXT, "calloc"); + real_realloc = (realloc_t) dlsym(RTLD_NEXT, "realloc"); + real_free = (free_t) dlsym(RTLD_NEXT, "free"); + + // gMallocLeakZygoteChild is an extra useful piece of information to have. + // When available, it tells whether we're in the zygote (=0) or forked (=1) + // a child off it. In the worst case it will be NULL and we'll just ignore it. + has_forked_off_zygote = (int*) dlsym(RTLD_NEXT, "gMallocLeakZygoteChild"); + + // Allocate room for the HeapStats area and initialize the heap profiler. + // Make an explicit map of /dev/zero (instead of MAP_ANONYMOUS), so that the + // heap_dump tool can easily spot the mapping in the target process. + int fd = open("/dev/zero", O_RDONLY); + if (fd < 0) { + abort(); // This world has gone wrong. Good night Vienna. + } + + HeapStats* stats = (HeapStats*) real_mmap( + 0, sizeof(HeapStats), PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); + heap_profiler_stats_for_tests = stats; + heap_profiler_init(stats); +} + +static inline __attribute__((always_inline)) void unwind_and_record_alloc( + void* start, size_t size, uint32_t flags) { + const int errno_save = errno; + uintptr_t frames[HEAP_PROFILER_MAX_DEPTH]; + const uint32_t depth = get_backtrace(frames, HEAP_PROFILER_MAX_DEPTH); + if (has_forked_off_zygote != NULL && *has_forked_off_zygote == 0) + flags |= HEAP_PROFILER_FLAGS_IN_ZYGOTE; + heap_profiler_alloc(start, size, frames, depth, flags); + errno = errno_save; +} + +static inline __attribute__((always_inline)) void discard_alloc( + void* start, size_t size, uint32_t* old_flags) { + const int errno_save = errno; + heap_profiler_free(start, size, old_flags); + errno = errno_save; +} + +// Flags are non-functional extra decorators that are made available to the +// final heap_dump tool, to get more details about the source of the allocation. +static uint32_t get_flags_for_mmap(int fd) { + return HEAP_PROFILER_FLAGS_MMAP | (fd ? HEAP_PROFILER_FLAGS_MMAP_FILE : 0); +} + +// +---------------------------------------------------------------------------+ +// + Actual mmap/malloc hooks + +// +---------------------------------------------------------------------------+ +HEAP_PROFILER_EXPORT void* mmap( + void* addr, size_t size, int prot, int flags, int fd, off_t offset) { + void* ret = real_mmap(addr, size, prot, flags, fd, offset); + if (ret != MAP_FAILED) + unwind_and_record_alloc(ret, size, get_flags_for_mmap(fd)); + return ret; +} + +HEAP_PROFILER_EXPORT void* mmap2( + void* addr, size_t size, int prot, int flags, int fd, off_t pgoffset) { + void* ret = real_mmap2(addr, size, prot, flags, fd, pgoffset); + if (ret != MAP_FAILED) + unwind_and_record_alloc(ret, size, get_flags_for_mmap(fd)); + return ret; +} + +HEAP_PROFILER_EXPORT void* mmap64( + void* addr, size_t size, int prot, int flags, int fd, off64_t offset) { + void* ret = real_mmap64(addr, size, prot, flags, fd, offset); + if (ret != MAP_FAILED) + unwind_and_record_alloc(ret, size, get_flags_for_mmap(fd)); + return ret; +} + +HEAP_PROFILER_EXPORT void* mremap( + void* addr, size_t oldlen, size_t newlen, unsigned long flags) { + void* ret = real_mremap(addr, oldlen, newlen, flags); + if (ret != MAP_FAILED) { + uint32_t flags = 0; + if (addr) + discard_alloc(addr, oldlen, &flags); + if (newlen > 0) + unwind_and_record_alloc(ret, newlen, flags); + } + return ret; +} + +HEAP_PROFILER_EXPORT int munmap(void* ptr, size_t size) { + int ret = real_munmap(ptr, size); + discard_alloc(ptr, size, /*old_flags=*/NULL); + return ret; +} + +HEAP_PROFILER_EXPORT void* malloc(size_t byte_count) { + void* ret = real_malloc(byte_count); + if (ret != NULL) + unwind_and_record_alloc(ret, byte_count, HEAP_PROFILER_FLAGS_MALLOC); + return ret; +} + +HEAP_PROFILER_EXPORT void* calloc(size_t nmemb, size_t size) { + void* ret = real_calloc(nmemb, size); + if (ret != NULL) + unwind_and_record_alloc(ret, nmemb * size, HEAP_PROFILER_FLAGS_MALLOC); + return ret; +} + +HEAP_PROFILER_EXPORT void* realloc(void* ptr, size_t size) { + void* ret = real_realloc(ptr, size); + uint32_t flags = 0; + if (ptr) + discard_alloc(ptr, 0, &flags); + if (ret != NULL) + unwind_and_record_alloc(ret, size, flags | HEAP_PROFILER_FLAGS_MALLOC); + return ret; +} + +HEAP_PROFILER_EXPORT void free(void* ptr) { + real_free(ptr); + discard_alloc(ptr, 0, /*old_flags=*/NULL); +} + +// +---------------------------------------------------------------------------+ +// + Stack unwinder + +// +---------------------------------------------------------------------------+ +typedef struct { + uintptr_t* frames; + uint32_t frame_count; + uint32_t max_depth; + bool have_skipped_self; +} stack_crawl_state_t; + +static _Unwind_Reason_Code unwind_fn(struct _Unwind_Context* ctx, void* arg) { + stack_crawl_state_t* state = (stack_crawl_state_t*) arg; + uintptr_t ip = _Unwind_GetIP(ctx); + + if (ip != 0 && !state->have_skipped_self) { + state->have_skipped_self = true; + return _URC_NO_REASON; + } + + state->frames[state->frame_count++] = ip; + return (state->frame_count >= state->max_depth) ? + _URC_END_OF_STACK : _URC_NO_REASON; +} + +static uint32_t get_backtrace(uintptr_t* frames, uint32_t max_depth) { + stack_crawl_state_t state = {.frames = frames, .max_depth = max_depth}; + _Unwind_Backtrace(unwind_fn, &state); + return state.frame_count; +}
diff --git a/tools/android/heap_profiler/heap_profiler_integrationtest.cc b/tools/android/heap_profiler/heap_profiler_integrationtest.cc new file mode 100644 index 0000000..ba7ebea --- /dev/null +++ b/tools/android/heap_profiler/heap_profiler_integrationtest.cc
@@ -0,0 +1,179 @@ +// Copyright 2014 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. + +#include <dlfcn.h> +#include <fcntl.h> +#include <stdlib.h> +#include <string.h> +#include <sys/mman.h> +#include <unistd.h> +#include <map> + +#include "base/compiler_specific.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "tools/android/heap_profiler/heap_profiler.h" + +namespace { + +typedef void* (*AllocatorFn)(size_t); +typedef int (*FreeFn)(void*, size_t); + +const size_t kSize1 = 499 * PAGE_SIZE; +const size_t kSize2 = 503 * PAGE_SIZE; +const size_t kSize3 = 509 * PAGE_SIZE; + +// The purpose of the four functions below is to create watermarked allocations, +// so the test fixture can ascertain that the hooks work end-to-end. +__attribute__((noinline)) void* MallocInner(size_t size) { + void* ptr = malloc(size); + // The memset below is to avoid tail-call elimination optimizations and ensure + // that this function will be part of the stack trace. + memset(ptr, 0, size); + return ptr; +} + +__attribute__((noinline)) void* MallocOuter(size_t size) { + void* ptr = MallocInner(size); + memset(ptr, 0, size); + return ptr; +} + +__attribute__((noinline)) void* DoMmap(size_t size) { + return mmap( + 0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); +} + +__attribute__((noinline)) void* MmapInner(size_t size) { + void* ptr = DoMmap(size); + memset(ptr, 0, size); + return ptr; +} + +__attribute__((noinline)) void* MmapOuter(size_t size) { + void* ptr = MmapInner(size); + memset(ptr, 0, size); + return ptr; +} + +const HeapStats* GetHeapStats() { + HeapStats* const* stats_ptr = reinterpret_cast<HeapStats* const*>( + dlsym(RTLD_DEFAULT, "heap_profiler_stats_for_tests")); + EXPECT_TRUE(stats_ptr != NULL); + const HeapStats* stats = *stats_ptr; + EXPECT_TRUE(stats != NULL); + EXPECT_EQ(HEAP_PROFILER_MAGIC_MARKER, stats->magic_start); + return stats; +} + +bool StackTraceContains(const StacktraceEntry* s, AllocatorFn fn) { + // kExpectedFnLen is a gross estimation of the watermark functions' size. + // It tries to address the following problem: the addrs in the unwound stack + // stack frames will NOT point to the beginning of the functions, but to the + // PC after the call to malloc/mmap. + const size_t kExpectedFnLen = 16; + const uintptr_t fn_addr = reinterpret_cast<uintptr_t>(fn); + for (size_t i = 0; i < HEAP_PROFILER_MAX_DEPTH; ++i) { + if (s->frames[i] >= fn_addr && s->frames[i] <= fn_addr + kExpectedFnLen) + return true; + } + return false; +} + +const StacktraceEntry* LookupStackTrace(size_t size, AllocatorFn fn) { + const HeapStats* stats = GetHeapStats(); + for (size_t i = 0; i < stats->max_stack_traces; ++i) { + const StacktraceEntry* st = &stats->stack_traces[i]; + if (st->alloc_bytes == size && StackTraceContains(st, fn)) + return st; + } + return NULL; +} + +int DoFree(void* addr, size_t /*size, ignored.*/) { + free(addr); + return 0; +} + +void TestStackTracesWithParams(AllocatorFn outer_fn, + AllocatorFn inner_fn, + FreeFn free_fn) { + const HeapStats* stats = GetHeapStats(); + + void* m1 = outer_fn(kSize1); + void* m2 = inner_fn(kSize2); + void* m3 = inner_fn(kSize3); + free_fn(m3, kSize3); + + const StacktraceEntry* st1 = LookupStackTrace(kSize1, inner_fn); + const StacktraceEntry* st2 = LookupStackTrace(kSize2, inner_fn); + const StacktraceEntry* st3 = LookupStackTrace(kSize3, inner_fn); + + EXPECT_TRUE(st1 != NULL); + EXPECT_TRUE(StackTraceContains(st1, outer_fn)); + EXPECT_TRUE(StackTraceContains(st1, inner_fn)); + + EXPECT_TRUE(st2 != NULL); + EXPECT_FALSE(StackTraceContains(st2, outer_fn)); + EXPECT_TRUE(StackTraceContains(st2, inner_fn)); + + EXPECT_EQ(NULL, st3); + + const size_t total_alloc_start = stats->total_alloc_bytes; + const size_t num_stack_traces_start = stats->num_stack_traces; + + free_fn(m1, kSize1); + free_fn(m2, kSize2); + + const size_t total_alloc_end = stats->total_alloc_bytes; + const size_t num_stack_traces_end = stats->num_stack_traces; + + EXPECT_EQ(kSize1 + kSize2, total_alloc_start - total_alloc_end); + EXPECT_EQ(2, num_stack_traces_start - num_stack_traces_end); + EXPECT_EQ(NULL, LookupStackTrace(kSize1, inner_fn)); + EXPECT_EQ(NULL, LookupStackTrace(kSize2, inner_fn)); + EXPECT_EQ(NULL, LookupStackTrace(kSize3, inner_fn)); +} + +TEST(HeapProfilerIntegrationTest, TestMallocStackTraces) { + TestStackTracesWithParams(&MallocOuter, &MallocInner, &DoFree); +} + +TEST(HeapProfilerIntegrationTest, TestMmapStackTraces) { + TestStackTracesWithParams(&MmapOuter, &MmapInner, &munmap); +} + +// Returns the path of the directory containing the current executable. +std::string GetExePath() { + char buf[1024]; + ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1); + if (len == -1) + return std::string(); + std::string path(buf, len); + size_t sep = path.find_last_of('/'); + if (sep == std::string::npos) + return std::string(); + path.erase(sep); + return path; +} + +} // namespace + +int main(int argc, char** argv) { + // Re-launch the process itself forcing the preload of the libheap_profiler. + char* ld_preload = getenv("LD_PRELOAD"); + if (ld_preload == NULL || strstr(ld_preload, "libheap_profiler.so") == NULL) { + char env_ld_lib_path[256]; + strlcpy(env_ld_lib_path, "LD_LIBRARY_PATH=", sizeof(env_ld_lib_path)); + strlcat(env_ld_lib_path, GetExePath().c_str(), sizeof(env_ld_lib_path)); + char env_ld_preload[] = "LD_PRELOAD=libheap_profiler.so"; + char* const env[] = {env_ld_preload, env_ld_lib_path, 0}; + execve("/proc/self/exe", argv, env); + // execve() never returns, unless something goes wrong. + perror("execve"); + assert(false); + } + + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}
diff --git a/tools/android/heap_profiler/heap_profiler_unittest.cc b/tools/android/heap_profiler/heap_profiler_unittest.cc new file mode 100644 index 0000000..65c2700 --- /dev/null +++ b/tools/android/heap_profiler/heap_profiler_unittest.cc
@@ -0,0 +1,458 @@ +// Copyright 2014 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. + +#include <stdint.h> +#include <string.h> +#include <map> + +#include "base/compiler_specific.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "tools/android/heap_profiler/heap_profiler.h" + +namespace { + +class HeapProfilerTest : public testing::Test { + public: + virtual void SetUp() OVERRIDE { heap_profiler_init(&stats_); } + + virtual void TearDown() OVERRIDE { + CheckAllocVsStacktaceConsistency(); + heap_profiler_cleanup(); + } + + protected: + struct StackTrace { + uintptr_t frames[HEAP_PROFILER_MAX_DEPTH]; + size_t depth; + }; + + StackTrace GenStackTrace(size_t depth, uintptr_t base) { + assert(depth <= HEAP_PROFILER_MAX_DEPTH); + StackTrace st; + for (size_t i = 0; i < depth; ++i) + st.frames[i] = base + i * 0x10UL; + st.depth = depth; + return st; + } + + void ExpectAlloc(uintptr_t start, + uintptr_t end, + const StackTrace& st, + uint32_t flags) { + for (uint32_t i = 0; i < stats_.max_allocs; ++i) { + const Alloc& alloc = stats_.allocs[i]; + if (alloc.start != start || alloc.end != end) + continue; + // Check that the stack trace match. + for (uint32_t j = 0; j < st.depth; ++j) { + EXPECT_EQ(st.frames[j], alloc.st->frames[j]) + << "Stacktrace not matching @ depth " << j; + } + EXPECT_EQ(flags, alloc.flags); + return; + } + + FAIL() << "Alloc not found [" << std::hex << start << "," << end << "]"; + } + + void CheckAllocVsStacktaceConsistency() { + uint32_t allocs_seen = 0; + uint32_t stack_traces_seen = 0; + std::map<StacktraceEntry*, uintptr_t> stacktrace_bytes_by_alloc; + + for (uint32_t i = 0; i < stats_.max_allocs; ++i) { + Alloc* alloc = &stats_.allocs[i]; + if (alloc->start == 0 && alloc->end == 0) + continue; + ++allocs_seen; + stacktrace_bytes_by_alloc[alloc->st] += alloc->end - alloc->start + 1; + } + + for (uint32_t i = 0; i < stats_.max_stack_traces; ++i) { + StacktraceEntry* st = &stats_.stack_traces[i]; + if (st->alloc_bytes == 0) + continue; + ++stack_traces_seen; + EXPECT_EQ(1, stacktrace_bytes_by_alloc.count(st)); + EXPECT_EQ(stacktrace_bytes_by_alloc[st], st->alloc_bytes); + } + + EXPECT_EQ(allocs_seen, stats_.num_allocs); + EXPECT_EQ(stack_traces_seen, stats_.num_stack_traces); + } + + HeapStats stats_; +}; + +TEST_F(HeapProfilerTest, SimpleAlloc) { + StackTrace st1 = GenStackTrace(8, 0x0); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 2048, st1.frames, st1.depth, 0); + + EXPECT_EQ(2, stats_.num_allocs); + EXPECT_EQ(1, stats_.num_stack_traces); + EXPECT_EQ(1024 + 2048, stats_.total_alloc_bytes); + ExpectAlloc(0x1000, 0x13ff, st1, 0); + ExpectAlloc(0x2000, 0x27ff, st1, 0); +} + +TEST_F(HeapProfilerTest, AllocMultipleStacks) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(4, 0x1000); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 2048, st2.frames, st2.depth, 0); + heap_profiler_alloc((void*)0x3000, 32, st1.frames, st1.depth, 0); + + EXPECT_EQ(3, stats_.num_allocs); + EXPECT_EQ(2, stats_.num_stack_traces); + EXPECT_EQ(1024 + 2048 + 32, stats_.total_alloc_bytes); + ExpectAlloc(0x1000, 0x13ff, st1, 0); + ExpectAlloc(0x2000, 0x27ff, st2, 0); + ExpectAlloc(0x3000, 0x301f, st1, 0); +} + +TEST_F(HeapProfilerTest, SimpleAllocAndFree) { + StackTrace st1 = GenStackTrace(8, 0x0); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + heap_profiler_free((void*)0x1000, 1024, NULL); + + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, Realloc) { + StackTrace st1 = GenStackTrace(8, 0); + heap_profiler_alloc((void*)0, 32, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0, 32, st1.frames, st1.depth, 0); +} + +TEST_F(HeapProfilerTest, AllocAndFreeMultipleStacks) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 2048, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x3000, 32, st2.frames, st2.depth, 0); + heap_profiler_alloc((void*)0x4000, 64, st2.frames, st2.depth, 0); + + heap_profiler_free((void*)0x1000, 1024, NULL); + heap_profiler_free((void*)0x3000, 32, NULL); + + EXPECT_EQ(2, stats_.num_allocs); + EXPECT_EQ(2, stats_.num_stack_traces); + EXPECT_EQ(2048 + 64, stats_.total_alloc_bytes); + ExpectAlloc(0x2000, 0x27ff, st1, 0); + ExpectAlloc(0x4000, 0x403f, st2, 0); +} + +TEST_F(HeapProfilerTest, AllocAndFreeAll) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 2048, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x3000, 32, st2.frames, st2.depth, 0); + heap_profiler_alloc((void*)0x4000, 64, st2.frames, st2.depth, 0); + + heap_profiler_free((void*)0x1000, 1024, NULL); + heap_profiler_free((void*)0x2000, 2048, NULL); + heap_profiler_free((void*)0x3000, 32, NULL); + heap_profiler_free((void*)0x4000, 64, NULL); + + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, AllocAndFreeWithZeroSize) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 2048, st2.frames, st2.depth, 0); + + heap_profiler_free((void*)0x1000, 0, NULL); + + EXPECT_EQ(1, stats_.num_allocs); + EXPECT_EQ(1, stats_.num_stack_traces); + EXPECT_EQ(2048, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, AllocAndFreeContiguous) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + heap_profiler_alloc((void*)0x1000, 4096, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 4096, st2.frames, st2.depth, 0); + + heap_profiler_free((void*)0x1000, 8192, NULL); + + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, SparseAllocsOneLargeOuterFree) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + + heap_profiler_alloc((void*)0x1010, 1, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x1400, 2, st2.frames, st2.depth, 0); + heap_profiler_alloc((void*)0x1600, 5, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x9000, 4096, st2.frames, st2.depth, 0); + + heap_profiler_free((void*)0x0800, 8192, NULL); + EXPECT_EQ(1, stats_.num_allocs); + EXPECT_EQ(1, stats_.num_stack_traces); + EXPECT_EQ(4096, stats_.total_alloc_bytes); + ExpectAlloc(0x9000, 0x9fff, st2, 0); +} + +TEST_F(HeapProfilerTest, SparseAllocsOneLargePartiallyOverlappingFree) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + StackTrace st3 = GenStackTrace(4, 0x2000); + + // This will be untouched. + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + + // These will be partially freed in one shot (% 64 a bytes "margin"). + heap_profiler_alloc((void*)0x2000, 128, st2.frames, st2.depth, 0); + heap_profiler_alloc((void*)0x2400, 128, st2.frames, st2.depth, 0); + heap_profiler_alloc((void*)0x2f80, 128, st2.frames, st2.depth, 0); + + // This will be untouched. + heap_profiler_alloc((void*)0x3000, 1024, st3.frames, st3.depth, 0); + + heap_profiler_free((void*)0x2040, 4096 - 64 - 64, NULL); + EXPECT_EQ(4, stats_.num_allocs); + EXPECT_EQ(3, stats_.num_stack_traces); + EXPECT_EQ(1024 + 64 + 64 + 1024, stats_.total_alloc_bytes); + + ExpectAlloc(0x1000, 0x13ff, st1, 0); + ExpectAlloc(0x2000, 0x203f, st2, 0); + ExpectAlloc(0x2fc0, 0x2fff, st2, 0); + ExpectAlloc(0x3000, 0x33ff, st3, 0); +} + +TEST_F(HeapProfilerTest, AllocAndFreeScattered) { + StackTrace st1 = GenStackTrace(8, 0x0); + heap_profiler_alloc((void*)0x1000, 4096, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 4096, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x3000, 4096, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x4000, 4096, st1.frames, st1.depth, 0); + + heap_profiler_free((void*)0x800, 4096, NULL); + EXPECT_EQ(4, stats_.num_allocs); + EXPECT_EQ(2048 + 4096 + 4096 + 4096, stats_.total_alloc_bytes); + + heap_profiler_free((void*)0x1800, 4096, NULL); + EXPECT_EQ(3, stats_.num_allocs); + EXPECT_EQ(2048 + 4096 + 4096, stats_.total_alloc_bytes); + + heap_profiler_free((void*)0x2800, 4096, NULL); + EXPECT_EQ(2, stats_.num_allocs); + EXPECT_EQ(2048 + 4096, stats_.total_alloc_bytes); + + heap_profiler_free((void*)0x3800, 4096, NULL); + EXPECT_EQ(1, stats_.num_allocs); + EXPECT_EQ(2048, stats_.total_alloc_bytes); + + heap_profiler_free((void*)0x4800, 4096, NULL); + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, AllocAndOverFreeContiguous) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + heap_profiler_alloc((void*)0x1000, 4096, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 4096, st2.frames, st2.depth, 0); + + heap_profiler_free((void*)0, 16834, NULL); + + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, AllocContiguousAndPunchHole) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + heap_profiler_alloc((void*)0x1000, 4096, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 4096, st2.frames, st2.depth, 0); + + // Punch a 4k hole in the middle of the two contiguous 4k allocs. + heap_profiler_free((void*)0x1800, 4096, NULL); + + EXPECT_EQ(2, stats_.num_allocs); + EXPECT_EQ(2, stats_.num_stack_traces); + EXPECT_EQ(4096, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, AllocAndPartialFree) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(6, 0x1000); + StackTrace st3 = GenStackTrace(7, 0x2000); + StackTrace st4 = GenStackTrace(9, 0x3000); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + heap_profiler_alloc((void*)0x2000, 1024, st2.frames, st2.depth, 0); + heap_profiler_alloc((void*)0x3000, 1024, st3.frames, st3.depth, 0); + heap_profiler_alloc((void*)0x4000, 1024, st4.frames, st4.depth, 0); + + heap_profiler_free((void*)0x1000, 128, NULL); // Shrink left by 128B. + heap_profiler_free((void*)0x2380, 128, NULL); // Shrink right by 128B. + heap_profiler_free((void*)0x3100, 512, NULL); // 512B hole in the middle. + heap_profiler_free((void*)0x4000, 512, NULL); // Free up the 4th alloc... + heap_profiler_free((void*)0x4200, 512, NULL); // ...but do it in two halves. + + EXPECT_EQ(4, stats_.num_allocs); // 1 + 2 + two sides around the hole 3. + EXPECT_EQ(3, stats_.num_stack_traces); // st4 should be gone. + EXPECT_EQ(896 + 896 + 512, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, RandomIndividualAllocAndFrees) { + static const size_t NUM_ST = 128; + static const size_t NUM_OPS = 1000; + + StackTrace st[NUM_ST]; + for (uint32_t i = 0; i < NUM_ST; ++i) + st[i] = GenStackTrace((i % 10) + 2, i * 128); + + for (size_t i = 0; i < NUM_OPS; ++i) { + uintptr_t start = ((i + 7) << 8) & (0xffffff); + size_t size = (start >> 16) & 0x0fff; + if (i & 1) { + StackTrace* s = &st[start % NUM_ST]; + heap_profiler_alloc((void*)start, size, s->frames, s->depth, 0); + } else { + heap_profiler_free((void*)start, size, NULL); + } + CheckAllocVsStacktaceConsistency(); + } +} + +TEST_F(HeapProfilerTest, RandomAllocAndFreesBatches) { + static const size_t NUM_ST = 128; + static const size_t NUM_ALLOCS = 100; + + StackTrace st[NUM_ST]; + for (size_t i = 0; i < NUM_ST; ++i) + st[i] = GenStackTrace((i % 10) + 2, i * NUM_ST); + + for (int repeat = 0; repeat < 5; ++repeat) { + for (size_t i = 0; i < NUM_ALLOCS; ++i) { + StackTrace* s = &st[i % NUM_ST]; + heap_profiler_alloc( + (void*)(i * 4096), ((i + 1) * 32) % 4097, s->frames, s->depth, 0); + CheckAllocVsStacktaceConsistency(); + } + + for (size_t i = 0; i < NUM_ALLOCS; ++i) { + heap_profiler_free((void*)(i * 1024), ((i + 1) * 64) % 16000, NULL); + CheckAllocVsStacktaceConsistency(); + } + } +} + +TEST_F(HeapProfilerTest, UnwindStackTooLargeShouldSaturate) { + StackTrace st1 = GenStackTrace(HEAP_PROFILER_MAX_DEPTH, 0x0); + uintptr_t many_frames[100] = {}; + memcpy(many_frames, st1.frames, sizeof(uintptr_t) * st1.depth); + heap_profiler_alloc((void*)0x1000, 1024, many_frames, 100, 0); + ExpectAlloc(0x1000, 0x13ff, st1, 0); +} + +TEST_F(HeapProfilerTest, NoUnwindShouldNotCrashButNoop) { + heap_profiler_alloc((void*)0x1000, 1024, NULL, 0, 0); + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, FreeNonExisting) { + StackTrace st1 = GenStackTrace(5, 0x0); + heap_profiler_free((void*)0x1000, 1024, NULL); + heap_profiler_free((void*)0x1400, 1024, NULL); + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); + heap_profiler_alloc((void*)0x1000, 1024, st1.frames, st1.depth, 0); + EXPECT_EQ(1, stats_.num_allocs); + EXPECT_EQ(1024, stats_.total_alloc_bytes); +} + +TEST_F(HeapProfilerTest, FlagsConsistency) { + StackTrace st1 = GenStackTrace(8, 0x0); + uint32_t flags = 0; + heap_profiler_alloc((void*)0x1000, 4096, st1.frames, st1.depth, 42); + heap_profiler_alloc((void*)0x2000, 4096, st1.frames, st1.depth, 142); + + ExpectAlloc(0x1000, 0x1fff, st1, 42); + ExpectAlloc(0x2000, 0x2fff, st1, 142); + + // Punch a 4k hole in the middle of the two contiguous 4k allocs. + heap_profiler_free((void*)0x1800, 4096, NULL); + + ExpectAlloc(0x1000, 0x17ff, st1, 42); + heap_profiler_free((void*)0x1000, 2048, &flags); + EXPECT_EQ(42, flags); + + ExpectAlloc(0x2800, 0x2fff, st1, 142); + heap_profiler_free((void*)0x2800, 2048, &flags); + EXPECT_EQ(142, flags); +} + +TEST_F(HeapProfilerTest, BeConsistentOnOOM) { + static const size_t NUM_ALLOCS = 512 * 1024; + uintptr_t frames[1]; + + for (uintptr_t i = 0; i < NUM_ALLOCS; ++i) { + frames[0] = i; + heap_profiler_alloc((void*)(i * 32), 32, frames, 1, 0); + } + + CheckAllocVsStacktaceConsistency(); + // Check that we're saturating, otherwise this entire test is pointless. + EXPECT_LT(stats_.num_allocs, NUM_ALLOCS); + EXPECT_LT(stats_.num_stack_traces, NUM_ALLOCS); + + for (uintptr_t i = 0; i < NUM_ALLOCS; ++i) + heap_profiler_free((void*)(i * 32), 32, NULL); + + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.total_alloc_bytes); + EXPECT_EQ(0, stats_.num_stack_traces); +} + +#ifdef __LP64__ +TEST_F(HeapProfilerTest, Test64Bit) { + StackTrace st1 = GenStackTrace(8, 0x0); + StackTrace st2 = GenStackTrace(10, 0x7fffffff70000000L); + StackTrace st3 = GenStackTrace(10, 0xffffffff70000000L); + heap_profiler_alloc((void*)0x1000, 4096, st1.frames, st1.depth, 0); + heap_profiler_alloc( + (void*)0x7ffffffffffff000L, 4096, st2.frames, st2.depth, 0); + heap_profiler_alloc( + (void*)0xfffffffffffff000L, 4096, st3.frames, st3.depth, 0); + EXPECT_EQ(3, stats_.num_allocs); + EXPECT_EQ(3, stats_.num_stack_traces); + EXPECT_EQ(4096 + 4096 + 4096, stats_.total_alloc_bytes); + + heap_profiler_free((void*)0x1000, 4096, NULL); + EXPECT_EQ(2, stats_.num_allocs); + EXPECT_EQ(2, stats_.num_stack_traces); + EXPECT_EQ(4096 + 4096, stats_.total_alloc_bytes); + + heap_profiler_free((void*)0x7ffffffffffff000L, 4096, NULL); + EXPECT_EQ(1, stats_.num_allocs); + EXPECT_EQ(1, stats_.num_stack_traces); + EXPECT_EQ(4096, stats_.total_alloc_bytes); + + heap_profiler_free((void*)0xfffffffffffff000L, 4096, NULL); + EXPECT_EQ(0, stats_.num_allocs); + EXPECT_EQ(0, stats_.num_stack_traces); + EXPECT_EQ(0, stats_.total_alloc_bytes); +} +#endif + +} // namespace
diff --git a/tools/android/md5sum/BUILD.gn b/tools/android/md5sum/BUILD.gn new file mode 100644 index 0000000..5f91a88 --- /dev/null +++ b/tools/android/md5sum/BUILD.gn
@@ -0,0 +1,53 @@ +# Copyright 2014 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. + +# GYP: //tools/android/md5sum/md5sum.gyp:md5sum +group("md5sum") { + datadeps = [ + ":md5sum_bin($host_toolchain)", + ":md5sum_bin($default_toolchain)", + ":md5sum_prepare_dist($default_toolchain)", + ":md5sum_copy_host($host_toolchain)", + ] + # TODO(cjhopman): Remove once group datadeps are fixed. + deps = datadeps +} + +# GYP: //tools/android/md5sum/md5sum.gyp:md5sum_bin_device (and md5sum_bin_host) +executable("md5sum_bin") { + sources = [ + "md5sum.cc" + ] + deps = [ + "//base" + ] + + # TODO(GYP) + #'conditions': [ + #[ 'order_profiling!=0 and OS=="android"', { + #'dependencies': [ '../../../tools/cygprofile/cygprofile.gyp:cygprofile', ], + #}], + #], +} + +if (current_toolchain == default_toolchain) { + import("//build/config/android/rules.gni") + + # GYP: //tools/android/md5sum/md5sum.gyp:md5sum_stripped_device_bin + create_native_executable_dist("md5sum_prepare_dist") { + dist_dir = "$root_build_dir/md5sum_dist" + binary = "$root_build_dir/exe.stripped/md5sum_bin" + } +} else { + # GYP: //tools/android/md5sum/md5sum.gyp:md5sum_bin_host + copy("md5sum_copy_host") { + sources = [ + "$root_out_dir/md5sum_bin" + ] + outputs = [ + "$root_build_dir/md5sum_bin_host" + ] + } +} +
diff --git a/tools/android/md5sum/md5sum.cc b/tools/android/md5sum/md5sum.cc new file mode 100644 index 0000000..07ce2c2 --- /dev/null +++ b/tools/android/md5sum/md5sum.cc
@@ -0,0 +1,93 @@ +// Copyright (c) 2012 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. + +// Md5sum implementation for Android. This version handles files as well as +// directories. Its output is sorted by file path. + +#include <fstream> +#include <iostream> +#include <set> +#include <string> + +#include "base/files/file_enumerator.h" +#include "base/files/file_path.h" +#include "base/files/file_util.h" +#include "base/logging.h" +#include "base/md5.h" + +namespace { + +const int kBufferSize = 1024; + +// Returns whether |path|'s MD5 was successfully written to |digest_string|. +bool MD5Sum(const char* path, std::string* digest_string) { + std::ifstream stream(path); + if (!stream.good()) { + LOG(ERROR) << "Could not open file " << path; + return false; + } + base::MD5Context ctx; + base::MD5Init(&ctx); + char buf[kBufferSize]; + while (stream.good()) { + std::streamsize bytes_read = stream.readsome(buf, sizeof(buf)); + if (bytes_read == 0) + break; + base::MD5Update(&ctx, base::StringPiece(buf, bytes_read)); + } + if (stream.fail()) { + LOG(ERROR) << "Error reading file " << path; + return false; + } + base::MD5Digest digest; + base::MD5Final(&digest, &ctx); + *digest_string = base::MD5DigestToBase16(digest); + return true; +} + +// Returns the set of all files contained in |files|. This handles directories +// by walking them recursively. Excludes, .svn directories and file under them. +std::set<std::string> MakeFileSet(const char** files) { + const std::string svn_dir_component = FILE_PATH_LITERAL("/.svn/"); + std::set<std::string> file_set; + for (const char** file = files; *file; ++file) { + base::FilePath file_path(*file); + if (base::DirectoryExists(file_path)) { + base::FileEnumerator file_enumerator( + file_path, true /* recurse */, base::FileEnumerator::FILES); + for (base::FilePath child, empty; + (child = file_enumerator.Next()) != empty; ) { + // If the path contains /.svn/, ignore it. + if (child.value().find(svn_dir_component) == std::string::npos) { + child = base::MakeAbsoluteFilePath(child); + file_set.insert(child.value()); + } + } + } else { + file_set.insert(*file); + } + } + return file_set; +} + +} // namespace + +int main(int argc, const char* argv[]) { + if (argc < 2) { + LOG(ERROR) << "Usage: md5sum <path/to/file_or_dir>..."; + return 1; + } + const std::set<std::string> files = MakeFileSet(argv + 1); + bool failed = false; + std::string digest; + for (std::set<std::string>::const_iterator it = files.begin(); + it != files.end(); ++it) { + if (!MD5Sum(it->c_str(), &digest)) + failed = true; + base::FilePath file_path(*it); + std::cout << digest << " " + << base::MakeAbsoluteFilePath(file_path).value() << std::endl; + } + return failed; +}
diff --git a/tools/android/md5sum/md5sum.gyp b/tools/android/md5sum/md5sum.gyp new file mode 100644 index 0000000..75d664e --- /dev/null +++ b/tools/android/md5sum/md5sum.gyp
@@ -0,0 +1,81 @@ +# Copyright (c) 2012 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. + +{ + 'targets': [ + { + # GN: //tools/android/md5sum:md5sum + 'target_name': 'md5sum', + 'type': 'none', + 'dependencies': [ + 'md5sum_stripped_device_bin', + 'md5sum_bin_host#host', + ], + # For the component build, ensure dependent shared libraries are stripped + # and put alongside md5sum to simplify pushing to the device. + 'variables': { + 'output_dir': '<(PRODUCT_DIR)/md5sum_dist/', + 'native_binary': '<(PRODUCT_DIR)/md5sum_bin', + }, + 'includes': ['../../../build/android/native_app_dependencies.gypi'], + }, + { + # GN: //tools/android/md5sum:md5sum_bin($default_toolchain) + 'target_name': 'md5sum_device_bin', + 'type': 'executable', + 'dependencies': [ + '../../../base/base.gyp:base', + ], + 'include_dirs': [ + '../../..', + ], + 'sources': [ + 'md5sum.cc', + ], + 'conditions': [ + [ 'order_profiling!=0 and OS=="android"', { + 'dependencies': [ '../../../tools/cygprofile/cygprofile.gyp:cygprofile', ], + }], + ], + }, + { + # GN: //tools/android/md5sum:md5sum_prepare_dist + 'target_name': 'md5sum_stripped_device_bin', + 'type': 'none', + 'dependencies': [ + 'md5sum_device_bin', + ], + 'actions': [ + { + 'action_name': 'strip_md5sum_device_bin', + 'inputs': ['<(PRODUCT_DIR)/md5sum_device_bin'], + 'outputs': ['<(PRODUCT_DIR)/md5sum_bin'], + 'action': [ + '<(android_strip)', + '--strip-unneeded', + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + }, + ], + }, + # Same binary but for the host rather than the device. + { + # GN: //tools/android/md5sum:md5sum_copy_host($default_toolchain) + 'target_name': 'md5sum_bin_host', + 'toolsets': ['host'], + 'type': 'executable', + 'dependencies': [ + '../../../base/base.gyp:base', + ], + 'include_dirs': [ + '../../..', + ], + 'sources': [ + 'md5sum.cc', + ], + }, + ], +}
diff --git a/tools/android/memconsumer/java/AndroidManifest.xml b/tools/android/memconsumer/java/AndroidManifest.xml new file mode 100644 index 0000000..c7f12e4 --- /dev/null +++ b/tools/android/memconsumer/java/AndroidManifest.xml
@@ -0,0 +1,23 @@ +<?xml version="1.0" encoding="utf-8"?> + +<!-- 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. + --> + +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="org.chromium.memconsumer" android:versionCode="1" + android:versionName="1.0"> + + <application + android:label="MemConsumer"> + <activity android:name=".MemConsumer" android:icon="@drawable/icon" android:launchMode="singleTop"> + <intent-filter> + <action android:name="android.intent.action.MAIN"/> + <category android:name="android.intent.category.LAUNCHER"/> + </intent-filter> + </activity> + <service android:name="ResidentService" android:enabled="true" /> + </application> + +</manifest>
diff --git a/tools/android/memconsumer/java/res/drawable/icon.png b/tools/android/memconsumer/java/res/drawable/icon.png new file mode 100644 index 0000000..cb10c9b --- /dev/null +++ b/tools/android/memconsumer/java/res/drawable/icon.png Binary files differ
diff --git a/tools/android/memconsumer/java/res/drawable/notification_icon.png b/tools/android/memconsumer/java/res/drawable/notification_icon.png new file mode 100644 index 0000000..7fc92c3 --- /dev/null +++ b/tools/android/memconsumer/java/res/drawable/notification_icon.png Binary files differ
diff --git a/tools/android/memconsumer/java/src/org/chromium/memconsumer/MemConsumer.java b/tools/android/memconsumer/java/src/org/chromium/memconsumer/MemConsumer.java new file mode 100644 index 0000000..17566f8 --- /dev/null +++ b/tools/android/memconsumer/java/src/org/chromium/memconsumer/MemConsumer.java
@@ -0,0 +1,107 @@ +// 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. + +package org.chromium.memconsumer; + +import android.app.Activity; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.os.Bundle; +import android.os.IBinder; +import android.view.Gravity; +import android.view.KeyEvent; +import android.view.View; +import android.widget.EditText; +import android.widget.NumberPicker; +import android.widget.TextView; + +public class MemConsumer extends Activity { + public static final String NOTIFICATION_ACTION = + MemConsumer.class.toString() + ".NOTIFICATION"; + + private ResidentService mResidentService; + private int mMemory = 0; + private NumberPicker mMemoryPicker; + + private ServiceConnection mServiceConnection = new ServiceConnection() { + @Override + public void onServiceConnected(ComponentName name, IBinder binder) { + mResidentService = ((ResidentService.ServiceBinder) binder).getService(); + mResidentService.useMemory(mMemory); + } + + @Override + public void onServiceDisconnected(ComponentName name) { + mResidentService = null; + } + }; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + mMemoryPicker = new NumberPicker(this); + mMemoryPicker.setGravity(Gravity.CENTER); + mMemoryPicker.setMaxValue(Integer.MAX_VALUE); + mMemoryPicker.setMinValue(0); + mMemoryPicker.setOnValueChangedListener(new NumberPicker.OnValueChangeListener() { + @Override + public void onValueChange(NumberPicker picker, int oldVal, int newVal) { + updateMemoryConsumption(picker.getValue()); + } + }); + for (int i = 0; i < mMemoryPicker.getChildCount(); i++) { + View child = mMemoryPicker.getChildAt(i); + if (child instanceof EditText) { + EditText editText = (EditText) child; + editText.setOnEditorActionListener(new TextView.OnEditorActionListener() { + @Override + public boolean onEditorAction (TextView v, int actionId, KeyEvent event) { + if (v.getText().length() > 0) { + updateMemoryConsumption(Integer.parseInt(v.getText().toString())); + } + return false; + } + }); + } + } + setContentView(mMemoryPicker); + onNewIntent(getIntent()); + } + + @Override + protected void onNewIntent(Intent intent) { + super.onNewIntent(intent); + if (intent.getAction() == NOTIFICATION_ACTION) { + updateMemoryConsumption(0); + return; + } + if (!intent.hasExtra("memory")) return; + updateMemoryConsumption(intent.getIntExtra("memory", 0)); + } + + void updateMemoryConsumption(int memory) { + if (memory == mMemory || memory < 0) return; + mMemory = memory; + mMemoryPicker.setValue(mMemory); + if (mResidentService == null) { + if (mMemory > 0) { + Intent resident = new Intent(); + resident.setClass(this, ResidentService.class); + startService(resident); + bindService(new Intent(this, ResidentService.class), + mServiceConnection, + Context.BIND_AUTO_CREATE); + } + } else { + mResidentService.useMemory(mMemory); + if (mMemory == 0) { + unbindService(mServiceConnection); + stopService(new Intent(this, ResidentService.class)); + mResidentService = null; + } + } + } +}
diff --git a/tools/android/memconsumer/java/src/org/chromium/memconsumer/ResidentService.java b/tools/android/memconsumer/java/src/org/chromium/memconsumer/ResidentService.java new file mode 100644 index 0000000..e40fbfe --- /dev/null +++ b/tools/android/memconsumer/java/src/org/chromium/memconsumer/ResidentService.java
@@ -0,0 +1,62 @@ +// 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. + +package org.chromium.memconsumer; + +import android.app.Notification; +import android.app.PendingIntent; +import android.app.Service; +import android.content.Intent; +import android.os.Binder; +import android.os.IBinder; + +public class ResidentService extends Service { + static { + // Loading the native library. + System.loadLibrary("memconsumer"); + } + + public class ServiceBinder extends Binder { + ResidentService getService() { + return ResidentService.this; + } + } + + private static final int RESIDENT_NOTIFICATION_ID = 1; + + private final IBinder mBinder = new ServiceBinder(); + private boolean mIsInForeground = false; + + @Override + public IBinder onBind(Intent intent) { + return mBinder; + } + + public void useMemory(long memory) { + if (memory > 0) { + Intent notificationIntent = new Intent(this, MemConsumer.class); + notificationIntent.setAction(MemConsumer.NOTIFICATION_ACTION); + PendingIntent pendingIntent = + PendingIntent.getActivity(this, 0, notificationIntent, 0); + Notification notification = + new Notification.Builder(getApplicationContext()). + setContentTitle("MC running (" + memory + "Mb)"). + setSmallIcon(R.drawable.notification_icon). + setDeleteIntent(pendingIntent). + setContentIntent(pendingIntent). + build(); + startForeground(RESIDENT_NOTIFICATION_ID, notification); + mIsInForeground = true; + } + if (mIsInForeground && memory == 0) { + stopForeground(true); + mIsInForeground = false; + } + nativeUseMemory(memory * 1024 * 1024); + } + + // Allocate the amount of memory in native code. Otherwise the memory + // allocation is limited by the framework. + private native void nativeUseMemory(long memory); +}
diff --git a/tools/android/memconsumer/memconsumer.gyp b/tools/android/memconsumer/memconsumer.gyp new file mode 100644 index 0000000..f721fc1 --- /dev/null +++ b/tools/android/memconsumer/memconsumer.gyp
@@ -0,0 +1,39 @@ +# 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. + +{ + 'targets': [ + { + 'target_name': 'memconsumer', + 'type': 'none', + 'dependencies': [ + 'memconsumer_apk', + ], + }, + { + 'target_name': 'memconsumer_apk', + 'type': 'none', + 'variables': { + 'apk_name': 'MemConsumer', + 'java_in_dir': 'java', + 'resource_dir': 'java/res', + 'native_lib_target': 'libmemconsumer', + }, + 'dependencies': [ + 'libmemconsumer', + ], + 'includes': [ '../../../build/java_apk.gypi' ], + }, + { + 'target_name': 'libmemconsumer', + 'type': 'shared_library', + 'sources': [ + 'memconsumer_hook.cc', + ], + 'libraries': [ + '-llog', + ], + }, + ], +}
diff --git a/tools/android/memconsumer/memconsumer_hook.cc b/tools/android/memconsumer/memconsumer_hook.cc new file mode 100644 index 0000000..9ae0bc1 --- /dev/null +++ b/tools/android/memconsumer/memconsumer_hook.cc
@@ -0,0 +1,55 @@ +// 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. + +#include <android/log.h> +#include <jni.h> +#include <stdio.h> +#include <string.h> + +extern "C" { +JNIEXPORT void JNICALL + Java_org_chromium_memconsumer_ResidentService_nativeUseMemory(JNIEnv* env, + jobject clazz, + jlong memory); +} + +namespace { + +uint32_t get_random() { + static uint32_t m_w = 1; + static uint32_t m_z = 1; + m_z = 36969 * (m_z & 65535) + (m_z >> 16); + m_w = 18000 * (m_w & 65535) + (m_w >> 16); + return (m_z << 16) + m_w; +} + +} // namespace + +JNIEXPORT void JNICALL + Java_org_chromium_memconsumer_ResidentService_nativeUseMemory( + JNIEnv* env, + jobject clazz, + jlong memory) { + static uint32_t* g_memory = NULL; + if (g_memory) + free(g_memory); + if (memory == 0) { + g_memory = NULL; + return; + } + g_memory = static_cast<uint32_t*>(malloc(memory)); + if (!g_memory) { + __android_log_print(ANDROID_LOG_WARN, + "MemConsumer", + "Unable to allocate %ld bytes", + memory); + } + // If memory allocation failed, try to allocate as much as possible. + while (!g_memory) { + memory /= 2; + g_memory = static_cast<uint32_t*>(malloc(memory)); + } + for (int i = 0; i < memory / sizeof(uint32_t); ++i) + *(g_memory + i) = get_random(); +}
diff --git a/tools/android/memdump/memdump.cc b/tools/android/memdump/memdump.cc new file mode 100644 index 0000000..cb4b05a --- /dev/null +++ b/tools/android/memdump/memdump.cc
@@ -0,0 +1,534 @@ +// 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. + +#include <fcntl.h> +#include <signal.h> +#include <sys/types.h> +#include <unistd.h> + +#include <algorithm> +#include <cstring> +#include <fstream> +#include <iostream> +#include <limits> +#include <string> +#include <utility> +#include <vector> + +#include "base/base64.h" +#include "base/basictypes.h" +#include "base/bind.h" +#include "base/callback_helpers.h" +#include "base/containers/hash_tables.h" +#include "base/files/file_util.h" +#include "base/files/scoped_file.h" +#include "base/format_macros.h" +#include "base/logging.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/string_split.h" +#include "base/strings/stringprintf.h" + +const unsigned int kPageSize = getpagesize(); + +namespace { + +class BitSet { + public: + void resize(size_t nbits) { + data_.resize((nbits + 7) / 8); + } + + void set(uint32 bit) { + const uint32 byte_idx = bit / 8; + CHECK(byte_idx < data_.size()); + data_[byte_idx] |= (1 << (bit & 7)); + } + + std::string AsB64String() const { + // Simple optimization: strip trailing zero bytes from the bitmap. + // For instance, if a region has 32 pages but only the first 9 are resident, + // The full bitmap would be 0xff 0x01 0x00 0x00, the stripped one 0xff 0x01. + // It can save up to some seconds when printing large mmaps, in particular + // in presence of large virtual address space reservations (where none of + // the pages are resident). + size_t end = data_.size(); + while (end > 0 && data_[end - 1] == '\0') + --end; + std::string bits(&data_[0], end); + std::string b64_string; + base::Base64Encode(bits, &b64_string); + return b64_string; + } + + private: + std::vector<char> data_; +}; + +// An entry in /proc/<pid>/pagemap. +struct PageMapEntry { + uint64 page_frame_number : 55; + uint unused : 8; + uint present : 1; +}; + +// Describes a memory page. +struct PageInfo { + int64 page_frame_number; // Physical page id, also known as PFN. + int64 flags; + int32 times_mapped; +}; + +struct PageCount { + PageCount() : total_count(0), unevictable_count(0) {} + + int total_count; + int unevictable_count; +}; + +struct MemoryMap { + std::string name; + std::string flags; + uint64 start_address; + uint64 end_address; + uint64 offset; + PageCount private_pages; + // app_shared_pages[i] contains the number of pages mapped in i+2 processes + // (only among the processes that are being analyzed). + std::vector<PageCount> app_shared_pages; + PageCount other_shared_pages; + std::vector<PageInfo> committed_pages; + // committed_pages_bits is a bitset reflecting the present bit for all the + // virtual pages of the mapping. + BitSet committed_pages_bits; +}; + +struct ProcessMemory { + pid_t pid; + std::vector<MemoryMap> memory_maps; +}; + +bool PageIsUnevictable(const PageInfo& page_info) { + // These constants are taken from kernel-page-flags.h. + const int KPF_DIRTY = 4; // Note that only file-mapped pages can be DIRTY. + const int KPF_ANON = 12; // Anonymous pages are dirty per definition. + const int KPF_UNEVICTABLE = 18; + const int KPF_MLOCKED = 33; + + return (page_info.flags & ((1ll << KPF_DIRTY) | + (1ll << KPF_ANON) | + (1ll << KPF_UNEVICTABLE) | + (1ll << KPF_MLOCKED))) ? + true : false; +} + +// Number of times a physical page is mapped in a process. +typedef base::hash_map<uint64, int> PFNMap; + +// Parses lines from /proc/<PID>/maps, e.g.: +// 401e7000-401f5000 r-xp 00000000 103:02 158 /system/bin/linker +bool ParseMemoryMapLine(const std::string& line, + std::vector<std::string>* tokens, + MemoryMap* memory_map) { + tokens->clear(); + base::SplitString(line, ' ', tokens); + if (tokens->size() < 2) + return false; + const std::string& addr_range = tokens->at(0); + std::vector<std::string> range_tokens; + base::SplitString(addr_range, '-', &range_tokens); + const std::string& start_address_token = range_tokens.at(0); + if (!base::HexStringToUInt64(start_address_token, + &memory_map->start_address)) { + return false; + } + const std::string& end_address_token = range_tokens.at(1); + if (!base::HexStringToUInt64(end_address_token, &memory_map->end_address)) { + return false; + } + if (tokens->at(1).size() != strlen("rwxp")) + return false; + memory_map->flags.swap(tokens->at(1)); + if (!base::HexStringToUInt64(tokens->at(2), &memory_map->offset)) + return false; + memory_map->committed_pages_bits.resize( + (memory_map->end_address - memory_map->start_address) / kPageSize); + const int map_name_index = 5; + if (tokens->size() >= map_name_index + 1) { + for (std::vector<std::string>::const_iterator it = + tokens->begin() + map_name_index; it != tokens->end(); ++it) { + if (!it->empty()) { + if (!memory_map->name.empty()) + memory_map->name.append(" "); + memory_map->name.append(*it); + } + } + } + return true; +} + +// Reads sizeof(T) bytes from file |fd| at |offset|. +template <typename T> +bool ReadFromFileAtOffset(int fd, off_t offset, T* value) { + if (lseek64(fd, offset * sizeof(*value), SEEK_SET) < 0) { + PLOG(ERROR) << "lseek"; + return false; + } + ssize_t bytes = read(fd, value, sizeof(*value)); + if (bytes != sizeof(*value) && bytes != 0) { + PLOG(ERROR) << "read"; + return false; + } + return true; +} + +// Fills |process_maps| in with the process memory maps identified by |pid|. +bool GetProcessMaps(pid_t pid, std::vector<MemoryMap>* process_maps) { + std::ifstream maps_file(base::StringPrintf("/proc/%d/maps", pid).c_str()); + if (!maps_file.good()) { + PLOG(ERROR) << "open"; + return false; + } + std::string line; + std::vector<std::string> tokens; + while (std::getline(maps_file, line) && !line.empty()) { + MemoryMap memory_map = {}; + if (!ParseMemoryMapLine(line, &tokens, &memory_map)) { + LOG(ERROR) << "Could not parse line: " << line; + return false; + } + process_maps->push_back(memory_map); + } + return true; +} + +// Fills |committed_pages| in with the set of committed pages contained in the +// provided memory map. +bool GetPagesForMemoryMap(int pagemap_fd, + const MemoryMap& memory_map, + std::vector<PageInfo>* committed_pages, + BitSet* committed_pages_bits) { + const off64_t offset = memory_map.start_address / kPageSize; + if (lseek64(pagemap_fd, offset * sizeof(PageMapEntry), SEEK_SET) < 0) { + PLOG(ERROR) << "lseek"; + return false; + } + for (uint64 addr = memory_map.start_address, page_index = 0; + addr < memory_map.end_address; + addr += kPageSize, ++page_index) { + DCHECK_EQ(0, addr % kPageSize); + PageMapEntry page_map_entry = {}; + COMPILE_ASSERT(sizeof(PageMapEntry) == sizeof(uint64), unexpected_size); + ssize_t bytes = read(pagemap_fd, &page_map_entry, sizeof(page_map_entry)); + if (bytes != sizeof(PageMapEntry) && bytes != 0) { + PLOG(ERROR) << "read"; + return false; + } + if (page_map_entry.present) { // Ignore non-committed pages. + if (page_map_entry.page_frame_number == 0) + continue; + PageInfo page_info = {}; + page_info.page_frame_number = page_map_entry.page_frame_number; + committed_pages->push_back(page_info); + committed_pages_bits->set(page_index); + } + } + return true; +} + +// Fills |committed_pages| with mapping count and flags information gathered +// looking-up /proc/kpagecount and /proc/kpageflags. +bool SetPagesInfo(int pagecount_fd, + int pageflags_fd, + std::vector<PageInfo>* pages) { + for (std::vector<PageInfo>::iterator it = pages->begin(); + it != pages->end(); ++it) { + PageInfo* const page_info = &*it; + int64 times_mapped; + if (!ReadFromFileAtOffset( + pagecount_fd, page_info->page_frame_number, ×_mapped)) { + return false; + } + DCHECK(times_mapped <= std::numeric_limits<int32_t>::max()); + page_info->times_mapped = static_cast<int32>(times_mapped); + + int64 page_flags; + if (!ReadFromFileAtOffset( + pageflags_fd, page_info->page_frame_number, &page_flags)) { + return false; + } + page_info->flags = page_flags; + } + return true; +} + +// Fills in the provided vector of Page Frame Number maps. This lets +// ClassifyPages() know how many times each page is mapped in the processes. +void FillPFNMaps(const std::vector<ProcessMemory>& processes_memory, + std::vector<PFNMap>* pfn_maps) { + int current_process_index = 0; + for (std::vector<ProcessMemory>::const_iterator it = processes_memory.begin(); + it != processes_memory.end(); ++it, ++current_process_index) { + const std::vector<MemoryMap>& memory_maps = it->memory_maps; + for (std::vector<MemoryMap>::const_iterator it = memory_maps.begin(); + it != memory_maps.end(); ++it) { + const std::vector<PageInfo>& pages = it->committed_pages; + for (std::vector<PageInfo>::const_iterator it = pages.begin(); + it != pages.end(); ++it) { + const PageInfo& page_info = *it; + PFNMap* const pfn_map = &(*pfn_maps)[current_process_index]; + const std::pair<PFNMap::iterator, bool> result = pfn_map->insert( + std::make_pair(page_info.page_frame_number, 0)); + ++result.first->second; + } + } + } +} + +// Sets the private_count/app_shared_pages/other_shared_count fields of the +// provided memory maps for each process. +void ClassifyPages(std::vector<ProcessMemory>* processes_memory) { + std::vector<PFNMap> pfn_maps(processes_memory->size()); + FillPFNMaps(*processes_memory, &pfn_maps); + // Hash set keeping track of the physical pages mapped in a single process so + // that they can be counted only once. + base::hash_set<uint64> physical_pages_mapped_in_process; + + for (std::vector<ProcessMemory>::iterator it = processes_memory->begin(); + it != processes_memory->end(); ++it) { + std::vector<MemoryMap>* const memory_maps = &it->memory_maps; + physical_pages_mapped_in_process.clear(); + for (std::vector<MemoryMap>::iterator it = memory_maps->begin(); + it != memory_maps->end(); ++it) { + MemoryMap* const memory_map = &*it; + const size_t processes_count = processes_memory->size(); + memory_map->app_shared_pages.resize(processes_count - 1); + const std::vector<PageInfo>& pages = memory_map->committed_pages; + for (std::vector<PageInfo>::const_iterator it = pages.begin(); + it != pages.end(); ++it) { + const PageInfo& page_info = *it; + if (page_info.times_mapped == 1) { + ++memory_map->private_pages.total_count; + if (PageIsUnevictable(page_info)) + ++memory_map->private_pages.unevictable_count; + continue; + } + const uint64 page_frame_number = page_info.page_frame_number; + const std::pair<base::hash_set<uint64>::iterator, bool> result = + physical_pages_mapped_in_process.insert(page_frame_number); + const bool did_insert = result.second; + if (!did_insert) { + // This physical page (mapped multiple times in the same process) was + // already counted. + continue; + } + // See if the current physical page is also mapped in the other + // processes that are being analyzed. + int times_mapped = 0; + int mapped_in_processes_count = 0; + for (std::vector<PFNMap>::const_iterator it = pfn_maps.begin(); + it != pfn_maps.end(); ++it) { + const PFNMap& pfn_map = *it; + const PFNMap::const_iterator found_it = pfn_map.find( + page_frame_number); + if (found_it == pfn_map.end()) + continue; + ++mapped_in_processes_count; + times_mapped += found_it->second; + } + PageCount* page_count_to_update = NULL; + if (times_mapped == page_info.times_mapped) { + // The physical page is only mapped in the processes that are being + // analyzed. + if (mapped_in_processes_count > 1) { + // The physical page is mapped in multiple processes. + page_count_to_update = + &memory_map->app_shared_pages[mapped_in_processes_count - 2]; + } else { + // The physical page is mapped multiple times in the same process. + page_count_to_update = &memory_map->private_pages; + } + } else { + page_count_to_update = &memory_map->other_shared_pages; + } + ++page_count_to_update->total_count; + if (PageIsUnevictable(page_info)) + ++page_count_to_update->unevictable_count; + } + } + } +} + +void AppendAppSharedField(const std::vector<PageCount>& app_shared_pages, + std::string* out) { + out->append("["); + for (std::vector<PageCount>::const_iterator it = app_shared_pages.begin(); + it != app_shared_pages.end(); ++it) { + out->append(base::IntToString(it->total_count * kPageSize)); + out->append(":"); + out->append(base::IntToString(it->unevictable_count * kPageSize)); + if (it + 1 != app_shared_pages.end()) + out->append(","); + } + out->append("]"); +} + +void DumpProcessesMemoryMapsInShortFormat( + const std::vector<ProcessMemory>& processes_memory) { + const int KB_PER_PAGE = kPageSize >> 10; + std::vector<int> totals_app_shared(processes_memory.size()); + std::string buf; + std::cout << "pid\tprivate\t\tshared_app\tshared_other (KB)\n"; + for (std::vector<ProcessMemory>::const_iterator it = processes_memory.begin(); + it != processes_memory.end(); ++it) { + const ProcessMemory& process_memory = *it; + std::fill(totals_app_shared.begin(), totals_app_shared.end(), 0); + int total_private = 0, total_other_shared = 0; + const std::vector<MemoryMap>& memory_maps = process_memory.memory_maps; + for (std::vector<MemoryMap>::const_iterator it = memory_maps.begin(); + it != memory_maps.end(); ++it) { + const MemoryMap& memory_map = *it; + total_private += memory_map.private_pages.total_count; + for (size_t i = 0; i < memory_map.app_shared_pages.size(); ++i) + totals_app_shared[i] += memory_map.app_shared_pages[i].total_count; + total_other_shared += memory_map.other_shared_pages.total_count; + } + double total_app_shared = 0; + for (size_t i = 0; i < totals_app_shared.size(); ++i) + total_app_shared += static_cast<double>(totals_app_shared[i]) / (i + 2); + base::SStringPrintf( + &buf, "%d\t%d\t\t%d\t\t%d\n", + process_memory.pid, + total_private * KB_PER_PAGE, + static_cast<int>(total_app_shared) * KB_PER_PAGE, + total_other_shared * KB_PER_PAGE); + std::cout << buf; + } +} + +void DumpProcessesMemoryMapsInExtendedFormat( + const std::vector<ProcessMemory>& processes_memory) { + std::string buf; + std::string app_shared_buf; + for (std::vector<ProcessMemory>::const_iterator it = processes_memory.begin(); + it != processes_memory.end(); ++it) { + const ProcessMemory& process_memory = *it; + std::cout << "[ PID=" << process_memory.pid << "]" << '\n'; + const std::vector<MemoryMap>& memory_maps = process_memory.memory_maps; + for (std::vector<MemoryMap>::const_iterator it = memory_maps.begin(); + it != memory_maps.end(); ++it) { + const MemoryMap& memory_map = *it; + app_shared_buf.clear(); + AppendAppSharedField(memory_map.app_shared_pages, &app_shared_buf); + base::SStringPrintf( + &buf, + "%"PRIx64"-%"PRIx64" %s %"PRIx64" private_unevictable=%d private=%d " + "shared_app=%s shared_other_unevictable=%d shared_other=%d " + "\"%s\" [%s]\n", + memory_map.start_address, + memory_map.end_address, + memory_map.flags.c_str(), + memory_map.offset, + memory_map.private_pages.unevictable_count * kPageSize, + memory_map.private_pages.total_count * kPageSize, + app_shared_buf.c_str(), + memory_map.other_shared_pages.unevictable_count * kPageSize, + memory_map.other_shared_pages.total_count * kPageSize, + memory_map.name.c_str(), + memory_map.committed_pages_bits.AsB64String().c_str()); + std::cout << buf; + } + } +} + +bool CollectProcessMemoryInformation(int page_count_fd, + int page_flags_fd, + ProcessMemory* process_memory) { + const pid_t pid = process_memory->pid; + base::ScopedFD pagemap_fd(HANDLE_EINTR(open( + base::StringPrintf("/proc/%d/pagemap", pid).c_str(), O_RDONLY))); + if (!pagemap_fd.is_valid()) { + PLOG(ERROR) << "open"; + return false; + } + std::vector<MemoryMap>* const process_maps = &process_memory->memory_maps; + if (!GetProcessMaps(pid, process_maps)) + return false; + for (std::vector<MemoryMap>::iterator it = process_maps->begin(); + it != process_maps->end(); ++it) { + std::vector<PageInfo>* const committed_pages = &it->committed_pages; + BitSet* const pages_bits = &it->committed_pages_bits; + GetPagesForMemoryMap(pagemap_fd.get(), *it, committed_pages, pages_bits); + SetPagesInfo(page_count_fd, page_flags_fd, committed_pages); + } + return true; +} + +void KillAll(const std::vector<pid_t>& pids, int signal_number) { + for (std::vector<pid_t>::const_iterator it = pids.begin(); it != pids.end(); + ++it) { + kill(*it, signal_number); + } +} + +void ExitWithUsage() { + LOG(ERROR) << "Usage: memdump [-a] <PID1>... <PIDN>"; + exit(EXIT_FAILURE); +} + +} // namespace + +int main(int argc, char** argv) { + if (argc == 1) + ExitWithUsage(); + const bool short_output = !strncmp(argv[1], "-a", 2); + if (short_output) { + if (argc == 2) + ExitWithUsage(); + ++argv; + } + std::vector<pid_t> pids; + for (const char* const* ptr = argv + 1; *ptr; ++ptr) { + pid_t pid; + if (!base::StringToInt(*ptr, &pid)) + return EXIT_FAILURE; + pids.push_back(pid); + } + + std::vector<ProcessMemory> processes_memory(pids.size()); + { + base::ScopedFD page_count_fd( + HANDLE_EINTR(open("/proc/kpagecount", O_RDONLY))); + if (!page_count_fd.is_valid()) { + PLOG(ERROR) << "open /proc/kpagecount"; + return EXIT_FAILURE; + } + + base::ScopedFD page_flags_fd(open("/proc/kpageflags", O_RDONLY)); + if (!page_flags_fd.is_valid()) { + PLOG(ERROR) << "open /proc/kpageflags"; + return EXIT_FAILURE; + } + + base::ScopedClosureRunner auto_resume_processes( + base::Bind(&KillAll, pids, SIGCONT)); + KillAll(pids, SIGSTOP); + for (std::vector<pid_t>::const_iterator it = pids.begin(); it != pids.end(); + ++it) { + ProcessMemory* const process_memory = + &processes_memory[it - pids.begin()]; + process_memory->pid = *it; + if (!CollectProcessMemoryInformation( + page_count_fd.get(), page_flags_fd.get(), process_memory)) { + return EXIT_FAILURE; + } + } + } + + ClassifyPages(&processes_memory); + if (short_output) + DumpProcessesMemoryMapsInShortFormat(processes_memory); + else + DumpProcessesMemoryMapsInExtendedFormat(processes_memory); + return EXIT_SUCCESS; +}
diff --git a/tools/android/memdump/memdump.gyp b/tools/android/memdump/memdump.gyp new file mode 100644 index 0000000..f47cedf --- /dev/null +++ b/tools/android/memdump/memdump.gyp
@@ -0,0 +1,39 @@ +# Copyright (c) 2012 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. + +{ + 'targets': [ + { + 'target_name': 'memdump-unstripped', + 'type': 'executable', + 'dependencies': [ + '../../../base/base.gyp:base', + ], + 'sources': [ + 'memdump.cc', + ], + }, + { + 'target_name': 'memdump', + 'type': 'none', + 'dependencies': [ + 'memdump-unstripped', + ], + 'actions': [ + { + 'action_name': 'strip_memdump', + 'inputs': ['<(PRODUCT_DIR)/memdump-unstripped'], + 'outputs': ['<(PRODUCT_DIR)/memdump'], + 'action': [ + '<(android_strip)', + '--strip-unneeded', + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + }, + ], + }, + ], +}
diff --git a/tools/android/memdump/memsymbols.py b/tools/android/memdump/memsymbols.py new file mode 100755 index 0000000..3721963 --- /dev/null +++ b/tools/android/memdump/memsymbols.py
@@ -0,0 +1,152 @@ +#!/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. + +import base64 +import os +import sys +import re + +from optparse import OptionParser + +"""Extracts the list of resident symbols of a library loaded in a process. + +This scripts combines the extended output of memdump for a given process +(obtained through memdump -x PID) and the symbol table of a .so loaded in that +process (obtained through nm -C lib-with-symbols.so), filtering out only those +symbols that, at the time of the snapshot, were resident in memory (that are, +the symbols which start address belongs to a mapped page of the .so which was +resident at the time of the snapshot). +The aim is to perform a "code coverage"-like profiling of a binary, intersecting +run-time information (list of resident pages) and debug symbols. +""" + +_PAGE_SIZE = 4096 + + +def _TestBit(word, bit): + assert(bit >= 0 and bit < 8) + return not not ((word >> bit) & 1) + + +def _HexAddr(addr): + return hex(addr)[2:].zfill(8) + + +def _GetResidentPagesSet(memdump_contents, lib_name, verbose): + """Parses the memdump output and extracts the resident page set for lib_name. + Args: + memdump_contents: Array of strings (lines) of a memdump output. + lib_name: A string containing the name of the library.so to be matched. + verbose: Print a verbose header for each mapping matched. + + Returns: + A set of resident pages (the key is the page index) for all the + mappings matching .*lib_name. + """ + resident_pages = set() + MAP_RX = re.compile( + r'^([0-9a-f]+)-([0-9a-f]+) ([\w-]+) ([0-9a-f]+) .* "(.*)" \[(.*)\]$') + for line in memdump_contents: + line = line.rstrip('\r\n') + if line.startswith('[ PID'): + continue + + r = MAP_RX.match(line) + if not r: + sys.stderr.write('Skipping %s from %s\n' % (line, memdump_file)) + continue + + map_start = int(r.group(1), 16) + map_end = int(r.group(2), 16) + prot = r.group(3) + offset = int(r.group(4), 16) + assert(offset % _PAGE_SIZE == 0) + lib = r.group(5) + enc_bitmap = r.group(6) + + if not lib.endswith(lib_name): + continue + + bitmap = base64.b64decode(enc_bitmap) + map_pages_count = (map_end - map_start + 1) / _PAGE_SIZE + bitmap_pages_count = len(bitmap) * 8 + + if verbose: + print 'Found %s: mapped %d pages in mode %s @ offset %s.' % ( + lib, map_pages_count, prot, _HexAddr(offset)) + print ' Map range in the process VA: [%s - %s]. Len: %s' % ( + _HexAddr(map_start), + _HexAddr(map_end), + _HexAddr(map_pages_count * _PAGE_SIZE)) + print ' Corresponding addresses in the binary: [%s - %s]. Len: %s' % ( + _HexAddr(offset), + _HexAddr(offset + map_end - map_start), + _HexAddr(map_pages_count * _PAGE_SIZE)) + print ' Bitmap: %d pages' % bitmap_pages_count + print '' + + assert(bitmap_pages_count >= map_pages_count) + for i in xrange(map_pages_count): + bitmap_idx = i / 8 + bitmap_off = i % 8 + if (bitmap_idx < len(bitmap) and + _TestBit(ord(bitmap[bitmap_idx]), bitmap_off)): + resident_pages.add(offset / _PAGE_SIZE + i) + return resident_pages + + +def main(argv): + NM_RX = re.compile(r'^([0-9a-f]+)\s+.*$') + + parser = OptionParser() + parser.add_option("-r", "--reverse", + action="store_true", dest="reverse", default=False, + help="Print out non present symbols") + parser.add_option("-v", "--verbose", + action="store_true", dest="verbose", default=False, + help="Print out verbose debug information.") + + (options, args) = parser.parse_args() + + if len(args) != 3: + print 'Usage: %s [-v] memdump.file nm.file library.so' % ( + os.path.basename(argv[0])) + return 1 + + memdump_file = args[0] + nm_file = args[1] + lib_name = args[2] + + if memdump_file == '-': + memdump_contents = sys.stdin.readlines() + else: + memdump_contents = open(memdump_file, 'r').readlines() + resident_pages = _GetResidentPagesSet(memdump_contents, + lib_name, + options.verbose) + + # Process the nm symbol table, filtering out the resident symbols. + nm_fh = open(nm_file, 'r') + for line in nm_fh: + line = line.rstrip('\r\n') + # Skip undefined symbols (lines with no address). + if line.startswith(' '): + continue + + r = NM_RX.match(line) + if not r: + sys.stderr.write('Skipping %s from %s\n' % (line, nm_file)) + continue + + sym_addr = int(r.group(1), 16) + sym_page = sym_addr / _PAGE_SIZE + last_sym_matched = (sym_page in resident_pages) + if (sym_page in resident_pages) != options.reverse: + print line + return 0 + +if __name__ == '__main__': + sys.exit(main(sys.argv))
diff --git a/tools/android/mempressure.py b/tools/android/mempressure.py new file mode 100755 index 0000000..fa3daba --- /dev/null +++ b/tools/android/mempressure.py
@@ -0,0 +1,112 @@ +#!/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. + +import collections +import logging +import optparse +import os +import sys + +BUILD_ANDROID_DIR = os.path.join(os.path.dirname(__file__), + os.pardir, + os.pardir, + 'build', + 'android') +sys.path.append(BUILD_ANDROID_DIR) +from pylib import android_commands +from pylib import constants +from pylib import flag_changer +from pylib.device import device_errors +from pylib.device import device_utils + +# Browser Constants +DEFAULT_BROWSER = 'chrome' + +# Action Constants +ACTION_PACKAGE = 'org.chromium.base' +ACTION_TRIM = { + 'moderate' : ACTION_PACKAGE + '.ACTION_TRIM_MEMORY_MODERATE', + 'critical' : ACTION_PACKAGE + '.ACTION_TRIM_MEMORY_RUNNING_CRITICAL', + 'complete' : ACTION_PACKAGE + '.ACTION_TRIM_MEMORY' +} +ACTION_LOW = ACTION_PACKAGE + '.ACTION_LOW_MEMORY' + +# Command Line Constants +ENABLE_TEST_INTENTS_FLAG = '--enable-test-intents' + +def main(argv): + option_parser = optparse.OptionParser() + option_parser.add_option('-l', + '--low', + help='Simulate Activity#onLowMemory()', + action='store_true') + option_parser.add_option('-t', + '--trim', + help=('Simulate Activity#onTrimMemory(...) with ' + + ', '.join(ACTION_TRIM.keys())), + type='string') + option_parser.add_option('-b', + '--browser', + default=DEFAULT_BROWSER, + help=('Which browser to use. One of ' + + ', '.join(constants.PACKAGE_INFO.keys()) + + ' [default: %default]'), + type='string') + + (options, args) = option_parser.parse_args(argv) + + if len(args) > 1: + print 'Unknown argument: ', args[1:] + option_parser.print_help() + sys.exit(1) + + if options.low and options.trim: + option_parser.error('options --low and --trim are mutually exclusive') + + if not options.low and not options.trim: + option_parser.print_help() + sys.exit(1) + + action = None + if options.low: + action = ACTION_LOW + elif options.trim in ACTION_TRIM.keys(): + action = ACTION_TRIM[options.trim] + + if action is None: + option_parser.print_help() + sys.exit(1) + + if not options.browser in constants.PACKAGE_INFO.keys(): + option_parser.error('Unknown browser option ' + options.browser) + + package_info = constants.PACKAGE_INFO[options.browser] + + package = package_info.package + activity = package_info.activity + + devices = android_commands.GetAttachedDevices() + if not devices: + raise device_errors.NoDevicesError() + elif len(devices) > 1: + logging.warning('Multiple devices attached. Using %s.' % devices[0]) + device = device_utils.DeviceUtils(devices[0]) + + try: + device.EnableRoot() + except device_errors.CommandFailedError as e: + # Try to change the flags and start the activity anyway. + # TODO(jbudorick) Handle this exception appropriately after interface + # conversions are finished. + logging.error(str(e)) + flags = flag_changer.FlagChanger(device, package_info.cmdline_file) + if ENABLE_TEST_INTENTS_FLAG not in flags.Get(): + flags.AddFlags([ENABLE_TEST_INTENTS_FLAG]) + + device.StartActivity(intent.Intent(package=package, activity=activity, + action=action)) + +if __name__ == '__main__': + sys.exit(main(sys.argv))
diff --git a/tools/android/ps_ext/ps_ext.c b/tools/android/ps_ext/ps_ext.c new file mode 100644 index 0000000..06cf7bc --- /dev/null +++ b/tools/android/ps_ext/ps_ext.c
@@ -0,0 +1,192 @@ +/* + * Copyright 2014 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. + */ + +#include <ctype.h> +#include <dirent.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> + +/* + * This tool is essentially an extended version of ps with JSON output. + * Its output is meant consumed by scripts / tools for gathering OS/ps stats. + * Output units: + * All times are expressed in ticks. + * All memory counters are expressed in Kb. + */ + +static void dump_time(void) { + float uptime_secs = 0.0F; + const long rate = sysconf(_SC_CLK_TCK); + FILE *f = fopen("/proc/uptime", "r"); + if (!f) + return; + fscanf(f, "%f", &uptime_secs); + fclose(f); + const long ticks = (long) (rate * uptime_secs); + printf(" \"time\": { \"ticks\": %ld, \"rate\": %ld}", ticks, rate); +} + +static void dump_cpu_stats(void) { + FILE *f = fopen("/proc/stat", "r"); + if (!f) + return; + printf(" \"cpu\":\n [\n"); + + bool terminate_prev_line = false; + while (!feof(f)) { + char line[256]; + char cpu[8]; + long unsigned t_usr = 0; + long unsigned t_nice = 0; + long unsigned t_sys = 0; + long unsigned t_idle = 0; + fgets(line, sizeof(line), f); + + /* Skip the total 'cpu ' line and the other irrelevant ones. */ + if (strncmp(line, "cpu", 3) != 0 || line[3] == ' ') + continue; + if (sscanf(line, "%s %lu %lu %lu %lu", + cpu, &t_usr, &t_nice, &t_sys, &t_idle) != 5) { + continue; + } + + if (terminate_prev_line) + printf(",\n"); + terminate_prev_line = true; + printf(" {\"usr\": %lu, \"sys\": %lu, \"idle\": %lu}", + t_usr + t_nice, t_sys, t_idle); + } + fclose(f); + printf("\n ]"); +} + +static void dump_mem_stats(void) { + FILE *f = fopen("/proc/meminfo", "r"); + if (!f) + return; + printf(" \"mem\":\n {\n"); + + bool terminate_prev_line = false; + while (!feof(f)) { + char line[256]; + char key[32]; + long value = 0; + + fgets(line, sizeof(line), f); + if (sscanf(line, "%s %lu %*s", key, &value) < 2) + continue; + + if (terminate_prev_line) + printf(",\n"); + terminate_prev_line = true; + printf(" \"%s\": %lu", key, value); + } + fclose(f); + printf("\n }"); +} + +static void dump_proc_stats(void) { + struct dirent *de; + DIR *d = opendir("/proc"); + if (!d) + return; + + const long kb_per_page = sysconf(_SC_PAGESIZE) / 1024; + bool terminate_prev_line = false; + printf(" \"processes\":\n {\n"); + while ((de = readdir(d))) { + if (!isdigit(de->d_name[0])) + continue; + const int pid = atoi(de->d_name); + + /* Don't print out ourselves (how civilized). */ + if (pid == getpid()) + continue; + + char cmdline[64]; + char fpath[32]; + FILE *f; + + /* Read full process path / package from cmdline. */ + sprintf(fpath, "/proc/%d/cmdline", pid); + f = fopen(fpath, "r"); + if (!f) + continue; + cmdline[0] = '\0'; + fgets(cmdline, sizeof(cmdline), f); + fclose(f); + + /* Read cpu/io/mem stats. */ + char proc_name[256]; + long num_threads = 0; + long unsigned min_faults = 0; + long unsigned maj_faults = 0; + long unsigned utime = 0; + long unsigned ktime = 0; + long unsigned vm_rss = 0; + long long unsigned start_time = 0; + + sprintf(fpath, "/proc/%d/stat", pid); + f = fopen(fpath, "r"); + if (!f) + continue; + fscanf(f, "%*d %s %*c %*d %*d %*d %*d %*d %*u %lu %*u %lu %*u %lu %lu " + "%*d %*d %*d %*d %ld %*d %llu %*u %ld", proc_name, &min_faults, + &maj_faults, &utime, &ktime, &num_threads, &start_time, &vm_rss); + fclose(f); + + /* Prefer the cmdline when available, since it contains the package name. */ + char const * const cmd = (strlen(cmdline) > 0) ? cmdline : proc_name; + + if (terminate_prev_line) + printf(",\n"); + terminate_prev_line = true; + printf(" \"%d\": {" + "\"name\": \"%s\", " + "\"n_threads\": %ld, " + "\"start_time\": %llu, " + "\"user_time\": %lu, " + "\"sys_time\": %lu, " + "\"min_faults\": %lu, " + "\"maj_faults\": %lu, " + "\"vm_rss\": %lu" + "}", + pid, + cmd, + num_threads, + start_time, + utime, + ktime, + min_faults, + maj_faults, + vm_rss * kb_per_page); + } + closedir(d); + printf("\n }"); +} + +int main() +{ + printf("{\n"); + + dump_time(); + printf(",\n"); + + dump_mem_stats(); + printf(",\n"); + + dump_cpu_stats(); + printf(",\n"); + + dump_proc_stats(); + printf("\n}\n"); + + return 0; +}
diff --git a/tools/android/ps_ext/ps_ext.gyp b/tools/android/ps_ext/ps_ext.gyp new file mode 100644 index 0000000..f467d93 --- /dev/null +++ b/tools/android/ps_ext/ps_ext.gyp
@@ -0,0 +1,36 @@ +# Copyright 2014 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. + +{ + 'targets': [ + { + 'target_name': 'ps_ext-unstripped', + 'type': 'executable', + 'sources': [ + 'ps_ext.c', + ], + }, + { + 'target_name': 'ps_ext', + 'type': 'none', + 'dependencies': [ + 'ps_ext-unstripped', + ], + 'actions': [ + { + 'action_name': 'strip_ps_ext', + 'inputs': ['<(PRODUCT_DIR)/ps_ext-unstripped'], + 'outputs': ['<(PRODUCT_DIR)/ps_ext'], + 'action': [ + '<(android_strip)', + '--strip-unneeded', + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + }, + ], + }, + ], +}
diff --git a/tools/android/purge_ashmem/purge_ashmem.c b/tools/android/purge_ashmem/purge_ashmem.c new file mode 100644 index 0000000..0de582d --- /dev/null +++ b/tools/android/purge_ashmem/purge_ashmem.c
@@ -0,0 +1,20 @@ +// 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. + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +#include "third_party/ashmem/ashmem.h" + +int main(void) { + const int pages_purged = ashmem_purge_all(); + if (pages_purged < 0) { + perror("ashmem_purge_all"); + return EXIT_FAILURE; + } + printf("Purged %d pages (%d KBytes)\n", + pages_purged, pages_purged * getpagesize() / 1024); + return EXIT_SUCCESS; +}
diff --git a/tools/android/purge_ashmem/purge_ashmem.gyp b/tools/android/purge_ashmem/purge_ashmem.gyp new file mode 100644 index 0000000..d563b1f --- /dev/null +++ b/tools/android/purge_ashmem/purge_ashmem.gyp
@@ -0,0 +1,21 @@ +# 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. + +{ + 'targets': [ + { + 'target_name': 'purge_ashmem', + 'type': 'executable', + 'dependencies': [ + '../../../third_party/ashmem/ashmem.gyp:ashmem', + ], + 'include_dirs': [ + '../../../', + ], + 'sources': [ + 'purge_ashmem.c', + ], + }, + ], +}
diff --git a/tools/android/remove_strings.py b/tools/android/remove_strings.py new file mode 100755 index 0000000..b8c4807 --- /dev/null +++ b/tools/android/remove_strings.py
@@ -0,0 +1,49 @@ +#!/usr/bin/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. + +"""Remove strings by name from a GRD file.""" + +import optparse +import re +import sys + + +def RemoveStrings(grd_path, string_names): + """Removes strings with the given names from a GRD file. Overwrites the file. + + Args: + grd_path: path to the GRD file. + string_names: a list of string names to be removed. + """ + with open(grd_path, 'r') as f: + grd = f.read() + names_pattern = '|'.join(map(re.escape, string_names)) + pattern = r'<message [^>]*name="(%s)".*?</message>\s*' % names_pattern + grd = re.sub(pattern, '', grd, flags=re.DOTALL) + with open(grd_path, 'w') as f: + f.write(grd) + + +def ParseArgs(args): + usage = 'usage: %prog GRD_PATH...' + parser = optparse.OptionParser( + usage=usage, description='Remove strings from GRD files. Reads string ' + 'names from stdin, and removes strings with those names from the listed ' + 'GRD files.') + options, args = parser.parse_args(args=args) + if not args: + parser.error('must provide GRD_PATH argument(s)') + return args + + +def main(args=None): + grd_paths = ParseArgs(args) + strings_to_remove = filter(None, map(str.strip, sys.stdin.readlines())) + for grd_path in grd_paths: + RemoveStrings(grd_path, strings_to_remove) + + +if __name__ == '__main__': + main()
diff --git a/tools/android/run_pie/run_pie.c b/tools/android/run_pie/run_pie.c new file mode 100644 index 0000000..ee1a622 --- /dev/null +++ b/tools/android/run_pie/run_pie.c
@@ -0,0 +1,68 @@ +// Copyright 2014 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. + +#include <dlfcn.h> +#include <stdio.h> +#include <string.h> +#include <sys/prctl.h> +#include <unistd.h> + +// This is a wrapper to run position independent executables on Android ICS, +// where the linker doesn't support PIE. This requires the PIE binaries to be +// built with CFLAGS +=-fvisibility=default -fPIE, and LDFLAGS += -rdynamic -pie +// such that the main() symbol remains exported and can be dlsym-ed. + +#define ERR_PREFIX "[PIE Loader] " + +typedef int (*main_t)(int, char**); + + +int main(int argc, char** argv) { + if (argc < 2) { + printf("Usage: %s path_to_pie_executable [args]\n", argv[0]); + return -1; + } + + // Shift left the argv[]. argv is what /proc/PID/cmdline prints out. In turn + // cmdline is what Android "ps" prints out. In turn "ps" is what many scripts + // look for to decide which processes to kill / killall. + int i; + char* next_argv_start = argv[0]; + for (i = 1; i < argc; ++i) { + const size_t argv_len = strlen(argv[i]) + 1; + memcpy(argv[i - 1], argv[i], argv_len); + next_argv_start += argv_len; + argv[i] = next_argv_start; + } + argv[argc - 1] = NULL; // The last argv must be a NULL ptr. + + // Set also the proc name accordingly (/proc/PID/comm). + prctl(PR_SET_NAME, (long) argv[0]); + + // dlopen should not fail, unless: + // - The target binary does not exists: + // - The dependent .so libs cannot be loaded. + // In both cases, just bail out with an explicit error message. + void* handle = dlopen(argv[0], RTLD_NOW); + if (handle == NULL) { + printf(ERR_PREFIX "dlopen() failed: %s.\n", dlerror()); + return -1; + } + + main_t pie_main = (main_t) dlsym(handle, "main"); + if (pie_main) { + return pie_main(argc - 1, argv); + } + + // If we reached this point dlsym failed, very likely because the target + // binary has not been compiled with the proper CFLAGS / LDFLAGS. + // At this point the most sensible thing to do is running that normally + // via exec and hope that the target binary wasn't a PIE. + execv(argv[0], argv); + + // exevc is supposed to never return, unless it fails. + printf(ERR_PREFIX "Both dlsym() and the execv() fallback failed.\n"); + perror("execv"); + return -1; +}
diff --git a/tools/android/run_pie/run_pie.gyp b/tools/android/run_pie/run_pie.gyp new file mode 100644 index 0000000..b713dc4 --- /dev/null +++ b/tools/android/run_pie/run_pie.gyp
@@ -0,0 +1,49 @@ +# Copyright 2014 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. + +{ + 'targets': [ + { + 'target_name': 'run_pie-unstripped', + 'type': 'executable', + 'sources': [ + 'run_pie.c', + ], + # See crbug.com/373219. This is the only Android executable which must be + # non PIE. + 'cflags!': [ + '-fPIE', + ], + 'ldflags!': [ + '-pie', + ], + # Don't inherit unneeded dependencies on stlport.so, so the binary remains + # self-contained also in component=shared_library builds. + 'libraries!': [ + '-l<(android_stlport_library)', + ], + }, + { + 'target_name': 'run_pie', + 'type': 'none', + 'dependencies': [ + 'run_pie-unstripped', + ], + 'actions': [ + { + 'action_name': 'strip_run_pie', + 'inputs': ['<(PRODUCT_DIR)/run_pie-unstripped'], + 'outputs': ['<(PRODUCT_DIR)/run_pie'], + 'action': [ + '<(android_strip)', + '--strip-unneeded', + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + }, + ], + }, + ], +}
