blob: dea8f79399e5092b3e03267cc7e6dc283c287970 [file] [log] [blame]
/*
* Copyright (C) 2011 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 "utils.h"
#include <inttypes.h>
#include <pthread.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <memory>
#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
#include "dex_file-inl.h"
#include "mirror/art_field-inl.h"
#include "mirror/art_method-inl.h"
#include "mirror/class-inl.h"
#include "mirror/class_loader.h"
#include "mirror/object-inl.h"
#include "mirror/object_array-inl.h"
#include "mirror/string.h"
#include "os.h"
#include "scoped_thread_state_change.h"
#include "utf-inl.h"
#if defined(__APPLE__)
#include "AvailabilityMacros.h" // For MAC_OS_X_VERSION_MAX_ALLOWED
#include <sys/syscall.h>
#include <sys/time.h>
#endif
#include <backtrace/Backtrace.h> // For DumpNativeStack.
#if defined(__linux__)
#include <linux/unistd.h>
#endif
namespace art {
#if defined(__linux__)
static constexpr bool kUseAddr2line = !kIsTargetBuild;
#endif
pid_t GetTid() {
#if defined(__APPLE__)
uint64_t owner;
CHECK_PTHREAD_CALL(pthread_threadid_np, (NULL, &owner), __FUNCTION__); // Requires Mac OS 10.6
return owner;
#elif defined(__BIONIC__)
return gettid();
#else
return syscall(__NR_gettid);
#endif
}
std::string GetThreadName(pid_t tid) {
std::string result;
if (ReadFileToString(StringPrintf("/proc/self/task/%d/comm", tid), &result)) {
result.resize(result.size() - 1); // Lose the trailing '\n'.
} else {
result = "<unknown>";
}
return result;
}
void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size, size_t* guard_size) {
#if defined(__APPLE__)
*stack_size = pthread_get_stacksize_np(thread);
void* stack_addr = pthread_get_stackaddr_np(thread);
// Check whether stack_addr is the base or end of the stack.
// (On Mac OS 10.7, it's the end.)
int stack_variable;
if (stack_addr > &stack_variable) {
*stack_base = reinterpret_cast<uint8_t*>(stack_addr) - *stack_size;
} else {
*stack_base = stack_addr;
}
// This is wrong, but there doesn't seem to be a way to get the actual value on the Mac.
pthread_attr_t attributes;
CHECK_PTHREAD_CALL(pthread_attr_init, (&attributes), __FUNCTION__);
CHECK_PTHREAD_CALL(pthread_attr_getguardsize, (&attributes, guard_size), __FUNCTION__);
CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attributes), __FUNCTION__);
#else
pthread_attr_t attributes;
CHECK_PTHREAD_CALL(pthread_getattr_np, (thread, &attributes), __FUNCTION__);
CHECK_PTHREAD_CALL(pthread_attr_getstack, (&attributes, stack_base, stack_size), __FUNCTION__);
CHECK_PTHREAD_CALL(pthread_attr_getguardsize, (&attributes, guard_size), __FUNCTION__);
CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attributes), __FUNCTION__);
#if defined(__GLIBC__)
// If we're the main thread, check whether we were run with an unlimited stack. In that case,
// glibc will have reported a 2GB stack for our 32-bit process, and our stack overflow detection
// will be broken because we'll die long before we get close to 2GB.
bool is_main_thread = (::art::GetTid() == getpid());
if (is_main_thread) {
rlimit stack_limit;
if (getrlimit(RLIMIT_STACK, &stack_limit) == -1) {
PLOG(FATAL) << "getrlimit(RLIMIT_STACK) failed";
}
if (stack_limit.rlim_cur == RLIM_INFINITY) {
size_t old_stack_size = *stack_size;
// Use the kernel default limit as our size, and adjust the base to match.
*stack_size = 8 * MB;
*stack_base = reinterpret_cast<uint8_t*>(*stack_base) + (old_stack_size - *stack_size);
VLOG(threads) << "Limiting unlimited stack (reported as " << PrettySize(old_stack_size) << ")"
<< " to " << PrettySize(*stack_size)
<< " with base " << *stack_base;
}
}
#endif
#endif
}
bool ReadFileToString(const std::string& file_name, std::string* result) {
std::unique_ptr<File> file(new File);
if (!file->Open(file_name, O_RDONLY)) {
return false;
}
std::vector<char> buf(8 * KB);
while (true) {
int64_t n = TEMP_FAILURE_RETRY(read(file->Fd(), &buf[0], buf.size()));
if (n == -1) {
return false;
}
if (n == 0) {
return true;
}
result->append(&buf[0], n);
}
}
std::string GetIsoDate() {
time_t now = time(NULL);
tm tmbuf;
tm* ptm = localtime_r(&now, &tmbuf);
return StringPrintf("%04d-%02d-%02d %02d:%02d:%02d",
ptm->tm_year + 1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
}
uint64_t MilliTime() {
#if defined(__linux__)
timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000) + now.tv_nsec / UINT64_C(1000000);
#else // __APPLE__
timeval now;
gettimeofday(&now, NULL);
return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000) + now.tv_usec / UINT64_C(1000);
#endif
}
uint64_t MicroTime() {
#if defined(__linux__)
timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000) + now.tv_nsec / UINT64_C(1000);
#else // __APPLE__
timeval now;
gettimeofday(&now, NULL);
return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000) + now.tv_usec;
#endif
}
uint64_t NanoTime() {
#if defined(__linux__)
timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000000) + now.tv_nsec;
#else // __APPLE__
timeval now;
gettimeofday(&now, NULL);
return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000000) + now.tv_usec * UINT64_C(1000);
#endif
}
uint64_t ThreadCpuNanoTime() {
#if defined(__linux__)
timespec now;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now);
return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000000) + now.tv_nsec;
#else // __APPLE__
UNIMPLEMENTED(WARNING);
return -1;
#endif
}
void NanoSleep(uint64_t ns) {
timespec tm;
tm.tv_sec = 0;
tm.tv_nsec = ns;
nanosleep(&tm, NULL);
}
void InitTimeSpec(bool absolute, int clock, int64_t ms, int32_t ns, timespec* ts) {
int64_t endSec;
if (absolute) {
#if !defined(__APPLE__)
clock_gettime(clock, ts);
#else
UNUSED(clock);
timeval tv;
gettimeofday(&tv, NULL);
ts->tv_sec = tv.tv_sec;
ts->tv_nsec = tv.tv_usec * 1000;
#endif
} else {
ts->tv_sec = 0;
ts->tv_nsec = 0;
}
endSec = ts->tv_sec + ms / 1000;
if (UNLIKELY(endSec >= 0x7fffffff)) {
std::ostringstream ss;
LOG(INFO) << "Note: end time exceeds epoch: " << ss.str();
endSec = 0x7ffffffe;
}
ts->tv_sec = endSec;
ts->tv_nsec = (ts->tv_nsec + (ms % 1000) * 1000000) + ns;
// Catch rollover.
if (ts->tv_nsec >= 1000000000L) {
ts->tv_sec++;
ts->tv_nsec -= 1000000000L;
}
}
std::string PrettyDescriptor(mirror::String* java_descriptor) {
if (java_descriptor == NULL) {
return "null";
}
return PrettyDescriptor(java_descriptor->ToModifiedUtf8().c_str());
}
std::string PrettyDescriptor(mirror::Class* klass) {
if (klass == NULL) {
return "null";
}
std::string temp;
return PrettyDescriptor(klass->GetDescriptor(&temp));
}
std::string PrettyDescriptor(const char* descriptor) {
// Count the number of '['s to get the dimensionality.
const char* c = descriptor;
size_t dim = 0;
while (*c == '[') {
dim++;
c++;
}
// Reference or primitive?
if (*c == 'L') {
// "[[La/b/C;" -> "a.b.C[][]".
c++; // Skip the 'L'.
} else {
// "[[B" -> "byte[][]".
// To make life easier, we make primitives look like unqualified
// reference types.
switch (*c) {
case 'B': c = "byte;"; break;
case 'C': c = "char;"; break;
case 'D': c = "double;"; break;
case 'F': c = "float;"; break;
case 'I': c = "int;"; break;
case 'J': c = "long;"; break;
case 'S': c = "short;"; break;
case 'Z': c = "boolean;"; break;
case 'V': c = "void;"; break; // Used when decoding return types.
default: return descriptor;
}
}
// At this point, 'c' is a string of the form "fully/qualified/Type;"
// or "primitive;". Rewrite the type with '.' instead of '/':
std::string result;
const char* p = c;
while (*p != ';') {
char ch = *p++;
if (ch == '/') {
ch = '.';
}
result.push_back(ch);
}
// ...and replace the semicolon with 'dim' "[]" pairs:
for (size_t i = 0; i < dim; ++i) {
result += "[]";
}
return result;
}
std::string PrettyField(mirror::ArtField* f, bool with_type) {
if (f == NULL) {
return "null";
}
std::string result;
if (with_type) {
result += PrettyDescriptor(f->GetTypeDescriptor());
result += ' ';
}
std::string temp;
result += PrettyDescriptor(f->GetDeclaringClass()->GetDescriptor(&temp));
result += '.';
result += f->GetName();
return result;
}
std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type) {
if (field_idx >= dex_file.NumFieldIds()) {
return StringPrintf("<<invalid-field-idx-%d>>", field_idx);
}
const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
std::string result;
if (with_type) {
result += dex_file.GetFieldTypeDescriptor(field_id);
result += ' ';
}
result += PrettyDescriptor(dex_file.GetFieldDeclaringClassDescriptor(field_id));
result += '.';
result += dex_file.GetFieldName(field_id);
return result;
}
std::string PrettyType(uint32_t type_idx, const DexFile& dex_file) {
if (type_idx >= dex_file.NumTypeIds()) {
return StringPrintf("<<invalid-type-idx-%d>>", type_idx);
}
const DexFile::TypeId& type_id = dex_file.GetTypeId(type_idx);
return PrettyDescriptor(dex_file.GetTypeDescriptor(type_id));
}
std::string PrettyArguments(const char* signature) {
std::string result;
result += '(';
CHECK_EQ(*signature, '(');
++signature; // Skip the '('.
while (*signature != ')') {
size_t argument_length = 0;
while (signature[argument_length] == '[') {
++argument_length;
}
if (signature[argument_length] == 'L') {
argument_length = (strchr(signature, ';') - signature + 1);
} else {
++argument_length;
}
{
std::string argument_descriptor(signature, argument_length);
result += PrettyDescriptor(argument_descriptor.c_str());
}
if (signature[argument_length] != ')') {
result += ", ";
}
signature += argument_length;
}
CHECK_EQ(*signature, ')');
++signature; // Skip the ')'.
result += ')';
return result;
}
std::string PrettyReturnType(const char* signature) {
const char* return_type = strchr(signature, ')');
CHECK(return_type != NULL);
++return_type; // Skip ')'.
return PrettyDescriptor(return_type);
}
std::string PrettyMethod(mirror::ArtMethod* m, bool with_signature) {
if (m == nullptr) {
return "null";
}
std::string result(PrettyDescriptor(m->GetDeclaringClassDescriptor()));
result += '.';
result += m->GetName();
if (UNLIKELY(m->IsFastNative())) {
result += "!";
}
if (with_signature) {
const Signature signature = m->GetSignature();
std::string sig_as_string(signature.ToString());
if (signature == Signature::NoSignature()) {
return result + sig_as_string;
}
result = PrettyReturnType(sig_as_string.c_str()) + " " + result +
PrettyArguments(sig_as_string.c_str());
}
return result;
}
std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature) {
if (method_idx >= dex_file.NumMethodIds()) {
return StringPrintf("<<invalid-method-idx-%d>>", method_idx);
}
const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
std::string result(PrettyDescriptor(dex_file.GetMethodDeclaringClassDescriptor(method_id)));
result += '.';
result += dex_file.GetMethodName(method_id);
if (with_signature) {
const Signature signature = dex_file.GetMethodSignature(method_id);
std::string sig_as_string(signature.ToString());
if (signature == Signature::NoSignature()) {
return result + sig_as_string;
}
result = PrettyReturnType(sig_as_string.c_str()) + " " + result +
PrettyArguments(sig_as_string.c_str());
}
return result;
}
std::string PrettyTypeOf(mirror::Object* obj) {
if (obj == NULL) {
return "null";
}
if (obj->GetClass() == NULL) {
return "(raw)";
}
std::string temp;
std::string result(PrettyDescriptor(obj->GetClass()->GetDescriptor(&temp)));
if (obj->IsClass()) {
result += "<" + PrettyDescriptor(obj->AsClass()->GetDescriptor(&temp)) + ">";
}
return result;
}
std::string PrettyClass(mirror::Class* c) {
if (c == NULL) {
return "null";
}
std::string result;
result += "java.lang.Class<";
result += PrettyDescriptor(c);
result += ">";
return result;
}
std::string PrettyClassAndClassLoader(mirror::Class* c) {
if (c == NULL) {
return "null";
}
std::string result;
result += "java.lang.Class<";
result += PrettyDescriptor(c);
result += ",";
result += PrettyTypeOf(c->GetClassLoader());
// TODO: add an identifying hash value for the loader
result += ">";
return result;
}
std::string PrettyJavaAccessFlags(uint32_t access_flags) {
std::string result;
if ((access_flags & kAccPublic) != 0) {
result += "public ";
}
if ((access_flags & kAccProtected) != 0) {
result += "protected ";
}
if ((access_flags & kAccPrivate) != 0) {
result += "private ";
}
if ((access_flags & kAccFinal) != 0) {
result += "final ";
}
if ((access_flags & kAccStatic) != 0) {
result += "static ";
}
if ((access_flags & kAccTransient) != 0) {
result += "transient ";
}
if ((access_flags & kAccVolatile) != 0) {
result += "volatile ";
}
if ((access_flags & kAccSynchronized) != 0) {
result += "synchronized ";
}
return result;
}
std::string PrettySize(int64_t byte_count) {
// The byte thresholds at which we display amounts. A byte count is displayed
// in unit U when kUnitThresholds[U] <= bytes < kUnitThresholds[U+1].
static const int64_t kUnitThresholds[] = {
0, // B up to...
3*1024, // KB up to...
2*1024*1024, // MB up to...
1024*1024*1024 // GB from here.
};
static const int64_t kBytesPerUnit[] = { 1, KB, MB, GB };
static const char* const kUnitStrings[] = { "B", "KB", "MB", "GB" };
const char* negative_str = "";
if (byte_count < 0) {
negative_str = "-";
byte_count = -byte_count;
}
int i = arraysize(kUnitThresholds);
while (--i > 0) {
if (byte_count >= kUnitThresholds[i]) {
break;
}
}
return StringPrintf("%s%" PRId64 "%s",
negative_str, byte_count / kBytesPerUnit[i], kUnitStrings[i]);
}
std::string PrettyDuration(uint64_t nano_duration, size_t max_fraction_digits) {
if (nano_duration == 0) {
return "0";
} else {
return FormatDuration(nano_duration, GetAppropriateTimeUnit(nano_duration),
max_fraction_digits);
}
}
TimeUnit GetAppropriateTimeUnit(uint64_t nano_duration) {
const uint64_t one_sec = 1000 * 1000 * 1000;
const uint64_t one_ms = 1000 * 1000;
const uint64_t one_us = 1000;
if (nano_duration >= one_sec) {
return kTimeUnitSecond;
} else if (nano_duration >= one_ms) {
return kTimeUnitMillisecond;
} else if (nano_duration >= one_us) {
return kTimeUnitMicrosecond;
} else {
return kTimeUnitNanosecond;
}
}
uint64_t GetNsToTimeUnitDivisor(TimeUnit time_unit) {
const uint64_t one_sec = 1000 * 1000 * 1000;
const uint64_t one_ms = 1000 * 1000;
const uint64_t one_us = 1000;
switch (time_unit) {
case kTimeUnitSecond:
return one_sec;
case kTimeUnitMillisecond:
return one_ms;
case kTimeUnitMicrosecond:
return one_us;
case kTimeUnitNanosecond:
return 1;
}
return 0;
}
std::string FormatDuration(uint64_t nano_duration, TimeUnit time_unit,
size_t max_fraction_digits) {
const char* unit = nullptr;
uint64_t divisor = GetNsToTimeUnitDivisor(time_unit);
switch (time_unit) {
case kTimeUnitSecond:
unit = "s";
break;
case kTimeUnitMillisecond:
unit = "ms";
break;
case kTimeUnitMicrosecond:
unit = "us";
break;
case kTimeUnitNanosecond:
unit = "ns";
break;
}
const uint64_t whole_part = nano_duration / divisor;
uint64_t fractional_part = nano_duration % divisor;
if (fractional_part == 0) {
return StringPrintf("%" PRIu64 "%s", whole_part, unit);
} else {
static constexpr size_t kMaxDigits = 30;
size_t avail_digits = kMaxDigits;
char fraction_buffer[kMaxDigits];
char* ptr = fraction_buffer;
uint64_t multiplier = 10;
// This infinite loops if fractional part is 0.
while (avail_digits > 1 && fractional_part * multiplier < divisor) {
multiplier *= 10;
*ptr++ = '0';
avail_digits--;
}
snprintf(ptr, avail_digits, "%" PRIu64, fractional_part);
fraction_buffer[std::min(kMaxDigits - 1, max_fraction_digits)] = '\0';
return StringPrintf("%" PRIu64 ".%s%s", whole_part, fraction_buffer, unit);
}
}
std::string PrintableChar(uint16_t ch) {
std::string result;
result += '\'';
if (NeedsEscaping(ch)) {
StringAppendF(&result, "\\u%04x", ch);
} else {
result += ch;
}
result += '\'';
return result;
}
std::string PrintableString(const char* utf) {
std::string result;
result += '"';
const char* p = utf;
size_t char_count = CountModifiedUtf8Chars(p);
for (size_t i = 0; i < char_count; ++i) {
uint32_t ch = GetUtf16FromUtf8(&p);
if (ch == '\\') {
result += "\\\\";
} else if (ch == '\n') {
result += "\\n";
} else if (ch == '\r') {
result += "\\r";
} else if (ch == '\t') {
result += "\\t";
} else {
const uint16_t leading = GetLeadingUtf16Char(ch);
if (NeedsEscaping(leading)) {
StringAppendF(&result, "\\u%04x", leading);
} else {
result += leading;
}
const uint32_t trailing = GetTrailingUtf16Char(ch);
if (trailing != 0) {
// All high surrogates will need escaping.
StringAppendF(&result, "\\u%04x", trailing);
}
}
}
result += '"';
return result;
}
// See http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/design.html#wp615 for the full rules.
std::string MangleForJni(const std::string& s) {
std::string result;
size_t char_count = CountModifiedUtf8Chars(s.c_str());
const char* cp = &s[0];
for (size_t i = 0; i < char_count; ++i) {
uint32_t ch = GetUtf16FromUtf8(&cp);
if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) {
result.push_back(ch);
} else if (ch == '.' || ch == '/') {
result += "_";
} else if (ch == '_') {
result += "_1";
} else if (ch == ';') {
result += "_2";
} else if (ch == '[') {
result += "_3";
} else {
const uint16_t leading = GetLeadingUtf16Char(ch);
const uint32_t trailing = GetTrailingUtf16Char(ch);
StringAppendF(&result, "_0%04x", leading);
if (trailing != 0) {
StringAppendF(&result, "_0%04x", trailing);
}
}
}
return result;
}
std::string DotToDescriptor(const char* class_name) {
std::string descriptor(class_name);
std::replace(descriptor.begin(), descriptor.end(), '.', '/');
if (descriptor.length() > 0 && descriptor[0] != '[') {
descriptor = "L" + descriptor + ";";
}
return descriptor;
}
std::string DescriptorToDot(const char* descriptor) {
size_t length = strlen(descriptor);
if (length > 1) {
if (descriptor[0] == 'L' && descriptor[length - 1] == ';') {
// Descriptors have the leading 'L' and trailing ';' stripped.
std::string result(descriptor + 1, length - 2);
std::replace(result.begin(), result.end(), '/', '.');
return result;
} else {
// For arrays the 'L' and ';' remain intact.
std::string result(descriptor);
std::replace(result.begin(), result.end(), '/', '.');
return result;
}
}
// Do nothing for non-class/array descriptors.
return descriptor;
}
std::string DescriptorToName(const char* descriptor) {
size_t length = strlen(descriptor);
if (descriptor[0] == 'L' && descriptor[length - 1] == ';') {
std::string result(descriptor + 1, length - 2);
return result;
}
return descriptor;
}
std::string JniShortName(mirror::ArtMethod* m) {
std::string class_name(m->GetDeclaringClassDescriptor());
// Remove the leading 'L' and trailing ';'...
CHECK_EQ(class_name[0], 'L') << class_name;
CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name;
class_name.erase(0, 1);
class_name.erase(class_name.size() - 1, 1);
std::string method_name(m->GetName());
std::string short_name;
short_name += "Java_";
short_name += MangleForJni(class_name);
short_name += "_";
short_name += MangleForJni(method_name);
return short_name;
}
std::string JniLongName(mirror::ArtMethod* m) {
std::string long_name;
long_name += JniShortName(m);
long_name += "__";
std::string signature(m->GetSignature().ToString());
signature.erase(0, 1);
signature.erase(signature.begin() + signature.find(')'), signature.end());
long_name += MangleForJni(signature);
return long_name;
}
// Helper for IsValidPartOfMemberNameUtf8(), a bit vector indicating valid low ascii.
uint32_t DEX_MEMBER_VALID_LOW_ASCII[4] = {
0x00000000, // 00..1f low control characters; nothing valid
0x03ff2010, // 20..3f digits and symbols; valid: '0'..'9', '$', '-'
0x87fffffe, // 40..5f uppercase etc.; valid: 'A'..'Z', '_'
0x07fffffe // 60..7f lowercase etc.; valid: 'a'..'z'
};
// Helper for IsValidPartOfMemberNameUtf8(); do not call directly.
bool IsValidPartOfMemberNameUtf8Slow(const char** pUtf8Ptr) {
/*
* It's a multibyte encoded character. Decode it and analyze. We
* accept anything that isn't (a) an improperly encoded low value,
* (b) an improper surrogate pair, (c) an encoded '\0', (d) a high
* control character, or (e) a high space, layout, or special
* character (U+00a0, U+2000..U+200f, U+2028..U+202f,
* U+fff0..U+ffff). This is all specified in the dex format
* document.
*/
const uint32_t pair = GetUtf16FromUtf8(pUtf8Ptr);
const uint16_t leading = GetLeadingUtf16Char(pair);
const uint32_t trailing = GetTrailingUtf16Char(pair);
if (trailing == 0) {
// Perform follow-up tests based on the high 8 bits of the
// lower surrogate.
switch (leading >> 8) {
case 0x00:
// It's only valid if it's above the ISO-8859-1 high space (0xa0).
return (leading > 0x00a0);
case 0xd8:
case 0xd9:
case 0xda:
case 0xdb:
// It looks like a leading surrogate but we didn't find a trailing
// surrogate if we're here.
return false;
case 0xdc:
case 0xdd:
case 0xde:
case 0xdf:
// It's a trailing surrogate, which is not valid at this point.
return false;
case 0x20:
case 0xff:
// It's in the range that has spaces, controls, and specials.
switch (leading & 0xfff8) {
case 0x2000:
case 0x2008:
case 0x2028:
case 0xfff0:
case 0xfff8:
return false;
}
break;
}
return true;
}
// We have a surrogate pair. Check that trailing surrogate is well formed.
return (trailing >= 0xdc00 && trailing <= 0xdfff);
}
/* Return whether the pointed-at modified-UTF-8 encoded character is
* valid as part of a member name, updating the pointer to point past
* the consumed character. This will consume two encoded UTF-16 code
* points if the character is encoded as a surrogate pair. Also, if
* this function returns false, then the given pointer may only have
* been partially advanced.
*/
static bool IsValidPartOfMemberNameUtf8(const char** pUtf8Ptr) {
uint8_t c = (uint8_t) **pUtf8Ptr;
if (LIKELY(c <= 0x7f)) {
// It's low-ascii, so check the table.
uint32_t wordIdx = c >> 5;
uint32_t bitIdx = c & 0x1f;
(*pUtf8Ptr)++;
return (DEX_MEMBER_VALID_LOW_ASCII[wordIdx] & (1 << bitIdx)) != 0;
}
// It's a multibyte encoded character. Call a non-inline function
// for the heavy lifting.
return IsValidPartOfMemberNameUtf8Slow(pUtf8Ptr);
}
bool IsValidMemberName(const char* s) {
bool angle_name = false;
switch (*s) {
case '\0':
// The empty string is not a valid name.
return false;
case '<':
angle_name = true;
s++;
break;
}
while (true) {
switch (*s) {
case '\0':
return !angle_name;
case '>':
return angle_name && s[1] == '\0';
}
if (!IsValidPartOfMemberNameUtf8(&s)) {
return false;
}
}
}
enum ClassNameType { kName, kDescriptor };
template<ClassNameType kType, char kSeparator>
static bool IsValidClassName(const char* s) {
int arrayCount = 0;
while (*s == '[') {
arrayCount++;
s++;
}
if (arrayCount > 255) {
// Arrays may have no more than 255 dimensions.
return false;
}
ClassNameType type = kType;
if (type != kDescriptor && arrayCount != 0) {
/*
* If we're looking at an array of some sort, then it doesn't
* matter if what is being asked for is a class name; the
* format looks the same as a type descriptor in that case, so
* treat it as such.
*/
type = kDescriptor;
}
if (type == kDescriptor) {
/*
* We are looking for a descriptor. Either validate it as a
* single-character primitive type, or continue on to check the
* embedded class name (bracketed by "L" and ";").
*/
switch (*(s++)) {
case 'B':
case 'C':
case 'D':
case 'F':
case 'I':
case 'J':
case 'S':
case 'Z':
// These are all single-character descriptors for primitive types.
return (*s == '\0');
case 'V':
// Non-array void is valid, but you can't have an array of void.
return (arrayCount == 0) && (*s == '\0');
case 'L':
// Class name: Break out and continue below.
break;
default:
// Oddball descriptor character.
return false;
}
}
/*
* We just consumed the 'L' that introduces a class name as part
* of a type descriptor, or we are looking for an unadorned class
* name.
*/
bool sepOrFirst = true; // first character or just encountered a separator.
for (;;) {
uint8_t c = (uint8_t) *s;
switch (c) {
case '\0':
/*
* Premature end for a type descriptor, but valid for
* a class name as long as we haven't encountered an
* empty component (including the degenerate case of
* the empty string "").
*/
return (type == kName) && !sepOrFirst;
case ';':
/*
* Invalid character for a class name, but the
* legitimate end of a type descriptor. In the latter
* case, make sure that this is the end of the string
* and that it doesn't end with an empty component
* (including the degenerate case of "L;").
*/
return (type == kDescriptor) && !sepOrFirst && (s[1] == '\0');
case '/':
case '.':
if (c != kSeparator) {
// The wrong separator character.
return false;
}
if (sepOrFirst) {
// Separator at start or two separators in a row.
return false;
}
sepOrFirst = true;
s++;
break;
default:
if (!IsValidPartOfMemberNameUtf8(&s)) {
return false;
}
sepOrFirst = false;
break;
}
}
}
bool IsValidBinaryClassName(const char* s) {
return IsValidClassName<kName, '.'>(s);
}
bool IsValidJniClassName(const char* s) {
return IsValidClassName<kName, '/'>(s);
}
bool IsValidDescriptor(const char* s) {
return IsValidClassName<kDescriptor, '/'>(s);
}
void Split(const std::string& s, char separator, std::vector<std::string>* result) {
const char* p = s.data();
const char* end = p + s.size();
while (p != end) {
if (*p == separator) {
++p;
} else {
const char* start = p;
while (++p != end && *p != separator) {
// Skip to the next occurrence of the separator.
}
result->push_back(std::string(start, p - start));
}
}
}
std::string Trim(const std::string& s) {
std::string result;
unsigned int start_index = 0;
unsigned int end_index = s.size() - 1;
// Skip initial whitespace.
while (start_index < s.size()) {
if (!isspace(s[start_index])) {
break;
}
start_index++;
}
// Skip terminating whitespace.
while (end_index >= start_index) {
if (!isspace(s[end_index])) {
break;
}
end_index--;
}
// All spaces, no beef.
if (end_index < start_index) {
return "";
}
// Start_index is the first non-space, end_index is the last one.
return s.substr(start_index, end_index - start_index + 1);
}
template <typename StringT>
std::string Join(const std::vector<StringT>& strings, char separator) {
if (strings.empty()) {
return "";
}
std::string result(strings[0]);
for (size_t i = 1; i < strings.size(); ++i) {
result += separator;
result += strings[i];
}
return result;
}
// Explicit instantiations.
template std::string Join<std::string>(const std::vector<std::string>& strings, char separator);
template std::string Join<const char*>(const std::vector<const char*>& strings, char separator);
bool StartsWith(const std::string& s, const char* prefix) {
return s.compare(0, strlen(prefix), prefix) == 0;
}
bool EndsWith(const std::string& s, const char* suffix) {
size_t suffix_length = strlen(suffix);
size_t string_length = s.size();
if (suffix_length > string_length) {
return false;
}
size_t offset = string_length - suffix_length;
return s.compare(offset, suffix_length, suffix) == 0;
}
void SetThreadName(const char* thread_name) {
int hasAt = 0;
int hasDot = 0;
const char* s = thread_name;
while (*s) {
if (*s == '.') {
hasDot = 1;
} else if (*s == '@') {
hasAt = 1;
}
s++;
}
int len = s - thread_name;
if (len < 15 || hasAt || !hasDot) {
s = thread_name;
} else {
s = thread_name + len - 15;
}
#if defined(__linux__)
// pthread_setname_np fails rather than truncating long strings.
char buf[16]; // MAX_TASK_COMM_LEN=16 is hard-coded in the kernel.
strncpy(buf, s, sizeof(buf)-1);
buf[sizeof(buf)-1] = '\0';
errno = pthread_setname_np(pthread_self(), buf);
if (errno != 0) {
PLOG(WARNING) << "Unable to set the name of current thread to '" << buf << "'";
}
#else // __APPLE__
pthread_setname_np(thread_name);
#endif
}
void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu) {
*utime = *stime = *task_cpu = 0;
std::string stats;
if (!ReadFileToString(StringPrintf("/proc/self/task/%d/stat", tid), &stats)) {
return;
}
// Skip the command, which may contain spaces.
stats = stats.substr(stats.find(')') + 2);
// Extract the three fields we care about.
std::vector<std::string> fields;
Split(stats, ' ', &fields);
*state = fields[0][0];
*utime = strtoull(fields[11].c_str(), NULL, 10);
*stime = strtoull(fields[12].c_str(), NULL, 10);
*task_cpu = strtoull(fields[36].c_str(), NULL, 10);
}
std::string GetSchedulerGroupName(pid_t tid) {
// /proc/<pid>/cgroup looks like this:
// 2:devices:/
// 1:cpuacct,cpu:/
// We want the third field from the line whose second field contains the "cpu" token.
std::string cgroup_file;
if (!ReadFileToString(StringPrintf("/proc/self/task/%d/cgroup", tid), &cgroup_file)) {
return "";
}
std::vector<std::string> cgroup_lines;
Split(cgroup_file, '\n', &cgroup_lines);
for (size_t i = 0; i < cgroup_lines.size(); ++i) {
std::vector<std::string> cgroup_fields;
Split(cgroup_lines[i], ':', &cgroup_fields);
std::vector<std::string> cgroups;
Split(cgroup_fields[1], ',', &cgroups);
for (size_t j = 0; j < cgroups.size(); ++j) {
if (cgroups[j] == "cpu") {
return cgroup_fields[2].substr(1); // Skip the leading slash.
}
}
}
return "";
}
#if defined(__linux__)
ALWAYS_INLINE
static inline void WritePrefix(std::ostream* os, const char* prefix, bool odd) {
if (prefix != nullptr) {
*os << prefix;
}
*os << " ";
if (!odd) {
*os << " ";
}
}
static bool RunCommand(std::string cmd, std::ostream* os, const char* prefix) {
FILE* stream = popen(cmd.c_str(), "r");
if (stream) {
if (os != nullptr) {
bool odd_line = true; // We indent them differently.
bool wrote_prefix = false; // Have we already written a prefix?
constexpr size_t kMaxBuffer = 128; // Relatively small buffer. Should be OK as we're on an
// alt stack, but just to be sure...
char buffer[kMaxBuffer];
while (!feof(stream)) {
if (fgets(buffer, kMaxBuffer, stream) != nullptr) {
// Split on newlines.
char* tmp = buffer;
for (;;) {
char* new_line = strchr(tmp, '\n');
if (new_line == nullptr) {
// Print the rest.
if (*tmp != 0) {
if (!wrote_prefix) {
WritePrefix(os, prefix, odd_line);
}
wrote_prefix = true;
*os << tmp;
}
break;
}
if (!wrote_prefix) {
WritePrefix(os, prefix, odd_line);
}
char saved = *(new_line + 1);
*(new_line + 1) = 0;
*os << tmp;
*(new_line + 1) = saved;
tmp = new_line + 1;
odd_line = !odd_line;
wrote_prefix = false;
}
}
}
}
pclose(stream);
return true;
} else {
return false;
}
}
static void Addr2line(const std::string& map_src, uintptr_t offset, std::ostream& os,
const char* prefix) {
std::string cmdline(StringPrintf("addr2line --functions --inlines --demangle -e %s %zx",
map_src.c_str(), offset));
RunCommand(cmdline.c_str(), &os, prefix);
}
#endif
void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix,
mirror::ArtMethod* current_method, void* ucontext_ptr) {
#if __linux__
// b/18119146
if (RUNNING_ON_VALGRIND != 0) {
return;
}
#if !defined(HAVE_ANDROID_OS)
if (GetTid() != tid) {
// TODO: dumping of other threads is disabled to avoid crashes during stress testing.
// b/15446488.
return;
}
#endif
std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, tid));
if (!backtrace->Unwind(0, reinterpret_cast<ucontext*>(ucontext_ptr))) {
os << prefix << "(backtrace::Unwind failed for thread " << tid << ")\n";
return;
} else if (backtrace->NumFrames() == 0) {
os << prefix << "(no native stack frames for thread " << tid << ")\n";
return;
}
// Check whether we have and should use addr2line.
bool use_addr2line;
if (kUseAddr2line) {
// Try to run it to see whether we have it. Push an argument so that it doesn't assume a.out
// and print to stderr.
use_addr2line = (gAborting > 0) && RunCommand("addr2line -h", nullptr, nullptr);
} else {
use_addr2line = false;
}
for (Backtrace::const_iterator it = backtrace->begin();
it != backtrace->end(); ++it) {
// We produce output like this:
// ] #00 pc 000075bb8 /system/lib/libc.so (unwind_backtrace_thread+536)
// In order for parsing tools to continue to function, the stack dump
// format must at least adhere to this format:
// #XX pc <RELATIVE_ADDR> <FULL_PATH_TO_SHARED_LIBRARY> ...
// The parsers require a single space before and after pc, and two spaces
// after the <RELATIVE_ADDR>. There can be any prefix data before the
// #XX. <RELATIVE_ADDR> has to be a hex number but with no 0x prefix.
os << prefix << StringPrintf("#%02zu pc ", it->num);
bool try_addr2line = false;
if (!BacktraceMap::IsValid(it->map)) {
os << StringPrintf("%08" PRIxPTR " ???", it->pc);
} else {
os << StringPrintf("%08" PRIxPTR " ", it->pc - it->map.start);
os << it->map.name;
os << " (";
if (!it->func_name.empty()) {
os << it->func_name;
if (it->func_offset != 0) {
os << "+" << it->func_offset;
}
try_addr2line = true;
} else if (
current_method != nullptr && Locks::mutator_lock_->IsSharedHeld(Thread::Current()) &&
current_method->PcIsWithinQuickCode(it->pc)) {
const void* start_of_code = current_method->GetEntryPointFromQuickCompiledCode();
os << JniLongName(current_method) << "+"
<< (it->pc - reinterpret_cast<uintptr_t>(start_of_code));
} else {
os << "???";
}
os << ")";
}
os << "\n";
if (try_addr2line && use_addr2line) {
Addr2line(it->map.name, it->pc - it->map.start, os, prefix);
}
}
#else
UNUSED(os, tid, prefix, current_method, ucontext_ptr);
#endif
}
#if defined(__APPLE__)
// TODO: is there any way to get the kernel stack on Mac OS?
void DumpKernelStack(std::ostream&, pid_t, const char*, bool) {}
#else
void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix, bool include_count) {
if (tid == GetTid()) {
// There's no point showing that we're reading our stack out of /proc!
return;
}
std::string kernel_stack_filename(StringPrintf("/proc/self/task/%d/stack", tid));
std::string kernel_stack;
if (!ReadFileToString(kernel_stack_filename, &kernel_stack)) {
os << prefix << "(couldn't read " << kernel_stack_filename << ")\n";
return;
}
std::vector<std::string> kernel_stack_frames;
Split(kernel_stack, '\n', &kernel_stack_frames);
// We skip the last stack frame because it's always equivalent to "[<ffffffff>] 0xffffffff",
// which looking at the source appears to be the kernel's way of saying "that's all, folks!".
kernel_stack_frames.pop_back();
for (size_t i = 0; i < kernel_stack_frames.size(); ++i) {
// Turn "[<ffffffff8109156d>] futex_wait_queue_me+0xcd/0x110"
// into "futex_wait_queue_me+0xcd/0x110".
const char* text = kernel_stack_frames[i].c_str();
const char* close_bracket = strchr(text, ']');
if (close_bracket != NULL) {
text = close_bracket + 2;
}
os << prefix;
if (include_count) {
os << StringPrintf("#%02zd ", i);
}
os << text << "\n";
}
}
#endif
const char* GetAndroidRoot() {
const char* android_root = getenv("ANDROID_ROOT");
if (android_root == NULL) {
if (OS::DirectoryExists("/system")) {
android_root = "/system";
} else {
LOG(FATAL) << "ANDROID_ROOT not set and /system does not exist";
return "";
}
}
if (!OS::DirectoryExists(android_root)) {
LOG(FATAL) << "Failed to find ANDROID_ROOT directory " << android_root;
return "";
}
return android_root;
}
const char* GetAndroidData() {
std::string error_msg;
const char* dir = GetAndroidDataSafe(&error_msg);
if (dir != nullptr) {
return dir;
} else {
LOG(FATAL) << error_msg;
return "";
}
}
const char* GetAndroidDataSafe(std::string* error_msg) {
const char* android_data = getenv("ANDROID_DATA");
if (android_data == NULL) {
if (OS::DirectoryExists("/data")) {
android_data = "/data";
} else {
*error_msg = "ANDROID_DATA not set and /data does not exist";
return nullptr;
}
}
if (!OS::DirectoryExists(android_data)) {
*error_msg = StringPrintf("Failed to find ANDROID_DATA directory %s", android_data);
return nullptr;
}
return android_data;
}
void GetDalvikCache(const char* subdir, const bool create_if_absent, std::string* dalvik_cache,
bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache) {
CHECK(subdir != nullptr);
std::string error_msg;
const char* android_data = GetAndroidDataSafe(&error_msg);
if (android_data == nullptr) {
*have_android_data = false;
*dalvik_cache_exists = false;
*is_global_cache = false;
return;
} else {
*have_android_data = true;
}
const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data));
*dalvik_cache = dalvik_cache_root + subdir;
*dalvik_cache_exists = OS::DirectoryExists(dalvik_cache->c_str());
*is_global_cache = strcmp(android_data, "/data") == 0;
if (create_if_absent && !*dalvik_cache_exists && !*is_global_cache) {
// Don't create the system's /data/dalvik-cache/... because it needs special permissions.
*dalvik_cache_exists = ((mkdir(dalvik_cache_root.c_str(), 0700) == 0 || errno == EEXIST) &&
(mkdir(dalvik_cache->c_str(), 0700) == 0 || errno == EEXIST));
}
}
std::string GetDalvikCacheOrDie(const char* subdir, const bool create_if_absent) {
CHECK(subdir != nullptr);
const char* android_data = GetAndroidData();
const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data));
const std::string dalvik_cache = dalvik_cache_root + subdir;
if (create_if_absent && !OS::DirectoryExists(dalvik_cache.c_str())) {
// Don't create the system's /data/dalvik-cache/... because it needs special permissions.
if (strcmp(android_data, "/data") != 0) {
int result = mkdir(dalvik_cache_root.c_str(), 0700);
if (result != 0 && errno != EEXIST) {
PLOG(FATAL) << "Failed to create dalvik-cache directory " << dalvik_cache_root;
return "";
}
result = mkdir(dalvik_cache.c_str(), 0700);
if (result != 0) {
PLOG(FATAL) << "Failed to create dalvik-cache directory " << dalvik_cache;
return "";
}
} else {
LOG(FATAL) << "Failed to find dalvik-cache directory " << dalvik_cache;
return "";
}
}
return dalvik_cache;
}
bool GetDalvikCacheFilename(const char* location, const char* cache_location,
std::string* filename, std::string* error_msg) {
if (location[0] != '/') {
*error_msg = StringPrintf("Expected path in location to be absolute: %s", location);
return false;
}
std::string cache_file(&location[1]); // skip leading slash
if (!EndsWith(location, ".dex") && !EndsWith(location, ".art") && !EndsWith(location, ".oat")) {
cache_file += "/";
cache_file += DexFile::kClassesDex;
}
std::replace(cache_file.begin(), cache_file.end(), '/', '@');
*filename = StringPrintf("%s/%s", cache_location, cache_file.c_str());
return true;
}
std::string GetDalvikCacheFilenameOrDie(const char* location, const char* cache_location) {
std::string ret;
std::string error_msg;
if (!GetDalvikCacheFilename(location, cache_location, &ret, &error_msg)) {
LOG(FATAL) << error_msg;
}
return ret;
}
static void InsertIsaDirectory(const InstructionSet isa, std::string* filename) {
// in = /foo/bar/baz
// out = /foo/bar/<isa>/baz
size_t pos = filename->rfind('/');
CHECK_NE(pos, std::string::npos) << *filename << " " << isa;
filename->insert(pos, "/", 1);
filename->insert(pos + 1, GetInstructionSetString(isa));
}
std::string GetSystemImageFilename(const char* location, const InstructionSet isa) {
// location = /system/framework/boot.art
// filename = /system/framework/<isa>/boot.art
std::string filename(location);
InsertIsaDirectory(isa, &filename);
return filename;
}
std::string DexFilenameToOdexFilename(const std::string& location, const InstructionSet isa) {
// location = /foo/bar/baz.jar
// odex_location = /foo/bar/<isa>/baz.odex
CHECK_GE(location.size(), 4U) << location; // must be at least .123
std::string odex_location(location);
InsertIsaDirectory(isa, &odex_location);
size_t dot_index = odex_location.size() - 3 - 1; // 3=dex or zip or apk
CHECK_EQ('.', odex_location[dot_index]) << location;
odex_location.resize(dot_index + 1);
CHECK_EQ('.', odex_location[odex_location.size()-1]) << location << " " << odex_location;
odex_location += "odex";
return odex_location;
}
bool IsZipMagic(uint32_t magic) {
return (('P' == ((magic >> 0) & 0xff)) &&
('K' == ((magic >> 8) & 0xff)));
}
bool IsDexMagic(uint32_t magic) {
return DexFile::IsMagicValid(reinterpret_cast<const uint8_t*>(&magic));
}
bool IsOatMagic(uint32_t magic) {
return (memcmp(reinterpret_cast<const uint8_t*>(magic),
OatHeader::kOatMagic,
sizeof(OatHeader::kOatMagic)) == 0);
}
bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg) {
const std::string command_line(Join(arg_vector, ' '));
CHECK_GE(arg_vector.size(), 1U) << command_line;
// Convert the args to char pointers.
const char* program = arg_vector[0].c_str();
std::vector<char*> args;
for (size_t i = 0; i < arg_vector.size(); ++i) {
const std::string& arg = arg_vector[i];
char* arg_str = const_cast<char*>(arg.c_str());
CHECK(arg_str != nullptr) << i;
args.push_back(arg_str);
}
args.push_back(NULL);
// fork and exec
pid_t pid = fork();
if (pid == 0) {
// no allocation allowed between fork and exec
// change process groups, so we don't get reaped by ProcessManager
setpgid(0, 0);
execv(program, &args[0]);
PLOG(ERROR) << "Failed to execv(" << command_line << ")";
exit(1);
} else {
if (pid == -1) {
*error_msg = StringPrintf("Failed to execv(%s) because fork failed: %s",
command_line.c_str(), strerror(errno));
return false;
}
// wait for subprocess to finish
int status;
pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
if (got_pid != pid) {
*error_msg = StringPrintf("Failed after fork for execv(%s) because waitpid failed: "
"wanted %d, got %d: %s",
command_line.c_str(), pid, got_pid, strerror(errno));
return false;
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
*error_msg = StringPrintf("Failed execv(%s) because non-0 exit status",
command_line.c_str());
return false;
}
}
return true;
}
void EncodeUnsignedLeb128(uint32_t data, std::vector<uint8_t>* dst) {
Leb128Encoder(dst).PushBackUnsigned(data);
}
void EncodeSignedLeb128(int32_t data, std::vector<uint8_t>* dst) {
Leb128Encoder(dst).PushBackSigned(data);
}
std::string PrettyDescriptor(Primitive::Type type) {
return PrettyDescriptor(Primitive::Descriptor(type));
}
} // namespace art