blob: ce83509296e7840aaf1bc3cb04f2beb3bbae3d30 [file] [log] [blame]
Colin Crossf45fa6b2012-03-26 12:38:26 -07001/*
2 * Copyright (C) 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 */
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070016#define LOG_TAG "dumpstate"
Colin Crossf45fa6b2012-03-26 12:38:26 -070017
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -070018#include <dirent.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070019#include <errno.h>
20#include <fcntl.h>
Felipe Lemead5f6c42015-11-30 14:26:46 -080021#include <libgen.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070022#include <limits.h>
Felipe Leme6e01fa62015-11-11 19:35:14 -080023#include <memory>
Felipe Lemead5f6c42015-11-30 14:26:46 -080024#include <regex>
Felipe Leme635ca312016-01-05 14:23:02 -080025#include <set>
Wei Liuf87959e2016-08-26 14:51:42 -070026#include <signal.h>
Mark Salyzyn8f37aa52015-06-12 12:28:24 -070027#include <stdbool.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070028#include <stdio.h>
29#include <stdlib.h>
Felipe Leme6e01fa62015-11-11 19:35:14 -080030#include <string>
Colin Crossf45fa6b2012-03-26 12:38:26 -070031#include <string.h>
Christopher Ferris7dc7f322014-07-22 16:08:19 -070032#include <sys/prctl.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070033#include <sys/resource.h>
34#include <sys/stat.h>
35#include <sys/time.h>
36#include <sys/wait.h>
37#include <unistd.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070038
Felipe Leme96c2bbb2016-09-26 09:21:21 -070039#include <android-base/file.h>
40#include <android-base/properties.h>
Elliott Hughes9dc117c2015-12-07 14:21:50 -080041#include <android-base/stringprintf.h>
Naveen Kalla058e1e82016-10-19 21:38:44 -070042#include <android-base/strings.h>
Andreas Gampeaff68432016-07-18 18:01:27 -070043#include <android-base/unique_fd.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070044#include <cutils/properties.h>
Wei Liuf87959e2016-08-26 14:51:42 -070045#include <hardware_legacy/power.h>
Felipe Leme75876a22016-10-27 16:31:27 -070046#include <openssl/sha.h>
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070047#include <private/android_filesystem_config.h>
48#include <private/android_logger.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070049
Felipe Leme75876a22016-10-27 16:31:27 -070050#include "DumpstateService.h"
Colin Crossf45fa6b2012-03-26 12:38:26 -070051#include "dumpstate.h"
Felipe Leme6e01fa62015-11-11 19:35:14 -080052
Colin Crossf45fa6b2012-03-26 12:38:26 -070053/* read before root is shed */
54static char cmdline_buf[16384] = "(unknown)";
55static const char *dump_traces_path = NULL;
56
Felipe Leme1d486fe2016-10-14 18:06:47 -070057// TODO: variables and functions below should be part of dumpstate object
58
Felipe Leme635ca312016-01-05 14:23:02 -080059static std::set<std::string> mount_points;
60void add_mountinfo();
Felipe Leme78f2c862015-12-21 09:55:22 -080061
Todd Poynor2a83daa2013-11-22 15:44:22 -080062#define PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops"
Mark Salyzyn7d0a7622016-06-24 14:06:15 -070063#define ALT_PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops-0"
Todd Poynor2a83daa2013-11-22 15:44:22 -080064
Wei Liu341938b2016-04-27 16:18:17 -070065#define RAFT_DIR "/data/misc/raft"
Felipe Lemee82a27d2016-01-05 13:35:44 -080066#define RECOVERY_DIR "/cache/recovery"
Mark Salyzynd6ab0112016-03-25 12:56:39 -070067#define RECOVERY_DATA_DIR "/data/misc/recovery"
Mark Salyzyn4d42dea2016-04-01 10:03:14 -070068#define LOGPERSIST_DATA_DIR "/data/misc/logd"
David Brazdild2991962016-06-03 14:40:44 +010069#define PROFILE_DATA_DIR_CUR "/data/misc/profiles/cur"
70#define PROFILE_DATA_DIR_REF "/data/misc/profiles/ref"
Christopher Ferris7dc7f322014-07-22 16:08:19 -070071#define TOMBSTONE_DIR "/data/tombstones"
72#define TOMBSTONE_FILE_PREFIX TOMBSTONE_DIR "/tombstone_"
73/* Can accomodate a tombstone number up to 9999. */
74#define TOMBSTONE_MAX_LEN (sizeof(TOMBSTONE_FILE_PREFIX) + 4)
75#define NUM_TOMBSTONES 10
Erik Kline08165202016-05-30 11:55:44 +090076#define WLUTIL "/vendor/xbin/wlutil"
Wei Liuf87959e2016-08-26 14:51:42 -070077#define WAKE_LOCK_NAME "dumpstate_wakelock"
Christopher Ferris7dc7f322014-07-22 16:08:19 -070078
79typedef struct {
80 char name[TOMBSTONE_MAX_LEN];
81 int fd;
82} tombstone_data_t;
83
84static tombstone_data_t tombstone_data[NUM_TOMBSTONES];
85
Felipe Lemee844a9d2016-09-21 15:01:39 -070086// TODO: temporary variables and functions used during C++ refactoring
87static Dumpstate& ds = Dumpstate::GetInstance();
Felipe Leme678727a2016-09-21 17:22:11 -070088static int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
89 const CommandOptions& options = CommandOptions::DEFAULT) {
90 return ds.RunCommand(title, fullCommand, options);
91}
92static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
Felipe Lemebda15a02016-11-16 17:48:25 -080093 const CommandOptions& options = Dumpstate::DEFAULT_DUMPSYS,
Felipe Leme678727a2016-09-21 17:22:11 -070094 long dumpsysTimeout = 0) {
95 return ds.RunDumpsys(title, dumpsysArgs, options, dumpsysTimeout);
96}
97static int DumpFile(const std::string& title, const std::string& path) {
98 return ds.DumpFile(title, path);
99}
Felipe Leme6ad9c062016-09-28 11:58:36 -0700100bool IsUserBuild() {
101 return ds.IsUserBuild();
102}
Felipe Lemee82a27d2016-01-05 13:35:44 -0800103
Felipe Lemee844a9d2016-09-21 15:01:39 -0700104// Relative directory (inside the zip) for all files copied as-is into the bugreport.
105static const std::string ZIP_ROOT_DIR = "FS";
106
Felipe Leme9ce6aa42016-09-21 10:02:25 -0700107static constexpr char PROPERTY_EXTRA_OPTIONS[] = "dumpstate.options";
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700108static constexpr char PROPERTY_LAST_ID[] = "dumpstate.last_id";
Felipe Lemed071c682016-10-20 16:48:00 -0700109static constexpr char PROPERTY_VERSION[] = "dumpstate.version";
Felipe Leme9ce6aa42016-09-21 10:02:25 -0700110
Felipe Leme3d305a12016-05-20 11:24:37 -0700111/* gets the tombstone data, according to the bugreport type: if zipped, gets all tombstones;
112 * otherwise, gets just those modified in the last half an hour. */
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700113static void get_tombstone_fds(tombstone_data_t data[NUM_TOMBSTONES]) {
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700114 time_t thirty_minutes_ago = ds.now_ - 60 * 30;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700115 for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
116 snprintf(data[i].name, sizeof(data[i].name), "%s%02zu", TOMBSTONE_FILE_PREFIX, i);
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800117 int fd = TEMP_FAILURE_RETRY(open(data[i].name,
118 O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700119 struct stat st;
Felipe Leme3d305a12016-05-20 11:24:37 -0700120 if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode) && st.st_size > 0 &&
Felipe Leme1d486fe2016-10-14 18:06:47 -0700121 (ds.IsZipping() || st.st_mtime >= thirty_minutes_ago)) {
Felipe Leme3d305a12016-05-20 11:24:37 -0700122 data[i].fd = fd;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700123 } else {
Felipe Leme3d305a12016-05-20 11:24:37 -0700124 close(fd);
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700125 data[i].fd = -1;
126 }
127 }
128}
129
Felipe Leme635ca312016-01-05 14:23:02 -0800130// for_each_pid() callback to get mount info about a process.
Felipe Leme4c2d6632016-09-28 14:32:00 -0700131void do_mountinfo(int pid, const char* name __attribute__((unused))) {
Felipe Leme635ca312016-01-05 14:23:02 -0800132 char path[PATH_MAX];
133
134 // Gets the the content of the /proc/PID/ns/mnt link, so only unique mount points
135 // are added.
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700136 snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800137 char linkname[PATH_MAX];
138 ssize_t r = readlink(path, linkname, PATH_MAX);
139 if (r == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800140 MYLOGE("Unable to read link for %s: %s\n", path, strerror(errno));
Felipe Leme635ca312016-01-05 14:23:02 -0800141 return;
142 }
143 linkname[r] = '\0';
144
145 if (mount_points.find(linkname) == mount_points.end()) {
146 // First time this mount point was found: add it
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700147 snprintf(path, sizeof(path), "/proc/%d/mountinfo", pid);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700148 if (ds.AddZipEntry(ZIP_ROOT_DIR + path, path)) {
Felipe Leme635ca312016-01-05 14:23:02 -0800149 mount_points.insert(linkname);
150 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800151 MYLOGE("Unable to add mountinfo %s to zip file\n", path);
Felipe Leme635ca312016-01-05 14:23:02 -0800152 }
153 }
154}
155
156void add_mountinfo() {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700157 if (!ds.IsZipping()) return;
Felipe Leme678727a2016-09-21 17:22:11 -0700158 std::string title = "MOUNT INFO";
Felipe Leme635ca312016-01-05 14:23:02 -0800159 mount_points.clear();
Felipe Leme9a523ae2016-10-20 15:10:33 -0700160 DurationReporter duration_reporter(title, nullptr);
Felipe Leme678727a2016-09-21 17:22:11 -0700161 for_each_pid(do_mountinfo, nullptr);
162 MYLOGD("%s: %d entries added to zip file\n", title.c_str(), (int)mount_points.size());
Felipe Leme635ca312016-01-05 14:23:02 -0800163}
164
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700165static void dump_dev_files(const char *title, const char *driverpath, const char *filename)
166{
167 DIR *d;
168 struct dirent *de;
169 char path[PATH_MAX];
170
171 d = opendir(driverpath);
172 if (d == NULL) {
173 return;
174 }
175
176 while ((de = readdir(d))) {
177 if (de->d_type != DT_LNK) {
178 continue;
179 }
180 snprintf(path, sizeof(path), "%s/%s/%s", driverpath, de->d_name, filename);
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700181 DumpFile(title, path);
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700182 }
183
184 closedir(d);
185}
186
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700187// return pid of a userspace process. If not found or error, return 0.
188static unsigned int pid_of_process(const char* ps_name) {
189 DIR *proc_dir;
190 struct dirent *ps;
191 unsigned int pid;
192 std::string cmdline;
193
194 if (!(proc_dir = opendir("/proc"))) {
195 MYLOGE("Can't open /proc\n");
196 return 0;
197 }
198
199 while ((ps = readdir(proc_dir))) {
200 if (!(pid = atoi(ps->d_name))) {
201 continue;
202 }
203 android::base::ReadFileToString("/proc/"
204 + std::string(ps->d_name) + "/cmdline", &cmdline);
205 if (cmdline.find(ps_name) == std::string::npos) {
206 continue;
207 } else {
208 closedir(proc_dir);
209 return pid;
210 }
211 }
212 closedir(proc_dir);
213 return 0;
214}
215
216// dump anrd's trace and add to the zip file.
217// 1. check if anrd is running on this device.
218// 2. send a SIGUSR1 to its pid which will dump anrd's trace.
219// 3. wait until the trace generation completes and add to the zip file.
220static bool dump_anrd_trace() {
221 unsigned int pid;
222 char buf[50], path[PATH_MAX];
223 struct dirent *trace;
224 struct stat st;
225 DIR *trace_dir;
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700226 int retry = 5;
227 long max_ctime = 0, old_mtime;
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700228 long long cur_size = 0;
229 const char *trace_path = "/data/misc/anrd/";
230
Felipe Leme1d486fe2016-10-14 18:06:47 -0700231 if (!ds.IsZipping()) {
232 MYLOGE("Not dumping anrd trace because it's not a zipped bugreport\n");
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700233 return false;
234 }
235
236 // find anrd's pid if it is running.
237 pid = pid_of_process("/system/xbin/anrd");
238
239 if (pid > 0) {
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700240 if (stat(trace_path, &st) == 0) {
241 old_mtime = st.st_mtime;
242 } else {
243 MYLOGE("Failed to find: %s\n", trace_path);
244 return false;
245 }
246
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700247 // send SIGUSR1 to the anrd to generate a trace.
248 sprintf(buf, "%u", pid);
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700249 if (RunCommand("ANRD_DUMP", {"kill", "-SIGUSR1", buf},
Felipe Leme30dbfa12016-09-02 12:43:26 -0700250 CommandOptions::WithTimeout(1).Build())) {
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700251 MYLOGE("anrd signal timed out. Please manually collect trace\n");
252 return false;
253 }
254
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700255 while (retry-- > 0 && old_mtime == st.st_mtime) {
256 sleep(1);
257 stat(trace_path, &st);
258 }
259
260 if (retry < 0 && old_mtime == st.st_mtime) {
261 MYLOGE("Failed to stat %s or trace creation timeout\n", trace_path);
262 return false;
263 }
264
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700265 // identify the trace file by its creation time.
266 if (!(trace_dir = opendir(trace_path))) {
267 MYLOGE("Can't open trace file under %s\n", trace_path);
268 }
269 while ((trace = readdir(trace_dir))) {
270 if (strcmp(trace->d_name, ".") == 0
271 || strcmp(trace->d_name, "..") == 0) {
272 continue;
273 }
274 sprintf(path, "%s%s", trace_path, trace->d_name);
275 if (stat(path, &st) == 0) {
276 if (st.st_ctime > max_ctime) {
277 max_ctime = st.st_ctime;
278 sprintf(buf, "%s", trace->d_name);
279 }
280 }
281 }
282 closedir(trace_dir);
283
284 // Wait until the dump completes by checking the size of the trace.
285 if (max_ctime > 0) {
286 sprintf(path, "%s%s", trace_path, buf);
287 while(true) {
288 sleep(1);
289 if (stat(path, &st) == 0) {
290 if (st.st_size == cur_size) {
291 break;
292 } else if (st.st_size > cur_size) {
293 cur_size = st.st_size;
294 } else {
295 return false;
296 }
297 } else {
298 MYLOGE("Cant stat() %s anymore\n", path);
299 return false;
300 }
301 }
302 // Add to the zip file.
Felipe Leme1d486fe2016-10-14 18:06:47 -0700303 if (!ds.AddZipEntry("anrd_trace.txt", path)) {
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700304 MYLOGE("Unable to add anrd_trace file %s to zip file\n", path);
305 } else {
306 if (remove(path)) {
307 MYLOGE("Error removing anrd_trace file %s: %s", path, strerror(errno));
308 }
309 return true;
310 }
311 } else {
312 MYLOGE("Can't stats any trace file under %s\n", trace_path);
313 }
314 }
315 return false;
316}
317
Felipe Lemeefd7e272016-05-18 09:27:16 -0700318static void dump_systrace() {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700319 if (!ds.IsZipping()) {
320 MYLOGD("Not dumping systrace because it's not a zipped bugreport\n");
Felipe Leme71a74ac2016-03-17 15:43:25 -0700321 return;
322 }
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700323 std::string systrace_path = ds.GetPath("-systrace.txt");
Felipe Leme14e034a2016-03-30 18:51:03 -0700324 if (systrace_path.empty()) {
325 MYLOGE("Not dumping systrace because path is empty\n");
326 return;
327 }
Felipe Leme71a74ac2016-03-17 15:43:25 -0700328 const char* path = "/sys/kernel/debug/tracing/tracing_on";
329 long int is_tracing;
330 if (read_file_as_long(path, &is_tracing)) {
331 return; // error already logged
332 }
333 if (is_tracing <= 0) {
334 MYLOGD("Skipping systrace because '%s' content is '%ld'\n", path, is_tracing);
335 return;
336 }
337
Felipe Leme14e034a2016-03-30 18:51:03 -0700338 MYLOGD("Running '/system/bin/atrace --async_dump -o %s', which can take several minutes",
339 systrace_path.c_str());
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700340 if (RunCommand("SYSTRACE", {"/system/bin/atrace", "--async_dump", "-o", systrace_path},
Felipe Leme30dbfa12016-09-02 12:43:26 -0700341 CommandOptions::WithTimeout(120).Build())) {
Felipe Leme14e034a2016-03-30 18:51:03 -0700342 MYLOGE("systrace timed out, its zip entry will be incomplete\n");
Felipe Lemec7fe8fe2016-09-21 18:13:20 -0700343 // TODO: RunCommand tries to kill the process, but atrace doesn't die
Felipe Leme30dbfa12016-09-02 12:43:26 -0700344 // peacefully; ideally, we should call strace to stop itself, but there is no such option
345 // yet (just a --async_stop, which stops and dump
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700346 // if (RunCommand("SYSTRACE", {"/system/bin/atrace", "--kill"})) {
Felipe Leme30dbfa12016-09-02 12:43:26 -0700347 // MYLOGE("could not stop systrace ");
348 // }
Felipe Leme14e034a2016-03-30 18:51:03 -0700349 }
Felipe Leme1d486fe2016-10-14 18:06:47 -0700350 if (!ds.AddZipEntry("systrace.txt", systrace_path)) {
Felipe Leme14e034a2016-03-30 18:51:03 -0700351 MYLOGE("Unable to add systrace file %s to zip file\n", systrace_path.c_str());
Felipe Leme71a74ac2016-03-17 15:43:25 -0700352 } else {
Felipe Leme14e034a2016-03-30 18:51:03 -0700353 if (remove(systrace_path.c_str())) {
354 MYLOGE("Error removing systrace file %s: %s", systrace_path.c_str(), strerror(errno));
355 }
Felipe Leme71a74ac2016-03-17 15:43:25 -0700356 }
357}
358
Felipe Lemeefd7e272016-05-18 09:27:16 -0700359static void dump_raft() {
Felipe Leme6ad9c062016-09-28 11:58:36 -0700360 if (IsUserBuild()) {
Wei Liu341938b2016-04-27 16:18:17 -0700361 return;
362 }
363
Felipe Leme1d486fe2016-10-14 18:06:47 -0700364 std::string raft_path = ds.GetPath("-raft_log.txt");
365 if (raft_path.empty()) {
366 MYLOGD("raft_path is empty\n");
Wei Liu341938b2016-04-27 16:18:17 -0700367 return;
368 }
Wei Liuf0e78d42016-05-25 14:21:02 -0700369
370 struct stat s;
371 if (stat(RAFT_DIR, &s) != 0 || !S_ISDIR(s.st_mode)) {
372 MYLOGD("%s does not exist or is not a directory\n", RAFT_DIR);
373 return;
374 }
375
Felipe Leme30dbfa12016-09-02 12:43:26 -0700376 CommandOptions options = CommandOptions::WithTimeout(600).Build();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700377 if (!ds.IsZipping()) {
378 // Write compressed and encoded raft logs to stdout if it's not a zipped bugreport.
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700379 RunCommand("RAFT LOGS", {"logcompressor", "-r", RAFT_DIR}, options);
Wei Liu341938b2016-04-27 16:18:17 -0700380 return;
381 }
382
Felipe Leme1d486fe2016-10-14 18:06:47 -0700383 RunCommand("RAFT LOGS", {"logcompressor", "-n", "-r", RAFT_DIR, "-o", raft_path}, options);
384 if (!ds.AddZipEntry("raft_log.txt", raft_path)) {
385 MYLOGE("Unable to add raft log %s to zip file\n", raft_path.c_str());
Wei Liu341938b2016-04-27 16:18:17 -0700386 } else {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700387 if (remove(raft_path.c_str())) {
388 MYLOGE("Error removing raft file %s: %s\n", raft_path.c_str(), strerror(errno));
Wei Liu341938b2016-04-27 16:18:17 -0700389 }
390 }
391}
392
Naveen Kalla058e1e82016-10-19 21:38:44 -0700393/**
394 * Finds the last modified file in the directory dir whose name starts with file_prefix.
395 *
396 * Function returns empty string when it does not find a file
397 */
398static std::string GetLastModifiedFileWithPrefix(const std::string& dir,
399 const std::string& file_prefix) {
400 std::unique_ptr<DIR, decltype(&closedir)> d(opendir(dir.c_str()), closedir);
401 if (d == nullptr) {
402 MYLOGD("Error %d opening %s\n", errno, dir.c_str());
403 return "";
404 }
405
406 // Find the newest file matching the file_prefix in dir
407 struct dirent *de;
408 time_t last_modified_time = 0;
409 std::string last_modified_file = "";
410 struct stat s;
411
412 while ((de = readdir(d.get()))) {
413 std::string file = std::string(de->d_name);
414 if (!file_prefix.empty()) {
415 if (!android::base::StartsWith(file, file_prefix.c_str())) continue;
416 }
417 file = dir + "/" + file;
418 int ret = stat(file.c_str(), &s);
419
420 if ((ret == 0) && (s.st_mtime > last_modified_time)) {
421 last_modified_file = file;
422 last_modified_time = s.st_mtime;
423 }
424 }
425
426 return last_modified_file;
427}
428
429static void DumpModemLogs() {
430 DurationReporter durationReporter("DUMP MODEM LOGS");
431 if (IsUserBuild()) {
432 return;
433 }
434
435 if (!ds.IsZipping()) {
436 MYLOGD("Not dumping modem logs. dumpstate is not generating a zipping bugreport\n");
437 return;
438 }
439
440 std::string file_prefix = android::base::GetProperty("ro.radio.log_prefix", "");
441
442 if(file_prefix.empty()) {
443 MYLOGD("No modem log : file_prefix is empty\n");
444 return;
445 }
446
447 // TODO: use bugreport_dir_ directly when this function is moved to Dumpstate class
448 std::string bugreport_dir = dirname(ds.GetPath("").c_str());
449 MYLOGD("DumpModemLogs: directory is %s and file_prefix is %s\n",
450 bugreport_dir.c_str(), file_prefix.c_str());
451
452 std::string modem_log_file = GetLastModifiedFileWithPrefix(bugreport_dir, file_prefix);
453
454 struct stat s;
455 if (modem_log_file.empty() || stat(modem_log_file.c_str(), &s) != 0) {
456 MYLOGD("Modem log %s does not exist\n", modem_log_file.c_str());
457 return;
458 }
459
460 std::string filename = basename(modem_log_file.c_str());
461 if (!ds.AddZipEntry(filename, modem_log_file)) {
462 MYLOGE("Unable to add modem log %s to zip file\n", modem_log_file.c_str());
463 } else {
464 MYLOGD("Modem Log %s is added to zip\n", modem_log_file.c_str());
Naveen Kallab77df782016-11-18 17:32:23 -0800465 if (remove(modem_log_file.c_str())) {
466 MYLOGE("Error removing modem log %s\n", modem_log_file.c_str());
467 }
Naveen Kalla058e1e82016-10-19 21:38:44 -0700468 }
469}
470
Mark Salyzyn326842f2015-04-30 09:49:41 -0700471static bool skip_not_stat(const char *path) {
472 static const char stat[] = "/stat";
473 size_t len = strlen(path);
474 if (path[len - 1] == '/') { /* Directory? */
475 return false;
476 }
477 return strcmp(path + len - sizeof(stat) + 1, stat); /* .../stat? */
478}
479
Felipe Leme4c2d6632016-09-28 14:32:00 -0700480static bool skip_none(const char* path __attribute__((unused))) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800481 return false;
482}
483
Mark Salyzyn326842f2015-04-30 09:49:41 -0700484static const char mmcblk0[] = "/sys/block/mmcblk0/";
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700485unsigned long worst_write_perf = 20000; /* in KB/s */
Mark Salyzyn326842f2015-04-30 09:49:41 -0700486
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800487//
488// stat offsets
489// Name units description
490// ---- ----- -----------
491// read I/Os requests number of read I/Os processed
492#define __STAT_READ_IOS 0
493// read merges requests number of read I/Os merged with in-queue I/O
494#define __STAT_READ_MERGES 1
495// read sectors sectors number of sectors read
496#define __STAT_READ_SECTORS 2
497// read ticks milliseconds total wait time for read requests
498#define __STAT_READ_TICKS 3
499// write I/Os requests number of write I/Os processed
500#define __STAT_WRITE_IOS 4
501// write merges requests number of write I/Os merged with in-queue I/O
502#define __STAT_WRITE_MERGES 5
503// write sectors sectors number of sectors written
504#define __STAT_WRITE_SECTORS 6
505// write ticks milliseconds total wait time for write requests
506#define __STAT_WRITE_TICKS 7
507// in_flight requests number of I/Os currently in flight
508#define __STAT_IN_FLIGHT 8
509// io_ticks milliseconds total time this block device has been active
510#define __STAT_IO_TICKS 9
511// time_in_queue milliseconds total wait time for all requests
512#define __STAT_IN_QUEUE 10
513#define __STAT_NUMBER_FIELD 11
514//
515// read I/Os, write I/Os
516// =====================
517//
518// These values increment when an I/O request completes.
519//
520// read merges, write merges
521// =========================
522//
523// These values increment when an I/O request is merged with an
524// already-queued I/O request.
525//
526// read sectors, write sectors
527// ===========================
528//
529// These values count the number of sectors read from or written to this
530// block device. The "sectors" in question are the standard UNIX 512-byte
531// sectors, not any device- or filesystem-specific block size. The
532// counters are incremented when the I/O completes.
533#define SECTOR_SIZE 512
534//
535// read ticks, write ticks
536// =======================
537//
538// These values count the number of milliseconds that I/O requests have
539// waited on this block device. If there are multiple I/O requests waiting,
540// these values will increase at a rate greater than 1000/second; for
541// example, if 60 read requests wait for an average of 30 ms, the read_ticks
542// field will increase by 60*30 = 1800.
543//
544// in_flight
545// =========
546//
547// This value counts the number of I/O requests that have been issued to
548// the device driver but have not yet completed. It does not include I/O
549// requests that are in the queue but not yet issued to the device driver.
550//
551// io_ticks
552// ========
553//
554// This value counts the number of milliseconds during which the device has
555// had I/O requests queued.
556//
557// time_in_queue
558// =============
559//
560// This value counts the number of milliseconds that I/O requests have waited
561// on this block device. If there are multiple I/O requests waiting, this
562// value will increase as the product of the number of milliseconds times the
563// number of requests waiting (see "read ticks" above for an example).
564#define S_TO_MS 1000
565//
566
Mark Salyzyn326842f2015-04-30 09:49:41 -0700567static int dump_stat_from_fd(const char *title __unused, const char *path, int fd) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800568 unsigned long long fields[__STAT_NUMBER_FIELD];
Mark Salyzyn326842f2015-04-30 09:49:41 -0700569 bool z;
570 char *cp, *buffer = NULL;
571 size_t i = 0;
572 FILE *fp = fdopen(fd, "rb");
573 getline(&buffer, &i, fp);
574 fclose(fp);
575 if (!buffer) {
576 return -errno;
577 }
578 i = strlen(buffer);
579 while ((i > 0) && (buffer[i - 1] == '\n')) {
580 buffer[--i] = '\0';
581 }
582 if (!*buffer) {
583 free(buffer);
584 return 0;
585 }
586 z = true;
587 for (cp = buffer, i = 0; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800588 fields[i] = strtoull(cp, &cp, 10);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700589 if (fields[i] != 0) {
590 z = false;
591 }
592 }
593 if (z) { /* never accessed */
594 free(buffer);
595 return 0;
596 }
597
598 if (!strncmp(path, mmcblk0, sizeof(mmcblk0) - 1)) {
599 path += sizeof(mmcblk0) - 1;
600 }
601
602 printf("%s: %s\n", path, buffer);
603 free(buffer);
604
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800605 if (fields[__STAT_IO_TICKS]) {
606 unsigned long read_perf = 0;
607 unsigned long read_ios = 0;
608 if (fields[__STAT_READ_TICKS]) {
609 unsigned long long divisor = fields[__STAT_READ_TICKS]
610 * fields[__STAT_IO_TICKS];
611 read_perf = ((unsigned long long)SECTOR_SIZE
612 * fields[__STAT_READ_SECTORS]
613 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
614 / divisor;
615 read_ios = ((unsigned long long)S_TO_MS * fields[__STAT_READ_IOS]
616 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
617 / divisor;
618 }
619
620 unsigned long write_perf = 0;
621 unsigned long write_ios = 0;
622 if (fields[__STAT_WRITE_TICKS]) {
623 unsigned long long divisor = fields[__STAT_WRITE_TICKS]
624 * fields[__STAT_IO_TICKS];
625 write_perf = ((unsigned long long)SECTOR_SIZE
626 * fields[__STAT_WRITE_SECTORS]
627 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
628 / divisor;
629 write_ios = ((unsigned long long)S_TO_MS * fields[__STAT_WRITE_IOS]
630 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
631 / divisor;
632 }
633
634 unsigned queue = (fields[__STAT_IN_QUEUE]
635 + (fields[__STAT_IO_TICKS] >> 1))
636 / fields[__STAT_IO_TICKS];
637
638 if (!write_perf && !write_ios) {
639 printf("%s: perf(ios) rd: %luKB/s(%lu/s) q: %u\n",
640 path, read_perf, read_ios, queue);
641 } else {
642 printf("%s: perf(ios) rd: %luKB/s(%lu/s) wr: %luKB/s(%lu/s) q: %u\n",
643 path, read_perf, read_ios, write_perf, write_ios, queue);
644 }
645
646 /* bugreport timeout factor adjustment */
647 if ((write_perf > 1) && (write_perf < worst_write_perf)) {
648 worst_write_perf = write_perf;
649 }
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700650 }
Mark Salyzyn326842f2015-04-30 09:49:41 -0700651 return 0;
652}
653
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700654/* timeout in ms */
Felipe Leme8620bb42015-11-10 11:04:45 -0800655static unsigned long logcat_timeout(const char *name) {
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -0700656 log_id_t id = android_name_to_log_id(name);
657 unsigned long property_size = __android_logger_get_buffer_size(id);
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700658 /* Engineering margin is ten-fold our guess */
659 return 10 * (property_size + worst_write_perf) / worst_write_perf;
660}
661
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700662void Dumpstate::PrintHeader() const {
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700663 std::string build, fingerprint, radio, bootloader, network;
664 char date[80];
Colin Crossf45fa6b2012-03-26 12:38:26 -0700665
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700666 build = android::base::GetProperty("ro.build.display.id", "(unknown)");
667 fingerprint = android::base::GetProperty("ro.build.fingerprint", "(unknown)");
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700668 radio = android::base::GetProperty("gsm.version.baseband", "(unknown)");
669 bootloader = android::base::GetProperty("ro.bootloader", "(unknown)");
670 network = android::base::GetProperty("gsm.operator.alpha", "(unknown)");
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700671 strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now_));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700672
673 printf("========================================================\n");
674 printf("== dumpstate: %s\n", date);
675 printf("========================================================\n");
676
677 printf("\n");
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700678 printf("Build: %s\n", build.c_str());
679 // NOTE: fingerprint entry format is important for other tools.
680 printf("Build fingerprint: '%s'\n", fingerprint.c_str());
681 printf("Bootloader: %s\n", bootloader.c_str());
682 printf("Radio: %s\n", radio.c_str());
683 printf("Network: %s\n", network.c_str());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700684
685 printf("Kernel: ");
Felipe Lemebda15a02016-11-16 17:48:25 -0800686 fflush(stdout);
687 DumpFileToFd(STDOUT_FILENO, "/proc/version");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700688 printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700689 printf("Bugreport format version: %s\n", version_.c_str());
Felipe Leme7447d7c2016-11-03 18:12:22 -0700690 printf("Dumpstate info: id=%d pid=%d dry_run=%d args=%s extra_options=%s\n", id_, pid_,
Felipe Leme9a523ae2016-10-20 15:10:33 -0700691 dry_run_, args_.c_str(), extra_options_.c_str());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700692 printf("\n");
Felipe Leme78f2c862015-12-21 09:55:22 -0800693}
694
Felipe Leme24b66ee2016-06-16 10:55:26 -0700695// List of file extensions that can cause a zip file attachment to be rejected by some email
696// service providers.
697static const std::set<std::string> PROBLEMATIC_FILE_EXTENSIONS = {
698 ".ade", ".adp", ".bat", ".chm", ".cmd", ".com", ".cpl", ".exe", ".hta", ".ins", ".isp",
699 ".jar", ".jse", ".lib", ".lnk", ".mde", ".msc", ".msp", ".mst", ".pif", ".scr", ".sct",
700 ".shb", ".sys", ".vb", ".vbe", ".vbs", ".vxd", ".wsc", ".wsf", ".wsh"
701};
702
Felipe Leme1d486fe2016-10-14 18:06:47 -0700703bool Dumpstate::AddZipEntryFromFd(const std::string& entry_name, int fd) {
704 if (!IsZipping()) {
705 MYLOGD("Not adding zip entry %s from fd because it's not a zipped bugreport\n",
706 entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800707 return false;
708 }
Felipe Leme24b66ee2016-06-16 10:55:26 -0700709 std::string valid_name = entry_name;
710
711 // Rename extension if necessary.
712 size_t idx = entry_name.rfind(".");
713 if (idx != std::string::npos) {
714 std::string extension = entry_name.substr(idx);
715 std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
716 if (PROBLEMATIC_FILE_EXTENSIONS.count(extension) != 0) {
717 valid_name = entry_name + ".renamed";
718 MYLOGI("Renaming entry %s to %s\n", entry_name.c_str(), valid_name.c_str());
719 }
720 }
721
Felipe Leme6fe9db62016-02-12 09:04:16 -0800722 // Logging statement below is useful to time how long each entry takes, but it's too verbose.
723 // MYLOGD("Adding zip entry %s\n", entry_name.c_str());
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700724 int32_t err = zip_writer_->StartEntryWithTime(valid_name.c_str(), ZipWriter::kCompress,
725 get_mtime(fd, ds.now_));
Felipe Leme1d486fe2016-10-14 18:06:47 -0700726 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700727 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", valid_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700728 ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800729 return false;
730 }
731
Felipe Leme770410d2016-01-26 17:07:14 -0800732 std::vector<uint8_t> buffer(65536);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800733 while (1) {
Zach Riggle22200402016-08-18 01:01:24 -0400734 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), buffer.size()));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800735 if (bytes_read == 0) {
736 break;
737 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800738 MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800739 return false;
740 }
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700741 err = zip_writer_->WriteBytes(buffer.data(), bytes_read);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800742 if (err) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700743 MYLOGE("zip_writer_->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800744 return false;
745 }
746 }
747
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700748 err = zip_writer_->FinishEntry();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700749 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700750 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800751 return false;
752 }
753
754 return true;
755}
756
Felipe Leme1d486fe2016-10-14 18:06:47 -0700757bool Dumpstate::AddZipEntry(const std::string& entry_name, const std::string& entry_path) {
758 android::base::unique_fd fd(
759 TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
Andreas Gampeaff68432016-07-18 18:01:27 -0700760 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800761 MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800762 return false;
763 }
764
Felipe Leme1d486fe2016-10-14 18:06:47 -0700765 return AddZipEntryFromFd(entry_name, fd.get());
Felipe Lemee82a27d2016-01-05 13:35:44 -0800766}
767
768/* adds a file to the existing zipped bugreport */
Felipe Leme4c2d6632016-09-28 14:32:00 -0700769static int _add_file_from_fd(const char* title __attribute__((unused)), const char* path, int fd) {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700770 return ds.AddZipEntryFromFd(ZIP_ROOT_DIR + path, fd) ? 0 : 1;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800771}
772
Felipe Leme1d486fe2016-10-14 18:06:47 -0700773void Dumpstate::AddDir(const std::string& dir, bool recursive) {
774 if (!IsZipping()) {
775 MYLOGD("Not adding dir %s because it's not a zipped bugreport\n", dir.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800776 return;
777 }
Felipe Leme678727a2016-09-21 17:22:11 -0700778 MYLOGD("Adding dir %s (recursive: %d)\n", dir.c_str(), recursive);
Felipe Leme9a523ae2016-10-20 15:10:33 -0700779 DurationReporter duration_reporter(dir, nullptr);
Felipe Leme678727a2016-09-21 17:22:11 -0700780 dump_files("", dir.c_str(), recursive ? skip_none : is_dir, _add_file_from_fd);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800781}
782
Felipe Leme1d486fe2016-10-14 18:06:47 -0700783bool Dumpstate::AddTextZipEntry(const std::string& entry_name, const std::string& content) {
784 if (!IsZipping()) {
785 MYLOGD("Not adding text zip entry %s because it's not a zipped bugreport\n",
786 entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800787 return false;
788 }
Felipe Lemecbce55d2016-02-08 09:53:18 -0800789 MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700790 int32_t err = zip_writer_->StartEntryWithTime(entry_name.c_str(), ZipWriter::kCompress, ds.now_);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700791 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700792 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700793 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800794 return false;
795 }
796
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700797 err = zip_writer_->WriteBytes(content.c_str(), content.length());
Felipe Leme1d486fe2016-10-14 18:06:47 -0700798 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700799 MYLOGE("zip_writer_->WriteBytes(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700800 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800801 return false;
802 }
803
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700804 err = zip_writer_->FinishEntry();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700805 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700806 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800807 return false;
808 }
809
810 return true;
811}
812
Felipe Lemec0808152016-06-17 17:37:13 -0700813static void dump_iptables() {
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700814 RunCommand("IPTABLES", {"iptables", "-L", "-nvx"});
815 RunCommand("IP6TABLES", {"ip6tables", "-L", "-nvx"});
Erik Kline32af8c22016-09-28 17:26:26 +0900816 RunCommand("IPTABLES NAT", {"iptables", "-t", "nat", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -0700817 /* no ip6 nat */
Erik Kline32af8c22016-09-28 17:26:26 +0900818 RunCommand("IPTABLES MANGLE", {"iptables", "-t", "mangle", "-L", "-nvx"});
819 RunCommand("IP6TABLES MANGLE", {"ip6tables", "-t", "mangle", "-L", "-nvx"});
820 RunCommand("IPTABLES RAW", {"iptables", "-t", "raw", "-L", "-nvx"});
821 RunCommand("IP6TABLES RAW", {"ip6tables", "-t", "raw", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -0700822}
823
Felipe Lemee184f662016-10-27 10:04:47 -0700824static void AddAnrTraceFiles() {
825 bool add_to_zip = ds.IsZipping() && ds.version_ == VERSION_SPLIT_ANR;
826 std::string dump_traces_dir;
827
828 /* show the traces we collected in main(), if that was done */
829 if (dump_traces_path != nullptr) {
830 if (add_to_zip) {
831 dump_traces_dir = dirname(dump_traces_path);
832 MYLOGD("Adding ANR traces (directory %s) to the zip file\n", dump_traces_dir.c_str());
833 ds.AddDir(dump_traces_dir, true);
834 } else {
835 MYLOGD("Dumping current ANR traces (%s) to the main bugreport entry\n",
836 dump_traces_path);
837 ds.DumpFile("VM TRACES JUST NOW", dump_traces_path);
838 }
839 }
840
841 std::string anr_traces_path = android::base::GetProperty("dalvik.vm.stack-trace-file", "");
842 std::string anr_traces_dir = dirname(anr_traces_path.c_str());
843
844 // Make sure directory is not added twice.
845 // TODO: this is an overzealous check because it's relying on dump_traces_path - which is
846 // generated by dump_traces() - and anr_traces_path - which is retrieved from a system
847 // property - but in reality they're the same path (although the former could be nullptr).
848 // Anyways, once dump_traces() is refactored as a private Dumpstate function, this logic should
849 // be revisited.
850 bool already_dumped = anr_traces_dir == dump_traces_dir;
851
852 MYLOGD("AddAnrTraceFiles(): dump_traces_dir=%s, anr_traces_dir=%s, already_dumped=%d\n",
853 dump_traces_dir.c_str(), anr_traces_dir.c_str(), already_dumped);
854
855 if (anr_traces_path.empty()) {
856 printf("*** NO VM TRACES FILE DEFINED (dalvik.vm.stack-trace-file)\n\n");
857 } else {
858 int fd = TEMP_FAILURE_RETRY(
859 open(anr_traces_path.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
860 if (fd < 0) {
861 printf("*** NO ANR VM TRACES FILE (%s): %s\n\n", anr_traces_path.c_str(),
862 strerror(errno));
863 } else {
864 if (add_to_zip) {
865 if (!already_dumped) {
866 MYLOGD("Adding dalvik ANR traces (directory %s) to the zip file\n",
867 anr_traces_dir.c_str());
868 ds.AddDir(anr_traces_dir, true);
869 already_dumped = true;
870 }
871 } else {
872 MYLOGD("Dumping last ANR traces (%s) to the main bugreport entry\n",
873 anr_traces_path.c_str());
874 dump_file_from_fd("VM TRACES AT LAST ANR", anr_traces_path.c_str(), fd);
875 }
876 }
877 }
878
879 if (add_to_zip && already_dumped) {
880 MYLOGD("Already dumped directory %s to the zip file\n", anr_traces_dir.c_str());
881 return;
882 }
883
884 /* slow traces for slow operations */
885 struct stat st;
886 if (!anr_traces_path.empty()) {
887 int tail = anr_traces_path.size() - 1;
888 while (tail > 0 && anr_traces_path.at(tail) != '/') {
889 tail--;
890 }
891 int i = 0;
892 while (1) {
893 anr_traces_path = anr_traces_path.substr(0, tail + 1) +
894 android::base::StringPrintf("slow%02d.txt", i);
895 if (stat(anr_traces_path.c_str(), &st)) {
896 // No traces file at this index, done with the files.
897 break;
898 }
899 ds.DumpFile("VM TRACES WHEN SLOW", anr_traces_path.c_str());
900 i++;
901 }
902 }
903}
904
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700905static void dumpstate() {
Felipe Leme9a523ae2016-10-20 15:10:33 -0700906 DurationReporter duration_reporter("DUMPSTATE");
Felipe Leme78f2c862015-12-21 09:55:22 -0800907 unsigned long timeout;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700908
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700909 dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700910 RunCommand("UPTIME", {"uptime"});
Mark Salyzyn326842f2015-04-30 09:49:41 -0700911 dump_files("UPTIME MMC PERF", mmcblk0, skip_not_stat, dump_stat_from_fd);
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800912 dump_emmc_ecsd("/d/mmc0/mmc0:0001/ext_csd");
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700913 DumpFile("MEMORY INFO", "/proc/meminfo");
914 RunCommand("CPU INFO", {"top", "-b", "-n", "1", "-H", "-s", "6", "-o",
Felipe Leme30dbfa12016-09-02 12:43:26 -0700915 "pid,tid,user,pr,ni,%cpu,s,virt,res,pcy,cmd,name"});
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700916 RunCommand("PROCRANK", {"procrank"}, CommandOptions::AS_ROOT_20);
917 DumpFile("VIRTUAL MEMORY STATS", "/proc/vmstat");
918 DumpFile("VMALLOC INFO", "/proc/vmallocinfo");
919 DumpFile("SLAB INFO", "/proc/slabinfo");
920 DumpFile("ZONEINFO", "/proc/zoneinfo");
921 DumpFile("PAGETYPEINFO", "/proc/pagetypeinfo");
922 DumpFile("BUDDYINFO", "/proc/buddyinfo");
923 DumpFile("FRAGMENTATION INFO", "/d/extfrag/unusable_index");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700924
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700925 DumpFile("KERNEL WAKE SOURCES", "/d/wakeup_sources");
926 DumpFile("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
927 DumpFile("KERNEL SYNC", "/d/sync");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700928
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700929 RunCommand("PROCESSES AND THREADS",
Felipe Leme30dbfa12016-09-02 12:43:26 -0700930 {"ps", "-A", "-T", "-Z", "-O", "pri,nice,rtprio,sched,pcy"});
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700931 RunCommand("LIBRANK", {"librank"}, CommandOptions::AS_ROOT_10);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700932
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700933 RunCommand("PRINTENV", {"printenv"});
Elliott Hughes21b7c8d2016-10-28 08:53:02 -0700934 RunCommand("NETSTAT", {"netstat", "-nW"});
Felipe Lemee4eca582016-06-10 17:48:08 -0700935 struct stat s;
936 if (stat("/proc/modules", &s) != 0) {
937 MYLOGD("Skipping 'lsmod' because /proc/modules does not exist\n");
938 } else {
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700939 RunCommand("LSMOD", {"lsmod"});
Felipe Lemee4eca582016-06-10 17:48:08 -0700940 }
Michal Karpinski4db754f2015-12-11 18:04:32 +0000941
Colin Crossf45fa6b2012-03-26 12:38:26 -0700942 do_dmesg();
943
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700944 RunCommand("LIST OF OPEN FILES", {"lsof"}, CommandOptions::AS_ROOT_10);
Jeff Brown1dc94e32014-09-11 14:15:27 -0700945 for_each_pid(do_showmap, "SMAPS OF ALL PROCESSES");
946 for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
Mark Salyzyna297c322016-02-05 15:33:17 -0800947 for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700948
Ajay Panickerd886ec42016-09-14 12:26:46 -0700949 /* Dump Bluetooth HCI logs */
Felipe Leme1d486fe2016-10-14 18:06:47 -0700950 ds.AddDir("/data/misc/bluetooth/logs", true);
Ajay Panickerd886ec42016-09-14 12:26:46 -0700951
Felipe Leme9a523ae2016-10-20 15:10:33 -0700952 if (!ds.do_early_screenshot_) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800953 MYLOGI("taking late screenshot\n");
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700954 ds.TakeScreenshot();
Jeff Sharkey5a930032013-03-19 15:05:19 -0700955 }
956
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700957 // DumpFile("EVENT LOG TAGS", "/etc/event-log-tags");
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700958 // calculate timeout
959 timeout = logcat_timeout("main") + logcat_timeout("system") + logcat_timeout("crash");
960 if (timeout < 20000) {
961 timeout = 20000;
962 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700963 RunCommand("SYSTEM LOG", {"logcat", "-v", "threadtime", "-v", "printable", "-d", "*:v"},
Felipe Leme30dbfa12016-09-02 12:43:26 -0700964 CommandOptions::WithTimeout(timeout / 1000).Build());
Mark Salyzyn43afe5d2016-01-26 07:24:08 -0800965 timeout = logcat_timeout("events");
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700966 if (timeout < 20000) {
967 timeout = 20000;
968 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700969 RunCommand("EVENT LOG",
Felipe Leme30dbfa12016-09-02 12:43:26 -0700970 {"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-d", "*:v"},
971 CommandOptions::WithTimeout(timeout / 1000).Build());
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700972 timeout = logcat_timeout("radio");
973 if (timeout < 20000) {
974 timeout = 20000;
975 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700976 RunCommand("RADIO LOG",
Felipe Leme30dbfa12016-09-02 12:43:26 -0700977 {"logcat", "-b", "radio", "-v", "threadtime", "-v", "printable", "-d", "*:v"},
978 CommandOptions::WithTimeout(timeout / 1000).Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700979
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700980 RunCommand("LOG STATISTICS", {"logcat", "-b", "all", "-S"});
Mark Salyzynecc07632015-07-30 14:57:09 -0700981
Felipe Lemee184f662016-10-27 10:04:47 -0700982 AddAnrTraceFiles();
Colin Crossf45fa6b2012-03-26 12:38:26 -0700983
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700984 int dumped = 0;
985 for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
986 if (tombstone_data[i].fd != -1) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800987 const char *name = tombstone_data[i].name;
988 int fd = tombstone_data[i].fd;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700989 dumped = 1;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700990 if (ds.IsZipping()) {
991 if (!ds.AddZipEntryFromFd(ZIP_ROOT_DIR + name, fd)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800992 MYLOGE("Unable to add tombstone %s to zip file\n", name);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800993 }
994 } else {
995 dump_file_from_fd("TOMBSTONE", name, fd);
996 }
997 close(fd);
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700998 tombstone_data[i].fd = -1;
999 }
1000 }
1001 if (!dumped) {
1002 printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR);
1003 }
1004
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001005 DumpFile("NETWORK DEV INFO", "/proc/net/dev");
1006 DumpFile("QTAGUID NETWORK INTERFACES INFO", "/proc/net/xt_qtaguid/iface_stat_all");
1007 DumpFile("QTAGUID NETWORK INTERFACES INFO (xt)", "/proc/net/xt_qtaguid/iface_stat_fmt");
1008 DumpFile("QTAGUID CTRL INFO", "/proc/net/xt_qtaguid/ctrl");
1009 DumpFile("QTAGUID STATS INFO", "/proc/net/xt_qtaguid/stats");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001010
Felipe Lemee184f662016-10-27 10:04:47 -07001011 struct stat st;
Todd Poynor2a83daa2013-11-22 15:44:22 -08001012 if (!stat(PSTORE_LAST_KMSG, &st)) {
1013 /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001014 DumpFile("LAST KMSG", PSTORE_LAST_KMSG);
Mark Salyzyn7d0a7622016-06-24 14:06:15 -07001015 } else if (!stat(ALT_PSTORE_LAST_KMSG, &st)) {
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001016 DumpFile("LAST KMSG", ALT_PSTORE_LAST_KMSG);
Todd Poynor2a83daa2013-11-22 15:44:22 -08001017 } else {
1018 /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001019 DumpFile("LAST KMSG", "/proc/last_kmsg");
Todd Poynor2a83daa2013-11-22 15:44:22 -08001020 }
1021
Mark Salyzyn2262c162014-12-16 09:09:26 -08001022 /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001023 RunCommand("LAST LOGCAT",
Felipe Leme30dbfa12016-09-02 12:43:26 -07001024 {"logcat", "-L", "-b", "all", "-v", "threadtime", "-v", "printable", "-d", "*:v"});
Mark Salyzyn2262c162014-12-16 09:09:26 -08001025
Colin Crossf45fa6b2012-03-26 12:38:26 -07001026 /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
Elliott Hughesa59828a2015-01-27 20:48:52 -08001027
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001028 RunCommand("NETWORK INTERFACES", {"ip", "link"});
Lorenzo Colittid4c3d382014-07-30 14:38:20 +09001029
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001030 RunCommand("IPv4 ADDRESSES", {"ip", "-4", "addr", "show"});
1031 RunCommand("IPv6 ADDRESSES", {"ip", "-6", "addr", "show"});
Lorenzo Colittid4c3d382014-07-30 14:38:20 +09001032
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001033 RunCommand("IP RULES", {"ip", "rule", "show"});
1034 RunCommand("IP RULES v6", {"ip", "-6", "rule", "show"});
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -07001035
1036 dump_route_tables();
1037
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001038 RunCommand("ARP CACHE", {"ip", "-4", "neigh", "show"});
1039 RunCommand("IPv6 ND CACHE", {"ip", "-6", "neigh", "show"});
1040 RunCommand("MULTICAST ADDRESSES", {"ip", "maddr"});
1041 RunCommand("WIFI NETWORKS", {"wpa_cli", "IFNAME=wlan0", "list_networks"},
Felipe Leme30dbfa12016-09-02 12:43:26 -07001042 CommandOptions::WithTimeout(20).Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001043
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -08001044#ifdef FWDUMP_bcmdhd
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001045 RunCommand("ND OFFLOAD TABLE", {WLUTIL, "nd_hostip"}, CommandOptions::AS_ROOT_5);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001046
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001047 RunCommand("DUMP WIFI INTERNAL COUNTERS (1)", {WLUTIL, "counters"}, CommandOptions::AS_ROOT_20);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001048
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001049 RunCommand("ND OFFLOAD STATUS (1)", {WLUTIL, "nd_status"}, CommandOptions::AS_ROOT_5);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001050
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -08001051#endif
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001052 DumpFile("INTERRUPTS (1)", "/proc/interrupts");
Dmitry Shmidt0b2c9262012-11-07 11:09:46 -08001053
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001054 RunDumpsys("NETWORK DIAGNOSTICS", {"connectivity", "--diag"},
Felipe Leme30dbfa12016-09-02 12:43:26 -07001055 CommandOptions::WithTimeout(10).Build());
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001056
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -08001057#ifdef FWDUMP_bcmdhd
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001058 RunCommand("DUMP WIFI STATUS", {"dhdutil", "-i", "wlan0", "dump"}, CommandOptions::AS_ROOT_20);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001059
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001060 RunCommand("DUMP WIFI INTERNAL COUNTERS (2)", {WLUTIL, "counters"}, CommandOptions::AS_ROOT_20);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001061
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001062 RunCommand("ND OFFLOAD STATUS (2)", {WLUTIL, "nd_status"}, CommandOptions::AS_ROOT_5);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001063#endif
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001064 DumpFile("INTERRUPTS (2)", "/proc/interrupts");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001065
1066 print_properties();
1067
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001068 RunCommand("VOLD DUMP", {"vdc", "dump"});
1069 RunCommand("SECURE CONTAINERS", {"vdc", "asec", "list"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001070
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001071 RunCommand("FILESYSTEMS & FREE SPACE", {"df"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001072
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001073 RunCommand("LAST RADIO LOG", {"parse_radio_log", "/proc/last_radio_log"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001074
1075 printf("------ BACKLIGHTS ------\n");
1076 printf("LCD brightness=");
Felipe Leme678727a2016-09-21 17:22:11 -07001077 DumpFile("", "/sys/class/leds/lcd-backlight/brightness");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001078 printf("Button brightness=");
Felipe Leme678727a2016-09-21 17:22:11 -07001079 DumpFile("", "/sys/class/leds/button-backlight/brightness");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001080 printf("Keyboard brightness=");
Felipe Leme678727a2016-09-21 17:22:11 -07001081 DumpFile("", "/sys/class/leds/keyboard-backlight/brightness");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001082 printf("ALS mode=");
Felipe Leme678727a2016-09-21 17:22:11 -07001083 DumpFile("", "/sys/class/leds/lcd-backlight/als");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001084 printf("LCD driver registers:\n");
Felipe Leme678727a2016-09-21 17:22:11 -07001085 DumpFile("", "/sys/class/leds/lcd-backlight/registers");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001086 printf("\n");
1087
1088 /* Binder state is expensive to look at as it uses a lot of memory. */
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001089 DumpFile("BINDER FAILED TRANSACTION LOG", "/sys/kernel/debug/binder/failed_transaction_log");
1090 DumpFile("BINDER TRANSACTION LOG", "/sys/kernel/debug/binder/transaction_log");
1091 DumpFile("BINDER TRANSACTIONS", "/sys/kernel/debug/binder/transactions");
1092 DumpFile("BINDER STATS", "/sys/kernel/debug/binder/stats");
1093 DumpFile("BINDER STATE", "/sys/kernel/debug/binder/state");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001094
Colin Crossf45fa6b2012-03-26 12:38:26 -07001095 printf("========================================================\n");
1096 printf("== Board\n");
1097 printf("========================================================\n");
1098
Felipe Leme0bcc7ca2016-09-13 16:45:56 -07001099 {
1100 DurationReporter tmpDr("dumpstate_board()");
1101 dumpstate_board();
1102 printf("\n");
1103 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001104
1105 /* Migrate the ril_dumpstate to a dumpstate_board()? */
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001106 int rilDumpstateTimeout = android::base::GetIntProperty("ril.dumpstate.timeout", 0);
1107 if (rilDumpstateTimeout > 0) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001108 // su does not exist on user builds, so try running without it.
1109 // This way any implementations of vril-dump that do not require
1110 // root can run on user builds.
1111 CommandOptions::CommandOptionsBuilder options =
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001112 CommandOptions::WithTimeout(rilDumpstateTimeout);
Felipe Leme6ad9c062016-09-28 11:58:36 -07001113 if (!IsUserBuild()) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001114 options.AsRoot();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001115 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001116 RunCommand("DUMP VENDOR RIL LOGS", {"vril-dump"}, options.Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001117 }
1118
1119 printf("========================================================\n");
1120 printf("== Android Framework Services\n");
1121 printf("========================================================\n");
1122
Felipe Leme5bcce572016-09-27 09:21:08 -07001123 RunDumpsys("DUMPSYS", {"--skip", "meminfo", "cpuinfo"}, CommandOptions::WithTimeout(90).Build(),
1124 10);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001125
1126 printf("========================================================\n");
Dianne Hackborn02bea972013-06-26 18:59:09 -07001127 printf("== Checkins\n");
1128 printf("========================================================\n");
1129
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001130 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
1131 RunDumpsys("CHECKIN MEMINFO", {"meminfo", "--checkin"});
1132 RunDumpsys("CHECKIN NETSTATS", {"netstats", "--checkin"});
1133 RunDumpsys("CHECKIN PROCSTATS", {"procstats", "-c"});
1134 RunDumpsys("CHECKIN USAGESTATS", {"usagestats", "-c"});
1135 RunDumpsys("CHECKIN PACKAGE", {"package", "--checkin"});
Dianne Hackborn02bea972013-06-26 18:59:09 -07001136
1137 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001138 printf("== Running Application Activities\n");
1139 printf("========================================================\n");
1140
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001141 RunDumpsys("APP ACTIVITIES", {"activity", "all"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001142
1143 printf("========================================================\n");
1144 printf("== Running Application Services\n");
1145 printf("========================================================\n");
1146
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001147 RunDumpsys("APP SERVICES", {"activity", "service", "all"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001148
1149 printf("========================================================\n");
1150 printf("== Running Application Providers\n");
1151 printf("========================================================\n");
1152
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001153 RunDumpsys("APP PROVIDERS", {"activity", "provider", "all"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001154
Naveen Kalla058e1e82016-10-19 21:38:44 -07001155 // DumpModemLogs adds the modem logs if available to the bugreport.
1156 // Do this at the end to allow for sufficient time for the modem logs to be
1157 // collected.
1158 DumpModemLogs();
1159
Colin Crossf45fa6b2012-03-26 12:38:26 -07001160 printf("========================================================\n");
Felipe Leme7447d7c2016-11-03 18:12:22 -07001161 printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),
1162 ds.progress_->GetMax(), ds.progress_->GetInitialMax());
Felipe Leme608385d2016-02-01 10:35:38 -08001163 printf("========================================================\n");
Felipe Leme7447d7c2016-11-03 18:12:22 -07001164 printf("== dumpstate: done (id %d)\n", ds.id_);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001165 printf("========================================================\n");
1166}
1167
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001168static void ShowUsageAndExit(int exitCode = 1) {
1169 fprintf(stderr,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001170 "usage: dumpstate [-h] [-b soundfile] [-e soundfile] [-o file] [-d] [-p] "
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001171 "[-z]] [-s] [-S] [-q] [-B] [-P] [-R] [-V version]\n"
1172 " -h: display this help message\n"
1173 " -b: play sound file instead of vibrate, at beginning of job\n"
1174 " -e: play sound file instead of vibrate, at end of job\n"
1175 " -o: write to file (instead of stdout)\n"
1176 " -d: append date to filename (requires -o)\n"
1177 " -p: capture screenshot to filename.png (requires -o)\n"
1178 " -z: generate zipped file (requires -o)\n"
1179 " -s: write output to control socket (for init)\n"
1180 " -S: write file location to control socket (for init; requires -o and -z)"
1181 " -q: disable vibrate\n"
1182 " -B: send broadcast when finished (requires -o)\n"
1183 " -P: send broadcast when started and update system properties on "
1184 "progress (requires -o and -B)\n"
1185 " -R: take bugreport in remote mode (requires -o, -z, -d and -B, "
1186 "shouldn't be used with -P)\n"
Felipe Lemed071c682016-10-20 16:48:00 -07001187 " -v: prints the dumpstate header and exit\n");
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001188 exit(exitCode);
1189}
1190
1191static void ExitOnInvalidArgs() {
1192 fprintf(stderr, "invalid combination of args\n");
1193 ShowUsageAndExit();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001194}
1195
Wei Liuf87959e2016-08-26 14:51:42 -07001196static void wake_lock_releaser() {
1197 if (release_wake_lock(WAKE_LOCK_NAME) < 0) {
1198 MYLOGE("Failed to release wake lock: %s \n", strerror(errno));
1199 } else {
1200 MYLOGD("Wake lock released.\n");
1201 }
1202}
1203
Felipe Leme4c2d6632016-09-28 14:32:00 -07001204static void sig_handler(int signo __attribute__((unused))) {
Wei Liuf87959e2016-08-26 14:51:42 -07001205 wake_lock_releaser();
Andres Morales2e671bb2014-08-21 12:38:22 -07001206 _exit(EXIT_FAILURE);
John Michelau885f8882013-05-06 16:42:02 -05001207}
1208
Wei Liuf87959e2016-08-26 14:51:42 -07001209static void register_sig_handler() {
1210 struct sigaction sa;
1211 sigemptyset(&sa.sa_mask);
1212 sa.sa_flags = 0;
1213 sa.sa_handler = sig_handler;
1214 sigaction(SIGPIPE, &sa, NULL); // broken pipe
1215 sigaction(SIGSEGV, &sa, NULL); // segment fault
1216 sigaction(SIGINT, &sa, NULL); // ctrl-c
1217 sigaction(SIGTERM, &sa, NULL); // killed
1218 sigaction(SIGQUIT, &sa, NULL); // quit
1219}
1220
Felipe Leme1d486fe2016-10-14 18:06:47 -07001221bool Dumpstate::FinishZipFile() {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001222 std::string entry_name = base_name_ + "-" + name_ + ".txt";
Felipe Leme1d486fe2016-10-14 18:06:47 -07001223 MYLOGD("Adding main entry (%s) from %s to .zip bugreport\n", entry_name.c_str(),
Felipe Leme9a523ae2016-10-20 15:10:33 -07001224 tmp_path_.c_str());
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07001225 // Final timestamp
1226 char date[80];
1227 time_t the_real_now_please_stand_up = time(nullptr);
1228 strftime(date, sizeof(date), "%Y/%m/%d %H:%M:%S", localtime(&the_real_now_please_stand_up));
Felipe Leme7447d7c2016-11-03 18:12:22 -07001229 MYLOGD("dumpstate id %d finished around %s (%ld s)\n", ds.id_, date,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001230 the_real_now_please_stand_up - ds.now_);
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07001231
Felipe Leme9a523ae2016-10-20 15:10:33 -07001232 if (!ds.AddZipEntry(entry_name, tmp_path_)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001233 MYLOGE("Failed to add text entry to .zip file\n");
Felipe Leme1e9edc62015-12-21 16:02:13 -08001234 return false;
1235 }
Felipe Leme1d486fe2016-10-14 18:06:47 -07001236 if (!AddTextZipEntry("main_entry.txt", entry_name)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001237 MYLOGE("Failed to add main_entry.txt to .zip file\n");
Felipe Leme111b9d02016-02-03 09:28:24 -08001238 return false;
Felipe Leme809d74e2016-02-02 12:57:00 -08001239 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08001240
Felipe Leme0f3fb202016-06-10 17:10:53 -07001241 // Add log file (which contains stderr output) to zip...
1242 fprintf(stderr, "dumpstate_log.txt entry on zip file logged up to here\n");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001243 if (!ds.AddZipEntry("dumpstate_log.txt", ds.log_path_.c_str())) {
Felipe Leme0f3fb202016-06-10 17:10:53 -07001244 MYLOGE("Failed to add dumpstate log to .zip file\n");
1245 return false;
1246 }
1247 // ... and re-opens it for further logging.
Felipe Leme9a523ae2016-10-20 15:10:33 -07001248 redirect_to_existing_file(stderr, const_cast<char*>(ds.log_path_.c_str()));
Felipe Leme0f3fb202016-06-10 17:10:53 -07001249 fprintf(stderr, "\n");
1250
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07001251 int32_t err = zip_writer_->Finish();
Felipe Leme1d486fe2016-10-14 18:06:47 -07001252 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07001253 MYLOGE("zip_writer_->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001254 return false;
1255 }
1256
Felipe Leme1d486fe2016-10-14 18:06:47 -07001257 // TODO: remove once FinishZipFile() is automatically handled by Dumpstate's destructor.
1258 ds.zip_file.reset(nullptr);
1259
Felipe Lemee9d2c542016-11-15 11:48:26 -08001260 MYLOGD("Removing temporary file %s\n", tmp_path_.c_str())
1261 if (remove(tmp_path_.c_str()) != 0) {
1262 MYLOGE("Failed to remove temporary file (%s): %s\n", tmp_path_.c_str(), strerror(errno));
Felipe Lemec4eee562016-04-21 15:42:55 -07001263 }
1264
Felipe Leme1e9edc62015-12-21 16:02:13 -08001265 return true;
1266}
Felipe Leme6e01fa62015-11-11 19:35:14 -08001267
Michal Karpinski4db754f2015-12-11 18:04:32 +00001268static std::string SHA256_file_hash(std::string filepath) {
Andreas Gampe27cd7b22016-07-18 18:24:05 -07001269 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK
1270 | O_CLOEXEC | O_NOFOLLOW)));
Andreas Gampeaff68432016-07-18 18:01:27 -07001271 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001272 MYLOGE("open(%s): %s\n", filepath.c_str(), strerror(errno));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001273 return NULL;
1274 }
1275
1276 SHA256_CTX ctx;
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001277 SHA256_Init(&ctx);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001278
1279 std::vector<uint8_t> buffer(65536);
1280 while (1) {
1281 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd.get(), buffer.data(), buffer.size()));
1282 if (bytes_read == 0) {
1283 break;
1284 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001285 MYLOGE("read(%s): %s\n", filepath.c_str(), strerror(errno));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001286 return NULL;
1287 }
1288
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001289 SHA256_Update(&ctx, buffer.data(), bytes_read);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001290 }
1291
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001292 uint8_t hash[SHA256_DIGEST_LENGTH];
1293 SHA256_Final(hash, &ctx);
1294
1295 char hash_buffer[SHA256_DIGEST_LENGTH * 2 + 1];
1296 for(size_t i = 0; i < SHA256_DIGEST_LENGTH; i++) {
Michal Karpinskicbbdf732016-01-07 20:45:02 +00001297 sprintf(hash_buffer + (i * 2), "%02x", hash[i]);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001298 }
1299 hash_buffer[sizeof(hash_buffer) - 1] = 0;
1300 return std::string(hash_buffer);
1301}
1302
Colin Crossf45fa6b2012-03-26 12:38:26 -07001303int main(int argc, char *argv[]) {
1304 int do_add_date = 0;
Felipe Leme6e01fa62015-11-11 19:35:14 -08001305 int do_zip_file = 0;
John Michelau1f794c42012-09-17 11:20:19 -05001306 int do_vibrate = 1;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001307 char* use_outfile = 0;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001308 int use_socket = 0;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001309 int use_control_socket = 0;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001310 int do_fb = 0;
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07001311 int do_broadcast = 0;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001312 int is_remote_mode = 0;
Felipe Lemed071c682016-10-20 16:48:00 -07001313 bool show_header_only = false;
Felipe Leme75876a22016-10-27 16:31:27 -07001314 bool do_start_service = false;
Felipe Leme8fecfdd2016-02-09 10:40:07 -08001315
Colin Crossf45fa6b2012-03-26 12:38:26 -07001316 /* set as high priority, and protect from OOM killer */
1317 setpriority(PRIO_PROCESS, 0, -20);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001318
Felipe Lemed071c682016-10-20 16:48:00 -07001319 FILE* oom_adj = fopen("/proc/self/oom_score_adj", "we");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001320 if (oom_adj) {
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001321 fputs("-1000", oom_adj);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001322 fclose(oom_adj);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001323 } else {
1324 /* fallback to kernels <= 2.6.35 */
1325 oom_adj = fopen("/proc/self/oom_adj", "we");
1326 if (oom_adj) {
1327 fputs("-17", oom_adj);
1328 fclose(oom_adj);
1329 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001330 }
1331
Jeff Brown1dc94e32014-09-11 14:15:27 -07001332 /* parse arguments */
Colin Crossf45fa6b2012-03-26 12:38:26 -07001333 int c;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001334 while ((c = getopt(argc, argv, "dho:svqzpPBRSV:")) != -1) {
Colin Crossf45fa6b2012-03-26 12:38:26 -07001335 switch (c) {
Felipe Lemee844a9d2016-09-21 15:01:39 -07001336 // clang-format off
Felipe Lemed071c682016-10-20 16:48:00 -07001337 case 'd': do_add_date = 1; break;
1338 case 'z': do_zip_file = 1; break;
1339 case 'o': use_outfile = optarg; break;
1340 case 's': use_socket = 1; break;
1341 case 'S': use_control_socket = 1; break;
1342 case 'v': show_header_only = true; break;
1343 case 'q': do_vibrate = 0; break;
1344 case 'p': do_fb = 1; break;
Felipe Leme9a523ae2016-10-20 15:10:33 -07001345 case 'P': ds.update_progress_ = true; break;
Felipe Lemed071c682016-10-20 16:48:00 -07001346 case 'R': is_remote_mode = 1; break;
1347 case 'B': do_broadcast = 1; break;
1348 case 'V': break; // compatibility no-op
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001349 case 'h':
1350 ShowUsageAndExit(0);
1351 break;
1352 default:
1353 fprintf(stderr, "Invalid option: %c\n", c);
1354 ShowUsageAndExit();
Felipe Lemee844a9d2016-09-21 15:01:39 -07001355 // clang-format on
Colin Crossf45fa6b2012-03-26 12:38:26 -07001356 }
1357 }
1358
Felipe Lemed071c682016-10-20 16:48:00 -07001359 // TODO: use helper function to convert argv into a string
1360 for (int i = 0; i < argc; i++) {
1361 ds.args_ += argv[i];
1362 if (i < argc - 1) {
1363 ds.args_ += " ";
1364 }
1365 }
1366
1367 ds.extra_options_ = android::base::GetProperty(PROPERTY_EXTRA_OPTIONS, "");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001368 if (!ds.extra_options_.empty()) {
Felipe Leme9ce6aa42016-09-21 10:02:25 -07001369 // Framework uses a system property to override some command-line args.
1370 // Currently, it contains the type of the requested bugreport.
Felipe Leme9a523ae2016-10-20 15:10:33 -07001371 if (ds.extra_options_ == "bugreportplus") {
Felipe Leme75876a22016-10-27 16:31:27 -07001372 // Currently, the dumpstate binder is only used by Shell to update progress.
1373 do_start_service = true;
Felipe Leme9a523ae2016-10-20 15:10:33 -07001374 ds.update_progress_ = true;
Felipe Leme9ce6aa42016-09-21 10:02:25 -07001375 do_fb = 0;
Felipe Leme9a523ae2016-10-20 15:10:33 -07001376 } else if (ds.extra_options_ == "bugreportremote") {
Felipe Leme9ce6aa42016-09-21 10:02:25 -07001377 do_vibrate = 0;
1378 is_remote_mode = 1;
1379 do_fb = 0;
Felipe Leme9a523ae2016-10-20 15:10:33 -07001380 } else if (ds.extra_options_ == "bugreportwear") {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001381 ds.update_progress_ = true;
Felipe Leme9ce6aa42016-09-21 10:02:25 -07001382 } else {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001383 MYLOGE("Unknown extra option: %s\n", ds.extra_options_.c_str());
Felipe Leme9ce6aa42016-09-21 10:02:25 -07001384 }
1385 // Reset the property
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001386 android::base::SetProperty(PROPERTY_EXTRA_OPTIONS, "");
Felipe Leme9ce6aa42016-09-21 10:02:25 -07001387 }
1388
Felipe Leme9a523ae2016-10-20 15:10:33 -07001389 if ((do_zip_file || do_add_date || ds.update_progress_ || do_broadcast) && !use_outfile) {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001390 ExitOnInvalidArgs();
Felipe Leme6e01fa62015-11-11 19:35:14 -08001391 }
1392
Felipe Leme2628e9e2016-04-12 16:36:51 -07001393 if (use_control_socket && !do_zip_file) {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001394 ExitOnInvalidArgs();
Felipe Leme2628e9e2016-04-12 16:36:51 -07001395 }
1396
Felipe Leme9a523ae2016-10-20 15:10:33 -07001397 if (ds.update_progress_ && !do_broadcast) {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001398 ExitOnInvalidArgs();
Felipe Leme71bbfc52015-11-23 14:14:51 -08001399 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001400
Felipe Leme9a523ae2016-10-20 15:10:33 -07001401 if (is_remote_mode && (ds.update_progress_ || !do_broadcast || !do_zip_file || !do_add_date)) {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001402 ExitOnInvalidArgs();
Michal Karpinski4db754f2015-12-11 18:04:32 +00001403 }
1404
Felipe Lemed071c682016-10-20 16:48:00 -07001405 if (ds.version_ == VERSION_DEFAULT) {
1406 ds.version_ = VERSION_CURRENT;
Felipe Leme809d74e2016-02-02 12:57:00 -08001407 }
1408
Felipe Lemee184f662016-10-27 10:04:47 -07001409 if (ds.version_ != VERSION_CURRENT && ds.version_ != VERSION_SPLIT_ANR) {
1410 MYLOGE("invalid version requested ('%s'); suppported values are: ('%s', '%s', '%s')\n",
1411 ds.version_.c_str(), VERSION_DEFAULT.c_str(), VERSION_CURRENT.c_str(),
1412 VERSION_SPLIT_ANR.c_str());
Felipe Lemed071c682016-10-20 16:48:00 -07001413 exit(1);
1414 }
1415
1416 if (show_header_only) {
1417 ds.PrintHeader();
1418 exit(0);
1419 }
1420
Felipe Leme7447d7c2016-11-03 18:12:22 -07001421 /* redirect output if needed */
1422 bool is_redirecting = !use_socket && use_outfile;
1423
1424 // TODO: temporarily set progress until it's part of the Dumpstate constructor
1425 std::string stats_path =
1426 is_redirecting ? android::base::StringPrintf("%s/dumpstate-stats.txt", dirname(use_outfile))
1427 : "";
1428 ds.progress_.reset(new Progress(stats_path));
1429
Felipe Lemed071c682016-10-20 16:48:00 -07001430 /* gets the sequential id */
Felipe Leme7447d7c2016-11-03 18:12:22 -07001431 uint32_t last_id = android::base::GetIntProperty(PROPERTY_LAST_ID, 0);
Felipe Lemed071c682016-10-20 16:48:00 -07001432 ds.id_ = ++last_id;
1433 android::base::SetProperty(PROPERTY_LAST_ID, std::to_string(last_id));
1434
1435 MYLOGI("begin\n");
1436
1437 if (acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME) < 0) {
1438 MYLOGE("Failed to acquire wake lock: %s \n", strerror(errno));
1439 } else {
1440 MYLOGD("Wake lock acquired.\n");
1441 atexit(wake_lock_releaser);
1442 register_sig_handler();
1443 }
1444
Felipe Leme75876a22016-10-27 16:31:27 -07001445 if (do_start_service) {
1446 MYLOGI("Starting 'dumpstate' service\n");
1447 android::status_t ret;
1448 if ((ret = android::os::DumpstateService::Start()) != android::OK) {
1449 MYLOGE("Unable to start DumpstateService: %d\n", ret);
1450 }
1451 }
1452
Felipe Lemed071c682016-10-20 16:48:00 -07001453 if (ds.IsDryRun()) {
1454 MYLOGI("Running on dry-run mode (to disable it, call 'setprop dumpstate.dry_run false')\n");
1455 }
1456
Felipe Leme7447d7c2016-11-03 18:12:22 -07001457 MYLOGI("dumpstate info: id=%d, args='%s', extra_options= %s)\n", ds.id_, ds.args_.c_str(),
Felipe Lemed071c682016-10-20 16:48:00 -07001458 ds.extra_options_.c_str());
1459
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001460 MYLOGI("bugreport format version: %s\n", ds.version_.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -08001461
Felipe Leme9a523ae2016-10-20 15:10:33 -07001462 ds.do_early_screenshot_ = ds.update_progress_;
Felipe Lemee338bf62015-12-07 14:03:50 -08001463
Christopher Ferrised9354f2014-10-01 17:35:01 -07001464 // If we are going to use a socket, do it as early as possible
1465 // to avoid timeouts from bugreport.
1466 if (use_socket) {
1467 redirect_to_socket(stdout, "dumpstate");
1468 }
1469
Felipe Leme2628e9e2016-04-12 16:36:51 -07001470 if (use_control_socket) {
1471 MYLOGD("Opening control socket\n");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001472 ds.control_socket_fd_ = open_socket("dumpstate");
1473 ds.update_progress_ = 1;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001474 }
1475
Felipe Leme71bbfc52015-11-23 14:14:51 -08001476 if (is_redirecting) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001477 ds.bugreport_dir_ = dirname(use_outfile);
1478 ds.base_name_ = basename(use_outfile);
Felipe Leme71bbfc52015-11-23 14:14:51 -08001479 if (do_add_date) {
1480 char date[80];
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001481 strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&ds.now_));
Felipe Leme2b9b06c2016-10-14 09:13:06 -07001482 ds.name_ = date;
Felipe Lemead5f6c42015-11-30 14:26:46 -08001483 } else {
Felipe Leme2b9b06c2016-10-14 09:13:06 -07001484 ds.name_ = "undated";
Felipe Leme71bbfc52015-11-23 14:14:51 -08001485 }
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001486 std::string buildId = android::base::GetProperty("ro.build.id", "UNKNOWN_BUILD");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001487 ds.base_name_ += "-" + buildId;
Felipe Leme71bbfc52015-11-23 14:14:51 -08001488 if (do_fb) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001489 ds.screenshot_path_ = ds.GetPath(".png");
Felipe Leme71bbfc52015-11-23 14:14:51 -08001490 }
Felipe Leme9a523ae2016-10-20 15:10:33 -07001491 ds.tmp_path_ = ds.GetPath(".tmp");
Felipe Leme75876a22016-10-27 16:31:27 -07001492 ds.log_path_ = ds.GetPath("-dumpstate_log-" + std::to_string(ds.pid_) + ".txt");
Felipe Leme71bbfc52015-11-23 14:14:51 -08001493
Felipe Lemee844a9d2016-09-21 15:01:39 -07001494 MYLOGD(
1495 "Bugreport dir: %s\n"
1496 "Base name: %s\n"
1497 "Suffix: %s\n"
1498 "Log path: %s\n"
1499 "Temporary path: %s\n"
1500 "Screenshot path: %s\n",
Felipe Leme9a523ae2016-10-20 15:10:33 -07001501 ds.bugreport_dir_.c_str(), ds.base_name_.c_str(), ds.name_.c_str(),
1502 ds.log_path_.c_str(), ds.tmp_path_.c_str(), ds.screenshot_path_.c_str());
Felipe Leme71bbfc52015-11-23 14:14:51 -08001503
Felipe Leme1e9edc62015-12-21 16:02:13 -08001504 if (do_zip_file) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001505 ds.path_ = ds.GetPath(".zip");
1506 MYLOGD("Creating initial .zip file (%s)\n", ds.path_.c_str());
1507 create_parent_dirs(ds.path_.c_str());
1508 ds.zip_file.reset(fopen(ds.path_.c_str(), "wb"));
Felipe Leme1d486fe2016-10-14 18:06:47 -07001509 if (ds.zip_file == nullptr) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001510 MYLOGE("fopen(%s, 'wb'): %s\n", ds.path_.c_str(), strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001511 do_zip_file = 0;
1512 } else {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07001513 ds.zip_writer_.reset(new ZipWriter(ds.zip_file.get()));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001514 }
Felipe Leme1d486fe2016-10-14 18:06:47 -07001515 ds.AddTextZipEntry("version.txt", ds.version_);
Felipe Leme1e9edc62015-12-21 16:02:13 -08001516 }
1517
Felipe Leme9a523ae2016-10-20 15:10:33 -07001518 if (ds.update_progress_) {
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07001519 if (do_broadcast) {
1520 // clang-format off
1521 std::vector<std::string> am_args = {
1522 "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
Felipe Leme2b9b06c2016-10-14 09:13:06 -07001523 "--es", "android.intent.extra.NAME", ds.name_,
Felipe Lemee844a9d2016-09-21 15:01:39 -07001524 "--ei", "android.intent.extra.ID", std::to_string(ds.id_),
Felipe Leme75876a22016-10-27 16:31:27 -07001525 "--ei", "android.intent.extra.PID", std::to_string(ds.pid_),
Felipe Leme7447d7c2016-11-03 18:12:22 -07001526 "--ei", "android.intent.extra.MAX", std::to_string(ds.progress_->GetMax()),
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07001527 };
1528 // clang-format on
1529 send_broadcast("android.intent.action.BUGREPORT_STARTED", am_args);
1530 }
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001531 if (use_control_socket) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001532 dprintf(ds.control_socket_fd_, "BEGIN:%s\n", ds.path_.c_str());
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001533 }
Felipe Leme71bbfc52015-11-23 14:14:51 -08001534 }
1535 }
1536
Nick Kralevichf3599b32016-01-25 15:05:16 -08001537 /* read /proc/cmdline before dropping root */
1538 FILE *cmdline = fopen("/proc/cmdline", "re");
1539 if (cmdline) {
1540 fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
1541 fclose(cmdline);
1542 }
1543
Jeff Brown1dc94e32014-09-11 14:15:27 -07001544 /* open the vibrator before dropping root */
Felipe Leme6e01fa62015-11-11 19:35:14 -08001545 std::unique_ptr<FILE, int(*)(FILE*)> vibrator(NULL, fclose);
John Michelau1f794c42012-09-17 11:20:19 -05001546 if (do_vibrate) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001547 vibrator.reset(fopen("/sys/class/timed_output/vibrator/enable", "we"));
Jeff Brown1dc94e32014-09-11 14:15:27 -07001548 if (vibrator) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001549 vibrate(vibrator.get(), 150);
Jeff Brown1dc94e32014-09-11 14:15:27 -07001550 }
John Michelau1f794c42012-09-17 11:20:19 -05001551 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001552
Felipe Leme9a523ae2016-10-20 15:10:33 -07001553 if (do_fb && ds.do_early_screenshot_) {
1554 if (ds.screenshot_path_.empty()) {
Felipe Leme3634a1e2015-12-09 10:11:47 -08001555 // should not have happened
Felipe Lemecbce55d2016-02-08 09:53:18 -08001556 MYLOGE("INTERNAL ERROR: skipping early screenshot because path was not set\n");
Felipe Leme3634a1e2015-12-09 10:11:47 -08001557 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001558 MYLOGI("taking early screenshot\n");
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001559 ds.TakeScreenshot();
Felipe Lemee338bf62015-12-07 14:03:50 -08001560 }
1561 }
1562
Felipe Leme1e9edc62015-12-21 16:02:13 -08001563 if (do_zip_file) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001564 if (chown(ds.path_.c_str(), AID_SHELL, AID_SHELL)) {
1565 MYLOGE("Unable to change ownership of zip file %s: %s\n", ds.path_.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -07001566 strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001567 }
1568 }
1569
Felipe Leme71bbfc52015-11-23 14:14:51 -08001570 if (is_redirecting) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001571 redirect_to_file(stderr, const_cast<char*>(ds.log_path_.c_str()));
1572 if (chown(ds.log_path_.c_str(), AID_SHELL, AID_SHELL)) {
1573 MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n",
1574 ds.log_path_.c_str(), strerror(errno));
Felipe Leme6fe9db62016-02-12 09:04:16 -08001575 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001576 /* TODO: rather than generating a text file now and zipping it later,
1577 it would be more efficient to redirect stdout to the zip entry
1578 directly, but the libziparchive doesn't support that option yet. */
Felipe Leme9a523ae2016-10-20 15:10:33 -07001579 redirect_to_file(stdout, const_cast<char*>(ds.tmp_path_.c_str()));
1580 if (chown(ds.tmp_path_.c_str(), AID_SHELL, AID_SHELL)) {
Felipe Leme6fe9db62016-02-12 09:04:16 -08001581 MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
Felipe Leme9a523ae2016-10-20 15:10:33 -07001582 ds.tmp_path_.c_str(), strerror(errno));
Felipe Leme6fe9db62016-02-12 09:04:16 -08001583 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001584 }
Felipe Leme608385d2016-02-01 10:35:38 -08001585 // NOTE: there should be no stdout output until now, otherwise it would break the header.
1586 // In particular, DurationReport objects should be created passing 'title, NULL', so their
Felipe Lemecbce55d2016-02-08 09:53:18 -08001587 // duration is logged into MYLOG instead.
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001588 ds.PrintHeader();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001589
Felipe Leme71a74ac2016-03-17 15:43:25 -07001590 // Dumps systrace right away, otherwise it will be filled with unnecessary events.
Zhengyin Qian068ecc72016-08-10 16:48:14 -07001591 // First try to dump anrd trace if the daemon is running. Otherwise, dump
1592 // the raw trace.
1593 if (!dump_anrd_trace()) {
1594 dump_systrace();
1595 }
Felipe Leme71a74ac2016-03-17 15:43:25 -07001596
Felipe Leme9c74aad2016-02-29 18:15:42 -08001597 // Invoking the following dumpsys calls before dump_traces() to try and
1598 // keep the system stats as close to its initial state as possible.
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001599 RunDumpsys("DUMPSYS MEMINFO", {"meminfo", "-a"},
Felipe Leme30dbfa12016-09-02 12:43:26 -07001600 CommandOptions::WithTimeout(90).DropRoot().Build());
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001601 RunDumpsys("DUMPSYS CPUINFO", {"cpuinfo", "-a"},
Felipe Leme30dbfa12016-09-02 12:43:26 -07001602 CommandOptions::WithTimeout(10).DropRoot().Build());
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001603
Felipe Lemee844a9d2016-09-21 15:01:39 -07001604 // TODO: Drop root user and move into dumpstate() once b/28633932 is fixed.
1605 dump_raft();
1606
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001607 /* collect stack traces from Dalvik and native processes (needs root) */
1608 dump_traces_path = dump_traces();
1609
Felipe Lemec0808152016-06-17 17:37:13 -07001610 /* Run some operations that require root. */
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001611 get_tombstone_fds(tombstone_data);
Felipe Leme1d486fe2016-10-14 18:06:47 -07001612 ds.AddDir(RECOVERY_DIR, true);
1613 ds.AddDir(RECOVERY_DATA_DIR, true);
1614 ds.AddDir(LOGPERSIST_DATA_DIR, false);
Felipe Leme6ad9c062016-09-28 11:58:36 -07001615 if (!IsUserBuild()) {
Felipe Leme1d486fe2016-10-14 18:06:47 -07001616 ds.AddDir(PROFILE_DATA_DIR_CUR, true);
1617 ds.AddDir(PROFILE_DATA_DIR_REF, true);
David Brazdild2991962016-06-03 14:40:44 +01001618 }
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001619 add_mountinfo();
Felipe Lemec0808152016-06-17 17:37:13 -07001620 dump_iptables();
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001621
Erik Kline32af8c22016-09-28 17:26:26 +09001622 // Capture any IPSec policies in play. No keys are exposed here.
1623 RunCommand("IP XFRM POLICY", {"ip", "xfrm", "policy"},
1624 CommandOptions::WithTimeout(10).Build());
1625
Lorenzo Colittid3b809b2016-09-26 13:37:45 +09001626 // Run ss as root so we can see socket marks.
Felipe Lemec7fe8fe2016-09-21 18:13:20 -07001627 RunCommand("DETAILED SOCKET STATE", {"ss", "-eionptu"}, CommandOptions::WithTimeout(10).Build());
Lorenzo Colittid3b809b2016-09-26 13:37:45 +09001628
Felipe Lemecf6a8b42016-03-11 10:38:19 -08001629 if (!drop_root_user()) {
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001630 return -1;
1631 }
1632
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001633 dumpstate();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001634
Felipe Leme55b42a62015-11-10 17:39:08 -08001635 /* close output if needed */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001636 if (is_redirecting) {
Colin Crossf45fa6b2012-03-26 12:38:26 -07001637 fclose(stdout);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001638 }
1639
Felipe Leme6e01fa62015-11-11 19:35:14 -08001640 /* rename or zip the (now complete) .tmp file to its final location */
1641 if (use_outfile) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001642
1643 /* check if user changed the suffix using system properties */
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001644 std::string name = android::base::GetProperty(
Felipe Leme75876a22016-10-27 16:31:27 -07001645 android::base::StringPrintf("dumpstate.%d.name", ds.pid_), "");
Felipe Lemead5f6c42015-11-30 14:26:46 -08001646 bool change_suffix= false;
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001647 if (!name.empty()) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001648 /* must whitelist which characters are allowed, otherwise it could cross directories */
1649 std::regex valid_regex("^[-_a-zA-Z0-9]+$");
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001650 if (std::regex_match(name.c_str(), valid_regex)) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001651 change_suffix = true;
1652 } else {
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001653 MYLOGE("invalid suffix provided by user: %s\n", name.c_str());
Felipe Lemead5f6c42015-11-30 14:26:46 -08001654 }
1655 }
1656 if (change_suffix) {
Felipe Leme2b9b06c2016-10-14 09:13:06 -07001657 MYLOGI("changing suffix from %s to %s\n", ds.name_.c_str(), name.c_str());
1658 ds.name_ = name;
Felipe Leme9a523ae2016-10-20 15:10:33 -07001659 if (!ds.screenshot_path_.empty()) {
1660 std::string new_screenshot_path = ds.GetPath(".png");
1661 if (rename(ds.screenshot_path_.c_str(), new_screenshot_path.c_str())) {
1662 MYLOGE("rename(%s, %s): %s\n", ds.screenshot_path_.c_str(),
1663 new_screenshot_path.c_str(), strerror(errno));
Felipe Lemead5f6c42015-11-30 14:26:46 -08001664 } else {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001665 ds.screenshot_path_ = new_screenshot_path;
Felipe Lemead5f6c42015-11-30 14:26:46 -08001666 }
1667 }
1668 }
1669
Felipe Leme6e01fa62015-11-11 19:35:14 -08001670 bool do_text_file = true;
1671 if (do_zip_file) {
Felipe Leme1d486fe2016-10-14 18:06:47 -07001672 if (!ds.FinishZipFile()) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001673 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
Felipe Leme6e01fa62015-11-11 19:35:14 -08001674 do_text_file = true;
1675 } else {
1676 do_text_file = false;
Felipe Leme91274352016-02-26 15:03:52 -08001677 // Since zip file is already created, it needs to be renamed.
Felipe Leme9a523ae2016-10-20 15:10:33 -07001678 std::string new_path = ds.GetPath(".zip");
1679 if (ds.path_ != new_path) {
1680 MYLOGD("Renaming zip file from %s to %s\n", ds.path_.c_str(), new_path.c_str());
1681 if (rename(ds.path_.c_str(), new_path.c_str())) {
1682 MYLOGE("rename(%s, %s): %s\n", ds.path_.c_str(), new_path.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -07001683 strerror(errno));
Felipe Leme91274352016-02-26 15:03:52 -08001684 } else {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001685 ds.path_ = new_path;
Felipe Leme91274352016-02-26 15:03:52 -08001686 }
1687 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001688 }
1689 }
1690 if (do_text_file) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001691 ds.path_ = ds.GetPath(".txt");
1692 MYLOGD("Generating .txt bugreport at %s from %s\n", ds.path_.c_str(),
1693 ds.tmp_path_.c_str());
1694 if (rename(ds.tmp_path_.c_str(), ds.path_.c_str())) {
1695 MYLOGE("rename(%s, %s): %s\n", ds.tmp_path_.c_str(), ds.path_.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -07001696 strerror(errno));
Felipe Leme9a523ae2016-10-20 15:10:33 -07001697 ds.path_.clear();
Felipe Leme6e01fa62015-11-11 19:35:14 -08001698 }
1699 }
Felipe Leme2628e9e2016-04-12 16:36:51 -07001700 if (use_control_socket) {
1701 if (do_text_file) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001702 dprintf(ds.control_socket_fd_,
Felipe Lemee844a9d2016-09-21 15:01:39 -07001703 "FAIL:could not create zip file, check %s "
1704 "for more details\n",
Felipe Leme9a523ae2016-10-20 15:10:33 -07001705 ds.log_path_.c_str());
Felipe Leme2628e9e2016-04-12 16:36:51 -07001706 } else {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001707 dprintf(ds.control_socket_fd_, "OK:%s\n", ds.path_.c_str());
Felipe Leme2628e9e2016-04-12 16:36:51 -07001708 }
1709 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001710 }
1711
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08001712 /* vibrate a few but shortly times to let user know it's finished */
1713 if (vibrator) {
1714 for (int i = 0; i < 3; i++) {
1715 vibrate(vibrator.get(), 75);
1716 usleep((75 + 50) * 1000);
1717 }
1718 }
1719
Jeff Brown1dc94e32014-09-11 14:15:27 -07001720 /* tell activity manager we're done */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001721 if (do_broadcast) {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001722 if (!ds.path_.empty()) {
1723 MYLOGI("Final bugreport path: %s\n", ds.path_.c_str());
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001724 // clang-format off
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001725 std::vector<std::string> am_args = {
Felipe Leme43fd1bb2016-01-29 09:07:57 -08001726 "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
Felipe Lemee844a9d2016-09-21 15:01:39 -07001727 "--ei", "android.intent.extra.ID", std::to_string(ds.id_),
Felipe Leme75876a22016-10-27 16:31:27 -07001728 "--ei", "android.intent.extra.PID", std::to_string(ds.pid_),
Felipe Leme7447d7c2016-11-03 18:12:22 -07001729 "--ei", "android.intent.extra.MAX", std::to_string(ds.progress_->GetMax()),
Felipe Leme9a523ae2016-10-20 15:10:33 -07001730 "--es", "android.intent.extra.BUGREPORT", ds.path_,
1731 "--es", "android.intent.extra.DUMPSTATE_LOG", ds.log_path_
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001732 };
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001733 // clang-format on
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001734 if (do_fb) {
1735 am_args.push_back("--es");
1736 am_args.push_back("android.intent.extra.SCREENSHOT");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001737 am_args.push_back(ds.screenshot_path_);
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001738 }
Michal Karpinski4db754f2015-12-11 18:04:32 +00001739 if (is_remote_mode) {
1740 am_args.push_back("--es");
1741 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001742 am_args.push_back(SHA256_file_hash(ds.path_));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001743 send_broadcast("android.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
1744 } else {
1745 send_broadcast("android.intent.action.BUGREPORT_FINISHED", am_args);
1746 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001747 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001748 MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
Felipe Leme6e01fa62015-11-11 19:35:14 -08001749 }
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07001750 }
1751
Felipe Leme7447d7c2016-11-03 18:12:22 -07001752 MYLOGD("Final progress: %d/%d (estimated %d)\n", ds.progress_->Get(), ds.progress_->GetMax(),
1753 ds.progress_->GetInitialMax());
1754 ds.progress_->Save();
1755 MYLOGI("done (id %d)\n", ds.id_);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001756
Felipe Leme107a05f2016-03-08 15:11:15 -08001757 if (is_redirecting) {
1758 fclose(stderr);
1759 }
1760
Felipe Leme9a523ae2016-10-20 15:10:33 -07001761 if (use_control_socket && ds.control_socket_fd_ != -1) {
Felipe Lemee844a9d2016-09-21 15:01:39 -07001762 MYLOGD("Closing control socket\n");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001763 close(ds.control_socket_fd_);
Felipe Leme2628e9e2016-04-12 16:36:51 -07001764 }
1765
Colin Crossf45fa6b2012-03-26 12:38:26 -07001766 return 0;
1767}