utils.cc revision 6e9aeb6633e42bc7d2265f73de28e521e3fc9c21
1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "utils.h" 18 19#include <pthread.h> 20#include <sys/stat.h> 21#include <sys/syscall.h> 22#include <sys/types.h> 23#include <unistd.h> 24 25#include "UniquePtr.h" 26#include "base/unix_file/fd_file.h" 27#include "dex_file-inl.h" 28#include "mirror/art_field-inl.h" 29#include "mirror/art_method-inl.h" 30#include "mirror/class-inl.h" 31#include "mirror/class_loader.h" 32#include "mirror/object-inl.h" 33#include "mirror/object_array-inl.h" 34#include "mirror/string.h" 35#include "object_utils.h" 36#include "os.h" 37#include "utf-inl.h" 38 39#if !defined(HAVE_POSIX_CLOCKS) 40#include <sys/time.h> 41#endif 42 43#if defined(HAVE_PRCTL) 44#include <sys/prctl.h> 45#endif 46 47#if defined(__APPLE__) 48#include "AvailabilityMacros.h" // For MAC_OS_X_VERSION_MAX_ALLOWED 49#include <sys/syscall.h> 50#endif 51 52#include <backtrace/Backtrace.h> // For DumpNativeStack. 53 54#if defined(__linux__) 55#include <linux/unistd.h> 56#endif 57 58namespace art { 59 60pid_t GetTid() { 61#if defined(__APPLE__) 62 uint64_t owner; 63 CHECK_PTHREAD_CALL(pthread_threadid_np, (NULL, &owner), __FUNCTION__); // Requires Mac OS 10.6 64 return owner; 65#else 66 // Neither bionic nor glibc exposes gettid(2). 67 return syscall(__NR_gettid); 68#endif 69} 70 71std::string GetThreadName(pid_t tid) { 72 std::string result; 73 if (ReadFileToString(StringPrintf("/proc/self/task/%d/comm", tid), &result)) { 74 result.resize(result.size() - 1); // Lose the trailing '\n'. 75 } else { 76 result = "<unknown>"; 77 } 78 return result; 79} 80 81void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size) { 82#if defined(__APPLE__) 83 *stack_size = pthread_get_stacksize_np(thread); 84 void* stack_addr = pthread_get_stackaddr_np(thread); 85 86 // Check whether stack_addr is the base or end of the stack. 87 // (On Mac OS 10.7, it's the end.) 88 int stack_variable; 89 if (stack_addr > &stack_variable) { 90 *stack_base = reinterpret_cast<byte*>(stack_addr) - *stack_size; 91 } else { 92 *stack_base = stack_addr; 93 } 94#else 95 pthread_attr_t attributes; 96 CHECK_PTHREAD_CALL(pthread_getattr_np, (thread, &attributes), __FUNCTION__); 97 CHECK_PTHREAD_CALL(pthread_attr_getstack, (&attributes, stack_base, stack_size), __FUNCTION__); 98 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attributes), __FUNCTION__); 99#endif 100} 101 102bool ReadFileToString(const std::string& file_name, std::string* result) { 103 UniquePtr<File> file(new File); 104 if (!file->Open(file_name, O_RDONLY)) { 105 return false; 106 } 107 108 std::vector<char> buf(8 * KB); 109 while (true) { 110 int64_t n = TEMP_FAILURE_RETRY(read(file->Fd(), &buf[0], buf.size())); 111 if (n == -1) { 112 return false; 113 } 114 if (n == 0) { 115 return true; 116 } 117 result->append(&buf[0], n); 118 } 119} 120 121std::string GetIsoDate() { 122 time_t now = time(NULL); 123 tm tmbuf; 124 tm* ptm = localtime_r(&now, &tmbuf); 125 return StringPrintf("%04d-%02d-%02d %02d:%02d:%02d", 126 ptm->tm_year + 1900, ptm->tm_mon+1, ptm->tm_mday, 127 ptm->tm_hour, ptm->tm_min, ptm->tm_sec); 128} 129 130uint64_t MilliTime() { 131#if defined(HAVE_POSIX_CLOCKS) 132 timespec now; 133 clock_gettime(CLOCK_MONOTONIC, &now); 134 return static_cast<uint64_t>(now.tv_sec) * 1000LL + now.tv_nsec / 1000000LL; 135#else 136 timeval now; 137 gettimeofday(&now, NULL); 138 return static_cast<uint64_t>(now.tv_sec) * 1000LL + now.tv_usec / 1000LL; 139#endif 140} 141 142uint64_t MicroTime() { 143#if defined(HAVE_POSIX_CLOCKS) 144 timespec now; 145 clock_gettime(CLOCK_MONOTONIC, &now); 146 return static_cast<uint64_t>(now.tv_sec) * 1000000LL + now.tv_nsec / 1000LL; 147#else 148 timeval now; 149 gettimeofday(&now, NULL); 150 return static_cast<uint64_t>(now.tv_sec) * 1000000LL + now.tv_usec; 151#endif 152} 153 154uint64_t NanoTime() { 155#if defined(HAVE_POSIX_CLOCKS) 156 timespec now; 157 clock_gettime(CLOCK_MONOTONIC, &now); 158 return static_cast<uint64_t>(now.tv_sec) * 1000000000LL + now.tv_nsec; 159#else 160 timeval now; 161 gettimeofday(&now, NULL); 162 return static_cast<uint64_t>(now.tv_sec) * 1000000000LL + now.tv_usec * 1000LL; 163#endif 164} 165 166uint64_t ThreadCpuNanoTime() { 167#if defined(HAVE_POSIX_CLOCKS) 168 timespec now; 169 clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now); 170 return static_cast<uint64_t>(now.tv_sec) * 1000000000LL + now.tv_nsec; 171#else 172 UNIMPLEMENTED(WARNING); 173 return -1; 174#endif 175} 176 177void NanoSleep(uint64_t ns) { 178 timespec tm; 179 tm.tv_sec = 0; 180 tm.tv_nsec = ns; 181 nanosleep(&tm, NULL); 182} 183 184void InitTimeSpec(bool absolute, int clock, int64_t ms, int32_t ns, timespec* ts) { 185 int64_t endSec; 186 187 if (absolute) { 188#if !defined(__APPLE__) 189 clock_gettime(clock, ts); 190#else 191 UNUSED(clock); 192 timeval tv; 193 gettimeofday(&tv, NULL); 194 ts->tv_sec = tv.tv_sec; 195 ts->tv_nsec = tv.tv_usec * 1000; 196#endif 197 } else { 198 ts->tv_sec = 0; 199 ts->tv_nsec = 0; 200 } 201 endSec = ts->tv_sec + ms / 1000; 202 if (UNLIKELY(endSec >= 0x7fffffff)) { 203 std::ostringstream ss; 204 LOG(INFO) << "Note: end time exceeds epoch: " << ss.str(); 205 endSec = 0x7ffffffe; 206 } 207 ts->tv_sec = endSec; 208 ts->tv_nsec = (ts->tv_nsec + (ms % 1000) * 1000000) + ns; 209 210 // Catch rollover. 211 if (ts->tv_nsec >= 1000000000L) { 212 ts->tv_sec++; 213 ts->tv_nsec -= 1000000000L; 214 } 215} 216 217std::string PrettyDescriptor(const mirror::String* java_descriptor) { 218 if (java_descriptor == NULL) { 219 return "null"; 220 } 221 return PrettyDescriptor(java_descriptor->ToModifiedUtf8()); 222} 223 224std::string PrettyDescriptor(const mirror::Class* klass) { 225 if (klass == NULL) { 226 return "null"; 227 } 228 return PrettyDescriptor(ClassHelper(klass).GetDescriptor()); 229} 230 231std::string PrettyDescriptor(const std::string& descriptor) { 232 // Count the number of '['s to get the dimensionality. 233 const char* c = descriptor.c_str(); 234 size_t dim = 0; 235 while (*c == '[') { 236 dim++; 237 c++; 238 } 239 240 // Reference or primitive? 241 if (*c == 'L') { 242 // "[[La/b/C;" -> "a.b.C[][]". 243 c++; // Skip the 'L'. 244 } else { 245 // "[[B" -> "byte[][]". 246 // To make life easier, we make primitives look like unqualified 247 // reference types. 248 switch (*c) { 249 case 'B': c = "byte;"; break; 250 case 'C': c = "char;"; break; 251 case 'D': c = "double;"; break; 252 case 'F': c = "float;"; break; 253 case 'I': c = "int;"; break; 254 case 'J': c = "long;"; break; 255 case 'S': c = "short;"; break; 256 case 'Z': c = "boolean;"; break; 257 case 'V': c = "void;"; break; // Used when decoding return types. 258 default: return descriptor; 259 } 260 } 261 262 // At this point, 'c' is a string of the form "fully/qualified/Type;" 263 // or "primitive;". Rewrite the type with '.' instead of '/': 264 std::string result; 265 const char* p = c; 266 while (*p != ';') { 267 char ch = *p++; 268 if (ch == '/') { 269 ch = '.'; 270 } 271 result.push_back(ch); 272 } 273 // ...and replace the semicolon with 'dim' "[]" pairs: 274 while (dim--) { 275 result += "[]"; 276 } 277 return result; 278} 279 280std::string PrettyDescriptor(Primitive::Type type) { 281 std::string descriptor_string(Primitive::Descriptor(type)); 282 return PrettyDescriptor(descriptor_string); 283} 284 285std::string PrettyField(const mirror::ArtField* f, bool with_type) { 286 if (f == NULL) { 287 return "null"; 288 } 289 FieldHelper fh(f); 290 std::string result; 291 if (with_type) { 292 result += PrettyDescriptor(fh.GetTypeDescriptor()); 293 result += ' '; 294 } 295 result += PrettyDescriptor(fh.GetDeclaringClassDescriptor()); 296 result += '.'; 297 result += fh.GetName(); 298 return result; 299} 300 301std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type) { 302 if (field_idx >= dex_file.NumFieldIds()) { 303 return StringPrintf("<<invalid-field-idx-%d>>", field_idx); 304 } 305 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx); 306 std::string result; 307 if (with_type) { 308 result += dex_file.GetFieldTypeDescriptor(field_id); 309 result += ' '; 310 } 311 result += PrettyDescriptor(dex_file.GetFieldDeclaringClassDescriptor(field_id)); 312 result += '.'; 313 result += dex_file.GetFieldName(field_id); 314 return result; 315} 316 317std::string PrettyType(uint32_t type_idx, const DexFile& dex_file) { 318 if (type_idx >= dex_file.NumTypeIds()) { 319 return StringPrintf("<<invalid-type-idx-%d>>", type_idx); 320 } 321 const DexFile::TypeId& type_id = dex_file.GetTypeId(type_idx); 322 return PrettyDescriptor(dex_file.GetTypeDescriptor(type_id)); 323} 324 325std::string PrettyArguments(const char* signature) { 326 std::string result; 327 result += '('; 328 CHECK_EQ(*signature, '('); 329 ++signature; // Skip the '('. 330 while (*signature != ')') { 331 size_t argument_length = 0; 332 while (signature[argument_length] == '[') { 333 ++argument_length; 334 } 335 if (signature[argument_length] == 'L') { 336 argument_length = (strchr(signature, ';') - signature + 1); 337 } else { 338 ++argument_length; 339 } 340 std::string argument_descriptor(signature, argument_length); 341 result += PrettyDescriptor(argument_descriptor); 342 if (signature[argument_length] != ')') { 343 result += ", "; 344 } 345 signature += argument_length; 346 } 347 CHECK_EQ(*signature, ')'); 348 ++signature; // Skip the ')'. 349 result += ')'; 350 return result; 351} 352 353std::string PrettyReturnType(const char* signature) { 354 const char* return_type = strchr(signature, ')'); 355 CHECK(return_type != NULL); 356 ++return_type; // Skip ')'. 357 return PrettyDescriptor(return_type); 358} 359 360std::string PrettyMethod(const mirror::ArtMethod* m, bool with_signature) { 361 if (m == NULL) { 362 return "null"; 363 } 364 MethodHelper mh(m); 365 std::string result(PrettyDescriptor(mh.GetDeclaringClassDescriptor())); 366 result += '.'; 367 result += mh.GetName(); 368 if (with_signature) { 369 const Signature signature = mh.GetSignature(); 370 std::string sig_as_string(signature.ToString()); 371 if (signature == Signature::NoSignature()) { 372 return result + sig_as_string; 373 } 374 result = PrettyReturnType(sig_as_string.c_str()) + " " + result + 375 PrettyArguments(sig_as_string.c_str()); 376 } 377 return result; 378} 379 380std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature) { 381 if (method_idx >= dex_file.NumMethodIds()) { 382 return StringPrintf("<<invalid-method-idx-%d>>", method_idx); 383 } 384 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx); 385 std::string result(PrettyDescriptor(dex_file.GetMethodDeclaringClassDescriptor(method_id))); 386 result += '.'; 387 result += dex_file.GetMethodName(method_id); 388 if (with_signature) { 389 const Signature signature = dex_file.GetMethodSignature(method_id); 390 std::string sig_as_string(signature.ToString()); 391 if (signature == Signature::NoSignature()) { 392 return result + sig_as_string; 393 } 394 result = PrettyReturnType(sig_as_string.c_str()) + " " + result + 395 PrettyArguments(sig_as_string.c_str()); 396 } 397 return result; 398} 399 400std::string PrettyTypeOf(const mirror::Object* obj) { 401 if (obj == NULL) { 402 return "null"; 403 } 404 if (obj->GetClass() == NULL) { 405 return "(raw)"; 406 } 407 ClassHelper kh(obj->GetClass()); 408 std::string result(PrettyDescriptor(kh.GetDescriptor())); 409 if (obj->IsClass()) { 410 kh.ChangeClass(obj->AsClass()); 411 result += "<" + PrettyDescriptor(kh.GetDescriptor()) + ">"; 412 } 413 return result; 414} 415 416std::string PrettyClass(const mirror::Class* c) { 417 if (c == NULL) { 418 return "null"; 419 } 420 std::string result; 421 result += "java.lang.Class<"; 422 result += PrettyDescriptor(c); 423 result += ">"; 424 return result; 425} 426 427std::string PrettyClassAndClassLoader(const mirror::Class* c) { 428 if (c == NULL) { 429 return "null"; 430 } 431 std::string result; 432 result += "java.lang.Class<"; 433 result += PrettyDescriptor(c); 434 result += ","; 435 result += PrettyTypeOf(c->GetClassLoader()); 436 // TODO: add an identifying hash value for the loader 437 result += ">"; 438 return result; 439} 440 441std::string PrettySize(size_t byte_count) { 442 // The byte thresholds at which we display amounts. A byte count is displayed 443 // in unit U when kUnitThresholds[U] <= bytes < kUnitThresholds[U+1]. 444 static const size_t kUnitThresholds[] = { 445 0, // B up to... 446 3*1024, // KB up to... 447 2*1024*1024, // MB up to... 448 1024*1024*1024 // GB from here. 449 }; 450 static const size_t kBytesPerUnit[] = { 1, KB, MB, GB }; 451 static const char* const kUnitStrings[] = { "B", "KB", "MB", "GB" }; 452 453 int i = arraysize(kUnitThresholds); 454 while (--i > 0) { 455 if (byte_count >= kUnitThresholds[i]) { 456 break; 457 } 458 } 459 460 return StringPrintf("%zd%s", byte_count / kBytesPerUnit[i], kUnitStrings[i]); 461} 462 463std::string PrettyDuration(uint64_t nano_duration) { 464 if (nano_duration == 0) { 465 return "0"; 466 } else { 467 return FormatDuration(nano_duration, GetAppropriateTimeUnit(nano_duration)); 468 } 469} 470 471TimeUnit GetAppropriateTimeUnit(uint64_t nano_duration) { 472 const uint64_t one_sec = 1000 * 1000 * 1000; 473 const uint64_t one_ms = 1000 * 1000; 474 const uint64_t one_us = 1000; 475 if (nano_duration >= one_sec) { 476 return kTimeUnitSecond; 477 } else if (nano_duration >= one_ms) { 478 return kTimeUnitMillisecond; 479 } else if (nano_duration >= one_us) { 480 return kTimeUnitMicrosecond; 481 } else { 482 return kTimeUnitNanosecond; 483 } 484} 485 486uint64_t GetNsToTimeUnitDivisor(TimeUnit time_unit) { 487 const uint64_t one_sec = 1000 * 1000 * 1000; 488 const uint64_t one_ms = 1000 * 1000; 489 const uint64_t one_us = 1000; 490 491 switch (time_unit) { 492 case kTimeUnitSecond: 493 return one_sec; 494 case kTimeUnitMillisecond: 495 return one_ms; 496 case kTimeUnitMicrosecond: 497 return one_us; 498 case kTimeUnitNanosecond: 499 return 1; 500 } 501 return 0; 502} 503 504std::string FormatDuration(uint64_t nano_duration, TimeUnit time_unit) { 505 const char* unit = NULL; 506 uint64_t divisor = GetNsToTimeUnitDivisor(time_unit); 507 uint32_t zero_fill = 1; 508 switch (time_unit) { 509 case kTimeUnitSecond: 510 unit = "s"; 511 zero_fill = 9; 512 break; 513 case kTimeUnitMillisecond: 514 unit = "ms"; 515 zero_fill = 6; 516 break; 517 case kTimeUnitMicrosecond: 518 unit = "us"; 519 zero_fill = 3; 520 break; 521 case kTimeUnitNanosecond: 522 unit = "ns"; 523 zero_fill = 0; 524 break; 525 } 526 527 uint64_t whole_part = nano_duration / divisor; 528 uint64_t fractional_part = nano_duration % divisor; 529 if (fractional_part == 0) { 530 return StringPrintf("%llu%s", whole_part, unit); 531 } else { 532 while ((fractional_part % 1000) == 0) { 533 zero_fill -= 3; 534 fractional_part /= 1000; 535 } 536 if (zero_fill == 3) { 537 return StringPrintf("%llu.%03llu%s", whole_part, fractional_part, unit); 538 } else if (zero_fill == 6) { 539 return StringPrintf("%llu.%06llu%s", whole_part, fractional_part, unit); 540 } else { 541 return StringPrintf("%llu.%09llu%s", whole_part, fractional_part, unit); 542 } 543 } 544} 545 546std::string PrintableString(const std::string& utf) { 547 std::string result; 548 result += '"'; 549 const char* p = utf.c_str(); 550 size_t char_count = CountModifiedUtf8Chars(p); 551 for (size_t i = 0; i < char_count; ++i) { 552 uint16_t ch = GetUtf16FromUtf8(&p); 553 if (ch == '\\') { 554 result += "\\\\"; 555 } else if (ch == '\n') { 556 result += "\\n"; 557 } else if (ch == '\r') { 558 result += "\\r"; 559 } else if (ch == '\t') { 560 result += "\\t"; 561 } else if (NeedsEscaping(ch)) { 562 StringAppendF(&result, "\\u%04x", ch); 563 } else { 564 result += ch; 565 } 566 } 567 result += '"'; 568 return result; 569} 570 571// See http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/design.html#wp615 for the full rules. 572std::string MangleForJni(const std::string& s) { 573 std::string result; 574 size_t char_count = CountModifiedUtf8Chars(s.c_str()); 575 const char* cp = &s[0]; 576 for (size_t i = 0; i < char_count; ++i) { 577 uint16_t ch = GetUtf16FromUtf8(&cp); 578 if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) { 579 result.push_back(ch); 580 } else if (ch == '.' || ch == '/') { 581 result += "_"; 582 } else if (ch == '_') { 583 result += "_1"; 584 } else if (ch == ';') { 585 result += "_2"; 586 } else if (ch == '[') { 587 result += "_3"; 588 } else { 589 StringAppendF(&result, "_0%04x", ch); 590 } 591 } 592 return result; 593} 594 595std::string DotToDescriptor(const char* class_name) { 596 std::string descriptor(class_name); 597 std::replace(descriptor.begin(), descriptor.end(), '.', '/'); 598 if (descriptor.length() > 0 && descriptor[0] != '[') { 599 descriptor = "L" + descriptor + ";"; 600 } 601 return descriptor; 602} 603 604std::string DescriptorToDot(const char* descriptor) { 605 size_t length = strlen(descriptor); 606 if (descriptor[0] == 'L' && descriptor[length - 1] == ';') { 607 std::string result(descriptor + 1, length - 2); 608 std::replace(result.begin(), result.end(), '/', '.'); 609 return result; 610 } 611 return descriptor; 612} 613 614std::string DescriptorToName(const char* descriptor) { 615 size_t length = strlen(descriptor); 616 if (descriptor[0] == 'L' && descriptor[length - 1] == ';') { 617 std::string result(descriptor + 1, length - 2); 618 return result; 619 } 620 return descriptor; 621} 622 623std::string JniShortName(const mirror::ArtMethod* m) { 624 MethodHelper mh(m); 625 std::string class_name(mh.GetDeclaringClassDescriptor()); 626 // Remove the leading 'L' and trailing ';'... 627 CHECK_EQ(class_name[0], 'L') << class_name; 628 CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name; 629 class_name.erase(0, 1); 630 class_name.erase(class_name.size() - 1, 1); 631 632 std::string method_name(mh.GetName()); 633 634 std::string short_name; 635 short_name += "Java_"; 636 short_name += MangleForJni(class_name); 637 short_name += "_"; 638 short_name += MangleForJni(method_name); 639 return short_name; 640} 641 642std::string JniLongName(const mirror::ArtMethod* m) { 643 std::string long_name; 644 long_name += JniShortName(m); 645 long_name += "__"; 646 647 std::string signature(MethodHelper(m).GetSignature().ToString()); 648 signature.erase(0, 1); 649 signature.erase(signature.begin() + signature.find(')'), signature.end()); 650 651 long_name += MangleForJni(signature); 652 653 return long_name; 654} 655 656// Helper for IsValidPartOfMemberNameUtf8(), a bit vector indicating valid low ascii. 657uint32_t DEX_MEMBER_VALID_LOW_ASCII[4] = { 658 0x00000000, // 00..1f low control characters; nothing valid 659 0x03ff2010, // 20..3f digits and symbols; valid: '0'..'9', '$', '-' 660 0x87fffffe, // 40..5f uppercase etc.; valid: 'A'..'Z', '_' 661 0x07fffffe // 60..7f lowercase etc.; valid: 'a'..'z' 662}; 663 664// Helper for IsValidPartOfMemberNameUtf8(); do not call directly. 665bool IsValidPartOfMemberNameUtf8Slow(const char** pUtf8Ptr) { 666 /* 667 * It's a multibyte encoded character. Decode it and analyze. We 668 * accept anything that isn't (a) an improperly encoded low value, 669 * (b) an improper surrogate pair, (c) an encoded '\0', (d) a high 670 * control character, or (e) a high space, layout, or special 671 * character (U+00a0, U+2000..U+200f, U+2028..U+202f, 672 * U+fff0..U+ffff). This is all specified in the dex format 673 * document. 674 */ 675 676 uint16_t utf16 = GetUtf16FromUtf8(pUtf8Ptr); 677 678 // Perform follow-up tests based on the high 8 bits. 679 switch (utf16 >> 8) { 680 case 0x00: 681 // It's only valid if it's above the ISO-8859-1 high space (0xa0). 682 return (utf16 > 0x00a0); 683 case 0xd8: 684 case 0xd9: 685 case 0xda: 686 case 0xdb: 687 // It's a leading surrogate. Check to see that a trailing 688 // surrogate follows. 689 utf16 = GetUtf16FromUtf8(pUtf8Ptr); 690 return (utf16 >= 0xdc00) && (utf16 <= 0xdfff); 691 case 0xdc: 692 case 0xdd: 693 case 0xde: 694 case 0xdf: 695 // It's a trailing surrogate, which is not valid at this point. 696 return false; 697 case 0x20: 698 case 0xff: 699 // It's in the range that has spaces, controls, and specials. 700 switch (utf16 & 0xfff8) { 701 case 0x2000: 702 case 0x2008: 703 case 0x2028: 704 case 0xfff0: 705 case 0xfff8: 706 return false; 707 } 708 break; 709 } 710 return true; 711} 712 713/* Return whether the pointed-at modified-UTF-8 encoded character is 714 * valid as part of a member name, updating the pointer to point past 715 * the consumed character. This will consume two encoded UTF-16 code 716 * points if the character is encoded as a surrogate pair. Also, if 717 * this function returns false, then the given pointer may only have 718 * been partially advanced. 719 */ 720static bool IsValidPartOfMemberNameUtf8(const char** pUtf8Ptr) { 721 uint8_t c = (uint8_t) **pUtf8Ptr; 722 if (LIKELY(c <= 0x7f)) { 723 // It's low-ascii, so check the table. 724 uint32_t wordIdx = c >> 5; 725 uint32_t bitIdx = c & 0x1f; 726 (*pUtf8Ptr)++; 727 return (DEX_MEMBER_VALID_LOW_ASCII[wordIdx] & (1 << bitIdx)) != 0; 728 } 729 730 // It's a multibyte encoded character. Call a non-inline function 731 // for the heavy lifting. 732 return IsValidPartOfMemberNameUtf8Slow(pUtf8Ptr); 733} 734 735bool IsValidMemberName(const char* s) { 736 bool angle_name = false; 737 738 switch (*s) { 739 case '\0': 740 // The empty string is not a valid name. 741 return false; 742 case '<': 743 angle_name = true; 744 s++; 745 break; 746 } 747 748 while (true) { 749 switch (*s) { 750 case '\0': 751 return !angle_name; 752 case '>': 753 return angle_name && s[1] == '\0'; 754 } 755 756 if (!IsValidPartOfMemberNameUtf8(&s)) { 757 return false; 758 } 759 } 760} 761 762enum ClassNameType { kName, kDescriptor }; 763static bool IsValidClassName(const char* s, ClassNameType type, char separator) { 764 int arrayCount = 0; 765 while (*s == '[') { 766 arrayCount++; 767 s++; 768 } 769 770 if (arrayCount > 255) { 771 // Arrays may have no more than 255 dimensions. 772 return false; 773 } 774 775 if (arrayCount != 0) { 776 /* 777 * If we're looking at an array of some sort, then it doesn't 778 * matter if what is being asked for is a class name; the 779 * format looks the same as a type descriptor in that case, so 780 * treat it as such. 781 */ 782 type = kDescriptor; 783 } 784 785 if (type == kDescriptor) { 786 /* 787 * We are looking for a descriptor. Either validate it as a 788 * single-character primitive type, or continue on to check the 789 * embedded class name (bracketed by "L" and ";"). 790 */ 791 switch (*(s++)) { 792 case 'B': 793 case 'C': 794 case 'D': 795 case 'F': 796 case 'I': 797 case 'J': 798 case 'S': 799 case 'Z': 800 // These are all single-character descriptors for primitive types. 801 return (*s == '\0'); 802 case 'V': 803 // Non-array void is valid, but you can't have an array of void. 804 return (arrayCount == 0) && (*s == '\0'); 805 case 'L': 806 // Class name: Break out and continue below. 807 break; 808 default: 809 // Oddball descriptor character. 810 return false; 811 } 812 } 813 814 /* 815 * We just consumed the 'L' that introduces a class name as part 816 * of a type descriptor, or we are looking for an unadorned class 817 * name. 818 */ 819 820 bool sepOrFirst = true; // first character or just encountered a separator. 821 for (;;) { 822 uint8_t c = (uint8_t) *s; 823 switch (c) { 824 case '\0': 825 /* 826 * Premature end for a type descriptor, but valid for 827 * a class name as long as we haven't encountered an 828 * empty component (including the degenerate case of 829 * the empty string ""). 830 */ 831 return (type == kName) && !sepOrFirst; 832 case ';': 833 /* 834 * Invalid character for a class name, but the 835 * legitimate end of a type descriptor. In the latter 836 * case, make sure that this is the end of the string 837 * and that it doesn't end with an empty component 838 * (including the degenerate case of "L;"). 839 */ 840 return (type == kDescriptor) && !sepOrFirst && (s[1] == '\0'); 841 case '/': 842 case '.': 843 if (c != separator) { 844 // The wrong separator character. 845 return false; 846 } 847 if (sepOrFirst) { 848 // Separator at start or two separators in a row. 849 return false; 850 } 851 sepOrFirst = true; 852 s++; 853 break; 854 default: 855 if (!IsValidPartOfMemberNameUtf8(&s)) { 856 return false; 857 } 858 sepOrFirst = false; 859 break; 860 } 861 } 862} 863 864bool IsValidBinaryClassName(const char* s) { 865 return IsValidClassName(s, kName, '.'); 866} 867 868bool IsValidJniClassName(const char* s) { 869 return IsValidClassName(s, kName, '/'); 870} 871 872bool IsValidDescriptor(const char* s) { 873 return IsValidClassName(s, kDescriptor, '/'); 874} 875 876void Split(const std::string& s, char separator, std::vector<std::string>& result) { 877 const char* p = s.data(); 878 const char* end = p + s.size(); 879 while (p != end) { 880 if (*p == separator) { 881 ++p; 882 } else { 883 const char* start = p; 884 while (++p != end && *p != separator) { 885 // Skip to the next occurrence of the separator. 886 } 887 result.push_back(std::string(start, p - start)); 888 } 889 } 890} 891 892std::string Trim(std::string s) { 893 std::string result; 894 unsigned int start_index = 0; 895 unsigned int end_index = s.size() - 1; 896 897 // Skip initial whitespace. 898 while (start_index < s.size()) { 899 if (!isspace(s[start_index])) { 900 break; 901 } 902 start_index++; 903 } 904 905 // Skip terminating whitespace. 906 while (end_index >= start_index) { 907 if (!isspace(s[end_index])) { 908 break; 909 } 910 end_index--; 911 } 912 913 // All spaces, no beef. 914 if (end_index < start_index) { 915 return ""; 916 } 917 // Start_index is the first non-space, end_index is the last one. 918 return s.substr(start_index, end_index - start_index + 1); 919} 920 921template <typename StringT> 922std::string Join(std::vector<StringT>& strings, char separator) { 923 if (strings.empty()) { 924 return ""; 925 } 926 927 std::string result(strings[0]); 928 for (size_t i = 1; i < strings.size(); ++i) { 929 result += separator; 930 result += strings[i]; 931 } 932 return result; 933} 934 935// Explicit instantiations. 936template std::string Join<std::string>(std::vector<std::string>& strings, char separator); 937template std::string Join<const char*>(std::vector<const char*>& strings, char separator); 938template std::string Join<char*>(std::vector<char*>& strings, char separator); 939 940bool StartsWith(const std::string& s, const char* prefix) { 941 return s.compare(0, strlen(prefix), prefix) == 0; 942} 943 944bool EndsWith(const std::string& s, const char* suffix) { 945 size_t suffix_length = strlen(suffix); 946 size_t string_length = s.size(); 947 if (suffix_length > string_length) { 948 return false; 949 } 950 size_t offset = string_length - suffix_length; 951 return s.compare(offset, suffix_length, suffix) == 0; 952} 953 954void SetThreadName(const char* thread_name) { 955 int hasAt = 0; 956 int hasDot = 0; 957 const char* s = thread_name; 958 while (*s) { 959 if (*s == '.') { 960 hasDot = 1; 961 } else if (*s == '@') { 962 hasAt = 1; 963 } 964 s++; 965 } 966 int len = s - thread_name; 967 if (len < 15 || hasAt || !hasDot) { 968 s = thread_name; 969 } else { 970 s = thread_name + len - 15; 971 } 972#if defined(HAVE_ANDROID_PTHREAD_SETNAME_NP) 973 // pthread_setname_np fails rather than truncating long strings. 974 char buf[16]; // MAX_TASK_COMM_LEN=16 is hard-coded into bionic 975 strncpy(buf, s, sizeof(buf)-1); 976 buf[sizeof(buf)-1] = '\0'; 977 errno = pthread_setname_np(pthread_self(), buf); 978 if (errno != 0) { 979 PLOG(WARNING) << "Unable to set the name of current thread to '" << buf << "'"; 980 } 981#elif defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 982 pthread_setname_np(thread_name); 983#elif defined(HAVE_PRCTL) 984 prctl(PR_SET_NAME, (unsigned long) s, 0, 0, 0); // NOLINT (unsigned long) 985#else 986 UNIMPLEMENTED(WARNING) << thread_name; 987#endif 988} 989 990void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu) { 991 *utime = *stime = *task_cpu = 0; 992 std::string stats; 993 if (!ReadFileToString(StringPrintf("/proc/self/task/%d/stat", tid), &stats)) { 994 return; 995 } 996 // Skip the command, which may contain spaces. 997 stats = stats.substr(stats.find(')') + 2); 998 // Extract the three fields we care about. 999 std::vector<std::string> fields; 1000 Split(stats, ' ', fields); 1001 *state = fields[0][0]; 1002 *utime = strtoull(fields[11].c_str(), NULL, 10); 1003 *stime = strtoull(fields[12].c_str(), NULL, 10); 1004 *task_cpu = strtoull(fields[36].c_str(), NULL, 10); 1005} 1006 1007std::string GetSchedulerGroupName(pid_t tid) { 1008 // /proc/<pid>/cgroup looks like this: 1009 // 2:devices:/ 1010 // 1:cpuacct,cpu:/ 1011 // We want the third field from the line whose second field contains the "cpu" token. 1012 std::string cgroup_file; 1013 if (!ReadFileToString(StringPrintf("/proc/self/task/%d/cgroup", tid), &cgroup_file)) { 1014 return ""; 1015 } 1016 std::vector<std::string> cgroup_lines; 1017 Split(cgroup_file, '\n', cgroup_lines); 1018 for (size_t i = 0; i < cgroup_lines.size(); ++i) { 1019 std::vector<std::string> cgroup_fields; 1020 Split(cgroup_lines[i], ':', cgroup_fields); 1021 std::vector<std::string> cgroups; 1022 Split(cgroup_fields[1], ',', cgroups); 1023 for (size_t i = 0; i < cgroups.size(); ++i) { 1024 if (cgroups[i] == "cpu") { 1025 return cgroup_fields[2].substr(1); // Skip the leading slash. 1026 } 1027 } 1028 } 1029 return ""; 1030} 1031 1032static const char* CleanMapName(const char* map_name) { 1033 if (map_name == NULL) { 1034 return "???"; 1035 } 1036 // Turn "/usr/local/google/home/enh/clean-dalvik-dev/out/host/linux-x86/lib/libartd.so" 1037 // into "libartd.so". 1038 const char* last_slash = strrchr(map_name, '/'); 1039 if (last_slash != NULL) { 1040 map_name = last_slash + 1; 1041 } 1042 return map_name; 1043} 1044 1045void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix, bool include_count) { 1046 UniquePtr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, tid)); 1047 if (!backtrace->Unwind(0)) { 1048 os << prefix << "(backtrace::Unwind failed for thread " << tid << ")\n"; 1049 return; 1050 } else if (backtrace->NumFrames() == 0) { 1051 os << prefix << "(no native stack frames for thread " << tid << ")\n"; 1052 return; 1053 } 1054 1055 for (size_t i = 0; i < backtrace->NumFrames(); ++i) { 1056 // We produce output like this: 1057 // ] #00 unwind_backtrace_thread+536 [0x55d75bb8] (libbacktrace.so) 1058 const backtrace_frame_data_t* frame = backtrace->GetFrame(i); 1059 1060 os << prefix; 1061 if (include_count) { 1062 os << StringPrintf("#%02zu ", i); 1063 } 1064 if (frame->func_name) { 1065 os << frame->func_name; 1066 } else { 1067 os << "???"; 1068 } 1069 if (frame->func_offset != 0) { 1070 os << "+" << frame->func_offset; 1071 } 1072 os << StringPrintf(" [%p]", reinterpret_cast<void*>(frame->pc)); 1073 os << " (" << CleanMapName(frame->map_name) << ")\n"; 1074 } 1075} 1076 1077#if defined(__APPLE__) 1078 1079// TODO: is there any way to get the kernel stack on Mac OS? 1080void DumpKernelStack(std::ostream&, pid_t, const char*, bool) {} 1081 1082#else 1083 1084void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix, bool include_count) { 1085 if (tid == GetTid()) { 1086 // There's no point showing that we're reading our stack out of /proc! 1087 return; 1088 } 1089 1090 std::string kernel_stack_filename(StringPrintf("/proc/self/task/%d/stack", tid)); 1091 std::string kernel_stack; 1092 if (!ReadFileToString(kernel_stack_filename, &kernel_stack)) { 1093 os << prefix << "(couldn't read " << kernel_stack_filename << ")\n"; 1094 return; 1095 } 1096 1097 std::vector<std::string> kernel_stack_frames; 1098 Split(kernel_stack, '\n', kernel_stack_frames); 1099 // We skip the last stack frame because it's always equivalent to "[<ffffffff>] 0xffffffff", 1100 // which looking at the source appears to be the kernel's way of saying "that's all, folks!". 1101 kernel_stack_frames.pop_back(); 1102 for (size_t i = 0; i < kernel_stack_frames.size(); ++i) { 1103 // Turn "[<ffffffff8109156d>] futex_wait_queue_me+0xcd/0x110" into "futex_wait_queue_me+0xcd/0x110". 1104 const char* text = kernel_stack_frames[i].c_str(); 1105 const char* close_bracket = strchr(text, ']'); 1106 if (close_bracket != NULL) { 1107 text = close_bracket + 2; 1108 } 1109 os << prefix; 1110 if (include_count) { 1111 os << StringPrintf("#%02zd ", i); 1112 } 1113 os << text << "\n"; 1114 } 1115} 1116 1117#endif 1118 1119const char* GetAndroidRoot() { 1120 const char* android_root = getenv("ANDROID_ROOT"); 1121 if (android_root == NULL) { 1122 if (OS::DirectoryExists("/system")) { 1123 android_root = "/system"; 1124 } else { 1125 LOG(FATAL) << "ANDROID_ROOT not set and /system does not exist"; 1126 return ""; 1127 } 1128 } 1129 if (!OS::DirectoryExists(android_root)) { 1130 LOG(FATAL) << "Failed to find ANDROID_ROOT directory " << android_root; 1131 return ""; 1132 } 1133 return android_root; 1134} 1135 1136const char* GetAndroidData() { 1137 const char* android_data = getenv("ANDROID_DATA"); 1138 if (android_data == NULL) { 1139 if (OS::DirectoryExists("/data")) { 1140 android_data = "/data"; 1141 } else { 1142 LOG(FATAL) << "ANDROID_DATA not set and /data does not exist"; 1143 return ""; 1144 } 1145 } 1146 if (!OS::DirectoryExists(android_data)) { 1147 LOG(FATAL) << "Failed to find ANDROID_DATA directory " << android_data; 1148 return ""; 1149 } 1150 return android_data; 1151} 1152 1153std::string GetDalvikCacheOrDie(const char* android_data) { 1154 std::string dalvik_cache(StringPrintf("%s/dalvik-cache", android_data)); 1155 1156 if (!OS::DirectoryExists(dalvik_cache.c_str())) { 1157 if (StartsWith(dalvik_cache, "/tmp/")) { 1158 int result = mkdir(dalvik_cache.c_str(), 0700); 1159 if (result != 0) { 1160 LOG(FATAL) << "Failed to create dalvik-cache directory " << dalvik_cache; 1161 return ""; 1162 } 1163 } else { 1164 LOG(FATAL) << "Failed to find dalvik-cache directory " << dalvik_cache; 1165 return ""; 1166 } 1167 } 1168 return dalvik_cache; 1169} 1170 1171std::string GetDalvikCacheFilenameOrDie(const char* location) { 1172 std::string dalvik_cache(GetDalvikCacheOrDie(GetAndroidData())); 1173 if (location[0] != '/') { 1174 LOG(FATAL) << "Expected path in location to be absolute: "<< location; 1175 } 1176 std::string cache_file(&location[1]); // skip leading slash 1177 if (!EndsWith(location, ".dex") && !EndsWith(location, ".art")) { 1178 cache_file += "/"; 1179 cache_file += DexFile::kClassesDex; 1180 } 1181 std::replace(cache_file.begin(), cache_file.end(), '/', '@'); 1182 return dalvik_cache + "/" + cache_file; 1183} 1184 1185bool IsZipMagic(uint32_t magic) { 1186 return (('P' == ((magic >> 0) & 0xff)) && 1187 ('K' == ((magic >> 8) & 0xff))); 1188} 1189 1190bool IsDexMagic(uint32_t magic) { 1191 return DexFile::IsMagicValid(reinterpret_cast<const byte*>(&magic)); 1192} 1193 1194bool IsOatMagic(uint32_t magic) { 1195 return (memcmp(reinterpret_cast<const byte*>(magic), 1196 OatHeader::kOatMagic, 1197 sizeof(OatHeader::kOatMagic)) == 0); 1198} 1199 1200} // namespace art 1201