blob: 4ad5c4b7d5a5ae1172b27d6253834c8c8e5e3cec [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
Felipe Lemef0292972016-11-22 13:57:05 -080017#define LOG_TAG "dumpstate"
18
19#include "dumpstate.h"
20
Colin Crossf45fa6b2012-03-26 12:38:26 -070021#include <dirent.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070022#include <fcntl.h>
Felipe Lemee184f662016-10-27 10:04:47 -070023#include <libgen.h>
Felipe Leme7447d7c2016-11-03 18:12:22 -070024#include <math.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070025#include <poll.h>
26#include <signal.h>
27#include <stdarg.h>
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
Felipe Lemecf6a8b42016-03-11 10:38:19 -080031#include <sys/capability.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070032#include <sys/inotify.h>
Felipe Lemee184f662016-10-27 10:04:47 -070033#include <sys/klog.h>
Mark Salyzyna5e161b2016-09-29 08:08:05 -070034#include <sys/prctl.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070035#include <sys/stat.h>
36#include <sys/time.h>
37#include <sys/wait.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070038#include <time.h>
39#include <unistd.h>
Mark Salyzyn261a7332016-05-24 12:38:40 -070040
Narayan Kamath8f788292017-05-25 13:20:39 +010041#include <memory>
Steven Moreland17b29e12017-03-21 18:38:05 -070042#include <set>
Mark Salyzyna5e161b2016-09-29 08:08:05 -070043#include <string>
Felipe Leme36b3f6f2015-11-19 15:41:04 -080044#include <vector>
Colin Crossf45fa6b2012-03-26 12:38:26 -070045
Mark Salyzyn290f4b92016-05-16 08:33:59 -070046#include <android-base/file.h>
Felipe Leme96c2bbb2016-09-26 09:21:21 -070047#include <android-base/properties.h>
Felipe Leme2b9b06c2016-10-14 09:13:06 -070048#include <android-base/stringprintf.h>
Felipe Leme7447d7c2016-11-03 18:12:22 -070049#include <android-base/strings.h>
Narayan Kamath8f788292017-05-25 13:20:39 +010050#include <android-base/unique_fd.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070051#include <cutils/properties.h>
52#include <cutils/sockets.h>
Josh Gaod2db0242017-01-05 18:27:33 -080053#include <debuggerd/client.h>
Kweku Adams5ce418d2018-02-05 16:43:53 -080054#include <dumputils/dump_utils.h>
Mark Salyzyn4eb13822017-01-12 13:57:51 -080055#include <log/log.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070056#include <private/android_filesystem_config.h>
57
Felipe Lemef0292972016-11-22 13:57:05 -080058#include "DumpstateInternal.h"
Jeff Brown1dc94e32014-09-11 14:15:27 -070059
Felipe Leme47e9be22016-12-21 15:37:07 -080060// TODO: remove once moved to namespace
61using android::os::dumpstate::CommandOptions;
62using android::os::dumpstate::DumpFileToFd;
63using android::os::dumpstate::PropertiesHelper;
64
Brian Carlstroma3322752017-03-19 17:48:01 -070065// Keep in sync with
66// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
Felipe Leme61884122016-06-13 09:23:30 -070067static const int TRACE_DUMP_TIMEOUT_MS = 10000; // 10 seconds
68
Felipe Lemef0292972016-11-22 13:57:05 -080069/* Most simple commands have 10 as timeout, so 5 is a good estimate */
70static const int32_t WEIGHT_FILE = 5;
71
Felipe Lemee844a9d2016-09-21 15:01:39 -070072// TODO: temporary variables and functions used during C++ refactoring
73static Dumpstate& ds = Dumpstate::GetInstance();
Felipe Leme9a523ae2016-10-20 15:10:33 -070074static int RunCommand(const std::string& title, const std::vector<std::string>& full_command,
Felipe Leme678727a2016-09-21 17:22:11 -070075 const CommandOptions& options = CommandOptions::DEFAULT) {
Felipe Leme9a523ae2016-10-20 15:10:33 -070076 return ds.RunCommand(title, full_command, options);
Felipe Leme678727a2016-09-21 17:22:11 -070077}
Felipe Lemee844a9d2016-09-21 15:01:39 -070078
Felipe Leme7447d7c2016-11-03 18:12:22 -070079// Reasonable value for max stats.
80static const int STATS_MAX_N_RUNS = 1000;
81static const long STATS_MAX_AVERAGE = 100000;
82
Felipe Lemebda15a02016-11-16 17:48:25 -080083CommandOptions Dumpstate::DEFAULT_DUMPSYS = CommandOptions::WithTimeout(30).Build();
Felipe Leme30dbfa12016-09-02 12:43:26 -070084
Felipe Lemef0292972016-11-22 13:57:05 -080085Dumpstate::Dumpstate(const std::string& version)
86 : pid_(getpid()), version_(version), now_(time(nullptr)) {
Felipe Lemee844a9d2016-09-21 15:01:39 -070087}
88
89Dumpstate& Dumpstate::GetInstance() {
Felipe Lemef0292972016-11-22 13:57:05 -080090 static Dumpstate singleton_(android::base::GetProperty("dumpstate.version", VERSION_CURRENT));
Felipe Leme9a523ae2016-10-20 15:10:33 -070091 return singleton_;
Felipe Lemee844a9d2016-09-21 15:01:39 -070092}
93
Felipe Leme46b85da2016-11-21 17:40:45 -080094DurationReporter::DurationReporter(const std::string& title, bool log_only)
95 : title_(title), log_only_(log_only) {
Felipe Leme678727a2016-09-21 17:22:11 -070096 if (!title_.empty()) {
Felipe Lemef0292972016-11-22 13:57:05 -080097 started_ = Nanotime();
Felipe Leme78f2c862015-12-21 09:55:22 -080098 }
99}
100
101DurationReporter::~DurationReporter() {
Felipe Leme678727a2016-09-21 17:22:11 -0700102 if (!title_.empty()) {
Felipe Lemef0292972016-11-22 13:57:05 -0800103 uint64_t elapsed = Nanotime() - started_;
Felipe Leme46b85da2016-11-21 17:40:45 -0800104 if (log_only_) {
Felipe Leme678727a2016-09-21 17:22:11 -0700105 MYLOGD("Duration of '%s': %.3fs\n", title_.c_str(), (float)elapsed / NANOS_PER_SEC);
Felipe Leme46b85da2016-11-21 17:40:45 -0800106 } else {
107 // Use "Yoda grammar" to make it easier to grep|sort sections.
Felipe Lemed8b94e52016-12-08 10:21:44 -0800108 printf("------ %.3fs was the duration of '%s' ------\n", (float)elapsed / NANOS_PER_SEC,
109 title_.c_str());
Felipe Leme608385d2016-02-01 10:35:38 -0800110 }
Felipe Leme78f2c862015-12-21 09:55:22 -0800111 }
112}
113
Felipe Leme7447d7c2016-11-03 18:12:22 -0700114const int32_t Progress::kDefaultMax = 5000;
115
116Progress::Progress(const std::string& path) : Progress(Progress::kDefaultMax, 1.1, path) {
117}
118
119Progress::Progress(int32_t initial_max, int32_t progress, float growth_factor)
120 : Progress(initial_max, growth_factor, "") {
121 progress_ = progress;
122}
123
124Progress::Progress(int32_t initial_max, float growth_factor, const std::string& path)
125 : initial_max_(initial_max),
126 progress_(0),
127 max_(initial_max),
128 growth_factor_(growth_factor),
129 n_runs_(0),
130 average_max_(0),
131 path_(path) {
132 if (!path_.empty()) {
133 Load();
134 }
135}
136
137void Progress::Load() {
138 MYLOGD("Loading stats from %s\n", path_.c_str());
139 std::string content;
140 if (!android::base::ReadFileToString(path_, &content)) {
141 MYLOGI("Could not read stats from %s; using max of %d\n", path_.c_str(), max_);
142 return;
143 }
144 if (content.empty()) {
145 MYLOGE("No stats (empty file) on %s; using max of %d\n", path_.c_str(), max_);
146 return;
147 }
148 std::vector<std::string> lines = android::base::Split(content, "\n");
149
150 if (lines.size() < 1) {
151 MYLOGE("Invalid stats on file %s: not enough lines (%d). Using max of %d\n", path_.c_str(),
152 (int)lines.size(), max_);
153 return;
154 }
155 char* ptr;
156 n_runs_ = strtol(lines[0].c_str(), &ptr, 10);
157 average_max_ = strtol(ptr, nullptr, 10);
158 if (n_runs_ <= 0 || average_max_ <= 0 || n_runs_ > STATS_MAX_N_RUNS ||
159 average_max_ > STATS_MAX_AVERAGE) {
160 MYLOGE("Invalid stats line on file %s: %s\n", path_.c_str(), lines[0].c_str());
161 initial_max_ = Progress::kDefaultMax;
162 } else {
163 initial_max_ = average_max_;
164 }
165 max_ = initial_max_;
166
167 MYLOGI("Average max progress: %d in %d runs; estimated max: %d\n", average_max_, n_runs_, max_);
168}
169
170void Progress::Save() {
171 int32_t total = n_runs_ * average_max_ + progress_;
172 int32_t runs = n_runs_ + 1;
173 int32_t average = floor(((float)total) / runs);
174 MYLOGI("Saving stats (total=%d, runs=%d, average=%d) on %s\n", total, runs, average,
175 path_.c_str());
176 if (path_.empty()) {
177 return;
178 }
179
180 std::string content = android::base::StringPrintf("%d %d\n", runs, average);
181 if (!android::base::WriteStringToFile(content, path_)) {
182 MYLOGE("Could not save stats on %s\n", path_.c_str());
183 }
184}
185
186int32_t Progress::Get() const {
187 return progress_;
188}
189
Vishnu Nair6921f802017-11-22 09:17:23 -0800190bool Progress::Inc(int32_t delta_sec) {
Felipe Leme7447d7c2016-11-03 18:12:22 -0700191 bool changed = false;
Vishnu Nair6921f802017-11-22 09:17:23 -0800192 if (delta_sec >= 0) {
193 progress_ += delta_sec;
Felipe Leme7447d7c2016-11-03 18:12:22 -0700194 if (progress_ > max_) {
195 int32_t old_max = max_;
196 max_ = floor((float)progress_ * growth_factor_);
197 MYLOGD("Adjusting max progress from %d to %d\n", old_max, max_);
198 changed = true;
199 }
200 }
201 return changed;
202}
203
204int32_t Progress::GetMax() const {
205 return max_;
206}
207
208int32_t Progress::GetInitialMax() const {
209 return initial_max_;
210}
211
212void Progress::Dump(int fd, const std::string& prefix) const {
213 const char* pr = prefix.c_str();
214 dprintf(fd, "%sprogress: %d\n", pr, progress_);
215 dprintf(fd, "%smax: %d\n", pr, max_);
216 dprintf(fd, "%sinitial_max: %d\n", pr, initial_max_);
217 dprintf(fd, "%sgrowth_factor: %0.2f\n", pr, growth_factor_);
218 dprintf(fd, "%spath: %s\n", pr, path_.c_str());
219 dprintf(fd, "%sn_runs: %d\n", pr, n_runs_);
220 dprintf(fd, "%saverage_max: %d\n", pr, average_max_);
221}
222
Felipe Leme75876a22016-10-27 16:31:27 -0700223bool Dumpstate::IsZipping() const {
224 return zip_writer_ != nullptr;
225}
226
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700227std::string Dumpstate::GetPath(const std::string& suffix) const {
Felipe Leme9a523ae2016-10-20 15:10:33 -0700228 return android::base::StringPrintf("%s/%s-%s%s", bugreport_dir_.c_str(), base_name_.c_str(),
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700229 name_.c_str(), suffix.c_str());
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700230}
231
Felipe Leme7447d7c2016-11-03 18:12:22 -0700232void Dumpstate::SetProgress(std::unique_ptr<Progress> progress) {
233 progress_ = std::move(progress);
234}
235
John Spurlock5ecd4be2014-01-29 14:14:40 -0500236void for_each_userid(void (*func)(int), const char *header) {
Felipe Leme8f00ed02016-12-07 17:42:44 -0800237 std::string title = header == nullptr ? "for_each_userid" : android::base::StringPrintf(
238 "for_each_userid(%s)", header);
239 DurationReporter duration_reporter(title);
Felipe Lemef0292972016-11-22 13:57:05 -0800240 if (PropertiesHelper::IsDryRun()) return;
Felipe Lemed402e7d2016-08-03 09:22:27 -0700241
John Spurlock5ecd4be2014-01-29 14:14:40 -0500242 DIR *d;
243 struct dirent *de;
244
Felipe Lemed8b94e52016-12-08 10:21:44 -0800245 if (header) printf("\n------ %s ------\n", header);
John Spurlock5ecd4be2014-01-29 14:14:40 -0500246 func(0);
247
248 if (!(d = opendir("/data/system/users"))) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800249 printf("Failed to open /data/system/users (%s)\n", strerror(errno));
John Spurlock5ecd4be2014-01-29 14:14:40 -0500250 return;
251 }
252
253 while ((de = readdir(d))) {
254 int userid;
255 if (de->d_type != DT_DIR || !(userid = atoi(de->d_name))) {
256 continue;
257 }
258 func(userid);
259 }
260
261 closedir(d);
262}
263
Colin Cross0c22e8b2012-11-02 15:46:56 -0700264static void __for_each_pid(void (*helper)(int, const char *, void *), const char *header, void *arg) {
Colin Crossf45fa6b2012-03-26 12:38:26 -0700265 DIR *d;
266 struct dirent *de;
267
268 if (!(d = opendir("/proc"))) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800269 printf("Failed to open /proc (%s)\n", strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700270 return;
271 }
272
Felipe Lemed8b94e52016-12-08 10:21:44 -0800273 if (header) printf("\n------ %s ------\n", header);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700274 while ((de = readdir(d))) {
275 int pid;
276 int fd;
277 char cmdpath[255];
278 char cmdline[255];
279
280 if (!(pid = atoi(de->d_name))) {
281 continue;
282 }
283
Colin Crossf45fa6b2012-03-26 12:38:26 -0700284 memset(cmdline, 0, sizeof(cmdline));
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800285
286 snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/cmdline", pid);
287 if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) {
288 TEMP_FAILURE_RETRY(read(fd, cmdline, sizeof(cmdline) - 2));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700289 close(fd);
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800290 if (cmdline[0]) {
291 helper(pid, cmdline, arg);
292 continue;
293 }
294 }
295
296 // if no cmdline, a kernel thread has comm
297 snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/comm", pid);
298 if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) {
299 TEMP_FAILURE_RETRY(read(fd, cmdline + 1, sizeof(cmdline) - 4));
300 close(fd);
301 if (cmdline[1]) {
302 cmdline[0] = '[';
303 size_t len = strcspn(cmdline, "\f\b\r\n");
304 cmdline[len] = ']';
305 cmdline[len+1] = '\0';
306 }
307 }
308 if (!cmdline[0]) {
309 strcpy(cmdline, "N/A");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700310 }
Colin Cross0c22e8b2012-11-02 15:46:56 -0700311 helper(pid, cmdline, arg);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700312 }
313
314 closedir(d);
315}
316
Colin Cross0c22e8b2012-11-02 15:46:56 -0700317static void for_each_pid_helper(int pid, const char *cmdline, void *arg) {
Felipe Leme8620bb42015-11-10 11:04:45 -0800318 for_each_pid_func *func = (for_each_pid_func*) arg;
Colin Cross0c22e8b2012-11-02 15:46:56 -0700319 func(pid, cmdline);
320}
321
322void for_each_pid(for_each_pid_func func, const char *header) {
Felipe Leme8f00ed02016-12-07 17:42:44 -0800323 std::string title = header == nullptr ? "for_each_pid"
324 : android::base::StringPrintf("for_each_pid(%s)", header);
325 DurationReporter duration_reporter(title);
Felipe Lemef0292972016-11-22 13:57:05 -0800326 if (PropertiesHelper::IsDryRun()) return;
Felipe Lemed402e7d2016-08-03 09:22:27 -0700327
Felipe Leme515eb0d2015-12-14 15:09:56 -0800328 __for_each_pid(for_each_pid_helper, header, (void *) func);
Colin Cross0c22e8b2012-11-02 15:46:56 -0700329}
330
331static void for_each_tid_helper(int pid, const char *cmdline, void *arg) {
332 DIR *d;
333 struct dirent *de;
334 char taskpath[255];
Felipe Leme8620bb42015-11-10 11:04:45 -0800335 for_each_tid_func *func = (for_each_tid_func *) arg;
Colin Cross0c22e8b2012-11-02 15:46:56 -0700336
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700337 snprintf(taskpath, sizeof(taskpath), "/proc/%d/task", pid);
Colin Cross0c22e8b2012-11-02 15:46:56 -0700338
339 if (!(d = opendir(taskpath))) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800340 printf("Failed to open %s (%s)\n", taskpath, strerror(errno));
Colin Cross0c22e8b2012-11-02 15:46:56 -0700341 return;
342 }
343
344 func(pid, pid, cmdline);
345
346 while ((de = readdir(d))) {
347 int tid;
348 int fd;
349 char commpath[255];
350 char comm[255];
351
352 if (!(tid = atoi(de->d_name))) {
353 continue;
354 }
355
356 if (tid == pid)
357 continue;
358
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700359 snprintf(commpath, sizeof(commpath), "/proc/%d/comm", tid);
Colin Cross1493a392012-11-07 11:25:31 -0800360 memset(comm, 0, sizeof(comm));
Nick Kralevichcd67e9f2015-03-19 11:30:59 -0700361 if ((fd = TEMP_FAILURE_RETRY(open(commpath, O_RDONLY | O_CLOEXEC))) < 0) {
Colin Cross0c22e8b2012-11-02 15:46:56 -0700362 strcpy(comm, "N/A");
363 } else {
364 char *c;
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800365 TEMP_FAILURE_RETRY(read(fd, comm, sizeof(comm) - 2));
Colin Cross0c22e8b2012-11-02 15:46:56 -0700366 close(fd);
367
368 c = strrchr(comm, '\n');
369 if (c) {
370 *c = '\0';
371 }
372 }
373 func(pid, tid, comm);
374 }
375
376 closedir(d);
377}
378
379void for_each_tid(for_each_tid_func func, const char *header) {
Felipe Leme8f00ed02016-12-07 17:42:44 -0800380 std::string title = header == nullptr ? "for_each_tid"
381 : android::base::StringPrintf("for_each_tid(%s)", header);
382 DurationReporter duration_reporter(title);
Felipe Lemed8b94e52016-12-08 10:21:44 -0800383
Felipe Lemef0292972016-11-22 13:57:05 -0800384 if (PropertiesHelper::IsDryRun()) return;
Felipe Lemed402e7d2016-08-03 09:22:27 -0700385
Felipe Leme8620bb42015-11-10 11:04:45 -0800386 __for_each_pid(for_each_tid_helper, header, (void *) func);
Colin Cross0c22e8b2012-11-02 15:46:56 -0700387}
388
389void show_wchan(int pid, int tid, const char *name) {
Felipe Lemef0292972016-11-22 13:57:05 -0800390 if (PropertiesHelper::IsDryRun()) return;
Felipe Lemed402e7d2016-08-03 09:22:27 -0700391
Colin Crossf45fa6b2012-03-26 12:38:26 -0700392 char path[255];
393 char buffer[255];
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800394 int fd, ret, save_errno;
Colin Cross0c22e8b2012-11-02 15:46:56 -0700395 char name_buffer[255];
Colin Crossf45fa6b2012-03-26 12:38:26 -0700396
397 memset(buffer, 0, sizeof(buffer));
398
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700399 snprintf(path, sizeof(path), "/proc/%d/wchan", tid);
Nick Kralevichcd67e9f2015-03-19 11:30:59 -0700400 if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800401 printf("Failed to open '%s' (%s)\n", path, strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700402 return;
403 }
404
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800405 ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
406 save_errno = errno;
407 close(fd);
408
409 if (ret < 0) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800410 printf("Failed to read '%s' (%s)\n", path, strerror(save_errno));
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800411 return;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700412 }
413
Colin Cross0c22e8b2012-11-02 15:46:56 -0700414 snprintf(name_buffer, sizeof(name_buffer), "%*s%s",
415 pid == tid ? 0 : 3, "", name);
416
Felipe Lemed8b94e52016-12-08 10:21:44 -0800417 printf("%-7d %-32s %s\n", tid, name_buffer, buffer);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700418
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800419 return;
420}
421
422// print time in centiseconds
423static void snprcent(char *buffer, size_t len, size_t spc,
424 unsigned long long time) {
425 static long hz; // cache discovered hz
426
427 if (hz <= 0) {
428 hz = sysconf(_SC_CLK_TCK);
429 if (hz <= 0) {
430 hz = 1000;
431 }
432 }
433
434 // convert to centiseconds
435 time = (time * 100 + (hz / 2)) / hz;
436
437 char str[16];
438
439 snprintf(str, sizeof(str), " %llu.%02u",
440 time / 100, (unsigned)(time % 100));
441 size_t offset = strlen(buffer);
442 snprintf(buffer + offset, (len > offset) ? len - offset : 0,
443 "%*s", (spc > offset) ? (int)(spc - offset) : 0, str);
444}
445
446// print permille as a percent
447static void snprdec(char *buffer, size_t len, size_t spc, unsigned permille) {
448 char str[16];
449
450 snprintf(str, sizeof(str), " %u.%u%%", permille / 10, permille % 10);
451 size_t offset = strlen(buffer);
452 snprintf(buffer + offset, (len > offset) ? len - offset : 0,
453 "%*s", (spc > offset) ? (int)(spc - offset) : 0, str);
454}
455
456void show_showtime(int pid, const char *name) {
Felipe Lemef0292972016-11-22 13:57:05 -0800457 if (PropertiesHelper::IsDryRun()) return;
Felipe Lemed402e7d2016-08-03 09:22:27 -0700458
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800459 char path[255];
460 char buffer[1023];
461 int fd, ret, save_errno;
462
463 memset(buffer, 0, sizeof(buffer));
464
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700465 snprintf(path, sizeof(path), "/proc/%d/stat", pid);
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800466 if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800467 printf("Failed to open '%s' (%s)\n", path, strerror(errno));
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800468 return;
469 }
470
471 ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
472 save_errno = errno;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700473 close(fd);
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800474
475 if (ret < 0) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800476 printf("Failed to read '%s' (%s)\n", path, strerror(save_errno));
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800477 return;
478 }
479
480 // field 14 is utime
481 // field 15 is stime
482 // field 42 is iotime
483 unsigned long long utime = 0, stime = 0, iotime = 0;
484 if (sscanf(buffer,
Mark Salyzyn791ddd32016-02-10 07:41:12 -0800485 "%*u %*s %*s %*d %*d %*d %*d %*d %*d %*d %*d "
486 "%*d %*d %llu %llu %*d %*d %*d %*d %*d %*d "
487 "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
488 "%*d %*d %*d %*d %*d %*d %*d %*d %*d %llu ",
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800489 &utime, &stime, &iotime) != 3) {
490 return;
491 }
492
493 unsigned long long total = utime + stime;
494 if (!total) {
495 return;
496 }
497
498 unsigned permille = (iotime * 1000 + (total / 2)) / total;
499 if (permille > 1000) {
500 permille = 1000;
501 }
502
503 // try to beautify and stabilize columns at <80 characters
504 snprintf(buffer, sizeof(buffer), "%-6d%s", pid, name);
505 if ((name[0] != '[') || utime) {
506 snprcent(buffer, sizeof(buffer), 57, utime);
507 }
508 snprcent(buffer, sizeof(buffer), 65, stime);
509 if ((name[0] != '[') || iotime) {
510 snprcent(buffer, sizeof(buffer), 73, iotime);
511 }
512 if (iotime) {
513 snprdec(buffer, sizeof(buffer), 79, permille);
514 }
Felipe Lemed8b94e52016-12-08 10:21:44 -0800515 puts(buffer); // adds a trailing newline
Mark Salyzyn0751efa2016-02-05 15:33:17 -0800516
Colin Crossf45fa6b2012-03-26 12:38:26 -0700517 return;
518}
519
520void do_dmesg() {
Felipe Leme78f2c862015-12-21 09:55:22 -0800521 const char *title = "KERNEL LOG (dmesg)";
522 DurationReporter duration_reporter(title);
Felipe Lemed8b94e52016-12-08 10:21:44 -0800523 printf("------ %s ------\n", title);
Felipe Leme78f2c862015-12-21 09:55:22 -0800524
Felipe Lemef0292972016-11-22 13:57:05 -0800525 if (PropertiesHelper::IsDryRun()) return;
Felipe Lemed402e7d2016-08-03 09:22:27 -0700526
Elliott Hughes5f87b312012-09-17 11:43:40 -0700527 /* Get size of kernel buffer */
Yi Kong19d5c002018-07-20 13:39:55 -0700528 int size = klogctl(KLOG_SIZE_BUFFER, nullptr, 0);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700529 if (size <= 0) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800530 printf("Unexpected klogctl return value: %d\n\n", size);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700531 return;
532 }
533 char *buf = (char *) malloc(size + 1);
Yi Kong19d5c002018-07-20 13:39:55 -0700534 if (buf == nullptr) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800535 printf("memory allocation failed\n\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700536 return;
537 }
538 int retval = klogctl(KLOG_READ_ALL, buf, size);
539 if (retval < 0) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800540 printf("klogctl failure\n\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700541 free(buf);
542 return;
543 }
544 buf[retval] = '\0';
Felipe Lemed8b94e52016-12-08 10:21:44 -0800545 printf("%s\n\n", buf);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700546 free(buf);
547 return;
548}
549
550void do_showmap(int pid, const char *name) {
551 char title[255];
552 char arg[255];
553
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700554 snprintf(title, sizeof(title), "SHOW MAP %d (%s)", pid, name);
555 snprintf(arg, sizeof(arg), "%d", pid);
Felipe Lemef0292972016-11-22 13:57:05 -0800556 RunCommand(title, {"showmap", "-q", arg}, CommandOptions::AS_ROOT);
Felipe Lemebda15a02016-11-16 17:48:25 -0800557}
558
Felipe Leme678727a2016-09-21 17:22:11 -0700559int Dumpstate::DumpFile(const std::string& title, const std::string& path) {
Felipe Leme9a523ae2016-10-20 15:10:33 -0700560 DurationReporter duration_reporter(title);
Felipe Leme46b85da2016-11-21 17:40:45 -0800561
Felipe Lemef0292972016-11-22 13:57:05 -0800562 int status = DumpFileToFd(STDOUT_FILENO, title, path);
Felipe Leme46b85da2016-11-21 17:40:45 -0800563
Felipe Lemef0292972016-11-22 13:57:05 -0800564 UpdateProgress(WEIGHT_FILE);
Felipe Leme46b85da2016-11-21 17:40:45 -0800565
Felipe Leme46b85da2016-11-21 17:40:45 -0800566 return status;
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800567}
568
Felipe Leme71a74ac2016-03-17 15:43:25 -0700569int read_file_as_long(const char *path, long int *output) {
570 int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC));
571 if (fd < 0) {
572 int err = errno;
573 MYLOGE("Error opening file descriptor for %s: %s\n", path, strerror(err));
574 return -1;
575 }
576 char buffer[50];
577 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
578 if (bytes_read == -1) {
579 MYLOGE("Error reading file %s: %s\n", path, strerror(errno));
580 return -2;
581 }
582 if (bytes_read == 0) {
583 MYLOGE("File %s is empty\n", path);
584 return -3;
585 }
586 *output = atoi(buffer);
587 return 0;
588}
589
Mark Salyzyn326842f2015-04-30 09:49:41 -0700590/* calls skip to gate calling dump_from_fd recursively
591 * in the specified directory. dump_from_fd defaults to
592 * dump_file_from_fd above when set to NULL. skip defaults
593 * to false when set to NULL. dump_from_fd will always be
594 * called with title NULL.
595 */
Felipe Leme678727a2016-09-21 17:22:11 -0700596int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path),
597 int (*dump_from_fd)(const char* title, const char* path, int fd)) {
Felipe Leme78f2c862015-12-21 09:55:22 -0800598 DurationReporter duration_reporter(title);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700599 DIR *dirp;
600 struct dirent *d;
Yi Kong19d5c002018-07-20 13:39:55 -0700601 char *newpath = nullptr;
Felipe Leme8620bb42015-11-10 11:04:45 -0800602 const char *slash = "/";
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100603 int retval = 0;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700604
Felipe Leme678727a2016-09-21 17:22:11 -0700605 if (!title.empty()) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800606 printf("------ %s (%s) ------\n", title.c_str(), dir);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700607 }
Felipe Lemef0292972016-11-22 13:57:05 -0800608 if (PropertiesHelper::IsDryRun()) return 0;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700609
610 if (dir[strlen(dir) - 1] == '/') {
611 ++slash;
612 }
613 dirp = opendir(dir);
Yi Kong19d5c002018-07-20 13:39:55 -0700614 if (dirp == nullptr) {
Mark Salyzyn326842f2015-04-30 09:49:41 -0700615 retval = -errno;
Felipe Leme107a05f2016-03-08 15:11:15 -0800616 MYLOGE("%s: %s\n", dir, strerror(errno));
Mark Salyzyn326842f2015-04-30 09:49:41 -0700617 return retval;
618 }
619
620 if (!dump_from_fd) {
621 dump_from_fd = dump_file_from_fd;
622 }
Yi Kong19d5c002018-07-20 13:39:55 -0700623 for (; ((d = readdir(dirp))); free(newpath), newpath = nullptr) {
Mark Salyzyn326842f2015-04-30 09:49:41 -0700624 if ((d->d_name[0] == '.')
625 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
626 || (d->d_name[1] == '\0'))) {
627 continue;
628 }
629 asprintf(&newpath, "%s%s%s%s", dir, slash, d->d_name,
630 (d->d_type == DT_DIR) ? "/" : "");
631 if (!newpath) {
632 retval = -errno;
633 continue;
634 }
635 if (skip && (*skip)(newpath)) {
636 continue;
637 }
638 if (d->d_type == DT_DIR) {
Felipe Leme678727a2016-09-21 17:22:11 -0700639 int ret = dump_files("", newpath, skip, dump_from_fd);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700640 if (ret < 0) {
641 retval = ret;
642 }
643 continue;
644 }
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100645 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(newpath, O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
646 if (fd.get() < 0) {
647 retval = -1;
Felipe Lemed8b94e52016-12-08 10:21:44 -0800648 printf("*** %s: %s\n", newpath, strerror(errno));
Mark Salyzyn326842f2015-04-30 09:49:41 -0700649 continue;
650 }
Yi Kong19d5c002018-07-20 13:39:55 -0700651 (*dump_from_fd)(nullptr, newpath, fd.get());
Mark Salyzyn326842f2015-04-30 09:49:41 -0700652 }
653 closedir(dirp);
Felipe Leme678727a2016-09-21 17:22:11 -0700654 if (!title.empty()) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800655 printf("\n");
Mark Salyzyn326842f2015-04-30 09:49:41 -0700656 }
657 return retval;
658}
659
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800660/* fd must have been opened with the flag O_NONBLOCK. With this flag set,
661 * it's possible to avoid issues where opening the file itself can get
662 * stuck.
663 */
664int dump_file_from_fd(const char *title, const char *path, int fd) {
Felipe Lemef0292972016-11-22 13:57:05 -0800665 if (PropertiesHelper::IsDryRun()) return 0;
Felipe Lemed402e7d2016-08-03 09:22:27 -0700666
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800667 int flags = fcntl(fd, F_GETFL);
668 if (flags == -1) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800669 printf("*** %s: failed to get flags on fd %d: %s\n", path, fd, strerror(errno));
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800670 return -1;
671 } else if (!(flags & O_NONBLOCK)) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800672 printf("*** %s: fd must have O_NONBLOCK set.\n", path);
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800673 return -1;
674 }
Felipe Lemef0292972016-11-22 13:57:05 -0800675 return DumpFileFromFdToFd(title, path, fd, STDOUT_FILENO, PropertiesHelper::IsDryRun());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700676}
677
Felipe Leme46b85da2016-11-21 17:40:45 -0800678int Dumpstate::RunCommand(const std::string& title, const std::vector<std::string>& full_command,
679 const CommandOptions& options) {
680 DurationReporter duration_reporter(title);
681
Felipe Lemef0292972016-11-22 13:57:05 -0800682 int status = RunCommandToFd(STDOUT_FILENO, title, full_command, options);
Felipe Leme46b85da2016-11-21 17:40:45 -0800683
Felipe Lemef0292972016-11-22 13:57:05 -0800684 /* TODO: for now we're simplifying the progress calculation by using the
685 * timeout as the weight. It's a good approximation for most cases, except when calling dumpsys,
686 * where its weight should be much higher proportionally to its timeout.
687 * Ideally, it should use a options.EstimatedDuration() instead...*/
688 UpdateProgress(options.Timeout());
Felipe Leme46b85da2016-11-21 17:40:45 -0800689
Felipe Leme46b85da2016-11-21 17:40:45 -0800690 return status;
691}
692
Felipe Leme9a523ae2016-10-20 15:10:33 -0700693void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
Vishnu Nair6921f802017-11-22 09:17:23 -0800694 const CommandOptions& options, long dumpsysTimeoutMs) {
695 long timeout_ms = dumpsysTimeoutMs > 0 ? dumpsysTimeoutMs : options.TimeoutInMs();
696 std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-T", std::to_string(timeout_ms)};
Felipe Leme9a523ae2016-10-20 15:10:33 -0700697 dumpsys.insert(dumpsys.end(), dumpsys_args.begin(), dumpsys_args.end());
Felipe Leme678727a2016-09-21 17:22:11 -0700698 RunCommand(title, dumpsys, options);
Felipe Leme30dbfa12016-09-02 12:43:26 -0700699}
700
Felipe Leme2628e9e2016-04-12 16:36:51 -0700701int open_socket(const char *service) {
Colin Crossf45fa6b2012-03-26 12:38:26 -0700702 int s = android_get_control_socket(service);
703 if (s < 0) {
Felipe Leme107a05f2016-03-08 15:11:15 -0800704 MYLOGE("android_get_control_socket(%s): %s\n", service, strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700705 exit(1);
706 }
Nick Kralevichcd67e9f2015-03-19 11:30:59 -0700707 fcntl(s, F_SETFD, FD_CLOEXEC);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700708 if (listen(s, 4) < 0) {
Felipe Leme107a05f2016-03-08 15:11:15 -0800709 MYLOGE("listen(control socket): %s\n", strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700710 exit(1);
711 }
712
713 struct sockaddr addr;
714 socklen_t alen = sizeof(addr);
715 int fd = accept(s, &addr, &alen);
716 if (fd < 0) {
Felipe Leme107a05f2016-03-08 15:11:15 -0800717 MYLOGE("accept(control socket): %s\n", strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700718 exit(1);
719 }
720
Felipe Leme2628e9e2016-04-12 16:36:51 -0700721 return fd;
722}
723
724/* redirect output to a service control socket */
725void redirect_to_socket(FILE *redirect, const char *service) {
726 int fd = open_socket(service);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700727 fflush(redirect);
728 dup2(fd, fileno(redirect));
729 close(fd);
730}
731
Felipe Leme2628e9e2016-04-12 16:36:51 -0700732// TODO: should call is_valid_output_file and/or be merged into it.
Felipe Leme111b9d02016-02-03 09:28:24 -0800733void create_parent_dirs(const char *path) {
Srinath Sridharanfdf52d32016-02-01 15:50:22 -0800734 char *chp = const_cast<char *> (path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700735
736 /* skip initial slash */
737 if (chp[0] == '/')
738 chp++;
739
740 /* create leading directories, if necessary */
Felipe Leme111b9d02016-02-03 09:28:24 -0800741 struct stat dir_stat;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700742 while (chp && chp[0]) {
743 chp = strchr(chp, '/');
744 if (chp) {
745 *chp = 0;
Felipe Leme111b9d02016-02-03 09:28:24 -0800746 if (stat(path, &dir_stat) == -1 || !S_ISDIR(dir_stat.st_mode)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800747 MYLOGI("Creating directory %s\n", path);
Felipe Leme111b9d02016-02-03 09:28:24 -0800748 if (mkdir(path, 0770)) { /* drwxrwx--- */
Felipe Lemecbce55d2016-02-08 09:53:18 -0800749 MYLOGE("Unable to create directory %s: %s\n", path, strerror(errno));
Felipe Leme111b9d02016-02-03 09:28:24 -0800750 } else if (chown(path, AID_SHELL, AID_SHELL)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800751 MYLOGE("Unable to change ownership of dir %s: %s\n", path, strerror(errno));
Felipe Leme111b9d02016-02-03 09:28:24 -0800752 }
753 }
Colin Crossf45fa6b2012-03-26 12:38:26 -0700754 *chp++ = '/';
755 }
756 }
Felipe Leme111b9d02016-02-03 09:28:24 -0800757}
758
Felipe Leme0f3fb202016-06-10 17:10:53 -0700759void _redirect_to_file(FILE *redirect, char *path, int truncate_flag) {
Felipe Leme111b9d02016-02-03 09:28:24 -0800760 create_parent_dirs(path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700761
Felipe Leme0f3fb202016-06-10 17:10:53 -0700762 int fd = TEMP_FAILURE_RETRY(open(path,
763 O_WRONLY | O_CREAT | truncate_flag | O_CLOEXEC | O_NOFOLLOW,
Christopher Ferrisff4a4dc2015-02-09 16:24:47 -0800764 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700765 if (fd < 0) {
Felipe Leme107a05f2016-03-08 15:11:15 -0800766 MYLOGE("%s: %s\n", path, strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700767 exit(1);
768 }
769
Christopher Ferrisff4a4dc2015-02-09 16:24:47 -0800770 TEMP_FAILURE_RETRY(dup2(fd, fileno(redirect)));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700771 close(fd);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700772}
773
Felipe Leme0f3fb202016-06-10 17:10:53 -0700774void redirect_to_file(FILE *redirect, char *path) {
775 _redirect_to_file(redirect, path, O_TRUNC);
776}
777
778void redirect_to_existing_file(FILE *redirect, char *path) {
779 _redirect_to_file(redirect, path, O_APPEND);
780}
781
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700782// Dump Dalvik and native stack traces, return the trace file location (nullptr if none).
783const char* dump_traces() {
Felipe Lemee184f662016-10-27 10:04:47 -0700784 DurationReporter duration_reporter("DUMP TRACES");
Felipe Lemed402e7d2016-08-03 09:22:27 -0700785
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700786 const std::string temp_file_pattern = "/data/anr/dumptrace_XXXXXX";
Narayan Kamath8f788292017-05-25 13:20:39 +0100787 const size_t buf_size = temp_file_pattern.length() + 1;
788 std::unique_ptr<char[]> file_name_buf(new char[buf_size]);
789 memcpy(file_name_buf.get(), temp_file_pattern.c_str(), buf_size);
790
791 // Create a new, empty file to receive all trace dumps.
792 //
793 // TODO: This can be simplified once we remove support for the old style
794 // dumps. We can have a file descriptor passed in to dump_traces instead
795 // of creating a file, closing it and then reopening it again.
796 android::base::unique_fd fd(mkostemp(file_name_buf.get(), O_APPEND | O_CLOEXEC));
797 if (fd < 0) {
798 MYLOGE("mkostemp on pattern %s: %s\n", file_name_buf.get(), strerror(errno));
799 return nullptr;
800 }
801
802 // Nobody should have access to this temporary file except dumpstate, but we
803 // temporarily grant 'read' to 'others' here because this file is created
804 // when tombstoned is still running as root, but dumped after dropping. This
805 // can go away once support for old style dumping has.
806 const int chmod_ret = fchmod(fd, 0666);
807 if (chmod_ret < 0) {
808 MYLOGE("fchmod on %s failed: %s\n", file_name_buf.get(), strerror(errno));
809 return nullptr;
810 }
811
812 std::unique_ptr<DIR, decltype(&closedir)> proc(opendir("/proc"), closedir);
813 if (proc.get() == nullptr) {
814 MYLOGE("opendir /proc failed: %s\n", strerror(errno));
815 return nullptr;
816 }
817
818 // Number of times process dumping has timed out. If we encounter too many
819 // failures, we'll give up.
820 int timeout_failures = 0;
821 bool dalvik_found = false;
822
823 const std::set<int> hal_pids = get_interesting_hal_pids();
824
825 struct dirent* d;
826 while ((d = readdir(proc.get()))) {
827 int pid = atoi(d->d_name);
828 if (pid <= 0) {
829 continue;
830 }
831
832 const std::string link_name = android::base::StringPrintf("/proc/%d/exe", pid);
833 std::string exe;
834 if (!android::base::Readlink(link_name, &exe)) {
835 continue;
836 }
837
838 bool is_java_process;
839 if (exe == "/system/bin/app_process32" || exe == "/system/bin/app_process64") {
840 // Don't bother dumping backtraces for the zygote.
841 if (IsZygote(pid)) {
842 continue;
843 }
844
845 dalvik_found = true;
846 is_java_process = true;
847 } else if (should_dump_native_traces(exe.c_str()) || hal_pids.find(pid) != hal_pids.end()) {
848 is_java_process = false;
849 } else {
850 // Probably a native process we don't care about, continue.
851 continue;
852 }
853
854 // If 3 backtrace dumps fail in a row, consider debuggerd dead.
855 if (timeout_failures == 3) {
856 dprintf(fd, "ERROR: Too many stack dump failures, exiting.\n");
857 break;
858 }
859
860 const uint64_t start = Nanotime();
861 const int ret = dump_backtrace_to_file_timeout(
862 pid, is_java_process ? kDebuggerdJavaBacktrace : kDebuggerdNativeBacktrace,
863 is_java_process ? 5 : 20, fd);
864
865 if (ret == -1) {
866 dprintf(fd, "dumping failed, likely due to a timeout\n");
867 timeout_failures++;
868 continue;
869 }
870
871 // We've successfully dumped stack traces, reset the failure count
872 // and write a summary of the elapsed time to the file and continue with the
873 // next process.
874 timeout_failures = 0;
875
876 dprintf(fd, "[dump %s stack %d: %.3fs elapsed]\n", is_java_process ? "dalvik" : "native",
877 pid, (float)(Nanotime() - start) / NANOS_PER_SEC);
878 }
879
880 if (!dalvik_found) {
881 MYLOGE("Warning: no Dalvik processes found to dump stacks\n");
882 }
883
884 return file_name_buf.release();
885}
886
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700887void dump_route_tables() {
Felipe Leme78f2c862015-12-21 09:55:22 -0800888 DurationReporter duration_reporter("DUMP ROUTE TABLES");
Felipe Lemef0292972016-11-22 13:57:05 -0800889 if (PropertiesHelper::IsDryRun()) return;
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700890 const char* const RT_TABLES_PATH = "/data/misc/net/rt_tables";
Felipe Lemec7fe8fe2016-09-21 18:13:20 -0700891 ds.DumpFile("RT_TABLES", RT_TABLES_PATH);
Nick Kralevichcd67e9f2015-03-19 11:30:59 -0700892 FILE* fp = fopen(RT_TABLES_PATH, "re");
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700893 if (!fp) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800894 printf("*** %s: %s\n", RT_TABLES_PATH, strerror(errno));
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700895 return;
896 }
897 char table[16];
898 // Each line has an integer (the table number), a space, and a string (the table name). We only
899 // need the table number. It's a 32-bit unsigned number, so max 10 chars. Skip the table name.
900 // Add a fixed max limit so this doesn't go awry.
901 for (int i = 0; i < 64 && fscanf(fp, " %10s %*s", table) == 1; ++i) {
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700902 RunCommand("ROUTE TABLE IPv4", {"ip", "-4", "route", "show", "table", table});
903 RunCommand("ROUTE TABLE IPv6", {"ip", "-6", "route", "show", "table", table});
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700904 }
905 fclose(fp);
906}
Felipe Leme71bbfc52015-11-23 14:14:51 -0800907
Felipe Leme71bbfc52015-11-23 14:14:51 -0800908// TODO: make this function thread safe if sections are generated in parallel.
Vishnu Nair6921f802017-11-22 09:17:23 -0800909void Dumpstate::UpdateProgress(int32_t delta_sec) {
Felipe Leme7447d7c2016-11-03 18:12:22 -0700910 if (progress_ == nullptr) {
911 MYLOGE("UpdateProgress: progress_ not set\n");
912 return;
913 }
Felipe Leme71bbfc52015-11-23 14:14:51 -0800914
Felipe Leme7447d7c2016-11-03 18:12:22 -0700915 // Always update progess so stats can be tuned...
Vishnu Nair6921f802017-11-22 09:17:23 -0800916 bool max_changed = progress_->Inc(delta_sec);
Felipe Leme7447d7c2016-11-03 18:12:22 -0700917
918 // ...but only notifiy listeners when necessary.
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100919 if (!options_->do_progress_updates) return;
Felipe Leme71bbfc52015-11-23 14:14:51 -0800920
Felipe Leme009ecbb2016-11-07 10:18:44 -0800921 int progress = progress_->Get();
922 int max = progress_->GetMax();
Felipe Lemead5f6c42015-11-30 14:26:46 -0800923
924 // adjusts max on the fly
Felipe Leme009ecbb2016-11-07 10:18:44 -0800925 if (max_changed && listener_ != nullptr) {
926 listener_->onMaxProgressUpdated(max);
Felipe Lemead5f6c42015-11-30 14:26:46 -0800927 }
928
Felipe Leme009ecbb2016-11-07 10:18:44 -0800929 int32_t last_update_delta = progress - last_updated_progress_;
930 if (last_updated_progress_ > 0 && last_update_delta < update_progress_threshold_) {
931 return;
932 }
933 last_updated_progress_ = progress;
Felipe Leme7447d7c2016-11-03 18:12:22 -0700934
Felipe Leme9a523ae2016-10-20 15:10:33 -0700935 if (control_socket_fd_ >= 0) {
Felipe Leme7447d7c2016-11-03 18:12:22 -0700936 dprintf(control_socket_fd_, "PROGRESS:%d/%d\n", progress, max);
Felipe Leme9a523ae2016-10-20 15:10:33 -0700937 fsync(control_socket_fd_);
Felipe Leme02b7e002016-07-22 12:03:20 -0700938 }
939
Felipe Leme75876a22016-10-27 16:31:27 -0700940 if (listener_ != nullptr) {
Felipe Leme7447d7c2016-11-03 18:12:22 -0700941 if (progress % 100 == 0) {
Felipe Leme75876a22016-10-27 16:31:27 -0700942 // We don't want to spam logcat, so only log multiples of 100.
Felipe Leme7447d7c2016-11-03 18:12:22 -0700943 MYLOGD("Setting progress (%s): %d/%d\n", listener_name_.c_str(), progress, max);
Felipe Leme75876a22016-10-27 16:31:27 -0700944 } else {
945 // stderr is ignored on normal invocations, but useful when calling
946 // /system/bin/dumpstate directly for debuggging.
Felipe Leme7447d7c2016-11-03 18:12:22 -0700947 fprintf(stderr, "Setting progress (%s): %d/%d\n", listener_name_.c_str(), progress, max);
Felipe Leme75876a22016-10-27 16:31:27 -0700948 }
Felipe Leme7447d7c2016-11-03 18:12:22 -0700949 listener_->onProgressUpdated(progress);
Felipe Leme71bbfc52015-11-23 14:14:51 -0800950 }
951}
Felipe Lemee338bf62015-12-07 14:03:50 -0800952
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700953void Dumpstate::TakeScreenshot(const std::string& path) {
Felipe Leme9a523ae2016-10-20 15:10:33 -0700954 const std::string& real_path = path.empty() ? screenshot_path_ : path;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700955 int status =
Felipe Leme9a523ae2016-10-20 15:10:33 -0700956 RunCommand("", {"/system/bin/screencap", "-p", real_path},
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700957 CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build());
958 if (status == 0) {
Felipe Leme9a523ae2016-10-20 15:10:33 -0700959 MYLOGD("Screenshot saved on %s\n", real_path.c_str());
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700960 } else {
Felipe Leme9a523ae2016-10-20 15:10:33 -0700961 MYLOGE("Failed to take screenshot on %s\n", real_path.c_str());
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700962 }
Felipe Lemee338bf62015-12-07 14:03:50 -0800963}
Mark Salyzynf55d4022015-12-11 07:32:31 -0800964
Felipe Leme0c80cf02016-01-05 13:25:34 -0800965bool is_dir(const char* pathname) {
966 struct stat info;
967 if (stat(pathname, &info) == -1) {
968 return false;
969 }
970 return S_ISDIR(info.st_mode);
971}
972
973time_t get_mtime(int fd, time_t default_mtime) {
974 struct stat info;
975 if (fstat(fd, &info) == -1) {
976 return default_mtime;
977 }
978 return info.st_mtime;
979}
980
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800981void dump_emmc_ecsd(const char *ext_csd_path) {
Mark Salyzyn290f4b92016-05-16 08:33:59 -0700982 // List of interesting offsets
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800983 struct hex {
984 char str[2];
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800985 };
Mark Salyzyn290f4b92016-05-16 08:33:59 -0700986 static const size_t EXT_CSD_REV = 192 * sizeof(hex);
987 static const size_t EXT_PRE_EOL_INFO = 267 * sizeof(hex);
988 static const size_t EXT_DEVICE_LIFE_TIME_EST_TYP_A = 268 * sizeof(hex);
989 static const size_t EXT_DEVICE_LIFE_TIME_EST_TYP_B = 269 * sizeof(hex);
990
991 std::string buffer;
992 if (!android::base::ReadFileToString(ext_csd_path, &buffer)) {
993 return;
994 }
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800995
Felipe Lemed8b94e52016-12-08 10:21:44 -0800996 printf("------ %s Extended CSD ------\n", ext_csd_path);
Mark Salyzyn8c8130e2015-12-09 11:21:28 -0800997
Mark Salyzyn290f4b92016-05-16 08:33:59 -0700998 if (buffer.length() < (EXT_CSD_REV + sizeof(hex))) {
Felipe Lemed8b94e52016-12-08 10:21:44 -0800999 printf("*** %s: truncated content %zu\n\n", ext_csd_path, buffer.length());
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001000 return;
1001 }
1002
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001003 int ext_csd_rev = 0;
1004 std::string sub = buffer.substr(EXT_CSD_REV, sizeof(hex));
1005 if (sscanf(sub.c_str(), "%2x", &ext_csd_rev) != 1) {
Felipe Lemed8b94e52016-12-08 10:21:44 -08001006 printf("*** %s: EXT_CSD_REV parse error \"%s\"\n\n", ext_csd_path, sub.c_str());
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001007 return;
1008 }
1009
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001010 static const char *ver_str[] = {
1011 "4.0", "4.1", "4.2", "4.3", "Obsolete", "4.41", "4.5", "5.0"
1012 };
Felipe Lemed8b94e52016-12-08 10:21:44 -08001013 printf("rev 1.%d (MMC %s)\n", ext_csd_rev,
1014 (ext_csd_rev < (int)(sizeof(ver_str) / sizeof(ver_str[0]))) ? ver_str[ext_csd_rev]
1015 : "Unknown");
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001016 if (ext_csd_rev < 7) {
Felipe Lemed8b94e52016-12-08 10:21:44 -08001017 printf("\n");
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001018 return;
1019 }
1020
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001021 if (buffer.length() < (EXT_PRE_EOL_INFO + sizeof(hex))) {
Felipe Lemed8b94e52016-12-08 10:21:44 -08001022 printf("*** %s: truncated content %zu\n\n", ext_csd_path, buffer.length());
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001023 return;
1024 }
1025
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001026 int ext_pre_eol_info = 0;
1027 sub = buffer.substr(EXT_PRE_EOL_INFO, sizeof(hex));
1028 if (sscanf(sub.c_str(), "%2x", &ext_pre_eol_info) != 1) {
Felipe Lemed8b94e52016-12-08 10:21:44 -08001029 printf("*** %s: PRE_EOL_INFO parse error \"%s\"\n\n", ext_csd_path, sub.c_str());
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001030 return;
1031 }
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001032
1033 static const char *eol_str[] = {
1034 "Undefined",
1035 "Normal",
1036 "Warning (consumed 80% of reserve)",
1037 "Urgent (consumed 90% of reserve)"
1038 };
Felipe Lemed8b94e52016-12-08 10:21:44 -08001039 printf(
1040 "PRE_EOL_INFO %d (MMC %s)\n", ext_pre_eol_info,
Felipe Leme8f00ed02016-12-07 17:42:44 -08001041 eol_str[(ext_pre_eol_info < (int)(sizeof(eol_str) / sizeof(eol_str[0]))) ? ext_pre_eol_info
1042 : 0]);
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001043
1044 for (size_t lifetime = EXT_DEVICE_LIFE_TIME_EST_TYP_A;
1045 lifetime <= EXT_DEVICE_LIFE_TIME_EST_TYP_B;
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001046 lifetime += sizeof(hex)) {
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001047 int ext_device_life_time_est;
1048 static const char *est_str[] = {
1049 "Undefined",
1050 "0-10% of device lifetime used",
1051 "10-20% of device lifetime used",
1052 "20-30% of device lifetime used",
1053 "30-40% of device lifetime used",
1054 "40-50% of device lifetime used",
1055 "50-60% of device lifetime used",
1056 "60-70% of device lifetime used",
1057 "70-80% of device lifetime used",
1058 "80-90% of device lifetime used",
1059 "90-100% of device lifetime used",
1060 "Exceeded the maximum estimated device lifetime",
1061 };
1062
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001063 if (buffer.length() < (lifetime + sizeof(hex))) {
Felipe Lemed8b94e52016-12-08 10:21:44 -08001064 printf("*** %s: truncated content %zu\n", ext_csd_path, buffer.length());
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001065 break;
1066 }
1067
1068 ext_device_life_time_est = 0;
Mark Salyzyn290f4b92016-05-16 08:33:59 -07001069 sub = buffer.substr(lifetime, sizeof(hex));
1070 if (sscanf(sub.c_str(), "%2x", &ext_device_life_time_est) != 1) {
Felipe Lemed8b94e52016-12-08 10:21:44 -08001071 printf("*** %s: DEVICE_LIFE_TIME_EST_TYP_%c parse error \"%s\"\n", ext_csd_path,
1072 (unsigned)((lifetime - EXT_DEVICE_LIFE_TIME_EST_TYP_A) / sizeof(hex)) + 'A',
1073 sub.c_str());
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001074 continue;
1075 }
Felipe Lemed8b94e52016-12-08 10:21:44 -08001076 printf("DEVICE_LIFE_TIME_EST_TYP_%c %d (MMC %s)\n",
1077 (unsigned)((lifetime - EXT_DEVICE_LIFE_TIME_EST_TYP_A) / sizeof(hex)) + 'A',
1078 ext_device_life_time_est,
1079 est_str[(ext_device_life_time_est < (int)(sizeof(est_str) / sizeof(est_str[0])))
1080 ? ext_device_life_time_est
1081 : 0]);
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001082 }
1083
Felipe Lemed8b94e52016-12-08 10:21:44 -08001084 printf("\n");
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001085}