1 /* 2 * Copyright 2008, 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 #define LOG_TAG "DEBUG" 18 19 #include "utility.h" 20 21 #include <errno.h> 22 #include <signal.h> 23 #include <string.h> 24 #include <unistd.h> 25 #include <sys/ptrace.h> 26 #include <sys/wait.h> 27 28 #include <string> 29 30 #include <android-base/stringprintf.h> 31 #include <backtrace/Backtrace.h> 32 #include <log/log.h> 33 34 constexpr int SLEEP_TIME_USEC = 50000; // 0.05 seconds 35 constexpr int MAX_TOTAL_SLEEP_USEC = 10000000; // 10 seconds 36 37 // Whitelist output desired in the logcat output. 38 bool is_allowed_in_logcat(enum logtype ltype) { 39 if ((ltype == HEADER) 40 || (ltype == REGISTERS) 41 || (ltype == BACKTRACE)) { 42 return true; 43 } 44 return false; 45 } 46 47 void _LOG(log_t* log, enum logtype ltype, const char* fmt, ...) { 48 bool write_to_tombstone = (log->tfd != -1); 49 bool write_to_logcat = is_allowed_in_logcat(ltype) 50 && log->crashed_tid != -1 51 && log->current_tid != -1 52 && (log->crashed_tid == log->current_tid); 53 54 char buf[512]; 55 va_list ap; 56 va_start(ap, fmt); 57 vsnprintf(buf, sizeof(buf), fmt, ap); 58 va_end(ap); 59 60 size_t len = strlen(buf); 61 if (len <= 0) { 62 return; 63 } 64 65 if (write_to_tombstone) { 66 TEMP_FAILURE_RETRY(write(log->tfd, buf, len)); 67 } 68 69 if (write_to_logcat) { 70 __android_log_buf_write(LOG_ID_CRASH, ANDROID_LOG_FATAL, LOG_TAG, buf); 71 if (log->amfd_data != nullptr) { 72 *log->amfd_data += buf; 73 } 74 } 75 } 76 77 int wait_for_signal(pid_t tid, int* total_sleep_time_usec) { 78 while (true) { 79 int status; 80 pid_t n = TEMP_FAILURE_RETRY(waitpid(tid, &status, __WALL | WNOHANG)); 81 if (n == -1) { 82 ALOGE("waitpid failed: tid %d, %s", tid, strerror(errno)); 83 return -1; 84 } else if (n == tid) { 85 if (WIFSTOPPED(status)) { 86 return WSTOPSIG(status); 87 } else { 88 ALOGE("unexpected waitpid response: n=%d, status=%08x\n", n, status); 89 // This is the only circumstance under which we can allow a detach 90 // to fail with ESRCH, which indicates the tid has exited. 91 return -1; 92 } 93 } 94 95 if (*total_sleep_time_usec > MAX_TOTAL_SLEEP_USEC) { 96 ALOGE("timed out waiting for stop signal: tid=%d", tid); 97 return -1; 98 } 99 100 usleep(SLEEP_TIME_USEC); 101 *total_sleep_time_usec += SLEEP_TIME_USEC; 102 } 103 } 104 105 #define MEMORY_BYTES_TO_DUMP 256 106 #define MEMORY_BYTES_PER_LINE 16 107 108 void dump_memory(log_t* log, Backtrace* backtrace, uintptr_t addr, const char* fmt, ...) { 109 std::string log_msg; 110 va_list ap; 111 va_start(ap, fmt); 112 android::base::StringAppendV(&log_msg, fmt, ap); 113 va_end(ap); 114 115 // Align the address to sizeof(long) and start 32 bytes before the address. 116 addr &= ~(sizeof(long) - 1); 117 if (addr >= 4128) { 118 addr -= 32; 119 } 120 121 // Don't bother if the address looks too low, or looks too high. 122 if (addr < 4096 || 123 #if defined(__LP64__) 124 addr > 0x4000000000000000UL - MEMORY_BYTES_TO_DUMP) { 125 #else 126 addr > 0xffff0000 - MEMORY_BYTES_TO_DUMP) { 127 #endif 128 return; 129 } 130 131 _LOG(log, logtype::MEMORY, "\n%s\n", log_msg.c_str()); 132 133 // Dump 256 bytes 134 uintptr_t data[MEMORY_BYTES_TO_DUMP/sizeof(uintptr_t)]; 135 memset(data, 0, MEMORY_BYTES_TO_DUMP); 136 size_t bytes = backtrace->Read(addr, reinterpret_cast<uint8_t*>(data), sizeof(data)); 137 if (bytes % sizeof(uintptr_t) != 0) { 138 // This should never happen, but just in case. 139 ALOGE("Bytes read %zu, is not a multiple of %zu", bytes, sizeof(uintptr_t)); 140 bytes &= ~(sizeof(uintptr_t) - 1); 141 } 142 143 uintptr_t start = 0; 144 bool skip_2nd_read = false; 145 if (bytes == 0) { 146 // In this case, we might want to try another read at the beginning of 147 // the next page only if it's within the amount of memory we would have 148 // read. 149 size_t page_size = sysconf(_SC_PAGE_SIZE); 150 start = ((addr + (page_size - 1)) & ~(page_size - 1)) - addr; 151 if (start == 0 || start >= MEMORY_BYTES_TO_DUMP) { 152 skip_2nd_read = true; 153 } 154 } 155 156 if (bytes < MEMORY_BYTES_TO_DUMP && !skip_2nd_read) { 157 // Try to do one more read. This could happen if a read crosses a map, 158 // but the maps do not have any break between them. Or it could happen 159 // if reading from an unreadable map, but the read would cross back 160 // into a readable map. Only requires one extra read because a map has 161 // to contain at least one page, and the total number of bytes to dump 162 // is smaller than a page. 163 size_t bytes2 = backtrace->Read(addr + start + bytes, reinterpret_cast<uint8_t*>(data) + bytes, 164 sizeof(data) - bytes - start); 165 bytes += bytes2; 166 if (bytes2 > 0 && bytes % sizeof(uintptr_t) != 0) { 167 // This should never happen, but we'll try and continue any way. 168 ALOGE("Bytes after second read %zu, is not a multiple of %zu", bytes, sizeof(uintptr_t)); 169 bytes &= ~(sizeof(uintptr_t) - 1); 170 } 171 } 172 173 // Dump the code around memory as: 174 // addr contents ascii 175 // 0000000000008d34 ef000000e8bd0090 e1b00000512fff1e ............../Q 176 // 0000000000008d44 ea00b1f9e92d0090 e3a070fcef000000 ......-..p...... 177 // On 32-bit machines, there are still 16 bytes per line but addresses and 178 // words are of course presented differently. 179 uintptr_t* data_ptr = data; 180 size_t current = 0; 181 size_t total_bytes = start + bytes; 182 for (size_t line = 0; line < MEMORY_BYTES_TO_DUMP / MEMORY_BYTES_PER_LINE; line++) { 183 std::string logline; 184 android::base::StringAppendF(&logline, " %" PRIPTR, addr); 185 186 addr += MEMORY_BYTES_PER_LINE; 187 std::string ascii; 188 for (size_t i = 0; i < MEMORY_BYTES_PER_LINE / sizeof(uintptr_t); i++) { 189 if (current >= start && current + sizeof(uintptr_t) <= total_bytes) { 190 android::base::StringAppendF(&logline, " %" PRIPTR, *data_ptr); 191 192 // Fill out the ascii string from the data. 193 uint8_t* ptr = reinterpret_cast<uint8_t*>(data_ptr); 194 for (size_t val = 0; val < sizeof(uintptr_t); val++, ptr++) { 195 if (*ptr >= 0x20 && *ptr < 0x7f) { 196 ascii += *ptr; 197 } else { 198 ascii += '.'; 199 } 200 } 201 data_ptr++; 202 } else { 203 logline += ' ' + std::string(sizeof(uintptr_t) * 2, '-'); 204 ascii += std::string(sizeof(uintptr_t), '.'); 205 } 206 current += sizeof(uintptr_t); 207 } 208 _LOG(log, logtype::MEMORY, "%s %s\n", logline.c_str(), ascii.c_str()); 209 } 210 } 211
