blob: 44cc499bb2ec6678cac3fc7e751696682280ac87 [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>
Mark Salyzyn8f37aa52015-06-12 12:28:24 -070026#include <stdbool.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070027#include <stdio.h>
28#include <stdlib.h>
Felipe Leme6e01fa62015-11-11 19:35:14 -080029#include <string>
Colin Crossf45fa6b2012-03-26 12:38:26 -070030#include <string.h>
Christopher Ferris7dc7f322014-07-22 16:08:19 -070031#include <sys/prctl.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070032#include <sys/resource.h>
33#include <sys/stat.h>
34#include <sys/time.h>
35#include <sys/wait.h>
36#include <unistd.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070037
Elliott Hughes9dc117c2015-12-07 14:21:50 -080038#include <android-base/stringprintf.h>
Andreas Gampefcc8db92016-07-18 18:01:27 -070039#include <android-base/unique_fd.h>
Zhengyin Qian068ecc72016-08-10 16:48:14 -070040#include <android-base/file.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070041#include <cutils/properties.h>
42
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070043#include <private/android_filesystem_config.h>
44#include <private/android_logger.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070045
46#include "dumpstate.h"
Felipe Leme6e01fa62015-11-11 19:35:14 -080047#include "ziparchive/zip_writer.h"
48
Elliott Hughesc4dc1412016-04-12 16:28:31 -070049#include <openssl/sha.h>
Michal Karpinski4db754f2015-12-11 18:04:32 +000050
Felipe Leme6e01fa62015-11-11 19:35:14 -080051using android::base::StringPrintf;
Colin Crossf45fa6b2012-03-26 12:38:26 -070052
53/* read before root is shed */
54static char cmdline_buf[16384] = "(unknown)";
55static const char *dump_traces_path = NULL;
56
Felipe Lemeefd7e272016-05-18 09:27:16 -070057// TODO: variables below should be part of dumpstate object
Felipe Leme8fecfdd2016-02-09 10:40:07 -080058static unsigned long id;
Felipe Leme78f2c862015-12-21 09:55:22 -080059static char build_type[PROPERTY_VALUE_MAX];
Felipe Lemee82a27d2016-01-05 13:35:44 -080060static time_t now;
61static std::unique_ptr<ZipWriter> zip_writer;
Felipe Leme635ca312016-01-05 14:23:02 -080062static std::set<std::string> mount_points;
63void add_mountinfo();
Felipe Leme02b7e002016-07-22 12:03:20 -070064int control_socket_fd = -1;
Felipe Lemeefd7e272016-05-18 09:27:16 -070065/* suffix of the bugreport files - it's typically the date (when invoked with -d),
66 * although it could be changed by the user using a system property */
67static std::string suffix;
Felipe Leme78f2c862015-12-21 09:55:22 -080068
Todd Poynor2a83daa2013-11-22 15:44:22 -080069#define PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops"
Mark Salyzyn7d0a7622016-06-24 14:06:15 -070070#define ALT_PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops-0"
Todd Poynor2a83daa2013-11-22 15:44:22 -080071
Wei Liu341938b2016-04-27 16:18:17 -070072#define RAFT_DIR "/data/misc/raft"
Felipe Lemee82a27d2016-01-05 13:35:44 -080073#define RECOVERY_DIR "/cache/recovery"
Mark Salyzynd6ab0112016-03-25 12:56:39 -070074#define RECOVERY_DATA_DIR "/data/misc/recovery"
Mark Salyzyn4d42dea2016-04-01 10:03:14 -070075#define LOGPERSIST_DATA_DIR "/data/misc/logd"
David Brazdild2991962016-06-03 14:40:44 +010076#define PROFILE_DATA_DIR_CUR "/data/misc/profiles/cur"
77#define PROFILE_DATA_DIR_REF "/data/misc/profiles/ref"
Christopher Ferris7dc7f322014-07-22 16:08:19 -070078#define TOMBSTONE_DIR "/data/tombstones"
79#define TOMBSTONE_FILE_PREFIX TOMBSTONE_DIR "/tombstone_"
80/* Can accomodate a tombstone number up to 9999. */
81#define TOMBSTONE_MAX_LEN (sizeof(TOMBSTONE_FILE_PREFIX) + 4)
82#define NUM_TOMBSTONES 10
Erik Kline08165202016-05-30 11:55:44 +090083#define WLUTIL "/vendor/xbin/wlutil"
Christopher Ferris7dc7f322014-07-22 16:08:19 -070084
85typedef struct {
86 char name[TOMBSTONE_MAX_LEN];
87 int fd;
88} tombstone_data_t;
89
90static tombstone_data_t tombstone_data[NUM_TOMBSTONES];
91
Felipe Leme71ca15e2016-05-19 16:18:17 -070092const std::string ZIP_ROOT_DIR = "FS";
93std::string bugreport_dir;
Felipe Lemee82a27d2016-01-05 13:35:44 -080094
Felipe Leme809d74e2016-02-02 12:57:00 -080095/*
96 * List of supported zip format versions.
97 *
98 * See bugreport-format.txt for more info.
99 */
Felipe Lemeca9c12e2016-05-19 16:30:15 -0700100static std::string VERSION_DEFAULT = "1.0";
Felipe Leme809d74e2016-02-02 12:57:00 -0800101
Calvin On249beee2016-06-03 15:17:07 -0700102bool is_user_build() {
Felipe Lemec4eee562016-04-21 15:42:55 -0700103 return 0 == strncmp(build_type, "user", PROPERTY_VALUE_MAX - 1);
104}
105
Felipe Lemee82a27d2016-01-05 13:35:44 -0800106/* gets the tombstone data, according to the bugreport type: if zipped gets all tombstones,
107 * otherwise gets just those modified in the last half an hour. */
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700108static void get_tombstone_fds(tombstone_data_t data[NUM_TOMBSTONES]) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800109 time_t thirty_minutes_ago = now - 60*30;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700110 for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
111 snprintf(data[i].name, sizeof(data[i].name), "%s%02zu", TOMBSTONE_FILE_PREFIX, i);
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800112 int fd = TEMP_FAILURE_RETRY(open(data[i].name,
113 O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700114 struct stat st;
115 if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode) &&
Felipe Lemee82a27d2016-01-05 13:35:44 -0800116 (zip_writer || (time_t) st.st_mtime >= thirty_minutes_ago)) {
117 data[i].fd = fd;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700118 } else {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800119 close(fd);
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700120 data[i].fd = -1;
121 }
122 }
123}
124
Felipe Leme635ca312016-01-05 14:23:02 -0800125// for_each_pid() callback to get mount info about a process.
126void do_mountinfo(int pid, const char *name) {
127 char path[PATH_MAX];
128
129 // Gets the the content of the /proc/PID/ns/mnt link, so only unique mount points
130 // are added.
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700131 snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800132 char linkname[PATH_MAX];
133 ssize_t r = readlink(path, linkname, PATH_MAX);
134 if (r == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800135 MYLOGE("Unable to read link for %s: %s\n", path, strerror(errno));
Felipe Leme635ca312016-01-05 14:23:02 -0800136 return;
137 }
138 linkname[r] = '\0';
139
140 if (mount_points.find(linkname) == mount_points.end()) {
141 // First time this mount point was found: add it
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700142 snprintf(path, sizeof(path), "/proc/%d/mountinfo", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800143 if (add_zip_entry(ZIP_ROOT_DIR + path, path)) {
144 mount_points.insert(linkname);
145 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800146 MYLOGE("Unable to add mountinfo %s to zip file\n", path);
Felipe Leme635ca312016-01-05 14:23:02 -0800147 }
148 }
149}
150
151void add_mountinfo() {
Felipe Leme03974982016-10-21 11:38:26 -0700152 if (!is_zipping()) return;
Felipe Leme635ca312016-01-05 14:23:02 -0800153 const char *title = "MOUNT INFO";
154 mount_points.clear();
Felipe Leme608385d2016-02-01 10:35:38 -0800155 DurationReporter duration_reporter(title, NULL);
Felipe Leme635ca312016-01-05 14:23:02 -0800156 for_each_pid(do_mountinfo, NULL);
Felipe Leme1b0225a2016-02-09 16:35:14 -0800157 MYLOGD("%s: %d entries added to zip file\n", title, (int) mount_points.size());
Felipe Leme635ca312016-01-05 14:23:02 -0800158}
159
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700160static void dump_dev_files(const char *title, const char *driverpath, const char *filename)
161{
162 DIR *d;
163 struct dirent *de;
164 char path[PATH_MAX];
165
166 d = opendir(driverpath);
167 if (d == NULL) {
168 return;
169 }
170
171 while ((de = readdir(d))) {
172 if (de->d_type != DT_LNK) {
173 continue;
174 }
175 snprintf(path, sizeof(path), "%s/%s/%s", driverpath, de->d_name, filename);
176 dump_file(title, path);
177 }
178
179 closedir(d);
180}
181
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700182// return pid of a userspace process. If not found or error, return 0.
183static unsigned int pid_of_process(const char* ps_name) {
184 DIR *proc_dir;
185 struct dirent *ps;
186 unsigned int pid;
187 std::string cmdline;
188
189 if (!(proc_dir = opendir("/proc"))) {
190 MYLOGE("Can't open /proc\n");
191 return 0;
192 }
193
194 while ((ps = readdir(proc_dir))) {
195 if (!(pid = atoi(ps->d_name))) {
196 continue;
197 }
198 android::base::ReadFileToString("/proc/"
199 + std::string(ps->d_name) + "/cmdline", &cmdline);
200 if (cmdline.find(ps_name) == std::string::npos) {
201 continue;
202 } else {
203 closedir(proc_dir);
204 return pid;
205 }
206 }
207 closedir(proc_dir);
208 return 0;
209}
210
211// dump anrd's trace and add to the zip file.
212// 1. check if anrd is running on this device.
213// 2. send a SIGUSR1 to its pid which will dump anrd's trace.
214// 3. wait until the trace generation completes and add to the zip file.
215static bool dump_anrd_trace() {
216 unsigned int pid;
217 char buf[50], path[PATH_MAX];
218 struct dirent *trace;
219 struct stat st;
220 DIR *trace_dir;
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700221 int retry = 5;
222 long max_ctime = 0, old_mtime;
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700223 long long cur_size = 0;
224 const char *trace_path = "/data/misc/anrd/";
225
226 if (!zip_writer) {
227 MYLOGE("Not dumping anrd trace because zip_writer is not set\n");
228 return false;
229 }
230
231 // find anrd's pid if it is running.
232 pid = pid_of_process("/system/xbin/anrd");
233
234 if (pid > 0) {
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700235 if (stat(trace_path, &st) == 0) {
236 old_mtime = st.st_mtime;
237 } else {
238 MYLOGE("Failed to find: %s\n", trace_path);
239 return false;
240 }
241
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700242 // send SIGUSR1 to the anrd to generate a trace.
243 sprintf(buf, "%u", pid);
244 if (run_command("ANRD_DUMP", 1, "kill", "-SIGUSR1", buf, NULL)) {
245 MYLOGE("anrd signal timed out. Please manually collect trace\n");
246 return false;
247 }
248
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700249 while (retry-- > 0 && old_mtime == st.st_mtime) {
250 sleep(1);
251 stat(trace_path, &st);
252 }
253
254 if (retry < 0 && old_mtime == st.st_mtime) {
255 MYLOGE("Failed to stat %s or trace creation timeout\n", trace_path);
256 return false;
257 }
258
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700259 // identify the trace file by its creation time.
260 if (!(trace_dir = opendir(trace_path))) {
261 MYLOGE("Can't open trace file under %s\n", trace_path);
262 }
263 while ((trace = readdir(trace_dir))) {
264 if (strcmp(trace->d_name, ".") == 0
265 || strcmp(trace->d_name, "..") == 0) {
266 continue;
267 }
268 sprintf(path, "%s%s", trace_path, trace->d_name);
269 if (stat(path, &st) == 0) {
270 if (st.st_ctime > max_ctime) {
271 max_ctime = st.st_ctime;
272 sprintf(buf, "%s", trace->d_name);
273 }
274 }
275 }
276 closedir(trace_dir);
277
278 // Wait until the dump completes by checking the size of the trace.
279 if (max_ctime > 0) {
280 sprintf(path, "%s%s", trace_path, buf);
281 while(true) {
282 sleep(1);
283 if (stat(path, &st) == 0) {
284 if (st.st_size == cur_size) {
285 break;
286 } else if (st.st_size > cur_size) {
287 cur_size = st.st_size;
288 } else {
289 return false;
290 }
291 } else {
292 MYLOGE("Cant stat() %s anymore\n", path);
293 return false;
294 }
295 }
296 // Add to the zip file.
297 if (!add_zip_entry("anrd_trace.txt", path)) {
298 MYLOGE("Unable to add anrd_trace file %s to zip file\n", path);
299 } else {
300 if (remove(path)) {
301 MYLOGE("Error removing anrd_trace file %s: %s", path, strerror(errno));
302 }
303 return true;
304 }
305 } else {
306 MYLOGE("Can't stats any trace file under %s\n", trace_path);
307 }
308 }
309 return false;
310}
311
Felipe Lemeefd7e272016-05-18 09:27:16 -0700312static void dump_systrace() {
Felipe Leme03974982016-10-21 11:38:26 -0700313 if (!is_zipping()) {
314 MYLOGD("Not dumping systrace because dumpstate is not zipping\n");
Felipe Leme71a74ac2016-03-17 15:43:25 -0700315 return;
316 }
Felipe Lemeefd7e272016-05-18 09:27:16 -0700317 std::string systrace_path = bugreport_dir + "/systrace-" + suffix + ".txt";
Felipe Leme14e034a2016-03-30 18:51:03 -0700318 if (systrace_path.empty()) {
319 MYLOGE("Not dumping systrace because path is empty\n");
320 return;
321 }
Felipe Leme71a74ac2016-03-17 15:43:25 -0700322 const char* path = "/sys/kernel/debug/tracing/tracing_on";
323 long int is_tracing;
324 if (read_file_as_long(path, &is_tracing)) {
325 return; // error already logged
326 }
327 if (is_tracing <= 0) {
328 MYLOGD("Skipping systrace because '%s' content is '%ld'\n", path, is_tracing);
329 return;
330 }
331
Felipe Leme14e034a2016-03-30 18:51:03 -0700332 MYLOGD("Running '/system/bin/atrace --async_dump -o %s', which can take several minutes",
333 systrace_path.c_str());
334 if (run_command("SYSTRACE", 120, "/system/bin/atrace", "--async_dump", "-o",
335 systrace_path.c_str(), NULL)) {
336 MYLOGE("systrace timed out, its zip entry will be incomplete\n");
337 // TODO: run_command tries to kill the process, but atrace doesn't die peacefully; ideally,
338 // we should call strace to stop itself, but there is no such option yet (just a
339 // --async_stop, which stops and dump
340 // if (run_command("SYSTRACE", 10, "/system/bin/atrace", "--kill", NULL)) {
341 // MYLOGE("could not stop systrace ");
342 // }
343 }
344 if (!add_zip_entry("systrace.txt", systrace_path)) {
345 MYLOGE("Unable to add systrace file %s to zip file\n", systrace_path.c_str());
Felipe Leme71a74ac2016-03-17 15:43:25 -0700346 } else {
Felipe Leme14e034a2016-03-30 18:51:03 -0700347 if (remove(systrace_path.c_str())) {
348 MYLOGE("Error removing systrace file %s: %s", systrace_path.c_str(), strerror(errno));
349 }
Felipe Leme71a74ac2016-03-17 15:43:25 -0700350 }
351}
352
Felipe Lemeefd7e272016-05-18 09:27:16 -0700353static void dump_raft() {
Wei Liu341938b2016-04-27 16:18:17 -0700354 if (is_user_build()) {
355 return;
356 }
357
Felipe Lemeefd7e272016-05-18 09:27:16 -0700358 std::string raft_log_path = bugreport_dir + "/raft_log.txt";
Wei Liu341938b2016-04-27 16:18:17 -0700359 if (raft_log_path.empty()) {
360 MYLOGD("raft_log_path is empty\n");
361 return;
362 }
Wei Liuf0e78d42016-05-25 14:21:02 -0700363
364 struct stat s;
365 if (stat(RAFT_DIR, &s) != 0 || !S_ISDIR(s.st_mode)) {
366 MYLOGD("%s does not exist or is not a directory\n", RAFT_DIR);
367 return;
368 }
369
Felipe Leme03974982016-10-21 11:38:26 -0700370 if (!is_zipping()) {
Wei Liu310525a2016-05-25 11:28:57 -0700371 // Write compressed and encoded raft logs to stdout if not zip_writer.
372 run_command("RAFT LOGS", 600, "logcompressor", "-r", RAFT_DIR, NULL);
Wei Liu341938b2016-04-27 16:18:17 -0700373 return;
374 }
375
376 run_command("RAFT LOGS", 600, "logcompressor", "-n", "-r", RAFT_DIR,
377 "-o", raft_log_path.c_str(), NULL);
378 if (!add_zip_entry("raft_log.txt", raft_log_path)) {
379 MYLOGE("Unable to add raft log %s to zip file\n", raft_log_path.c_str());
380 } else {
381 if (remove(raft_log_path.c_str())) {
Felipe Lemeefd7e272016-05-18 09:27:16 -0700382 MYLOGE("Error removing raft file %s: %s\n", raft_log_path.c_str(), strerror(errno));
Wei Liu341938b2016-04-27 16:18:17 -0700383 }
384 }
385}
386
Mark Salyzyn326842f2015-04-30 09:49:41 -0700387static bool skip_not_stat(const char *path) {
388 static const char stat[] = "/stat";
389 size_t len = strlen(path);
390 if (path[len - 1] == '/') { /* Directory? */
391 return false;
392 }
393 return strcmp(path + len - sizeof(stat) + 1, stat); /* .../stat? */
394}
395
Felipe Lemee82a27d2016-01-05 13:35:44 -0800396static bool skip_none(const char *path) {
397 return false;
398}
399
Mark Salyzyn326842f2015-04-30 09:49:41 -0700400static const char mmcblk0[] = "/sys/block/mmcblk0/";
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700401unsigned long worst_write_perf = 20000; /* in KB/s */
Mark Salyzyn326842f2015-04-30 09:49:41 -0700402
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800403//
404// stat offsets
405// Name units description
406// ---- ----- -----------
407// read I/Os requests number of read I/Os processed
408#define __STAT_READ_IOS 0
409// read merges requests number of read I/Os merged with in-queue I/O
410#define __STAT_READ_MERGES 1
411// read sectors sectors number of sectors read
412#define __STAT_READ_SECTORS 2
413// read ticks milliseconds total wait time for read requests
414#define __STAT_READ_TICKS 3
415// write I/Os requests number of write I/Os processed
416#define __STAT_WRITE_IOS 4
417// write merges requests number of write I/Os merged with in-queue I/O
418#define __STAT_WRITE_MERGES 5
419// write sectors sectors number of sectors written
420#define __STAT_WRITE_SECTORS 6
421// write ticks milliseconds total wait time for write requests
422#define __STAT_WRITE_TICKS 7
423// in_flight requests number of I/Os currently in flight
424#define __STAT_IN_FLIGHT 8
425// io_ticks milliseconds total time this block device has been active
426#define __STAT_IO_TICKS 9
427// time_in_queue milliseconds total wait time for all requests
428#define __STAT_IN_QUEUE 10
429#define __STAT_NUMBER_FIELD 11
430//
431// read I/Os, write I/Os
432// =====================
433//
434// These values increment when an I/O request completes.
435//
436// read merges, write merges
437// =========================
438//
439// These values increment when an I/O request is merged with an
440// already-queued I/O request.
441//
442// read sectors, write sectors
443// ===========================
444//
445// These values count the number of sectors read from or written to this
446// block device. The "sectors" in question are the standard UNIX 512-byte
447// sectors, not any device- or filesystem-specific block size. The
448// counters are incremented when the I/O completes.
449#define SECTOR_SIZE 512
450//
451// read ticks, write ticks
452// =======================
453//
454// These values count the number of milliseconds that I/O requests have
455// waited on this block device. If there are multiple I/O requests waiting,
456// these values will increase at a rate greater than 1000/second; for
457// example, if 60 read requests wait for an average of 30 ms, the read_ticks
458// field will increase by 60*30 = 1800.
459//
460// in_flight
461// =========
462//
463// This value counts the number of I/O requests that have been issued to
464// the device driver but have not yet completed. It does not include I/O
465// requests that are in the queue but not yet issued to the device driver.
466//
467// io_ticks
468// ========
469//
470// This value counts the number of milliseconds during which the device has
471// had I/O requests queued.
472//
473// time_in_queue
474// =============
475//
476// This value counts the number of milliseconds that I/O requests have waited
477// on this block device. If there are multiple I/O requests waiting, this
478// value will increase as the product of the number of milliseconds times the
479// number of requests waiting (see "read ticks" above for an example).
480#define S_TO_MS 1000
481//
482
Mark Salyzyn326842f2015-04-30 09:49:41 -0700483static int dump_stat_from_fd(const char *title __unused, const char *path, int fd) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800484 unsigned long long fields[__STAT_NUMBER_FIELD];
Mark Salyzyn326842f2015-04-30 09:49:41 -0700485 bool z;
486 char *cp, *buffer = NULL;
487 size_t i = 0;
488 FILE *fp = fdopen(fd, "rb");
489 getline(&buffer, &i, fp);
490 fclose(fp);
491 if (!buffer) {
492 return -errno;
493 }
494 i = strlen(buffer);
495 while ((i > 0) && (buffer[i - 1] == '\n')) {
496 buffer[--i] = '\0';
497 }
498 if (!*buffer) {
499 free(buffer);
500 return 0;
501 }
502 z = true;
503 for (cp = buffer, i = 0; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800504 fields[i] = strtoull(cp, &cp, 10);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700505 if (fields[i] != 0) {
506 z = false;
507 }
508 }
509 if (z) { /* never accessed */
510 free(buffer);
511 return 0;
512 }
513
514 if (!strncmp(path, mmcblk0, sizeof(mmcblk0) - 1)) {
515 path += sizeof(mmcblk0) - 1;
516 }
517
518 printf("%s: %s\n", path, buffer);
519 free(buffer);
520
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800521 if (fields[__STAT_IO_TICKS]) {
522 unsigned long read_perf = 0;
523 unsigned long read_ios = 0;
524 if (fields[__STAT_READ_TICKS]) {
525 unsigned long long divisor = fields[__STAT_READ_TICKS]
526 * fields[__STAT_IO_TICKS];
527 read_perf = ((unsigned long long)SECTOR_SIZE
528 * fields[__STAT_READ_SECTORS]
529 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
530 / divisor;
531 read_ios = ((unsigned long long)S_TO_MS * fields[__STAT_READ_IOS]
532 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
533 / divisor;
534 }
535
536 unsigned long write_perf = 0;
537 unsigned long write_ios = 0;
538 if (fields[__STAT_WRITE_TICKS]) {
539 unsigned long long divisor = fields[__STAT_WRITE_TICKS]
540 * fields[__STAT_IO_TICKS];
541 write_perf = ((unsigned long long)SECTOR_SIZE
542 * fields[__STAT_WRITE_SECTORS]
543 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
544 / divisor;
545 write_ios = ((unsigned long long)S_TO_MS * fields[__STAT_WRITE_IOS]
546 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
547 / divisor;
548 }
549
550 unsigned queue = (fields[__STAT_IN_QUEUE]
551 + (fields[__STAT_IO_TICKS] >> 1))
552 / fields[__STAT_IO_TICKS];
553
554 if (!write_perf && !write_ios) {
555 printf("%s: perf(ios) rd: %luKB/s(%lu/s) q: %u\n",
556 path, read_perf, read_ios, queue);
557 } else {
558 printf("%s: perf(ios) rd: %luKB/s(%lu/s) wr: %luKB/s(%lu/s) q: %u\n",
559 path, read_perf, read_ios, write_perf, write_ios, queue);
560 }
561
562 /* bugreport timeout factor adjustment */
563 if ((write_perf > 1) && (write_perf < worst_write_perf)) {
564 worst_write_perf = write_perf;
565 }
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700566 }
Mark Salyzyn326842f2015-04-30 09:49:41 -0700567 return 0;
568}
569
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700570/* timeout in ms */
Felipe Leme8620bb42015-11-10 11:04:45 -0800571static unsigned long logcat_timeout(const char *name) {
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -0700572 log_id_t id = android_name_to_log_id(name);
573 unsigned long property_size = __android_logger_get_buffer_size(id);
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700574 /* Engineering margin is ten-fold our guess */
575 return 10 * (property_size + worst_write_perf) / worst_write_perf;
576}
577
Colin Crossf45fa6b2012-03-26 12:38:26 -0700578/* dumps the current system state to stdout */
Felipe Leme809d74e2016-02-02 12:57:00 -0800579static void print_header(std::string version) {
Colin Crossf45fa6b2012-03-26 12:38:26 -0700580 char build[PROPERTY_VALUE_MAX], fingerprint[PROPERTY_VALUE_MAX];
581 char radio[PROPERTY_VALUE_MAX], bootloader[PROPERTY_VALUE_MAX];
582 char network[PROPERTY_VALUE_MAX], date[80];
Colin Crossf45fa6b2012-03-26 12:38:26 -0700583
584 property_get("ro.build.display.id", build, "(unknown)");
585 property_get("ro.build.fingerprint", fingerprint, "(unknown)");
586 property_get("ro.build.type", build_type, "(unknown)");
Junda Liu58ad9292016-06-12 11:51:54 -0700587 property_get("gsm.version.baseband", radio, "(unknown)");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700588 property_get("ro.bootloader", bootloader, "(unknown)");
589 property_get("gsm.operator.alpha", network, "(unknown)");
590 strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now));
591
592 printf("========================================================\n");
593 printf("== dumpstate: %s\n", date);
594 printf("========================================================\n");
595
596 printf("\n");
597 printf("Build: %s\n", build);
598 printf("Build fingerprint: '%s'\n", fingerprint); /* format is important for other tools */
599 printf("Bootloader: %s\n", bootloader);
600 printf("Radio: %s\n", radio);
601 printf("Network: %s\n", network);
602
603 printf("Kernel: ");
604 dump_file(NULL, "/proc/version");
605 printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
Felipe Leme809d74e2016-02-02 12:57:00 -0800606 printf("Bugreport format version: %s\n", version.c_str());
Felipe Leme8fecfdd2016-02-09 10:40:07 -0800607 printf("Dumpstate info: id=%lu pid=%d\n", id, getpid());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700608 printf("\n");
Felipe Leme78f2c862015-12-21 09:55:22 -0800609}
610
Felipe Leme24b66ee2016-06-16 10:55:26 -0700611// List of file extensions that can cause a zip file attachment to be rejected by some email
612// service providers.
613static const std::set<std::string> PROBLEMATIC_FILE_EXTENSIONS = {
614 ".ade", ".adp", ".bat", ".chm", ".cmd", ".com", ".cpl", ".exe", ".hta", ".ins", ".isp",
615 ".jar", ".jse", ".lib", ".lnk", ".mde", ".msc", ".msp", ".mst", ".pif", ".scr", ".sct",
616 ".shb", ".sys", ".vb", ".vbe", ".vbs", ".vxd", ".wsc", ".wsf", ".wsh"
617};
618
Felipe Leme71ca15e2016-05-19 16:18:17 -0700619bool add_zip_entry_from_fd(const std::string& entry_name, int fd) {
Felipe Leme03974982016-10-21 11:38:26 -0700620 if (!is_zipping()) {
621 MYLOGD("Not adding entry %s from fd because dumpstate is not zipping\n",
Felipe Leme88c79332016-02-22 11:06:49 -0800622 entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800623 return false;
624 }
Felipe Leme24b66ee2016-06-16 10:55:26 -0700625 std::string valid_name = entry_name;
626
627 // Rename extension if necessary.
628 size_t idx = entry_name.rfind(".");
629 if (idx != std::string::npos) {
630 std::string extension = entry_name.substr(idx);
631 std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
632 if (PROBLEMATIC_FILE_EXTENSIONS.count(extension) != 0) {
633 valid_name = entry_name + ".renamed";
634 MYLOGI("Renaming entry %s to %s\n", entry_name.c_str(), valid_name.c_str());
635 }
636 }
637
Felipe Leme6fe9db62016-02-12 09:04:16 -0800638 // Logging statement below is useful to time how long each entry takes, but it's too verbose.
639 // MYLOGD("Adding zip entry %s\n", entry_name.c_str());
Felipe Leme24b66ee2016-06-16 10:55:26 -0700640 int32_t err = zip_writer->StartEntryWithTime(valid_name.c_str(),
Felipe Lemee82a27d2016-01-05 13:35:44 -0800641 ZipWriter::kCompress, get_mtime(fd, now));
642 if (err) {
Felipe Leme24b66ee2016-06-16 10:55:26 -0700643 MYLOGE("zip_writer->StartEntryWithTime(%s): %s\n", valid_name.c_str(),
Felipe Leme809d74e2016-02-02 12:57:00 -0800644 ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800645 return false;
646 }
647
Felipe Leme770410d2016-01-26 17:07:14 -0800648 std::vector<uint8_t> buffer(65536);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800649 while (1) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800650 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), sizeof(buffer)));
651 if (bytes_read == 0) {
652 break;
653 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800654 MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800655 return false;
656 }
657 err = zip_writer->WriteBytes(buffer.data(), bytes_read);
658 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800659 MYLOGE("zip_writer->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800660 return false;
661 }
662 }
663
664 err = zip_writer->FinishEntry();
665 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800666 MYLOGE("zip_writer->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800667 return false;
668 }
669
670 return true;
671}
672
Felipe Leme71ca15e2016-05-19 16:18:17 -0700673bool add_zip_entry(const std::string& entry_name, const std::string& entry_path) {
Andreas Gampe27cd7b22016-07-18 18:24:05 -0700674 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK
675 | O_CLOEXEC)));
Andreas Gampefcc8db92016-07-18 18:01:27 -0700676 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800677 MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800678 return false;
679 }
680
681 return add_zip_entry_from_fd(entry_name, fd.get());
682}
683
684/* adds a file to the existing zipped bugreport */
685static int _add_file_from_fd(const char *title, const char *path, int fd) {
686 return add_zip_entry_from_fd(ZIP_ROOT_DIR + path, fd) ? 0 : 1;
687}
688
Felipe Leme24b66ee2016-06-16 10:55:26 -0700689// TODO: move to util.cpp
Felipe Lemee82a27d2016-01-05 13:35:44 -0800690void add_dir(const char *dir, bool recursive) {
Felipe Leme03974982016-10-21 11:38:26 -0700691 if (!is_zipping()) {
692 MYLOGD("Not adding dir %s because dumpstate is not zipping\n", dir);
Felipe Leme111b9d02016-02-03 09:28:24 -0800693 return;
694 }
Felipe Leme88c79332016-02-22 11:06:49 -0800695 MYLOGD("Adding dir %s (recursive: %d)\n", dir, recursive);
Felipe Leme608385d2016-02-01 10:35:38 -0800696 DurationReporter duration_reporter(dir, NULL);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800697 dump_files(NULL, dir, recursive ? skip_none : is_dir, _add_file_from_fd);
698}
699
Felipe Leme03974982016-10-21 11:38:26 -0700700bool is_zipping() {
701 return zip_writer != nullptr;
702}
703
Felipe Leme809d74e2016-02-02 12:57:00 -0800704/* adds a text entry entry to the existing zip file. */
705static bool add_text_zip_entry(const std::string& entry_name, const std::string& content) {
Felipe Leme03974982016-10-21 11:38:26 -0700706 if (!is_zipping()) {
707 MYLOGD("Not adding text entry %s because dumpstate is not zipping\n", entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800708 return false;
709 }
Felipe Lemecbce55d2016-02-08 09:53:18 -0800710 MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -0800711 int32_t err = zip_writer->StartEntryWithTime(entry_name.c_str(), ZipWriter::kCompress, now);
712 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800713 MYLOGE("zip_writer->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
Felipe Leme809d74e2016-02-02 12:57:00 -0800714 ZipWriter::ErrorCodeString(err));
715 return false;
716 }
717
718 err = zip_writer->WriteBytes(content.c_str(), content.length());
719 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800720 MYLOGE("zip_writer->WriteBytes(%s): %s\n", entry_name.c_str(),
Felipe Leme809d74e2016-02-02 12:57:00 -0800721 ZipWriter::ErrorCodeString(err));
722 return false;
723 }
724
725 err = zip_writer->FinishEntry();
726 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800727 MYLOGE("zip_writer->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800728 return false;
729 }
730
731 return true;
732}
733
Felipe Lemec0808152016-06-17 17:37:13 -0700734static void dump_iptables() {
735 run_command("IPTABLES", 10, "iptables", "-L", "-nvx", NULL);
736 run_command("IP6TABLES", 10, "ip6tables", "-L", "-nvx", NULL);
Erik Kline53ca94a2016-09-28 17:26:26 +0900737 run_command("IPTABLES NAT", 10, "iptables", "-t", "nat", "-L", "-nvx", NULL);
Felipe Lemec0808152016-06-17 17:37:13 -0700738 /* no ip6 nat */
Erik Kline53ca94a2016-09-28 17:26:26 +0900739 run_command("IPTABLES MANGLE", 10, "iptables", "-t", "mangle", "-L", "-nvx", NULL);
740 run_command("IP6TABLES MANGLE", 10, "ip6tables", "-t", "mangle", "-L", "-nvx", NULL);
741 run_command("IPTABLES RAW", 10, "iptables", "-t", "raw", "-L", "-nvx", NULL);
742 run_command("IP6TABLES RAW", 10, "ip6tables", "-t", "raw", "-L", "-nvx", NULL);
Felipe Lemec0808152016-06-17 17:37:13 -0700743}
744
Srinath Sridharanfdf52d32016-02-01 15:50:22 -0800745static void dumpstate(const std::string& screenshot_path, const std::string& version) {
Felipe Leme770410d2016-01-26 17:07:14 -0800746 DurationReporter duration_reporter("DUMPSTATE");
Felipe Leme78f2c862015-12-21 09:55:22 -0800747 unsigned long timeout;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700748
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700749 dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700750 run_command("UPTIME", 10, "uptime", NULL);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700751 dump_files("UPTIME MMC PERF", mmcblk0, skip_not_stat, dump_stat_from_fd);
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800752 dump_emmc_ecsd("/d/mmc0/mmc0:0001/ext_csd");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700753 dump_file("MEMORY INFO", "/proc/meminfo");
Elliott Hughes52860032016-06-14 13:56:00 -0700754 run_command("CPU INFO", 10, "top", "-b", "-n", "1", "-H", "-s", "6",
Elliott Hughes646e92f2016-06-13 17:35:07 -0700755 "-o", "pid,tid,user,pr,ni,%cpu,s,virt,res,pcy,cmd,name", NULL);
Nick Kralevich2b1f88b2015-10-07 16:38:42 -0700756 run_command("PROCRANK", 20, SU_PATH, "root", "procrank", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700757 dump_file("VIRTUAL MEMORY STATS", "/proc/vmstat");
758 dump_file("VMALLOC INFO", "/proc/vmallocinfo");
759 dump_file("SLAB INFO", "/proc/slabinfo");
760 dump_file("ZONEINFO", "/proc/zoneinfo");
761 dump_file("PAGETYPEINFO", "/proc/pagetypeinfo");
762 dump_file("BUDDYINFO", "/proc/buddyinfo");
Colin Cross2281af92012-10-28 22:41:06 -0700763 dump_file("FRAGMENTATION INFO", "/d/extfrag/unusable_index");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700764
Todd Poynor29e27a82012-05-22 17:54:59 -0700765 dump_file("KERNEL WAKE SOURCES", "/d/wakeup_sources");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700766 dump_file("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
Mathias Agopian85aea742012-08-08 15:32:02 -0700767 dump_file("KERNEL SYNC", "/d/sync");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700768
Elliott Hughes52860032016-06-14 13:56:00 -0700769 run_command("PROCESSES AND THREADS", 10, "ps", "-A", "-T", "-Z",
Elliott Hughes32caf1d2016-05-04 14:03:54 -0700770 "-O", "pri,nice,rtprio,sched,pcy", NULL);
Nick Kralevichb82c9252015-11-27 17:56:13 -0800771 run_command("LIBRANK", 10, SU_PATH, "root", "librank", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700772
Michal Karpinski4db754f2015-12-11 18:04:32 +0000773 run_command("PRINTENV", 10, "printenv", NULL);
Elliott Hughes0adb3a32016-10-28 08:53:02 -0700774 run_command("NETSTAT", 10, "netstat", "-nW", NULL);
Michal Karpinski4db754f2015-12-11 18:04:32 +0000775 run_command("LSMOD", 10, "lsmod", NULL);
776
Colin Crossf45fa6b2012-03-26 12:38:26 -0700777 do_dmesg();
778
779 run_command("LIST OF OPEN FILES", 10, SU_PATH, "root", "lsof", NULL);
Jeff Brown1dc94e32014-09-11 14:15:27 -0700780 for_each_pid(do_showmap, "SMAPS OF ALL PROCESSES");
781 for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
Mark Salyzyna297c322016-02-05 15:33:17 -0800782 for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700783
Ajay Panicker2f531772016-09-14 12:26:46 -0700784 /* Dump Bluetooth HCI logs */
785 add_dir("/data/misc/bluetooth/logs", true);
786
Felipe Leme6e01fa62015-11-11 19:35:14 -0800787 if (!screenshot_path.empty()) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800788 MYLOGI("taking late screenshot\n");
Felipe Lemee338bf62015-12-07 14:03:50 -0800789 take_screenshot(screenshot_path);
Felipe Lemecbce55d2016-02-08 09:53:18 -0800790 MYLOGI("wrote screenshot: %s\n", screenshot_path.c_str());
Jeff Sharkey5a930032013-03-19 15:05:19 -0700791 }
792
Colin Crossf45fa6b2012-03-26 12:38:26 -0700793 // dump_file("EVENT LOG TAGS", "/etc/event-log-tags");
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700794 // calculate timeout
795 timeout = logcat_timeout("main") + logcat_timeout("system") + logcat_timeout("crash");
796 if (timeout < 20000) {
797 timeout = 20000;
798 }
Mark Salyzyn78316382015-10-09 14:02:07 -0700799 run_command("SYSTEM LOG", timeout / 1000, "logcat", "-v", "threadtime",
800 "-v", "printable",
801 "-d",
802 "*:v", NULL);
Mark Salyzyn43afe5d2016-01-26 07:24:08 -0800803 timeout = logcat_timeout("events");
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700804 if (timeout < 20000) {
805 timeout = 20000;
806 }
Mark Salyzyn78316382015-10-09 14:02:07 -0700807 run_command("EVENT LOG", timeout / 1000, "logcat", "-b", "events",
808 "-v", "threadtime",
809 "-v", "printable",
810 "-d",
811 "*:v", NULL);
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700812 timeout = logcat_timeout("radio");
813 if (timeout < 20000) {
814 timeout = 20000;
815 }
Mark Salyzyn78316382015-10-09 14:02:07 -0700816 run_command("RADIO LOG", timeout / 1000, "logcat", "-b", "radio",
817 "-v", "threadtime",
818 "-v", "printable",
819 "-d",
820 "*:v", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700821
Mark Salyzynecc07632015-07-30 14:57:09 -0700822 run_command("LOG STATISTICS", 10, "logcat", "-b", "all", "-S", NULL);
823
Colin Crossf45fa6b2012-03-26 12:38:26 -0700824 /* show the traces we collected in main(), if that was done */
825 if (dump_traces_path != NULL) {
826 dump_file("VM TRACES JUST NOW", dump_traces_path);
827 }
828
829 /* only show ANR traces if they're less than 15 minutes old */
830 struct stat st;
831 char anr_traces_path[PATH_MAX];
832 property_get("dalvik.vm.stack-trace-file", anr_traces_path, "");
833 if (!anr_traces_path[0]) {
834 printf("*** NO VM TRACES FILE DEFINED (dalvik.vm.stack-trace-file)\n\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700835 } else {
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800836 int fd = TEMP_FAILURE_RETRY(open(anr_traces_path,
837 O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700838 if (fd < 0) {
839 printf("*** NO ANR VM TRACES FILE (%s): %s\n\n", anr_traces_path, strerror(errno));
840 } else {
841 dump_file_from_fd("VM TRACES AT LAST ANR", anr_traces_path, fd);
842 }
Colin Crossf45fa6b2012-03-26 12:38:26 -0700843 }
844
845 /* slow traces for slow operations */
846 if (anr_traces_path[0] != 0) {
847 int tail = strlen(anr_traces_path)-1;
848 while (tail > 0 && anr_traces_path[tail] != '/') {
849 tail--;
850 }
851 int i = 0;
852 while (1) {
853 sprintf(anr_traces_path+tail+1, "slow%02d.txt", i);
854 if (stat(anr_traces_path, &st)) {
855 // No traces file at this index, done with the files.
856 break;
857 }
858 dump_file("VM TRACES WHEN SLOW", anr_traces_path);
859 i++;
860 }
861 }
862
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700863 int dumped = 0;
864 for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
865 if (tombstone_data[i].fd != -1) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800866 const char *name = tombstone_data[i].name;
867 int fd = tombstone_data[i].fd;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700868 dumped = 1;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800869 if (zip_writer) {
870 if (!add_zip_entry_from_fd(ZIP_ROOT_DIR + name, fd)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800871 MYLOGE("Unable to add tombstone %s to zip file\n", name);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800872 }
873 } else {
874 dump_file_from_fd("TOMBSTONE", name, fd);
875 }
876 close(fd);
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700877 tombstone_data[i].fd = -1;
878 }
879 }
880 if (!dumped) {
881 printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR);
882 }
883
Colin Crossf45fa6b2012-03-26 12:38:26 -0700884 dump_file("NETWORK DEV INFO", "/proc/net/dev");
885 dump_file("QTAGUID NETWORK INTERFACES INFO", "/proc/net/xt_qtaguid/iface_stat_all");
JP Abgrall012c2ea2012-05-16 20:49:29 -0700886 dump_file("QTAGUID NETWORK INTERFACES INFO (xt)", "/proc/net/xt_qtaguid/iface_stat_fmt");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700887 dump_file("QTAGUID CTRL INFO", "/proc/net/xt_qtaguid/ctrl");
888 dump_file("QTAGUID STATS INFO", "/proc/net/xt_qtaguid/stats");
889
Todd Poynor2a83daa2013-11-22 15:44:22 -0800890 if (!stat(PSTORE_LAST_KMSG, &st)) {
891 /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
892 dump_file("LAST KMSG", PSTORE_LAST_KMSG);
Mark Salyzyn7d0a7622016-06-24 14:06:15 -0700893 } else if (!stat(ALT_PSTORE_LAST_KMSG, &st)) {
894 dump_file("LAST KMSG", ALT_PSTORE_LAST_KMSG);
Todd Poynor2a83daa2013-11-22 15:44:22 -0800895 } else {
896 /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
897 dump_file("LAST KMSG", "/proc/last_kmsg");
898 }
899
Mark Salyzyn2262c162014-12-16 09:09:26 -0800900 /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
Mark Salyzyn78316382015-10-09 14:02:07 -0700901 run_command("LAST LOGCAT", 10, "logcat", "-L",
902 "-b", "all",
903 "-v", "threadtime",
904 "-v", "printable",
905 "-d",
906 "*:v", NULL);
Mark Salyzyn2262c162014-12-16 09:09:26 -0800907
Colin Crossf45fa6b2012-03-26 12:38:26 -0700908 /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
Elliott Hughesa59828a2015-01-27 20:48:52 -0800909
910 run_command("NETWORK INTERFACES", 10, "ip", "link", NULL);
Lorenzo Colittid4c3d382014-07-30 14:38:20 +0900911
912 run_command("IPv4 ADDRESSES", 10, "ip", "-4", "addr", "show", NULL);
913 run_command("IPv6 ADDRESSES", 10, "ip", "-6", "addr", "show", NULL);
914
Colin Crossf45fa6b2012-03-26 12:38:26 -0700915 run_command("IP RULES", 10, "ip", "rule", "show", NULL);
916 run_command("IP RULES v6", 10, "ip", "-6", "rule", "show", NULL);
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700917
918 dump_route_tables();
919
Lorenzo Colittid4c3d382014-07-30 14:38:20 +0900920 run_command("ARP CACHE", 10, "ip", "-4", "neigh", "show", NULL);
921 run_command("IPv6 ND CACHE", 10, "ip", "-6", "neigh", "show", NULL);
Erik Klinef7f2b0f2016-05-27 11:29:19 +0900922 run_command("MULTICAST ADDRESSES", 10, "ip", "maddr", NULL);
Felipe Lemec0808152016-06-17 17:37:13 -0700923 run_command("WIFI NETWORKS", 20, "wpa_cli", "IFNAME=wlan0", "list_networks", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700924
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -0800925#ifdef FWDUMP_bcmdhd
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +0900926 run_command("ND OFFLOAD TABLE", 5,
Erik Kline08165202016-05-30 11:55:44 +0900927 SU_PATH, "root", WLUTIL, "nd_hostip", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +0900928
929 run_command("DUMP WIFI INTERNAL COUNTERS (1)", 20,
Erik Kline08165202016-05-30 11:55:44 +0900930 SU_PATH, "root", WLUTIL, "counters", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +0900931
932 run_command("ND OFFLOAD STATUS (1)", 5,
Erik Kline08165202016-05-30 11:55:44 +0900933 SU_PATH, "root", WLUTIL, "nd_status", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +0900934
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -0800935#endif
Dmitry Shmidt0b2c9262012-11-07 11:09:46 -0800936 dump_file("INTERRUPTS (1)", "/proc/interrupts");
937
Felipe Leme7cff4622016-06-08 09:51:29 -0700938 run_command("NETWORK DIAGNOSTICS", 10, "dumpsys", "-t", "10", "connectivity", "--diag", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +0900939
Dmitry Shmidtc11f56e2012-11-07 10:42:05 -0800940#ifdef FWDUMP_bcmdhd
Colin Crossf45fa6b2012-03-26 12:38:26 -0700941 run_command("DUMP WIFI STATUS", 20,
942 SU_PATH, "root", "dhdutil", "-i", "wlan0", "dump", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +0900943
944 run_command("DUMP WIFI INTERNAL COUNTERS (2)", 20,
Erik Kline08165202016-05-30 11:55:44 +0900945 SU_PATH, "root", WLUTIL, "counters", NULL);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +0900946
947 run_command("ND OFFLOAD STATUS (2)", 5,
Erik Kline08165202016-05-30 11:55:44 +0900948 SU_PATH, "root", WLUTIL, "nd_status", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700949#endif
Dmitry Shmidt0b2c9262012-11-07 11:09:46 -0800950 dump_file("INTERRUPTS (2)", "/proc/interrupts");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700951
952 print_properties();
953
954 run_command("VOLD DUMP", 10, "vdc", "dump", NULL);
955 run_command("SECURE CONTAINERS", 10, "vdc", "asec", "list", NULL);
956
Ken Sumrall8f75fa72013-02-08 17:35:58 -0800957 run_command("FILESYSTEMS & FREE SPACE", 10, "df", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700958
Colin Crossf45fa6b2012-03-26 12:38:26 -0700959 run_command("LAST RADIO LOG", 10, "parse_radio_log", "/proc/last_radio_log", NULL);
960
961 printf("------ BACKLIGHTS ------\n");
962 printf("LCD brightness=");
963 dump_file(NULL, "/sys/class/leds/lcd-backlight/brightness");
964 printf("Button brightness=");
965 dump_file(NULL, "/sys/class/leds/button-backlight/brightness");
966 printf("Keyboard brightness=");
967 dump_file(NULL, "/sys/class/leds/keyboard-backlight/brightness");
968 printf("ALS mode=");
969 dump_file(NULL, "/sys/class/leds/lcd-backlight/als");
970 printf("LCD driver registers:\n");
971 dump_file(NULL, "/sys/class/leds/lcd-backlight/registers");
972 printf("\n");
973
974 /* Binder state is expensive to look at as it uses a lot of memory. */
975 dump_file("BINDER FAILED TRANSACTION LOG", "/sys/kernel/debug/binder/failed_transaction_log");
976 dump_file("BINDER TRANSACTION LOG", "/sys/kernel/debug/binder/transaction_log");
977 dump_file("BINDER TRANSACTIONS", "/sys/kernel/debug/binder/transactions");
978 dump_file("BINDER STATS", "/sys/kernel/debug/binder/stats");
979 dump_file("BINDER STATE", "/sys/kernel/debug/binder/state");
980
Colin Crossf45fa6b2012-03-26 12:38:26 -0700981 printf("========================================================\n");
982 printf("== Board\n");
983 printf("========================================================\n");
984
985 dumpstate_board();
986 printf("\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700987
988 /* Migrate the ril_dumpstate to a dumpstate_board()? */
989 char ril_dumpstate_timeout[PROPERTY_VALUE_MAX] = {0};
990 property_get("ril.dumpstate.timeout", ril_dumpstate_timeout, "30");
991 if (strnlen(ril_dumpstate_timeout, PROPERTY_VALUE_MAX - 1) > 0) {
Felipe Lemec4eee562016-04-21 15:42:55 -0700992 if (is_user_build()) {
Colin Crossf45fa6b2012-03-26 12:38:26 -0700993 // su does not exist on user builds, so try running without it.
994 // This way any implementations of vril-dump that do not require
995 // root can run on user builds.
996 run_command("DUMP VENDOR RIL LOGS", atoi(ril_dumpstate_timeout),
997 "vril-dump", NULL);
998 } else {
999 run_command("DUMP VENDOR RIL LOGS", atoi(ril_dumpstate_timeout),
1000 SU_PATH, "root", "vril-dump", NULL);
1001 }
1002 }
1003
1004 printf("========================================================\n");
1005 printf("== Android Framework Services\n");
1006 printf("========================================================\n");
1007
Wei Liu34222562016-05-19 13:59:01 -07001008 run_command("DUMPSYS", 60, "dumpsys", "-t", "60", "--skip", "meminfo", "cpuinfo", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001009
1010 printf("========================================================\n");
Dianne Hackborn02bea972013-06-26 18:59:09 -07001011 printf("== Checkins\n");
1012 printf("========================================================\n");
1013
Felipe Leme7cff4622016-06-08 09:51:29 -07001014 run_command("CHECKIN BATTERYSTATS", 30, "dumpsys", "-t", "30", "batterystats", "-c", NULL);
1015 run_command("CHECKIN MEMINFO", 30, "dumpsys", "-t", "30", "meminfo", "--checkin", NULL);
1016 run_command("CHECKIN NETSTATS", 30, "dumpsys", "-t", "30", "netstats", "--checkin", NULL);
1017 run_command("CHECKIN PROCSTATS", 30, "dumpsys", "-t", "30", "procstats", "-c", NULL);
1018 run_command("CHECKIN USAGESTATS", 30, "dumpsys", "-t", "30", "usagestats", "-c", NULL);
1019 run_command("CHECKIN PACKAGE", 30, "dumpsys", "-t", "30", "package", "--checkin", NULL);
Dianne Hackborn02bea972013-06-26 18:59:09 -07001020
1021 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001022 printf("== Running Application Activities\n");
1023 printf("========================================================\n");
1024
Felipe Leme3f83dbe2016-06-10 16:56:33 -07001025 run_command("APP ACTIVITIES", 30, "dumpsys", "-t", "30", "activity", "all", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001026
1027 printf("========================================================\n");
1028 printf("== Running Application Services\n");
1029 printf("========================================================\n");
1030
Felipe Leme3f83dbe2016-06-10 16:56:33 -07001031 run_command("APP SERVICES", 30, "dumpsys", "-t", "30", "activity", "service", "all", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001032
1033 printf("========================================================\n");
1034 printf("== Running Application Providers\n");
1035 printf("========================================================\n");
1036
Junda Liucfc33d42016-06-14 00:09:10 -07001037 run_command("APP PROVIDERS", 30, "dumpsys", "-t", "30", "activity", "provider", "all", NULL);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001038
1039
1040 printf("========================================================\n");
Felipe Leme608385d2016-02-01 10:35:38 -08001041 printf("== Final progress (pid %d): %d/%d (originally %d)\n",
1042 getpid(), progress, weight_total, WEIGHT_TOTAL);
1043 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001044 printf("== dumpstate: done\n");
1045 printf("========================================================\n");
1046}
1047
1048static void usage() {
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001049 fprintf(stderr,
Felipe Leme2628e9e2016-04-12 16:36:51 -07001050 "usage: dumpstate [-h] [-b soundfile] [-e soundfile] [-o file [-d] [-p] "
1051 "[-z]] [-s] [-S] [-q] [-B] [-P] [-R] [-V version]\n"
1052 " -h: display this help message\n"
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001053 " -b: play sound file instead of vibrate, at beginning of job\n"
1054 " -e: play sound file instead of vibrate, at end of job\n"
1055 " -o: write to file (instead of stdout)\n"
1056 " -d: append date to filename (requires -o)\n"
1057 " -p: capture screenshot to filename.png (requires -o)\n"
Felipe Leme2628e9e2016-04-12 16:36:51 -07001058 " -z: generate zipped file (requires -o)\n"
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001059 " -s: write output to control socket (for init)\n"
Felipe Leme2628e9e2016-04-12 16:36:51 -07001060 " -S: write file location to control socket (for init; requires -o and -z)"
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001061 " -q: disable vibrate\n"
1062 " -B: send broadcast when finished (requires -o)\n"
1063 " -P: send broadcast when started and update system properties on "
1064 "progress (requires -o and -B)\n"
1065 " -R: take bugreport in remote mode (requires -o, -z, -d and -B, "
1066 "shouldn't be used with -P)\n"
1067 " -V: sets the bugreport format version (valid values: %s)\n",
1068 VERSION_DEFAULT.c_str());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001069}
1070
Felipe Lemebb6b6042016-10-25 18:18:24 +00001071static void sigpipe_handler(int n) {
1072 // don't complain to stderr or stdout
Andres Morales2e671bb2014-08-21 12:38:22 -07001073 _exit(EXIT_FAILURE);
John Michelau885f8882013-05-06 16:42:02 -05001074}
1075
Felipe Leme1e9edc62015-12-21 16:02:13 -08001076/* adds the temporary report to the existing .zip file, closes the .zip file, and removes the
1077 temporary file.
1078 */
Felipe Lemee82a27d2016-01-05 13:35:44 -08001079static bool finish_zip_file(const std::string& bugreport_name, const std::string& bugreport_path,
Felipe Leme1e9edc62015-12-21 16:02:13 -08001080 time_t now) {
Felipe Lemee82a27d2016-01-05 13:35:44 -08001081 if (!add_zip_entry(bugreport_name, bugreport_path)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001082 MYLOGE("Failed to add text entry to .zip file\n");
Felipe Leme1e9edc62015-12-21 16:02:13 -08001083 return false;
1084 }
Felipe Leme809d74e2016-02-02 12:57:00 -08001085 if (!add_text_zip_entry("main_entry.txt", bugreport_name)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001086 MYLOGE("Failed to add main_entry.txt to .zip file\n");
Felipe Leme111b9d02016-02-03 09:28:24 -08001087 return false;
Felipe Leme809d74e2016-02-02 12:57:00 -08001088 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08001089
Felipe Lemee82a27d2016-01-05 13:35:44 -08001090 int32_t err = zip_writer->Finish();
Felipe Leme1e9edc62015-12-21 16:02:13 -08001091 if (err) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001092 MYLOGE("zip_writer->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001093 return false;
1094 }
1095
Felipe Lemec4eee562016-04-21 15:42:55 -07001096 if (is_user_build()) {
1097 MYLOGD("Removing temporary file %s\n", bugreport_path.c_str())
1098 if (remove(bugreport_path.c_str())) {
1099 ALOGW("remove(%s): %s\n", bugreport_path.c_str(), strerror(errno));
1100 }
1101 } else {
1102 MYLOGD("Keeping temporary file %s on non-user build\n", bugreport_path.c_str())
1103 }
1104
Felipe Leme1e9edc62015-12-21 16:02:13 -08001105 return true;
1106}
Felipe Leme6e01fa62015-11-11 19:35:14 -08001107
Michal Karpinski4db754f2015-12-11 18:04:32 +00001108static std::string SHA256_file_hash(std::string filepath) {
Andreas Gampe27cd7b22016-07-18 18:24:05 -07001109 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK
1110 | O_CLOEXEC | O_NOFOLLOW)));
Andreas Gampefcc8db92016-07-18 18:01:27 -07001111 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001112 MYLOGE("open(%s): %s\n", filepath.c_str(), strerror(errno));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001113 return NULL;
1114 }
1115
1116 SHA256_CTX ctx;
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001117 SHA256_Init(&ctx);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001118
1119 std::vector<uint8_t> buffer(65536);
1120 while (1) {
1121 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd.get(), buffer.data(), buffer.size()));
1122 if (bytes_read == 0) {
1123 break;
1124 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001125 MYLOGE("read(%s): %s\n", filepath.c_str(), strerror(errno));
Michal Karpinski4db754f2015-12-11 18:04:32 +00001126 return NULL;
1127 }
1128
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001129 SHA256_Update(&ctx, buffer.data(), bytes_read);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001130 }
1131
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001132 uint8_t hash[SHA256_DIGEST_LENGTH];
1133 SHA256_Final(hash, &ctx);
1134
1135 char hash_buffer[SHA256_DIGEST_LENGTH * 2 + 1];
1136 for(size_t i = 0; i < SHA256_DIGEST_LENGTH; i++) {
Michal Karpinskicbbdf732016-01-07 20:45:02 +00001137 sprintf(hash_buffer + (i * 2), "%02x", hash[i]);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001138 }
1139 hash_buffer[sizeof(hash_buffer) - 1] = 0;
1140 return std::string(hash_buffer);
1141}
1142
Colin Crossf45fa6b2012-03-26 12:38:26 -07001143int main(int argc, char *argv[]) {
Felipe Lemebb6b6042016-10-25 18:18:24 +00001144 struct sigaction sigact;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001145 int do_add_date = 0;
Felipe Leme6e01fa62015-11-11 19:35:14 -08001146 int do_zip_file = 0;
John Michelau1f794c42012-09-17 11:20:19 -05001147 int do_vibrate = 1;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001148 char* use_outfile = 0;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001149 int use_socket = 0;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001150 int use_control_socket = 0;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001151 int do_fb = 0;
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07001152 int do_broadcast = 0;
Felipe Lemee338bf62015-12-07 14:03:50 -08001153 int do_early_screenshot = 0;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001154 int is_remote_mode = 0;
Felipe Leme809d74e2016-02-02 12:57:00 -08001155 std::string version = VERSION_DEFAULT;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001156
Felipe Lemee82a27d2016-01-05 13:35:44 -08001157 now = time(NULL);
1158
Felipe Lemecbce55d2016-02-08 09:53:18 -08001159 MYLOGI("begin\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001160
Felipe Leme8fecfdd2016-02-09 10:40:07 -08001161 /* gets the sequential id */
1162 char last_id[PROPERTY_VALUE_MAX];
1163 property_get("dumpstate.last_id", last_id, "0");
1164 id = strtoul(last_id, NULL, 10) + 1;
Nick Kralevichf0922cc2016-05-14 16:47:44 -07001165 snprintf(last_id, sizeof(last_id), "%lu", id);
Felipe Leme8fecfdd2016-02-09 10:40:07 -08001166 property_set("dumpstate.last_id", last_id);
1167 MYLOGI("dumpstate id: %lu\n", id);
1168
Felipe Lemebb6b6042016-10-25 18:18:24 +00001169 /* clear SIGPIPE handler */
1170 memset(&sigact, 0, sizeof(sigact));
1171 sigact.sa_handler = sigpipe_handler;
1172 sigaction(SIGPIPE, &sigact, NULL);
1173
Colin Crossf45fa6b2012-03-26 12:38:26 -07001174 /* set as high priority, and protect from OOM killer */
1175 setpriority(PRIO_PROCESS, 0, -20);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001176
1177 FILE *oom_adj = fopen("/proc/self/oom_score_adj", "we");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001178 if (oom_adj) {
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001179 fputs("-1000", oom_adj);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001180 fclose(oom_adj);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07001181 } else {
1182 /* fallback to kernels <= 2.6.35 */
1183 oom_adj = fopen("/proc/self/oom_adj", "we");
1184 if (oom_adj) {
1185 fputs("-17", oom_adj);
1186 fclose(oom_adj);
1187 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001188 }
1189
Jeff Brown1dc94e32014-09-11 14:15:27 -07001190 /* parse arguments */
Felipe Lemea34efb72016-03-11 09:33:32 -08001191 std::string args;
1192 format_args(argc, const_cast<const char **>(argv), &args);
1193 MYLOGD("Dumpstate command line: %s\n", args.c_str());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001194 int c;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001195 while ((c = getopt(argc, argv, "dho:svqzpPBRSV:")) != -1) {
Colin Crossf45fa6b2012-03-26 12:38:26 -07001196 switch (c) {
Felipe Leme71bbfc52015-11-23 14:14:51 -08001197 case 'd': do_add_date = 1; break;
1198 case 'z': do_zip_file = 1; break;
1199 case 'o': use_outfile = optarg; break;
1200 case 's': use_socket = 1; break;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001201 case 'S': use_control_socket = 1; break;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001202 case 'v': break; // compatibility no-op
Felipe Leme71bbfc52015-11-23 14:14:51 -08001203 case 'q': do_vibrate = 0; break;
1204 case 'p': do_fb = 1; break;
1205 case 'P': do_update_progress = 1; break;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001206 case 'R': is_remote_mode = 1; break;
Felipe Leme71bbfc52015-11-23 14:14:51 -08001207 case 'B': do_broadcast = 1; break;
Felipe Leme809d74e2016-02-02 12:57:00 -08001208 case 'V': version = optarg; break;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001209 case '?': printf("\n");
1210 case 'h':
1211 usage();
1212 exit(1);
1213 }
1214 }
1215
Felipe Leme71bbfc52015-11-23 14:14:51 -08001216 if ((do_zip_file || do_add_date || do_update_progress || do_broadcast) && !use_outfile) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001217 usage();
1218 exit(1);
1219 }
1220
Felipe Leme2628e9e2016-04-12 16:36:51 -07001221 if (use_control_socket && !do_zip_file) {
1222 usage();
1223 exit(1);
1224 }
1225
Felipe Leme71bbfc52015-11-23 14:14:51 -08001226 if (do_update_progress && !do_broadcast) {
1227 usage();
1228 exit(1);
1229 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001230
Michal Karpinski4db754f2015-12-11 18:04:32 +00001231 if (is_remote_mode && (do_update_progress || !do_broadcast || !do_zip_file || !do_add_date)) {
1232 usage();
1233 exit(1);
1234 }
1235
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001236 if (version != VERSION_DEFAULT) {
1237 usage();
1238 exit(1);
Felipe Leme809d74e2016-02-02 12:57:00 -08001239 }
1240
Felipe Lemecbce55d2016-02-08 09:53:18 -08001241 MYLOGI("bugreport format version: %s\n", version.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -08001242
Felipe Lemee338bf62015-12-07 14:03:50 -08001243 do_early_screenshot = do_update_progress;
1244
Christopher Ferrised9354f2014-10-01 17:35:01 -07001245 // If we are going to use a socket, do it as early as possible
1246 // to avoid timeouts from bugreport.
1247 if (use_socket) {
1248 redirect_to_socket(stdout, "dumpstate");
1249 }
1250
Felipe Leme2628e9e2016-04-12 16:36:51 -07001251 if (use_control_socket) {
1252 MYLOGD("Opening control socket\n");
1253 control_socket_fd = open_socket("dumpstate");
Felipe Leme02b7e002016-07-22 12:03:20 -07001254 do_update_progress = 1;
Felipe Leme2628e9e2016-04-12 16:36:51 -07001255 }
1256
Felipe Lemecbce55d2016-02-08 09:53:18 -08001257 /* full path of the temporary file containing the bugreport */
Felipe Lemead5f6c42015-11-30 14:26:46 -08001258 std::string tmp_path;
1259
Felipe Lemecbce55d2016-02-08 09:53:18 -08001260 /* full path of the file containing the dumpstate logs*/
1261 std::string log_path;
1262
Felipe Leme14e034a2016-03-30 18:51:03 -07001263 /* full path of the systrace file, when enabled */
1264 std::string systrace_path;
1265
Felipe Lemee338bf62015-12-07 14:03:50 -08001266 /* full path of the temporary file containing the screenshot (when requested) */
1267 std::string screenshot_path;
1268
Felipe Lemecbce55d2016-02-08 09:53:18 -08001269 /* base name (without suffix or extensions) of the bugreport files */
Felipe Lemead5f6c42015-11-30 14:26:46 -08001270 std::string base_name;
1271
Felipe Leme71bbfc52015-11-23 14:14:51 -08001272 /* pointer to the actual path, be it zip or text */
1273 std::string path;
1274
Felipe Leme635ca312016-01-05 14:23:02 -08001275 /* pointer to the zipped file */
Felipe Leme1e9edc62015-12-21 16:02:13 -08001276 std::unique_ptr<FILE, int(*)(FILE*)> zip_file(NULL, fclose);
Felipe Leme71bbfc52015-11-23 14:14:51 -08001277
Felipe Lemead5f6c42015-11-30 14:26:46 -08001278 /* redirect output if needed */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001279 bool is_redirecting = !use_socket && use_outfile;
1280
1281 if (is_redirecting) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001282 bugreport_dir = dirname(use_outfile);
1283 base_name = basename(use_outfile);
Felipe Leme71bbfc52015-11-23 14:14:51 -08001284 if (do_add_date) {
1285 char date[80];
Felipe Lemead5f6c42015-11-30 14:26:46 -08001286 strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&now));
1287 suffix = date;
1288 } else {
1289 suffix = "undated";
Felipe Leme71bbfc52015-11-23 14:14:51 -08001290 }
Felipe Lemecc37b8e2016-04-11 13:45:18 -07001291 char build_id[PROPERTY_VALUE_MAX];
1292 property_get("ro.build.id", build_id, "UNKNOWN_BUILD");
1293 base_name = base_name + "-" + build_id;
Felipe Leme71bbfc52015-11-23 14:14:51 -08001294 if (do_fb) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001295 // TODO: if dumpstate was an object, the paths could be internal variables and then
1296 // we could have a function to calculate the derived values, such as:
1297 // screenshot_path = GetPath(".png");
1298 screenshot_path = bugreport_dir + "/" + base_name + "-" + suffix + ".png";
Felipe Leme71bbfc52015-11-23 14:14:51 -08001299 }
Felipe Lemead5f6c42015-11-30 14:26:46 -08001300 tmp_path = bugreport_dir + "/" + base_name + "-" + suffix + ".tmp";
Felipe Lemecbce55d2016-02-08 09:53:18 -08001301 log_path = bugreport_dir + "/dumpstate_log-" + suffix + "-"
1302 + std::to_string(getpid()) + ".txt";
Felipe Leme71bbfc52015-11-23 14:14:51 -08001303
Felipe Lemecbce55d2016-02-08 09:53:18 -08001304 MYLOGD("Bugreport dir: %s\n"
1305 "Base name: %s\n"
1306 "Suffix: %s\n"
1307 "Log path: %s\n"
1308 "Temporary path: %s\n"
1309 "Screenshot path: %s\n",
1310 bugreport_dir.c_str(), base_name.c_str(), suffix.c_str(),
1311 log_path.c_str(), tmp_path.c_str(), screenshot_path.c_str());
Felipe Leme71bbfc52015-11-23 14:14:51 -08001312
Felipe Leme1e9edc62015-12-21 16:02:13 -08001313 if (do_zip_file) {
Felipe Leme1e9edc62015-12-21 16:02:13 -08001314 path = bugreport_dir + "/" + base_name + "-" + suffix + ".zip";
Felipe Leme26bd34c2016-03-15 13:40:33 -07001315 MYLOGD("Creating initial .zip file (%s)\n", path.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -08001316 create_parent_dirs(path.c_str());
Felipe Leme1e9edc62015-12-21 16:02:13 -08001317 zip_file.reset(fopen(path.c_str(), "wb"));
1318 if (!zip_file) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001319 MYLOGE("fopen(%s, 'wb'): %s\n", path.c_str(), strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001320 do_zip_file = 0;
1321 } else {
1322 zip_writer.reset(new ZipWriter(zip_file.get()));
1323 }
Felipe Leme809d74e2016-02-02 12:57:00 -08001324 add_text_zip_entry("version.txt", version);
Felipe Leme1e9edc62015-12-21 16:02:13 -08001325 }
1326
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07001327 if (do_update_progress) {
1328 if (do_broadcast) {
1329 // clang-format off
1330 std::vector<std::string> am_args = {
1331 "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
1332 "--es", "android.intent.extra.NAME", suffix,
1333 "--ei", "android.intent.extra.ID", std::to_string(id),
1334 "--ei", "android.intent.extra.PID", std::to_string(getpid()),
1335 "--ei", "android.intent.extra.MAX", std::to_string(WEIGHT_TOTAL),
1336 };
1337 // clang-format on
1338 send_broadcast("android.intent.action.BUGREPORT_STARTED", am_args);
1339 }
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001340 if (use_control_socket) {
1341 dprintf(control_socket_fd, "BEGIN:%s\n", path.c_str());
1342 }
Felipe Leme71bbfc52015-11-23 14:14:51 -08001343 }
1344 }
1345
Nick Kralevichf3599b32016-01-25 15:05:16 -08001346 /* read /proc/cmdline before dropping root */
1347 FILE *cmdline = fopen("/proc/cmdline", "re");
1348 if (cmdline) {
1349 fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
1350 fclose(cmdline);
1351 }
1352
Jeff Brown1dc94e32014-09-11 14:15:27 -07001353 /* open the vibrator before dropping root */
Felipe Leme6e01fa62015-11-11 19:35:14 -08001354 std::unique_ptr<FILE, int(*)(FILE*)> vibrator(NULL, fclose);
John Michelau1f794c42012-09-17 11:20:19 -05001355 if (do_vibrate) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001356 vibrator.reset(fopen("/sys/class/timed_output/vibrator/enable", "we"));
Jeff Brown1dc94e32014-09-11 14:15:27 -07001357 if (vibrator) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001358 vibrate(vibrator.get(), 150);
Jeff Brown1dc94e32014-09-11 14:15:27 -07001359 }
John Michelau1f794c42012-09-17 11:20:19 -05001360 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001361
Felipe Leme3634a1e2015-12-09 10:11:47 -08001362 if (do_fb && do_early_screenshot) {
1363 if (screenshot_path.empty()) {
1364 // should not have happened
Felipe Lemecbce55d2016-02-08 09:53:18 -08001365 MYLOGE("INTERNAL ERROR: skipping early screenshot because path was not set\n");
Felipe Leme3634a1e2015-12-09 10:11:47 -08001366 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001367 MYLOGI("taking early screenshot\n");
Felipe Leme3634a1e2015-12-09 10:11:47 -08001368 take_screenshot(screenshot_path);
Felipe Lemecbce55d2016-02-08 09:53:18 -08001369 MYLOGI("wrote screenshot: %s\n", screenshot_path.c_str());
Felipe Leme3634a1e2015-12-09 10:11:47 -08001370 if (chown(screenshot_path.c_str(), AID_SHELL, AID_SHELL)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001371 MYLOGE("Unable to change ownership of screenshot file %s: %s\n",
Felipe Leme3634a1e2015-12-09 10:11:47 -08001372 screenshot_path.c_str(), strerror(errno));
1373 }
Felipe Lemee338bf62015-12-07 14:03:50 -08001374 }
1375 }
1376
Felipe Leme1e9edc62015-12-21 16:02:13 -08001377 if (do_zip_file) {
1378 if (chown(path.c_str(), AID_SHELL, AID_SHELL)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001379 MYLOGE("Unable to change ownership of zip file %s: %s\n", path.c_str(), strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001380 }
1381 }
1382
Felipe Leme71bbfc52015-11-23 14:14:51 -08001383 if (is_redirecting) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001384 redirect_to_file(stderr, const_cast<char*>(log_path.c_str()));
Felipe Leme6fe9db62016-02-12 09:04:16 -08001385 if (chown(log_path.c_str(), AID_SHELL, AID_SHELL)) {
1386 MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n",
1387 log_path.c_str(), strerror(errno));
1388 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001389 /* TODO: rather than generating a text file now and zipping it later,
1390 it would be more efficient to redirect stdout to the zip entry
1391 directly, but the libziparchive doesn't support that option yet. */
1392 redirect_to_file(stdout, const_cast<char*>(tmp_path.c_str()));
Felipe Leme6fe9db62016-02-12 09:04:16 -08001393 if (chown(tmp_path.c_str(), AID_SHELL, AID_SHELL)) {
1394 MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
1395 tmp_path.c_str(), strerror(errno));
1396 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001397 }
Felipe Leme608385d2016-02-01 10:35:38 -08001398 // NOTE: there should be no stdout output until now, otherwise it would break the header.
1399 // In particular, DurationReport objects should be created passing 'title, NULL', so their
Felipe Lemecbce55d2016-02-08 09:53:18 -08001400 // duration is logged into MYLOG instead.
Felipe Leme809d74e2016-02-02 12:57:00 -08001401 print_header(version);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001402
Felipe Leme71a74ac2016-03-17 15:43:25 -07001403 // Dumps systrace right away, otherwise it will be filled with unnecessary events.
Zhengyin Qian068ecc72016-08-10 16:48:14 -07001404 // First try to dump anrd trace if the daemon is running. Otherwise, dump
1405 // the raw trace.
1406 if (!dump_anrd_trace()) {
1407 dump_systrace();
1408 }
Felipe Leme71a74ac2016-03-17 15:43:25 -07001409
Wei Liu341938b2016-04-27 16:18:17 -07001410 // TODO: Drop root user and move into dumpstate() once b/28633932 is fixed.
Felipe Lemeefd7e272016-05-18 09:27:16 -07001411 dump_raft();
Wei Liu341938b2016-04-27 16:18:17 -07001412
Felipe Leme9c74aad2016-02-29 18:15:42 -08001413 // Invoking the following dumpsys calls before dump_traces() to try and
1414 // keep the system stats as close to its initial state as possible.
Thierry Strudel8b78b752016-03-22 10:25:44 -07001415 run_command_as_shell("DUMPSYS MEMINFO", 30, "dumpsys", "-t", "30", "meminfo", "-a", NULL);
Felipe Leme7cff4622016-06-08 09:51:29 -07001416 run_command_as_shell("DUMPSYS CPUINFO", 10, "dumpsys", "-t", "10", "cpuinfo", "-a", NULL);
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001417
1418 /* collect stack traces from Dalvik and native processes (needs root) */
1419 dump_traces_path = dump_traces();
1420
Felipe Lemec0808152016-06-17 17:37:13 -07001421 /* Run some operations that require root. */
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001422 get_tombstone_fds(tombstone_data);
1423 add_dir(RECOVERY_DIR, true);
Mark Salyzynd6ab0112016-03-25 12:56:39 -07001424 add_dir(RECOVERY_DATA_DIR, true);
Mark Salyzyn4d42dea2016-04-01 10:03:14 -07001425 add_dir(LOGPERSIST_DATA_DIR, false);
David Brazdild2991962016-06-03 14:40:44 +01001426 if (!is_user_build()) {
1427 add_dir(PROFILE_DATA_DIR_CUR, true);
1428 add_dir(PROFILE_DATA_DIR_REF, true);
1429 }
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001430 add_mountinfo();
Felipe Lemec0808152016-06-17 17:37:13 -07001431 dump_iptables();
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001432
Erik Kline53ca94a2016-09-28 17:26:26 +09001433 // Capture any IPSec policies in play. No keys are exposed here.
1434 run_command("IP XFRM POLICY", 10, "ip", "xfrm", "policy", nullptr);
1435
Lorenzo Colittid3b809b2016-09-26 13:37:45 +09001436 // Run ss as root so we can see socket marks.
1437 run_command("DETAILED SOCKET STATE", 10, "ss", "-eionptu", NULL);
1438
Felipe Lemecf6a8b42016-03-11 10:38:19 -08001439 if (!drop_root_user()) {
Srinath Sridharanfdf52d32016-02-01 15:50:22 -08001440 return -1;
1441 }
1442
1443 dumpstate(do_early_screenshot ? "": screenshot_path, version);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001444
Felipe Leme55b42a62015-11-10 17:39:08 -08001445 /* close output if needed */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001446 if (is_redirecting) {
Colin Crossf45fa6b2012-03-26 12:38:26 -07001447 fclose(stdout);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001448 }
1449
Felipe Leme6e01fa62015-11-11 19:35:14 -08001450 /* rename or zip the (now complete) .tmp file to its final location */
1451 if (use_outfile) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001452
1453 /* check if user changed the suffix using system properties */
1454 char key[PROPERTY_KEY_MAX];
1455 char value[PROPERTY_VALUE_MAX];
Nick Kralevichf0922cc2016-05-14 16:47:44 -07001456 snprintf(key, sizeof(key), "dumpstate.%d.name", getpid());
Felipe Lemead5f6c42015-11-30 14:26:46 -08001457 property_get(key, value, "");
1458 bool change_suffix= false;
1459 if (value[0]) {
1460 /* must whitelist which characters are allowed, otherwise it could cross directories */
1461 std::regex valid_regex("^[-_a-zA-Z0-9]+$");
1462 if (std::regex_match(value, valid_regex)) {
1463 change_suffix = true;
1464 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001465 MYLOGE("invalid suffix provided by user: %s\n", value);
Felipe Lemead5f6c42015-11-30 14:26:46 -08001466 }
1467 }
1468 if (change_suffix) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001469 MYLOGI("changing suffix from %s to %s\n", suffix.c_str(), value);
Felipe Lemead5f6c42015-11-30 14:26:46 -08001470 suffix = value;
1471 if (!screenshot_path.empty()) {
1472 std::string new_screenshot_path =
1473 bugreport_dir + "/" + base_name + "-" + suffix + ".png";
1474 if (rename(screenshot_path.c_str(), new_screenshot_path.c_str())) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001475 MYLOGE("rename(%s, %s): %s\n", screenshot_path.c_str(),
Felipe Lemead5f6c42015-11-30 14:26:46 -08001476 new_screenshot_path.c_str(), strerror(errno));
1477 } else {
1478 screenshot_path = new_screenshot_path;
1479 }
1480 }
1481 }
1482
Felipe Leme6e01fa62015-11-11 19:35:14 -08001483 bool do_text_file = true;
1484 if (do_zip_file) {
Felipe Leme88c79332016-02-22 11:06:49 -08001485 std::string entry_name = base_name + "-" + suffix + ".txt";
1486 MYLOGD("Adding main entry (%s) to .zip bugreport\n", entry_name.c_str());
1487 if (!finish_zip_file(entry_name, tmp_path, now)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001488 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
Felipe Leme6e01fa62015-11-11 19:35:14 -08001489 do_text_file = true;
1490 } else {
1491 do_text_file = false;
Felipe Leme91274352016-02-26 15:03:52 -08001492 // Since zip file is already created, it needs to be renamed.
1493 std::string new_path = bugreport_dir + "/" + base_name + "-" + suffix + ".zip";
1494 if (path != new_path) {
1495 MYLOGD("Renaming zip file from %s to %s\n", path.c_str(), new_path.c_str());
1496 if (rename(path.c_str(), new_path.c_str())) {
1497 MYLOGE("rename(%s, %s): %s\n", path.c_str(),
1498 new_path.c_str(), strerror(errno));
1499 } else {
1500 path = new_path;
1501 }
1502 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001503 }
1504 }
1505 if (do_text_file) {
Felipe Lemead5f6c42015-11-30 14:26:46 -08001506 path = bugreport_dir + "/" + base_name + "-" + suffix + ".txt";
Felipe Leme88c79332016-02-22 11:06:49 -08001507 MYLOGD("Generating .txt bugreport at %s from %s\n", path.c_str(), tmp_path.c_str());
Felipe Lemead5f6c42015-11-30 14:26:46 -08001508 if (rename(tmp_path.c_str(), path.c_str())) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001509 MYLOGE("rename(%s, %s): %s\n", tmp_path.c_str(), path.c_str(), strerror(errno));
Felipe Leme6e01fa62015-11-11 19:35:14 -08001510 path.clear();
1511 }
1512 }
Felipe Leme2628e9e2016-04-12 16:36:51 -07001513 if (use_control_socket) {
1514 if (do_text_file) {
1515 dprintf(control_socket_fd, "FAIL:could not create zip file, check %s "
1516 "for more details\n", log_path.c_str());
1517 } else {
1518 dprintf(control_socket_fd, "OK:%s\n", path.c_str());
1519 }
1520 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001521 }
1522
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08001523 /* vibrate a few but shortly times to let user know it's finished */
1524 if (vibrator) {
1525 for (int i = 0; i < 3; i++) {
1526 vibrate(vibrator.get(), 75);
1527 usleep((75 + 50) * 1000);
1528 }
1529 }
1530
Jeff Brown1dc94e32014-09-11 14:15:27 -07001531 /* tell activity manager we're done */
Felipe Leme71bbfc52015-11-23 14:14:51 -08001532 if (do_broadcast) {
Felipe Leme6e01fa62015-11-11 19:35:14 -08001533 if (!path.empty()) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001534 MYLOGI("Final bugreport path: %s\n", path.c_str());
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001535 // clang-format off
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001536 std::vector<std::string> am_args = {
Felipe Leme43fd1bb2016-01-29 09:07:57 -08001537 "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
Felipe Leme8fecfdd2016-02-09 10:40:07 -08001538 "--ei", "android.intent.extra.ID", std::to_string(id),
Felipe Leme71bbfc52015-11-23 14:14:51 -08001539 "--ei", "android.intent.extra.PID", std::to_string(getpid()),
Felipe Lemeee2e4a02016-02-22 18:12:11 -08001540 "--ei", "android.intent.extra.MAX", std::to_string(weight_total),
Felipe Lemecbce55d2016-02-08 09:53:18 -08001541 "--es", "android.intent.extra.BUGREPORT", path,
1542 "--es", "android.intent.extra.DUMPSTATE_LOG", log_path
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001543 };
Felipe Lemeaabfcae2016-07-29 09:49:04 -07001544 // clang-format on
Felipe Leme36b3f6f2015-11-19 15:41:04 -08001545 if (do_fb) {
1546 am_args.push_back("--es");
1547 am_args.push_back("android.intent.extra.SCREENSHOT");
1548 am_args.push_back(screenshot_path);
1549 }
Michal Karpinski4db754f2015-12-11 18:04:32 +00001550 if (is_remote_mode) {
1551 am_args.push_back("--es");
1552 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
1553 am_args.push_back(SHA256_file_hash(path));
1554 send_broadcast("android.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
1555 } else {
1556 send_broadcast("android.intent.action.BUGREPORT_FINISHED", am_args);
1557 }
Felipe Leme6e01fa62015-11-11 19:35:14 -08001558 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001559 MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
Felipe Leme6e01fa62015-11-11 19:35:14 -08001560 }
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07001561 }
1562
Felipe Lemecbce55d2016-02-08 09:53:18 -08001563 MYLOGD("Final progress: %d/%d (originally %d)\n", progress, weight_total, WEIGHT_TOTAL);
1564 MYLOGI("done\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001565
Felipe Leme107a05f2016-03-08 15:11:15 -08001566 if (is_redirecting) {
1567 fclose(stderr);
1568 }
1569
Felipe Leme02b7e002016-07-22 12:03:20 -07001570 if (use_control_socket && control_socket_fd != -1) {
1571 MYLOGD("Closing control socket\n");
1572 close(control_socket_fd);
Felipe Leme2628e9e2016-04-12 16:36:51 -07001573 }
1574
Colin Crossf45fa6b2012-03-26 12:38:26 -07001575 return 0;
1576}