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 "android-base/stringprintf.h"
29 #include "android-base/strings.h"
30 
31 #include "base/stl_util.h"
32 #include "base/unix_file/fd_file.h"
33 #include "dex_file-inl.h"
34 #include "dex_instruction.h"
35 #include "oat_quick_method_header.h"
36 #include "os.h"
37 #include "scoped_thread_state_change-inl.h"
38 #include "utf-inl.h"
39 
40 #if defined(__APPLE__)
41 #include "AvailabilityMacros.h"  // For MAC_OS_X_VERSION_MAX_ALLOWED
42 #include <sys/syscall.h>
43 #include <crt_externs.h>
44 #endif
45 
46 #if defined(__linux__)
47 #include <linux/unistd.h>
48 #endif
49 
50 namespace art {
51 
52 using android::base::StringAppendF;
53 using android::base::StringPrintf;
54 
GetTid()55 pid_t GetTid() {
56 #if defined(__APPLE__)
57   uint64_t owner;
58   CHECK_PTHREAD_CALL(pthread_threadid_np, (nullptr, &owner), __FUNCTION__);  // Requires Mac OS 10.6
59   return owner;
60 #elif defined(__BIONIC__)
61   return gettid();
62 #else
63   return syscall(__NR_gettid);
64 #endif
65 }
66 
GetThreadName(pid_t tid)67 std::string GetThreadName(pid_t tid) {
68   std::string result;
69   if (ReadFileToString(StringPrintf("/proc/self/task/%d/comm", tid), &result)) {
70     result.resize(result.size() - 1);  // Lose the trailing '\n'.
71   } else {
72     result = "<unknown>";
73   }
74   return result;
75 }
76 
ReadFileToString(const std::string & file_name,std::string * result)77 bool ReadFileToString(const std::string& file_name, std::string* result) {
78   File file(file_name, O_RDONLY, false);
79   if (!file.IsOpened()) {
80     return false;
81   }
82 
83   std::vector<char> buf(8 * KB);
84   while (true) {
85     int64_t n = TEMP_FAILURE_RETRY(read(file.Fd(), &buf[0], buf.size()));
86     if (n == -1) {
87       return false;
88     }
89     if (n == 0) {
90       return true;
91     }
92     result->append(&buf[0], n);
93   }
94 }
95 
PrintFileToLog(const std::string & file_name,LogSeverity level)96 bool PrintFileToLog(const std::string& file_name, LogSeverity level) {
97   File file(file_name, O_RDONLY, false);
98   if (!file.IsOpened()) {
99     return false;
100   }
101 
102   constexpr size_t kBufSize = 256;  // Small buffer. Avoid stack overflow and stack size warnings.
103   char buf[kBufSize + 1];           // +1 for terminator.
104   size_t filled_to = 0;
105   while (true) {
106     DCHECK_LT(filled_to, kBufSize);
107     int64_t n = TEMP_FAILURE_RETRY(read(file.Fd(), &buf[filled_to], kBufSize - filled_to));
108     if (n <= 0) {
109       // Print the rest of the buffer, if it exists.
110       if (filled_to > 0) {
111         buf[filled_to] = 0;
112         LOG(level) << buf;
113       }
114       return n == 0;
115     }
116     // Scan for '\n'.
117     size_t i = filled_to;
118     bool found_newline = false;
119     for (; i < filled_to + n; ++i) {
120       if (buf[i] == '\n') {
121         // Found a line break, that's something to print now.
122         buf[i] = 0;
123         LOG(level) << buf;
124         // Copy the rest to the front.
125         if (i + 1 < filled_to + n) {
126           memmove(&buf[0], &buf[i + 1], filled_to + n - i - 1);
127           filled_to = filled_to + n - i - 1;
128         } else {
129           filled_to = 0;
130         }
131         found_newline = true;
132         break;
133       }
134     }
135     if (found_newline) {
136       continue;
137     } else {
138       filled_to += n;
139       // Check if we must flush now.
140       if (filled_to == kBufSize) {
141         buf[kBufSize] = 0;
142         LOG(level) << buf;
143         filled_to = 0;
144       }
145     }
146   }
147 }
148 
PrettyDescriptor(const char * descriptor)149 std::string PrettyDescriptor(const char* descriptor) {
150   // Count the number of '['s to get the dimensionality.
151   const char* c = descriptor;
152   size_t dim = 0;
153   while (*c == '[') {
154     dim++;
155     c++;
156   }
157 
158   // Reference or primitive?
159   if (*c == 'L') {
160     // "[[La/b/C;" -> "a.b.C[][]".
161     c++;  // Skip the 'L'.
162   } else {
163     // "[[B" -> "byte[][]".
164     // To make life easier, we make primitives look like unqualified
165     // reference types.
166     switch (*c) {
167     case 'B': c = "byte;"; break;
168     case 'C': c = "char;"; break;
169     case 'D': c = "double;"; break;
170     case 'F': c = "float;"; break;
171     case 'I': c = "int;"; break;
172     case 'J': c = "long;"; break;
173     case 'S': c = "short;"; break;
174     case 'Z': c = "boolean;"; break;
175     case 'V': c = "void;"; break;  // Used when decoding return types.
176     default: return descriptor;
177     }
178   }
179 
180   // At this point, 'c' is a string of the form "fully/qualified/Type;"
181   // or "primitive;". Rewrite the type with '.' instead of '/':
182   std::string result;
183   const char* p = c;
184   while (*p != ';') {
185     char ch = *p++;
186     if (ch == '/') {
187       ch = '.';
188     }
189     result.push_back(ch);
190   }
191   // ...and replace the semicolon with 'dim' "[]" pairs:
192   for (size_t i = 0; i < dim; ++i) {
193     result += "[]";
194   }
195   return result;
196 }
197 
PrettyArguments(const char * signature)198 std::string PrettyArguments(const char* signature) {
199   std::string result;
200   result += '(';
201   CHECK_EQ(*signature, '(');
202   ++signature;  // Skip the '('.
203   while (*signature != ')') {
204     size_t argument_length = 0;
205     while (signature[argument_length] == '[') {
206       ++argument_length;
207     }
208     if (signature[argument_length] == 'L') {
209       argument_length = (strchr(signature, ';') - signature + 1);
210     } else {
211       ++argument_length;
212     }
213     {
214       std::string argument_descriptor(signature, argument_length);
215       result += PrettyDescriptor(argument_descriptor.c_str());
216     }
217     if (signature[argument_length] != ')') {
218       result += ", ";
219     }
220     signature += argument_length;
221   }
222   CHECK_EQ(*signature, ')');
223   ++signature;  // Skip the ')'.
224   result += ')';
225   return result;
226 }
227 
PrettyReturnType(const char * signature)228 std::string PrettyReturnType(const char* signature) {
229   const char* return_type = strchr(signature, ')');
230   CHECK(return_type != nullptr);
231   ++return_type;  // Skip ')'.
232   return PrettyDescriptor(return_type);
233 }
234 
PrettyJavaAccessFlags(uint32_t access_flags)235 std::string PrettyJavaAccessFlags(uint32_t access_flags) {
236   std::string result;
237   if ((access_flags & kAccPublic) != 0) {
238     result += "public ";
239   }
240   if ((access_flags & kAccProtected) != 0) {
241     result += "protected ";
242   }
243   if ((access_flags & kAccPrivate) != 0) {
244     result += "private ";
245   }
246   if ((access_flags & kAccFinal) != 0) {
247     result += "final ";
248   }
249   if ((access_flags & kAccStatic) != 0) {
250     result += "static ";
251   }
252   if ((access_flags & kAccAbstract) != 0) {
253     result += "abstract ";
254   }
255   if ((access_flags & kAccInterface) != 0) {
256     result += "interface ";
257   }
258   if ((access_flags & kAccTransient) != 0) {
259     result += "transient ";
260   }
261   if ((access_flags & kAccVolatile) != 0) {
262     result += "volatile ";
263   }
264   if ((access_flags & kAccSynchronized) != 0) {
265     result += "synchronized ";
266   }
267   return result;
268 }
269 
PrettySize(int64_t byte_count)270 std::string PrettySize(int64_t byte_count) {
271   // The byte thresholds at which we display amounts.  A byte count is displayed
272   // in unit U when kUnitThresholds[U] <= bytes < kUnitThresholds[U+1].
273   static const int64_t kUnitThresholds[] = {
274     0,              // B up to...
275     3*1024,         // KB up to...
276     2*1024*1024,    // MB up to...
277     1024*1024*1024  // GB from here.
278   };
279   static const int64_t kBytesPerUnit[] = { 1, KB, MB, GB };
280   static const char* const kUnitStrings[] = { "B", "KB", "MB", "GB" };
281   const char* negative_str = "";
282   if (byte_count < 0) {
283     negative_str = "-";
284     byte_count = -byte_count;
285   }
286   int i = arraysize(kUnitThresholds);
287   while (--i > 0) {
288     if (byte_count >= kUnitThresholds[i]) {
289       break;
290     }
291   }
292   return StringPrintf("%s%" PRId64 "%s",
293                       negative_str, byte_count / kBytesPerUnit[i], kUnitStrings[i]);
294 }
295 
NeedsEscaping(uint16_t ch)296 static inline constexpr bool NeedsEscaping(uint16_t ch) {
297   return (ch < ' ' || ch > '~');
298 }
299 
PrintableChar(uint16_t ch)300 std::string PrintableChar(uint16_t ch) {
301   std::string result;
302   result += '\'';
303   if (NeedsEscaping(ch)) {
304     StringAppendF(&result, "\\u%04x", ch);
305   } else {
306     result += ch;
307   }
308   result += '\'';
309   return result;
310 }
311 
PrintableString(const char * utf)312 std::string PrintableString(const char* utf) {
313   std::string result;
314   result += '"';
315   const char* p = utf;
316   size_t char_count = CountModifiedUtf8Chars(p);
317   for (size_t i = 0; i < char_count; ++i) {
318     uint32_t ch = GetUtf16FromUtf8(&p);
319     if (ch == '\\') {
320       result += "\\\\";
321     } else if (ch == '\n') {
322       result += "\\n";
323     } else if (ch == '\r') {
324       result += "\\r";
325     } else if (ch == '\t') {
326       result += "\\t";
327     } else {
328       const uint16_t leading = GetLeadingUtf16Char(ch);
329 
330       if (NeedsEscaping(leading)) {
331         StringAppendF(&result, "\\u%04x", leading);
332       } else {
333         result += leading;
334       }
335 
336       const uint32_t trailing = GetTrailingUtf16Char(ch);
337       if (trailing != 0) {
338         // All high surrogates will need escaping.
339         StringAppendF(&result, "\\u%04x", trailing);
340       }
341     }
342   }
343   result += '"';
344   return result;
345 }
346 
GetJniShortName(const std::string & class_descriptor,const std::string & method)347 std::string GetJniShortName(const std::string& class_descriptor, const std::string& method) {
348   // Remove the leading 'L' and trailing ';'...
349   std::string class_name(class_descriptor);
350   CHECK_EQ(class_name[0], 'L') << class_name;
351   CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name;
352   class_name.erase(0, 1);
353   class_name.erase(class_name.size() - 1, 1);
354 
355   std::string short_name;
356   short_name += "Java_";
357   short_name += MangleForJni(class_name);
358   short_name += "_";
359   short_name += MangleForJni(method);
360   return short_name;
361 }
362 
363 // See http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/design.html#wp615 for the full rules.
MangleForJni(const std::string & s)364 std::string MangleForJni(const std::string& s) {
365   std::string result;
366   size_t char_count = CountModifiedUtf8Chars(s.c_str());
367   const char* cp = &s[0];
368   for (size_t i = 0; i < char_count; ++i) {
369     uint32_t ch = GetUtf16FromUtf8(&cp);
370     if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) {
371       result.push_back(ch);
372     } else if (ch == '.' || ch == '/') {
373       result += "_";
374     } else if (ch == '_') {
375       result += "_1";
376     } else if (ch == ';') {
377       result += "_2";
378     } else if (ch == '[') {
379       result += "_3";
380     } else {
381       const uint16_t leading = GetLeadingUtf16Char(ch);
382       const uint32_t trailing = GetTrailingUtf16Char(ch);
383 
384       StringAppendF(&result, "_0%04x", leading);
385       if (trailing != 0) {
386         StringAppendF(&result, "_0%04x", trailing);
387       }
388     }
389   }
390   return result;
391 }
392 
DotToDescriptor(const char * class_name)393 std::string DotToDescriptor(const char* class_name) {
394   std::string descriptor(class_name);
395   std::replace(descriptor.begin(), descriptor.end(), '.', '/');
396   if (descriptor.length() > 0 && descriptor[0] != '[') {
397     descriptor = "L" + descriptor + ";";
398   }
399   return descriptor;
400 }
401 
DescriptorToDot(const char * descriptor)402 std::string DescriptorToDot(const char* descriptor) {
403   size_t length = strlen(descriptor);
404   if (length > 1) {
405     if (descriptor[0] == 'L' && descriptor[length - 1] == ';') {
406       // Descriptors have the leading 'L' and trailing ';' stripped.
407       std::string result(descriptor + 1, length - 2);
408       std::replace(result.begin(), result.end(), '/', '.');
409       return result;
410     } else {
411       // For arrays the 'L' and ';' remain intact.
412       std::string result(descriptor);
413       std::replace(result.begin(), result.end(), '/', '.');
414       return result;
415     }
416   }
417   // Do nothing for non-class/array descriptors.
418   return descriptor;
419 }
420 
DescriptorToName(const char * descriptor)421 std::string DescriptorToName(const char* descriptor) {
422   size_t length = strlen(descriptor);
423   if (descriptor[0] == 'L' && descriptor[length - 1] == ';') {
424     std::string result(descriptor + 1, length - 2);
425     return result;
426   }
427   return descriptor;
428 }
429 
430 // Helper for IsValidPartOfMemberNameUtf8(), a bit vector indicating valid low ascii.
431 uint32_t DEX_MEMBER_VALID_LOW_ASCII[4] = {
432   0x00000000,  // 00..1f low control characters; nothing valid
433   0x03ff2010,  // 20..3f digits and symbols; valid: '0'..'9', '$', '-'
434   0x87fffffe,  // 40..5f uppercase etc.; valid: 'A'..'Z', '_'
435   0x07fffffe   // 60..7f lowercase etc.; valid: 'a'..'z'
436 };
437 
438 // Helper for IsValidPartOfMemberNameUtf8(); do not call directly.
IsValidPartOfMemberNameUtf8Slow(const char ** pUtf8Ptr)439 bool IsValidPartOfMemberNameUtf8Slow(const char** pUtf8Ptr) {
440   /*
441    * It's a multibyte encoded character. Decode it and analyze. We
442    * accept anything that isn't (a) an improperly encoded low value,
443    * (b) an improper surrogate pair, (c) an encoded '\0', (d) a high
444    * control character, or (e) a high space, layout, or special
445    * character (U+00a0, U+2000..U+200f, U+2028..U+202f,
446    * U+fff0..U+ffff). This is all specified in the dex format
447    * document.
448    */
449 
450   const uint32_t pair = GetUtf16FromUtf8(pUtf8Ptr);
451   const uint16_t leading = GetLeadingUtf16Char(pair);
452 
453   // We have a surrogate pair resulting from a valid 4 byte UTF sequence.
454   // No further checks are necessary because 4 byte sequences span code
455   // points [U+10000, U+1FFFFF], which are valid codepoints in a dex
456   // identifier. Furthermore, GetUtf16FromUtf8 guarantees that each of
457   // the surrogate halves are valid and well formed in this instance.
458   if (GetTrailingUtf16Char(pair) != 0) {
459     return true;
460   }
461 
462 
463   // We've encountered a one, two or three byte UTF-8 sequence. The
464   // three byte UTF-8 sequence could be one half of a surrogate pair.
465   switch (leading >> 8) {
466     case 0x00:
467       // It's only valid if it's above the ISO-8859-1 high space (0xa0).
468       return (leading > 0x00a0);
469     case 0xd8:
470     case 0xd9:
471     case 0xda:
472     case 0xdb:
473       {
474         // We found a three byte sequence encoding one half of a surrogate.
475         // Look for the other half.
476         const uint32_t pair2 = GetUtf16FromUtf8(pUtf8Ptr);
477         const uint16_t trailing = GetLeadingUtf16Char(pair2);
478 
479         return (GetTrailingUtf16Char(pair2) == 0) && (0xdc00 <= trailing && trailing <= 0xdfff);
480       }
481     case 0xdc:
482     case 0xdd:
483     case 0xde:
484     case 0xdf:
485       // It's a trailing surrogate, which is not valid at this point.
486       return false;
487     case 0x20:
488     case 0xff:
489       // It's in the range that has spaces, controls, and specials.
490       switch (leading & 0xfff8) {
491         case 0x2000:
492         case 0x2008:
493         case 0x2028:
494         case 0xfff0:
495         case 0xfff8:
496           return false;
497       }
498       return true;
499     default:
500       return true;
501   }
502 
503   UNREACHABLE();
504 }
505 
506 /* Return whether the pointed-at modified-UTF-8 encoded character is
507  * valid as part of a member name, updating the pointer to point past
508  * the consumed character. This will consume two encoded UTF-16 code
509  * points if the character is encoded as a surrogate pair. Also, if
510  * this function returns false, then the given pointer may only have
511  * been partially advanced.
512  */
IsValidPartOfMemberNameUtf8(const char ** pUtf8Ptr)513 static bool IsValidPartOfMemberNameUtf8(const char** pUtf8Ptr) {
514   uint8_t c = (uint8_t) **pUtf8Ptr;
515   if (LIKELY(c <= 0x7f)) {
516     // It's low-ascii, so check the table.
517     uint32_t wordIdx = c >> 5;
518     uint32_t bitIdx = c & 0x1f;
519     (*pUtf8Ptr)++;
520     return (DEX_MEMBER_VALID_LOW_ASCII[wordIdx] & (1 << bitIdx)) != 0;
521   }
522 
523   // It's a multibyte encoded character. Call a non-inline function
524   // for the heavy lifting.
525   return IsValidPartOfMemberNameUtf8Slow(pUtf8Ptr);
526 }
527 
IsValidMemberName(const char * s)528 bool IsValidMemberName(const char* s) {
529   bool angle_name = false;
530 
531   switch (*s) {
532     case '\0':
533       // The empty string is not a valid name.
534       return false;
535     case '<':
536       angle_name = true;
537       s++;
538       break;
539   }
540 
541   while (true) {
542     switch (*s) {
543       case '\0':
544         return !angle_name;
545       case '>':
546         return angle_name && s[1] == '\0';
547     }
548 
549     if (!IsValidPartOfMemberNameUtf8(&s)) {
550       return false;
551     }
552   }
553 }
554 
555 enum ClassNameType { kName, kDescriptor };
556 template<ClassNameType kType, char kSeparator>
IsValidClassName(const char * s)557 static bool IsValidClassName(const char* s) {
558   int arrayCount = 0;
559   while (*s == '[') {
560     arrayCount++;
561     s++;
562   }
563 
564   if (arrayCount > 255) {
565     // Arrays may have no more than 255 dimensions.
566     return false;
567   }
568 
569   ClassNameType type = kType;
570   if (type != kDescriptor && arrayCount != 0) {
571     /*
572      * If we're looking at an array of some sort, then it doesn't
573      * matter if what is being asked for is a class name; the
574      * format looks the same as a type descriptor in that case, so
575      * treat it as such.
576      */
577     type = kDescriptor;
578   }
579 
580   if (type == kDescriptor) {
581     /*
582      * We are looking for a descriptor. Either validate it as a
583      * single-character primitive type, or continue on to check the
584      * embedded class name (bracketed by "L" and ";").
585      */
586     switch (*(s++)) {
587     case 'B':
588     case 'C':
589     case 'D':
590     case 'F':
591     case 'I':
592     case 'J':
593     case 'S':
594     case 'Z':
595       // These are all single-character descriptors for primitive types.
596       return (*s == '\0');
597     case 'V':
598       // Non-array void is valid, but you can't have an array of void.
599       return (arrayCount == 0) && (*s == '\0');
600     case 'L':
601       // Class name: Break out and continue below.
602       break;
603     default:
604       // Oddball descriptor character.
605       return false;
606     }
607   }
608 
609   /*
610    * We just consumed the 'L' that introduces a class name as part
611    * of a type descriptor, or we are looking for an unadorned class
612    * name.
613    */
614 
615   bool sepOrFirst = true;  // first character or just encountered a separator.
616   for (;;) {
617     uint8_t c = (uint8_t) *s;
618     switch (c) {
619     case '\0':
620       /*
621        * Premature end for a type descriptor, but valid for
622        * a class name as long as we haven't encountered an
623        * empty component (including the degenerate case of
624        * the empty string "").
625        */
626       return (type == kName) && !sepOrFirst;
627     case ';':
628       /*
629        * Invalid character for a class name, but the
630        * legitimate end of a type descriptor. In the latter
631        * case, make sure that this is the end of the string
632        * and that it doesn't end with an empty component
633        * (including the degenerate case of "L;").
634        */
635       return (type == kDescriptor) && !sepOrFirst && (s[1] == '\0');
636     case '/':
637     case '.':
638       if (c != kSeparator) {
639         // The wrong separator character.
640         return false;
641       }
642       if (sepOrFirst) {
643         // Separator at start or two separators in a row.
644         return false;
645       }
646       sepOrFirst = true;
647       s++;
648       break;
649     default:
650       if (!IsValidPartOfMemberNameUtf8(&s)) {
651         return false;
652       }
653       sepOrFirst = false;
654       break;
655     }
656   }
657 }
658 
IsValidBinaryClassName(const char * s)659 bool IsValidBinaryClassName(const char* s) {
660   return IsValidClassName<kName, '.'>(s);
661 }
662 
IsValidJniClassName(const char * s)663 bool IsValidJniClassName(const char* s) {
664   return IsValidClassName<kName, '/'>(s);
665 }
666 
IsValidDescriptor(const char * s)667 bool IsValidDescriptor(const char* s) {
668   return IsValidClassName<kDescriptor, '/'>(s);
669 }
670 
Split(const std::string & s,char separator,std::vector<std::string> * result)671 void Split(const std::string& s, char separator, std::vector<std::string>* result) {
672   const char* p = s.data();
673   const char* end = p + s.size();
674   while (p != end) {
675     if (*p == separator) {
676       ++p;
677     } else {
678       const char* start = p;
679       while (++p != end && *p != separator) {
680         // Skip to the next occurrence of the separator.
681       }
682       result->push_back(std::string(start, p - start));
683     }
684   }
685 }
686 
SetThreadName(const char * thread_name)687 void SetThreadName(const char* thread_name) {
688   int hasAt = 0;
689   int hasDot = 0;
690   const char* s = thread_name;
691   while (*s) {
692     if (*s == '.') {
693       hasDot = 1;
694     } else if (*s == '@') {
695       hasAt = 1;
696     }
697     s++;
698   }
699   int len = s - thread_name;
700   if (len < 15 || hasAt || !hasDot) {
701     s = thread_name;
702   } else {
703     s = thread_name + len - 15;
704   }
705 #if defined(__linux__)
706   // pthread_setname_np fails rather than truncating long strings.
707   char buf[16];       // MAX_TASK_COMM_LEN=16 is hard-coded in the kernel.
708   strncpy(buf, s, sizeof(buf)-1);
709   buf[sizeof(buf)-1] = '\0';
710   errno = pthread_setname_np(pthread_self(), buf);
711   if (errno != 0) {
712     PLOG(WARNING) << "Unable to set the name of current thread to '" << buf << "'";
713   }
714 #else  // __APPLE__
715   pthread_setname_np(thread_name);
716 #endif
717 }
718 
GetTaskStats(pid_t tid,char * state,int * utime,int * stime,int * task_cpu)719 void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu) {
720   *utime = *stime = *task_cpu = 0;
721   std::string stats;
722   if (!ReadFileToString(StringPrintf("/proc/self/task/%d/stat", tid), &stats)) {
723     return;
724   }
725   // Skip the command, which may contain spaces.
726   stats = stats.substr(stats.find(')') + 2);
727   // Extract the three fields we care about.
728   std::vector<std::string> fields;
729   Split(stats, ' ', &fields);
730   *state = fields[0][0];
731   *utime = strtoull(fields[11].c_str(), nullptr, 10);
732   *stime = strtoull(fields[12].c_str(), nullptr, 10);
733   *task_cpu = strtoull(fields[36].c_str(), nullptr, 10);
734 }
735 
GetAndroidDirSafe(const char * env_var,const char * default_dir,std::string * error_msg)736 static const char* GetAndroidDirSafe(const char* env_var,
737                                      const char* default_dir,
738                                      std::string* error_msg) {
739   const char* android_dir = getenv(env_var);
740   if (android_dir == nullptr) {
741     if (OS::DirectoryExists(default_dir)) {
742       android_dir = default_dir;
743     } else {
744       *error_msg = StringPrintf("%s not set and %s does not exist", env_var, default_dir);
745       return nullptr;
746     }
747   }
748   if (!OS::DirectoryExists(android_dir)) {
749     *error_msg = StringPrintf("Failed to find %s directory %s", env_var, android_dir);
750     return nullptr;
751   }
752   return android_dir;
753 }
754 
GetAndroidDir(const char * env_var,const char * default_dir)755 const char* GetAndroidDir(const char* env_var, const char* default_dir) {
756   std::string error_msg;
757   const char* dir = GetAndroidDirSafe(env_var, default_dir, &error_msg);
758   if (dir != nullptr) {
759     return dir;
760   } else {
761     LOG(FATAL) << error_msg;
762     return nullptr;
763   }
764 }
765 
GetAndroidRoot()766 const char* GetAndroidRoot() {
767   return GetAndroidDir("ANDROID_ROOT", "/system");
768 }
769 
GetAndroidRootSafe(std::string * error_msg)770 const char* GetAndroidRootSafe(std::string* error_msg) {
771   return GetAndroidDirSafe("ANDROID_ROOT", "/system", error_msg);
772 }
773 
GetAndroidData()774 const char* GetAndroidData() {
775   return GetAndroidDir("ANDROID_DATA", "/data");
776 }
777 
GetAndroidDataSafe(std::string * error_msg)778 const char* GetAndroidDataSafe(std::string* error_msg) {
779   return GetAndroidDirSafe("ANDROID_DATA", "/data", error_msg);
780 }
781 
GetDefaultBootImageLocation(std::string * error_msg)782 std::string GetDefaultBootImageLocation(std::string* error_msg) {
783   const char* android_root = GetAndroidRootSafe(error_msg);
784   if (android_root == nullptr) {
785     return "";
786   }
787   return StringPrintf("%s/framework/boot.art", android_root);
788 }
789 
GetDalvikCache(const char * subdir,const bool create_if_absent,std::string * dalvik_cache,bool * have_android_data,bool * dalvik_cache_exists,bool * is_global_cache)790 void GetDalvikCache(const char* subdir, const bool create_if_absent, std::string* dalvik_cache,
791                     bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache) {
792   CHECK(subdir != nullptr);
793   std::string error_msg;
794   const char* android_data = GetAndroidDataSafe(&error_msg);
795   if (android_data == nullptr) {
796     *have_android_data = false;
797     *dalvik_cache_exists = false;
798     *is_global_cache = false;
799     return;
800   } else {
801     *have_android_data = true;
802   }
803   const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data));
804   *dalvik_cache = dalvik_cache_root + subdir;
805   *dalvik_cache_exists = OS::DirectoryExists(dalvik_cache->c_str());
806   *is_global_cache = strcmp(android_data, "/data") == 0;
807   if (create_if_absent && !*dalvik_cache_exists && !*is_global_cache) {
808     // Don't create the system's /data/dalvik-cache/... because it needs special permissions.
809     *dalvik_cache_exists = ((mkdir(dalvik_cache_root.c_str(), 0700) == 0 || errno == EEXIST) &&
810                             (mkdir(dalvik_cache->c_str(), 0700) == 0 || errno == EEXIST));
811   }
812 }
813 
GetDalvikCache(const char * subdir)814 std::string GetDalvikCache(const char* subdir) {
815   CHECK(subdir != nullptr);
816   const char* android_data = GetAndroidData();
817   const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data));
818   const std::string dalvik_cache = dalvik_cache_root + subdir;
819   if (!OS::DirectoryExists(dalvik_cache.c_str())) {
820     // TODO: Check callers. Traditional behavior is to not abort.
821     return "";
822   }
823   return dalvik_cache;
824 }
825 
GetDalvikCacheFilename(const char * location,const char * cache_location,std::string * filename,std::string * error_msg)826 bool GetDalvikCacheFilename(const char* location, const char* cache_location,
827                             std::string* filename, std::string* error_msg) {
828   if (location[0] != '/') {
829     *error_msg = StringPrintf("Expected path in location to be absolute: %s", location);
830     return false;
831   }
832   std::string cache_file(&location[1]);  // skip leading slash
833   if (!android::base::EndsWith(location, ".dex") &&
834       !android::base::EndsWith(location, ".art") &&
835       !android::base::EndsWith(location, ".oat")) {
836     cache_file += "/";
837     cache_file += DexFile::kClassesDex;
838   }
839   std::replace(cache_file.begin(), cache_file.end(), '/', '@');
840   *filename = StringPrintf("%s/%s", cache_location, cache_file.c_str());
841   return true;
842 }
843 
GetVdexFilename(const std::string & oat_location)844 std::string GetVdexFilename(const std::string& oat_location) {
845   return ReplaceFileExtension(oat_location, "vdex");
846 }
847 
InsertIsaDirectory(const InstructionSet isa,std::string * filename)848 static void InsertIsaDirectory(const InstructionSet isa, std::string* filename) {
849   // in = /foo/bar/baz
850   // out = /foo/bar/<isa>/baz
851   size_t pos = filename->rfind('/');
852   CHECK_NE(pos, std::string::npos) << *filename << " " << isa;
853   filename->insert(pos, "/", 1);
854   filename->insert(pos + 1, GetInstructionSetString(isa));
855 }
856 
GetSystemImageFilename(const char * location,const InstructionSet isa)857 std::string GetSystemImageFilename(const char* location, const InstructionSet isa) {
858   // location = /system/framework/boot.art
859   // filename = /system/framework/<isa>/boot.art
860   std::string filename(location);
861   InsertIsaDirectory(isa, &filename);
862   return filename;
863 }
864 
FileExists(const std::string & filename)865 bool FileExists(const std::string& filename) {
866   struct stat buffer;
867   return stat(filename.c_str(), &buffer) == 0;
868 }
869 
FileExistsAndNotEmpty(const std::string & filename)870 bool FileExistsAndNotEmpty(const std::string& filename) {
871   struct stat buffer;
872   if (stat(filename.c_str(), &buffer) != 0) {
873     return false;
874   }
875   return buffer.st_size > 0;
876 }
877 
ReplaceFileExtension(const std::string & filename,const std::string & new_extension)878 std::string ReplaceFileExtension(const std::string& filename, const std::string& new_extension) {
879   const size_t last_ext = filename.find_last_of('.');
880   if (last_ext == std::string::npos) {
881     return filename + "." + new_extension;
882   } else {
883     return filename.substr(0, last_ext + 1) + new_extension;
884   }
885 }
886 
PrettyDescriptor(Primitive::Type type)887 std::string PrettyDescriptor(Primitive::Type type) {
888   return PrettyDescriptor(Primitive::Descriptor(type));
889 }
890 
ParseStringAfterChar(const std::string & s,char c,std::string * parsed_value,UsageFn Usage)891 static void ParseStringAfterChar(const std::string& s,
892                                  char c,
893                                  std::string* parsed_value,
894                                  UsageFn Usage) {
895   std::string::size_type colon = s.find(c);
896   if (colon == std::string::npos) {
897     Usage("Missing char %c in option %s\n", c, s.c_str());
898   }
899   // Add one to remove the char we were trimming until.
900   *parsed_value = s.substr(colon + 1);
901 }
902 
ParseDouble(const std::string & option,char after_char,double min,double max,double * parsed_value,UsageFn Usage)903 void ParseDouble(const std::string& option,
904                  char after_char,
905                  double min,
906                  double max,
907                  double* parsed_value,
908                  UsageFn Usage) {
909   std::string substring;
910   ParseStringAfterChar(option, after_char, &substring, Usage);
911   bool sane_val = true;
912   double value;
913   if ((false)) {
914     // TODO: this doesn't seem to work on the emulator.  b/15114595
915     std::stringstream iss(substring);
916     iss >> value;
917     // Ensure that we have a value, there was no cruft after it and it satisfies a sensible range.
918     sane_val = iss.eof() && (value >= min) && (value <= max);
919   } else {
920     char* end = nullptr;
921     value = strtod(substring.c_str(), &end);
922     sane_val = *end == '\0' && value >= min && value <= max;
923   }
924   if (!sane_val) {
925     Usage("Invalid double value %s for option %s\n", substring.c_str(), option.c_str());
926   }
927   *parsed_value = value;
928 }
929 
GetFileSizeBytes(const std::string & filename)930 int64_t GetFileSizeBytes(const std::string& filename) {
931   struct stat stat_buf;
932   int rc = stat(filename.c_str(), &stat_buf);
933   return rc == 0 ? stat_buf.st_size : -1;
934 }
935 
SleepForever()936 void SleepForever() {
937   while (true) {
938     usleep(1000000);
939   }
940 }
941 
942 }  // namespace art
943