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#include <unistd.h> 26#include <memory> 27 28#include "art_field-inl.h" 29#include "art_method-inl.h" 30#include "base/stl_util.h" 31#include "base/unix_file/fd_file.h" 32#include "dex_file-inl.h" 33#include "mirror/class-inl.h" 34#include "mirror/class_loader.h" 35#include "mirror/object-inl.h" 36#include "mirror/object_array-inl.h" 37#include "mirror/string.h" 38#include "os.h" 39#include "scoped_thread_state_change.h" 40#include "utf-inl.h" 41 42#if defined(__APPLE__) 43#include "AvailabilityMacros.h" // For MAC_OS_X_VERSION_MAX_ALLOWED 44#include <sys/syscall.h> 45#endif 46 47#include <backtrace/Backtrace.h> // For DumpNativeStack. 48 49#if defined(__linux__) 50#include <linux/unistd.h> 51#endif 52 53namespace art { 54 55#if defined(__linux__) 56static constexpr bool kUseAddr2line = !kIsTargetBuild; 57#endif 58 59pid_t GetTid() { 60#if defined(__APPLE__) 61 uint64_t owner; 62 CHECK_PTHREAD_CALL(pthread_threadid_np, (nullptr, &owner), __FUNCTION__); // Requires Mac OS 10.6 63 return owner; 64#elif defined(__BIONIC__) 65 return gettid(); 66#else 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, size_t* guard_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<uint8_t*>(stack_addr) - *stack_size; 91 } else { 92 *stack_base = stack_addr; 93 } 94 95 // This is wrong, but there doesn't seem to be a way to get the actual value on the Mac. 96 pthread_attr_t attributes; 97 CHECK_PTHREAD_CALL(pthread_attr_init, (&attributes), __FUNCTION__); 98 CHECK_PTHREAD_CALL(pthread_attr_getguardsize, (&attributes, guard_size), __FUNCTION__); 99 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attributes), __FUNCTION__); 100#else 101 pthread_attr_t attributes; 102 CHECK_PTHREAD_CALL(pthread_getattr_np, (thread, &attributes), __FUNCTION__); 103 CHECK_PTHREAD_CALL(pthread_attr_getstack, (&attributes, stack_base, stack_size), __FUNCTION__); 104 CHECK_PTHREAD_CALL(pthread_attr_getguardsize, (&attributes, guard_size), __FUNCTION__); 105 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attributes), __FUNCTION__); 106 107#if defined(__GLIBC__) 108 // If we're the main thread, check whether we were run with an unlimited stack. In that case, 109 // glibc will have reported a 2GB stack for our 32-bit process, and our stack overflow detection 110 // will be broken because we'll die long before we get close to 2GB. 111 bool is_main_thread = (::art::GetTid() == getpid()); 112 if (is_main_thread) { 113 rlimit stack_limit; 114 if (getrlimit(RLIMIT_STACK, &stack_limit) == -1) { 115 PLOG(FATAL) << "getrlimit(RLIMIT_STACK) failed"; 116 } 117 if (stack_limit.rlim_cur == RLIM_INFINITY) { 118 size_t old_stack_size = *stack_size; 119 120 // Use the kernel default limit as our size, and adjust the base to match. 121 *stack_size = 8 * MB; 122 *stack_base = reinterpret_cast<uint8_t*>(*stack_base) + (old_stack_size - *stack_size); 123 124 VLOG(threads) << "Limiting unlimited stack (reported as " << PrettySize(old_stack_size) << ")" 125 << " to " << PrettySize(*stack_size) 126 << " with base " << *stack_base; 127 } 128 } 129#endif 130 131#endif 132} 133 134bool ReadFileToString(const std::string& file_name, std::string* result) { 135 File file; 136 if (!file.Open(file_name, O_RDONLY)) { 137 return false; 138 } 139 140 std::vector<char> buf(8 * KB); 141 while (true) { 142 int64_t n = TEMP_FAILURE_RETRY(read(file.Fd(), &buf[0], buf.size())); 143 if (n == -1) { 144 return false; 145 } 146 if (n == 0) { 147 return true; 148 } 149 result->append(&buf[0], n); 150 } 151} 152 153bool PrintFileToLog(const std::string& file_name, LogSeverity level) { 154 File file; 155 if (!file.Open(file_name, O_RDONLY)) { 156 return false; 157 } 158 159 constexpr size_t kBufSize = 256; // Small buffer. Avoid stack overflow and stack size warnings. 160 char buf[kBufSize + 1]; // +1 for terminator. 161 size_t filled_to = 0; 162 while (true) { 163 DCHECK_LT(filled_to, kBufSize); 164 int64_t n = TEMP_FAILURE_RETRY(read(file.Fd(), &buf[filled_to], kBufSize - filled_to)); 165 if (n <= 0) { 166 // Print the rest of the buffer, if it exists. 167 if (filled_to > 0) { 168 buf[filled_to] = 0; 169 LOG(level) << buf; 170 } 171 return n == 0; 172 } 173 // Scan for '\n'. 174 size_t i = filled_to; 175 bool found_newline = false; 176 for (; i < filled_to + n; ++i) { 177 if (buf[i] == '\n') { 178 // Found a line break, that's something to print now. 179 buf[i] = 0; 180 LOG(level) << buf; 181 // Copy the rest to the front. 182 if (i + 1 < filled_to + n) { 183 memmove(&buf[0], &buf[i + 1], filled_to + n - i - 1); 184 filled_to = filled_to + n - i - 1; 185 } else { 186 filled_to = 0; 187 } 188 found_newline = true; 189 break; 190 } 191 } 192 if (found_newline) { 193 continue; 194 } else { 195 filled_to += n; 196 // Check if we must flush now. 197 if (filled_to == kBufSize) { 198 buf[kBufSize] = 0; 199 LOG(level) << buf; 200 filled_to = 0; 201 } 202 } 203 } 204} 205 206std::string PrettyDescriptor(mirror::String* java_descriptor) { 207 if (java_descriptor == nullptr) { 208 return "null"; 209 } 210 return PrettyDescriptor(java_descriptor->ToModifiedUtf8().c_str()); 211} 212 213std::string PrettyDescriptor(mirror::Class* klass) { 214 if (klass == nullptr) { 215 return "null"; 216 } 217 std::string temp; 218 return PrettyDescriptor(klass->GetDescriptor(&temp)); 219} 220 221std::string PrettyDescriptor(const char* descriptor) { 222 // Count the number of '['s to get the dimensionality. 223 const char* c = descriptor; 224 size_t dim = 0; 225 while (*c == '[') { 226 dim++; 227 c++; 228 } 229 230 // Reference or primitive? 231 if (*c == 'L') { 232 // "[[La/b/C;" -> "a.b.C[][]". 233 c++; // Skip the 'L'. 234 } else { 235 // "[[B" -> "byte[][]". 236 // To make life easier, we make primitives look like unqualified 237 // reference types. 238 switch (*c) { 239 case 'B': c = "byte;"; break; 240 case 'C': c = "char;"; break; 241 case 'D': c = "double;"; break; 242 case 'F': c = "float;"; break; 243 case 'I': c = "int;"; break; 244 case 'J': c = "long;"; break; 245 case 'S': c = "short;"; break; 246 case 'Z': c = "boolean;"; break; 247 case 'V': c = "void;"; break; // Used when decoding return types. 248 default: return descriptor; 249 } 250 } 251 252 // At this point, 'c' is a string of the form "fully/qualified/Type;" 253 // or "primitive;". Rewrite the type with '.' instead of '/': 254 std::string result; 255 const char* p = c; 256 while (*p != ';') { 257 char ch = *p++; 258 if (ch == '/') { 259 ch = '.'; 260 } 261 result.push_back(ch); 262 } 263 // ...and replace the semicolon with 'dim' "[]" pairs: 264 for (size_t i = 0; i < dim; ++i) { 265 result += "[]"; 266 } 267 return result; 268} 269 270std::string PrettyField(ArtField* f, bool with_type) { 271 if (f == nullptr) { 272 return "null"; 273 } 274 std::string result; 275 if (with_type) { 276 result += PrettyDescriptor(f->GetTypeDescriptor()); 277 result += ' '; 278 } 279 std::string temp; 280 result += PrettyDescriptor(f->GetDeclaringClass()->GetDescriptor(&temp)); 281 result += '.'; 282 result += f->GetName(); 283 return result; 284} 285 286std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type) { 287 if (field_idx >= dex_file.NumFieldIds()) { 288 return StringPrintf("<<invalid-field-idx-%d>>", field_idx); 289 } 290 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx); 291 std::string result; 292 if (with_type) { 293 result += dex_file.GetFieldTypeDescriptor(field_id); 294 result += ' '; 295 } 296 result += PrettyDescriptor(dex_file.GetFieldDeclaringClassDescriptor(field_id)); 297 result += '.'; 298 result += dex_file.GetFieldName(field_id); 299 return result; 300} 301 302std::string PrettyType(uint32_t type_idx, const DexFile& dex_file) { 303 if (type_idx >= dex_file.NumTypeIds()) { 304 return StringPrintf("<<invalid-type-idx-%d>>", type_idx); 305 } 306 const DexFile::TypeId& type_id = dex_file.GetTypeId(type_idx); 307 return PrettyDescriptor(dex_file.GetTypeDescriptor(type_id)); 308} 309 310std::string PrettyArguments(const char* signature) { 311 std::string result; 312 result += '('; 313 CHECK_EQ(*signature, '('); 314 ++signature; // Skip the '('. 315 while (*signature != ')') { 316 size_t argument_length = 0; 317 while (signature[argument_length] == '[') { 318 ++argument_length; 319 } 320 if (signature[argument_length] == 'L') { 321 argument_length = (strchr(signature, ';') - signature + 1); 322 } else { 323 ++argument_length; 324 } 325 { 326 std::string argument_descriptor(signature, argument_length); 327 result += PrettyDescriptor(argument_descriptor.c_str()); 328 } 329 if (signature[argument_length] != ')') { 330 result += ", "; 331 } 332 signature += argument_length; 333 } 334 CHECK_EQ(*signature, ')'); 335 ++signature; // Skip the ')'. 336 result += ')'; 337 return result; 338} 339 340std::string PrettyReturnType(const char* signature) { 341 const char* return_type = strchr(signature, ')'); 342 CHECK(return_type != nullptr); 343 ++return_type; // Skip ')'. 344 return PrettyDescriptor(return_type); 345} 346 347std::string PrettyMethod(ArtMethod* m, bool with_signature) { 348 if (m == nullptr) { 349 return "null"; 350 } 351 if (!m->IsRuntimeMethod()) { 352 m = m->GetInterfaceMethodIfProxy(Runtime::Current()->GetClassLinker()->GetImagePointerSize()); 353 } 354 std::string result(PrettyDescriptor(m->GetDeclaringClassDescriptor())); 355 result += '.'; 356 result += m->GetName(); 357 if (UNLIKELY(m->IsFastNative())) { 358 result += "!"; 359 } 360 if (with_signature) { 361 const Signature signature = m->GetSignature(); 362 std::string sig_as_string(signature.ToString()); 363 if (signature == Signature::NoSignature()) { 364 return result + sig_as_string; 365 } 366 result = PrettyReturnType(sig_as_string.c_str()) + " " + result + 367 PrettyArguments(sig_as_string.c_str()); 368 } 369 return result; 370} 371 372std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature) { 373 if (method_idx >= dex_file.NumMethodIds()) { 374 return StringPrintf("<<invalid-method-idx-%d>>", method_idx); 375 } 376 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx); 377 std::string result(PrettyDescriptor(dex_file.GetMethodDeclaringClassDescriptor(method_id))); 378 result += '.'; 379 result += dex_file.GetMethodName(method_id); 380 if (with_signature) { 381 const Signature signature = dex_file.GetMethodSignature(method_id); 382 std::string sig_as_string(signature.ToString()); 383 if (signature == Signature::NoSignature()) { 384 return result + sig_as_string; 385 } 386 result = PrettyReturnType(sig_as_string.c_str()) + " " + result + 387 PrettyArguments(sig_as_string.c_str()); 388 } 389 return result; 390} 391 392std::string PrettyTypeOf(mirror::Object* obj) { 393 if (obj == nullptr) { 394 return "null"; 395 } 396 if (obj->GetClass() == nullptr) { 397 return "(raw)"; 398 } 399 std::string temp; 400 std::string result(PrettyDescriptor(obj->GetClass()->GetDescriptor(&temp))); 401 if (obj->IsClass()) { 402 result += "<" + PrettyDescriptor(obj->AsClass()->GetDescriptor(&temp)) + ">"; 403 } 404 return result; 405} 406 407std::string PrettyClass(mirror::Class* c) { 408 if (c == nullptr) { 409 return "null"; 410 } 411 std::string result; 412 result += "java.lang.Class<"; 413 result += PrettyDescriptor(c); 414 result += ">"; 415 return result; 416} 417 418std::string PrettyClassAndClassLoader(mirror::Class* c) { 419 if (c == nullptr) { 420 return "null"; 421 } 422 std::string result; 423 result += "java.lang.Class<"; 424 result += PrettyDescriptor(c); 425 result += ","; 426 result += PrettyTypeOf(c->GetClassLoader()); 427 // TODO: add an identifying hash value for the loader 428 result += ">"; 429 return result; 430} 431 432std::string PrettyJavaAccessFlags(uint32_t access_flags) { 433 std::string result; 434 if ((access_flags & kAccPublic) != 0) { 435 result += "public "; 436 } 437 if ((access_flags & kAccProtected) != 0) { 438 result += "protected "; 439 } 440 if ((access_flags & kAccPrivate) != 0) { 441 result += "private "; 442 } 443 if ((access_flags & kAccFinal) != 0) { 444 result += "final "; 445 } 446 if ((access_flags & kAccStatic) != 0) { 447 result += "static "; 448 } 449 if ((access_flags & kAccTransient) != 0) { 450 result += "transient "; 451 } 452 if ((access_flags & kAccVolatile) != 0) { 453 result += "volatile "; 454 } 455 if ((access_flags & kAccSynchronized) != 0) { 456 result += "synchronized "; 457 } 458 return result; 459} 460 461std::string PrettySize(int64_t byte_count) { 462 // The byte thresholds at which we display amounts. A byte count is displayed 463 // in unit U when kUnitThresholds[U] <= bytes < kUnitThresholds[U+1]. 464 static const int64_t kUnitThresholds[] = { 465 0, // B up to... 466 3*1024, // KB up to... 467 2*1024*1024, // MB up to... 468 1024*1024*1024 // GB from here. 469 }; 470 static const int64_t kBytesPerUnit[] = { 1, KB, MB, GB }; 471 static const char* const kUnitStrings[] = { "B", "KB", "MB", "GB" }; 472 const char* negative_str = ""; 473 if (byte_count < 0) { 474 negative_str = "-"; 475 byte_count = -byte_count; 476 } 477 int i = arraysize(kUnitThresholds); 478 while (--i > 0) { 479 if (byte_count >= kUnitThresholds[i]) { 480 break; 481 } 482 } 483 return StringPrintf("%s%" PRId64 "%s", 484 negative_str, byte_count / kBytesPerUnit[i], kUnitStrings[i]); 485} 486 487std::string PrintableChar(uint16_t ch) { 488 std::string result; 489 result += '\''; 490 if (NeedsEscaping(ch)) { 491 StringAppendF(&result, "\\u%04x", ch); 492 } else { 493 result += ch; 494 } 495 result += '\''; 496 return result; 497} 498 499std::string PrintableString(const char* utf) { 500 std::string result; 501 result += '"'; 502 const char* p = utf; 503 size_t char_count = CountModifiedUtf8Chars(p); 504 for (size_t i = 0; i < char_count; ++i) { 505 uint32_t ch = GetUtf16FromUtf8(&p); 506 if (ch == '\\') { 507 result += "\\\\"; 508 } else if (ch == '\n') { 509 result += "\\n"; 510 } else if (ch == '\r') { 511 result += "\\r"; 512 } else if (ch == '\t') { 513 result += "\\t"; 514 } else { 515 const uint16_t leading = GetLeadingUtf16Char(ch); 516 517 if (NeedsEscaping(leading)) { 518 StringAppendF(&result, "\\u%04x", leading); 519 } else { 520 result += leading; 521 } 522 523 const uint32_t trailing = GetTrailingUtf16Char(ch); 524 if (trailing != 0) { 525 // All high surrogates will need escaping. 526 StringAppendF(&result, "\\u%04x", trailing); 527 } 528 } 529 } 530 result += '"'; 531 return result; 532} 533 534// See http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/design.html#wp615 for the full rules. 535std::string MangleForJni(const std::string& s) { 536 std::string result; 537 size_t char_count = CountModifiedUtf8Chars(s.c_str()); 538 const char* cp = &s[0]; 539 for (size_t i = 0; i < char_count; ++i) { 540 uint32_t ch = GetUtf16FromUtf8(&cp); 541 if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) { 542 result.push_back(ch); 543 } else if (ch == '.' || ch == '/') { 544 result += "_"; 545 } else if (ch == '_') { 546 result += "_1"; 547 } else if (ch == ';') { 548 result += "_2"; 549 } else if (ch == '[') { 550 result += "_3"; 551 } else { 552 const uint16_t leading = GetLeadingUtf16Char(ch); 553 const uint32_t trailing = GetTrailingUtf16Char(ch); 554 555 StringAppendF(&result, "_0%04x", leading); 556 if (trailing != 0) { 557 StringAppendF(&result, "_0%04x", trailing); 558 } 559 } 560 } 561 return result; 562} 563 564std::string DotToDescriptor(const char* class_name) { 565 std::string descriptor(class_name); 566 std::replace(descriptor.begin(), descriptor.end(), '.', '/'); 567 if (descriptor.length() > 0 && descriptor[0] != '[') { 568 descriptor = "L" + descriptor + ";"; 569 } 570 return descriptor; 571} 572 573std::string DescriptorToDot(const char* descriptor) { 574 size_t length = strlen(descriptor); 575 if (length > 1) { 576 if (descriptor[0] == 'L' && descriptor[length - 1] == ';') { 577 // Descriptors have the leading 'L' and trailing ';' stripped. 578 std::string result(descriptor + 1, length - 2); 579 std::replace(result.begin(), result.end(), '/', '.'); 580 return result; 581 } else { 582 // For arrays the 'L' and ';' remain intact. 583 std::string result(descriptor); 584 std::replace(result.begin(), result.end(), '/', '.'); 585 return result; 586 } 587 } 588 // Do nothing for non-class/array descriptors. 589 return descriptor; 590} 591 592std::string DescriptorToName(const char* descriptor) { 593 size_t length = strlen(descriptor); 594 if (descriptor[0] == 'L' && descriptor[length - 1] == ';') { 595 std::string result(descriptor + 1, length - 2); 596 return result; 597 } 598 return descriptor; 599} 600 601std::string JniShortName(ArtMethod* m) { 602 std::string class_name(m->GetDeclaringClassDescriptor()); 603 // Remove the leading 'L' and trailing ';'... 604 CHECK_EQ(class_name[0], 'L') << class_name; 605 CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name; 606 class_name.erase(0, 1); 607 class_name.erase(class_name.size() - 1, 1); 608 609 std::string method_name(m->GetName()); 610 611 std::string short_name; 612 short_name += "Java_"; 613 short_name += MangleForJni(class_name); 614 short_name += "_"; 615 short_name += MangleForJni(method_name); 616 return short_name; 617} 618 619std::string JniLongName(ArtMethod* m) { 620 std::string long_name; 621 long_name += JniShortName(m); 622 long_name += "__"; 623 624 std::string signature(m->GetSignature().ToString()); 625 signature.erase(0, 1); 626 signature.erase(signature.begin() + signature.find(')'), signature.end()); 627 628 long_name += MangleForJni(signature); 629 630 return long_name; 631} 632 633// Helper for IsValidPartOfMemberNameUtf8(), a bit vector indicating valid low ascii. 634uint32_t DEX_MEMBER_VALID_LOW_ASCII[4] = { 635 0x00000000, // 00..1f low control characters; nothing valid 636 0x03ff2010, // 20..3f digits and symbols; valid: '0'..'9', '$', '-' 637 0x87fffffe, // 40..5f uppercase etc.; valid: 'A'..'Z', '_' 638 0x07fffffe // 60..7f lowercase etc.; valid: 'a'..'z' 639}; 640 641// Helper for IsValidPartOfMemberNameUtf8(); do not call directly. 642bool IsValidPartOfMemberNameUtf8Slow(const char** pUtf8Ptr) { 643 /* 644 * It's a multibyte encoded character. Decode it and analyze. We 645 * accept anything that isn't (a) an improperly encoded low value, 646 * (b) an improper surrogate pair, (c) an encoded '\0', (d) a high 647 * control character, or (e) a high space, layout, or special 648 * character (U+00a0, U+2000..U+200f, U+2028..U+202f, 649 * U+fff0..U+ffff). This is all specified in the dex format 650 * document. 651 */ 652 653 const uint32_t pair = GetUtf16FromUtf8(pUtf8Ptr); 654 const uint16_t leading = GetLeadingUtf16Char(pair); 655 656 // We have a surrogate pair resulting from a valid 4 byte UTF sequence. 657 // No further checks are necessary because 4 byte sequences span code 658 // points [U+10000, U+1FFFFF], which are valid codepoints in a dex 659 // identifier. Furthermore, GetUtf16FromUtf8 guarantees that each of 660 // the surrogate halves are valid and well formed in this instance. 661 if (GetTrailingUtf16Char(pair) != 0) { 662 return true; 663 } 664 665 666 // We've encountered a one, two or three byte UTF-8 sequence. The 667 // three byte UTF-8 sequence could be one half of a surrogate pair. 668 switch (leading >> 8) { 669 case 0x00: 670 // It's only valid if it's above the ISO-8859-1 high space (0xa0). 671 return (leading > 0x00a0); 672 case 0xd8: 673 case 0xd9: 674 case 0xda: 675 case 0xdb: 676 { 677 // We found a three byte sequence encoding one half of a surrogate. 678 // Look for the other half. 679 const uint32_t pair2 = GetUtf16FromUtf8(pUtf8Ptr); 680 const uint16_t trailing = GetLeadingUtf16Char(pair2); 681 682 return (GetTrailingUtf16Char(pair2) == 0) && (0xdc00 <= trailing && trailing <= 0xdfff); 683 } 684 case 0xdc: 685 case 0xdd: 686 case 0xde: 687 case 0xdf: 688 // It's a trailing surrogate, which is not valid at this point. 689 return false; 690 case 0x20: 691 case 0xff: 692 // It's in the range that has spaces, controls, and specials. 693 switch (leading & 0xfff8) { 694 case 0x2000: 695 case 0x2008: 696 case 0x2028: 697 case 0xfff0: 698 case 0xfff8: 699 return false; 700 } 701 return true; 702 default: 703 return true; 704 } 705 706 UNREACHABLE(); 707} 708 709/* Return whether the pointed-at modified-UTF-8 encoded character is 710 * valid as part of a member name, updating the pointer to point past 711 * the consumed character. This will consume two encoded UTF-16 code 712 * points if the character is encoded as a surrogate pair. Also, if 713 * this function returns false, then the given pointer may only have 714 * been partially advanced. 715 */ 716static bool IsValidPartOfMemberNameUtf8(const char** pUtf8Ptr) { 717 uint8_t c = (uint8_t) **pUtf8Ptr; 718 if (LIKELY(c <= 0x7f)) { 719 // It's low-ascii, so check the table. 720 uint32_t wordIdx = c >> 5; 721 uint32_t bitIdx = c & 0x1f; 722 (*pUtf8Ptr)++; 723 return (DEX_MEMBER_VALID_LOW_ASCII[wordIdx] & (1 << bitIdx)) != 0; 724 } 725 726 // It's a multibyte encoded character. Call a non-inline function 727 // for the heavy lifting. 728 return IsValidPartOfMemberNameUtf8Slow(pUtf8Ptr); 729} 730 731bool IsValidMemberName(const char* s) { 732 bool angle_name = false; 733 734 switch (*s) { 735 case '\0': 736 // The empty string is not a valid name. 737 return false; 738 case '<': 739 angle_name = true; 740 s++; 741 break; 742 } 743 744 while (true) { 745 switch (*s) { 746 case '\0': 747 return !angle_name; 748 case '>': 749 return angle_name && s[1] == '\0'; 750 } 751 752 if (!IsValidPartOfMemberNameUtf8(&s)) { 753 return false; 754 } 755 } 756} 757 758enum ClassNameType { kName, kDescriptor }; 759template<ClassNameType kType, char kSeparator> 760static bool IsValidClassName(const char* s) { 761 int arrayCount = 0; 762 while (*s == '[') { 763 arrayCount++; 764 s++; 765 } 766 767 if (arrayCount > 255) { 768 // Arrays may have no more than 255 dimensions. 769 return false; 770 } 771 772 ClassNameType type = kType; 773 if (type != kDescriptor && arrayCount != 0) { 774 /* 775 * If we're looking at an array of some sort, then it doesn't 776 * matter if what is being asked for is a class name; the 777 * format looks the same as a type descriptor in that case, so 778 * treat it as such. 779 */ 780 type = kDescriptor; 781 } 782 783 if (type == kDescriptor) { 784 /* 785 * We are looking for a descriptor. Either validate it as a 786 * single-character primitive type, or continue on to check the 787 * embedded class name (bracketed by "L" and ";"). 788 */ 789 switch (*(s++)) { 790 case 'B': 791 case 'C': 792 case 'D': 793 case 'F': 794 case 'I': 795 case 'J': 796 case 'S': 797 case 'Z': 798 // These are all single-character descriptors for primitive types. 799 return (*s == '\0'); 800 case 'V': 801 // Non-array void is valid, but you can't have an array of void. 802 return (arrayCount == 0) && (*s == '\0'); 803 case 'L': 804 // Class name: Break out and continue below. 805 break; 806 default: 807 // Oddball descriptor character. 808 return false; 809 } 810 } 811 812 /* 813 * We just consumed the 'L' that introduces a class name as part 814 * of a type descriptor, or we are looking for an unadorned class 815 * name. 816 */ 817 818 bool sepOrFirst = true; // first character or just encountered a separator. 819 for (;;) { 820 uint8_t c = (uint8_t) *s; 821 switch (c) { 822 case '\0': 823 /* 824 * Premature end for a type descriptor, but valid for 825 * a class name as long as we haven't encountered an 826 * empty component (including the degenerate case of 827 * the empty string ""). 828 */ 829 return (type == kName) && !sepOrFirst; 830 case ';': 831 /* 832 * Invalid character for a class name, but the 833 * legitimate end of a type descriptor. In the latter 834 * case, make sure that this is the end of the string 835 * and that it doesn't end with an empty component 836 * (including the degenerate case of "L;"). 837 */ 838 return (type == kDescriptor) && !sepOrFirst && (s[1] == '\0'); 839 case '/': 840 case '.': 841 if (c != kSeparator) { 842 // The wrong separator character. 843 return false; 844 } 845 if (sepOrFirst) { 846 // Separator at start or two separators in a row. 847 return false; 848 } 849 sepOrFirst = true; 850 s++; 851 break; 852 default: 853 if (!IsValidPartOfMemberNameUtf8(&s)) { 854 return false; 855 } 856 sepOrFirst = false; 857 break; 858 } 859 } 860} 861 862bool IsValidBinaryClassName(const char* s) { 863 return IsValidClassName<kName, '.'>(s); 864} 865 866bool IsValidJniClassName(const char* s) { 867 return IsValidClassName<kName, '/'>(s); 868} 869 870bool IsValidDescriptor(const char* s) { 871 return IsValidClassName<kDescriptor, '/'>(s); 872} 873 874void Split(const std::string& s, char separator, std::vector<std::string>* result) { 875 const char* p = s.data(); 876 const char* end = p + s.size(); 877 while (p != end) { 878 if (*p == separator) { 879 ++p; 880 } else { 881 const char* start = p; 882 while (++p != end && *p != separator) { 883 // Skip to the next occurrence of the separator. 884 } 885 result->push_back(std::string(start, p - start)); 886 } 887 } 888} 889 890std::string Trim(const std::string& s) { 891 std::string result; 892 unsigned int start_index = 0; 893 unsigned int end_index = s.size() - 1; 894 895 // Skip initial whitespace. 896 while (start_index < s.size()) { 897 if (!isspace(s[start_index])) { 898 break; 899 } 900 start_index++; 901 } 902 903 // Skip terminating whitespace. 904 while (end_index >= start_index) { 905 if (!isspace(s[end_index])) { 906 break; 907 } 908 end_index--; 909 } 910 911 // All spaces, no beef. 912 if (end_index < start_index) { 913 return ""; 914 } 915 // Start_index is the first non-space, end_index is the last one. 916 return s.substr(start_index, end_index - start_index + 1); 917} 918 919template <typename StringT> 920std::string Join(const std::vector<StringT>& strings, char separator) { 921 if (strings.empty()) { 922 return ""; 923 } 924 925 std::string result(strings[0]); 926 for (size_t i = 1; i < strings.size(); ++i) { 927 result += separator; 928 result += strings[i]; 929 } 930 return result; 931} 932 933// Explicit instantiations. 934template std::string Join<std::string>(const std::vector<std::string>& strings, char separator); 935template std::string Join<const char*>(const std::vector<const char*>& strings, char separator); 936 937bool StartsWith(const std::string& s, const char* prefix) { 938 return s.compare(0, strlen(prefix), prefix) == 0; 939} 940 941bool EndsWith(const std::string& s, const char* suffix) { 942 size_t suffix_length = strlen(suffix); 943 size_t string_length = s.size(); 944 if (suffix_length > string_length) { 945 return false; 946 } 947 size_t offset = string_length - suffix_length; 948 return s.compare(offset, suffix_length, suffix) == 0; 949} 950 951void SetThreadName(const char* thread_name) { 952 int hasAt = 0; 953 int hasDot = 0; 954 const char* s = thread_name; 955 while (*s) { 956 if (*s == '.') { 957 hasDot = 1; 958 } else if (*s == '@') { 959 hasAt = 1; 960 } 961 s++; 962 } 963 int len = s - thread_name; 964 if (len < 15 || hasAt || !hasDot) { 965 s = thread_name; 966 } else { 967 s = thread_name + len - 15; 968 } 969#if defined(__linux__) 970 // pthread_setname_np fails rather than truncating long strings. 971 char buf[16]; // MAX_TASK_COMM_LEN=16 is hard-coded in the kernel. 972 strncpy(buf, s, sizeof(buf)-1); 973 buf[sizeof(buf)-1] = '\0'; 974 errno = pthread_setname_np(pthread_self(), buf); 975 if (errno != 0) { 976 PLOG(WARNING) << "Unable to set the name of current thread to '" << buf << "'"; 977 } 978#else // __APPLE__ 979 pthread_setname_np(thread_name); 980#endif 981} 982 983void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu) { 984 *utime = *stime = *task_cpu = 0; 985 std::string stats; 986 if (!ReadFileToString(StringPrintf("/proc/self/task/%d/stat", tid), &stats)) { 987 return; 988 } 989 // Skip the command, which may contain spaces. 990 stats = stats.substr(stats.find(')') + 2); 991 // Extract the three fields we care about. 992 std::vector<std::string> fields; 993 Split(stats, ' ', &fields); 994 *state = fields[0][0]; 995 *utime = strtoull(fields[11].c_str(), nullptr, 10); 996 *stime = strtoull(fields[12].c_str(), nullptr, 10); 997 *task_cpu = strtoull(fields[36].c_str(), nullptr, 10); 998} 999 1000std::string GetSchedulerGroupName(pid_t tid) { 1001 // /proc/<pid>/cgroup looks like this: 1002 // 2:devices:/ 1003 // 1:cpuacct,cpu:/ 1004 // We want the third field from the line whose second field contains the "cpu" token. 1005 std::string cgroup_file; 1006 if (!ReadFileToString(StringPrintf("/proc/self/task/%d/cgroup", tid), &cgroup_file)) { 1007 return ""; 1008 } 1009 std::vector<std::string> cgroup_lines; 1010 Split(cgroup_file, '\n', &cgroup_lines); 1011 for (size_t i = 0; i < cgroup_lines.size(); ++i) { 1012 std::vector<std::string> cgroup_fields; 1013 Split(cgroup_lines[i], ':', &cgroup_fields); 1014 std::vector<std::string> cgroups; 1015 Split(cgroup_fields[1], ',', &cgroups); 1016 for (size_t j = 0; j < cgroups.size(); ++j) { 1017 if (cgroups[j] == "cpu") { 1018 return cgroup_fields[2].substr(1); // Skip the leading slash. 1019 } 1020 } 1021 } 1022 return ""; 1023} 1024 1025#if defined(__linux__) 1026 1027ALWAYS_INLINE 1028static inline void WritePrefix(std::ostream* os, const char* prefix, bool odd) { 1029 if (prefix != nullptr) { 1030 *os << prefix; 1031 } 1032 *os << " "; 1033 if (!odd) { 1034 *os << " "; 1035 } 1036} 1037 1038static bool RunCommand(std::string cmd, std::ostream* os, const char* prefix) { 1039 FILE* stream = popen(cmd.c_str(), "r"); 1040 if (stream) { 1041 if (os != nullptr) { 1042 bool odd_line = true; // We indent them differently. 1043 bool wrote_prefix = false; // Have we already written a prefix? 1044 constexpr size_t kMaxBuffer = 128; // Relatively small buffer. Should be OK as we're on an 1045 // alt stack, but just to be sure... 1046 char buffer[kMaxBuffer]; 1047 while (!feof(stream)) { 1048 if (fgets(buffer, kMaxBuffer, stream) != nullptr) { 1049 // Split on newlines. 1050 char* tmp = buffer; 1051 for (;;) { 1052 char* new_line = strchr(tmp, '\n'); 1053 if (new_line == nullptr) { 1054 // Print the rest. 1055 if (*tmp != 0) { 1056 if (!wrote_prefix) { 1057 WritePrefix(os, prefix, odd_line); 1058 } 1059 wrote_prefix = true; 1060 *os << tmp; 1061 } 1062 break; 1063 } 1064 if (!wrote_prefix) { 1065 WritePrefix(os, prefix, odd_line); 1066 } 1067 char saved = *(new_line + 1); 1068 *(new_line + 1) = 0; 1069 *os << tmp; 1070 *(new_line + 1) = saved; 1071 tmp = new_line + 1; 1072 odd_line = !odd_line; 1073 wrote_prefix = false; 1074 } 1075 } 1076 } 1077 } 1078 pclose(stream); 1079 return true; 1080 } else { 1081 return false; 1082 } 1083} 1084 1085static void Addr2line(const std::string& map_src, uintptr_t offset, std::ostream& os, 1086 const char* prefix) { 1087 std::string cmdline(StringPrintf("addr2line --functions --inlines --demangle -e %s %zx", 1088 map_src.c_str(), offset)); 1089 RunCommand(cmdline.c_str(), &os, prefix); 1090} 1091#endif 1092 1093void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix, 1094 ArtMethod* current_method, void* ucontext_ptr) { 1095#if __linux__ 1096 // b/18119146 1097 if (RUNNING_ON_VALGRIND != 0) { 1098 return; 1099 } 1100 1101 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, tid)); 1102 if (!backtrace->Unwind(0, reinterpret_cast<ucontext*>(ucontext_ptr))) { 1103 os << prefix << "(backtrace::Unwind failed for thread " << tid << ")\n"; 1104 return; 1105 } else if (backtrace->NumFrames() == 0) { 1106 os << prefix << "(no native stack frames for thread " << tid << ")\n"; 1107 return; 1108 } 1109 1110 // Check whether we have and should use addr2line. 1111 bool use_addr2line; 1112 if (kUseAddr2line) { 1113 // Try to run it to see whether we have it. Push an argument so that it doesn't assume a.out 1114 // and print to stderr. 1115 use_addr2line = (gAborting > 0) && RunCommand("addr2line -h", nullptr, nullptr); 1116 } else { 1117 use_addr2line = false; 1118 } 1119 1120 for (Backtrace::const_iterator it = backtrace->begin(); 1121 it != backtrace->end(); ++it) { 1122 // We produce output like this: 1123 // ] #00 pc 000075bb8 /system/lib/libc.so (unwind_backtrace_thread+536) 1124 // In order for parsing tools to continue to function, the stack dump 1125 // format must at least adhere to this format: 1126 // #XX pc <RELATIVE_ADDR> <FULL_PATH_TO_SHARED_LIBRARY> ... 1127 // The parsers require a single space before and after pc, and two spaces 1128 // after the <RELATIVE_ADDR>. There can be any prefix data before the 1129 // #XX. <RELATIVE_ADDR> has to be a hex number but with no 0x prefix. 1130 os << prefix << StringPrintf("#%02zu pc ", it->num); 1131 bool try_addr2line = false; 1132 if (!BacktraceMap::IsValid(it->map)) { 1133 os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIxPTR " ???" 1134 : "%08" PRIxPTR " ???", 1135 it->pc); 1136 } else { 1137 os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIxPTR " " 1138 : "%08" PRIxPTR " ", 1139 BacktraceMap::GetRelativePc(it->map, it->pc)); 1140 os << it->map.name; 1141 os << " ("; 1142 if (!it->func_name.empty()) { 1143 os << it->func_name; 1144 if (it->func_offset != 0) { 1145 os << "+" << it->func_offset; 1146 } 1147 try_addr2line = true; 1148 } else if ( 1149 current_method != nullptr && Locks::mutator_lock_->IsSharedHeld(Thread::Current()) && 1150 current_method->PcIsWithinQuickCode(it->pc)) { 1151 const void* start_of_code = current_method->GetEntryPointFromQuickCompiledCode(); 1152 os << JniLongName(current_method) << "+" 1153 << (it->pc - reinterpret_cast<uintptr_t>(start_of_code)); 1154 } else { 1155 os << "???"; 1156 } 1157 os << ")"; 1158 } 1159 os << "\n"; 1160 if (try_addr2line && use_addr2line) { 1161 Addr2line(it->map.name, it->pc - it->map.start, os, prefix); 1162 } 1163 } 1164#else 1165 UNUSED(os, tid, prefix, current_method, ucontext_ptr); 1166#endif 1167} 1168 1169#if defined(__APPLE__) 1170 1171// TODO: is there any way to get the kernel stack on Mac OS? 1172void DumpKernelStack(std::ostream&, pid_t, const char*, bool) {} 1173 1174#else 1175 1176void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix, bool include_count) { 1177 if (tid == GetTid()) { 1178 // There's no point showing that we're reading our stack out of /proc! 1179 return; 1180 } 1181 1182 std::string kernel_stack_filename(StringPrintf("/proc/self/task/%d/stack", tid)); 1183 std::string kernel_stack; 1184 if (!ReadFileToString(kernel_stack_filename, &kernel_stack)) { 1185 os << prefix << "(couldn't read " << kernel_stack_filename << ")\n"; 1186 return; 1187 } 1188 1189 std::vector<std::string> kernel_stack_frames; 1190 Split(kernel_stack, '\n', &kernel_stack_frames); 1191 // We skip the last stack frame because it's always equivalent to "[<ffffffff>] 0xffffffff", 1192 // which looking at the source appears to be the kernel's way of saying "that's all, folks!". 1193 kernel_stack_frames.pop_back(); 1194 for (size_t i = 0; i < kernel_stack_frames.size(); ++i) { 1195 // Turn "[<ffffffff8109156d>] futex_wait_queue_me+0xcd/0x110" 1196 // into "futex_wait_queue_me+0xcd/0x110". 1197 const char* text = kernel_stack_frames[i].c_str(); 1198 const char* close_bracket = strchr(text, ']'); 1199 if (close_bracket != nullptr) { 1200 text = close_bracket + 2; 1201 } 1202 os << prefix; 1203 if (include_count) { 1204 os << StringPrintf("#%02zd ", i); 1205 } 1206 os << text << "\n"; 1207 } 1208} 1209 1210#endif 1211 1212const char* GetAndroidRoot() { 1213 const char* android_root = getenv("ANDROID_ROOT"); 1214 if (android_root == nullptr) { 1215 if (OS::DirectoryExists("/system")) { 1216 android_root = "/system"; 1217 } else { 1218 LOG(FATAL) << "ANDROID_ROOT not set and /system does not exist"; 1219 return ""; 1220 } 1221 } 1222 if (!OS::DirectoryExists(android_root)) { 1223 LOG(FATAL) << "Failed to find ANDROID_ROOT directory " << android_root; 1224 return ""; 1225 } 1226 return android_root; 1227} 1228 1229const char* GetAndroidData() { 1230 std::string error_msg; 1231 const char* dir = GetAndroidDataSafe(&error_msg); 1232 if (dir != nullptr) { 1233 return dir; 1234 } else { 1235 LOG(FATAL) << error_msg; 1236 return ""; 1237 } 1238} 1239 1240const char* GetAndroidDataSafe(std::string* error_msg) { 1241 const char* android_data = getenv("ANDROID_DATA"); 1242 if (android_data == nullptr) { 1243 if (OS::DirectoryExists("/data")) { 1244 android_data = "/data"; 1245 } else { 1246 *error_msg = "ANDROID_DATA not set and /data does not exist"; 1247 return nullptr; 1248 } 1249 } 1250 if (!OS::DirectoryExists(android_data)) { 1251 *error_msg = StringPrintf("Failed to find ANDROID_DATA directory %s", android_data); 1252 return nullptr; 1253 } 1254 return android_data; 1255} 1256 1257void GetDalvikCache(const char* subdir, const bool create_if_absent, std::string* dalvik_cache, 1258 bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache) { 1259 CHECK(subdir != nullptr); 1260 std::string error_msg; 1261 const char* android_data = GetAndroidDataSafe(&error_msg); 1262 if (android_data == nullptr) { 1263 *have_android_data = false; 1264 *dalvik_cache_exists = false; 1265 *is_global_cache = false; 1266 return; 1267 } else { 1268 *have_android_data = true; 1269 } 1270 const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data)); 1271 *dalvik_cache = dalvik_cache_root + subdir; 1272 *dalvik_cache_exists = OS::DirectoryExists(dalvik_cache->c_str()); 1273 *is_global_cache = strcmp(android_data, "/data") == 0; 1274 if (create_if_absent && !*dalvik_cache_exists && !*is_global_cache) { 1275 // Don't create the system's /data/dalvik-cache/... because it needs special permissions. 1276 *dalvik_cache_exists = ((mkdir(dalvik_cache_root.c_str(), 0700) == 0 || errno == EEXIST) && 1277 (mkdir(dalvik_cache->c_str(), 0700) == 0 || errno == EEXIST)); 1278 } 1279} 1280 1281static std::string GetDalvikCacheImpl(const char* subdir, 1282 const bool create_if_absent, 1283 const bool abort_on_error) { 1284 CHECK(subdir != nullptr); 1285 const char* android_data = GetAndroidData(); 1286 const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data)); 1287 const std::string dalvik_cache = dalvik_cache_root + subdir; 1288 if (!OS::DirectoryExists(dalvik_cache.c_str())) { 1289 if (!create_if_absent) { 1290 // TODO: Check callers. Traditional behavior is to not to abort, even when abort_on_error. 1291 return ""; 1292 } 1293 1294 // Don't create the system's /data/dalvik-cache/... because it needs special permissions. 1295 if (strcmp(android_data, "/data") == 0) { 1296 if (abort_on_error) { 1297 LOG(FATAL) << "Failed to find dalvik-cache directory " << dalvik_cache 1298 << ", cannot create /data dalvik-cache."; 1299 UNREACHABLE(); 1300 } 1301 return ""; 1302 } 1303 1304 int result = mkdir(dalvik_cache_root.c_str(), 0700); 1305 if (result != 0 && errno != EEXIST) { 1306 if (abort_on_error) { 1307 PLOG(FATAL) << "Failed to create dalvik-cache root directory " << dalvik_cache_root; 1308 UNREACHABLE(); 1309 } 1310 return ""; 1311 } 1312 1313 result = mkdir(dalvik_cache.c_str(), 0700); 1314 if (result != 0) { 1315 if (abort_on_error) { 1316 PLOG(FATAL) << "Failed to create dalvik-cache directory " << dalvik_cache; 1317 UNREACHABLE(); 1318 } 1319 return ""; 1320 } 1321 } 1322 return dalvik_cache; 1323} 1324 1325std::string GetDalvikCache(const char* subdir, const bool create_if_absent) { 1326 return GetDalvikCacheImpl(subdir, create_if_absent, false); 1327} 1328 1329std::string GetDalvikCacheOrDie(const char* subdir, const bool create_if_absent) { 1330 return GetDalvikCacheImpl(subdir, create_if_absent, true); 1331} 1332 1333bool GetDalvikCacheFilename(const char* location, const char* cache_location, 1334 std::string* filename, std::string* error_msg) { 1335 if (location[0] != '/') { 1336 *error_msg = StringPrintf("Expected path in location to be absolute: %s", location); 1337 return false; 1338 } 1339 std::string cache_file(&location[1]); // skip leading slash 1340 if (!EndsWith(location, ".dex") && !EndsWith(location, ".art") && !EndsWith(location, ".oat")) { 1341 cache_file += "/"; 1342 cache_file += DexFile::kClassesDex; 1343 } 1344 std::replace(cache_file.begin(), cache_file.end(), '/', '@'); 1345 *filename = StringPrintf("%s/%s", cache_location, cache_file.c_str()); 1346 return true; 1347} 1348 1349std::string GetDalvikCacheFilenameOrDie(const char* location, const char* cache_location) { 1350 std::string ret; 1351 std::string error_msg; 1352 if (!GetDalvikCacheFilename(location, cache_location, &ret, &error_msg)) { 1353 LOG(FATAL) << error_msg; 1354 } 1355 return ret; 1356} 1357 1358static void InsertIsaDirectory(const InstructionSet isa, std::string* filename) { 1359 // in = /foo/bar/baz 1360 // out = /foo/bar/<isa>/baz 1361 size_t pos = filename->rfind('/'); 1362 CHECK_NE(pos, std::string::npos) << *filename << " " << isa; 1363 filename->insert(pos, "/", 1); 1364 filename->insert(pos + 1, GetInstructionSetString(isa)); 1365} 1366 1367std::string GetSystemImageFilename(const char* location, const InstructionSet isa) { 1368 // location = /system/framework/boot.art 1369 // filename = /system/framework/<isa>/boot.art 1370 std::string filename(location); 1371 InsertIsaDirectory(isa, &filename); 1372 return filename; 1373} 1374 1375bool IsZipMagic(uint32_t magic) { 1376 return (('P' == ((magic >> 0) & 0xff)) && 1377 ('K' == ((magic >> 8) & 0xff))); 1378} 1379 1380bool IsDexMagic(uint32_t magic) { 1381 return DexFile::IsMagicValid(reinterpret_cast<const uint8_t*>(&magic)); 1382} 1383 1384bool IsOatMagic(uint32_t magic) { 1385 return (memcmp(reinterpret_cast<const uint8_t*>(magic), 1386 OatHeader::kOatMagic, 1387 sizeof(OatHeader::kOatMagic)) == 0); 1388} 1389 1390bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg) { 1391 const std::string command_line(Join(arg_vector, ' ')); 1392 1393 CHECK_GE(arg_vector.size(), 1U) << command_line; 1394 1395 // Convert the args to char pointers. 1396 const char* program = arg_vector[0].c_str(); 1397 std::vector<char*> args; 1398 for (size_t i = 0; i < arg_vector.size(); ++i) { 1399 const std::string& arg = arg_vector[i]; 1400 char* arg_str = const_cast<char*>(arg.c_str()); 1401 CHECK(arg_str != nullptr) << i; 1402 args.push_back(arg_str); 1403 } 1404 args.push_back(nullptr); 1405 1406 // fork and exec 1407 pid_t pid = fork(); 1408 if (pid == 0) { 1409 // no allocation allowed between fork and exec 1410 1411 // change process groups, so we don't get reaped by ProcessManager 1412 setpgid(0, 0); 1413 1414 execv(program, &args[0]); 1415 1416 PLOG(ERROR) << "Failed to execv(" << command_line << ")"; 1417 exit(1); 1418 } else { 1419 if (pid == -1) { 1420 *error_msg = StringPrintf("Failed to execv(%s) because fork failed: %s", 1421 command_line.c_str(), strerror(errno)); 1422 return false; 1423 } 1424 1425 // wait for subprocess to finish 1426 int status; 1427 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0)); 1428 if (got_pid != pid) { 1429 *error_msg = StringPrintf("Failed after fork for execv(%s) because waitpid failed: " 1430 "wanted %d, got %d: %s", 1431 command_line.c_str(), pid, got_pid, strerror(errno)); 1432 return false; 1433 } 1434 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { 1435 *error_msg = StringPrintf("Failed execv(%s) because non-0 exit status", 1436 command_line.c_str()); 1437 return false; 1438 } 1439 } 1440 return true; 1441} 1442 1443void EncodeUnsignedLeb128(uint32_t data, std::vector<uint8_t>* dst) { 1444 Leb128Encoder(dst).PushBackUnsigned(data); 1445} 1446 1447void EncodeSignedLeb128(int32_t data, std::vector<uint8_t>* dst) { 1448 Leb128Encoder(dst).PushBackSigned(data); 1449} 1450 1451std::string PrettyDescriptor(Primitive::Type type) { 1452 return PrettyDescriptor(Primitive::Descriptor(type)); 1453} 1454 1455} // namespace art 1456