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