Merge "libutils: hide SharedBuffer by moving SharedBuffer.h to the implementation directory"
diff --git a/adb/__init__.py b/adb/__init__.py
deleted file mode 100644
index 6b509c6..0000000
--- a/adb/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Copyright (C) 2015 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-from __future__ import absolute_import
-from .device import * # pylint: disable=wildcard-import
diff --git a/adb/adb.cpp b/adb/adb.cpp
index 60966d6..19dd03d 100644
--- a/adb/adb.cpp
+++ b/adb/adb.cpp
@@ -334,7 +334,7 @@
#endif
connection_properties.push_back(android::base::StringPrintf(
- "features=%s", android::base::Join(supported_features(), ',').c_str()));
+ "features=%s", FeatureSetToString(supported_features()).c_str()));
return android::base::StringPrintf(
"%s::%s", adb_device_banner,
@@ -396,9 +396,7 @@
} else if (key == "ro.product.device") {
qual_overwrite(&t->device, value);
} else if (key == "features") {
- for (const auto& feature : android::base::Split(value, ",")) {
- t->add_feature(feature);
- }
+ t->SetFeatures(value);
}
}
}
@@ -1149,27 +1147,13 @@
std::string error_msg;
atransport* t = acquire_one_transport(kCsAny, type, serial, &error_msg);
if (t != nullptr) {
- SendOkay(reply_fd, android::base::Join(t->features(), '\n'));
+ SendOkay(reply_fd, FeatureSetToString(t->features()));
} else {
SendFail(reply_fd, error_msg);
}
return 0;
}
- if (!strncmp(service, "check-feature:", strlen("check-feature:"))) {
- std::string error_msg;
- atransport* t = acquire_one_transport(kCsAny, type, serial, &error_msg);
- if (t && t->CanUseFeature(service + strlen("check-feature:"))) {
- // We could potentially extend this to reply with the feature
- // version if that becomes necessary.
- SendOkay(reply_fd, "1");
- } else {
- // Empty response means unsupported feature.
- SendOkay(reply_fd, "");
- }
- return 0;
- }
-
// remove TCP transport
if (!strncmp(service, "disconnect:", 11)) {
const std::string address(service + 11);
diff --git a/adb/adb_trace.h b/adb/adb_trace.h
index 623108e..b4155df 100644
--- a/adb/adb_trace.h
+++ b/adb/adb_trace.h
@@ -50,9 +50,7 @@
#define D(...) \
do { \
if (ADB_TRACING) { \
- int saved_errno = errno; \
LOG(INFO) << android::base::StringPrintf(__VA_ARGS__); \
- errno = saved_errno; \
} \
} while (0)
diff --git a/adb/commandline.cpp b/adb/commandline.cpp
index d287480..4e93dee 100644
--- a/adb/commandline.cpp
+++ b/adb/commandline.cpp
@@ -36,6 +36,7 @@
#include <base/logging.h>
#include <base/stringprintf.h>
+#include <base/strings.h>
#if !defined(_WIN32)
#include <termios.h>
@@ -108,7 +109,9 @@
" adb sync [ <directory> ] - copy host->device only if changed\n"
" (-l means list but don't copy)\n"
" adb shell - run remote shell interactively\n"
- " adb shell <command> - run remote shell command\n"
+ " adb shell [-Tt] <command> - run remote shell command\n"
+ " (-T disables PTY allocation)\n"
+ " (-t forces PTY allocation)\n"
" adb emu <command> - run emulator console command\n"
" adb logcat [ <filter-spec> ] - View device log\n"
" adb forward --list - list all forward socket connections.\n"
@@ -475,9 +478,10 @@
return nullptr;
}
-static int interactive_shell(bool use_shell_protocol) {
+static int interactive_shell(const std::string& service_string,
+ bool use_shell_protocol) {
std::string error;
- int fd = adb_connect("shell:", &error);
+ int fd = adb_connect(service_string, &error);
if (fd < 0) {
fprintf(stderr,"error: %s\n", error.c_str());
return 1;
@@ -524,18 +528,16 @@
return android::base::StringPrintf("%s:%s", prefix, command);
}
-// Checks whether the device indicated by |transport_type| and |serial| supports
-// |feature|. Returns the response string, which will be empty if the device
-// could not be found or the feature is not supported.
-static std::string CheckFeature(const std::string& feature,
- TransportType transport_type,
+// Returns the FeatureSet for the indicated transport.
+static FeatureSet GetFeatureSet(TransportType transport_type,
const char* serial) {
- std::string result, error, command("check-feature:" + feature);
- if (!adb_query(format_host_command(command.c_str(), transport_type, serial),
- &result, &error)) {
- return "";
+ std::string result, error;
+
+ if (adb_query(format_host_command("features", transport_type, serial),
+ &result, &error)) {
+ return StringToFeatureSet(result);
}
- return result;
+ return FeatureSet();
}
static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz,
@@ -797,9 +799,8 @@
wait_for_device("wait-for-device", transport_type, serial);
}
- bool use_shell_protocol = !CheckFeature(kFeatureShell2, transport_type,
- serial).empty();
- int exit_code = read_and_dump(fd, use_shell_protocol);
+ FeatureSet features = GetFeatureSet(transport_type, serial);
+ int exit_code = read_and_dump(fd, features.count(kFeatureShell2) > 0);
if (adb_close(fd) < 0) {
PLOG(ERROR) << "failure closing FD " << fd;
@@ -1238,24 +1239,44 @@
else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) {
char h = (argv[0][0] == 'h');
+ FeatureSet features = GetFeatureSet(transport_type, serial);
+
+ bool use_shell_protocol = (features.count(kFeatureShell2) > 0);
+ if (!use_shell_protocol) {
+ D("shell protocol not supported, using raw data transfer");
+ } else {
+ D("using shell protocol");
+ }
+
+ // Parse shell-specific command-line options.
+ // argv[0] is always "shell".
+ --argc;
+ ++argv;
+ std::string shell_type_arg;
+ while (argc) {
+ if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) {
+ if (features.count(kFeatureShell2) == 0) {
+ fprintf(stderr, "error: target doesn't support PTY args -Tt\n");
+ return 1;
+ }
+ shell_type_arg = argv[0];
+ --argc;
+ ++argv;
+ } else {
+ break;
+ }
+ }
+ std::string service_string = android::base::StringPrintf(
+ "shell%s:", shell_type_arg.c_str());
+
if (h) {
printf("\x1b[41;33m");
fflush(stdout);
}
- bool use_shell_protocol;
- if (CheckFeature(kFeatureShell2, transport_type, serial).empty()) {
- D("shell protocol not supported, using raw data transfer");
- use_shell_protocol = false;
- } else {
- D("using shell protocol");
- use_shell_protocol = true;
- }
-
-
- if (argc < 2) {
+ if (!argc) {
D("starting interactive shell");
- r = interactive_shell(use_shell_protocol);
+ r = interactive_shell(service_string, use_shell_protocol);
if (h) {
printf("\x1b[0m");
fflush(stdout);
@@ -1263,19 +1284,14 @@
return r;
}
- std::string cmd = "shell:";
- --argc;
- ++argv;
- while (argc-- > 0) {
- // We don't escape here, just like ssh(1). http://b/20564385.
- cmd += *argv++;
- if (*argv) cmd += " ";
- }
+ // We don't escape here, just like ssh(1). http://b/20564385.
+ service_string += android::base::Join(
+ std::vector<const char*>(argv, argv + argc), ' ');
while (true) {
- D("non-interactive shell loop. cmd=%s", cmd.c_str());
+ D("non-interactive shell loop. cmd=%s", service_string.c_str());
std::string error;
- int fd = adb_connect(cmd, &error);
+ int fd = adb_connect(service_string, &error);
int r;
if (fd >= 0) {
D("about to read_and_dump(fd=%d)", fd);
@@ -1545,7 +1561,14 @@
return 0;
}
else if (!strcmp(argv[0], "features")) {
- return adb_query_command(format_host_command("features", transport_type, serial));
+ // Only list the features common to both the adb client and the device.
+ FeatureSet features = GetFeatureSet(transport_type, serial);
+ for (const std::string& name : features) {
+ if (supported_features().count(name) > 0) {
+ printf("%s\n", name.c_str());
+ }
+ }
+ return 0;
}
usage();
diff --git a/adb/device.py b/adb/device.py
deleted file mode 100644
index 516e880..0000000
--- a/adb/device.py
+++ /dev/null
@@ -1,339 +0,0 @@
-#
-# Copyright (C) 2015 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import logging
-import os
-import re
-import subprocess
-import tempfile
-
-
-class FindDeviceError(RuntimeError):
- pass
-
-
-class DeviceNotFoundError(FindDeviceError):
- def __init__(self, serial):
- self.serial = serial
- super(DeviceNotFoundError, self).__init__(
- 'No device with serial {}'.format(serial))
-
-
-class NoUniqueDeviceError(FindDeviceError):
- def __init__(self):
- super(NoUniqueDeviceError, self).__init__('No unique device')
-
-
-class ShellError(RuntimeError):
- def __init__(self, cmd, stdout, stderr, exit_code):
- super(ShellError, self).__init__(
- '`{0}` exited with code {1}'.format(cmd, exit_code))
- self.cmd = cmd
- self.stdout = stdout
- self.stderr = stderr
- self.exit_code = exit_code
-
-
-def get_devices():
- with open(os.devnull, 'wb') as devnull:
- subprocess.check_call(['adb', 'start-server'], stdout=devnull,
- stderr=devnull)
- out = subprocess.check_output(['adb', 'devices']).splitlines()
-
- # The first line of `adb devices` just says "List of attached devices", so
- # skip that.
- devices = []
- for line in out[1:]:
- if not line.strip():
- continue
- if 'offline' in line:
- continue
-
- serial, _ = re.split(r'\s+', line, maxsplit=1)
- devices.append(serial)
- return devices
-
-
-def _get_unique_device(product=None):
- devices = get_devices()
- if len(devices) != 1:
- raise NoUniqueDeviceError()
- return AndroidDevice(devices[0], product)
-
-
-def _get_device_by_serial(serial, product=None):
- for device in get_devices():
- if device == serial:
- return AndroidDevice(serial, product)
- raise DeviceNotFoundError(serial)
-
-
-def get_device(serial=None, product=None):
- """Get a uniquely identified AndroidDevice if one is available.
-
- Raises:
- DeviceNotFoundError:
- The serial specified by `serial` or $ANDROID_SERIAL is not
- connected.
-
- NoUniqueDeviceError:
- Neither `serial` nor $ANDROID_SERIAL was set, and the number of
- devices connected to the system is not 1. Having 0 connected
- devices will also result in this error.
-
- Returns:
- An AndroidDevice associated with the first non-None identifier in the
- following order of preference:
-
- 1) The `serial` argument.
- 2) The environment variable $ANDROID_SERIAL.
- 3) The single device connnected to the system.
- """
- if serial is not None:
- return _get_device_by_serial(serial, product)
-
- android_serial = os.getenv('ANDROID_SERIAL')
- if android_serial is not None:
- return _get_device_by_serial(android_serial, product)
-
- return _get_unique_device(product)
-
-# Call this instead of subprocess.check_output() to work-around issue in Python
-# 2's subprocess class on Windows where it doesn't support Unicode. This
-# writes the command line to a UTF-8 batch file that is properly interpreted
-# by cmd.exe.
-def _subprocess_check_output(*popenargs, **kwargs):
- # Only do this slow work-around if Unicode is in the cmd line.
- if (os.name == 'nt' and
- any(isinstance(arg, unicode) for arg in popenargs[0])):
- # cmd.exe requires a suffix to know that it is running a batch file
- tf = tempfile.NamedTemporaryFile('wb', suffix='.cmd', delete=False)
- # @ in batch suppresses echo of the current line.
- # Change the codepage to 65001, the UTF-8 codepage.
- tf.write('@chcp 65001 > nul\r\n')
- tf.write('@')
- # Properly quote all the arguments and encode in UTF-8.
- tf.write(subprocess.list2cmdline(popenargs[0]).encode('utf-8'))
- tf.close()
-
- try:
- result = subprocess.check_output(['cmd.exe', '/c', tf.name],
- **kwargs)
- except subprocess.CalledProcessError as e:
- # Show real command line instead of the cmd.exe command line.
- raise subprocess.CalledProcessError(e.returncode, popenargs[0],
- output=e.output)
- finally:
- os.remove(tf.name)
- return result
- else:
- return subprocess.check_output(*popenargs, **kwargs)
-
-class AndroidDevice(object):
- # Delimiter string to indicate the start of the exit code.
- _RETURN_CODE_DELIMITER = 'x'
-
- # Follow any shell command with this string to get the exit
- # status of a program since this isn't propagated by adb.
- #
- # The delimiter is needed because `printf 1; echo $?` would print
- # "10", and we wouldn't be able to distinguish the exit code.
- _RETURN_CODE_PROBE_STRING = 'echo "{0}$?"'.format(_RETURN_CODE_DELIMITER)
-
- # Maximum search distance from the output end to find the delimiter.
- # adb on Windows returns \r\n even if adbd returns \n.
- _RETURN_CODE_SEARCH_LENGTH = len('{0}255\r\n'.format(_RETURN_CODE_DELIMITER))
-
- # Shell protocol feature string.
- SHELL_PROTOCOL_FEATURE = 'shell_2'
-
- def __init__(self, serial, product=None):
- self.serial = serial
- self.product = product
- self.adb_cmd = ['adb']
- if self.serial is not None:
- self.adb_cmd.extend(['-s', serial])
- if self.product is not None:
- self.adb_cmd.extend(['-p', product])
- self._linesep = None
- self._features = None
-
- @property
- def linesep(self):
- if self._linesep is None:
- self._linesep = subprocess.check_output(self.adb_cmd +
- ['shell', 'echo'])
- return self._linesep
-
- @property
- def features(self):
- if self._features is None:
- try:
- self._features = self._simple_call(['features']).splitlines()
- except subprocess.CalledProcessError:
- self._features = []
- return self._features
-
- def _make_shell_cmd(self, user_cmd):
- command = self.adb_cmd + ['shell'] + user_cmd
- if self.SHELL_PROTOCOL_FEATURE not in self.features:
- command.append('; ' + self._RETURN_CODE_PROBE_STRING)
- return command
-
- def _parse_shell_output(self, out):
- """Finds the exit code string from shell output.
-
- Args:
- out: Shell output string.
-
- Returns:
- An (exit_code, output_string) tuple. The output string is
- cleaned of any additional stuff we appended to find the
- exit code.
-
- Raises:
- RuntimeError: Could not find the exit code in |out|.
- """
- search_text = out
- if len(search_text) > self._RETURN_CODE_SEARCH_LENGTH:
- # We don't want to search over massive amounts of data when we know
- # the part we want is right at the end.
- search_text = search_text[-self._RETURN_CODE_SEARCH_LENGTH:]
- partition = search_text.rpartition(self._RETURN_CODE_DELIMITER)
- if partition[1] == '':
- raise RuntimeError('Could not find exit status in shell output.')
- result = int(partition[2])
- # partition[0] won't contain the full text if search_text was truncated,
- # pull from the original string instead.
- out = out[:-len(partition[1]) - len(partition[2])]
- return result, out
-
- def _simple_call(self, cmd):
- logging.info(' '.join(self.adb_cmd + cmd))
- return _subprocess_check_output(
- self.adb_cmd + cmd, stderr=subprocess.STDOUT)
-
- def shell(self, cmd):
- """Calls `adb shell`
-
- Args:
- cmd: string shell command to execute.
-
- Returns:
- A (stdout, stderr) tuple. Stderr may be combined into stdout
- if the device doesn't support separate streams.
-
- Raises:
- ShellError: the exit code was non-zero.
- """
- exit_code, stdout, stderr = self.shell_nocheck(cmd)
- if exit_code != 0:
- raise ShellError(cmd, stdout, stderr, exit_code)
- return stdout, stderr
-
- def shell_nocheck(self, cmd):
- """Calls `adb shell`
-
- Args:
- cmd: string shell command to execute.
-
- Returns:
- An (exit_code, stdout, stderr) tuple. Stderr may be combined
- into stdout if the device doesn't support separate streams.
- """
- cmd = self._make_shell_cmd(cmd)
- logging.info(' '.join(cmd))
- p = subprocess.Popen(
- cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- stdout, stderr = p.communicate()
- if self.SHELL_PROTOCOL_FEATURE in self.features:
- exit_code = p.returncode
- else:
- exit_code, stdout = self._parse_shell_output(stdout)
- return exit_code, stdout, stderr
-
- def install(self, filename, replace=False):
- cmd = ['install']
- if replace:
- cmd.append('-r')
- cmd.append(filename)
- return self._simple_call(cmd)
-
- def push(self, local, remote):
- return self._simple_call(['push', local, remote])
-
- def pull(self, remote, local):
- return self._simple_call(['pull', remote, local])
-
- def sync(self, directory=None):
- cmd = ['sync']
- if directory is not None:
- cmd.append(directory)
- return self._simple_call(cmd)
-
- def forward(self, local, remote):
- return self._simple_call(['forward', local, remote])
-
- def tcpip(self, port):
- return self._simple_call(['tcpip', port])
-
- def usb(self):
- return self._simple_call(['usb'])
-
- def reboot(self):
- return self._simple_call(['reboot'])
-
- def root(self):
- return self._simple_call(['root'])
-
- def unroot(self):
- return self._simple_call(['unroot'])
-
- def forward_remove(self, local):
- return self._simple_call(['forward', '--remove', local])
-
- def forward_remove_all(self):
- return self._simple_call(['forward', '--remove-all'])
-
- def connect(self, host):
- return self._simple_call(['connect', host])
-
- def disconnect(self, host):
- return self._simple_call(['disconnect', host])
-
- def reverse(self, remote, local):
- return self._simple_call(['reverse', remote, local])
-
- def reverse_remove_all(self):
- return self._simple_call(['reverse', '--remove-all'])
-
- def reverse_remove(self, remote):
- return self._simple_call(['reverse', '--remove', remote])
-
- def wait(self):
- return self._simple_call(['wait-for-device'])
-
- def get_prop(self, prop_name):
- output = self.shell(['getprop', prop_name])[0].splitlines()
- if len(output) != 1:
- raise RuntimeError('Too many lines in getprop output:\n' +
- '\n'.join(output))
- value = output[0]
- if not value.strip():
- return None
- return value
-
- def set_prop(self, prop_name, value):
- self.shell(['setprop', prop_name, value])
diff --git a/adb/services.cpp b/adb/services.cpp
index d128efc..d0494ec 100644
--- a/adb/services.cpp
+++ b/adb/services.cpp
@@ -194,7 +194,39 @@
adb_close(fd);
}
-#endif
+// Shell service string can look like:
+// shell[args]:[command]
+// Currently the only supported args are -T (force raw) and -t (force PTY).
+static int ShellService(const std::string& args, const atransport* transport) {
+ size_t delimiter_index = args.find(':');
+ if (delimiter_index == std::string::npos) {
+ LOG(ERROR) << "No ':' found in shell service arguments: " << args;
+ return -1;
+ }
+ const std::string service_args = args.substr(0, delimiter_index);
+ const std::string command = args.substr(delimiter_index + 1);
+
+ SubprocessType type;
+ if (service_args.empty()) {
+ // Default: use PTY for interactive, raw for non-interactive.
+ type = (command.empty() ? SubprocessType::kPty : SubprocessType::kRaw);
+ } else if (service_args == "-T") {
+ type = SubprocessType::kRaw;
+ } else if (service_args == "-t") {
+ type = SubprocessType::kPty;
+ } else {
+ LOG(ERROR) << "Unsupported shell service arguments: " << args;
+ return -1;
+ }
+
+ SubprocessProtocol protocol =
+ (transport->CanUseFeature(kFeatureShell2) ? SubprocessProtocol::kShell
+ : SubprocessProtocol::kNone);
+
+ return StartSubprocess(command.c_str(), type, protocol);
+}
+
+#endif // !ADB_HOST
static int create_service_thread(void (*func)(int, void *), void *cookie)
{
@@ -265,14 +297,8 @@
ret = create_service_thread(framebuffer_service, 0);
} else if (!strncmp(name, "jdwp:", 5)) {
ret = create_jdwp_connection_fd(atoi(name+5));
- } else if(!strncmp(name, "shell:", 6)) {
- const char* args = name + 6;
- // Use raw for non-interactive, PTY for interactive.
- SubprocessType type = (*args ? SubprocessType::kRaw : SubprocessType::kPty);
- SubprocessProtocol protocol =
- (transport->CanUseFeature(kFeatureShell2) ? SubprocessProtocol::kShell
- : SubprocessProtocol::kNone);
- ret = StartSubprocess(args, type, protocol);
+ } else if(!strncmp(name, "shell", 5)) {
+ ret = ShellService(name + 5, transport);
} else if(!strncmp(name, "exec:", 5)) {
ret = StartSubprocess(name + 5, SubprocessType::kRaw,
SubprocessProtocol::kNone);
diff --git a/adb/test_adb.py b/adb/test_adb.py
index 59aa14d..5bda22f 100644
--- a/adb/test_adb.py
+++ b/adb/test_adb.py
@@ -21,8 +21,10 @@
"""
from __future__ import print_function
+import os
import random
import subprocess
+import threading
import unittest
import adb
@@ -63,6 +65,80 @@
self.assertEqual(1, p.returncode)
self.assertIn('error', out)
+ # Helper method that reads a pipe until it is closed, then sets the event.
+ def _read_pipe_and_set_event(self, pipe, event):
+ x = pipe.read()
+ event.set()
+
+ # Test that launch_server() does not let the adb server inherit
+ # stdin/stdout/stderr handles which can cause callers of adb.exe to hang.
+ # This test also runs fine on unix even though the impetus is an issue
+ # unique to Windows.
+ def test_handle_inheritance(self):
+ # This test takes 5 seconds to run on Windows: if there is no adb server
+ # running on the the port used below, adb kill-server tries to make a
+ # TCP connection to a closed port and that takes 1 second on Windows;
+ # adb start-server does the same TCP connection which takes another
+ # second, and it waits 3 seconds after starting the server.
+
+ # Start adb client with redirected stdin/stdout/stderr to check if it
+ # passes those redirections to the adb server that it starts. To do
+ # this, run an instance of the adb server on a non-default port so we
+ # don't conflict with a pre-existing adb server that may already be
+ # setup with adb TCP/emulator connections. If there is a pre-existing
+ # adb server, this also tests whether multiple instances of the adb
+ # server conflict on adb.log.
+
+ port = 5038
+ # Kill any existing server on this non-default port.
+ subprocess.check_output(['adb', '-P', str(port), 'kill-server'],
+ stderr=subprocess.STDOUT)
+
+ try:
+ # Run the adb client and have it start the adb server.
+ p = subprocess.Popen(['adb', '-P', str(port), 'start-server'],
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+
+ # Start threads that set events when stdout/stderr are closed.
+ stdout_event = threading.Event()
+ stdout_thread = threading.Thread(
+ target=self._read_pipe_and_set_event,
+ args=(p.stdout, stdout_event))
+ stdout_thread.daemon = True
+ stdout_thread.start()
+
+ stderr_event = threading.Event()
+ stderr_thread = threading.Thread(
+ target=self._read_pipe_and_set_event,
+ args=(p.stderr, stderr_event))
+ stderr_thread.daemon = True
+ stderr_thread.start()
+
+ # Wait for the adb client to finish. Once that has occurred, if
+ # stdin/stderr/stdout are still open, it must be open in the adb
+ # server.
+ p.wait()
+
+ # Try to write to stdin which we expect is closed. If it isn't
+ # closed, we should get an IOError. If we don't get an IOError,
+ # stdin must still be open in the adb server. The adb client is
+ # probably letting the adb server inherit stdin which would be
+ # wrong.
+ with self.assertRaises(IOError):
+ p.stdin.write('x')
+
+ # Wait a few seconds for stdout/stderr to be closed (in the success
+ # case, this won't wait at all). If there is a timeout, that means
+ # stdout/stderr were not closed and and they must be open in the adb
+ # server, suggesting that the adb client is letting the adb server
+ # inherit stdout/stderr which would be wrong.
+ self.assertTrue(stdout_event.wait(5), "adb stdout not closed")
+ self.assertTrue(stderr_event.wait(5), "adb stderr not closed")
+ finally:
+ # If we started a server, kill it.
+ subprocess.check_output(['adb', '-P', str(port), 'kill-server'],
+ stderr=subprocess.STDOUT)
def main():
random.seed(0)
diff --git a/adb/test_device.py b/adb/test_device.py
deleted file mode 100644
index d033a01..0000000
--- a/adb/test_device.py
+++ /dev/null
@@ -1,537 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2015 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-from __future__ import print_function
-
-import hashlib
-import os
-import posixpath
-import random
-import shlex
-import shutil
-import signal
-import subprocess
-import tempfile
-import unittest
-
-import mock
-
-import adb
-
-
-def requires_root(func):
- def wrapper(self, *args):
- if self.device.get_prop('ro.debuggable') != '1':
- raise unittest.SkipTest('requires rootable build')
-
- was_root = self.device.shell(['id', '-un'])[0].strip() == 'root'
- if not was_root:
- self.device.root()
- self.device.wait()
-
- try:
- func(self, *args)
- finally:
- if not was_root:
- self.device.unroot()
- self.device.wait()
-
- return wrapper
-
-
-class GetDeviceTest(unittest.TestCase):
- def setUp(self):
- self.android_serial = os.getenv('ANDROID_SERIAL')
- if 'ANDROID_SERIAL' in os.environ:
- del os.environ['ANDROID_SERIAL']
-
- def tearDown(self):
- if self.android_serial is not None:
- os.environ['ANDROID_SERIAL'] = self.android_serial
- else:
- if 'ANDROID_SERIAL' in os.environ:
- del os.environ['ANDROID_SERIAL']
-
- @mock.patch('adb.device.get_devices')
- def test_explicit(self, mock_get_devices):
- mock_get_devices.return_value = ['foo', 'bar']
- device = adb.get_device('foo')
- self.assertEqual(device.serial, 'foo')
-
- @mock.patch('adb.device.get_devices')
- def test_from_env(self, mock_get_devices):
- mock_get_devices.return_value = ['foo', 'bar']
- os.environ['ANDROID_SERIAL'] = 'foo'
- device = adb.get_device()
- self.assertEqual(device.serial, 'foo')
-
- @mock.patch('adb.device.get_devices')
- def test_arg_beats_env(self, mock_get_devices):
- mock_get_devices.return_value = ['foo', 'bar']
- os.environ['ANDROID_SERIAL'] = 'bar'
- device = adb.get_device('foo')
- self.assertEqual(device.serial, 'foo')
-
- @mock.patch('adb.device.get_devices')
- def test_no_such_device(self, mock_get_devices):
- mock_get_devices.return_value = ['foo', 'bar']
- self.assertRaises(adb.DeviceNotFoundError, adb.get_device, ['baz'])
-
- os.environ['ANDROID_SERIAL'] = 'baz'
- self.assertRaises(adb.DeviceNotFoundError, adb.get_device)
-
- @mock.patch('adb.device.get_devices')
- def test_unique_device(self, mock_get_devices):
- mock_get_devices.return_value = ['foo']
- device = adb.get_device()
- self.assertEqual(device.serial, 'foo')
-
- @mock.patch('adb.device.get_devices')
- def test_no_unique_device(self, mock_get_devices):
- mock_get_devices.return_value = ['foo', 'bar']
- self.assertRaises(adb.NoUniqueDeviceError, adb.get_device)
-
-
-class DeviceTest(unittest.TestCase):
- def setUp(self):
- self.device = adb.get_device()
-
-
-class ShellTest(DeviceTest):
- def test_cat(self):
- """Check that we can at least cat a file."""
- out = self.device.shell(['cat', '/proc/uptime'])[0].strip()
- elements = out.split()
- self.assertEqual(len(elements), 2)
-
- uptime, idle = elements
- self.assertGreater(float(uptime), 0.0)
- self.assertGreater(float(idle), 0.0)
-
- def test_throws_on_failure(self):
- self.assertRaises(adb.ShellError, self.device.shell, ['false'])
-
- def test_output_not_stripped(self):
- out = self.device.shell(['echo', 'foo'])[0]
- self.assertEqual(out, 'foo' + self.device.linesep)
-
- def test_shell_nocheck_failure(self):
- rc, out, _ = self.device.shell_nocheck(['false'])
- self.assertNotEqual(rc, 0)
- self.assertEqual(out, '')
-
- def test_shell_nocheck_output_not_stripped(self):
- rc, out, _ = self.device.shell_nocheck(['echo', 'foo'])
- self.assertEqual(rc, 0)
- self.assertEqual(out, 'foo' + self.device.linesep)
-
- def test_can_distinguish_tricky_results(self):
- # If result checking on ADB shell is naively implemented as
- # `adb shell <cmd>; echo $?`, we would be unable to distinguish the
- # output from the result for a cmd of `echo -n 1`.
- rc, out, _ = self.device.shell_nocheck(['echo', '-n', '1'])
- self.assertEqual(rc, 0)
- self.assertEqual(out, '1')
-
- def test_line_endings(self):
- """Ensure that line ending translation is not happening in the pty.
-
- Bug: http://b/19735063
- """
- output = self.device.shell(['uname'])[0]
- self.assertEqual(output, 'Linux' + self.device.linesep)
-
- def test_pty_logic(self):
- """Verify PTY logic for shells.
-
- Interactive shells should use a PTY, non-interactive should not.
-
- Bug: http://b/21215503
- """
- proc = subprocess.Popen(
- self.device.adb_cmd + ['shell'], stdin=subprocess.PIPE,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
- # [ -t 0 ] is used (rather than `tty`) to provide portability. This
- # gives an exit code of 0 iff stdin is connected to a terminal.
- #
- # Closing host-side stdin doesn't currently trigger the interactive
- # shell to exit so we need to explicitly add an exit command to
- # close the session from the device side, and append \n to complete
- # the interactive command.
- result = proc.communicate('[ -t 0 ]; echo x$?; exit 0\n')[0]
- partition = result.rpartition('x')
- self.assertEqual(partition[1], 'x')
- self.assertEqual(int(partition[2]), 0)
-
- exit_code = self.device.shell_nocheck(['[ -t 0 ]'])[0]
- self.assertEqual(exit_code, 1)
-
- def test_shell_protocol(self):
- """Tests the shell protocol on the device.
-
- If the device supports shell protocol, this gives us the ability
- to separate stdout/stderr and return the exit code directly.
-
- Bug: http://b/19734861
- """
- if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features:
- raise unittest.SkipTest('shell protocol unsupported on this device')
- result = self.device.shell_nocheck(
- shlex.split('echo foo; echo bar >&2; exit 17'))
-
- self.assertEqual(17, result[0])
- self.assertEqual('foo' + self.device.linesep, result[1])
- self.assertEqual('bar' + self.device.linesep, result[2])
-
- def test_non_interactive_sigint(self):
- """Tests that SIGINT in a non-interactive shell kills the process.
-
- This requires the shell protocol in order to detect the broken
- pipe; raw data transfer mode will only see the break once the
- subprocess tries to read or write.
-
- Bug: http://b/23825725
- """
- if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features:
- raise unittest.SkipTest('shell protocol unsupported on this device')
-
- # Start a long-running process.
- sleep_proc = subprocess.Popen(
- self.device.adb_cmd + shlex.split('shell echo $$; sleep 60'),
- stdin=subprocess.PIPE, stdout=subprocess.PIPE,
- stderr=subprocess.STDOUT)
- remote_pid = sleep_proc.stdout.readline().strip()
- self.assertIsNone(sleep_proc.returncode, 'subprocess terminated early')
- proc_query = shlex.split('ps {0} | grep {0}'.format(remote_pid))
-
- # Verify that the process is running, send signal, verify it stopped.
- self.device.shell(proc_query)
- os.kill(sleep_proc.pid, signal.SIGINT)
- sleep_proc.communicate()
- self.assertEqual(1, self.device.shell_nocheck(proc_query)[0],
- 'subprocess failed to terminate')
-
-
-class ArgumentEscapingTest(DeviceTest):
- def test_shell_escaping(self):
- """Make sure that argument escaping is somewhat sane."""
-
- # http://b/19734868
- # Note that this actually matches ssh(1)'s behavior --- it's
- # converted to `sh -c echo hello; echo world` which sh interprets
- # as `sh -c echo` (with an argument to that shell of "hello"),
- # and then `echo world` back in the first shell.
- result = self.device.shell(
- shlex.split("sh -c 'echo hello; echo world'"))[0]
- result = result.splitlines()
- self.assertEqual(['', 'world'], result)
- # If you really wanted "hello" and "world", here's what you'd do:
- result = self.device.shell(
- shlex.split(r'echo hello\;echo world'))[0].splitlines()
- self.assertEqual(['hello', 'world'], result)
-
- # http://b/15479704
- result = self.device.shell(shlex.split("'true && echo t'"))[0].strip()
- self.assertEqual('t', result)
- result = self.device.shell(
- shlex.split("sh -c 'true && echo t'"))[0].strip()
- self.assertEqual('t', result)
-
- # http://b/20564385
- result = self.device.shell(shlex.split('FOO=a BAR=b echo t'))[0].strip()
- self.assertEqual('t', result)
- result = self.device.shell(
- shlex.split(r'echo -n 123\;uname'))[0].strip()
- self.assertEqual('123Linux', result)
-
- def test_install_argument_escaping(self):
- """Make sure that install argument escaping works."""
- # http://b/20323053
- tf = tempfile.NamedTemporaryFile('wb', suffix='-text;ls;1.apk',
- delete=False)
- tf.close()
- self.assertIn("-text;ls;1.apk", self.device.install(tf.name))
- os.remove(tf.name)
-
- # http://b/3090932
- tf = tempfile.NamedTemporaryFile('wb', suffix="-Live Hold'em.apk",
- delete=False)
- tf.close()
- self.assertIn("-Live Hold'em.apk", self.device.install(tf.name))
- os.remove(tf.name)
-
-
-class RootUnrootTest(DeviceTest):
- def _test_root(self):
- message = self.device.root()
- if 'adbd cannot run as root in production builds' in message:
- return
- self.device.wait()
- self.assertEqual('root', self.device.shell(['id', '-un'])[0].strip())
-
- def _test_unroot(self):
- self.device.unroot()
- self.device.wait()
- self.assertEqual('shell', self.device.shell(['id', '-un'])[0].strip())
-
- def test_root_unroot(self):
- """Make sure that adb root and adb unroot work, using id(1)."""
- if self.device.get_prop('ro.debuggable') != '1':
- raise unittest.SkipTest('requires rootable build')
-
- original_user = self.device.shell(['id', '-un'])[0].strip()
- try:
- if original_user == 'root':
- self._test_unroot()
- self._test_root()
- elif original_user == 'shell':
- self._test_root()
- self._test_unroot()
- finally:
- if original_user == 'root':
- self.device.root()
- else:
- self.device.unroot()
- self.device.wait()
-
-
-class TcpIpTest(DeviceTest):
- def test_tcpip_failure_raises(self):
- """adb tcpip requires a port.
-
- Bug: http://b/22636927
- """
- self.assertRaises(
- subprocess.CalledProcessError, self.device.tcpip, '')
- self.assertRaises(
- subprocess.CalledProcessError, self.device.tcpip, 'foo')
-
-
-class SystemPropertiesTest(DeviceTest):
- def test_get_prop(self):
- self.assertEqual(self.device.get_prop('init.svc.adbd'), 'running')
-
- @requires_root
- def test_set_prop(self):
- prop_name = 'foo.bar'
- self.device.shell(['setprop', prop_name, '""'])
-
- self.device.set_prop(prop_name, 'qux')
- self.assertEqual(
- self.device.shell(['getprop', prop_name])[0].strip(), 'qux')
-
-
-def compute_md5(string):
- hsh = hashlib.md5()
- hsh.update(string)
- return hsh.hexdigest()
-
-
-def get_md5_prog(device):
- """Older platforms (pre-L) had the name md5 rather than md5sum."""
- try:
- device.shell(['md5sum', '/proc/uptime'])
- return 'md5sum'
- except subprocess.CalledProcessError:
- return 'md5'
-
-
-class HostFile(object):
- def __init__(self, handle, checksum):
- self.handle = handle
- self.checksum = checksum
- self.full_path = handle.name
- self.base_name = os.path.basename(self.full_path)
-
-
-class DeviceFile(object):
- def __init__(self, checksum, full_path):
- self.checksum = checksum
- self.full_path = full_path
- self.base_name = posixpath.basename(self.full_path)
-
-
-def make_random_host_files(in_dir, num_files):
- min_size = 1 * (1 << 10)
- max_size = 16 * (1 << 10)
-
- files = []
- for _ in xrange(num_files):
- file_handle = tempfile.NamedTemporaryFile(dir=in_dir, delete=False)
-
- size = random.randrange(min_size, max_size, 1024)
- rand_str = os.urandom(size)
- file_handle.write(rand_str)
- file_handle.flush()
- file_handle.close()
-
- md5 = compute_md5(rand_str)
- files.append(HostFile(file_handle, md5))
- return files
-
-
-def make_random_device_files(device, in_dir, num_files):
- min_size = 1 * (1 << 10)
- max_size = 16 * (1 << 10)
-
- files = []
- for file_num in xrange(num_files):
- size = random.randrange(min_size, max_size, 1024)
-
- base_name = 'device_tmpfile' + str(file_num)
- full_path = posixpath.join(in_dir, base_name)
-
- device.shell(['dd', 'if=/dev/urandom', 'of={}'.format(full_path),
- 'bs={}'.format(size), 'count=1'])
- dev_md5, _ = device.shell([get_md5_prog(device), full_path])[0].split()
-
- files.append(DeviceFile(dev_md5, full_path))
- return files
-
-
-class FileOperationsTest(DeviceTest):
- SCRATCH_DIR = '/data/local/tmp'
- DEVICE_TEMP_FILE = SCRATCH_DIR + '/adb_test_file'
- DEVICE_TEMP_DIR = SCRATCH_DIR + '/adb_test_dir'
-
- def _test_push(self, local_file, checksum):
- self.device.shell(['rm', '-rf', self.DEVICE_TEMP_FILE])
- self.device.push(local=local_file, remote=self.DEVICE_TEMP_FILE)
- dev_md5, _ = self.device.shell([get_md5_prog(self.device),
- self.DEVICE_TEMP_FILE])[0].split()
- self.assertEqual(checksum, dev_md5)
- self.device.shell(['rm', '-f', self.DEVICE_TEMP_FILE])
-
- def test_push(self):
- """Push a randomly generated file to specified device."""
- kbytes = 512
- tmp = tempfile.NamedTemporaryFile(mode='wb', delete=False)
- rand_str = os.urandom(1024 * kbytes)
- tmp.write(rand_str)
- tmp.close()
- self._test_push(tmp.name, compute_md5(rand_str))
- os.remove(tmp.name)
-
- # TODO: write push directory test.
-
- def _test_pull(self, remote_file, checksum):
- tmp_write = tempfile.NamedTemporaryFile(mode='wb', delete=False)
- tmp_write.close()
- self.device.pull(remote=remote_file, local=tmp_write.name)
- with open(tmp_write.name, 'rb') as tmp_read:
- host_contents = tmp_read.read()
- host_md5 = compute_md5(host_contents)
- self.assertEqual(checksum, host_md5)
- os.remove(tmp_write.name)
-
- def test_pull(self):
- """Pull a randomly generated file from specified device."""
- kbytes = 512
- self.device.shell(['rm', '-rf', self.DEVICE_TEMP_FILE])
- cmd = ['dd', 'if=/dev/urandom',
- 'of={}'.format(self.DEVICE_TEMP_FILE), 'bs=1024',
- 'count={}'.format(kbytes)]
- self.device.shell(cmd)
- dev_md5, _ = self.device.shell(
- [get_md5_prog(self.device), self.DEVICE_TEMP_FILE])[0].split()
- self._test_pull(self.DEVICE_TEMP_FILE, dev_md5)
- self.device.shell_nocheck(['rm', self.DEVICE_TEMP_FILE])
-
- def test_pull_dir(self):
- """Pull a randomly generated directory of files from the device."""
- host_dir = tempfile.mkdtemp()
- self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR])
- self.device.shell(['mkdir', '-p', self.DEVICE_TEMP_DIR])
-
- # Populate device directory with random files.
- temp_files = make_random_device_files(
- self.device, in_dir=self.DEVICE_TEMP_DIR, num_files=32)
-
- self.device.pull(remote=self.DEVICE_TEMP_DIR, local=host_dir)
-
- for temp_file in temp_files:
- host_path = os.path.join(host_dir, temp_file.base_name)
- with open(host_path, 'rb') as host_file:
- host_md5 = compute_md5(host_file.read())
- self.assertEqual(host_md5, temp_file.checksum)
-
- self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR])
- if host_dir is not None:
- shutil.rmtree(host_dir)
-
- def test_sync(self):
- """Sync a randomly generated directory of files to specified device."""
- base_dir = tempfile.mkdtemp()
-
- # Create mirror device directory hierarchy within base_dir.
- full_dir_path = base_dir + self.DEVICE_TEMP_DIR
- os.makedirs(full_dir_path)
-
- # Create 32 random files within the host mirror.
- temp_files = make_random_host_files(in_dir=full_dir_path, num_files=32)
-
- # Clean up any trash on the device.
- device = adb.get_device(product=base_dir)
- device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR])
-
- device.sync('data')
-
- # Confirm that every file on the device mirrors that on the host.
- for temp_file in temp_files:
- device_full_path = posixpath.join(self.DEVICE_TEMP_DIR,
- temp_file.base_name)
- dev_md5, _ = device.shell(
- [get_md5_prog(self.device), device_full_path])[0].split()
- self.assertEqual(temp_file.checksum, dev_md5)
-
- self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR])
- if base_dir is not None:
- shutil.rmtree(base_dir)
-
- def test_unicode_paths(self):
- """Ensure that we can support non-ASCII paths, even on Windows."""
- name = u'로보카 폴리'
-
- ## push.
- tf = tempfile.NamedTemporaryFile('wb', suffix=name, delete=False)
- tf.close()
- self.device.push(tf.name, u'/data/local/tmp/adb-test-{}'.format(name))
- os.remove(tf.name)
- self.device.shell(['rm', '-f', '/data/local/tmp/adb-test-*'])
-
- # pull.
- cmd = ['touch', u'"/data/local/tmp/adb-test-{}"'.format(name)]
- self.device.shell(cmd)
-
- tf = tempfile.NamedTemporaryFile('wb', suffix=name, delete=False)
- tf.close()
- self.device.pull(u'/data/local/tmp/adb-test-{}'.format(name), tf.name)
- os.remove(tf.name)
- self.device.shell(['rm', '-f', '/data/local/tmp/adb-test-*'])
-
-
-def main():
- random.seed(0)
- if len(adb.get_devices()) > 0:
- suite = unittest.TestLoader().loadTestsFromName(__name__)
- unittest.TextTestRunner(verbosity=3).run(suite)
- else:
- print('Test suite must be run with attached devices')
-
-
-if __name__ == '__main__':
- main()
diff --git a/adb/transport.cpp b/adb/transport.cpp
index db9236e..402546b 100644
--- a/adb/transport.cpp
+++ b/adb/transport.cpp
@@ -779,27 +779,37 @@
return max_payload;
}
-// Do not use any of [:;=,] in feature strings, they have special meaning
-// in the connection banner.
-// TODO(dpursell): add this in once we can pass features through to the client.
-const char kFeatureShell2[] = "shell_2";
+namespace {
-// The list of features supported by the current system. Will be sent to the
-// other side of the connection in the banner.
-static const FeatureSet gSupportedFeatures = {
- kFeatureShell2,
-};
+constexpr char kFeatureStringDelimiter = ',';
+
+} // namespace
const FeatureSet& supported_features() {
- return gSupportedFeatures;
+ // Local static allocation to avoid global non-POD variables.
+ static const FeatureSet* features = new FeatureSet{
+ kFeatureShell2
+ };
+
+ return *features;
+}
+
+std::string FeatureSetToString(const FeatureSet& features) {
+ return android::base::Join(features, kFeatureStringDelimiter);
+}
+
+FeatureSet StringToFeatureSet(const std::string& features_string) {
+ auto names = android::base::Split(features_string,
+ {kFeatureStringDelimiter});
+ return FeatureSet(names.begin(), names.end());
}
bool atransport::has_feature(const std::string& feature) const {
return features_.count(feature) > 0;
}
-void atransport::add_feature(const std::string& feature) {
- features_.insert(feature);
+void atransport::SetFeatures(const std::string& features_string) {
+ features_ = StringToFeatureSet(features_string);
}
bool atransport::CanUseFeature(const std::string& feature) const {
@@ -855,9 +865,6 @@
append_transport_info(result, "product:", t->product, false);
append_transport_info(result, "model:", t->model, true);
append_transport_info(result, "device:", t->device, false);
- append_transport_info(result, "features:",
- android::base::Join(t->features(), ',').c_str(),
- false);
}
*result += '\n';
}
diff --git a/adb/transport.h b/adb/transport.h
index 999922a..0ec8ceb 100644
--- a/adb/transport.h
+++ b/adb/transport.h
@@ -29,7 +29,13 @@
const FeatureSet& supported_features();
-const extern char kFeatureShell2[];
+// Encodes and decodes FeatureSet objects into human-readable strings.
+std::string FeatureSetToString(const FeatureSet& features);
+FeatureSet StringToFeatureSet(const std::string& features_string);
+
+// Do not use any of [:;=,] in feature strings, they have special meaning
+// in the connection banner.
+constexpr char kFeatureShell2[] = "shell_2";
class atransport {
public:
@@ -85,12 +91,14 @@
int get_protocol_version() const;
size_t get_max_payload() const;
- inline const FeatureSet features() const {
+ const FeatureSet& features() const {
return features_;
}
bool has_feature(const std::string& feature) const;
- void add_feature(const std::string& feature);
+
+ // Loads the transport's feature set from the given string.
+ void SetFeatures(const std::string& features_string);
// Returns true if both we and the other end of the transport support the
// feature.
diff --git a/adb/transport_test.cpp b/adb/transport_test.cpp
index 10872ac..7d69c3e 100644
--- a/adb/transport_test.cpp
+++ b/adb/transport_test.cpp
@@ -144,23 +144,29 @@
ASSERT_EQ(0, count);
}
-TEST(transport, add_feature) {
+TEST(transport, SetFeatures) {
atransport t;
ASSERT_EQ(0U, t.features().size());
- t.add_feature("foo");
+ t.SetFeatures(FeatureSetToString(FeatureSet{"foo"}));
ASSERT_EQ(1U, t.features().size());
ASSERT_TRUE(t.has_feature("foo"));
- t.add_feature("bar");
+ t.SetFeatures(FeatureSetToString(FeatureSet{"foo", "bar"}));
ASSERT_EQ(2U, t.features().size());
ASSERT_TRUE(t.has_feature("foo"));
ASSERT_TRUE(t.has_feature("bar"));
- t.add_feature("foo");
+ t.SetFeatures(FeatureSetToString(FeatureSet{"foo", "bar", "foo"}));
ASSERT_EQ(2U, t.features().size());
ASSERT_TRUE(t.has_feature("foo"));
ASSERT_TRUE(t.has_feature("bar"));
+
+ t.SetFeatures(FeatureSetToString(FeatureSet{"bar", "baz"}));
+ ASSERT_EQ(2U, t.features().size());
+ ASSERT_FALSE(t.has_feature("foo"));
+ ASSERT_TRUE(t.has_feature("bar"));
+ ASSERT_TRUE(t.has_feature("baz"));
}
TEST(transport, parse_banner_no_features) {
diff --git a/base/include/base/logging.h b/base/include/base/logging.h
index 283a7bc..30f6906 100644
--- a/base/include/base/logging.h
+++ b/base/include/base/logging.h
@@ -87,30 +87,64 @@
// Replace the current logger.
extern void SetLogger(LogFunction&& logger);
+// Get the minimum severity level for logging.
+extern LogSeverity GetMinimumLogSeverity();
+
+class ErrnoRestorer {
+ public:
+ ErrnoRestorer()
+ : saved_errno_(errno) {
+ }
+
+ ~ErrnoRestorer() {
+ errno = saved_errno_;
+ }
+
+ // Allow this object to evaluate to false which is useful in macros.
+ operator bool() const {
+ return false;
+ }
+
+ private:
+ const int saved_errno_;
+
+ DISALLOW_COPY_AND_ASSIGN(ErrnoRestorer);
+};
+
// Logs a message to logcat on Android otherwise to stderr. If the severity is
// FATAL it also causes an abort. For example:
//
// LOG(FATAL) << "We didn't expect to reach here";
-#define LOG(severity) \
- ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::DEFAULT, \
- ::android::base::severity, -1).stream()
+#define LOG(severity) LOG_TO(DEFAULT, severity)
// Logs a message to logcat with the specified log ID on Android otherwise to
// stderr. If the severity is FATAL it also causes an abort.
-#define LOG_TO(dest, severity) \
- ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::dest, \
- ::android::base::severity, -1).stream()
+// Use an if-else statement instead of just an if statement here. So if there is a
+// else statement after LOG() macro, it won't bind to the if statement in the macro.
+// do-while(0) statement doesn't work here. Because we need to support << operator
+// following the macro, like "LOG(DEBUG) << xxx;".
+#define LOG_TO(dest, severity) \
+ if (LIKELY(::android::base::severity < ::android::base::GetMinimumLogSeverity())) \
+ ; \
+ else \
+ ::android::base::ErrnoRestorer() ? *(std::ostream*)nullptr : \
+ ::android::base::LogMessage(__FILE__, __LINE__, \
+ ::android::base::dest, \
+ ::android::base::severity, -1).stream()
// A variant of LOG that also logs the current errno value. To be used when
// library calls fail.
-#define PLOG(severity) \
- ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::DEFAULT, \
- ::android::base::severity, errno).stream()
+#define PLOG(severity) PLOG_TO(DEFAULT, severity)
// Behaves like PLOG, but logs to the specified log ID.
-#define PLOG_TO(dest, severity) \
- ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::dest, \
- ::android::base::severity, errno).stream()
+#define PLOG_TO(dest, severity) \
+ if (LIKELY(::android::base::severity < ::android::base::GetMinimumLogSeverity())) \
+ ; \
+ else \
+ ::android::base::ErrnoRestorer() ? *(std::ostream*)nullptr : \
+ ::android::base::LogMessage(__FILE__, __LINE__, \
+ ::android::base::dest, \
+ ::android::base::severity, errno).stream()
// Marker that code is yet to be implemented.
#define UNIMPLEMENTED(level) \
@@ -122,11 +156,13 @@
//
// CHECK(false == true) results in a log message of
// "Check failed: false == true".
-#define CHECK(x) \
- if (UNLIKELY(!(x))) \
- ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::DEFAULT, \
- ::android::base::FATAL, -1).stream() \
- << "Check failed: " #x << " "
+#define CHECK(x) \
+ if (LIKELY((x))) \
+ ; \
+ else \
+ ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::DEFAULT, \
+ ::android::base::FATAL, -1).stream() \
+ << "Check failed: " #x << " "
// Helper for CHECK_xx(x,y) macros.
#define CHECK_OP(LHS, RHS, OP) \
@@ -153,7 +189,9 @@
// Helper for CHECK_STRxx(s1,s2) macros.
#define CHECK_STROP(s1, s2, sense) \
- if (UNLIKELY((strcmp(s1, s2) == 0) != sense)) \
+ if (LIKELY((strcmp(s1, s2) == 0) == sense)) \
+ ; \
+ else \
LOG(FATAL) << "Check failed: " \
<< "\"" << s1 << "\"" \
<< (sense ? " == " : " != ") << "\"" << s2 << "\""
diff --git a/base/logging.cpp b/base/logging.cpp
index e9e06df..6bfaaec 100644
--- a/base/logging.cpp
+++ b/base/logging.cpp
@@ -139,6 +139,10 @@
static LogSeverity gMinimumLogSeverity = INFO;
static std::unique_ptr<std::string> gProgramInvocationName;
+LogSeverity GetMinimumLogSeverity() {
+ return gMinimumLogSeverity;
+}
+
static const char* ProgramInvocationName() {
if (gProgramInvocationName == nullptr) {
gProgramInvocationName.reset(new std::string(getprogname()));
@@ -200,20 +204,6 @@
InitLogging(argv);
}
-// TODO: make this public; it's independently useful.
-class ErrnoRestorer {
- public:
- ErrnoRestorer(int saved_errno) : saved_errno_(saved_errno) {
- }
-
- ~ErrnoRestorer() {
- errno = saved_errno_;
- }
-
- private:
- const int saved_errno_;
-};
-
void InitLogging(char* argv[]) {
if (gInitialized) {
return;
@@ -286,13 +276,12 @@
class LogMessageData {
public:
LogMessageData(const char* file, unsigned int line, LogId id,
- LogSeverity severity, int error, int saved_errno)
+ LogSeverity severity, int error)
: file_(GetFileBasename(file)),
line_number_(line),
id_(id),
severity_(severity),
- error_(error),
- errno_restorer_(saved_errno) {
+ error_(error) {
}
const char* GetFile() const {
@@ -330,39 +319,38 @@
const LogId id_;
const LogSeverity severity_;
const int error_;
- ErrnoRestorer errno_restorer_;
DISALLOW_COPY_AND_ASSIGN(LogMessageData);
};
LogMessage::LogMessage(const char* file, unsigned int line, LogId id,
LogSeverity severity, int error)
- : data_(new LogMessageData(file, line, id, severity, error, errno)) {
+ : data_(new LogMessageData(file, line, id, severity, error)) {
}
LogMessage::~LogMessage() {
- if (data_->GetSeverity() < gMinimumLogSeverity) {
- return; // No need to format something we're not going to output.
- }
-
// Finish constructing the message.
if (data_->GetError() != -1) {
data_->GetBuffer() << ": " << strerror(data_->GetError());
}
std::string msg(data_->ToString());
- if (msg.find('\n') == std::string::npos) {
- LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
- data_->GetSeverity(), msg.c_str());
- } else {
- msg += '\n';
- size_t i = 0;
- while (i < msg.size()) {
- size_t nl = msg.find('\n', i);
- msg[nl] = '\0';
+ {
+ // Do the actual logging with the lock held.
+ lock_guard<mutex> lock(logging_lock);
+ if (msg.find('\n') == std::string::npos) {
LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
- data_->GetSeverity(), &msg[i]);
- i = nl + 1;
+ data_->GetSeverity(), msg.c_str());
+ } else {
+ msg += '\n';
+ size_t i = 0;
+ while (i < msg.size()) {
+ size_t nl = msg.find('\n', i);
+ msg[nl] = '\0';
+ LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
+ data_->GetSeverity(), &msg[i]);
+ i = nl + 1;
+ }
}
}
@@ -382,7 +370,6 @@
void LogMessage::LogLine(const char* file, unsigned int line, LogId id,
LogSeverity severity, const char* message) {
const char* tag = ProgramInvocationName();
- lock_guard<mutex> lock(logging_lock);
gLogger(id, severity, tag, file, line, message);
}
diff --git a/base/logging_test.cpp b/base/logging_test.cpp
index c12dfa5..9cf1aad 100644
--- a/base/logging_test.cpp
+++ b/base/logging_test.cpp
@@ -18,6 +18,10 @@
#include <libgen.h>
+#if defined(_WIN32)
+#include <signal.h>
+#endif
+
#include <regex>
#include <string>
@@ -49,6 +53,11 @@
private:
void init() {
+#if defined(_WIN32)
+ // On Windows, stderr is often buffered, so make sure it is unbuffered so
+ // that we can immediately read back what was written to stderr.
+ ASSERT_EQ(0, setvbuf(stderr, NULL, _IONBF, 0));
+#endif
old_stderr_ = dup(STDERR_FILENO);
ASSERT_NE(-1, old_stderr_);
ASSERT_NE(-1, dup2(fd(), STDERR_FILENO));
@@ -57,21 +66,58 @@
void reset() {
ASSERT_NE(-1, dup2(old_stderr_, STDERR_FILENO));
ASSERT_EQ(0, close(old_stderr_));
+ // Note: cannot restore prior setvbuf() setting.
}
TemporaryFile temp_file_;
int old_stderr_;
};
+#if defined(_WIN32)
+static void ExitSignalAbortHandler(int) {
+ _exit(3);
+}
+#endif
+
+static void SuppressAbortUI() {
+#if defined(_WIN32)
+ // We really just want to call _set_abort_behavior(0, _CALL_REPORTFAULT) to
+ // suppress the Windows Error Reporting dialog box, but that API is not
+ // available in the OS-supplied C Runtime, msvcrt.dll, that we currently
+ // use (it is available in the Visual Studio C runtime).
+ //
+ // Instead, we setup a SIGABRT handler, which is called in abort() right
+ // before calling Windows Error Reporting. In the handler, we exit the
+ // process just like abort() does.
+ ASSERT_NE(SIG_ERR, signal(SIGABRT, ExitSignalAbortHandler));
+#endif
+}
+
TEST(logging, CHECK) {
- ASSERT_DEATH(CHECK(false), "Check failed: false ");
+ ASSERT_DEATH({SuppressAbortUI(); CHECK(false);}, "Check failed: false ");
CHECK(true);
- ASSERT_DEATH(CHECK_EQ(0, 1), "Check failed: 0 == 1 ");
+ ASSERT_DEATH({SuppressAbortUI(); CHECK_EQ(0, 1);}, "Check failed: 0 == 1 ");
CHECK_EQ(0, 0);
- ASSERT_DEATH(CHECK_STREQ("foo", "bar"), R"(Check failed: "foo" == "bar")");
+ ASSERT_DEATH({SuppressAbortUI(); CHECK_STREQ("foo", "bar");},
+ R"(Check failed: "foo" == "bar")");
CHECK_STREQ("foo", "foo");
+
+ // Test whether CHECK() and CHECK_STREQ() have a dangling if with no else.
+ bool flag = false;
+ if (true)
+ CHECK(true);
+ else
+ flag = true;
+ EXPECT_FALSE(flag) << "CHECK macro probably has a dangling if with no else";
+
+ flag = false;
+ if (true)
+ CHECK_STREQ("foo", "foo");
+ else
+ flag = true;
+ EXPECT_FALSE(flag) << "CHECK_STREQ probably has a dangling if with no else";
}
std::string make_log_pattern(android::base::LogSeverity severity,
@@ -85,7 +131,7 @@
}
TEST(logging, LOG) {
- ASSERT_DEATH(LOG(FATAL) << "foobar", "foobar");
+ ASSERT_DEATH({SuppressAbortUI(); LOG(FATAL) << "foobar";}, "foobar");
// We can't usefully check the output of any of these on Windows because we
// don't have std::regex, but we can at least make sure we printed at least as
@@ -148,6 +194,50 @@
ASSERT_TRUE(std::regex_search(output, message_regex)) << output;
#endif
}
+
+ // Test whether LOG() saves and restores errno.
+ {
+ CapturedStderr cap;
+ errno = 12345;
+ LOG(INFO) << (errno = 67890);
+ EXPECT_EQ(12345, errno) << "errno was not restored";
+
+ ASSERT_EQ(0, lseek(cap.fd(), SEEK_SET, 0));
+
+ std::string output;
+ android::base::ReadFdToString(cap.fd(), &output);
+ EXPECT_NE(nullptr, strstr(output.c_str(), "67890")) << output;
+
+#if !defined(_WIN32)
+ std::regex message_regex(
+ make_log_pattern(android::base::INFO, "67890"));
+ ASSERT_TRUE(std::regex_search(output, message_regex)) << output;
+#endif
+ }
+
+ // Test whether LOG() has a dangling if with no else.
+ {
+ CapturedStderr cap;
+
+ // Do the test two ways: once where we hypothesize that LOG()'s if
+ // will evaluate to true (when severity is high enough) and once when we
+ // expect it to evaluate to false (when severity is not high enough).
+ bool flag = false;
+ if (true)
+ LOG(INFO) << "foobar";
+ else
+ flag = true;
+
+ EXPECT_FALSE(flag) << "LOG macro probably has a dangling if with no else";
+
+ flag = false;
+ if (true)
+ LOG(VERBOSE) << "foobar";
+ else
+ flag = true;
+
+ EXPECT_FALSE(flag) << "LOG macro probably has a dangling if with no else";
+ }
}
TEST(logging, PLOG) {
diff --git a/crash_reporter/crash_reporter.cc b/crash_reporter/crash_reporter.cc
index 72eeeda..7872f7b 100644
--- a/crash_reporter/crash_reporter.cc
+++ b/crash_reporter/crash_reporter.cc
@@ -20,6 +20,7 @@
#include <vector>
#include <base/files/file_util.h>
+#include <base/guid.h>
#include <base/logging.h>
#include <base/strings/string_split.h>
#include <base/strings/string_util.h>
@@ -41,6 +42,7 @@
static const char kKernelCrashDetected[] = "/var/run/kernel-crash-detected";
static const char kUncleanShutdownDetected[] =
"/var/run/unclean-shutdown-detected";
+static const char kGUIDFileName[] = "/data/misc/crash_reporter/guid";
// Enumeration of kinds of crashes to be used in the CrashCounter histogram.
enum CrashKinds {
@@ -122,6 +124,21 @@
const bool clean_shutdown) {
CHECK(!clean_shutdown) << "Incompatible options";
+ // Try to read the GUID from kGUIDFileName. If the file doesn't exist, is
+ // blank, or the read fails, generate a new GUID and write it to the file.
+ std::string guid;
+ base::FilePath filepath(kGUIDFileName);
+ if (!base::ReadFileToString(filepath, &guid) || guid.empty()) {
+ guid = base::GenerateGUID();
+ // If we can't read or write the file, log an error. However it is not
+ // a fatal error, as the crash server will assign a random GUID based
+ // on a hash of the IP address if one is not provided in the report.
+ if (base::WriteFile(filepath, guid.c_str(), guid.size()) <= 0) {
+ LOG(ERROR) << "Could not write guid " << guid << " to file "
+ << filepath.value();
+ }
+ }
+
bool was_kernel_crash = false;
bool was_unclean_shutdown = false;
kernel_collector->Enable();
diff --git a/crash_reporter/crash_sender b/crash_reporter/crash_sender
index d0d6772..29a1229 100755
--- a/crash_reporter/crash_sender
+++ b/crash_reporter/crash_sender
@@ -22,9 +22,8 @@
# Base directory that contains any crash reporter state files.
CRASH_STATE_DIR="/data/misc/crash_reporter"
-# File whose existence implies crash reports may be sent, and whose
-# contents includes our machine's anonymized guid.
-CONSENT_ID="/data/misc/metrics/enabled"
+# File containing crash_reporter's anonymized guid.
+GUID_FILE="${CRASH_STATE_DIR}/guid"
# Crash sender lock in case the sender is already running.
CRASH_SENDER_LOCK="${CRASH_STATE_DIR}/lock/crash_sender"
@@ -393,7 +392,7 @@
# Need to strip dashes ourselves as Chrome preserves it in the file
# nowadays. This is also what the Chrome breakpad client does.
- guid=$(tr -d '-' < "${CONSENT_ID}")
+ guid=$(tr -d '-' < "${GUID_FILE}")
local error_type="$(get_key_value "${meta_path}" "error_type")"
[ "${error_type}" = "undefined" ] && error_type=
diff --git a/debuggerd/Android.mk b/debuggerd/Android.mk
index f7a5f82..de0f943 100644
--- a/debuggerd/Android.mk
+++ b/debuggerd/Android.mk
@@ -99,6 +99,7 @@
debuggerd_cpp_flags := \
$(common_cppflags) \
-Wno-missing-field-initializers \
+ -fno-rtti \
# Only build the host tests on linux.
ifeq ($(HOST_OS),linux)
diff --git a/include/backtrace/Backtrace.h b/include/backtrace/Backtrace.h
index 290682a..f440bd2 100644
--- a/include/backtrace/Backtrace.h
+++ b/include/backtrace/Backtrace.h
@@ -52,6 +52,12 @@
typedef ucontext ucontext_t;
#endif
+struct backtrace_stackinfo_t {
+ uint64_t start;
+ uint64_t end;
+ const uint8_t* data;
+};
+
class Backtrace {
public:
// Create the correct Backtrace object based on what is to be unwound.
@@ -66,6 +72,14 @@
// If map is not NULL, the map is still owned by the caller.
static Backtrace* Create(pid_t pid, pid_t tid, BacktraceMap* map = NULL);
+ // Create an offline Backtrace object that can be used to do an unwind without a process
+ // that is still running. If cache_file is set to true, then elf information will be cached
+ // for this call. The cached information survives until the calling process ends. This means
+ // that subsequent calls to create offline Backtrace objects will continue to use the same
+ // cache. It also assumes that the elf files used for each offline unwind are the same.
+ static Backtrace* CreateOffline(pid_t pid, pid_t tid, BacktraceMap* map,
+ const backtrace_stackinfo_t& stack, bool cache_file = false);
+
virtual ~Backtrace();
// Get the current stack trace and store in the backtrace_ structure.
diff --git a/include/backtrace/BacktraceMap.h b/include/backtrace/BacktraceMap.h
index bb18aa2..2373c45 100644
--- a/include/backtrace/BacktraceMap.h
+++ b/include/backtrace/BacktraceMap.h
@@ -31,6 +31,7 @@
#include <deque>
#include <string>
+#include <vector>
struct backtrace_map_t {
uintptr_t start = 0;
@@ -48,6 +49,8 @@
// is unsupported.
static BacktraceMap* Create(pid_t pid, bool uncached = false);
+ static BacktraceMap* Create(pid_t pid, const std::vector<backtrace_map_t>& maps);
+
virtual ~BacktraceMap();
// Fill in the map data structure for the given address.
diff --git a/libbacktrace/Android.build.mk b/libbacktrace/Android.build.mk
index 4983b55..84d07f2 100644
--- a/libbacktrace/Android.build.mk
+++ b/libbacktrace/Android.build.mk
@@ -69,13 +69,22 @@
$($(module)_ldlibs) \
$($(module)_ldlibs_$(build_type)) \
+LOCAL_STRIP_MODULE := $($(module)_strip_module)
+
ifeq ($(build_type),target)
+ include $(LLVM_DEVICE_BUILD_MK)
include $(BUILD_$(build_target))
endif
ifeq ($(build_type),host)
# Only build if host builds are supported.
ifeq ($(build_host),true)
+ include $(LLVM_HOST_BUILD_MK)
+ # -fno-omit-frame-pointer should be set for host build. Because currently
+ # libunwind can't recognize .debug_frame using dwarf version 4, and it relies
+ # on stack frame pointer to do unwinding on x86.
+ # $(LLVM_HOST_BUILD_MK) overwrites -fno-omit-frame-pointer. so the below line
+ # must be after the include.
LOCAL_CFLAGS += -Wno-extern-c-compat -fno-omit-frame-pointer
include $(BUILD_HOST_$(build_target))
endif
diff --git a/libbacktrace/Android.mk b/libbacktrace/Android.mk
index 395d677..9c6742e 100644
--- a/libbacktrace/Android.mk
+++ b/libbacktrace/Android.mk
@@ -25,6 +25,7 @@
libbacktrace_common_cppflags := \
-std=gnu++11 \
+ -I external/libunwind/include/tdep \
# The latest clang (r230699) does not allow SP/PC to be declared in inline asm lists.
libbacktrace_common_clang_cflags += \
@@ -37,6 +38,9 @@
endif
endif
+LLVM_ROOT_PATH := external/llvm
+include $(LLVM_ROOT_PATH)/llvm.mk
+
#-------------------------------------------------------------------------
# The libbacktrace library.
#-------------------------------------------------------------------------
@@ -44,6 +48,7 @@
Backtrace.cpp \
BacktraceCurrent.cpp \
BacktraceMap.cpp \
+ BacktraceOffline.cpp \
BacktracePtrace.cpp \
thread_utils.c \
ThreadEntry.cpp \
@@ -56,6 +61,20 @@
liblog \
libunwind \
+# Use shared llvm library on device to save space.
+libbacktrace_shared_libraries_target := \
+ libLLVM \
+
+# Use static llvm libraries on host to remove dependency on 32-bit llvm shared library
+# which is not included in the prebuilt.
+libbacktrace_static_libraries_host := \
+ libLLVMObject \
+ libLLVMBitReader \
+ libLLVMMC \
+ libLLVMMCParser \
+ libLLVMCore \
+ libLLVMSupport \
+
libbacktrace_ldlibs_host := \
-lpthread \
-lrt \
@@ -86,6 +105,8 @@
libbacktrace_test_src_files := \
backtrace_testlib.c \
+libbacktrace_test_strip_module := false
+
module := libbacktrace_test
module_tag := debug
build_type := target
@@ -107,6 +128,7 @@
-DENABLE_PSS_TESTS \
backtrace_test_src_files := \
+ backtrace_offline_test.cpp \
backtrace_test.cpp \
GetPss.cpp \
thread_utils.c \
@@ -120,6 +142,7 @@
libbacktrace \
libbase \
libcutils \
+ libunwind \
backtrace_test_shared_libraries_target += \
libdl \
@@ -127,6 +150,8 @@
backtrace_test_ldlibs_host += \
-ldl \
+backtrace_test_strip_module := false
+
module := backtrace_test
module_tag := debug
build_type := target
diff --git a/libbacktrace/Backtrace.cpp b/libbacktrace/Backtrace.cpp
index 97f0ef4..9ead452 100644
--- a/libbacktrace/Backtrace.cpp
+++ b/libbacktrace/Backtrace.cpp
@@ -30,6 +30,7 @@
#include <cutils/threads.h>
#include "BacktraceLog.h"
+#include "BacktraceOffline.h"
#include "thread_utils.h"
#include "UnwindCurrent.h"
#include "UnwindPtrace.h"
@@ -140,3 +141,8 @@
return new UnwindPtrace(pid, tid, map);
}
}
+
+Backtrace* Backtrace::CreateOffline(pid_t pid, pid_t tid, BacktraceMap* map,
+ const backtrace_stackinfo_t& stack, bool cache_file) {
+ return new BacktraceOffline(pid, tid, map, stack, cache_file);
+}
diff --git a/libbacktrace/BacktraceMap.cpp b/libbacktrace/BacktraceMap.cpp
index ca47f67..ba86632 100644
--- a/libbacktrace/BacktraceMap.cpp
+++ b/libbacktrace/BacktraceMap.cpp
@@ -63,7 +63,7 @@
// 6f000000-6f01e000 rwxp 00000000 00:0c 16389419 /system/lib/libcomposer.so\n
// 012345678901234567890123456789012345678901234567890123456789
// 0 1 2 3 4 5
- if (sscanf(line, "%lx-%lx %4s %*x %*x:%*x %*d%n",
+ if (sscanf(line, "%lx-%lx %4s %*x %*x:%*x %*d %n",
&start, &end, permissions, &name_pos) != 3) {
#endif
return false;
@@ -82,9 +82,6 @@
map->flags |= PROT_EXEC;
}
- while (isspace(line[name_pos])) {
- name_pos += 1;
- }
map->name = line+name_pos;
if (!map->name.empty() && map->name[map->name.length()-1] == '\n') {
map->name.erase(map->name.length()-1);
@@ -144,3 +141,13 @@
return map;
}
#endif
+
+BacktraceMap* BacktraceMap::Create(pid_t pid, const std::vector<backtrace_map_t>& maps) {
+ BacktraceMap* backtrace_map = new BacktraceMap(pid);
+ backtrace_map->maps_.insert(backtrace_map->maps_.begin(), maps.begin(), maps.end());
+ std::sort(backtrace_map->maps_.begin(), backtrace_map->maps_.end(),
+ [](const backtrace_map_t& map1, const backtrace_map_t& map2) {
+ return map1.start < map2.start;
+ });
+ return backtrace_map;
+}
diff --git a/libbacktrace/BacktraceOffline.cpp b/libbacktrace/BacktraceOffline.cpp
new file mode 100644
index 0000000..27dfb83
--- /dev/null
+++ b/libbacktrace/BacktraceOffline.cpp
@@ -0,0 +1,636 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BacktraceOffline.h"
+
+extern "C" {
+#define UNW_REMOTE_ONLY
+#include <dwarf.h>
+}
+
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+#include <string>
+#include <vector>
+
+#include <backtrace/Backtrace.h>
+#include <backtrace/BacktraceMap.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Object/Binary.h>
+#include <llvm/Object/ELFObjectFile.h>
+#include <llvm/Object/ObjectFile.h>
+
+#pragma clang diagnostic pop
+
+#include "BacktraceLog.h"
+
+void Space::Clear() {
+ start = 0;
+ end = 0;
+ data = nullptr;
+}
+
+size_t Space::Read(uint64_t addr, uint8_t* buffer, size_t size) {
+ if (addr >= start && addr < end) {
+ size_t read_size = std::min(size, static_cast<size_t>(end - addr));
+ memcpy(buffer, data + (addr - start), read_size);
+ return read_size;
+ }
+ return 0;
+}
+
+static int FindProcInfo(unw_addr_space_t addr_space, unw_word_t ip, unw_proc_info* proc_info,
+ int need_unwind_info, void* arg) {
+ BacktraceOffline* backtrace = reinterpret_cast<BacktraceOffline*>(arg);
+ bool result = backtrace->FindProcInfo(addr_space, ip, proc_info, need_unwind_info);
+ return result ? 0 : -UNW_EINVAL;
+}
+
+static void PutUnwindInfo(unw_addr_space_t, unw_proc_info_t*, void*) {
+}
+
+static int GetDynInfoListAddr(unw_addr_space_t, unw_word_t*, void*) {
+ return -UNW_ENOINFO;
+}
+
+static int AccessMem(unw_addr_space_t, unw_word_t addr, unw_word_t* value, int write, void* arg) {
+ if (write == 1) {
+ return -UNW_EINVAL;
+ }
+ BacktraceOffline* backtrace = reinterpret_cast<BacktraceOffline*>(arg);
+ *value = 0;
+ size_t read_size = backtrace->Read(addr, reinterpret_cast<uint8_t*>(value), sizeof(unw_word_t));
+ // Strictly we should check if read_size matches sizeof(unw_word_t), but it is possible in
+ // .eh_frame_hdr that the section can end at a position not aligned in sizeof(unw_word_t), and
+ // we should permit the read at the end of the section.
+ return (read_size > 0u ? 0 : -UNW_EINVAL);
+}
+
+static int AccessReg(unw_addr_space_t, unw_regnum_t unwind_reg, unw_word_t* value, int write,
+ void* arg) {
+ if (write == 1) {
+ return -UNW_EINVAL;
+ }
+ BacktraceOffline* backtrace = reinterpret_cast<BacktraceOffline*>(arg);
+ uint64_t reg_value;
+ bool result = backtrace->ReadReg(unwind_reg, ®_value);
+ if (result) {
+ *value = static_cast<unw_word_t>(reg_value);
+ }
+ return result ? 0 : -UNW_EINVAL;
+}
+
+static int AccessFpReg(unw_addr_space_t, unw_regnum_t, unw_fpreg_t*, int, void*) {
+ return -UNW_EINVAL;
+}
+
+static int Resume(unw_addr_space_t, unw_cursor_t*, void*) {
+ return -UNW_EINVAL;
+}
+
+static int GetProcName(unw_addr_space_t, unw_word_t, char*, size_t, unw_word_t*, void*) {
+ return -UNW_EINVAL;
+}
+
+static unw_accessors_t accessors = {
+ .find_proc_info = FindProcInfo,
+ .put_unwind_info = PutUnwindInfo,
+ .get_dyn_info_list_addr = GetDynInfoListAddr,
+ .access_mem = AccessMem,
+ .access_reg = AccessReg,
+ .access_fpreg = AccessFpReg,
+ .resume = Resume,
+ .get_proc_name = GetProcName,
+};
+
+bool BacktraceOffline::Unwind(size_t num_ignore_frames, ucontext_t* context) {
+ if (context == nullptr) {
+ BACK_LOGW("The context is needed for offline backtracing.");
+ return false;
+ }
+ context_ = context;
+
+ unw_addr_space_t addr_space = unw_create_addr_space(&accessors, 0);
+ unw_cursor_t cursor;
+ int ret = unw_init_remote(&cursor, addr_space, this);
+ if (ret != 0) {
+ BACK_LOGW("unw_init_remote failed %d", ret);
+ unw_destroy_addr_space(addr_space);
+ return false;
+ }
+ size_t num_frames = 0;
+ do {
+ unw_word_t pc;
+ ret = unw_get_reg(&cursor, UNW_REG_IP, &pc);
+ if (ret < 0) {
+ BACK_LOGW("Failed to read IP %d", ret);
+ break;
+ }
+ unw_word_t sp;
+ ret = unw_get_reg(&cursor, UNW_REG_SP, &sp);
+ if (ret < 0) {
+ BACK_LOGW("Failed to read SP %d", ret);
+ break;
+ }
+
+ if (num_ignore_frames == 0) {
+ frames_.resize(num_frames + 1);
+ backtrace_frame_data_t* frame = &frames_[num_frames];
+ frame->num = num_frames;
+ frame->pc = static_cast<uintptr_t>(pc);
+ frame->sp = static_cast<uintptr_t>(sp);
+ frame->stack_size = 0;
+
+ if (num_frames > 0) {
+ backtrace_frame_data_t* prev = &frames_[num_frames - 1];
+ prev->stack_size = frame->sp - prev->sp;
+ }
+ frame->func_name = GetFunctionName(frame->pc, &frame->func_offset);
+ FillInMap(frame->pc, &frame->map);
+ num_frames++;
+ } else {
+ num_ignore_frames--;
+ }
+ ret = unw_step(&cursor);
+ } while (ret > 0 && num_frames < MAX_BACKTRACE_FRAMES);
+
+ unw_destroy_addr_space(addr_space);
+ context_ = nullptr;
+ return true;
+}
+
+bool BacktraceOffline::ReadWord(uintptr_t ptr, word_t* out_value) {
+ size_t bytes_read = Read(ptr, reinterpret_cast<uint8_t*>(out_value), sizeof(word_t));
+ return bytes_read == sizeof(word_t);
+}
+
+size_t BacktraceOffline::Read(uintptr_t addr, uint8_t* buffer, size_t bytes) {
+ // Normally, libunwind needs stack information and call frame information to do remote unwinding.
+ // If call frame information is stored in .debug_frame, libunwind can read it from file
+ // by itself. If call frame information is stored in .eh_frame, we need to provide data in
+ // .eh_frame/.eh_frame_hdr sections.
+ // The order of readings below doesn't matter, as the spaces don't overlap with each other.
+ size_t read_size = eh_frame_hdr_space_.Read(addr, buffer, bytes);
+ if (read_size != 0) {
+ return read_size;
+ }
+ read_size = eh_frame_space_.Read(addr, buffer, bytes);
+ if (read_size != 0) {
+ return read_size;
+ }
+ read_size = stack_space_.Read(addr, buffer, bytes);
+ return read_size;
+}
+
+static bool FileOffsetToVaddr(
+ const std::vector<DebugFrameInfo::EhFrame::ProgramHeader>& program_headers,
+ uint64_t file_offset, uint64_t* vaddr) {
+ for (auto& header : program_headers) {
+ if (file_offset >= header.file_offset && file_offset < header.file_offset + header.file_size) {
+ // TODO: Consider load_bias?
+ *vaddr = file_offset - header.file_offset + header.vaddr;
+ return true;
+ }
+ }
+ return false;
+}
+
+bool BacktraceOffline::FindProcInfo(unw_addr_space_t addr_space, uint64_t ip,
+ unw_proc_info_t* proc_info, int need_unwind_info) {
+ backtrace_map_t map;
+ FillInMap(ip, &map);
+ if (!BacktraceMap::IsValid(map)) {
+ return false;
+ }
+ const std::string& filename = map.name;
+ DebugFrameInfo* debug_frame = GetDebugFrameInFile(filename);
+ if (debug_frame == nullptr) {
+ return false;
+ }
+ if (debug_frame->is_eh_frame) {
+ uint64_t ip_offset = ip - map.start + map.offset;
+ uint64_t ip_vaddr; // vaddr in the elf file.
+ bool result = FileOffsetToVaddr(debug_frame->eh_frame.program_headers, ip_offset, &ip_vaddr);
+ if (!result) {
+ return false;
+ }
+ // Calculate the addresses where .eh_frame_hdr and .eh_frame stay when the process was running.
+ eh_frame_hdr_space_.start = (ip - ip_vaddr) + debug_frame->eh_frame.eh_frame_hdr_vaddr;
+ eh_frame_hdr_space_.end =
+ eh_frame_hdr_space_.start + debug_frame->eh_frame.eh_frame_hdr_data.size();
+ eh_frame_hdr_space_.data = debug_frame->eh_frame.eh_frame_hdr_data.data();
+
+ eh_frame_space_.start = (ip - ip_vaddr) + debug_frame->eh_frame.eh_frame_vaddr;
+ eh_frame_space_.end = eh_frame_space_.start + debug_frame->eh_frame.eh_frame_data.size();
+ eh_frame_space_.data = debug_frame->eh_frame.eh_frame_data.data();
+
+ unw_dyn_info di;
+ memset(&di, '\0', sizeof(di));
+ di.start_ip = map.start;
+ di.end_ip = map.end;
+ di.format = UNW_INFO_FORMAT_REMOTE_TABLE;
+ di.u.rti.name_ptr = 0;
+ di.u.rti.segbase = eh_frame_hdr_space_.start;
+ di.u.rti.table_data =
+ eh_frame_hdr_space_.start + debug_frame->eh_frame.fde_table_offset_in_eh_frame_hdr;
+ di.u.rti.table_len = (eh_frame_hdr_space_.end - di.u.rti.table_data) / sizeof(unw_word_t);
+ int ret = dwarf_search_unwind_table(addr_space, ip, &di, proc_info, need_unwind_info, this);
+ return ret == 0;
+ }
+
+ eh_frame_hdr_space_.Clear();
+ eh_frame_space_.Clear();
+ unw_dyn_info_t di;
+ unw_word_t segbase = map.start - map.offset;
+ int found = dwarf_find_debug_frame(0, &di, ip, segbase, filename.c_str(), map.start, map.end);
+ if (found == 1) {
+ int ret = dwarf_search_unwind_table(addr_space, ip, &di, proc_info, need_unwind_info, this);
+ return ret == 0;
+ }
+ return false;
+}
+
+bool BacktraceOffline::ReadReg(size_t reg, uint64_t* value) {
+ bool result = true;
+#if defined(__arm__)
+ switch (reg) {
+ case UNW_ARM_R0:
+ *value = context_->uc_mcontext.arm_r0;
+ break;
+ case UNW_ARM_R1:
+ *value = context_->uc_mcontext.arm_r1;
+ break;
+ case UNW_ARM_R2:
+ *value = context_->uc_mcontext.arm_r2;
+ break;
+ case UNW_ARM_R3:
+ *value = context_->uc_mcontext.arm_r3;
+ break;
+ case UNW_ARM_R4:
+ *value = context_->uc_mcontext.arm_r4;
+ break;
+ case UNW_ARM_R5:
+ *value = context_->uc_mcontext.arm_r5;
+ break;
+ case UNW_ARM_R6:
+ *value = context_->uc_mcontext.arm_r6;
+ break;
+ case UNW_ARM_R7:
+ *value = context_->uc_mcontext.arm_r7;
+ break;
+ case UNW_ARM_R8:
+ *value = context_->uc_mcontext.arm_r8;
+ break;
+ case UNW_ARM_R9:
+ *value = context_->uc_mcontext.arm_r9;
+ break;
+ case UNW_ARM_R10:
+ *value = context_->uc_mcontext.arm_r10;
+ break;
+ case UNW_ARM_R11:
+ *value = context_->uc_mcontext.arm_fp;
+ break;
+ case UNW_ARM_R12:
+ *value = context_->uc_mcontext.arm_ip;
+ break;
+ case UNW_ARM_R13:
+ *value = context_->uc_mcontext.arm_sp;
+ break;
+ case UNW_ARM_R14:
+ *value = context_->uc_mcontext.arm_lr;
+ break;
+ case UNW_ARM_R15:
+ *value = context_->uc_mcontext.arm_pc;
+ break;
+ default:
+ result = false;
+ }
+#elif defined(__aarch64__)
+ if (reg <= UNW_AARCH64_PC) {
+ *value = context_->uc_mcontext.regs[reg];
+ } else {
+ result = false;
+ }
+#elif defined(__x86_64__)
+ switch (reg) {
+ case UNW_X86_64_R8:
+ *value = context_->uc_mcontext.gregs[REG_R8];
+ break;
+ case UNW_X86_64_R9:
+ *value = context_->uc_mcontext.gregs[REG_R9];
+ break;
+ case UNW_X86_64_R10:
+ *value = context_->uc_mcontext.gregs[REG_R10];
+ break;
+ case UNW_X86_64_R11:
+ *value = context_->uc_mcontext.gregs[REG_R11];
+ break;
+ case UNW_X86_64_R12:
+ *value = context_->uc_mcontext.gregs[REG_R12];
+ break;
+ case UNW_X86_64_R13:
+ *value = context_->uc_mcontext.gregs[REG_R13];
+ break;
+ case UNW_X86_64_R14:
+ *value = context_->uc_mcontext.gregs[REG_R14];
+ break;
+ case UNW_X86_64_R15:
+ *value = context_->uc_mcontext.gregs[REG_R15];
+ break;
+ case UNW_X86_64_RDI:
+ *value = context_->uc_mcontext.gregs[REG_RDI];
+ break;
+ case UNW_X86_64_RSI:
+ *value = context_->uc_mcontext.gregs[REG_RSI];
+ break;
+ case UNW_X86_64_RBP:
+ *value = context_->uc_mcontext.gregs[REG_RBP];
+ break;
+ case UNW_X86_64_RBX:
+ *value = context_->uc_mcontext.gregs[REG_RBX];
+ break;
+ case UNW_X86_64_RDX:
+ *value = context_->uc_mcontext.gregs[REG_RDX];
+ break;
+ case UNW_X86_64_RAX:
+ *value = context_->uc_mcontext.gregs[REG_RAX];
+ break;
+ case UNW_X86_64_RCX:
+ *value = context_->uc_mcontext.gregs[REG_RCX];
+ break;
+ case UNW_X86_64_RSP:
+ *value = context_->uc_mcontext.gregs[REG_RSP];
+ break;
+ case UNW_X86_64_RIP:
+ *value = context_->uc_mcontext.gregs[REG_RIP];
+ break;
+ default:
+ result = false;
+ }
+#elif defined(__i386__)
+ switch (reg) {
+ case UNW_X86_GS:
+ *value = context_->uc_mcontext.gregs[REG_GS];
+ break;
+ case UNW_X86_FS:
+ *value = context_->uc_mcontext.gregs[REG_FS];
+ break;
+ case UNW_X86_ES:
+ *value = context_->uc_mcontext.gregs[REG_ES];
+ break;
+ case UNW_X86_DS:
+ *value = context_->uc_mcontext.gregs[REG_DS];
+ break;
+ case UNW_X86_EAX:
+ *value = context_->uc_mcontext.gregs[REG_EAX];
+ break;
+ case UNW_X86_EBX:
+ *value = context_->uc_mcontext.gregs[REG_EBX];
+ break;
+ case UNW_X86_ECX:
+ *value = context_->uc_mcontext.gregs[REG_ECX];
+ break;
+ case UNW_X86_EDX:
+ *value = context_->uc_mcontext.gregs[REG_EDX];
+ break;
+ case UNW_X86_ESI:
+ *value = context_->uc_mcontext.gregs[REG_ESI];
+ break;
+ case UNW_X86_EDI:
+ *value = context_->uc_mcontext.gregs[REG_EDI];
+ break;
+ case UNW_X86_EBP:
+ *value = context_->uc_mcontext.gregs[REG_EBP];
+ break;
+ case UNW_X86_EIP:
+ *value = context_->uc_mcontext.gregs[REG_EIP];
+ break;
+ case UNW_X86_ESP:
+ *value = context_->uc_mcontext.gregs[REG_ESP];
+ break;
+ case UNW_X86_TRAPNO:
+ *value = context_->uc_mcontext.gregs[REG_TRAPNO];
+ break;
+ case UNW_X86_CS:
+ *value = context_->uc_mcontext.gregs[REG_CS];
+ break;
+ case UNW_X86_EFLAGS:
+ *value = context_->uc_mcontext.gregs[REG_EFL];
+ break;
+ case UNW_X86_SS:
+ *value = context_->uc_mcontext.gregs[REG_SS];
+ break;
+ default:
+ result = false;
+ }
+#endif
+ return result;
+}
+
+std::string BacktraceOffline::GetFunctionNameRaw(uintptr_t, uintptr_t* offset) {
+ // We don't have enough information to support this. And it is expensive.
+ *offset = 0;
+ return "";
+}
+
+std::unordered_map<std::string, std::unique_ptr<DebugFrameInfo>> BacktraceOffline::debug_frames_;
+std::unordered_set<std::string> BacktraceOffline::debug_frame_missing_files_;
+
+static DebugFrameInfo* ReadDebugFrameFromFile(const std::string& filename);
+
+DebugFrameInfo* BacktraceOffline::GetDebugFrameInFile(const std::string& filename) {
+ if (cache_file_) {
+ auto it = debug_frames_.find(filename);
+ if (it != debug_frames_.end()) {
+ return it->second.get();
+ }
+ if (debug_frame_missing_files_.find(filename) != debug_frame_missing_files_.end()) {
+ return nullptr;
+ }
+ }
+ DebugFrameInfo* debug_frame = ReadDebugFrameFromFile(filename);
+ if (cache_file_) {
+ if (debug_frame != nullptr) {
+ debug_frames_.emplace(filename, std::unique_ptr<DebugFrameInfo>(debug_frame));
+ } else {
+ debug_frame_missing_files_.insert(filename);
+ }
+ } else {
+ if (last_debug_frame_ != nullptr) {
+ delete last_debug_frame_;
+ }
+ last_debug_frame_ = debug_frame;
+ }
+ return debug_frame;
+}
+
+static bool OmitEncodedValue(uint8_t encode, const uint8_t*& p) {
+ if (encode == DW_EH_PE_omit) {
+ return 0;
+ }
+ uint8_t format = encode & 0x0f;
+ switch (format) {
+ case DW_EH_PE_ptr:
+ p += sizeof(unw_word_t);
+ break;
+ case DW_EH_PE_uleb128:
+ case DW_EH_PE_sleb128:
+ while ((*p & 0x80) != 0) {
+ ++p;
+ }
+ ++p;
+ break;
+ case DW_EH_PE_udata2:
+ case DW_EH_PE_sdata2:
+ p += 2;
+ break;
+ case DW_EH_PE_udata4:
+ case DW_EH_PE_sdata4:
+ p += 4;
+ break;
+ case DW_EH_PE_udata8:
+ case DW_EH_PE_sdata8:
+ p += 8;
+ break;
+ default:
+ return false;
+ }
+ return true;
+}
+
+static bool GetFdeTableOffsetInEhFrameHdr(const std::vector<uint8_t>& data,
+ uint64_t* table_offset_in_eh_frame_hdr) {
+ const uint8_t* p = data.data();
+ const uint8_t* end = p + data.size();
+ if (p + 4 > end) {
+ return false;
+ }
+ uint8_t version = *p++;
+ if (version != 1) {
+ return false;
+ }
+ uint8_t eh_frame_ptr_encode = *p++;
+ uint8_t fde_count_encode = *p++;
+ uint8_t fde_table_encode = *p++;
+
+ if (fde_table_encode != (DW_EH_PE_datarel | DW_EH_PE_sdata4)) {
+ return false;
+ }
+
+ if (!OmitEncodedValue(eh_frame_ptr_encode, p) || !OmitEncodedValue(fde_count_encode, p)) {
+ return false;
+ }
+ if (p >= end) {
+ return false;
+ }
+ *table_offset_in_eh_frame_hdr = p - data.data();
+ return true;
+}
+
+using ProgramHeader = DebugFrameInfo::EhFrame::ProgramHeader;
+
+template <class ELFT>
+DebugFrameInfo* ReadDebugFrameFromELFFile(const llvm::object::ELFFile<ELFT>* elf) {
+ bool has_eh_frame_hdr = false;
+ uint64_t eh_frame_hdr_vaddr = 0;
+ std::vector<uint8_t> eh_frame_hdr_data;
+ bool has_eh_frame = false;
+ uint64_t eh_frame_vaddr = 0;
+ std::vector<uint8_t> eh_frame_data;
+
+ for (auto it = elf->begin_sections(); it != elf->end_sections(); ++it) {
+ llvm::ErrorOr<llvm::StringRef> name = elf->getSectionName(&*it);
+ if (name) {
+ if (name.get() == ".debug_frame") {
+ DebugFrameInfo* debug_frame = new DebugFrameInfo;
+ debug_frame->is_eh_frame = false;
+ return debug_frame;
+ }
+ if (name.get() == ".eh_frame_hdr") {
+ has_eh_frame_hdr = true;
+ eh_frame_hdr_vaddr = it->sh_addr;
+ llvm::ErrorOr<llvm::ArrayRef<uint8_t>> data = elf->getSectionContents(&*it);
+ if (data) {
+ eh_frame_hdr_data.insert(eh_frame_hdr_data.begin(), data->data(),
+ data->data() + data->size());
+ } else {
+ return nullptr;
+ }
+ } else if (name.get() == ".eh_frame") {
+ has_eh_frame = true;
+ eh_frame_vaddr = it->sh_addr;
+ llvm::ErrorOr<llvm::ArrayRef<uint8_t>> data = elf->getSectionContents(&*it);
+ if (data) {
+ eh_frame_data.insert(eh_frame_data.begin(), data->data(), data->data() + data->size());
+ } else {
+ return nullptr;
+ }
+ }
+ }
+ }
+ if (!(has_eh_frame_hdr && has_eh_frame)) {
+ return nullptr;
+ }
+ uint64_t fde_table_offset;
+ if (!GetFdeTableOffsetInEhFrameHdr(eh_frame_hdr_data, &fde_table_offset)) {
+ return nullptr;
+ }
+
+ std::vector<ProgramHeader> program_headers;
+ for (auto it = elf->begin_program_headers(); it != elf->end_program_headers(); ++it) {
+ ProgramHeader header;
+ header.vaddr = it->p_vaddr;
+ header.file_offset = it->p_offset;
+ header.file_size = it->p_filesz;
+ program_headers.push_back(header);
+ }
+ DebugFrameInfo* debug_frame = new DebugFrameInfo;
+ debug_frame->is_eh_frame = true;
+ debug_frame->eh_frame.eh_frame_hdr_vaddr = eh_frame_hdr_vaddr;
+ debug_frame->eh_frame.eh_frame_vaddr = eh_frame_vaddr;
+ debug_frame->eh_frame.fde_table_offset_in_eh_frame_hdr = fde_table_offset;
+ debug_frame->eh_frame.eh_frame_hdr_data = std::move(eh_frame_hdr_data);
+ debug_frame->eh_frame.eh_frame_data = std::move(eh_frame_data);
+ debug_frame->eh_frame.program_headers = program_headers;
+ return debug_frame;
+}
+
+static DebugFrameInfo* ReadDebugFrameFromFile(const std::string& filename) {
+ auto owning_binary = llvm::object::createBinary(llvm::StringRef(filename));
+ if (owning_binary.getError()) {
+ return nullptr;
+ }
+ llvm::object::Binary* binary = owning_binary.get().getBinary();
+ auto obj = llvm::dyn_cast<llvm::object::ObjectFile>(binary);
+ if (obj == nullptr) {
+ return nullptr;
+ }
+ if (auto elf = llvm::dyn_cast<llvm::object::ELF32LEObjectFile>(obj)) {
+ return ReadDebugFrameFromELFFile(elf->getELFFile());
+ }
+ if (auto elf = llvm::dyn_cast<llvm::object::ELF64LEObjectFile>(obj)) {
+ return ReadDebugFrameFromELFFile(elf->getELFFile());
+ }
+ return nullptr;
+}
diff --git a/libbacktrace/BacktraceOffline.h b/libbacktrace/BacktraceOffline.h
new file mode 100644
index 0000000..42f826d
--- /dev/null
+++ b/libbacktrace/BacktraceOffline.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _LIBBACKTRACE_UNWIND_OFFLINE_H
+#define _LIBBACKTRACE_UNWIND_OFFLINE_H
+
+#include <libunwind.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <ucontext.h>
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include <backtrace/Backtrace.h>
+
+struct Space {
+ uint64_t start;
+ uint64_t end;
+ const uint8_t* data;
+
+ Space() {
+ Clear();
+ }
+
+ void Clear();
+ size_t Read(uint64_t addr, uint8_t* buffer, size_t size);
+};
+
+struct DebugFrameInfo {
+ bool is_eh_frame;
+ struct EhFrame {
+ uint64_t eh_frame_hdr_vaddr;
+ uint64_t eh_frame_vaddr;
+ uint64_t fde_table_offset_in_eh_frame_hdr;
+ std::vector<uint8_t> eh_frame_hdr_data;
+ std::vector<uint8_t> eh_frame_data;
+ struct ProgramHeader {
+ uint64_t vaddr;
+ uint64_t file_offset;
+ uint64_t file_size;
+ };
+ std::vector<ProgramHeader> program_headers;
+ } eh_frame;
+};
+
+class BacktraceOffline : public Backtrace {
+ public:
+ BacktraceOffline(pid_t pid, pid_t tid, BacktraceMap* map, const backtrace_stackinfo_t& stack,
+ bool cache_file)
+ : Backtrace(pid, tid, map),
+ cache_file_(cache_file),
+ context_(nullptr),
+ last_debug_frame_(nullptr) {
+ stack_space_.start = stack.start;
+ stack_space_.end = stack.end;
+ stack_space_.data = stack.data;
+ }
+
+ virtual ~BacktraceOffline() {
+ if (last_debug_frame_ != nullptr) {
+ delete last_debug_frame_;
+ }
+ }
+
+ bool Unwind(size_t num_ignore_frames, ucontext_t* context) override;
+
+ bool ReadWord(uintptr_t ptr, word_t* out_value) override;
+
+ size_t Read(uintptr_t addr, uint8_t* buffer, size_t bytes) override;
+
+ bool FindProcInfo(unw_addr_space_t addr_space, uint64_t ip, unw_proc_info_t* proc_info,
+ int need_unwind_info);
+
+ bool ReadReg(size_t reg_index, uint64_t* value);
+
+ protected:
+ std::string GetFunctionNameRaw(uintptr_t pc, uintptr_t* offset) override;
+ DebugFrameInfo* GetDebugFrameInFile(const std::string& filename);
+
+ static std::unordered_map<std::string, std::unique_ptr<DebugFrameInfo>> debug_frames_;
+ static std::unordered_set<std::string> debug_frame_missing_files_;
+
+ bool cache_file_;
+ ucontext_t* context_;
+ Space eh_frame_hdr_space_;
+ Space eh_frame_space_;
+ Space stack_space_;
+ DebugFrameInfo* last_debug_frame_;
+};
+
+#endif // _LIBBACKTRACE_BACKTRACE_OFFLINE_H
diff --git a/libbacktrace/backtrace_offline_test.cpp b/libbacktrace/backtrace_offline_test.cpp
new file mode 100644
index 0000000..88a3533
--- /dev/null
+++ b/libbacktrace/backtrace_offline_test.cpp
@@ -0,0 +1,189 @@
+#include <libunwind.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <backtrace/Backtrace.h>
+#include <backtrace/BacktraceMap.h>
+#include <cutils/threads.h>
+
+#include <gtest/gtest.h>
+
+extern "C" {
+// Prototypes for functions in the test library.
+int test_level_one(int, int, int, int, void (*)(void*), void*);
+int test_level_two(int, int, int, int, void (*)(void*), void*);
+int test_level_three(int, int, int, int, void (*)(void*), void*);
+int test_level_four(int, int, int, int, void (*)(void*), void*);
+int test_recursive_call(int, void (*)(void*), void*);
+}
+
+static volatile bool g_exit_flag = false;
+
+static void GetContextAndExit(void* arg) {
+ unw_context_t* unw_context = reinterpret_cast<unw_context_t*>(arg);
+ unw_getcontext(unw_context);
+ // Don't touch the stack anymore.
+ while (!g_exit_flag) {
+ }
+}
+
+struct OfflineThreadArg {
+ unw_context_t unw_context;
+ pid_t tid;
+ std::function<int(void (*)(void*), void*)> function;
+};
+
+static void* OfflineThreadFunc(void* arg) {
+ OfflineThreadArg* fn_arg = reinterpret_cast<OfflineThreadArg*>(arg);
+ fn_arg->tid = gettid();
+ fn_arg->function(GetContextAndExit, &fn_arg->unw_context);
+ return nullptr;
+}
+
+static ucontext_t GetUContextFromUnwContext(const unw_context_t& unw_context) {
+ ucontext_t ucontext;
+ memset(&ucontext, 0, sizeof(ucontext));
+#if defined(__arm__)
+ ucontext.uc_mcontext.arm_r0 = unw_context.regs[0];
+ ucontext.uc_mcontext.arm_r1 = unw_context.regs[1];
+ ucontext.uc_mcontext.arm_r2 = unw_context.regs[2];
+ ucontext.uc_mcontext.arm_r3 = unw_context.regs[3];
+ ucontext.uc_mcontext.arm_r4 = unw_context.regs[4];
+ ucontext.uc_mcontext.arm_r5 = unw_context.regs[5];
+ ucontext.uc_mcontext.arm_r6 = unw_context.regs[6];
+ ucontext.uc_mcontext.arm_r7 = unw_context.regs[7];
+ ucontext.uc_mcontext.arm_r8 = unw_context.regs[8];
+ ucontext.uc_mcontext.arm_r9 = unw_context.regs[9];
+ ucontext.uc_mcontext.arm_r10 = unw_context.regs[10];
+ ucontext.uc_mcontext.arm_fp = unw_context.regs[11];
+ ucontext.uc_mcontext.arm_ip = unw_context.regs[12];
+ ucontext.uc_mcontext.arm_sp = unw_context.regs[13];
+ ucontext.uc_mcontext.arm_lr = unw_context.regs[14];
+ ucontext.uc_mcontext.arm_pc = unw_context.regs[15];
+#else
+ ucontext.uc_mcontext = unw_context.uc_mcontext;
+#endif
+ return ucontext;
+}
+
+static void OfflineBacktraceFunctionCall(std::function<int(void (*)(void*), void*)> function,
+ std::vector<uintptr_t>* pc_values) {
+ // Create a thread to generate the needed stack and registers information.
+ g_exit_flag = false;
+ const size_t stack_size = 1024 * 1024;
+ void* stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ ASSERT_NE(MAP_FAILED, stack);
+ uintptr_t stack_addr = reinterpret_cast<uintptr_t>(stack);
+ pthread_attr_t attr;
+ ASSERT_EQ(0, pthread_attr_init(&attr));
+ ASSERT_EQ(0, pthread_attr_setstack(&attr, reinterpret_cast<void*>(stack), stack_size));
+ pthread_t thread;
+ OfflineThreadArg arg;
+ arg.function = function;
+ ASSERT_EQ(0, pthread_create(&thread, &attr, OfflineThreadFunc, &arg));
+ // Wait for the offline thread to generate the stack and unw_context information.
+ sleep(1);
+ // Copy the stack information.
+ std::vector<uint8_t> stack_data(reinterpret_cast<uint8_t*>(stack),
+ reinterpret_cast<uint8_t*>(stack) + stack_size);
+ g_exit_flag = true;
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
+ ASSERT_EQ(0, munmap(stack, stack_size));
+
+ // Do offline backtrace.
+ std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid()));
+ ASSERT_TRUE(map != nullptr);
+
+ backtrace_stackinfo_t stack_info;
+ stack_info.start = stack_addr;
+ stack_info.end = stack_addr + stack_size;
+ stack_info.data = stack_data.data();
+
+ std::unique_ptr<Backtrace> backtrace(
+ Backtrace::CreateOffline(getpid(), arg.tid, map.get(), stack_info));
+ ASSERT_TRUE(backtrace != nullptr);
+
+ ucontext_t ucontext = GetUContextFromUnwContext(arg.unw_context);
+ ASSERT_TRUE(backtrace->Unwind(0, &ucontext));
+
+ // Collect pc values of the call stack frames.
+ for (size_t i = 0; i < backtrace->NumFrames(); ++i) {
+ pc_values->push_back(backtrace->GetFrame(i)->pc);
+ }
+}
+
+// Return the name of the function which matches the address. Although we don't know the
+// exact end of each function, it is accurate enough for the tests.
+static std::string FunctionNameForAddress(uintptr_t addr) {
+ struct FunctionSymbol {
+ std::string name;
+ uintptr_t start;
+ uintptr_t end;
+ };
+
+ static std::vector<FunctionSymbol> symbols;
+ if (symbols.empty()) {
+ symbols = std::vector<FunctionSymbol>{
+ {"unknown_start", 0, 0},
+ {"test_level_one", reinterpret_cast<uintptr_t>(&test_level_one), 0},
+ {"test_level_two", reinterpret_cast<uintptr_t>(&test_level_two), 0},
+ {"test_level_three", reinterpret_cast<uintptr_t>(&test_level_three), 0},
+ {"test_level_four", reinterpret_cast<uintptr_t>(&test_level_four), 0},
+ {"test_recursive_call", reinterpret_cast<uintptr_t>(&test_recursive_call), 0},
+ {"GetContextAndExit", reinterpret_cast<uintptr_t>(&GetContextAndExit), 0},
+ {"unknown_end", static_cast<uintptr_t>(-1), static_cast<uintptr_t>(-1)},
+ };
+ std::sort(
+ symbols.begin(), symbols.end(),
+ [](const FunctionSymbol& s1, const FunctionSymbol& s2) { return s1.start < s2.start; });
+ for (size_t i = 0; i + 1 < symbols.size(); ++i) {
+ symbols[i].end = symbols[i + 1].start;
+ }
+ }
+ for (auto& symbol : symbols) {
+ if (addr >= symbol.start && addr < symbol.end) {
+ return symbol.name;
+ }
+ }
+ return "";
+}
+
+TEST(libbacktrace, offline) {
+ std::function<int(void (*)(void*), void*)> function =
+ std::bind(test_level_one, 1, 2, 3, 4, std::placeholders::_1, std::placeholders::_2);
+ std::vector<uintptr_t> pc_values;
+ OfflineBacktraceFunctionCall(function, &pc_values);
+ ASSERT_FALSE(pc_values.empty());
+ ASSERT_LE(pc_values.size(), static_cast<size_t>(MAX_BACKTRACE_FRAMES));
+
+ size_t test_one_index = 0;
+ for (size_t i = 0; i < pc_values.size(); ++i) {
+ if (FunctionNameForAddress(pc_values[i]) == "test_level_one") {
+ test_one_index = i;
+ break;
+ }
+ }
+
+ ASSERT_GE(test_one_index, 3u);
+ ASSERT_EQ("test_level_one", FunctionNameForAddress(pc_values[test_one_index]));
+ ASSERT_EQ("test_level_two", FunctionNameForAddress(pc_values[test_one_index - 1]));
+ ASSERT_EQ("test_level_three", FunctionNameForAddress(pc_values[test_one_index - 2]));
+ ASSERT_EQ("test_level_four", FunctionNameForAddress(pc_values[test_one_index - 3]));
+}
+
+TEST(libbacktrace, offline_max_trace) {
+ std::function<int(void (*)(void*), void*)> function = std::bind(
+ test_recursive_call, MAX_BACKTRACE_FRAMES + 10, std::placeholders::_1, std::placeholders::_2);
+ std::vector<uintptr_t> pc_values;
+ OfflineBacktraceFunctionCall(function, &pc_values);
+ ASSERT_FALSE(pc_values.empty());
+ ASSERT_EQ(static_cast<size_t>(MAX_BACKTRACE_FRAMES), pc_values.size());
+ ASSERT_EQ("test_recursive_call", FunctionNameForAddress(pc_values.back()));
+}
diff --git a/libbacktrace/map_info.c b/libbacktrace/map_info.c
deleted file mode 100644
index 073b24a..0000000
--- a/libbacktrace/map_info.c
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <log/log.h>
-#include <sys/time.h>
-
-#include <backtrace/backtrace.h>
-
-#if defined(__APPLE__)
-
-// Mac OS vmmap(1) output:
-// __TEXT 0009f000-000a1000 [ 8K 8K] r-x/rwx SM=COW /Volumes/android/dalvik-dev/out/host/darwin-x86/bin/libcorkscrew_test\n
-// 012345678901234567890123456789012345678901234567890123456789
-// 0 1 2 3 4 5
-static backtrace_map_info_t* parse_vmmap_line(const char* line) {
- unsigned long int start;
- unsigned long int end;
- char permissions[4];
- int name_pos;
- if (sscanf(line, "%*21c %lx-%lx [%*13c] %3c/%*3c SM=%*3c %n",
- &start, &end, permissions, &name_pos) != 3) {
- return NULL;
- }
-
- const char* name = line + name_pos;
- size_t name_len = strlen(name);
-
- backtrace_map_info_t* mi = calloc(1, sizeof(backtrace_map_info_t) + name_len);
- if (mi != NULL) {
- mi->start = start;
- mi->end = end;
- mi->is_readable = permissions[0] == 'r';
- mi->is_writable = permissions[1] == 'w';
- mi->is_executable = permissions[2] == 'x';
- memcpy(mi->name, name, name_len);
- mi->name[name_len - 1] = '\0';
- ALOGV("Parsed map: start=0x%08x, end=0x%08x, "
- "is_readable=%d, is_writable=%d is_executable=%d, name=%s",
- mi->start, mi->end,
- mi->is_readable, mi->is_writable, mi->is_executable, mi->name);
- }
- return mi;
-}
-
-backtrace_map_info_t* backtrace_create_map_info_list(pid_t pid) {
- char cmd[1024];
- if (pid < 0) {
- pid = getpid();
- }
- snprintf(cmd, sizeof(cmd), "vmmap -w -resident -submap -allSplitLibs -interleaved %d", pid);
- FILE* fp = popen(cmd, "r");
- if (fp == NULL) {
- return NULL;
- }
-
- char line[1024];
- backtrace_map_info_t* milist = NULL;
- while (fgets(line, sizeof(line), fp) != NULL) {
- backtrace_map_info_t* mi = parse_vmmap_line(line);
- if (mi != NULL) {
- mi->next = milist;
- milist = mi;
- }
- }
- pclose(fp);
- return milist;
-}
-
-#else
-
-// Linux /proc/<pid>/maps lines:
-// 6f000000-6f01e000 rwxp 00000000 00:0c 16389419 /system/lib/libcomposer.so\n
-// 012345678901234567890123456789012345678901234567890123456789
-// 0 1 2 3 4 5
-static backtrace_map_info_t* parse_maps_line(const char* line)
-{
- unsigned long int start;
- unsigned long int end;
- char permissions[5];
- int name_pos;
- if (sscanf(line, "%lx-%lx %4s %*x %*x:%*x %*d%n", &start, &end,
- permissions, &name_pos) != 3) {
- return NULL;
- }
-
- while (isspace(line[name_pos])) {
- name_pos += 1;
- }
- const char* name = line + name_pos;
- size_t name_len = strlen(name);
- if (name_len && name[name_len - 1] == '\n') {
- name_len -= 1;
- }
-
- backtrace_map_info_t* mi = calloc(1, sizeof(backtrace_map_info_t) + name_len + 1);
- if (mi) {
- mi->start = start;
- mi->end = end;
- mi->is_readable = strlen(permissions) == 4 && permissions[0] == 'r';
- mi->is_writable = strlen(permissions) == 4 && permissions[1] == 'w';
- mi->is_executable = strlen(permissions) == 4 && permissions[2] == 'x';
- memcpy(mi->name, name, name_len);
- mi->name[name_len] = '\0';
- ALOGV("Parsed map: start=0x%08x, end=0x%08x, "
- "is_readable=%d, is_writable=%d, is_executable=%d, name=%s",
- mi->start, mi->end,
- mi->is_readable, mi->is_writable, mi->is_executable, mi->name);
- }
- return mi;
-}
-
-backtrace_map_info_t* backtrace_create_map_info_list(pid_t tid) {
- char path[PATH_MAX];
- char line[1024];
- FILE* fp;
- backtrace_map_info_t* milist = NULL;
-
- if (tid < 0) {
- tid = getpid();
- }
- snprintf(path, PATH_MAX, "/proc/%d/maps", tid);
- fp = fopen(path, "r");
- if (fp) {
- while(fgets(line, sizeof(line), fp)) {
- backtrace_map_info_t* mi = parse_maps_line(line);
- if (mi) {
- mi->next = milist;
- milist = mi;
- }
- }
- fclose(fp);
- }
- return milist;
-}
-
-#endif
-
-void backtrace_destroy_map_info_list(backtrace_map_info_t* milist) {
- while (milist) {
- backtrace_map_info_t* next = milist->next;
- free(milist);
- milist = next;
- }
-}
-
-const backtrace_map_info_t* backtrace_find_map_info(
- const backtrace_map_info_t* milist, uintptr_t addr) {
- const backtrace_map_info_t* mi = milist;
- while (mi && !(addr >= mi->start && addr < mi->end)) {
- mi = mi->next;
- }
- return mi;
-}
diff --git a/liblog/Android.bp b/liblog/Android.bp
new file mode 100644
index 0000000..ee394fd
--- /dev/null
+++ b/liblog/Android.bp
@@ -0,0 +1,76 @@
+//
+// Copyright (C) 2008-2014 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+liblog_host_sources = [
+ "logd_write.c",
+ "log_event_write.c",
+ "fake_log_device.c",
+ //"event.logtags",
+]
+liblog_target_sources = [
+ "logd_write.c",
+ "log_event_write.c",
+ "event_tag_map.c",
+ "log_time.cpp",
+ "log_is_loggable.c",
+ "logprint.c",
+ "log_read.c",
+]
+
+// Shared and static library for host and device
+// ========================================================
+cc_library {
+ name: "liblog",
+ host_supported: true,
+
+ target: {
+ host: {
+ srcs: liblog_host_sources,
+ cflags: ["-DFAKE_LOG_DEVICE=1"],
+ },
+ android: {
+ srcs: liblog_target_sources,
+ // AddressSanitizer runtime library depends on liblog.
+ sanitize: ["never"],
+ },
+ android_arm: {
+ // TODO: This is to work around b/19059885. Remove after root cause is fixed
+ ldflags: ["-Wl,--hash-style=both"],
+ },
+ windows: {
+ srcs: ["uio.c"],
+ },
+ not_windows: {
+ srcs: ["event_tag_map.c"],
+ },
+ linux: {
+ host_ldlibs: ["-lrt"],
+ },
+ },
+
+ cflags: [
+ "-Werror",
+ // This is what we want to do:
+ // liblog_cflags := $(shell \
+ // sed -n \
+ // 's/^\([0-9]*\)[ \t]*liblog[ \t].*/-DLIBLOG_LOG_TAG=\1/p' \
+ // $(LOCAL_PATH)/event.logtags)
+ // so make sure we do not regret hard-coding it as follows:
+ "-DLIBLOG_LOG_TAG=1005",
+ ],
+ compile_multilib: "both",
+ stl: "none",
+}
diff --git a/logcat/Android.mk b/logcat/Android.mk
index 844ab8b..c4a9550 100644
--- a/logcat/Android.mk
+++ b/logcat/Android.mk
@@ -15,4 +15,15 @@
include $(BUILD_EXECUTABLE)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := logpersist.start
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_MODULE_PATH := $(bin_dir)
+LOCAL_SRC_FILES := logpersist
+ALL_TOOLS := logpersist.start logpersist.stop logpersist.cat
+LOCAL_POST_INSTALL_CMD := $(hide) $(foreach t,$(filter-out $(LOCAL_MODULE),$(ALL_TOOLS)),ln -sf $(LOCAL_MODULE) $(TARGET_OUT)/bin/$(t);)
+include $(BUILD_PREBUILT)
+
include $(call first-makefiles-under,$(LOCAL_PATH))
diff --git a/logcat/logcatd.rc b/logcat/logcatd.rc
index 0bc581e..33d39ac 100644
--- a/logcat/logcatd.rc
+++ b/logcat/logcatd.rc
@@ -2,10 +2,10 @@
# all exec/services are called with umask(077), so no gain beyond 0700
mkdir /data/misc/logd 0700 logd log
# logd for write to /data/misc/logd, log group for read from pstore (-L)
- exec - logd log -- /system/bin/logcat -L -b all -v threadtime -v usec -v printable -D -f /data/misc/logd/logcat -r 64 -n 256
+ exec - logd log -- /system/bin/logcat -L -b all -v threadtime -v usec -v printable -D -f /data/misc/logd/logcat -r 1024 -n 256
start logcatd
-service logcatd /system/bin/logcat -b all -v threadtime -v usec -v printable -D -f /data/misc/logd/logcat -r 64 -n 256
+service logcatd /system/bin/logcat -b all -v threadtime -v usec -v printable -D -f /data/misc/logd/logcat -r 1024 -n 256
class late_start
disabled
# logd for write to /data/misc/logd, log group for read from log daemon
diff --git a/logd/logpersist b/logcat/logpersist
similarity index 88%
rename from logd/logpersist
rename to logcat/logpersist
index 215e1e2..6f666f6 100755
--- a/logd/logpersist
+++ b/logcat/logpersist
@@ -1,9 +1,15 @@
#! /system/bin/sh
# logpersist cat start and stop handlers
+progname="${0##*/}"
+case `getprop ro.build.type` in
+userdebug|eng) ;;
+*) echo "${progname} - Permission denied"
+ exit 1
+ ;;
+esac
data=/data/misc/logd
property=persist.logd.logpersistd
service=logcatd
-progname="${0##*/}"
if [ X"${1}" = "-h" -o X"${1}" = X"--help" ]; then
echo "${progname%.*}.cat - dump current ${service%d} logs"
echo "${progname%.*}.start - start ${service} service"
diff --git a/logd/Android.mk b/logd/Android.mk
index 01c51c7..c00061b 100644
--- a/logd/Android.mk
+++ b/logd/Android.mk
@@ -43,15 +43,4 @@
include $(BUILD_EXECUTABLE)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := logpersist.start
-LOCAL_MODULE_TAGS := debug
-LOCAL_MODULE_CLASS := EXECUTABLES
-LOCAL_MODULE_PATH := $(bin_dir)
-LOCAL_SRC_FILES := logpersist
-ALL_TOOLS := logpersist.start logpersist.stop logpersist.cat
-LOCAL_POST_INSTALL_CMD := $(hide) $(foreach t,$(filter-out $(LOCAL_MODULE),$(ALL_TOOLS)),ln -sf $(LOCAL_MODULE) $(TARGET_OUT)/bin/$(t);)
-include $(BUILD_PREBUILT)
-
include $(call first-makefiles-under,$(LOCAL_PATH))
diff --git a/metricsd/metrics_daemon.cc b/metricsd/metrics_daemon.cc
index de7f2ea..f399c55 100644
--- a/metricsd/metrics_daemon.cc
+++ b/metricsd/metrics_daemon.cc
@@ -76,13 +76,13 @@
// The {Read,Write}Sectors numbers are in sectors/second.
// A sector is usually 512 bytes.
-const char kMetricReadSectorsLongName[] = "Platform.ReadSectorsLong";
-const char kMetricWriteSectorsLongName[] = "Platform.WriteSectorsLong";
-const char kMetricReadSectorsShortName[] = "Platform.ReadSectorsShort";
-const char kMetricWriteSectorsShortName[] = "Platform.WriteSectorsShort";
+const char kMetricReadSectorsLongName[] = "Platform.ReadSectors.PerMinute";
+const char kMetricWriteSectorsLongName[] = "Platform.WriteSectors.PerMinute";
+const char kMetricReadSectorsShortName[] = "Platform.ReadSectors.PerSecond";
+const char kMetricWriteSectorsShortName[] = "Platform.WriteSectors.PerSecond";
const int kMetricStatsShortInterval = 1; // seconds
-const int kMetricStatsLongInterval = 30; // seconds
+const int kMetricStatsLongInterval = 60; // seconds
const int kMetricMeminfoInterval = 30; // seconds
@@ -97,16 +97,16 @@
// Major page faults, i.e. the ones that require data to be read from disk.
-const char kMetricPageFaultsLongName[] = "Platform.PageFaultsLong";
-const char kMetricPageFaultsShortName[] = "Platform.PageFaultsShort";
+const char kMetricPageFaultsLongName[] = "Platform.PageFaults.PerMinute";
+const char kMetricPageFaultsShortName[] = "Platform.PageFaults.PerSecond";
// Swap in and Swap out
-const char kMetricSwapInLongName[] = "Platform.SwapInLong";
-const char kMetricSwapInShortName[] = "Platform.SwapInShort";
+const char kMetricSwapInLongName[] = "Platform.SwapIn.PerMinute";
+const char kMetricSwapInShortName[] = "Platform.SwapIn.PerSecond";
-const char kMetricSwapOutLongName[] = "Platform.SwapOutLong";
-const char kMetricSwapOutShortName[] = "Platform.SwapOutShort";
+const char kMetricSwapOutLongName[] = "Platform.SwapOut.PerMinute";
+const char kMetricSwapOutShortName[] = "Platform.SwapOut.PerSecond";
const char kMetricsProcStatFileName[] = "/proc/stat";
const char kVmStatFileName[] = "/proc/vmstat";
@@ -241,7 +241,7 @@
daily_active_use_.reset(
new PersistentInteger("Platform.DailyUseTime"));
version_cumulative_active_use_.reset(
- new PersistentInteger("Platform.CumulativeDailyUseTime"));
+ new PersistentInteger("Platform.CumulativeUseTime"));
version_cumulative_cpu_use_.reset(
new PersistentInteger("Platform.CumulativeCpuTime"));
@@ -444,7 +444,7 @@
UpdateStats(TimeTicks::Now(), Time::Now());
// Reports the active use time since the last crash and resets it.
- SendCrashIntervalSample(user_crash_interval_);
+ SendAndResetCrashIntervalSample(user_crash_interval_);
any_crashes_daily_count_->Add(1);
any_crashes_weekly_count_->Add(1);
@@ -457,7 +457,7 @@
UpdateStats(TimeTicks::Now(), Time::Now());
// Reports the active use time since the last crash and resets it.
- SendCrashIntervalSample(kernel_crash_interval_);
+ SendAndResetCrashIntervalSample(kernel_crash_interval_);
any_crashes_daily_count_->Add(1);
any_crashes_weekly_count_->Add(1);
@@ -472,7 +472,7 @@
UpdateStats(TimeTicks::Now(), Time::Now());
// Reports the active use time since the last crash and resets it.
- SendCrashIntervalSample(unclean_shutdown_interval_);
+ SendAndResetCrashIntervalSample(unclean_shutdown_interval_);
unclean_shutdowns_daily_count_->Add(1);
unclean_shutdowns_weekly_count_->Add(1);
@@ -892,7 +892,7 @@
int swap_used = swap_total - swap_free;
int swap_used_percent = swap_used * 100 / swap_total;
SendSample("Platform.MeminfoSwapUsed", swap_used, 1, 8 * 1000 * 1000, 100);
- SendLinearSample("Platform.MeminfoSwapUsedPercent", swap_used_percent,
+ SendLinearSample("Platform.MeminfoSwapUsed.Percent", swap_used_percent,
100, 101);
}
return true;
@@ -1033,7 +1033,7 @@
int64_t active_use_seconds = version_cumulative_active_use_->Get();
if (active_use_seconds > 0) {
SendSample(version_cumulative_active_use_->Name(),
- active_use_seconds / 1000, // stat is in seconds
+ active_use_seconds,
1, // device may be used very little...
8 * 1000 * 1000, // ... or a lot (about 90 days)
100);
@@ -1046,7 +1046,7 @@
}
}
-void MetricsDaemon::SendDailyUseSample(
+void MetricsDaemon::SendAndResetDailyUseSample(
const scoped_ptr<PersistentInteger>& use) {
SendSample(use->Name(),
use->GetAndClear(),
@@ -1055,7 +1055,7 @@
50); // number of buckets
}
-void MetricsDaemon::SendCrashIntervalSample(
+void MetricsDaemon::SendAndResetCrashIntervalSample(
const scoped_ptr<PersistentInteger>& interval) {
SendSample(interval->Name(),
interval->GetAndClear(),
@@ -1064,7 +1064,7 @@
50); // number of buckets
}
-void MetricsDaemon::SendCrashFrequencySample(
+void MetricsDaemon::SendAndResetCrashFrequencySample(
const scoped_ptr<PersistentInteger>& frequency) {
SendSample(frequency->Name(),
frequency->GetAndClear(),
@@ -1097,21 +1097,20 @@
if (daily_cycle_->Get() != day) {
daily_cycle_->Set(day);
- SendDailyUseSample(daily_active_use_);
- SendDailyUseSample(version_cumulative_active_use_);
- SendCrashFrequencySample(any_crashes_daily_count_);
- SendCrashFrequencySample(user_crashes_daily_count_);
- SendCrashFrequencySample(kernel_crashes_daily_count_);
- SendCrashFrequencySample(unclean_shutdowns_daily_count_);
+ SendAndResetDailyUseSample(daily_active_use_);
+ SendAndResetCrashFrequencySample(any_crashes_daily_count_);
+ SendAndResetCrashFrequencySample(user_crashes_daily_count_);
+ SendAndResetCrashFrequencySample(kernel_crashes_daily_count_);
+ SendAndResetCrashFrequencySample(unclean_shutdowns_daily_count_);
SendKernelCrashesCumulativeCountStats();
}
if (weekly_cycle_->Get() != week) {
weekly_cycle_->Set(week);
- SendCrashFrequencySample(any_crashes_weekly_count_);
- SendCrashFrequencySample(user_crashes_weekly_count_);
- SendCrashFrequencySample(kernel_crashes_weekly_count_);
- SendCrashFrequencySample(unclean_shutdowns_weekly_count_);
+ SendAndResetCrashFrequencySample(any_crashes_weekly_count_);
+ SendAndResetCrashFrequencySample(user_crashes_weekly_count_);
+ SendAndResetCrashFrequencySample(kernel_crashes_weekly_count_);
+ SendAndResetCrashFrequencySample(unclean_shutdowns_weekly_count_);
}
}
diff --git a/metricsd/metrics_daemon.h b/metricsd/metrics_daemon.h
index b363c5e..fbb871e 100644
--- a/metricsd/metrics_daemon.h
+++ b/metricsd/metrics_daemon.h
@@ -171,15 +171,19 @@
base::TimeDelta GetIncrementalCpuUse();
// Sends a sample representing the number of seconds of active use
- // for a 24-hour period.
- void SendDailyUseSample(const scoped_ptr<PersistentInteger>& use);
+ // for a 24-hour period and reset |use|.
+ void SendAndResetDailyUseSample(
+ const scoped_ptr<PersistentInteger>& use);
// Sends a sample representing a time interval between two crashes of the
- // same type.
- void SendCrashIntervalSample(const scoped_ptr<PersistentInteger>& interval);
+ // same type and reset |interval|.
+ void SendAndResetCrashIntervalSample(
+ const scoped_ptr<PersistentInteger>& interval);
- // Sends a sample representing a frequency of crashes of some type.
- void SendCrashFrequencySample(const scoped_ptr<PersistentInteger>& frequency);
+ // Sends a sample representing a frequency of crashes of some type and reset
+ // |frequency|.
+ void SendAndResetCrashFrequencySample(
+ const scoped_ptr<PersistentInteger>& frequency);
// Initializes vm and disk stats reporting.
void StatsReporterInit();
diff --git a/metricsd/metrics_daemon_test.cc b/metricsd/metrics_daemon_test.cc
index 476d0f3..1adf9de 100644
--- a/metricsd/metrics_daemon_test.cc
+++ b/metricsd/metrics_daemon_test.cc
@@ -25,6 +25,7 @@
#include <base/files/scoped_temp_dir.h>
#include <base/strings/string_number_conversions.h>
#include <base/strings/stringprintf.h>
+#include <chromeos/flag_helper.h>
#include <gtest/gtest.h>
#include "constants.h"
@@ -60,6 +61,7 @@
std::string kFakeDiskStats1;
virtual void SetUp() {
+ chromeos::FlagHelper::Init(0, nullptr, "");
EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
scaling_max_freq_path_ = temp_dir_.path().Append("scaling_max");
cpu_max_freq_path_ = temp_dir_.path().Append("cpu_freq_max");
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index f853fac..8b16996 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -13,7 +13,7 @@
#######################################
# asan.options
-ifeq (address,$(strip $(SANITIZE_TARGET)))
+ifneq ($(filter address,$(SANITIZE_TARGET)),)
include $(CLEAR_VARS)
LOCAL_MODULE := asan.options
@@ -33,7 +33,7 @@
LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT)
EXPORT_GLOBAL_ASAN_OPTIONS :=
-ifeq (address,$(strip $(SANITIZE_TARGET)))
+ifneq ($(filter address,$(SANITIZE_TARGET)),)
EXPORT_GLOBAL_ASAN_OPTIONS := export ASAN_OPTIONS include=/system/asan.options
LOCAL_REQUIRED_MODULES := asan.options
endif