blob: d9b6a5c0a20dffde13824c649eef0b8cd4bb195e [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 */
16
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -070017#include <dirent.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070018#include <errno.h>
19#include <fcntl.h>
Felipe Lemead5f6c42015-11-30 14:26:46 -080020#include <libgen.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070021#include <limits.h>
Felipe Leme6e01fa62015-11-11 19:35:14 -080022#include <memory>
Felipe Lemead5f6c42015-11-30 14:26:46 -080023#include <regex>
Felipe Leme635ca312016-01-05 14:23:02 -080024#include <set>
Mark Salyzyn8f37aa52015-06-12 12:28:24 -070025#include <stdbool.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070026#include <stdio.h>
27#include <stdlib.h>
Felipe Leme6e01fa62015-11-11 19:35:14 -080028#include <string>
Colin Crossf45fa6b2012-03-26 12:38:26 -070029#include <string.h>
Christopher Ferris7dc7f322014-07-22 16:08:19 -070030#include <sys/prctl.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070031#include <sys/resource.h>
32#include <sys/stat.h>
33#include <sys/time.h>
34#include <sys/wait.h>
35#include <unistd.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070036
Zhengyin Qian068ecc72016-08-10 16:48:14 -070037#include <android-base/file.h>
Naveen Kallade591df2016-10-19 21:38:44 -070038#include <android-base/stringprintf.h>
39#include <android-base/strings.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070040#include <cutils/properties.h>
41
42#include "private/android_filesystem_config.h"
43
44#define LOG_TAG "dumpstate"
Alex Ray656a6b92013-07-23 13:44:34 -070045#include <cutils/log.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070046
47#include "dumpstate.h"
Felipe Leme6e01fa62015-11-11 19:35:14 -080048#include "ScopedFd.h"
49#include "ziparchive/zip_writer.h"
50
Michal Karpinski4db754f2015-12-11 18:04:32 +000051#include "mincrypt/sha256.h"
52
Felipe Leme6e01fa62015-11-11 19:35:14 -080053using android::base::StringPrintf;
Colin Crossf45fa6b2012-03-26 12:38:26 -070054
55/* read before root is shed */
56static char cmdline_buf[16384] = "(unknown)";
57static const char *dump_traces_path = NULL;
58
Felipe Lemeefd7e272016-05-18 09:27:16 -070059// TODO: variables below should be part of dumpstate object
Felipe Leme8fecfdd2016-02-09 10:40:07 -080060static unsigned long id;
Felipe Leme78f2c862015-12-21 09:55:22 -080061static char build_type[PROPERTY_VALUE_MAX];
Felipe Lemee82a27d2016-01-05 13:35:44 -080062static time_t now;
63static std::unique_ptr<ZipWriter> zip_writer;
Felipe Leme635ca312016-01-05 14:23:02 -080064static std::set<std::string> mount_points;
65void add_mountinfo();
Felipe Leme02b7e002016-07-22 12:03:20 -070066int control_socket_fd = -1;
Felipe Lemeefd7e272016-05-18 09:27:16 -070067/* suffix of the bugreport files - it's typically the date (when invoked with -d),
68 * although it could be changed by the user using a system property */
69static std::string suffix;
Felipe Leme78f2c862015-12-21 09:55:22 -080070
Todd Poynor2a83daa2013-11-22 15:44:22 -080071#define PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops"
Mark Salyzynced60782016-06-24 14:06:15 -070072#define ALT_PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops-0"
Todd Poynor2a83daa2013-11-22 15:44:22 -080073
Wei Liu341938b2016-04-27 16:18:17 -070074#define RAFT_DIR "/data/misc/raft"
Felipe Lemee82a27d2016-01-05 13:35:44 -080075#define RECOVERY_DIR "/cache/recovery"
Mark Salyzynd6ab0112016-03-25 12:56:39 -070076#define RECOVERY_DATA_DIR "/data/misc/recovery"
Mark Salyzyn4d42dea2016-04-01 10:03:14 -070077#define LOGPERSIST_DATA_DIR "/data/misc/logd"
David Brazdild2991962016-06-03 14:40:44 +010078#define PROFILE_DATA_DIR_CUR "/data/misc/profiles/cur"
79#define PROFILE_DATA_DIR_REF "/data/misc/profiles/ref"
Christopher Ferris7dc7f322014-07-22 16:08:19 -070080#define TOMBSTONE_DIR "/data/tombstones"
81#define TOMBSTONE_FILE_PREFIX TOMBSTONE_DIR "/tombstone_"
82/* Can accomodate a tombstone number up to 9999. */
83#define TOMBSTONE_MAX_LEN (sizeof(TOMBSTONE_FILE_PREFIX) + 4)
84#define NUM_TOMBSTONES 10
Erik Kline08165202016-05-30 11:55:44 +090085#define WLUTIL "/vendor/xbin/wlutil"
Christopher Ferris7dc7f322014-07-22 16:08:19 -070086
87typedef struct {
88 char name[TOMBSTONE_MAX_LEN];
89 int fd;
90} tombstone_data_t;
91
92static tombstone_data_t tombstone_data[NUM_TOMBSTONES];
93
Felipe Leme71ca15e2016-05-19 16:18:17 -070094const std::string ZIP_ROOT_DIR = "FS";
95std::string bugreport_dir;
Felipe Lemee82a27d2016-01-05 13:35:44 -080096
Felipe Leme809d74e2016-02-02 12:57:00 -080097/*
98 * List of supported zip format versions.
99 *
100 * See bugreport-format.txt for more info.
101 */
Felipe Lemeca9c12e2016-05-19 16:30:15 -0700102static std::string VERSION_DEFAULT = "1.0";
Felipe Leme809d74e2016-02-02 12:57:00 -0800103
Calvin On249beee2016-06-03 15:17:07 -0700104bool is_user_build() {
Felipe Lemec4eee562016-04-21 15:42:55 -0700105 return 0 == strncmp(build_type, "user", PROPERTY_VALUE_MAX - 1);
106}
107
Felipe Lemee82a27d2016-01-05 13:35:44 -0800108/* gets the tombstone data, according to the bugreport type: if zipped gets all tombstones,
109 * otherwise gets just those modified in the last half an hour. */
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700110static void get_tombstone_fds(tombstone_data_t data[NUM_TOMBSTONES]) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800111 time_t thirty_minutes_ago = now - 60*30;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700112 for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
113 snprintf(data[i].name, sizeof(data[i].name), "%s%02zu", TOMBSTONE_FILE_PREFIX, i);
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800114 int fd = TEMP_FAILURE_RETRY(open(data[i].name,
115 O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700116 struct stat st;
117 if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode) &&
Felipe Lemee82a27d2016-01-05 13:35:44 -0800118 (zip_writer || (time_t) st.st_mtime >= thirty_minutes_ago)) {
119 data[i].fd = fd;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700120 } else {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800121 close(fd);
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700122 data[i].fd = -1;
123 }
124 }
125}
126
Felipe Leme635ca312016-01-05 14:23:02 -0800127// for_each_pid() callback to get mount info about a process.
128void do_mountinfo(int pid, const char *name) {
129 char path[PATH_MAX];
130
131 // Gets the the content of the /proc/PID/ns/mnt link, so only unique mount points
132 // are added.
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700133 snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800134 char linkname[PATH_MAX];
135 ssize_t r = readlink(path, linkname, PATH_MAX);
136 if (r == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800137 MYLOGE("Unable to read link for %s: %s\n", path, strerror(errno));
Felipe Leme635ca312016-01-05 14:23:02 -0800138 return;
139 }
140 linkname[r] = '\0';
141
142 if (mount_points.find(linkname) == mount_points.end()) {
143 // First time this mount point was found: add it
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700144 snprintf(path, sizeof(path), "/proc/%d/mountinfo", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800145 if (add_zip_entry(ZIP_ROOT_DIR + path, path)) {
146 mount_points.insert(linkname);
147 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800148 MYLOGE("Unable to add mountinfo %s to zip file\n", path);
Felipe Leme635ca312016-01-05 14:23:02 -0800149 }
150 }
151}
152
153void add_mountinfo() {
Felipe Leme03974982016-10-21 11:38:26 -0700154 if (!is_zipping()) return;
Felipe Leme635ca312016-01-05 14:23:02 -0800155 const char *title = "MOUNT INFO";
156 mount_points.clear();
Felipe Leme608385d2016-02-01 10:35:38 -0800157 DurationReporter duration_reporter(title, NULL);
Felipe Leme635ca312016-01-05 14:23:02 -0800158 for_each_pid(do_mountinfo, NULL);
Felipe Leme1b0225a2016-02-09 16:35:14 -0800159 MYLOGD("%s: %d entries added to zip file\n", title, (int) mount_points.size());
Felipe Leme635ca312016-01-05 14:23:02 -0800160}
161
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700162static void dump_dev_files(const char *title, const char *driverpath, const char *filename)
163{
164 DIR *d;
165 struct dirent *de;
166 char path[PATH_MAX];
167
168 d = opendir(driverpath);
169 if (d == NULL) {
170 return;
171 }
172
173 while ((de = readdir(d))) {
174 if (de->d_type != DT_LNK) {
175 continue;
176 }
177 snprintf(path, sizeof(path), "%s/%s/%s", driverpath, de->d_name, filename);
178 dump_file(title, path);
179 }
180
181 closedir(d);
182}
183
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700184// return pid of a userspace process. If not found or error, return 0.
185static unsigned int pid_of_process(const char* ps_name) {
186 DIR *proc_dir;
187 struct dirent *ps;
188 unsigned int pid;
189 std::string cmdline;
190
191 if (!(proc_dir = opendir("/proc"))) {
192 MYLOGE("Can't open /proc\n");
193 return 0;
194 }
195
196 while ((ps = readdir(proc_dir))) {
197 if (!(pid = atoi(ps->d_name))) {
198 continue;
199 }
200 android::base::ReadFileToString("/proc/"
201 + std::string(ps->d_name) + "/cmdline", &cmdline);
202 if (cmdline.find(ps_name) == std::string::npos) {
203 continue;
204 } else {
205 closedir(proc_dir);
206 return pid;
207 }
208 }
209 closedir(proc_dir);
210 return 0;
211}
212
213// dump anrd's trace and add to the zip file.
214// 1. check if anrd is running on this device.
215// 2. send a SIGUSR1 to its pid which will dump anrd's trace.
216// 3. wait until the trace generation completes and add to the zip file.
217static bool dump_anrd_trace() {
218 unsigned int pid;
219 char buf[50], path[PATH_MAX];
220 struct dirent *trace;
221 struct stat st;
222 DIR *trace_dir;
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700223 int retry = 5;
224 long max_ctime = 0, old_mtime;
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700225 long long cur_size = 0;
226 const char *trace_path = "/data/misc/anrd/";
227
228 if (!zip_writer) {
229 MYLOGE("Not dumping anrd trace because zip_writer is not set\n");
230 return false;
231 }
232
233 // find anrd's pid if it is running.
234 pid = pid_of_process("/system/xbin/anrd");
235
236 if (pid > 0) {
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700237 if (stat(trace_path, &st) == 0) {
238 old_mtime = st.st_mtime;
239 } else {
240 MYLOGE("Failed to find: %s\n", trace_path);
241 return false;
242 }
243
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700244 // send SIGUSR1 to the anrd to generate a trace.
245 sprintf(buf, "%u", pid);
246 if (run_command("ANRD_DUMP", 1, "kill", "-SIGUSR1", buf, NULL)) {
247 MYLOGE("anrd signal timed out. Please manually collect trace\n");
248 return false;
249 }
250
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700251 while (retry-- > 0 && old_mtime == st.st_mtime) {
252 sleep(1);
253 stat(trace_path, &st);
254 }
255
256 if (retry < 0 && old_mtime == st.st_mtime) {
257 MYLOGE("Failed to stat %s or trace creation timeout\n", trace_path);
258 return false;
259 }
260
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700261 // identify the trace file by its creation time.
262 if (!(trace_dir = opendir(trace_path))) {
263 MYLOGE("Can't open trace file under %s\n", trace_path);
264 }
265 while ((trace = readdir(trace_dir))) {
266 if (strcmp(trace->d_name, ".") == 0
267 || strcmp(trace->d_name, "..") == 0) {
268 continue;
269 }
270 sprintf(path, "%s%s", trace_path, trace->d_name);
271 if (stat(path, &st) == 0) {
272 if (st.st_ctime > max_ctime) {
273 max_ctime = st.st_ctime;
274 sprintf(buf, "%s", trace->d_name);
275 }
276 }
277 }
278 closedir(trace_dir);
279
280 // Wait until the dump completes by checking the size of the trace.
281 if (max_ctime > 0) {
282 sprintf(path, "%s%s", trace_path, buf);
283 while(true) {
284 sleep(1);
285 if (stat(path, &st) == 0) {
286 if (st.st_size == cur_size) {
287 break;
288 } else if (st.st_size > cur_size) {
289 cur_size = st.st_size;
290 } else {
291 return false;
292 }
293 } else {
294 MYLOGE("Cant stat() %s anymore\n", path);
295 return false;
296 }
297 }
298 // Add to the zip file.
299 if (!add_zip_entry("anrd_trace.txt", path)) {
300 MYLOGE("Unable to add anrd_trace file %s to zip file\n", path);
301 } else {
302 if (remove(path)) {
303 MYLOGE("Error removing anrd_trace file %s: %s", path, strerror(errno));
304 }
305 return true;
306 }
307 } else {
308 MYLOGE("Can't stats any trace file under %s\n", trace_path);
309 }
310 }
311 return false;
312}
313
Felipe Lemeefd7e272016-05-18 09:27:16 -0700314static void dump_systrace() {
Felipe Leme03974982016-10-21 11:38:26 -0700315 if (!is_zipping()) {
316 MYLOGD("Not dumping systrace because dumpstate is not zipping\n");
Felipe Leme71a74ac2016-03-17 15:43:25 -0700317 return;
318 }
Felipe Lemeefd7e272016-05-18 09:27:16 -0700319 std::string systrace_path = bugreport_dir + "/systrace-" + suffix + ".txt";
Felipe Leme14e034a2016-03-30 18:51:03 -0700320 if (systrace_path.empty()) {
321 MYLOGE("Not dumping systrace because path is empty\n");
322 return;
323 }
Felipe Leme71a74ac2016-03-17 15:43:25 -0700324 const char* path = "/sys/kernel/debug/tracing/tracing_on";
325 long int is_tracing;
326 if (read_file_as_long(path, &is_tracing)) {
327 return; // error already logged
328 }
329 if (is_tracing <= 0) {
330 MYLOGD("Skipping systrace because '%s' content is '%ld'\n", path, is_tracing);
331 return;
332 }
333
Felipe Leme14e034a2016-03-30 18:51:03 -0700334 MYLOGD("Running '/system/bin/atrace --async_dump -o %s', which can take several minutes",
335 systrace_path.c_str());
336 if (run_command("SYSTRACE", 120, "/system/bin/atrace", "--async_dump", "-o",
337 systrace_path.c_str(), NULL)) {
338 MYLOGE("systrace timed out, its zip entry will be incomplete\n");
339 // TODO: run_command tries to kill the process, but atrace doesn't die peacefully; ideally,
340 // we should call strace to stop itself, but there is no such option yet (just a
341 // --async_stop, which stops and dump
342 // if (run_command("SYSTRACE", 10, "/system/bin/atrace", "--kill", NULL)) {
343 // MYLOGE("could not stop systrace ");
344 // }
345 }
346 if (!add_zip_entry("systrace.txt", systrace_path)) {
347 MYLOGE("Unable to add systrace file %s to zip file\n", systrace_path.c_str());
Felipe Leme71a74ac2016-03-17 15:43:25 -0700348 } else {
Felipe Leme14e034a2016-03-30 18:51:03 -0700349 if (remove(systrace_path.c_str())) {
350 MYLOGE("Error removing systrace file %s: %s", systrace_path.c_str(), strerror(errno));
351 }
Felipe Leme71a74ac2016-03-17 15:43:25 -0700352 }
353}
354
Felipe Lemeefd7e272016-05-18 09:27:16 -0700355static void dump_raft() {
Wei Liu341938b2016-04-27 16:18:17 -0700356 if (is_user_build()) {
357 return;
358 }
359
Felipe Lemeefd7e272016-05-18 09:27:16 -0700360 std::string raft_log_path = bugreport_dir + "/raft_log.txt";
Wei Liu341938b2016-04-27 16:18:17 -0700361 if (raft_log_path.empty()) {
362 MYLOGD("raft_log_path is empty\n");
363 return;
364 }
Wei Liuf0e78d42016-05-25 14:21:02 -0700365
366 struct stat s;
367 if (stat(RAFT_DIR, &s) != 0 || !S_ISDIR(s.st_mode)) {
368 MYLOGD("%s does not exist or is not a directory\n", RAFT_DIR);
369 return;
370 }
371
Felipe Leme03974982016-10-21 11:38:26 -0700372 if (!is_zipping()) {
Wei Liu310525a2016-05-25 11:28:57 -0700373 // Write compressed and encoded raft logs to stdout if not zip_writer.
374 run_command("RAFT LOGS", 600, "logcompressor", "-r", RAFT_DIR, NULL);
Wei Liu341938b2016-04-27 16:18:17 -0700375 return;
376 }
377
378 run_command("RAFT LOGS", 600, "logcompressor", "-n", "-r", RAFT_DIR,
379 "-o", raft_log_path.c_str(), NULL);
380 if (!add_zip_entry("raft_log.txt", raft_log_path)) {
381 MYLOGE("Unable to add raft log %s to zip file\n", raft_log_path.c_str());
382 } else {
383 if (remove(raft_log_path.c_str())) {
Felipe Lemeefd7e272016-05-18 09:27:16 -0700384 MYLOGE("Error removing raft file %s: %s\n", raft_log_path.c_str(), strerror(errno));
Wei Liu341938b2016-04-27 16:18:17 -0700385 }
386 }
387}
388
Naveen Kallade591df2016-10-19 21:38:44 -0700389/**
390 * Finds the last modified file in the directory dir whose name starts with file_prefix
391 * Function returns empty string when it does not find a file
392 */
393static std::string get_last_modified_file_matching_prefix(const std::string& dir,
394 const std::string& file_prefix) {
395 std::unique_ptr<DIR, decltype(&closedir)> d(opendir(dir.c_str()), closedir);
396 if (d == nullptr) {
397 MYLOGD("Error %d opening %s\n", errno, dir.c_str());
398 return "";
399 }
400
401 // Find the newest file matching the file_prefix in dir
402 struct dirent *de;
403 time_t last_modified = 0;
404 std::string last_modified_file = "";
405 struct stat s;
406
407 while ((de = readdir(d.get()))) {
408 std::string file = std::string(de->d_name);
409 if (!file_prefix.empty()) {
410 if (!android::base::StartsWith(file, file_prefix.c_str())) continue;
411 }
412 file = dir + "/" + file;
413 int ret = stat(file.c_str(), &s);
414
415 if ((ret == 0) && (s.st_mtime > last_modified)) {
416 last_modified_file = file;
417 last_modified = s.st_mtime;
418 }
419 }
420
421 return last_modified_file;
422}
423
424void dump_modem_logs() {
425 DurationReporter duration_reporter("dump_modem_logs");
426 if (is_user_build()) {
427 return;
428 }
429
430 if (!is_zipping()) {
431 MYLOGD("Not dumping modem logs. dumpstate is not generating a zipping bugreport\n");
432 return;
433 }
434
435 char property[PROPERTY_VALUE_MAX];
436 property_get("ro.radio.log_prefix", property, "");
437 std::string file_prefix = std::string(property);
438 if(file_prefix.empty()) {
439 MYLOGD("No modem log : file_prefix is empty\n");
440 return;
441 }
442
443 MYLOGD("dump_modem_logs: directory is %s and file_prefix is %s\n",
444 bugreport_dir.c_str(), file_prefix.c_str());
445
446 std::string modem_log_file =
447 get_last_modified_file_matching_prefix(bugreport_dir, file_prefix);
448
449 struct stat s;
450 if (modem_log_file.empty() || stat(modem_log_file.c_str(), &s) != 0) {
451 MYLOGD("Modem log %s does not exist\n", modem_log_file.c_str());
452 return;
453 }
454
455 std::string filename = basename(modem_log_file.c_str());
456 if (!add_zip_entry(filename, modem_log_file)) {
457 MYLOGE("Unable to add modem log %s to zip file\n", modem_log_file.c_str());
458 } else {
459 MYLOGD("Modem Log %s is added to zip\n", modem_log_file.c_str());
460 }
461}
462
Mark Salyzyn326842f2015-04-30 09:49:41 -0700463static bool skip_not_stat(const char *path) {
464 static const char stat[] = "/stat";
465 size_t len = strlen(path);
466 if (path[len - 1] == '/') { /* Directory? */
467 return false;
468 }
469 return strcmp(path + len - sizeof(stat) + 1, stat); /* .../stat? */
470}
471
Felipe Lemee82a27d2016-01-05 13:35:44 -0800472static bool skip_none(const char *path) {
473 return false;
474}
475
Mark Salyzyn326842f2015-04-30 09:49:41 -0700476static const char mmcblk0[] = "/sys/block/mmcblk0/";
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700477unsigned long worst_write_perf = 20000; /* in KB/s */
Mark Salyzyn326842f2015-04-30 09:49:41 -0700478
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800479//
480// stat offsets
481// Name units description
482// ---- ----- -----------
483// read I/Os requests number of read I/Os processed
484#define __STAT_READ_IOS 0
485// read merges requests number of read I/Os merged with in-queue I/O
486#define __STAT_READ_MERGES 1
487// read sectors sectors number of sectors read
488#define __STAT_READ_SECTORS 2
489// read ticks milliseconds total wait time for read requests
490#define __STAT_READ_TICKS 3
491// write I/Os requests number of write I/Os processed
492#define __STAT_WRITE_IOS 4
493// write merges requests number of write I/Os merged with in-queue I/O
494#define __STAT_WRITE_MERGES 5
495// write sectors sectors number of sectors written
496#define __STAT_WRITE_SECTORS 6
497// write ticks milliseconds total wait time for write requests
498#define __STAT_WRITE_TICKS 7
499// in_flight requests number of I/Os currently in flight
500#define __STAT_IN_FLIGHT 8
501// io_ticks milliseconds total time this block device has been active
502#define __STAT_IO_TICKS 9
503// time_in_queue milliseconds total wait time for all requests
504#define __STAT_IN_QUEUE 10
505#define __STAT_NUMBER_FIELD 11
506//
507// read I/Os, write I/Os
508// =====================
509//
510// These values increment when an I/O request completes.
511//
512// read merges, write merges
513// =========================
514//
515// These values increment when an I/O request is merged with an
516// already-queued I/O request.
517//
518// read sectors, write sectors
519// ===========================
520//
521// These values count the number of sectors read from or written to this
522// block device. The "sectors" in question are the standard UNIX 512-byte
523// sectors, not any device- or filesystem-specific block size. The
524// counters are incremented when the I/O completes.
525#define SECTOR_SIZE 512
526//
527// read ticks, write ticks
528// =======================
529//
530// These values count the number of milliseconds that I/O requests have
531// waited on this block device. If there are multiple I/O requests waiting,
532// these values will increase at a rate greater than 1000/second; for
533// example, if 60 read requests wait for an average of 30 ms, the read_ticks
534// field will increase by 60*30 = 1800.
535//
536// in_flight
537// =========
538//
539// This value counts the number of I/O requests that have been issued to
540// the device driver but have not yet completed. It does not include I/O
541// requests that are in the queue but not yet issued to the device driver.
542//
543// io_ticks
544// ========
545//
546// This value counts the number of milliseconds during which the device has
547// had I/O requests queued.
548//
549// time_in_queue
550// =============
551//
552// This value counts the number of milliseconds that I/O requests have waited
553// on this block device. If there are multiple I/O requests waiting, this
554// value will increase as the product of the number of milliseconds times the
555// number of requests waiting (see "read ticks" above for an example).
556#define S_TO_MS 1000
557//
558
Mark Salyzyn326842f2015-04-30 09:49:41 -0700559static int dump_stat_from_fd(const char *title __unused, const char *path, int fd) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800560 unsigned long long fields[__STAT_NUMBER_FIELD];
Mark Salyzyn326842f2015-04-30 09:49:41 -0700561 bool z;
562 char *cp, *buffer = NULL;
563 size_t i = 0;
564 FILE *fp = fdopen(fd, "rb");
565 getline(&buffer, &i, fp);
566 fclose(fp);
567 if (!buffer) {
568 return -errno;
569 }
570 i = strlen(buffer);
571 while ((i > 0) && (buffer[i - 1] == '\n')) {
572 buffer[--i] = '\0';
573 }
574 if (!*buffer) {
575 free(buffer);
576 return 0;
577 }
578 z = true;
579 for (cp = buffer, i = 0; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800580 fields[i] = strtoull(cp, &cp, 10);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700581 if (fields[i] != 0) {
582 z = false;
583 }
584 }
585 if (z) { /* never accessed */
586 free(buffer);
587 return 0;
588 }
589
590 if (!strncmp(path, mmcblk0, sizeof(mmcblk0) - 1)) {
591 path += sizeof(mmcblk0) - 1;
592 }
593
594 printf("%s: %s\n", path, buffer);
595 free(buffer);
596
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800597 if (fields[__STAT_IO_TICKS]) {
598 unsigned long read_perf = 0;
599 unsigned long read_ios = 0;
600 if (fields[__STAT_READ_TICKS]) {
601 unsigned long long divisor = fields[__STAT_READ_TICKS]
602 * fields[__STAT_IO_TICKS];
603 read_perf = ((unsigned long long)SECTOR_SIZE
604 * fields[__STAT_READ_SECTORS]
605 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
606 / divisor;
607 read_ios = ((unsigned long long)S_TO_MS * fields[__STAT_READ_IOS]
608 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
609 / divisor;
610 }
611
612 unsigned long write_perf = 0;
613 unsigned long write_ios = 0;
614 if (fields[__STAT_WRITE_TICKS]) {
615 unsigned long long divisor = fields[__STAT_WRITE_TICKS]
616 * fields[__STAT_IO_TICKS];
617 write_perf = ((unsigned long long)SECTOR_SIZE
618 * fields[__STAT_WRITE_SECTORS]
619 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
620 / divisor;
621 write_ios = ((unsigned long long)S_TO_MS * fields[__STAT_WRITE_IOS]
622 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
623 / divisor;
624 }
625
626 unsigned queue = (fields[__STAT_IN_QUEUE]
627 + (fields[__STAT_IO_TICKS] >> 1))
628 / fields[__STAT_IO_TICKS];
629
630 if (!write_perf && !write_ios) {
631 printf("%s: perf(ios) rd: %luKB/s(%lu/s) q: %u\n",
632 path, read_perf, read_ios, queue);
633 } else {
634 printf("%s: perf(ios) rd: %luKB/s(%lu/s) wr: %luKB/s(%lu/s) q: %u\n",
635 path, read_perf, read_ios, write_perf, write_ios, queue);
636 }
637
638 /* bugreport timeout factor adjustment */
639 if ((write_perf > 1) && (write_perf < worst_write_perf)) {
640 worst_write_perf = write_perf;
641 }
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700642 }
Mark Salyzyn326842f2015-04-30 09:49:41 -0700643 return 0;
644}
645
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700646/* Copied policy from system/core/logd/LogBuffer.cpp */
647
648#define LOG_BUFFER_SIZE (256 * 1024)
649#define LOG_BUFFER_MIN_SIZE (64 * 1024UL)
650#define LOG_BUFFER_MAX_SIZE (256 * 1024 * 1024UL)
651
652static bool valid_size(unsigned long value) {
653 if ((value < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < value)) {
654 return false;
655 }
656
657 long pages = sysconf(_SC_PHYS_PAGES);
658 if (pages < 1) {
659 return true;
660 }
661
662 long pagesize = sysconf(_SC_PAGESIZE);
663 if (pagesize <= 1) {
664 pagesize = PAGE_SIZE;
665 }
666
667 // maximum memory impact a somewhat arbitrary ~3%
668 pages = (pages + 31) / 32;
669 unsigned long maximum = pages * pagesize;
670
671 if ((maximum < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < maximum)) {
672 return true;
673 }
674
675 return value <= maximum;
676}
677
678static unsigned long property_get_size(const char *key) {
679 unsigned long value;
680 char *cp, property[PROPERTY_VALUE_MAX];
681
682 property_get(key, property, "");
683 value = strtoul(property, &cp, 10);
684
685 switch(*cp) {
686 case 'm':
687 case 'M':
688 value *= 1024;
689 /* FALLTHRU */
690 case 'k':
691 case 'K':
692 value *= 1024;
693 /* FALLTHRU */
694 case '\0':
695 break;
696
697 default:
698 value = 0;
699 }
700
701 if (!valid_size(value)) {
702 value = 0;
703 }
704
705 return value;
706}
707
708/* timeout in ms */
Felipe Leme8620bb42015-11-10 11:04:45 -0800709static unsigned long logcat_timeout(const char *name) {
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700710 static const char global_tuneable[] = "persist.logd.size"; // Settings App
711 static const char global_default[] = "ro.logd.size"; // BoardConfig.mk
712 char key[PROP_NAME_MAX];
713 unsigned long property_size, default_size;
714
715 default_size = property_get_size(global_tuneable);
716 if (!default_size) {
717 default_size = property_get_size(global_default);
718 }
719
720 snprintf(key, sizeof(key), "%s.%s", global_tuneable, name);
721 property_size = property_get_size(key);
722
723 if (!property_size) {
724 snprintf(key, sizeof(key), "%s.%s", global_default, name);
725 property_size = property_get_size(key);
726 }
727
728 if (!property_size) {
729 property_size = default_size;
730 }
731
732 if (!property_size) {
733 property_size = LOG_BUFFER_SIZE;
734 }
735
736 /* Engineering margin is ten-fold our guess */
737 return 10 * (property_size + worst_write_perf) / worst_write_perf;
738}
739
740/* End copy from system/core/logd/LogBuffer.cpp */
741
Colin Crossf45fa6b2012-03-26 12:38:26 -0700742/* dumps the current system state to stdout */
Felipe Leme809d74e2016-02-02 12:57:00 -0800743static void print_header(std::string version) {
Colin Crossf45fa6b2012-03-26 12:38:26 -0700744 char build[PROPERTY_VALUE_MAX], fingerprint[PROPERTY_VALUE_MAX];
745 char radio[PROPERTY_VALUE_MAX], bootloader[PROPERTY_VALUE_MAX];
746 char network[PROPERTY_VALUE_MAX], date[80];
Colin Crossf45fa6b2012-03-26 12:38:26 -0700747
748 property_get("ro.build.display.id", build, "(unknown)");
749 property_get("ro.build.fingerprint", fingerprint, "(unknown)");
750 property_get("ro.build.type", build_type, "(unknown)");
Junda Liu58ad9292016-06-12 11:51:54 -0700751 property_get("gsm.version.baseband", radio, "(unknown)");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700752 property_get("ro.bootloader", bootloader, "(unknown)");
753 property_get("gsm.operator.alpha", network, "(unknown)");
754 strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now));
755
756 printf("========================================================\n");
757 printf("== dumpstate: %s\n", date);
758 printf("========================================================\n");
759
760 printf("\n");
761 printf("Build: %s\n", build);
762 printf("Build fingerprint: '%s'\n", fingerprint); /* format is important for other tools */
763 printf("Bootloader: %s\n", bootloader);
764 printf("Radio: %s\n", radio);
765 printf("Network: %s\n", network);
766
767 printf("Kernel: ");
768 dump_file(NULL, "/proc/version");
769 printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
Felipe Leme809d74e2016-02-02 12:57:00 -0800770 printf("Bugreport format version: %s\n", version.c_str());
Felipe Leme8fecfdd2016-02-09 10:40:07 -0800771 printf("Dumpstate info: id=%lu pid=%d\n", id, getpid());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700772 printf("\n");
Felipe Leme78f2c862015-12-21 09:55:22 -0800773}
774
Felipe Leme24b66ee2016-06-16 10:55:26 -0700775// List of file extensions that can cause a zip file attachment to be rejected by some email
776// service providers.
777static const std::set<std::string> PROBLEMATIC_FILE_EXTENSIONS = {
778 ".ade", ".adp", ".bat", ".chm", ".cmd", ".com", ".cpl", ".exe", ".hta", ".ins", ".isp",
779 ".jar", ".jse", ".lib", ".lnk", ".mde", ".msc", ".msp", ".mst", ".pif", ".scr", ".sct",
780 ".shb", ".sys", ".vb", ".vbe", ".vbs", ".vxd", ".wsc", ".wsf", ".wsh"
781};
782
Felipe Leme71ca15e2016-05-19 16:18:17 -0700783bool add_zip_entry_from_fd(const std::string& entry_name, int fd) {
Felipe Leme03974982016-10-21 11:38:26 -0700784 if (!is_zipping()) {
785 MYLOGD("Not adding entry %s from fd because dumpstate is not zipping\n",
Felipe Leme88c79332016-02-22 11:06:49 -0800786 entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800787 return false;
788 }
Felipe Leme24b66ee2016-06-16 10:55:26 -0700789 std::string valid_name = entry_name;
790
791 // Rename extension if necessary.
792 size_t idx = entry_name.rfind(".");
793 if (idx != std::string::npos) {
794 std::string extension = entry_name.substr(idx);
795 std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
796 if (PROBLEMATIC_FILE_EXTENSIONS.count(extension) != 0) {
797 valid_name = entry_name + ".renamed";
798 MYLOGI("Renaming entry %s to %s\n", entry_name.c_str(), valid_name.c_str());
799 }
800 }
801
Felipe Leme6fe9db62016-02-12 09:04:16 -0800802 // Logging statement below is useful to time how long each entry takes, but it's too verbose.
803 // MYLOGD("Adding zip entry %s\n", entry_name.c_str());
Felipe Leme24b66ee2016-06-16 10:55:26 -0700804 int32_t err = zip_writer->StartEntryWithTime(valid_name.c_str(),
Felipe Lemee82a27d2016-01-05 13:35:44 -0800805 ZipWriter::kCompress, get_mtime(fd, now));
806 if (err) {
Felipe Leme24b66ee2016-06-16 10:55:26 -0700807 MYLOGE("zip_writer->StartEntryWithTime(%s): %s\n", valid_name.c_str(),
Felipe Leme809d74e2016-02-02 12:57:00 -0800808 ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800809 return false;
810 }
811
Felipe Leme770410d2016-01-26 17:07:14 -0800812 std::vector<uint8_t> buffer(65536);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800813 while (1) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800814 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), sizeof(buffer)));
815 if (bytes_read == 0) {
816 break;
817 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800818 MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800819 return false;
820 }
821 err = zip_writer->WriteBytes(buffer.data(), bytes_read);
822 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800823 MYLOGE("zip_writer->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800824 return false;
825 }
826 }
827
828 err = zip_writer->FinishEntry();
829 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800830 MYLOGE("zip_writer->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800831 return false;
832 }
833
834 return true;
835}
836
Felipe Leme71ca15e2016-05-19 16:18:17 -0700837bool add_zip_entry(const std::string& entry_name, const std::string& entry_path) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800838 ScopedFd fd(TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
839 if (fd.get() == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800840 MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800841 return false;
842 }
843
844 return add_zip_entry_from_fd(entry_name, fd.get());
845}
846
847/* adds a file to the existing zipped bugreport */
848static int _add_file_from_fd(const char *title, const char *path, int fd) {
849 return add_zip_entry_from_fd(ZIP_ROOT_DIR + path, fd) ? 0 : 1;
850}
851
Felipe Leme24b66ee2016-06-16 10:55:26 -0700852// TODO: move to util.cpp
Felipe Lemee82a27d2016-01-05 13:35:44 -0800853void add_dir(const char *dir, bool recursive) {
Felipe Leme03974982016-10-21 11:38:26 -0700854 if (!is_zipping()) {
855 MYLOGD("Not adding dir %s because dumpstate is not zipping\n", dir);
Felipe Leme111b9d02016-02-03 09:28:24 -0800856 return;
857 }
Felipe Leme88c79332016-02-22 11:06:49 -0800858 MYLOGD("Adding dir %s (recursive: %d)\n", dir, recursive);
Felipe Leme608385d2016-02-01 10:35:38 -0800859 DurationReporter duration_reporter(dir, NULL);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800860 dump_files(NULL, dir, recursive ? skip_none : is_dir, _add_file_from_fd);
861}
862
Felipe Leme03974982016-10-21 11:38:26 -0700863bool is_zipping() {
864 return zip_writer != nullptr;
865}
866
Felipe Leme809d74e2016-02-02 12:57:00 -0800867/* adds a text entry entry to the existing zip file. */
868static bool add_text_zip_entry(const std::string& entry_name, const std::string& content) {
Felipe Leme03974982016-10-21 11:38:26 -0700869 if (!is_zipping()) {
870 MYLOGD("Not adding text entry %s because dumpstate is not zipping\n", entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800871 return false;
872 }
Felipe Lemecbce55d2016-02-08 09:53:18 -0800873 MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -0800874 int32_t err = zip_writer->StartEntryWithTime(entry_name.c_str(), ZipWriter::kCompress, now);
875 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800876 MYLOGE("zip_writer->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
Felipe Leme809d74e2016-02-02 12:57:00 -0800877 ZipWriter::ErrorCodeString(err));
878 return false;
879 }
880
881 err = zip_writer->WriteBytes(content.c_str(), content.length());
882 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800883 MYLOGE("zip_writer->WriteBytes(%s): %s\n", entry_name.c_str(),
Felipe Leme809d74e2016-02-02 12:57:00 -0800884 ZipWriter::ErrorCodeString(err));
885 return false;
886 }
887
888 err = zip_writer->FinishEntry();
889 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800890 MYLOGE("zip_writer->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800891 return false;
892 }
893
894 return true;
895}
896
Felipe Lemec0808152016-06-17 17:37:13 -0700897static void dump_iptables() {
898 run_command("IPTABLES", 10, "iptables", "-L", "-nvx", NULL);
899 run_command("IP6TABLES", 10, "ip6tables", "-L", "-nvx", NULL);
Erik Kline53ca94a2016-09-28 17:26:26 +0900900 run_command("IPTABLES NAT", 10, "iptables", "-t", "nat", "-L", "-nvx", NULL);
Felipe Lemec0808152016-06-17 17:37:13 -0700901 /* no ip6 nat */
Erik Kline53ca94a2016-09-28 17:26:26 +0900902 run_command("IPTABLES MANGLE", 10, "iptables", "-t", "mangle", "-L", "-nvx", NULL);
903 run_command("IP6TABLES MANGLE", 10, "ip6tables", "-t", "mangle", "-L", "-nvx", NULL);
904 run_command("IPTABLES RAW", 10, "iptables", "-t", "raw", "-L", "-nvx", NULL);
905 run_command("IP6TABLES RAW", 10, "ip6tables", "-t", "raw", "-L", "-nvx", NULL);
Felipe Lemec0808152016-06-17 17:37:13 -0700906}
907
Srinath Sridharanfdf52d32016-02-01 15:50:22 -0800908static void dumpstate(const std::string& screenshot_path, const std::string& version) {
Felipe Leme770410d2016-01-26 17:07:14 -0800909 DurationReporter duration_reporter("DUMPSTATE");
Felipe Leme78f2c862015-12-21 09:55:22 -0800910 unsigned long timeout;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700911
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700912 dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700913 run_command("UPTIME", 10, "uptime", NULL);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700914 dump_files("UPTIME MMC PERF", mmcblk0, skip_not_stat, dump_stat_from_fd);
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800915 dump_emmc_ecsd("/d/mmc0/mmc0:0001/ext_csd");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700916 dump_file("MEMORY INFO", "/proc/meminfo");
Elliott Hughesb32c7e12015-11-13 11:32:48 -0800917 run_command("CPU INFO", 10, "top", "-n", "1", "-d", "1", "-m", "30", "-H", NULL);
Nick Kralevich2b1f88b2015-10-07 16:38:42 -0700918 run_command("PROCRANK", 20, SU_PATH, "root", "procrank", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700919 dump_file("VIRTUAL MEMORY STATS", "/proc/vmstat");
920 dump_file("VMALLOC INFO", "/proc/vmallocinfo");
921 dump_file("SLAB INFO", "/proc/slabinfo");
922 dump_file("ZONEINFO", "/proc/zoneinfo");
923 dump_file("PAGETYPEINFO", "/proc/pagetypeinfo");
924 dump_file("BUDDYINFO", "/proc/buddyinfo");
Colin Cross2281af92012-10-28 22:41:06 -0700925 dump_file("FRAGMENTATION INFO", "/d/extfrag/unusable_index");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700926
Todd Poynor29e27a82012-05-22 17:54:59 -0700927 dump_file("KERNEL WAKE SOURCES", "/d/wakeup_sources");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700928 dump_file("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
Mathias Agopian85aea742012-08-08 15:32:02 -0700929 dump_file("KERNEL SYNC", "/d/sync");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700930
Elliott Hughesa3533a32015-10-30 16:17:49 -0700931 run_command("PROCESSES AND THREADS", 10, "ps", "-Z", "-t", "-p", "-P", NULL);
Nick Kralevichb82c9252015-11-27 17:56:13 -0800932 run_command("LIBRANK", 10, SU_PATH, "root", "librank", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700933
Michal Karpinski4db754f2015-12-11 18:04:32 +0000934 run_command("PRINTENV", 10, "printenv", NULL);
Lorenzo Colittif7f26512016-03-11 10:58:55 +0900935 run_command("NETSTAT", 10, "netstat", "-n", NULL);
Michal Karpinski4db754f2015-12-11 18:04:32 +0000936 run_command("LSMOD", 10, "lsmod", NULL);
937
Colin Crossf45fa6b2012-03-26 12:38:26 -0700938 do_dmesg();
939
940 run_command("LIST OF OPEN FILES", 10, SU_PATH, "root", "lsof", NULL);
Jeff Brown1dc94e32014-09-11 14:15:27 -0700941 for_each_pid(do_showmap, "SMAPS OF ALL PROCESSES");
942 for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
Mark Salyzyna297c322016-02-05 15:33:17 -0800943 for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700944
Felipe Leme6e01fa62015-11-11 19:35:14 -0800945 if (!screenshot_path.empty()) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800946 MYLOGI("taking late screenshot\n");
Felipe Lemee338bf62015-12-07 14:03:50 -0800947 take_screenshot(screenshot_path);
Felipe Lemecbce55d2016-02-08 09:53:18 -0800948 MYLOGI("wrote screenshot: %s\n", screenshot_path.c_str());
Jeff Sharkey5a930032013-03-19 15:05:19 -0700949 }
950
Colin Crossf45fa6b2012-03-26 12:38:26 -0700951 // dump_file("EVENT LOG TAGS", "/etc/event-log-tags");
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700952 // calculate timeout
953 timeout = logcat_timeout("main") + logcat_timeout("system") + logcat_timeout("crash");
954 if (timeout < 20000) {
955 timeout = 20000;
956 }
Mark Salyzyn78316382015-10-09 14:02:07 -0700957 run_command("SYSTEM LOG", timeout / 1000, "logcat", "-v", "threadtime",
958 "-v", "printable",
959 "-d",
960 "*:v", NULL);
Mark Salyzyn43afe5d2016-01-26 07:24:08 -0800961 timeout = logcat_timeout("events");
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700962 if (timeout < 20000) {
963 timeout = 20000;
964 }
Mark Salyzyn78316382015-10-09 14:02:07 -0700965 run_command("EVENT LOG", timeout / 1000, "logcat", "-b", "events",
966 "-v", "threadtime",
967 "-v", "printable",
968 "-d",
969 "*:v", NULL);
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700970 timeout = logcat_timeout("radio");
971 if (timeout < 20000) {
972 timeout = 20000;
973 }
Mark Salyzyn78316382015-10-09 14:02:07 -0700974 run_command("RADIO LOG", timeout / 1000, "logcat", "-b", "radio",
975 "-v", "threadtime",
976 "-v", "printable",
977 "-d",
978 "*:v", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700979
Mark Salyzynecc07632015-07-30 14:57:09 -0700980 run_command("LOG STATISTICS", 10, "logcat", "-b", "all", "-S", NULL);
981
Colin Crossf45fa6b2012-03-26 12:38:26 -0700982 /* show the traces we collected in main(), if that was done */
983 if (dump_traces_path != NULL) {
984 dump_file("VM TRACES JUST NOW", dump_traces_path);
985 }
986
987 /* only show ANR traces if they're less than 15 minutes old */
988 struct stat st;
989 char anr_traces_path[PATH_MAX];
990 property_get("dalvik.vm.stack-trace-file", anr_traces_path, "");
991 if (!anr_traces_path[0]) {
992 printf("*** NO VM TRACES FILE DEFINED (dalvik.vm.stack-trace-file)\n\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700993 } else {
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800994 int fd = TEMP_FAILURE_RETRY(open(anr_traces_path,
995 O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700996 if (fd < 0) {
997 printf("*** NO ANR VM TRACES FILE (%s): %s\n\n", anr_traces_path, strerror(errno));
998 } else {
999 dump_file_from_fd("VM TRACES AT LAST ANR", anr_traces_path, fd);
1000 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001001 }
1002
1003 /* slow traces for slow operations */
1004 if (anr_traces_path[0] != 0) {
1005 int tail = strlen(anr_traces_path)-1;
1006 while (tail > 0 && anr_traces_path[tail] != '/') {
1007 tail--;
1008 }
1009 int i = 0;
1010 while (1) {
1011 sprintf(anr_traces_path+tail+1, "slow%02d.txt", i);
1012 if (stat(anr_traces_path, &st)) {
1013 // No traces file at this index, done with the files.
1014 break;
1015 }
1016 dump_file("VM TRACES WHEN SLOW", anr_traces_path);
1017 i++;
1018 }
1019 }
1020
Christopher Ferris7dc7f322014-07-22 16:08:19 -07001021 int dumped = 0;
1022 for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
1023 if (tombstone_data[i].fd != -1) {
Felipe Lemee82a27d2016-01-05 13:35:44 -08001024 const char *name = tombstone_data[i].name;
1025 int fd = tombstone_data[i].fd;
Christopher Ferris7dc7f322014-07-22 16:08:19 -07001026 dumped = 1;
Felipe Lemee82a27d2016-01-05 13:35:44 -08001027 if (zip_writer) {
1028 if (!add_zip_entry_from_fd(ZIP_ROOT_DIR + name, fd)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001029 MYLOGE("Unable to add tombstone %s to zip file\n", name);
Felipe Lemee82a27d2016-01-05 13:35:44 -08001030 }
1031 } else {
1032 dump_file_from_fd("TOMBSTONE", name, fd);
1033 }
1034 close(fd);
Christopher Ferris7dc7f322014-07-22 16:08:19 -07001035 tombstone_data[i].fd = -1;
1036 }
1037 }
1038 if (!dumped) {
1039 printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR);
1040 }
1041
Colin Crossf45fa6b2012-03-26 12:38:26 -07001042 dump_file("NETWORK DEV INFO", "/proc/net/dev");
1043 dump_file("QTAGUID NETWORK INTERFACES INFO", "/proc/net/xt_qtaguid/iface_stat_all");
JP Abgrall012c2ea2012-05-16 20:49:29 -07001044 dump_file("QTAGUID NETWORK INTERFACES INFO (xt)", "/proc/net/xt_qtaguid/iface_stat_fmt");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001045 dump_file("QTAGUID CTRL INFO", "/proc/net/xt_qtaguid/ctrl");
1046 dump_file("QTAGUID STATS INFO", "/proc/net/xt_qtaguid/stats");
1047
Todd Poynor2a83daa2013-11-22 15:44:22 -08001048 if (!stat(PSTORE_LAST_KMSG, &st)) {
1049 /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
1050 dump_file("LAST KMSG", PSTORE_LAST_KMSG);
Mark Salyzynced60782016-06-24 14:06:15 -07001051 } else if (!stat(ALT_PSTORE_LAST_KMSG, &st)) {
1052 dump_file("LAST KMSG", ALT_PSTORE_LAST_KMSG);
Todd Poynor2a83daa2013-11-22 15:44:22 -08001053 } else {
1054 /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
1055 dump_file("LAST KMSG", "/proc/last_kmsg");
1056 }
1057
Mark Salyzyn2262c162014-12-16 09:09:26 -08001058 /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
Mark Salyzyn78316382015-10-09 14:02:07 -07001059 run_command("LAST LOGCAT", 10, "logcat", "-L",
1060 "-b", "all",
1061 "-v", "threadtime",
1062 "-v", "printable",
1063 "-d",
1064 "*:v", NULL);
Mark Salyzyn2262c162014-12-16 09:09:26 -08001065
Colin Crossf45fa6b2012-03-26 12:38:26 -07001066 /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
Elliott Hughesa59828a2015-01-27 20:48:52 -08001067
1068 run_command("NETWORK INTERFACES", 10, "ip", "link", NULL);
Lorenzo Colittid4c3d382014-07-30 14:38:20 +09001069
1070 run_command("IPv4 ADDRESSES", 10, "ip", "-4", "addr", "show", NULL);
1071 run_command("IPv6 ADDRESSES", 10, "ip", "-6", "addr", "show", NULL);
1072
Colin Crossf45fa6b2012-03-26 12:38:26 -07001073 run_command("IP RULES", 10, "ip", "rule", "show", NULL);
1074 run_command("IP RULES v6", 10, "ip", "-6", "rule", "show", NULL);
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -07001075
1076 dump_route_tables();
1077
Lorenzo Colittid4c3d382014-07-30 14:38:20 +09001078 run_command("ARP CACHE", 10, "ip", "-4", "neigh", "show", NULL);
1079 run_command("IPv6 ND CACHE", 10, "ip", "-6", "neigh", "show", NULL);
Erik Klinef7f2b0f2016-05-27 11:29:19 +09001080 run_command("MULTICAST ADDRESSES", 10, "ip", "maddr", NULL);
Felipe Lemec0808152016-06-17 17:37:13 -07001081 run_command("WIFI NETWORKS", 20, "wpa_cli", "IFNAME=wlan0", "list_networks", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001082
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -08001083#ifdef FWDUMP_bcmdhd
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001084 run_command("ND OFFLOAD TABLE", 5,
Erik Kline08165202016-05-30 11:55:44 +09001085 SU_PATH, "root", WLUTIL, "nd_hostip", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001086
1087 run_command("DUMP WIFI INTERNAL COUNTERS (1)", 20,
Erik Kline08165202016-05-30 11:55:44 +09001088 SU_PATH, "root", WLUTIL, "counters", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001089
1090 run_command("ND OFFLOAD STATUS (1)", 5,
Erik Kline08165202016-05-30 11:55:44 +09001091 SU_PATH, "root", WLUTIL, "nd_status", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001092
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -08001093#endif
Dmitry Shmidt0b2c9262012-11-07 11:09:46 -08001094 dump_file("INTERRUPTS (1)", "/proc/interrupts");
1095
Felipe Leme7cff4622016-06-08 09:51:29 -07001096 run_command("NETWORK DIAGNOSTICS", 10, "dumpsys", "-t", "10", "connectivity", "--diag", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001097
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -08001098#ifdef FWDUMP_bcmdhd
Colin Crossf45fa6b2012-03-26 12:38:26 -07001099 run_command("DUMP WIFI STATUS", 20,
1100 SU_PATH, "root", "dhdutil", "-i", "wlan0", "dump", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001101
1102 run_command("DUMP WIFI INTERNAL COUNTERS (2)", 20,
Erik Kline08165202016-05-30 11:55:44 +09001103 SU_PATH, "root", WLUTIL, "counters", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001104
1105 run_command("ND OFFLOAD STATUS (2)", 5,
Erik Kline08165202016-05-30 11:55:44 +09001106 SU_PATH, "root", WLUTIL, "nd_status", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001107#endif
Dmitry Shmidt0b2c9262012-11-07 11:09:46 -08001108 dump_file("INTERRUPTS (2)", "/proc/interrupts");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001109
1110 print_properties();
1111
1112 run_command("VOLD DUMP", 10, "vdc", "dump", NULL);
1113 run_command("SECURE CONTAINERS", 10, "vdc", "asec", "list", NULL);
1114
Ken Sumrall8f75fa72013-02-08 17:35:58 -08001115 run_command("FILESYSTEMS & FREE SPACE", 10, "df", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001116
Colin Crossf45fa6b2012-03-26 12:38:26 -07001117 run_command("LAST RADIO LOG", 10, "parse_radio_log", "/proc/last_radio_log", NULL);
1118
1119 printf("------ BACKLIGHTS ------\n");
1120 printf("LCD brightness=");
1121 dump_file(NULL, "/sys/class/leds/lcd-backlight/brightness");
1122 printf("Button brightness=");
1123 dump_file(NULL, "/sys/class/leds/button-backlight/brightness");
1124 printf("Keyboard brightness=");
1125 dump_file(NULL, "/sys/class/leds/keyboard-backlight/brightness");
1126 printf("ALS mode=");
1127 dump_file(NULL, "/sys/class/leds/lcd-backlight/als");
1128 printf("LCD driver registers:\n");
1129 dump_file(NULL, "/sys/class/leds/lcd-backlight/registers");
1130 printf("\n");
1131
1132 /* Binder state is expensive to look at as it uses a lot of memory. */
1133 dump_file("BINDER FAILED TRANSACTION LOG", "/sys/kernel/debug/binder/failed_transaction_log");
1134 dump_file("BINDER TRANSACTION LOG", "/sys/kernel/debug/binder/transaction_log");
1135 dump_file("BINDER TRANSACTIONS", "/sys/kernel/debug/binder/transactions");
1136 dump_file("BINDER STATS", "/sys/kernel/debug/binder/stats");
1137 dump_file("BINDER STATE", "/sys/kernel/debug/binder/state");
1138
Colin Crossf45fa6b2012-03-26 12:38:26 -07001139 printf("========================================================\n");
1140 printf("== Board\n");
1141 printf("========================================================\n");
1142
1143 dumpstate_board();
1144 printf("\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001145
1146 /* Migrate the ril_dumpstate to a dumpstate_board()? */
1147 char ril_dumpstate_timeout[PROPERTY_VALUE_MAX] = {0};
1148 property_get("ril.dumpstate.timeout", ril_dumpstate_timeout, "30");
1149 if (strnlen(ril_dumpstate_timeout, PROPERTY_VALUE_MAX - 1) > 0) {
Felipe Lemec4eee562016-04-21 15:42:55 -07001150 if (is_user_build()) {
Colin Crossf45fa6b2012-03-26 12:38:26 -07001151 // su does not exist on user builds, so try running without it.
1152 // This way any implementations of vril-dump that do not require
1153 // root can run on user builds.
1154 run_command("DUMP VENDOR RIL LOGS", atoi(ril_dumpstate_timeout),
1155 "vril-dump", NULL);
1156 } else {
1157 run_command("DUMP VENDOR RIL LOGS", atoi(ril_dumpstate_timeout),
1158 SU_PATH, "root", "vril-dump", NULL);
1159 }
1160 }
1161
1162 printf("========================================================\n");
1163 printf("== Android Framework Services\n");
1164 printf("========================================================\n");
1165
Wei Liu34222562016-05-19 13:59:01 -07001166 run_command("DUMPSYS", 60, "dumpsys", "-t", "60", "--skip", "meminfo", "cpuinfo", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001167
1168 printf("========================================================\n");
Dianne Hackborn02bea972013-06-26 18:59:09 -07001169 printf("== Checkins\n");
1170 printf("========================================================\n");
1171
Felipe Leme7cff4622016-06-08 09:51:29 -07001172 run_command("CHECKIN BATTERYSTATS", 30, "dumpsys", "-t", "30", "batterystats", "-c", NULL);
1173 run_command("CHECKIN MEMINFO", 30, "dumpsys", "-t", "30", "meminfo", "--checkin", NULL);
1174 run_command("CHECKIN NETSTATS", 30, "dumpsys", "-t", "30", "netstats", "--checkin", NULL);
1175 run_command("CHECKIN PROCSTATS", 30, "dumpsys", "-t", "30", "procstats", "-c", NULL);
1176 run_command("CHECKIN USAGESTATS", 30, "dumpsys", "-t", "30", "usagestats", "-c", NULL);
1177 run_command("CHECKIN PACKAGE", 30, "dumpsys", "-t", "30", "package", "--checkin", NULL);
Dianne Hackborn02bea972013-06-26 18:59:09 -07001178
1179 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001180 printf("== Running Application Activities\n");
1181 printf("========================================================\n");
1182
Felipe Leme3f83dbe2016-06-10 16:56:33 -07001183 run_command("APP ACTIVITIES", 30, "dumpsys", "-t", "30", "activity", "all", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001184
1185 printf("========================================================\n");
1186 printf("== Running Application Services\n");
1187 printf("========================================================\n");
1188
Felipe Leme3f83dbe2016-06-10 16:56:33 -07001189 run_command("APP SERVICES", 30, "dumpsys", "-t", "30", "activity", "service", "all", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001190
1191 printf("========================================================\n");
1192 printf("== Running Application Providers\n");
1193 printf("========================================================\n");
1194
Junda Liucfc33d42016-06-14 00:09:10 -07001195 run_command("APP PROVIDERS", 30, "dumpsys", "-t", "30", "activity", "provider", "all", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001196
Naveen Kallade591df2016-10-19 21:38:44 -07001197 // dump_modem_logs adds the modem logs if available to the bugreport.
1198 // Do this at the end to allow for sufficient time for the modem logs to be
1199 // collected.
1200 dump_modem_logs();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001201
1202 printf("========================================================\n");
Felipe Leme608385d2016-02-01 10:35:38 -08001203 printf("== Final progress (pid %d): %d/%d (originally %d)\n",
1204 getpid(), progress, weight_total, WEIGHT_TOTAL);
1205 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001206 printf("== dumpstate: done\n");
1207 printf("========================================================\n");
1208}
1209
1210static void usage() {
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001211 fprintf(stderr,
Felipe Leme2628e9e2016-04-12 16:36:51 -07001212 "usage: dumpstate [-h] [-b soundfile] [-e soundfile] [-o file [-d] [-p] "
1213 "[-z]] [-s] [-S] [-q] [-B] [-P] [-R] [-V version]\n"
1214 " -h: display this help message\n"
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001215 " -b: play sound file instead of vibrate, at beginning of job\n"
1216 " -e: play sound file instead of vibrate, at end of job\n"
1217 " -o: write to file (instead of stdout)\n"
1218 " -d: append date to filename (requires -o)\n"
1219 " -p: capture screenshot to filename.png (requires -o)\n"
Felipe Leme2628e9e2016-04-12 16:36:51 -07001220 " -z: generate zipped file (requires -o)\n"
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001221 " -s: write output to control socket (for init)\n"
Felipe Leme2628e9e2016-04-12 16:36:51 -07001222 " -S: write file location to control socket (for init; requires -o and -z)"
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001223 " -q: disable vibrate\n"
1224 " -B: send broadcast when finished (requires -o)\n"
1225 " -P: send broadcast when started and update system properties on "
1226 "progress (requires -o and -B)\n"
1227 " -R: take bugreport in remote mode (requires -o, -z, -d and -B, "
1228 "shouldn't be used with -P)\n"
1229 " -V: sets the bugreport format version (valid values: %s)\n",
1230 VERSION_DEFAULT.c_str());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001231}
1232
Felipe Lemebb6b6042016-10-25 18:18:24 +00001233static void sigpipe_handler(int n) {
1234 // don't complain to stderr or stdout
Andres Morales2e671bb2014-08-21 12:38:22 -07001235 _exit(EXIT_FAILURE);
John Michelau885f8882013-05-06 16:42:02 -05001236}
1237
Felipe Leme1e9edc62015-12-21 16:02:13 -08001238/* adds the temporary report to the existing .zip file, closes the .zip file, and removes the
1239 temporary file.
1240 */
Felipe Lemee82a27d2016-01-05 13:35:44 -08001241static bool finish_zip_file(const std::string& bugreport_name, const std::string& bugreport_path,
Felipe Leme1e9edc62015-12-21 16:02:13 -08001242 time_t now) {
Felipe Lemee82a27d2016-01-05 13:35:44 -08001243 if (!add_zip_entry(bugreport_name, bugreport_path)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001244 MYLOGE("Failed to add text entry to .zip file\n");
Felipe Leme1e9edc62015-12-21 16:02:13 -08001245 return false;
1246 }
Felipe Leme809d74e2016-02-02 12:57:00 -08001247 if (!add_text_zip_entry("main_entry.txt", bugreport_name)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001248 MYLOGE("Failed to add main_entry.txt to .zip file\n");
Felipe Leme111b9d02016-02-03 09:28:24 -08001249 return false;
Felipe Leme809d74e2016-02-02 12:57:00 -08001250 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08001251
Felipe Lemee82a27d2016-01-05 13:35:44 -08001252 int32_t err = zip_writer->Finish();
Felipe Leme1e9edc62015-12-21 16:02:13 -08001253 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001254 MYLOGE("zip_writer->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001255 return false;
1256 }
1257
Felipe Lemec4eee562016-04-21 15:42:55 -07001258 if (is_user_build()) {
1259 MYLOGD("Removing temporary file %s\n", bugreport_path.c_str())
1260 if (remove(bugreport_path.c_str())) {
1261 ALOGW("remove(%s): %s\n", bugreport_path.c_str(), strerror(errno));
1262 }
1263 } else {
1264 MYLOGD("Keeping temporary file %s on non-user build\n", bugreport_path.c_str())
1265 }
1266
Felipe Leme1e9edc62015-12-21 16:02:13 -08001267 return true;
1268}
Felipe Leme6e01fa62015-11-11 19:35:14 -08001269
Michal Karpinski4db754f2015-12-11 18:04:32 +00001270static std::string SHA256_file_hash(std::string filepath) {
Michal Karpinskicbbdf732016-01-07 20:45:02 +00001271 ScopedFd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC
1272 | O_NOFOLLOW)));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001273 if (fd.get() == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001274 MYLOGE("open(%s): %s\n", filepath.c_str(), strerror(errno));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001275 return NULL;
1276 }
1277
1278 SHA256_CTX ctx;
1279 SHA256_init(&ctx);
1280
1281 std::vector<uint8_t> buffer(65536);
1282 while (1) {
1283 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd.get(), buffer.data(), buffer.size()));
1284 if (bytes_read == 0) {
1285 break;
1286 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001287 MYLOGE("read(%s): %s\n", filepath.c_str(), strerror(errno));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001288 return NULL;
1289 }
1290
1291 SHA256_update(&ctx, buffer.data(), bytes_read);
1292 }
1293
1294 uint8_t hash[SHA256_DIGEST_SIZE];
1295 memcpy(hash, SHA256_final(&ctx), SHA256_DIGEST_SIZE);
1296 char hash_buffer[SHA256_DIGEST_SIZE * 2 + 1];
Michal Karpinskicbbdf732016-01-07 20:45:02 +00001297 for(size_t i = 0; i < SHA256_DIGEST_SIZE; i++) {
1298 sprintf(hash_buffer + (i * 2), "%02x", hash[i]);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001299 }
1300 hash_buffer[sizeof(hash_buffer) - 1] = 0;
1301 return std::string(hash_buffer);
1302}
1303
Colin Crossf45fa6b2012-03-26 12:38:26 -07001304int main(int argc, char *argv[]) {
Felipe Lemebb6b6042016-10-25 18:18:24 +00001305 struct sigaction sigact;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001306 int do_add_date = 0;
Felipe Leme6e01fa62015-11-11 19:35:14 -08001307 int do_zip_file = 0;
John Michelau1f794c42012-09-17 11:20:19 -05001308 int do_vibrate = 1;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001309 char* use_outfile = 0;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001310 int use_socket = 0;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001311 int use_control_socket = 0;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001312 int do_fb = 0;
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07001313 int do_broadcast = 0;
Felipe Lemee338bf62015-12-07 14:03:50 -08001314 int do_early_screenshot = 0;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001315 int is_remote_mode = 0;
Felipe Leme809d74e2016-02-02 12:57:00 -08001316 std::string version = VERSION_DEFAULT;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001317
Felipe Lemee82a27d2016-01-05 13:35:44 -08001318 now = time(NULL);
1319
Felipe Lemecbce55d2016-02-08 09:53:18 -08001320 MYLOGI("begin\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001321
Felipe Leme8fecfdd2016-02-09 10:40:07 -08001322 /* gets the sequential id */
1323 char last_id[PROPERTY_VALUE_MAX];
1324 property_get("dumpstate.last_id", last_id, "0");
1325 id = strtoul(last_id, NULL, 10) + 1;
Nick Kralevichf0922cc2016-05-14 16:47:44 -07001326 snprintf(last_id, sizeof(last_id), "%lu", id);
Felipe Leme8fecfdd2016-02-09 10:40:07 -08001327 property_set("dumpstate.last_id", last_id);
1328 MYLOGI("dumpstate id: %lu\n", id);
1329
Felipe Lemebb6b6042016-10-25 18:18:24 +00001330 /* clear SIGPIPE handler */
1331 memset(&sigact, 0, sizeof(sigact));
1332 sigact.sa_handler = sigpipe_handler;
1333 sigaction(SIGPIPE, &sigact, NULL);
1334
Colin Crossf45fa6b2012-03-26 12:38:26 -07001335 /* set as high priority, and protect from OOM killer */
1336 setpriority(PRIO_PROCESS, 0, -20);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001337
1338 FILE *oom_adj = fopen("/proc/self/oom_score_adj", "we");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001339 if (oom_adj) {
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001340 fputs("-1000", oom_adj);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001341 fclose(oom_adj);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001342 } else {
1343 /* fallback to kernels <= 2.6.35 */
1344 oom_adj = fopen("/proc/self/oom_adj", "we");
1345 if (oom_adj) {
1346 fputs("-17", oom_adj);
1347 fclose(oom_adj);
1348 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001349 }
1350
Jeff Brown1dc94e32014-09-11 14:15:27 -07001351 /* parse arguments */
Felipe Lemea34efb72016-03-11 09:33:32 -08001352 std::string args;
1353 format_args(argc, const_cast<const char **>(argv), &args);
1354 MYLOGD("Dumpstate command line: %s\n", args.c_str());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001355 int c;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001356 while ((c = getopt(argc, argv, "dho:svqzpPBRSV:")) != -1) {
Colin Crossf45fa6b2012-03-26 12:38:26 -07001357 switch (c) {
Felipe Leme71bbfc52015-11-23 14:14:51 -08001358 case 'd': do_add_date = 1; break;
1359 case 'z': do_zip_file = 1; break;
1360 case 'o': use_outfile = optarg; break;
1361 case 's': use_socket = 1; break;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001362 case 'S': use_control_socket = 1; break;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001363 case 'v': break; // compatibility no-op
Felipe Leme71bbfc52015-11-23 14:14:51 -08001364 case 'q': do_vibrate = 0; break;
1365 case 'p': do_fb = 1; break;
1366 case 'P': do_update_progress = 1; break;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001367 case 'R': is_remote_mode = 1; break;
Felipe Leme71bbfc52015-11-23 14:14:51 -08001368 case 'B': do_broadcast = 1; break;
Felipe Leme809d74e2016-02-02 12:57:00 -08001369 case 'V': version = optarg; break;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001370 case '?': printf("\n");
1371 case 'h':
1372 usage();
1373 exit(1);
1374 }
1375 }
1376
Felipe Leme71bbfc52015-11-23 14:14:51 -08001377 if ((do_zip_file || do_add_date || do_update_progress || do_broadcast) && !use_outfile) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001378 usage();
1379 exit(1);
1380 }
1381
Felipe Leme2628e9e2016-04-12 16:36:51 -07001382 if (use_control_socket && !do_zip_file) {
1383 usage();
1384 exit(1);
1385 }
1386
Felipe Leme71bbfc52015-11-23 14:14:51 -08001387 if (do_update_progress && !do_broadcast) {
1388 usage();
1389 exit(1);
1390 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001391
Michal Karpinski4db754f2015-12-11 18:04:32 +00001392 if (is_remote_mode && (do_update_progress || !do_broadcast || !do_zip_file || !do_add_date)) {
1393 usage();
1394 exit(1);
1395 }
1396
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001397 if (version != VERSION_DEFAULT) {
1398 usage();
1399 exit(1);
Felipe Leme809d74e2016-02-02 12:57:00 -08001400 }
1401
Felipe Lemecbce55d2016-02-08 09:53:18 -08001402 MYLOGI("bugreport format version: %s\n", version.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -08001403
Felipe Lemee338bf62015-12-07 14:03:50 -08001404 do_early_screenshot = do_update_progress;
1405
Christopher Ferrised9354f2014-10-01 17:35:01 -07001406 // If we are going to use a socket, do it as early as possible
1407 // to avoid timeouts from bugreport.
1408 if (use_socket) {
1409 redirect_to_socket(stdout, "dumpstate");
1410 }
1411
Felipe Leme2628e9e2016-04-12 16:36:51 -07001412 if (use_control_socket) {
1413 MYLOGD("Opening control socket\n");
1414 control_socket_fd = open_socket("dumpstate");
Felipe Leme02b7e002016-07-22 12:03:20 -07001415 do_update_progress = 1;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001416 }
1417
Felipe Lemecbce55d2016-02-08 09:53:18 -08001418 /* full path of the temporary file containing the bugreport */
Felipe Lemead5f6c42015-11-30 14:26:46 -08001419 std::string tmp_path;
1420
Felipe Lemecbce55d2016-02-08 09:53:18 -08001421 /* full path of the file containing the dumpstate logs*/
1422 std::string log_path;
1423
Felipe Leme14e034a2016-03-30 18:51:03 -07001424 /* full path of the systrace file, when enabled */
1425 std::string systrace_path;
1426
Felipe Lemee338bf62015-12-07 14:03:50 -08001427 /* full path of the temporary file containing the screenshot (when requested) */
1428 std::string screenshot_path;
1429
Felipe Lemecbce55d2016-02-08 09:53:18 -08001430 /* base name (without suffix or extensions) of the bugreport files */
Felipe Lemead5f6c42015-11-30 14:26:46 -08001431 std::string base_name;
1432
Felipe Leme71bbfc52015-11-23 14:14:51 -08001433 /* pointer to the actual path, be it zip or text */
1434 std::string path;
1435
Felipe Leme635ca312016-01-05 14:23:02 -08001436 /* pointer to the zipped file */
Felipe Leme1e9edc62015-12-21 16:02:13 -08001437 std::unique_ptr<FILE, int(*)(FILE*)> zip_file(NULL, fclose);
Felipe Leme71bbfc52015-11-23 14:14:51 -08001438
Felipe Lemead5f6c42015-11-30 14:26:46 -08001439 /* redirect output if needed */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001440 bool is_redirecting = !use_socket && use_outfile;
1441
1442 if (is_redirecting) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001443 bugreport_dir = dirname(use_outfile);
1444 base_name = basename(use_outfile);
Felipe Leme71bbfc52015-11-23 14:14:51 -08001445 if (do_add_date) {
1446 char date[80];
Felipe Lemead5f6c42015-11-30 14:26:46 -08001447 strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&now));
1448 suffix = date;
1449 } else {
1450 suffix = "undated";
Felipe Leme71bbfc52015-11-23 14:14:51 -08001451 }
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001452 char build_id[PROPERTY_VALUE_MAX];
1453 property_get("ro.build.id", build_id, "UNKNOWN_BUILD");
1454 base_name = base_name + "-" + build_id;
Felipe Leme71bbfc52015-11-23 14:14:51 -08001455 if (do_fb) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001456 // TODO: if dumpstate was an object, the paths could be internal variables and then
1457 // we could have a function to calculate the derived values, such as:
1458 // screenshot_path = GetPath(".png");
1459 screenshot_path = bugreport_dir + "/" + base_name + "-" + suffix + ".png";
Felipe Leme71bbfc52015-11-23 14:14:51 -08001460 }
Felipe Lemead5f6c42015-11-30 14:26:46 -08001461 tmp_path = bugreport_dir + "/" + base_name + "-" + suffix + ".tmp";
Felipe Lemecbce55d2016-02-08 09:53:18 -08001462 log_path = bugreport_dir + "/dumpstate_log-" + suffix + "-"
1463 + std::to_string(getpid()) + ".txt";
Felipe Leme71bbfc52015-11-23 14:14:51 -08001464
Felipe Lemecbce55d2016-02-08 09:53:18 -08001465 MYLOGD("Bugreport dir: %s\n"
1466 "Base name: %s\n"
1467 "Suffix: %s\n"
1468 "Log path: %s\n"
1469 "Temporary path: %s\n"
1470 "Screenshot path: %s\n",
1471 bugreport_dir.c_str(), base_name.c_str(), suffix.c_str(),
1472 log_path.c_str(), tmp_path.c_str(), screenshot_path.c_str());
Felipe Leme71bbfc52015-11-23 14:14:51 -08001473
Felipe Leme1e9edc62015-12-21 16:02:13 -08001474 if (do_zip_file) {
Felipe Leme1e9edc62015-12-21 16:02:13 -08001475 path = bugreport_dir + "/" + base_name + "-" + suffix + ".zip";
Felipe Leme26bd34c2016-03-15 13:40:33 -07001476 MYLOGD("Creating initial .zip file (%s)\n", path.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -08001477 create_parent_dirs(path.c_str());
Felipe Leme1e9edc62015-12-21 16:02:13 -08001478 zip_file.reset(fopen(path.c_str(), "wb"));
1479 if (!zip_file) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001480 MYLOGE("fopen(%s, 'wb'): %s\n", path.c_str(), strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001481 do_zip_file = 0;
1482 } else {
1483 zip_writer.reset(new ZipWriter(zip_file.get()));
1484 }
Felipe Leme809d74e2016-02-02 12:57:00 -08001485 add_text_zip_entry("version.txt", version);
Felipe Leme1e9edc62015-12-21 16:02:13 -08001486 }
1487
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07001488 if (do_update_progress) {
1489 if (do_broadcast) {
1490 // clang-format off
1491 std::vector<std::string> am_args = {
1492 "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
1493 "--es", "android.intent.extra.NAME", suffix,
1494 "--ei", "android.intent.extra.ID", std::to_string(id),
1495 "--ei", "android.intent.extra.PID", std::to_string(getpid()),
1496 "--ei", "android.intent.extra.MAX", std::to_string(WEIGHT_TOTAL),
1497 };
1498 // clang-format on
1499 send_broadcast("android.intent.action.BUGREPORT_STARTED", am_args);
1500 }
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001501 if (use_control_socket) {
1502 dprintf(control_socket_fd, "BEGIN:%s\n", path.c_str());
1503 }
Felipe Leme71bbfc52015-11-23 14:14:51 -08001504 }
1505 }
1506
Nick Kralevichf3599b32016-01-25 15:05:16 -08001507 /* read /proc/cmdline before dropping root */
1508 FILE *cmdline = fopen("/proc/cmdline", "re");
1509 if (cmdline) {
1510 fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
1511 fclose(cmdline);
1512 }
1513
Jeff Brown1dc94e32014-09-11 14:15:27 -07001514 /* open the vibrator before dropping root */
Felipe Leme6e01fa62015-11-11 19:35:14 -08001515 std::unique_ptr<FILE, int(*)(FILE*)> vibrator(NULL, fclose);
John Michelau1f794c42012-09-17 11:20:19 -05001516 if (do_vibrate) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001517 vibrator.reset(fopen("/sys/class/timed_output/vibrator/enable", "we"));
Jeff Brown1dc94e32014-09-11 14:15:27 -07001518 if (vibrator) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001519 vibrate(vibrator.get(), 150);
Jeff Brown1dc94e32014-09-11 14:15:27 -07001520 }
John Michelau1f794c42012-09-17 11:20:19 -05001521 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001522
Felipe Leme3634a1e2015-12-09 10:11:47 -08001523 if (do_fb && do_early_screenshot) {
1524 if (screenshot_path.empty()) {
1525 // should not have happened
Felipe Lemecbce55d2016-02-08 09:53:18 -08001526 MYLOGE("INTERNAL ERROR: skipping early screenshot because path was not set\n");
Felipe Leme3634a1e2015-12-09 10:11:47 -08001527 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001528 MYLOGI("taking early screenshot\n");
Felipe Leme3634a1e2015-12-09 10:11:47 -08001529 take_screenshot(screenshot_path);
Felipe Lemecbce55d2016-02-08 09:53:18 -08001530 MYLOGI("wrote screenshot: %s\n", screenshot_path.c_str());
Felipe Leme3634a1e2015-12-09 10:11:47 -08001531 if (chown(screenshot_path.c_str(), AID_SHELL, AID_SHELL)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001532 MYLOGE("Unable to change ownership of screenshot file %s: %s\n",
Felipe Leme3634a1e2015-12-09 10:11:47 -08001533 screenshot_path.c_str(), strerror(errno));
1534 }
Felipe Lemee338bf62015-12-07 14:03:50 -08001535 }
1536 }
1537
Felipe Leme1e9edc62015-12-21 16:02:13 -08001538 if (do_zip_file) {
1539 if (chown(path.c_str(), AID_SHELL, AID_SHELL)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001540 MYLOGE("Unable to change ownership of zip file %s: %s\n", path.c_str(), strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001541 }
1542 }
1543
Felipe Leme71bbfc52015-11-23 14:14:51 -08001544 if (is_redirecting) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001545 redirect_to_file(stderr, const_cast<char*>(log_path.c_str()));
Felipe Leme6fe9db62016-02-12 09:04:16 -08001546 if (chown(log_path.c_str(), AID_SHELL, AID_SHELL)) {
1547 MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n",
1548 log_path.c_str(), strerror(errno));
1549 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001550 /* TODO: rather than generating a text file now and zipping it later,
1551 it would be more efficient to redirect stdout to the zip entry
1552 directly, but the libziparchive doesn't support that option yet. */
1553 redirect_to_file(stdout, const_cast<char*>(tmp_path.c_str()));
Felipe Leme6fe9db62016-02-12 09:04:16 -08001554 if (chown(tmp_path.c_str(), AID_SHELL, AID_SHELL)) {
1555 MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
1556 tmp_path.c_str(), strerror(errno));
1557 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001558 }
Felipe Leme608385d2016-02-01 10:35:38 -08001559 // NOTE: there should be no stdout output until now, otherwise it would break the header.
1560 // In particular, DurationReport objects should be created passing 'title, NULL', so their
Felipe Lemecbce55d2016-02-08 09:53:18 -08001561 // duration is logged into MYLOG instead.
Felipe Leme809d74e2016-02-02 12:57:00 -08001562 print_header(version);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001563
Felipe Leme71a74ac2016-03-17 15:43:25 -07001564 // Dumps systrace right away, otherwise it will be filled with unnecessary events.
Zhengyin Qian068ecc72016-08-10 16:48:14 -07001565 // First try to dump anrd trace if the daemon is running. Otherwise, dump
1566 // the raw trace.
1567 if (!dump_anrd_trace()) {
1568 dump_systrace();
1569 }
Felipe Leme71a74ac2016-03-17 15:43:25 -07001570
Wei Liu341938b2016-04-27 16:18:17 -07001571 // TODO: Drop root user and move into dumpstate() once b/28633932 is fixed.
Felipe Lemeefd7e272016-05-18 09:27:16 -07001572 dump_raft();
Wei Liu341938b2016-04-27 16:18:17 -07001573
Felipe Leme9c74aad2016-02-29 18:15:42 -08001574 // Invoking the following dumpsys calls before dump_traces() to try and
1575 // keep the system stats as close to its initial state as possible.
Thierry Strudel8b78b752016-03-22 10:25:44 -07001576 run_command_as_shell("DUMPSYS MEMINFO", 30, "dumpsys", "-t", "30", "meminfo", "-a", NULL);
Felipe Leme7cff4622016-06-08 09:51:29 -07001577 run_command_as_shell("DUMPSYS CPUINFO", 10, "dumpsys", "-t", "10", "cpuinfo", "-a", NULL);
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001578
1579 /* collect stack traces from Dalvik and native processes (needs root) */
1580 dump_traces_path = dump_traces();
1581
Felipe Lemec0808152016-06-17 17:37:13 -07001582 /* Run some operations that require root. */
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001583 get_tombstone_fds(tombstone_data);
1584 add_dir(RECOVERY_DIR, true);
Mark Salyzynd6ab0112016-03-25 12:56:39 -07001585 add_dir(RECOVERY_DATA_DIR, true);
Mark Salyzyn4d42dea2016-04-01 10:03:14 -07001586 add_dir(LOGPERSIST_DATA_DIR, false);
David Brazdild2991962016-06-03 14:40:44 +01001587 if (!is_user_build()) {
1588 add_dir(PROFILE_DATA_DIR_CUR, true);
1589 add_dir(PROFILE_DATA_DIR_REF, true);
1590 }
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001591 add_mountinfo();
Felipe Lemec0808152016-06-17 17:37:13 -07001592 dump_iptables();
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001593
Erik Kline53ca94a2016-09-28 17:26:26 +09001594 // Capture any IPSec policies in play. No keys are exposed here.
1595 run_command("IP XFRM POLICY", 10, "ip", "xfrm", "policy", nullptr);
1596
Lorenzo Colittid3b809b2016-09-26 13:37:45 +09001597 // Run ss as root so we can see socket marks.
1598 run_command("DETAILED SOCKET STATE", 10, "ss", "-eionptu", NULL);
1599
Felipe Lemecf6a8b42016-03-11 10:38:19 -08001600 if (!drop_root_user()) {
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001601 return -1;
1602 }
1603
1604 dumpstate(do_early_screenshot ? "": screenshot_path, version);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001605
Felipe Leme55b42a62015-11-10 17:39:08 -08001606 /* close output if needed */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001607 if (is_redirecting) {
Colin Crossf45fa6b2012-03-26 12:38:26 -07001608 fclose(stdout);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001609 }
1610
Felipe Leme6e01fa62015-11-11 19:35:14 -08001611 /* rename or zip the (now complete) .tmp file to its final location */
1612 if (use_outfile) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001613
1614 /* check if user changed the suffix using system properties */
1615 char key[PROPERTY_KEY_MAX];
1616 char value[PROPERTY_VALUE_MAX];
Nick Kralevichf0922cc2016-05-14 16:47:44 -07001617 snprintf(key, sizeof(key), "dumpstate.%d.name", getpid());
Felipe Lemead5f6c42015-11-30 14:26:46 -08001618 property_get(key, value, "");
1619 bool change_suffix= false;
1620 if (value[0]) {
1621 /* must whitelist which characters are allowed, otherwise it could cross directories */
1622 std::regex valid_regex("^[-_a-zA-Z0-9]+$");
1623 if (std::regex_match(value, valid_regex)) {
1624 change_suffix = true;
1625 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001626 MYLOGE("invalid suffix provided by user: %s\n", value);
Felipe Lemead5f6c42015-11-30 14:26:46 -08001627 }
1628 }
1629 if (change_suffix) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001630 MYLOGI("changing suffix from %s to %s\n", suffix.c_str(), value);
Felipe Lemead5f6c42015-11-30 14:26:46 -08001631 suffix = value;
1632 if (!screenshot_path.empty()) {
1633 std::string new_screenshot_path =
1634 bugreport_dir + "/" + base_name + "-" + suffix + ".png";
1635 if (rename(screenshot_path.c_str(), new_screenshot_path.c_str())) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001636 MYLOGE("rename(%s, %s): %s\n", screenshot_path.c_str(),
Felipe Lemead5f6c42015-11-30 14:26:46 -08001637 new_screenshot_path.c_str(), strerror(errno));
1638 } else {
1639 screenshot_path = new_screenshot_path;
1640 }
1641 }
1642 }
1643
Felipe Leme6e01fa62015-11-11 19:35:14 -08001644 bool do_text_file = true;
1645 if (do_zip_file) {
Felipe Leme88c79332016-02-22 11:06:49 -08001646 std::string entry_name = base_name + "-" + suffix + ".txt";
1647 MYLOGD("Adding main entry (%s) to .zip bugreport\n", entry_name.c_str());
1648 if (!finish_zip_file(entry_name, tmp_path, now)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001649 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
Felipe Leme6e01fa62015-11-11 19:35:14 -08001650 do_text_file = true;
1651 } else {
1652 do_text_file = false;
Felipe Leme91274352016-02-26 15:03:52 -08001653 // Since zip file is already created, it needs to be renamed.
1654 std::string new_path = bugreport_dir + "/" + base_name + "-" + suffix + ".zip";
1655 if (path != new_path) {
1656 MYLOGD("Renaming zip file from %s to %s\n", path.c_str(), new_path.c_str());
1657 if (rename(path.c_str(), new_path.c_str())) {
1658 MYLOGE("rename(%s, %s): %s\n", path.c_str(),
1659 new_path.c_str(), strerror(errno));
1660 } else {
1661 path = new_path;
1662 }
1663 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001664 }
1665 }
1666 if (do_text_file) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001667 path = bugreport_dir + "/" + base_name + "-" + suffix + ".txt";
Felipe Leme88c79332016-02-22 11:06:49 -08001668 MYLOGD("Generating .txt bugreport at %s from %s\n", path.c_str(), tmp_path.c_str());
Felipe Lemead5f6c42015-11-30 14:26:46 -08001669 if (rename(tmp_path.c_str(), path.c_str())) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001670 MYLOGE("rename(%s, %s): %s\n", tmp_path.c_str(), path.c_str(), strerror(errno));
Felipe Leme6e01fa62015-11-11 19:35:14 -08001671 path.clear();
1672 }
1673 }
Felipe Leme2628e9e2016-04-12 16:36:51 -07001674 if (use_control_socket) {
1675 if (do_text_file) {
1676 dprintf(control_socket_fd, "FAIL:could not create zip file, check %s "
1677 "for more details\n", log_path.c_str());
1678 } else {
1679 dprintf(control_socket_fd, "OK:%s\n", path.c_str());
1680 }
1681 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001682 }
1683
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08001684 /* vibrate a few but shortly times to let user know it's finished */
1685 if (vibrator) {
1686 for (int i = 0; i < 3; i++) {
1687 vibrate(vibrator.get(), 75);
1688 usleep((75 + 50) * 1000);
1689 }
1690 }
1691
Jeff Brown1dc94e32014-09-11 14:15:27 -07001692 /* tell activity manager we're done */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001693 if (do_broadcast) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001694 if (!path.empty()) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001695 MYLOGI("Final bugreport path: %s\n", path.c_str());
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001696 // clang-format off
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001697 std::vector<std::string> am_args = {
Felipe Leme43fd1bb2016-01-29 09:07:57 -08001698 "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
Felipe Leme8fecfdd2016-02-09 10:40:07 -08001699 "--ei", "android.intent.extra.ID", std::to_string(id),
Felipe Leme71bbfc52015-11-23 14:14:51 -08001700 "--ei", "android.intent.extra.PID", std::to_string(getpid()),
Felipe Lemeee2e4a02016-02-22 18:12:11 -08001701 "--ei", "android.intent.extra.MAX", std::to_string(weight_total),
Felipe Lemecbce55d2016-02-08 09:53:18 -08001702 "--es", "android.intent.extra.BUGREPORT", path,
1703 "--es", "android.intent.extra.DUMPSTATE_LOG", log_path
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001704 };
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001705 // clang-format on
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001706 if (do_fb) {
1707 am_args.push_back("--es");
1708 am_args.push_back("android.intent.extra.SCREENSHOT");
1709 am_args.push_back(screenshot_path);
1710 }
Michal Karpinski4db754f2015-12-11 18:04:32 +00001711 if (is_remote_mode) {
1712 am_args.push_back("--es");
1713 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
1714 am_args.push_back(SHA256_file_hash(path));
1715 send_broadcast("android.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
1716 } else {
1717 send_broadcast("android.intent.action.BUGREPORT_FINISHED", am_args);
1718 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001719 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001720 MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
Felipe Leme6e01fa62015-11-11 19:35:14 -08001721 }
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07001722 }
1723
Felipe Lemecbce55d2016-02-08 09:53:18 -08001724 MYLOGD("Final progress: %d/%d (originally %d)\n", progress, weight_total, WEIGHT_TOTAL);
1725 MYLOGI("done\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001726
Felipe Leme107a05f2016-03-08 15:11:15 -08001727 if (is_redirecting) {
1728 fclose(stderr);
1729 }
1730
Felipe Leme02b7e002016-07-22 12:03:20 -07001731 if (use_control_socket && control_socket_fd != -1) {
1732 MYLOGD("Closing control socket\n");
1733 close(control_socket_fd);
Felipe Leme2628e9e2016-04-12 16:36:51 -07001734 }
1735
Colin Crossf45fa6b2012-03-26 12:38:26 -07001736 return 0;
1737}