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
34constexpr int SLEEP_TIME_USEC = 50000;          // 0.05 seconds
35constexpr int MAX_TOTAL_SLEEP_USEC = 10000000;  // 10 seconds
36
37// Whitelist output desired in the logcat output.
38bool 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
47void _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
77int 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
108void 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