blob: cbb74b34f224c33993204452507abbfadd32c1e0 [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 */
Felipe Lemef0292972016-11-22 13:57:05 -080016
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070017#define LOG_TAG "dumpstate"
Colin Crossf45fa6b2012-03-26 12:38:26 -070018
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -070019#include <dirent.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070020#include <errno.h>
21#include <fcntl.h>
Nikita Ioffea325a572019-05-16 19:49:47 +010022#include <inttypes.h>
Felipe Lemead5f6c42015-11-30 14:26:46 -080023#include <libgen.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070024#include <limits.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010025#include <math.h>
26#include <poll.h>
Mark Salyzyn8f37aa52015-06-12 12:28:24 -070027#include <stdbool.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070028#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080031#include <sys/poll.h>
Christopher Ferris7dc7f322014-07-22 16:08:19 -070032#include <sys/prctl.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070033#include <sys/resource.h>
34#include <sys/stat.h>
35#include <sys/time.h>
36#include <sys/wait.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010037#include <signal.h>
38#include <stdarg.h>
39#include <string.h>
40#include <sys/capability.h>
41#include <sys/inotify.h>
42#include <sys/klog.h>
43#include <time.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070044#include <unistd.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070045
46#include <chrono>
Hridya Valsarajuac582cd2019-08-05 15:39:54 -070047#include <cmath>
Abhijeet Kaurd3cca0d2019-03-25 12:04:16 +000048#include <fstream>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070049#include <functional>
50#include <future>
Narayan Kamath8f788292017-05-25 13:20:39 +010051#include <memory>
Hridya Valsarajuac582cd2019-08-05 15:39:54 -070052#include <numeric>
Narayan Kamath8f788292017-05-25 13:20:39 +010053#include <regex>
54#include <set>
55#include <string>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070056#include <utility>
Narayan Kamath8f788292017-05-25 13:20:39 +010057#include <vector>
Colin Crossf45fa6b2012-03-26 12:38:26 -070058
Felipe Leme96c2bbb2016-09-26 09:21:21 -070059#include <android-base/file.h>
60#include <android-base/properties.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070061#include <android-base/scopeguard.h>
Elliott Hughes9dc117c2015-12-07 14:21:50 -080062#include <android-base/stringprintf.h>
Naveen Kalla058e1e82016-10-19 21:38:44 -070063#include <android-base/strings.h>
Andreas Gampeaff68432016-07-18 18:01:27 -070064#include <android-base/unique_fd.h>
Nikita Ioffea325a572019-05-16 19:49:47 +010065#include <android/content/pm/IPackageManagerNative.h>
Felipe Leme6f674ae2016-11-18 17:10:33 -080066#include <android/hardware/dumpstate/1.0/IDumpstateDevice.h>
Hunter Knepshield8540faf2020-02-04 19:47:20 -080067#include <android/hardware/dumpstate/1.1/IDumpstateDevice.h>
68#include <android/hardware/dumpstate/1.1/types.h>
Steven Moreland44cd9482018-01-04 16:24:13 -080069#include <android/hidl/manager/1.0/IServiceManager.h>
Nandana Duttd2f5f082019-01-18 17:13:52 +000070#include <android/os/IIncidentCompanion.h>
Nikita Ioffea325a572019-05-16 19:49:47 +010071#include <binder/IServiceManager.h>
Felipe Leme6f674ae2016-11-18 17:10:33 -080072#include <cutils/native_handle.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070073#include <cutils/properties.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010074#include <cutils/sockets.h>
Nandana Duttfaafd522019-03-11 09:23:09 +000075#include <debuggerd/client.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080076#include <dumpsys.h>
Nandana Duttfaafd522019-03-11 09:23:09 +000077#include <dumputils/dump_utils.h>
Sahana Raof35ed432019-07-12 10:47:52 +010078#include <hardware_legacy/power.h>
Steven Moreland44cd9482018-01-04 16:24:13 -080079#include <hidl/ServiceManagement.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010080#include <log/log.h>
Tom Cherryf4472f32020-08-05 09:31:17 -070081#include <log/log_read.h>
Felipe Leme75876a22016-10-27 16:31:27 -070082#include <openssl/sha.h>
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070083#include <private/android_filesystem_config.h>
84#include <private/android_logger.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080085#include <serviceutils/PriorityDumper.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070086#include <utils/StrongPointer.h>
Felipe Lemef0292972016-11-22 13:57:05 -080087#include "DumpstateInternal.h"
Felipe Leme75876a22016-10-27 16:31:27 -070088#include "DumpstateService.h"
Colin Crossf45fa6b2012-03-26 12:38:26 -070089#include "dumpstate.h"
Felipe Leme6e01fa62015-11-11 19:35:14 -080090
Hunter Knepshield8540faf2020-02-04 19:47:20 -080091using IDumpstateDevice_1_0 = ::android::hardware::dumpstate::V1_0::IDumpstateDevice;
92using IDumpstateDevice_1_1 = ::android::hardware::dumpstate::V1_1::IDumpstateDevice;
93using ::android::hardware::dumpstate::V1_1::DumpstateMode;
94using ::android::hardware::dumpstate::V1_1::DumpstateStatus;
95using ::android::hardware::dumpstate::V1_1::toString;
Vishnu Naire97d6122018-01-18 13:58:56 -080096using ::std::literals::chrono_literals::operator""ms;
97using ::std::literals::chrono_literals::operator""s;
Rhed Jao5377d792020-07-16 17:37:39 +080098using ::std::placeholders::_1;
Steven Morelandcb7ef822016-11-29 13:20:37 -080099
Felipe Leme47e9be22016-12-21 15:37:07 -0800100// TODO: remove once moved to namespace
Vishnu Naire97d6122018-01-18 13:58:56 -0800101using android::defaultServiceManager;
102using android::Dumpsys;
103using android::INVALID_OPERATION;
104using android::IServiceManager;
105using android::OK;
106using android::sp;
107using android::status_t;
108using android::String16;
109using android::String8;
110using android::TIMED_OUT;
111using android::UNKNOWN_ERROR;
112using android::Vector;
Nandana Dutt979388e2018-11-30 16:48:55 +0000113using android::base::StringPrintf;
Nandana Duttd2f5f082019-01-18 17:13:52 +0000114using android::os::IDumpstateListener;
Felipe Leme47e9be22016-12-21 15:37:07 -0800115using android::os::dumpstate::CommandOptions;
116using android::os::dumpstate::DumpFileToFd;
Rhed Jao5377d792020-07-16 17:37:39 +0800117using android::os::dumpstate::DumpPool;
Vishnu Naire97d6122018-01-18 13:58:56 -0800118using android::os::dumpstate::PropertiesHelper;
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800119using android::os::dumpstate::TaskQueue;
Felipe Leme47e9be22016-12-21 15:37:07 -0800120
Abhijeet Kaurcf234e82019-07-01 14:53:55 +0100121// Keep in sync with
122// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
123static const int TRACE_DUMP_TIMEOUT_MS = 10000; // 10 seconds
124
125/* Most simple commands have 10 as timeout, so 5 is a good estimate */
126static const int32_t WEIGHT_FILE = 5;
127
128// TODO: temporary variables and functions used during C++ refactoring
129static Dumpstate& ds = Dumpstate::GetInstance();
130static int RunCommand(const std::string& title, const std::vector<std::string>& full_command,
Nandana Dutt8d945c02019-08-14 13:30:07 +0100131 const CommandOptions& options = CommandOptions::DEFAULT,
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800132 bool verbose_duration = false, int out_fd = STDOUT_FILENO) {
133 return ds.RunCommand(title, full_command, options, verbose_duration, out_fd);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +0100134}
135
136// Reasonable value for max stats.
137static const int STATS_MAX_N_RUNS = 1000;
138static const long STATS_MAX_AVERAGE = 100000;
139
140CommandOptions Dumpstate::DEFAULT_DUMPSYS = CommandOptions::WithTimeout(30).Build();
141
Nandana Duttd2f5f082019-01-18 17:13:52 +0000142typedef Dumpstate::ConsentCallback::ConsentResult UserConsentResult;
143
Colin Crossf45fa6b2012-03-26 12:38:26 -0700144/* read before root is shed */
145static char cmdline_buf[16384] = "(unknown)";
Yi Kong19d5c002018-07-20 13:39:55 -0700146static const char *dump_traces_path = nullptr;
Nandana Duttd2f5f082019-01-18 17:13:52 +0000147static const uint64_t USER_CONSENT_TIMEOUT_MS = 30 * 1000;
Hunter Knepshield70610fa2020-01-03 15:27:33 -0800148// Because telephony reports are significantly faster to collect (< 10 seconds vs. > 2 minutes),
149// it's often the case that they time out far too quickly for consent with such a hefty dialog for
150// the user to read. For telephony reports only, we increase the default timeout to 2 minutes to
151// roughly match full reports' durations.
152static const uint64_t TELEPHONY_REPORT_USER_CONSENT_TIMEOUT_MS = 2 * 60 * 1000;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700153
Felipe Leme1d486fe2016-10-14 18:06:47 -0700154// TODO: variables and functions below should be part of dumpstate object
155
Felipe Leme635ca312016-01-05 14:23:02 -0800156static std::set<std::string> mount_points;
157void add_mountinfo();
Felipe Leme78f2c862015-12-21 09:55:22 -0800158
Todd Poynor2a83daa2013-11-22 15:44:22 -0800159#define PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops"
Mark Salyzyn7d0a7622016-06-24 14:06:15 -0700160#define ALT_PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops-0"
Wei Wang509bb5d2017-06-09 14:42:12 -0700161#define BLK_DEV_SYS_DIR "/sys/block"
Todd Poynor2a83daa2013-11-22 15:44:22 -0800162
Felipe Lemee82a27d2016-01-05 13:35:44 -0800163#define RECOVERY_DIR "/cache/recovery"
Mark Salyzynd6ab0112016-03-25 12:56:39 -0700164#define RECOVERY_DATA_DIR "/data/misc/recovery"
Tianjie Xu75d53362018-04-11 16:42:28 -0700165#define UPDATE_ENGINE_LOG_DIR "/data/misc/update_engine_log"
Mark Salyzyn4d42dea2016-04-01 10:03:14 -0700166#define LOGPERSIST_DATA_DIR "/data/misc/logd"
Jerry Changa1df8a92020-01-02 16:03:39 +0800167#define PREREBOOT_DATA_DIR "/data/misc/prereboot"
David Brazdild2991962016-06-03 14:40:44 +0100168#define PROFILE_DATA_DIR_CUR "/data/misc/profiles/cur"
169#define PROFILE_DATA_DIR_REF "/data/misc/profiles/ref"
Benedict Wong8f9d8a42019-01-03 16:19:38 -0800170#define XFRM_STAT_PROC_FILE "/proc/net/xfrm_stat"
Erik Kline08165202016-05-30 11:55:44 +0900171#define WLUTIL "/vendor/xbin/wlutil"
Vishnu Nair36b4cdb2017-11-17 10:27:05 -0800172#define WMTRACE_DATA_DIR "/data/misc/wmtrace"
Yifan Hong3945e1b2019-10-29 12:59:23 -0700173#define OTA_METADATA_DIR "/metadata/ota"
Yifan Hong0efa7972020-02-03 16:45:02 -0800174#define SNAPSHOTCTL_LOG_DIR "/data/misc/snapshotctl_log"
Kiyoung Kimc2d22ac2020-02-04 19:43:36 +0900175#define LINKERCONFIG_DIR "/linkerconfig"
Calin Juravlef84d3692020-04-28 15:31:12 -0700176#define PACKAGE_DEX_USE_LIST "/data/system/package-dex-usage.list"
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700177
Narayan Kamath8f788292017-05-25 13:20:39 +0100178// TODO(narayan): Since this information has to be kept in sync
179// with tombstoned, we should just put it in a common header.
180//
181// File: system/core/debuggerd/tombstoned/tombstoned.cpp
Narayan Kamathbd863722017-06-01 18:50:12 +0100182static const std::string TOMBSTONE_DIR = "/data/tombstones/";
183static const std::string TOMBSTONE_FILE_PREFIX = "tombstone_";
184static const std::string ANR_DIR = "/data/anr/";
185static const std::string ANR_FILE_PREFIX = "anr_";
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700186
Felipe Lemee844a9d2016-09-21 15:01:39 -0700187// TODO: temporary variables and functions used during C++ refactoring
Nandana Dutt979388e2018-11-30 16:48:55 +0000188
Nandana Dutt5c390032019-03-12 10:52:56 +0000189#define RETURN_IF_USER_DENIED_CONSENT() \
190 if (ds.IsUserConsentDenied()) { \
191 MYLOGE("Returning early as user denied consent to share bugreport with calling app."); \
192 return Dumpstate::RunStatus::USER_CONSENT_DENIED; \
193 }
194
195// Runs func_ptr, but checks user consent before and after running it. Returns USER_CONSENT_DENIED
196// if consent is found to be denied.
197#define RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(func_ptr, ...) \
198 RETURN_IF_USER_DENIED_CONSENT(); \
199 func_ptr(__VA_ARGS__); \
200 RETURN_IF_USER_DENIED_CONSENT();
201
Rhed Jao5377d792020-07-16 17:37:39 +0800202// Runs func_ptr, and logs a duration report after it's finished.
203#define RUN_SLOW_FUNCTION_AND_LOG(log_title, func_ptr, ...) \
204 { \
205 DurationReporter duration_reporter_in_macro(log_title); \
206 func_ptr(__VA_ARGS__); \
207 }
208
209// Similar with RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK, an additional duration report
210// is output after a slow function is finished.
211#define RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(log_title, func_ptr, ...) \
212 RETURN_IF_USER_DENIED_CONSENT(); \
213 RUN_SLOW_FUNCTION_AND_LOG(log_title, func_ptr, __VA_ARGS__); \
214 RETURN_IF_USER_DENIED_CONSENT();
215
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800216#define WAIT_TASK_WITH_CONSENT_CHECK(task_name, pool_ptr) \
217 RETURN_IF_USER_DENIED_CONSENT(); \
218 pool_ptr->waitForTask(task_name); \
219 RETURN_IF_USER_DENIED_CONSENT();
220
Sahana Raof35ed432019-07-12 10:47:52 +0100221static const char* WAKE_LOCK_NAME = "dumpstate_wakelock";
222
Rhed Jao5377d792020-07-16 17:37:39 +0800223// Names of parallel tasks, they are used for the DumpPool to identify the dump
224// task and the log title of the duration report.
225static const std::string DUMP_TRACES_TASK = "DUMP TRACES";
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800226static const std::string DUMP_INCIDENT_REPORT_TASK = "INCIDENT REPORT";
227static const std::string DUMP_HALS_TASK = "DUMP HALS";
228static const std::string DUMP_BOARD_TASK = "dumpstate_board()";
Rhed Jaoe017f982020-07-21 17:58:41 +0800229static const std::string DUMP_CHECKINS_TASK = "DUMP CHECKINS";
230static const std::string DUMP_APP_INFOS_TASK = "DUMP APP INFOS";
Rhed Jao5377d792020-07-16 17:37:39 +0800231
Nandana Dutt979388e2018-11-30 16:48:55 +0000232namespace android {
233namespace os {
234namespace {
235
236static int Open(std::string path, int flags, mode_t mode = 0) {
237 int fd = TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode));
238 if (fd == -1) {
239 MYLOGE("open(%s, %s)\n", path.c_str(), strerror(errno));
240 }
241 return fd;
242}
243
mhasank2d75c442020-06-11 15:05:25 -0700244static int OpenForWrite(std::string path) {
245 return Open(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
246 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
247}
Nandana Dutt979388e2018-11-30 16:48:55 +0000248
249static int OpenForRead(std::string path) {
250 return Open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
251}
252
253bool CopyFile(int in_fd, int out_fd) {
254 char buf[4096];
255 ssize_t byte_count;
256 while ((byte_count = TEMP_FAILURE_RETRY(read(in_fd, buf, sizeof(buf)))) > 0) {
257 if (!android::base::WriteFully(out_fd, buf, byte_count)) {
258 return false;
259 }
260 }
261 return (byte_count != -1);
262}
263
264static bool CopyFileToFd(const std::string& input_file, int out_fd) {
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000265 MYLOGD("Going to copy file (%s) to %d\n", input_file.c_str(), out_fd);
Nandana Dutt979388e2018-11-30 16:48:55 +0000266
267 // Obtain a handle to the source file.
268 android::base::unique_fd in_fd(OpenForRead(input_file));
269 if (out_fd != -1 && in_fd.get() != -1) {
270 if (CopyFile(in_fd.get(), out_fd)) {
271 return true;
272 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000273 MYLOGE("Failed to copy file: %s\n", strerror(errno));
Nandana Dutt979388e2018-11-30 16:48:55 +0000274 }
275 return false;
276}
277
Nandana Duttd2f5f082019-01-18 17:13:52 +0000278static bool UnlinkAndLogOnError(const std::string& file) {
Nandana Dutt8ae16e62020-03-27 10:20:22 +0000279 if (file.empty()) {
280 return false;
281 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000282 if (unlink(file.c_str())) {
283 MYLOGE("Failed to unlink file (%s): %s\n", file.c_str(), strerror(errno));
Nandana Duttd2f5f082019-01-18 17:13:52 +0000284 return false;
285 }
286 return true;
287}
Nandana Dutt979388e2018-11-30 16:48:55 +0000288
Nikita Ioffea325a572019-05-16 19:49:47 +0100289int64_t GetModuleMetadataVersion() {
290 auto binder = defaultServiceManager()->getService(android::String16("package_native"));
291 if (binder == nullptr) {
292 MYLOGE("Failed to retrieve package_native service");
293 return 0L;
294 }
295 auto package_service = android::interface_cast<content::pm::IPackageManagerNative>(binder);
296 std::string package_name;
297 auto status = package_service->getModuleMetadataPackageName(&package_name);
298 if (!status.isOk()) {
299 MYLOGE("Failed to retrieve module metadata package name: %s", status.toString8().c_str());
300 return 0L;
301 }
Nandana Duttdb379fa2019-10-09 16:54:41 +0100302 MYLOGD("Module metadata package name: %s\n", package_name.c_str());
Nikita Ioffea325a572019-05-16 19:49:47 +0100303 int64_t version_code;
304 status = package_service->getVersionCodeForPackage(android::String16(package_name.c_str()),
305 &version_code);
306 if (!status.isOk()) {
307 MYLOGE("Failed to retrieve module metadata version: %s", status.toString8().c_str());
308 return 0L;
309 }
310 return version_code;
311}
312
mhasank2d75c442020-06-11 15:05:25 -0700313static bool PathExists(const std::string& path) {
314 struct stat sb;
315 return stat(path.c_str(), &sb) == 0;
316}
317
318static bool CopyFileToFile(const std::string& input_file, const std::string& output_file) {
319 if (input_file == output_file) {
320 MYLOGD("Skipping copying bugreport file since the destination is the same (%s)\n",
321 output_file.c_str());
322 return false;
323 }
324 else if (PathExists(output_file)) {
325 MYLOGD("Cannot overwrite an existing file (%s)\n", output_file.c_str());
326 return false;
327 }
328
329 MYLOGD("Going to copy bugreport file (%s) to %s\n", input_file.c_str(), output_file.c_str());
330 android::base::unique_fd out_fd(OpenForWrite(output_file));
331 return CopyFileToFd(input_file, out_fd.get());
332}
333
Nandana Dutt979388e2018-11-30 16:48:55 +0000334} // namespace
335} // namespace os
336} // namespace android
337
Felipe Leme678727a2016-09-21 17:22:11 -0700338static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
Felipe Lemebda15a02016-11-16 17:48:25 -0800339 const CommandOptions& options = Dumpstate::DEFAULT_DUMPSYS,
Rhed Jaoe017f982020-07-21 17:58:41 +0800340 long dumpsysTimeoutMs = 0, int out_fd = STDOUT_FILENO) {
341 return ds.RunDumpsys(title, dumpsysArgs, options, dumpsysTimeoutMs, out_fd);
342}
343static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
344 int out_fd) {
345 return ds.RunDumpsys(title, dumpsysArgs, Dumpstate::DEFAULT_DUMPSYS, 0, out_fd);
Felipe Leme678727a2016-09-21 17:22:11 -0700346}
347static int DumpFile(const std::string& title, const std::string& path) {
348 return ds.DumpFile(title, path);
349}
Felipe Lemee82a27d2016-01-05 13:35:44 -0800350
Felipe Lemee844a9d2016-09-21 15:01:39 -0700351// Relative directory (inside the zip) for all files copied as-is into the bugreport.
352static const std::string ZIP_ROOT_DIR = "FS";
353
Vishnu Naire97d6122018-01-18 13:58:56 -0800354static const std::string kProtoPath = "proto/";
355static const std::string kProtoExt = ".proto";
Jie Song9fbfad02017-06-20 16:29:42 -0700356static const std::string kDumpstateBoardFiles[] = {
357 "dumpstate_board.txt",
Felipe Leme95d6ca52017-08-01 16:35:56 -0700358 "dumpstate_board.bin"
Jie Song9fbfad02017-06-20 16:29:42 -0700359};
360static const int NUM_OF_DUMPS = arraysize(kDumpstateBoardFiles);
361
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700362static constexpr char PROPERTY_LAST_ID[] = "dumpstate.last_id";
Felipe Lemed071c682016-10-20 16:48:00 -0700363static constexpr char PROPERTY_VERSION[] = "dumpstate.version";
Felipe Leme9ce6aa42016-09-21 10:02:25 -0700364
Felipe Lemef0292972016-11-22 13:57:05 -0800365static const CommandOptions AS_ROOT_20 = CommandOptions::WithTimeout(20).AsRoot().Build();
366
Narayan Kamath8f788292017-05-25 13:20:39 +0100367/*
Narayan Kamathbd863722017-06-01 18:50:12 +0100368 * Returns a vector of dump fds under |dir_path| with a given |file_prefix|.
Rhed Jao01dc0c62020-06-03 17:13:30 +0800369 * The returned vector is sorted by the mtimes of the dumps with descending
370 * order. If |limit_by_mtime| is set, the vector only contains files that
371 * were written in the last 30 minutes.
Narayan Kamath8f788292017-05-25 13:20:39 +0100372 */
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700373static std::vector<DumpData> GetDumpFds(const std::string& dir_path,
374 const std::string& file_prefix,
Elliott Hughesdb6d2112019-09-26 15:24:51 -0700375 bool limit_by_mtime) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100376 const time_t thirty_minutes_ago = ds.now_ - 60 * 30;
377
Narayan Kamathbd863722017-06-01 18:50:12 +0100378 std::unique_ptr<DIR, decltype(&closedir)> dump_dir(opendir(dir_path.c_str()), closedir);
Narayan Kamath8f788292017-05-25 13:20:39 +0100379
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700380 if (dump_dir == nullptr) {
381 MYLOGW("Unable to open directory %s: %s\n", dir_path.c_str(), strerror(errno));
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700382 return std::vector<DumpData>();
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700383 }
384
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700385 std::vector<DumpData> dump_data;
Narayan Kamathbd863722017-06-01 18:50:12 +0100386 struct dirent* entry = nullptr;
387 while ((entry = readdir(dump_dir.get()))) {
388 if (entry->d_type != DT_REG) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100389 continue;
390 }
391
Narayan Kamathbd863722017-06-01 18:50:12 +0100392 const std::string base_name(entry->d_name);
393 if (base_name.find(file_prefix) != 0) {
394 continue;
395 }
396
397 const std::string abs_path = dir_path + base_name;
398 android::base::unique_fd fd(
399 TEMP_FAILURE_RETRY(open(abs_path.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK)));
400 if (fd == -1) {
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700401 MYLOGW("Unable to open dump file %s: %s\n", abs_path.c_str(), strerror(errno));
Narayan Kamathbd863722017-06-01 18:50:12 +0100402 break;
403 }
404
405 struct stat st = {};
406 if (fstat(fd, &st) == -1) {
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700407 MYLOGW("Unable to stat dump file %s: %s\n", abs_path.c_str(), strerror(errno));
Narayan Kamath8f788292017-05-25 13:20:39 +0100408 continue;
409 }
410
Narayan Kamath3f31b632018-02-22 19:42:36 +0000411 if (limit_by_mtime && st.st_mtime < thirty_minutes_ago) {
Narayan Kamathbd863722017-06-01 18:50:12 +0100412 MYLOGI("Excluding stale dump file: %s\n", abs_path.c_str());
Narayan Kamath8f788292017-05-25 13:20:39 +0100413 continue;
414 }
415
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700416 dump_data.emplace_back(DumpData{abs_path, std::move(fd), st.st_mtime});
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700417 }
Rhed Jao01dc0c62020-06-03 17:13:30 +0800418 if (!dump_data.empty()) {
419 std::sort(dump_data.begin(), dump_data.end(),
420 [](const auto& a, const auto& b) { return a.mtime > b.mtime; });
421 }
Narayan Kamath8f788292017-05-25 13:20:39 +0100422
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700423 return dump_data;
Narayan Kamath8f788292017-05-25 13:20:39 +0100424}
425
Narayan Kamathbd863722017-06-01 18:50:12 +0100426static bool AddDumps(const std::vector<DumpData>::const_iterator start,
427 const std::vector<DumpData>::const_iterator end,
428 const char* type_name, const bool add_to_zip) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100429 bool dumped = false;
Narayan Kamathbd863722017-06-01 18:50:12 +0100430 for (auto it = start; it != end; ++it) {
431 const std::string& name = it->name;
432 const int fd = it->fd;
Narayan Kamath8f788292017-05-25 13:20:39 +0100433 dumped = true;
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100434
435 // Seek to the beginning of the file before dumping any data. A given
436 // DumpData entry might be dumped multiple times in the report.
437 //
438 // For example, the most recent ANR entry is dumped to the body of the
439 // main entry and it also shows up as a separate entry in the bugreport
440 // ZIP file.
441 if (lseek(fd, 0, SEEK_SET) != static_cast<off_t>(0)) {
442 MYLOGE("Unable to add %s to zip file, lseek failed: %s\n", name.c_str(),
443 strerror(errno));
444 }
445
Narayan Kamath8f788292017-05-25 13:20:39 +0100446 if (ds.IsZipping() && add_to_zip) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800447 if (ds.AddZipEntryFromFd(ZIP_ROOT_DIR + name, fd, /* timeout = */ 0ms) != OK) {
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100448 MYLOGE("Unable to add %s to zip file, addZipEntryFromFd failed\n", name.c_str());
Narayan Kamath8f788292017-05-25 13:20:39 +0100449 }
450 } else {
451 dump_file_from_fd(type_name, name.c_str(), fd);
452 }
Narayan Kamath8f788292017-05-25 13:20:39 +0100453 }
454
455 return dumped;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700456}
457
Felipe Leme635ca312016-01-05 14:23:02 -0800458// for_each_pid() callback to get mount info about a process.
Felipe Leme4c2d6632016-09-28 14:32:00 -0700459void do_mountinfo(int pid, const char* name __attribute__((unused))) {
Felipe Leme635ca312016-01-05 14:23:02 -0800460 char path[PATH_MAX];
461
462 // Gets the the content of the /proc/PID/ns/mnt link, so only unique mount points
463 // are added.
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700464 snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800465 char linkname[PATH_MAX];
466 ssize_t r = readlink(path, linkname, PATH_MAX);
467 if (r == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800468 MYLOGE("Unable to read link for %s: %s\n", path, strerror(errno));
Felipe Leme635ca312016-01-05 14:23:02 -0800469 return;
470 }
471 linkname[r] = '\0';
472
473 if (mount_points.find(linkname) == mount_points.end()) {
474 // First time this mount point was found: add it
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700475 snprintf(path, sizeof(path), "/proc/%d/mountinfo", pid);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700476 if (ds.AddZipEntry(ZIP_ROOT_DIR + path, path)) {
Felipe Leme635ca312016-01-05 14:23:02 -0800477 mount_points.insert(linkname);
478 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800479 MYLOGE("Unable to add mountinfo %s to zip file\n", path);
Felipe Leme635ca312016-01-05 14:23:02 -0800480 }
481 }
482}
483
484void add_mountinfo() {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700485 if (!ds.IsZipping()) return;
Felipe Leme678727a2016-09-21 17:22:11 -0700486 std::string title = "MOUNT INFO";
Felipe Leme635ca312016-01-05 14:23:02 -0800487 mount_points.clear();
Felipe Leme46b85da2016-11-21 17:40:45 -0800488 DurationReporter duration_reporter(title, true);
Felipe Leme678727a2016-09-21 17:22:11 -0700489 for_each_pid(do_mountinfo, nullptr);
490 MYLOGD("%s: %d entries added to zip file\n", title.c_str(), (int)mount_points.size());
Felipe Leme635ca312016-01-05 14:23:02 -0800491}
492
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700493static void dump_dev_files(const char *title, const char *driverpath, const char *filename)
494{
495 DIR *d;
496 struct dirent *de;
497 char path[PATH_MAX];
498
499 d = opendir(driverpath);
Yi Kong19d5c002018-07-20 13:39:55 -0700500 if (d == nullptr) {
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700501 return;
502 }
503
504 while ((de = readdir(d))) {
505 if (de->d_type != DT_LNK) {
506 continue;
507 }
508 snprintf(path, sizeof(path), "%s/%s/%s", driverpath, de->d_name, filename);
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700509 DumpFile(title, path);
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700510 }
511
512 closedir(d);
513}
514
Mark Salyzyn326842f2015-04-30 09:49:41 -0700515static bool skip_not_stat(const char *path) {
516 static const char stat[] = "/stat";
517 size_t len = strlen(path);
518 if (path[len - 1] == '/') { /* Directory? */
519 return false;
520 }
521 return strcmp(path + len - sizeof(stat) + 1, stat); /* .../stat? */
522}
523
Felipe Leme4c2d6632016-09-28 14:32:00 -0700524static bool skip_none(const char* path __attribute__((unused))) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800525 return false;
526}
527
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700528unsigned long worst_write_perf = 20000; /* in KB/s */
Mark Salyzyn326842f2015-04-30 09:49:41 -0700529
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800530//
531// stat offsets
532// Name units description
533// ---- ----- -----------
534// read I/Os requests number of read I/Os processed
535#define __STAT_READ_IOS 0
536// read merges requests number of read I/Os merged with in-queue I/O
537#define __STAT_READ_MERGES 1
538// read sectors sectors number of sectors read
539#define __STAT_READ_SECTORS 2
540// read ticks milliseconds total wait time for read requests
541#define __STAT_READ_TICKS 3
542// write I/Os requests number of write I/Os processed
543#define __STAT_WRITE_IOS 4
544// write merges requests number of write I/Os merged with in-queue I/O
545#define __STAT_WRITE_MERGES 5
546// write sectors sectors number of sectors written
547#define __STAT_WRITE_SECTORS 6
548// write ticks milliseconds total wait time for write requests
549#define __STAT_WRITE_TICKS 7
550// in_flight requests number of I/Os currently in flight
551#define __STAT_IN_FLIGHT 8
552// io_ticks milliseconds total time this block device has been active
553#define __STAT_IO_TICKS 9
554// time_in_queue milliseconds total wait time for all requests
555#define __STAT_IN_QUEUE 10
556#define __STAT_NUMBER_FIELD 11
557//
558// read I/Os, write I/Os
559// =====================
560//
561// These values increment when an I/O request completes.
562//
563// read merges, write merges
564// =========================
565//
566// These values increment when an I/O request is merged with an
567// already-queued I/O request.
568//
569// read sectors, write sectors
570// ===========================
571//
572// These values count the number of sectors read from or written to this
573// block device. The "sectors" in question are the standard UNIX 512-byte
574// sectors, not any device- or filesystem-specific block size. The
575// counters are incremented when the I/O completes.
576#define SECTOR_SIZE 512
577//
578// read ticks, write ticks
579// =======================
580//
581// These values count the number of milliseconds that I/O requests have
582// waited on this block device. If there are multiple I/O requests waiting,
583// these values will increase at a rate greater than 1000/second; for
584// example, if 60 read requests wait for an average of 30 ms, the read_ticks
585// field will increase by 60*30 = 1800.
586//
587// in_flight
588// =========
589//
590// This value counts the number of I/O requests that have been issued to
591// the device driver but have not yet completed. It does not include I/O
592// requests that are in the queue but not yet issued to the device driver.
593//
594// io_ticks
595// ========
596//
597// This value counts the number of milliseconds during which the device has
598// had I/O requests queued.
599//
600// time_in_queue
601// =============
602//
603// This value counts the number of milliseconds that I/O requests have waited
604// on this block device. If there are multiple I/O requests waiting, this
605// value will increase as the product of the number of milliseconds times the
606// number of requests waiting (see "read ticks" above for an example).
607#define S_TO_MS 1000
608//
609
Mark Salyzyn326842f2015-04-30 09:49:41 -0700610static int dump_stat_from_fd(const char *title __unused, const char *path, int fd) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800611 unsigned long long fields[__STAT_NUMBER_FIELD];
Mark Salyzyn326842f2015-04-30 09:49:41 -0700612 bool z;
Yi Kong19d5c002018-07-20 13:39:55 -0700613 char *cp, *buffer = nullptr;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700614 size_t i = 0;
Josh Gao7c4258c2018-06-25 13:40:08 -0700615 FILE *fp = fdopen(dup(fd), "rb");
Mark Salyzyn326842f2015-04-30 09:49:41 -0700616 getline(&buffer, &i, fp);
617 fclose(fp);
618 if (!buffer) {
619 return -errno;
620 }
621 i = strlen(buffer);
622 while ((i > 0) && (buffer[i - 1] == '\n')) {
623 buffer[--i] = '\0';
624 }
625 if (!*buffer) {
626 free(buffer);
627 return 0;
628 }
629 z = true;
630 for (cp = buffer, i = 0; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800631 fields[i] = strtoull(cp, &cp, 10);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700632 if (fields[i] != 0) {
633 z = false;
634 }
635 }
636 if (z) { /* never accessed */
637 free(buffer);
638 return 0;
639 }
640
Wei Wang509bb5d2017-06-09 14:42:12 -0700641 if (!strncmp(path, BLK_DEV_SYS_DIR, sizeof(BLK_DEV_SYS_DIR) - 1)) {
642 path += sizeof(BLK_DEV_SYS_DIR) - 1;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700643 }
Wei Wang1dc1ef52017-06-12 11:28:37 -0700644
645 printf("%-30s:%9s%9s%9s%9s%9s%9s%9s%9s%9s%9s%9s\n%-30s:\t%s\n", "Block-Dev",
646 "R-IOs", "R-merg", "R-sect", "R-wait", "W-IOs", "W-merg", "W-sect",
647 "W-wait", "in-fli", "activ", "T-wait", path, buffer);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700648 free(buffer);
649
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800650 if (fields[__STAT_IO_TICKS]) {
651 unsigned long read_perf = 0;
652 unsigned long read_ios = 0;
653 if (fields[__STAT_READ_TICKS]) {
654 unsigned long long divisor = fields[__STAT_READ_TICKS]
655 * fields[__STAT_IO_TICKS];
656 read_perf = ((unsigned long long)SECTOR_SIZE
657 * fields[__STAT_READ_SECTORS]
658 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
659 / divisor;
660 read_ios = ((unsigned long long)S_TO_MS * fields[__STAT_READ_IOS]
661 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
662 / divisor;
663 }
664
665 unsigned long write_perf = 0;
666 unsigned long write_ios = 0;
667 if (fields[__STAT_WRITE_TICKS]) {
668 unsigned long long divisor = fields[__STAT_WRITE_TICKS]
669 * fields[__STAT_IO_TICKS];
670 write_perf = ((unsigned long long)SECTOR_SIZE
671 * fields[__STAT_WRITE_SECTORS]
672 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
673 / divisor;
674 write_ios = ((unsigned long long)S_TO_MS * fields[__STAT_WRITE_IOS]
675 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
676 / divisor;
677 }
678
679 unsigned queue = (fields[__STAT_IN_QUEUE]
680 + (fields[__STAT_IO_TICKS] >> 1))
681 / fields[__STAT_IO_TICKS];
682
683 if (!write_perf && !write_ios) {
Wei Wang1dc1ef52017-06-12 11:28:37 -0700684 printf("%-30s: perf(ios) rd: %luKB/s(%lu/s) q: %u\n", path, read_perf, read_ios, queue);
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800685 } else {
Wei Wang1dc1ef52017-06-12 11:28:37 -0700686 printf("%-30s: perf(ios) rd: %luKB/s(%lu/s) wr: %luKB/s(%lu/s) q: %u\n", path, read_perf,
Felipe Lemed8b94e52016-12-08 10:21:44 -0800687 read_ios, write_perf, write_ios, queue);
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800688 }
689
690 /* bugreport timeout factor adjustment */
691 if ((write_perf > 1) && (write_perf < worst_write_perf)) {
692 worst_write_perf = write_perf;
693 }
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700694 }
Mark Salyzyn326842f2015-04-30 09:49:41 -0700695 return 0;
696}
697
Yao Chenbe3bbc12018-01-17 16:31:10 -0800698static const long MINIMUM_LOGCAT_TIMEOUT_MS = 50000;
699
Tom Cherryf4472f32020-08-05 09:31:17 -0700700// Returns the actual readable size of the given buffer or -1 on error.
701static long logcat_buffer_readable_size(const std::string& buffer) {
702 std::unique_ptr<logger_list, decltype(&android_logger_list_free)> logger_list{
703 android_logger_list_alloc(0, 0, 0), &android_logger_list_free};
704 auto logger = android_logger_open(logger_list.get(), android_name_to_log_id(buffer.c_str()));
705
706 return android_logger_get_log_readable_size(logger);
707}
708
709// Returns timeout in ms to read a list of buffers.
Yao Chenbe3bbc12018-01-17 16:31:10 -0800710static unsigned long logcat_timeout(const std::vector<std::string>& buffers) {
711 unsigned long timeout_ms = 0;
712 for (const auto& buffer : buffers) {
Tom Cherryf4472f32020-08-05 09:31:17 -0700713 long readable_size = logcat_buffer_readable_size(buffer);
714 if (readable_size > 0) {
715 // Engineering margin is ten-fold our guess.
716 timeout_ms += 10 * (readable_size + worst_write_perf) / worst_write_perf;
717 }
Yao Chenbe3bbc12018-01-17 16:31:10 -0800718 }
719 return timeout_ms > MINIMUM_LOGCAT_TIMEOUT_MS ? timeout_ms : MINIMUM_LOGCAT_TIMEOUT_MS;
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700720}
721
Dieter Hsu105ad0c2020-09-29 15:23:33 +0800722// Opens a socket and returns its file descriptor.
723static int open_socket(const char* service);
724
Nandana Duttd2f5f082019-01-18 17:13:52 +0000725Dumpstate::ConsentCallback::ConsentCallback() : result_(UNAVAILABLE), start_time_(Nanotime()) {
726}
727
728android::binder::Status Dumpstate::ConsentCallback::onReportApproved() {
729 std::lock_guard<std::mutex> lock(lock_);
730 result_ = APPROVED;
731 MYLOGD("User approved consent to share bugreport\n");
Paul Chang0d2aad72020-02-13 20:04:03 +0800732
733 // Maybe copy screenshot so calling app can display the screenshot to the user as soon as
734 // consent is granted.
735 if (ds.options_->is_screenshot_copied) {
736 return android::binder::Status::ok();
737 }
738
739 if (!ds.options_->do_screenshot || ds.options_->screenshot_fd.get() == -1 ||
740 !ds.do_early_screenshot_) {
741 return android::binder::Status::ok();
742 }
743
744 bool copy_succeeded = android::os::CopyFileToFd(ds.screenshot_path_,
745 ds.options_->screenshot_fd.get());
746 ds.options_->is_screenshot_copied = copy_succeeded;
747 if (copy_succeeded) {
748 android::os::UnlinkAndLogOnError(ds.screenshot_path_);
749 }
Nandana Duttd2f5f082019-01-18 17:13:52 +0000750 return android::binder::Status::ok();
751}
752
753android::binder::Status Dumpstate::ConsentCallback::onReportDenied() {
754 std::lock_guard<std::mutex> lock(lock_);
755 result_ = DENIED;
756 MYLOGW("User denied consent to share bugreport\n");
757 return android::binder::Status::ok();
758}
759
760UserConsentResult Dumpstate::ConsentCallback::getResult() {
761 std::lock_guard<std::mutex> lock(lock_);
762 return result_;
763}
764
765uint64_t Dumpstate::ConsentCallback::getElapsedTimeMs() const {
Hunter Knepshieldf0a39052020-01-03 14:53:04 -0800766 return (Nanotime() - start_time_) / NANOS_PER_MILLI;
Nandana Duttd2f5f082019-01-18 17:13:52 +0000767}
768
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700769void Dumpstate::PrintHeader() const {
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700770 std::string build, fingerprint, radio, bootloader, network;
771 char date[80];
Colin Crossf45fa6b2012-03-26 12:38:26 -0700772
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700773 build = android::base::GetProperty("ro.build.display.id", "(unknown)");
774 fingerprint = android::base::GetProperty("ro.build.fingerprint", "(unknown)");
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700775 radio = android::base::GetProperty("gsm.version.baseband", "(unknown)");
776 bootloader = android::base::GetProperty("ro.bootloader", "(unknown)");
777 network = android::base::GetProperty("gsm.operator.alpha", "(unknown)");
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700778 strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now_));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700779
Felipe Lemed8b94e52016-12-08 10:21:44 -0800780 printf("========================================================\n");
781 printf("== dumpstate: %s\n", date);
782 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700783
Felipe Lemed8b94e52016-12-08 10:21:44 -0800784 printf("\n");
785 printf("Build: %s\n", build.c_str());
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700786 // NOTE: fingerprint entry format is important for other tools.
Felipe Lemed8b94e52016-12-08 10:21:44 -0800787 printf("Build fingerprint: '%s'\n", fingerprint.c_str());
788 printf("Bootloader: %s\n", bootloader.c_str());
789 printf("Radio: %s\n", radio.c_str());
790 printf("Network: %s\n", network.c_str());
Nikita Ioffea325a572019-05-16 19:49:47 +0100791 int64_t module_metadata_version = android::os::GetModuleMetadataVersion();
792 if (module_metadata_version != 0) {
793 printf("Module Metadata version: %" PRId64 "\n", module_metadata_version);
794 }
Colin Crossf45fa6b2012-03-26 12:38:26 -0700795
Felipe Lemed8b94e52016-12-08 10:21:44 -0800796 printf("Kernel: ");
Felipe Lemef0292972016-11-22 13:57:05 -0800797 DumpFileToFd(STDOUT_FILENO, "", "/proc/version");
Felipe Lemed8b94e52016-12-08 10:21:44 -0800798 printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
Felipe Leme7709f8a2017-12-05 09:30:09 -0800799 printf("Uptime: ");
800 RunCommandToFd(STDOUT_FILENO, "", {"uptime", "-p"},
801 CommandOptions::WithTimeout(1).Always().Build());
Felipe Lemed8b94e52016-12-08 10:21:44 -0800802 printf("Bugreport format version: %s\n", version_.c_str());
Rhed Jao5377d792020-07-16 17:37:39 +0800803 printf("Dumpstate info: id=%d pid=%d dry_run=%d parallel_run=%d args=%s bugreport_mode=%s\n",
804 id_, pid_, PropertiesHelper::IsDryRun(), PropertiesHelper::IsParallelRun(),
805 options_->args.c_str(), options_->bugreport_mode.c_str());
Felipe Lemed8b94e52016-12-08 10:21:44 -0800806 printf("\n");
Felipe Leme78f2c862015-12-21 09:55:22 -0800807}
808
Felipe Leme24b66ee2016-06-16 10:55:26 -0700809// List of file extensions that can cause a zip file attachment to be rejected by some email
810// service providers.
811static const std::set<std::string> PROBLEMATIC_FILE_EXTENSIONS = {
812 ".ade", ".adp", ".bat", ".chm", ".cmd", ".com", ".cpl", ".exe", ".hta", ".ins", ".isp",
813 ".jar", ".jse", ".lib", ".lnk", ".mde", ".msc", ".msp", ".mst", ".pif", ".scr", ".sct",
814 ".shb", ".sys", ".vb", ".vbe", ".vbs", ".vxd", ".wsc", ".wsf", ".wsh"
815};
816
Vishnu Naire97d6122018-01-18 13:58:56 -0800817status_t Dumpstate::AddZipEntryFromFd(const std::string& entry_name, int fd,
818 std::chrono::milliseconds timeout = 0ms) {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700819 if (!IsZipping()) {
820 MYLOGD("Not adding zip entry %s from fd because it's not a zipped bugreport\n",
821 entry_name.c_str());
Vishnu Naire97d6122018-01-18 13:58:56 -0800822 return INVALID_OPERATION;
Felipe Leme111b9d02016-02-03 09:28:24 -0800823 }
Felipe Leme24b66ee2016-06-16 10:55:26 -0700824 std::string valid_name = entry_name;
825
826 // Rename extension if necessary.
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -0700827 size_t idx = entry_name.rfind('.');
Felipe Leme24b66ee2016-06-16 10:55:26 -0700828 if (idx != std::string::npos) {
829 std::string extension = entry_name.substr(idx);
830 std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
831 if (PROBLEMATIC_FILE_EXTENSIONS.count(extension) != 0) {
832 valid_name = entry_name + ".renamed";
833 MYLOGI("Renaming entry %s to %s\n", entry_name.c_str(), valid_name.c_str());
834 }
835 }
836
Felipe Leme6fe9db62016-02-12 09:04:16 -0800837 // Logging statement below is useful to time how long each entry takes, but it's too verbose.
838 // MYLOGD("Adding zip entry %s\n", entry_name.c_str());
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700839 int32_t err = zip_writer_->StartEntryWithTime(valid_name.c_str(), ZipWriter::kCompress,
840 get_mtime(fd, ds.now_));
Felipe Leme1d486fe2016-10-14 18:06:47 -0700841 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700842 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", valid_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700843 ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800844 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800845 }
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000846 bool finished_entry = false;
847 auto finish_entry = [this, &finished_entry] {
848 if (!finished_entry) {
849 // This should only be called when we're going to return an earlier error,
850 // which would've been logged. This may imply the file is already corrupt
851 // and any further logging from FinishEntry is more likely to mislead than
852 // not.
853 this->zip_writer_->FinishEntry();
854 }
855 };
856 auto scope_guard = android::base::make_scope_guard(finish_entry);
Vishnu Naire97d6122018-01-18 13:58:56 -0800857 auto start = std::chrono::steady_clock::now();
858 auto end = start + timeout;
859 struct pollfd pfd = {fd, POLLIN};
Felipe Lemee82a27d2016-01-05 13:35:44 -0800860
Felipe Leme770410d2016-01-26 17:07:14 -0800861 std::vector<uint8_t> buffer(65536);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800862 while (1) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800863 if (timeout.count() > 0) {
864 // lambda to recalculate the timeout.
865 auto time_left_ms = [end]() {
866 auto now = std::chrono::steady_clock::now();
867 auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - now);
868 return std::max(diff.count(), 0LL);
869 };
870
871 int rc = TEMP_FAILURE_RETRY(poll(&pfd, 1, time_left_ms()));
872 if (rc < 0) {
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000873 MYLOGE("Error in poll while adding from fd to zip entry %s:%s\n",
874 entry_name.c_str(), strerror(errno));
Vishnu Naire97d6122018-01-18 13:58:56 -0800875 return -errno;
876 } else if (rc == 0) {
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000877 MYLOGE("Timed out adding from fd to zip entry %s:%s Timeout:%lldms\n",
Vishnu Naire97d6122018-01-18 13:58:56 -0800878 entry_name.c_str(), strerror(errno), timeout.count());
879 return TIMED_OUT;
880 }
881 }
882
Zach Riggle22200402016-08-18 01:01:24 -0400883 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), buffer.size()));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800884 if (bytes_read == 0) {
885 break;
886 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800887 MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
Vishnu Naire97d6122018-01-18 13:58:56 -0800888 return -errno;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800889 }
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700890 err = zip_writer_->WriteBytes(buffer.data(), bytes_read);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800891 if (err) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700892 MYLOGE("zip_writer_->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800893 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800894 }
895 }
896
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700897 err = zip_writer_->FinishEntry();
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000898 finished_entry = true;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700899 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700900 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800901 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800902 }
903
Vishnu Naire97d6122018-01-18 13:58:56 -0800904 return OK;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800905}
906
Felipe Leme1d486fe2016-10-14 18:06:47 -0700907bool Dumpstate::AddZipEntry(const std::string& entry_name, const std::string& entry_path) {
908 android::base::unique_fd fd(
909 TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
Andreas Gampeaff68432016-07-18 18:01:27 -0700910 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800911 MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800912 return false;
913 }
914
Vishnu Naire97d6122018-01-18 13:58:56 -0800915 return (AddZipEntryFromFd(entry_name, fd.get()) == OK);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800916}
917
918/* adds a file to the existing zipped bugreport */
Felipe Leme4c2d6632016-09-28 14:32:00 -0700919static int _add_file_from_fd(const char* title __attribute__((unused)), const char* path, int fd) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800920 return (ds.AddZipEntryFromFd(ZIP_ROOT_DIR + path, fd) == OK) ? 0 : 1;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800921}
922
Felipe Leme1d486fe2016-10-14 18:06:47 -0700923void Dumpstate::AddDir(const std::string& dir, bool recursive) {
924 if (!IsZipping()) {
925 MYLOGD("Not adding dir %s because it's not a zipped bugreport\n", dir.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800926 return;
927 }
Felipe Leme678727a2016-09-21 17:22:11 -0700928 MYLOGD("Adding dir %s (recursive: %d)\n", dir.c_str(), recursive);
Felipe Leme46b85da2016-11-21 17:40:45 -0800929 DurationReporter duration_reporter(dir, true);
Felipe Leme678727a2016-09-21 17:22:11 -0700930 dump_files("", dir.c_str(), recursive ? skip_none : is_dir, _add_file_from_fd);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800931}
932
Felipe Leme1d486fe2016-10-14 18:06:47 -0700933bool Dumpstate::AddTextZipEntry(const std::string& entry_name, const std::string& content) {
934 if (!IsZipping()) {
935 MYLOGD("Not adding text zip entry %s because it's not a zipped bugreport\n",
936 entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800937 return false;
938 }
Felipe Lemecbce55d2016-02-08 09:53:18 -0800939 MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700940 int32_t err = zip_writer_->StartEntryWithTime(entry_name.c_str(), ZipWriter::kCompress, ds.now_);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700941 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700942 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700943 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800944 return false;
945 }
946
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700947 err = zip_writer_->WriteBytes(content.c_str(), content.length());
Felipe Leme1d486fe2016-10-14 18:06:47 -0700948 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700949 MYLOGE("zip_writer_->WriteBytes(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700950 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800951 return false;
952 }
953
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700954 err = zip_writer_->FinishEntry();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700955 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700956 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800957 return false;
958 }
959
960 return true;
961}
962
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800963static void DoKmsg() {
964 struct stat st;
965 if (!stat(PSTORE_LAST_KMSG, &st)) {
966 /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
967 DumpFile("LAST KMSG", PSTORE_LAST_KMSG);
968 } else if (!stat(ALT_PSTORE_LAST_KMSG, &st)) {
969 DumpFile("LAST KMSG", ALT_PSTORE_LAST_KMSG);
970 } else {
971 /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
972 DumpFile("LAST KMSG", "/proc/last_kmsg");
973 }
974}
975
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800976static void DoKernelLogcat() {
Yao Chenbe3bbc12018-01-17 16:31:10 -0800977 unsigned long timeout_ms = logcat_timeout({"kernel"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800978 RunCommand(
979 "KERNEL LOG",
980 {"logcat", "-b", "kernel", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
981 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
982}
983
Nandana Duttdb379fa2019-10-09 16:54:41 +0100984static void DoSystemLogcat(time_t since) {
985 char since_str[80];
986 strftime(since_str, sizeof(since_str), "%Y-%m-%d %H:%M:%S.000", localtime(&since));
987
988 unsigned long timeout_ms = logcat_timeout({"main", "system", "crash"});
989 RunCommand("SYSTEM LOG",
990 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v", "-T",
991 since_str},
992 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
993}
994
Hunter Knepshield820f9bc2020-02-05 20:10:53 -0800995static void DoRadioLogcat() {
996 unsigned long timeout_ms = logcat_timeout({"radio"});
997 RunCommand(
998 "RADIO LOG",
999 {"logcat", "-b", "radio", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1000 CommandOptions::WithTimeoutInMs(timeout_ms).Build(), true /* verbose_duration */);
1001}
1002
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001003static void DoLogcat() {
Vishnu Nair6921f802017-11-22 09:17:23 -08001004 unsigned long timeout_ms;
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001005 // DumpFile("EVENT LOG TAGS", "/etc/event-log-tags");
1006 // calculate timeout
Yao Chenbe3bbc12018-01-17 16:31:10 -08001007 timeout_ms = logcat_timeout({"main", "system", "crash"});
Tony Makae737652017-03-30 17:47:09 +01001008 RunCommand("SYSTEM LOG",
Vishnu Nair6921f802017-11-22 09:17:23 -08001009 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1010 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Yao Chenbe3bbc12018-01-17 16:31:10 -08001011 timeout_ms = logcat_timeout({"events"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001012 RunCommand(
1013 "EVENT LOG",
1014 {"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
Nandana Dutt8d945c02019-08-14 13:30:07 +01001015 CommandOptions::WithTimeoutInMs(timeout_ms).Build(), true /* verbose_duration */);
Yao Chenbe3bbc12018-01-17 16:31:10 -08001016 timeout_ms = logcat_timeout({"stats"});
1017 RunCommand(
1018 "STATS LOG",
1019 {"logcat", "-b", "stats", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
Nandana Dutt8d945c02019-08-14 13:30:07 +01001020 CommandOptions::WithTimeoutInMs(timeout_ms).Build(), true /* verbose_duration */);
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001021 DoRadioLogcat();
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001022
1023 RunCommand("LOG STATISTICS", {"logcat", "-b", "all", "-S"});
1024
1025 /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001026 RunCommand("LAST LOGCAT", {"logcat", "-L", "-b", "all", "-v", "threadtime", "-v", "printable",
1027 "-v", "uid", "-d", "*:v"});
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001028}
1029
Mike Ma5c267872019-08-21 11:31:34 -07001030static void DumpIncidentReport() {
1031 if (!ds.IsZipping()) {
1032 MYLOGD("Not dumping incident report because it's not a zipped bugreport\n");
1033 return;
1034 }
Mike Ma5c267872019-08-21 11:31:34 -07001035 const std::string path = ds.bugreport_internal_dir_ + "/tmp_incident_report";
1036 auto fd = android::base::unique_fd(TEMP_FAILURE_RETRY(open(path.c_str(),
1037 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1038 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1039 if (fd < 0) {
1040 MYLOGE("Could not open %s to dump incident report.\n", path.c_str());
1041 return;
1042 }
1043 RunCommandToFd(fd, "", {"incident", "-u"}, CommandOptions::WithTimeout(120).Build());
1044 bool empty = 0 == lseek(fd, 0, SEEK_END);
1045 if (!empty) {
1046 // Use a different name from "incident.proto"
1047 // /proto/incident.proto is reserved for incident service dump
1048 // i.e. metadata for debugging.
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001049 ds.EnqueueAddZipEntryAndCleanupIfNeeded(kProtoPath + "incident_report" + kProtoExt,
1050 path);
1051 } else {
1052 unlink(path.c_str());
Mike Ma5c267872019-08-21 11:31:34 -07001053 }
Mike Ma5c267872019-08-21 11:31:34 -07001054}
1055
Sunny Goyal35949782019-11-19 15:54:36 -08001056static void DumpVisibleWindowViews() {
1057 if (!ds.IsZipping()) {
1058 MYLOGD("Not dumping visible views because it's not a zipped bugreport\n");
1059 return;
1060 }
1061 DurationReporter duration_reporter("VISIBLE WINDOW VIEWS");
1062 const std::string path = ds.bugreport_internal_dir_ + "/tmp_visible_window_views";
1063 auto fd = android::base::unique_fd(TEMP_FAILURE_RETRY(open(path.c_str(),
1064 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1065 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1066 if (fd < 0) {
1067 MYLOGE("Could not open %s to dump visible views.\n", path.c_str());
1068 return;
1069 }
1070 RunCommandToFd(fd, "", {"cmd", "window", "dump-visible-window-views"},
1071 CommandOptions::WithTimeout(120).Build());
1072 bool empty = 0 == lseek(fd, 0, SEEK_END);
1073 if (!empty) {
1074 ds.AddZipEntry("visible_windows.zip", path);
1075 } else {
1076 MYLOGW("Failed to dump visible windows\n");
1077 }
1078 unlink(path.c_str());
1079}
1080
Jayachandran Ca94c7172017-06-10 15:08:12 -07001081static void DumpIpTablesAsRoot() {
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001082 RunCommand("IPTABLES", {"iptables", "-L", "-nvx"});
1083 RunCommand("IP6TABLES", {"ip6tables", "-L", "-nvx"});
Erik Kline32af8c22016-09-28 17:26:26 +09001084 RunCommand("IPTABLES NAT", {"iptables", "-t", "nat", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -07001085 /* no ip6 nat */
Erik Kline32af8c22016-09-28 17:26:26 +09001086 RunCommand("IPTABLES MANGLE", {"iptables", "-t", "mangle", "-L", "-nvx"});
1087 RunCommand("IP6TABLES MANGLE", {"ip6tables", "-t", "mangle", "-L", "-nvx"});
1088 RunCommand("IPTABLES RAW", {"iptables", "-t", "raw", "-L", "-nvx"});
1089 RunCommand("IP6TABLES RAW", {"ip6tables", "-t", "raw", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -07001090}
1091
David Andersond9ba4752018-12-11 18:26:59 -08001092static void DumpDynamicPartitionInfo() {
1093 if (!::android::base::GetBoolProperty("ro.boot.dynamic_partitions", false)) {
1094 return;
1095 }
1096
1097 RunCommand("LPDUMP", {"lpdump", "--all"});
David Anderson6650ade2019-10-02 15:18:59 -07001098 RunCommand("DEVICE-MAPPER", {"gsid", "dump-device-mapper"});
David Andersond9ba4752018-12-11 18:26:59 -08001099}
1100
Narayan Kamath8f788292017-05-25 13:20:39 +01001101static void AddAnrTraceDir(const bool add_to_zip, const std::string& anr_traces_dir) {
1102 MYLOGD("AddAnrTraceDir(): dump_traces_file=%s, anr_traces_dir=%s\n", dump_traces_path,
1103 anr_traces_dir.c_str());
1104
1105 // If we're here, dump_traces_path will always be a temporary file
1106 // (created with mkostemp or similar) that contains dumps taken earlier
1107 // on in the process.
1108 if (dump_traces_path != nullptr) {
1109 if (add_to_zip) {
1110 ds.AddZipEntry(ZIP_ROOT_DIR + anr_traces_dir + "/traces-just-now.txt", dump_traces_path);
1111 } else {
1112 MYLOGD("Dumping current ANR traces (%s) to the main bugreport entry\n",
1113 dump_traces_path);
1114 ds.DumpFile("VM TRACES JUST NOW", dump_traces_path);
1115 }
1116
1117 const int ret = unlink(dump_traces_path);
1118 if (ret == -1) {
1119 MYLOGW("Error unlinking temporary trace path %s: %s\n", dump_traces_path,
1120 strerror(errno));
Felipe Lemee184f662016-10-27 10:04:47 -07001121 }
1122 }
1123
Narayan Kamathbd863722017-06-01 18:50:12 +01001124 // Add a specific message for the first ANR Dump.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001125 if (ds.anr_data_.size() > 0) {
1126 AddDumps(ds.anr_data_.begin(), ds.anr_data_.begin() + 1,
Narayan Kamathbd863722017-06-01 18:50:12 +01001127 "VM TRACES AT LAST ANR", add_to_zip);
1128
Narayan Kamath6b9516c2017-10-27 11:15:51 +01001129 // The "last" ANR will always be included as separate entry in the zip file. In addition,
1130 // it will be present in the body of the main entry if |add_to_zip| == false.
1131 //
1132 // Historical ANRs are always included as separate entries in the bugreport zip file.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001133 AddDumps(ds.anr_data_.begin() + ((add_to_zip) ? 1 : 0), ds.anr_data_.end(),
Narayan Kamath6b9516c2017-10-27 11:15:51 +01001134 "HISTORICAL ANR", true /* add_to_zip */);
Narayan Kamathbd863722017-06-01 18:50:12 +01001135 } else {
Narayan Kamath8f788292017-05-25 13:20:39 +01001136 printf("*** NO ANRs to dump in %s\n\n", ANR_DIR.c_str());
1137 }
1138}
1139
1140static void AddAnrTraceFiles() {
1141 const bool add_to_zip = ds.IsZipping() && ds.version_ == VERSION_SPLIT_ANR;
1142
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001143 std::string anr_traces_dir = "/data/anr";
Narayan Kamath8f788292017-05-25 13:20:39 +01001144
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001145 AddAnrTraceDir(add_to_zip, anr_traces_dir);
Narayan Kamath8f788292017-05-25 13:20:39 +01001146
Makoto Onuki83ec63f2019-01-31 17:08:59 -08001147 RunCommand("ANR FILES", {"ls", "-lt", ANR_DIR});
1148
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001149 // Slow traces for slow operations.
Felipe Lemee184f662016-10-27 10:04:47 -07001150 struct stat st;
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001151 int i = 0;
1152 while (true) {
1153 const std::string slow_trace_path =
1154 anr_traces_dir + android::base::StringPrintf("slow%02d.txt", i);
1155 if (stat(slow_trace_path.c_str(), &st)) {
1156 // No traces file at this index, done with the files.
1157 break;
Felipe Lemee184f662016-10-27 10:04:47 -07001158 }
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001159 ds.DumpFile("VM TRACES WHEN SLOW", slow_trace_path.c_str());
1160 i++;
Felipe Lemee184f662016-10-27 10:04:47 -07001161 }
1162}
1163
Wei Wang509bb5d2017-06-09 14:42:12 -07001164static void DumpBlockStatFiles() {
1165 DurationReporter duration_reporter("DUMP BLOCK STAT");
Wei Wang509bb5d2017-06-09 14:42:12 -07001166
Wei Wang1dc1ef52017-06-12 11:28:37 -07001167 std::unique_ptr<DIR, std::function<int(DIR*)>> dirptr(opendir(BLK_DEV_SYS_DIR), closedir);
1168
1169 if (dirptr == nullptr) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001170 MYLOGE("Failed to open %s: %s\n", BLK_DEV_SYS_DIR, strerror(errno));
1171 return;
1172 }
1173
1174 printf("------ DUMP BLOCK STAT ------\n\n");
Wei Wang1dc1ef52017-06-12 11:28:37 -07001175 while (struct dirent *d = readdir(dirptr.get())) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001176 if ((d->d_name[0] == '.')
1177 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
1178 || (d->d_name[1] == '\0'))) {
1179 continue;
1180 }
1181 const std::string new_path =
1182 android::base::StringPrintf("%s/%s", BLK_DEV_SYS_DIR, d->d_name);
1183 printf("------ BLOCK STAT (%s) ------\n", new_path.c_str());
1184 dump_files("", new_path.c_str(), skip_not_stat, dump_stat_from_fd);
1185 printf("\n");
1186 }
Wei Wang1dc1ef52017-06-12 11:28:37 -07001187 return;
Wei Wang509bb5d2017-06-09 14:42:12 -07001188}
Jayachandran Ca94c7172017-06-10 15:08:12 -07001189
1190static void DumpPacketStats() {
1191 DumpFile("NETWORK DEV INFO", "/proc/net/dev");
1192 DumpFile("QTAGUID NETWORK INTERFACES INFO", "/proc/net/xt_qtaguid/iface_stat_all");
1193 DumpFile("QTAGUID NETWORK INTERFACES INFO (xt)", "/proc/net/xt_qtaguid/iface_stat_fmt");
1194 DumpFile("QTAGUID CTRL INFO", "/proc/net/xt_qtaguid/ctrl");
1195 DumpFile("QTAGUID STATS INFO", "/proc/net/xt_qtaguid/stats");
1196}
1197
1198static void DumpIpAddrAndRules() {
1199 /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
1200 RunCommand("NETWORK INTERFACES", {"ip", "link"});
1201 RunCommand("IPv4 ADDRESSES", {"ip", "-4", "addr", "show"});
1202 RunCommand("IPv6 ADDRESSES", {"ip", "-6", "addr", "show"});
1203 RunCommand("IP RULES", {"ip", "rule", "show"});
1204 RunCommand("IP RULES v6", {"ip", "-6", "rule", "show"});
1205}
1206
Nandana Dutt5c390032019-03-12 10:52:56 +00001207static Dumpstate::RunStatus RunDumpsysTextByPriority(const std::string& title, int priority,
1208 std::chrono::milliseconds timeout,
1209 std::chrono::milliseconds service_timeout) {
Vishnu Nair64afc022018-02-01 15:29:34 -08001210 auto start = std::chrono::steady_clock::now();
Vishnu Naire97d6122018-01-18 13:58:56 -08001211 sp<android::IServiceManager> sm = defaultServiceManager();
1212 Dumpsys dumpsys(sm.get());
Vishnu Naire97d6122018-01-18 13:58:56 -08001213 Vector<String16> args;
1214 Dumpsys::setServiceArgs(args, /* asProto = */ false, priority);
Vishnu Naire97d6122018-01-18 13:58:56 -08001215 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ false);
1216 for (const String16& service : services) {
Nandana Dutt5c390032019-03-12 10:52:56 +00001217 RETURN_IF_USER_DENIED_CONSENT();
Vishnu Naire97d6122018-01-18 13:58:56 -08001218 std::string path(title);
1219 path.append(" - ").append(String8(service).c_str());
Vishnu Naire97d6122018-01-18 13:58:56 -08001220 size_t bytes_written = 0;
Steven Moreland5a30d342019-10-08 13:53:28 -07001221 status_t status = dumpsys.startDumpThread(Dumpsys::Type::DUMP, service, args);
Vishnu Naire97d6122018-01-18 13:58:56 -08001222 if (status == OK) {
1223 dumpsys.writeDumpHeader(STDOUT_FILENO, service, priority);
1224 std::chrono::duration<double> elapsed_seconds;
1225 status = dumpsys.writeDump(STDOUT_FILENO, service, service_timeout,
1226 /* as_proto = */ false, elapsed_seconds, bytes_written);
Vishnu Naire97d6122018-01-18 13:58:56 -08001227 dumpsys.writeDumpFooter(STDOUT_FILENO, service, elapsed_seconds);
1228 bool dump_complete = (status == OK);
1229 dumpsys.stopDumpThread(dump_complete);
1230 }
Vishnu Naire97d6122018-01-18 13:58:56 -08001231
1232 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1233 std::chrono::steady_clock::now() - start);
1234 if (elapsed_duration > timeout) {
1235 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1236 elapsed_duration.count());
1237 break;
1238 }
1239 }
Nandana Dutt5c390032019-03-12 10:52:56 +00001240 return Dumpstate::RunStatus::OK;
Vishnu Naire97d6122018-01-18 13:58:56 -08001241}
1242
Vishnu Nair64afc022018-02-01 15:29:34 -08001243static void RunDumpsysText(const std::string& title, int priority,
1244 std::chrono::milliseconds timeout,
1245 std::chrono::milliseconds service_timeout) {
1246 DurationReporter duration_reporter(title);
1247 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1248 fsync(STDOUT_FILENO);
1249 RunDumpsysTextByPriority(title, priority, timeout, service_timeout);
1250}
1251
1252/* Dump all services registered with Normal or Default priority. */
Nandana Dutt5c390032019-03-12 10:52:56 +00001253static Dumpstate::RunStatus RunDumpsysTextNormalPriority(const std::string& title,
1254 std::chrono::milliseconds timeout,
1255 std::chrono::milliseconds service_timeout) {
Vishnu Nair64afc022018-02-01 15:29:34 -08001256 DurationReporter duration_reporter(title);
1257 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1258 fsync(STDOUT_FILENO);
1259 RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_NORMAL, timeout,
1260 service_timeout);
Nandana Dutt5c390032019-03-12 10:52:56 +00001261
1262 RETURN_IF_USER_DENIED_CONSENT();
1263
1264 return RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT, timeout,
1265 service_timeout);
Vishnu Nair64afc022018-02-01 15:29:34 -08001266}
1267
Nandana Dutt5c390032019-03-12 10:52:56 +00001268static Dumpstate::RunStatus RunDumpsysProto(const std::string& title, int priority,
1269 std::chrono::milliseconds timeout,
1270 std::chrono::milliseconds service_timeout) {
Luis Hector Chavez1e27b082018-03-22 15:36:42 -07001271 if (!ds.IsZipping()) {
1272 MYLOGD("Not dumping %s because it's not a zipped bugreport\n", title.c_str());
Nandana Dutt5c390032019-03-12 10:52:56 +00001273 return Dumpstate::RunStatus::OK;
Luis Hector Chavez1e27b082018-03-22 15:36:42 -07001274 }
Vishnu Naire97d6122018-01-18 13:58:56 -08001275 sp<android::IServiceManager> sm = defaultServiceManager();
1276 Dumpsys dumpsys(sm.get());
1277 Vector<String16> args;
1278 Dumpsys::setServiceArgs(args, /* asProto = */ true, priority);
1279 DurationReporter duration_reporter(title);
1280
1281 auto start = std::chrono::steady_clock::now();
1282 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ true);
1283 for (const String16& service : services) {
Nandana Dutt5c390032019-03-12 10:52:56 +00001284 RETURN_IF_USER_DENIED_CONSENT();
Vishnu Naire97d6122018-01-18 13:58:56 -08001285 std::string path(kProtoPath);
1286 path.append(String8(service).c_str());
1287 if (priority == IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL) {
1288 path.append("_CRITICAL");
1289 } else if (priority == IServiceManager::DUMP_FLAG_PRIORITY_HIGH) {
1290 path.append("_HIGH");
1291 }
1292 path.append(kProtoExt);
Steven Moreland5a30d342019-10-08 13:53:28 -07001293 status_t status = dumpsys.startDumpThread(Dumpsys::Type::DUMP, service, args);
Vishnu Naire97d6122018-01-18 13:58:56 -08001294 if (status == OK) {
1295 status = ds.AddZipEntryFromFd(path, dumpsys.getDumpFd(), service_timeout);
1296 bool dumpTerminated = (status == OK);
1297 dumpsys.stopDumpThread(dumpTerminated);
1298 }
1299 ZipWriter::FileEntry file_entry;
1300 ds.zip_writer_->GetLastEntry(&file_entry);
Vishnu Naire97d6122018-01-18 13:58:56 -08001301
1302 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1303 std::chrono::steady_clock::now() - start);
1304 if (elapsed_duration > timeout) {
1305 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1306 elapsed_duration.count());
1307 break;
1308 }
1309 }
Nandana Dutt5c390032019-03-12 10:52:56 +00001310 return Dumpstate::RunStatus::OK;
Vishnu Naire97d6122018-01-18 13:58:56 -08001311}
1312
Nandana Dutta7db6342018-11-21 14:53:34 +00001313// Runs dumpsys on services that must dump first and will take less than 100ms to dump.
Nandana Dutt5c390032019-03-12 10:52:56 +00001314static Dumpstate::RunStatus RunDumpsysCritical() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001315 RunDumpsysText("DUMPSYS CRITICAL", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1316 /* timeout= */ 5s, /* service_timeout= */ 500ms);
Nandana Dutt5c390032019-03-12 10:52:56 +00001317
1318 RETURN_IF_USER_DENIED_CONSENT();
1319
1320 return RunDumpsysProto("DUMPSYS CRITICAL PROTO", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1321 /* timeout= */ 5s, /* service_timeout= */ 500ms);
Vishnu Nair780b1282017-10-10 13:57:24 -07001322}
1323
1324// Runs dumpsys on services that must dump first but can take up to 250ms to dump.
Nandana Dutt5c390032019-03-12 10:52:56 +00001325static Dumpstate::RunStatus RunDumpsysHigh() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001326 // TODO meminfo takes ~10s, connectivity takes ~5sec to dump. They are both
1327 // high priority. Reduce timeout once they are able to dump in a shorter time or
1328 // moved to a parallel task.
1329 RunDumpsysText("DUMPSYS HIGH", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1330 /* timeout= */ 90s, /* service_timeout= */ 30s);
Nandana Dutt5c390032019-03-12 10:52:56 +00001331
1332 RETURN_IF_USER_DENIED_CONSENT();
1333
1334 return RunDumpsysProto("DUMPSYS HIGH PROTO", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1335 /* timeout= */ 5s, /* service_timeout= */ 1s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001336}
1337
1338// Runs dumpsys on services that must dump but can take up to 10s to dump.
Nandana Dutt5c390032019-03-12 10:52:56 +00001339static Dumpstate::RunStatus RunDumpsysNormal() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001340 RunDumpsysTextNormalPriority("DUMPSYS", /* timeout= */ 90s, /* service_timeout= */ 10s);
Nandana Dutt5c390032019-03-12 10:52:56 +00001341
1342 RETURN_IF_USER_DENIED_CONSENT();
1343
1344 return RunDumpsysProto("DUMPSYS PROTO", IServiceManager::DUMP_FLAG_PRIORITY_NORMAL,
1345 /* timeout= */ 90s, /* service_timeout= */ 10s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001346}
1347
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001348/*
1349 * |out_fd| A fd to support the DumpPool to output results to a temporary file.
1350 * Dumpstate can pick up later and output to the bugreport. Using STDOUT_FILENO
1351 * if it's not running in the parallel task.
1352 */
1353static void DumpHals(int out_fd = STDOUT_FILENO) {
Nandana Dutt6ad9a602019-03-11 16:33:24 +00001354 if (!ds.IsZipping()) {
Yifan Hong30528a22020-08-07 18:24:06 -07001355 RunCommand("HARDWARE HALS", {"lshal", "--all", "--types=all", "--debug"},
Steven Morelandd3646e02020-09-23 17:26:33 +00001356 CommandOptions::WithTimeout(60).AsRootIfAvailable().Build(),
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001357 false, out_fd);
Nandana Dutt6ad9a602019-03-11 16:33:24 +00001358 return;
1359 }
Yifan Hong30528a22020-08-07 18:24:06 -07001360 RunCommand("HARDWARE HALS", {"lshal", "--all", "--types=all"},
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001361 CommandOptions::WithTimeout(10).AsRootIfAvailable().Build(),
1362 false, out_fd);
Nandana Dutt6ad9a602019-03-11 16:33:24 +00001363
Steven Moreland44cd9482018-01-04 16:24:13 -08001364 using android::hidl::manager::V1_0::IServiceManager;
1365 using android::hardware::defaultServiceManager;
1366
1367 sp<IServiceManager> sm = defaultServiceManager();
1368 if (sm == nullptr) {
1369 MYLOGE("Could not retrieve hwservicemanager to dump hals.\n");
1370 return;
1371 }
1372
1373 auto ret = sm->list([&](const auto& interfaces) {
1374 for (const std::string& interface : interfaces) {
1375 std::string cleanName = interface;
1376 std::replace_if(cleanName.begin(),
1377 cleanName.end(),
1378 [](char c) {
1379 return !isalnum(c) &&
1380 std::string("@-_:.").find(c) == std::string::npos;
1381 }, '_');
Nandana Dutt979388e2018-11-30 16:48:55 +00001382 const std::string path = ds.bugreport_internal_dir_ + "/lshal_debug_" + cleanName;
Steven Moreland44cd9482018-01-04 16:24:13 -08001383
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001384 bool empty = false;
Steven Moreland44cd9482018-01-04 16:24:13 -08001385 {
1386 auto fd = android::base::unique_fd(
1387 TEMP_FAILURE_RETRY(open(path.c_str(),
1388 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1389 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1390 if (fd < 0) {
1391 MYLOGE("Could not open %s to dump additional hal information.\n", path.c_str());
1392 continue;
1393 }
1394 RunCommandToFd(fd,
1395 "",
Steven Morelandc81cd3c2018-01-18 14:36:26 -08001396 {"lshal", "debug", "-E", interface},
Steven Moreland44cd9482018-01-04 16:24:13 -08001397 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
1398
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001399 empty = 0 == lseek(fd, 0, SEEK_END);
Steven Moreland44cd9482018-01-04 16:24:13 -08001400 }
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001401 if (!empty) {
1402 ds.EnqueueAddZipEntryAndCleanupIfNeeded("lshal-debug/" + cleanName + ".txt",
1403 path);
1404 } else {
1405 unlink(path.c_str());
1406 }
Steven Moreland44cd9482018-01-04 16:24:13 -08001407 }
1408 });
1409
1410 if (!ret.isOk()) {
1411 MYLOGE("Could not list hals from hwservicemanager.\n");
1412 }
1413}
1414
Hridya Valsarajuac582cd2019-08-05 15:39:54 -07001415static void DumpExternalFragmentationInfo() {
1416 struct stat st;
1417 if (stat("/proc/buddyinfo", &st) != 0) {
1418 MYLOGE("Unable to dump external fragmentation info\n");
1419 return;
1420 }
1421
1422 printf("------ EXTERNAL FRAGMENTATION INFO ------\n");
1423 std::ifstream ifs("/proc/buddyinfo");
1424 auto unusable_index_regex = std::regex{"Node\\s+([0-9]+),\\s+zone\\s+(\\S+)\\s+(.*)"};
1425 for (std::string line; std::getline(ifs, line);) {
1426 std::smatch match_results;
1427 if (std::regex_match(line, match_results, unusable_index_regex)) {
1428 std::stringstream free_pages(std::string{match_results[3]});
1429 std::vector<int> free_pages_per_order(std::istream_iterator<int>{free_pages},
1430 std::istream_iterator<int>());
1431
1432 int total_free_pages = 0;
1433 for (size_t i = 0; i < free_pages_per_order.size(); i++) {
1434 total_free_pages += (free_pages_per_order[i] * std::pow(2, i));
1435 }
1436
1437 printf("Node %s, zone %8s", match_results[1].str().c_str(),
1438 match_results[2].str().c_str());
1439
1440 int usable_free_pages = total_free_pages;
1441 for (size_t i = 0; i < free_pages_per_order.size(); i++) {
1442 auto unusable_index = (total_free_pages - usable_free_pages) /
1443 static_cast<double>(total_free_pages);
1444 printf(" %5.3f", unusable_index);
1445 usable_free_pages -= (free_pages_per_order[i] * std::pow(2, i));
1446 }
1447
1448 printf("\n");
1449 }
1450 }
1451 printf("\n");
1452}
1453
mhasankd451a472020-05-26 18:02:39 -07001454static void DumpstateLimitedOnly() {
1455 // Trimmed-down version of dumpstate to only include a whitelisted
1456 // set of logs (system log, event log, and system server / system app
1457 // crashes, and networking logs). See b/136273873 and b/138459828
1458 // for context.
1459 DurationReporter duration_reporter("DUMPSTATE");
1460 unsigned long timeout_ms;
1461 // calculate timeout
1462 timeout_ms = logcat_timeout({"main", "system", "crash"});
1463 RunCommand("SYSTEM LOG",
1464 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1465 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
1466 timeout_ms = logcat_timeout({"events"});
1467 RunCommand(
1468 "EVENT LOG",
1469 {"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1470 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
1471
1472 printf("========================================================\n");
1473 printf("== Networking Service\n");
1474 printf("========================================================\n");
1475
1476 RunDumpsys("DUMPSYS NETWORK_SERVICE_LIMITED", {"wifi", "-a"},
1477 CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
Hugo Benichiaa162682020-10-30 23:28:56 +09001478 RunDumpsys("DUMPSYS CONNECTIVITY REQUESTS", {"connectivity", "requests"},
1479 CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
mhasankd451a472020-05-26 18:02:39 -07001480
1481 printf("========================================================\n");
1482 printf("== Dropbox crashes\n");
1483 printf("========================================================\n");
1484
1485 RunDumpsys("DROPBOX SYSTEM SERVER CRASHES", {"dropbox", "-p", "system_server_crash"});
1486 RunDumpsys("DROPBOX SYSTEM APP CRASHES", {"dropbox", "-p", "system_app_crash"});
1487
1488 printf("========================================================\n");
1489 printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),
1490 ds.progress_->GetMax(), ds.progress_->GetInitialMax());
1491 printf("========================================================\n");
1492 printf("== dumpstate: done (id %d)\n", ds.id_);
1493 printf("========================================================\n");
1494}
1495
Rhed Jaoe017f982020-07-21 17:58:41 +08001496/*
1497 * |out_fd| A fd to support the DumpPool to output results to a temporary file.
1498 * Dumpstate can pick up later and output to the bugreport. Using STDOUT_FILENO
1499 * if it's not running in the parallel task.
1500 */
1501static void DumpCheckins(int out_fd = STDOUT_FILENO) {
1502 dprintf(out_fd, "========================================================\n");
1503 dprintf(out_fd, "== Checkins\n");
1504 dprintf(out_fd, "========================================================\n");
1505
1506 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"}, out_fd);
1507 RunDumpsys("CHECKIN MEMINFO", {"meminfo", "--checkin"}, out_fd);
1508 RunDumpsys("CHECKIN NETSTATS", {"netstats", "--checkin"}, out_fd);
1509 RunDumpsys("CHECKIN PROCSTATS", {"procstats", "-c"}, out_fd);
1510 RunDumpsys("CHECKIN USAGESTATS", {"usagestats", "-c"}, out_fd);
1511 RunDumpsys("CHECKIN PACKAGE", {"package", "--checkin"}, out_fd);
1512}
1513
1514/*
1515 * Runs dumpsys on activity service to dump all application activities, services
1516 * and providers in the device.
1517 *
1518 * |out_fd| A fd to support the DumpPool to output results to a temporary file.
1519 * Dumpstate can pick up later and output to the bugreport. Using STDOUT_FILENO
1520 * if it's not running in the parallel task.
1521 */
1522static void DumpAppInfos(int out_fd = STDOUT_FILENO) {
1523 dprintf(out_fd, "========================================================\n");
1524 dprintf(out_fd, "== Running Application Activities\n");
1525 dprintf(out_fd, "========================================================\n");
1526
1527 // The following dumpsys internally collects output from running apps, so it can take a long
1528 // time. So let's extend the timeout.
1529
1530 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
1531
1532 RunDumpsys("APP ACTIVITIES", {"activity", "-v", "all"}, DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1533
1534 dprintf(out_fd, "========================================================\n");
1535 dprintf(out_fd, "== Running Application Services (platform)\n");
1536 dprintf(out_fd, "========================================================\n");
1537
1538 RunDumpsys("APP SERVICES PLATFORM", {"activity", "service", "all-platform-non-critical"},
1539 DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1540
1541 dprintf(out_fd, "========================================================\n");
1542 dprintf(out_fd, "== Running Application Services (non-platform)\n");
1543 dprintf(out_fd, "========================================================\n");
1544
1545 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
1546 DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1547
1548 dprintf(out_fd, "========================================================\n");
1549 dprintf(out_fd, "== Running Application Providers (platform)\n");
1550 dprintf(out_fd, "========================================================\n");
1551
1552 RunDumpsys("APP PROVIDERS PLATFORM", {"activity", "provider", "all-platform"},
1553 DUMPSYS_COMPONENTS_OPTIONS, out_fd);
1554
1555 dprintf(out_fd, "========================================================\n");
1556 dprintf(out_fd, "== Running Application Providers (non-platform)\n");
1557 dprintf(out_fd, "========================================================\n");
1558
1559 RunDumpsys("APP PROVIDERS NON-PLATFORM", {"activity", "provider", "all-non-platform"},
1560 DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1561}
1562
Nandana Dutt5c390032019-03-12 10:52:56 +00001563// Dumps various things. Returns early with status USER_CONSENT_DENIED if user denies consent
1564// via the consent they are shown. Ignores other errors that occur while running various
1565// commands. The consent checking is currently done around long running tasks, which happen to
1566// be distributed fairly evenly throughout the function.
1567static Dumpstate::RunStatus dumpstate() {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001568 DurationReporter duration_reporter("DUMPSTATE");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001569
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001570 // Enqueue slow functions into the thread pool, if the parallel run is enabled.
1571 if (ds.dump_pool_) {
1572 // Pool was shutdown in DumpstateDefaultAfterCritical method in order to
1573 // drop root user. Restarts it with two threads for the parallel run.
1574 ds.dump_pool_->start(/* thread_counts = */2);
1575
1576 ds.dump_pool_->enqueueTaskWithFd(DUMP_HALS_TASK, &DumpHals, _1);
1577 ds.dump_pool_->enqueueTask(DUMP_INCIDENT_REPORT_TASK, &DumpIncidentReport);
1578 ds.dump_pool_->enqueueTaskWithFd(DUMP_BOARD_TASK, &Dumpstate::DumpstateBoard, &ds, _1);
Rhed Jaoe017f982020-07-21 17:58:41 +08001579 ds.dump_pool_->enqueueTaskWithFd(DUMP_CHECKINS_TASK, &DumpCheckins, _1);
1580 ds.dump_pool_->enqueueTaskWithFd(DUMP_APP_INFOS_TASK, &DumpAppInfos, _1);
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001581 }
1582
Nandana Dutt5c390032019-03-12 10:52:56 +00001583 // Dump various things. Note that anything that takes "long" (i.e. several seconds) should
1584 // check intermittently (if it's intrerruptable like a foreach on pids) and/or should be wrapped
1585 // in a consent check (via RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK).
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -07001586 dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001587 RunCommand("UPTIME", {"uptime"});
Wei Wang509bb5d2017-06-09 14:42:12 -07001588 DumpBlockStatFiles();
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001589 DumpFile("MEMORY INFO", "/proc/meminfo");
1590 RunCommand("CPU INFO", {"top", "-b", "-n", "1", "-H", "-s", "6", "-o",
Felipe Leme30dbfa12016-09-02 12:43:26 -07001591 "pid,tid,user,pr,ni,%cpu,s,virt,res,pcy,cmd,name"});
Nandana Dutt5c390032019-03-12 10:52:56 +00001592
1593 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunCommand, "PROCRANK", {"procrank"}, AS_ROOT_20);
1594
Sunny Goyal35949782019-11-19 15:54:36 -08001595 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(DumpVisibleWindowViews);
1596
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001597 DumpFile("VIRTUAL MEMORY STATS", "/proc/vmstat");
1598 DumpFile("VMALLOC INFO", "/proc/vmallocinfo");
1599 DumpFile("SLAB INFO", "/proc/slabinfo");
1600 DumpFile("ZONEINFO", "/proc/zoneinfo");
1601 DumpFile("PAGETYPEINFO", "/proc/pagetypeinfo");
1602 DumpFile("BUDDYINFO", "/proc/buddyinfo");
Hridya Valsarajuac582cd2019-08-05 15:39:54 -07001603 DumpExternalFragmentationInfo();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001604
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001605 DumpFile("KERNEL WAKE SOURCES", "/d/wakeup_sources");
1606 DumpFile("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001607
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001608 RunCommand("PROCESSES AND THREADS",
Yohei Yukawa591a72d2017-10-05 21:36:35 -07001609 {"ps", "-A", "-T", "-Z", "-O", "pri,nice,rtprio,sched,pcy,time"});
Nandana Dutt5c390032019-03-12 10:52:56 +00001610
1611 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunCommand, "LIBRANK", {"librank"},
1612 CommandOptions::AS_ROOT);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001613
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001614 if (ds.dump_pool_) {
1615 WAIT_TASK_WITH_CONSENT_CHECK(DUMP_HALS_TASK, ds.dump_pool_);
1616 } else {
1617 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_HALS_TASK, DumpHals);
1618 }
Steven Moreland81b429e2017-01-31 19:50:46 -08001619
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001620 RunCommand("PRINTENV", {"printenv"});
Elliott Hughes21b7c8d2016-10-28 08:53:02 -07001621 RunCommand("NETSTAT", {"netstat", "-nW"});
Felipe Lemee4eca582016-06-10 17:48:08 -07001622 struct stat s;
1623 if (stat("/proc/modules", &s) != 0) {
1624 MYLOGD("Skipping 'lsmod' because /proc/modules does not exist\n");
1625 } else {
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001626 RunCommand("LSMOD", {"lsmod"});
Felipe Lemee4eca582016-06-10 17:48:08 -07001627 }
Michal Karpinski4db754f2015-12-11 18:04:32 +00001628
Tom Cherryb87dbfa2020-07-28 11:28:53 -07001629 if (android::base::GetBoolProperty("ro.logd.kernel", false)) {
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001630 DoKernelLogcat();
1631 } else {
1632 do_dmesg();
1633 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001634
Felipe Lemef0292972016-11-22 13:57:05 -08001635 RunCommand("LIST OF OPEN FILES", {"lsof"}, CommandOptions::AS_ROOT);
Nandana Dutt5c390032019-03-12 10:52:56 +00001636
1637 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(for_each_pid, do_showmap, "SMAPS OF ALL PROCESSES");
1638
Jeff Brown1dc94e32014-09-11 14:15:27 -07001639 for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
Mark Salyzyna297c322016-02-05 15:33:17 -08001640 for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001641
Ajay Panicker2ff8e872017-04-27 14:04:32 -07001642 /* Dump Bluetooth HCI logs */
1643 ds.AddDir("/data/misc/bluetooth/logs", true);
Jack Yu5a6b2e22020-08-14 18:13:35 +08001644 /* Dump Nfc NCI logs */
1645 ds.AddDir("/data/misc/nfc/logs", true);
Ajay Panickerd886ec42016-09-14 12:26:46 -07001646
Paul Chang0d2aad72020-02-13 20:04:03 +08001647 if (ds.options_->do_screenshot && !ds.do_early_screenshot_) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001648 MYLOGI("taking late screenshot\n");
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001649 ds.TakeScreenshot();
Jeff Sharkey5a930032013-03-19 15:05:19 -07001650 }
1651
Felipe Lemee184f662016-10-27 10:04:47 -07001652 AddAnrTraceFiles();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001653
Narayan Kamath8f788292017-05-25 13:20:39 +01001654 // NOTE: tombstones are always added as separate entries in the zip archive
1655 // and are not interspersed with the main report.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001656 const bool tombstones_dumped = AddDumps(ds.tombstone_data_.begin(), ds.tombstone_data_.end(),
Narayan Kamathbd863722017-06-01 18:50:12 +01001657 "TOMBSTONE", true /* add_to_zip */);
Narayan Kamath8f788292017-05-25 13:20:39 +01001658 if (!tombstones_dumped) {
1659 printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR.c_str());
Christopher Ferris7dc7f322014-07-22 16:08:19 -07001660 }
1661
Jayachandran Ca94c7172017-06-10 15:08:12 -07001662 DumpPacketStats();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001663
Chenbo Feng276a3b62018-08-07 11:44:49 -07001664 RunDumpsys("EBPF MAP STATS", {"netd", "trafficcontroller"});
1665
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001666 DoKmsg();
Mark Salyzyn2262c162014-12-16 09:09:26 -08001667
Jayachandran Ca94c7172017-06-10 15:08:12 -07001668 DumpIpAddrAndRules();
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -07001669
1670 dump_route_tables();
1671
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001672 RunCommand("ARP CACHE", {"ip", "-4", "neigh", "show"});
1673 RunCommand("IPv6 ND CACHE", {"ip", "-6", "neigh", "show"});
1674 RunCommand("MULTICAST ADDRESSES", {"ip", "maddr"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001675
Nandana Dutt5c390032019-03-12 10:52:56 +00001676 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunDumpsysHigh);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001677
Elliott Hughes23ccc622017-02-28 10:14:22 -08001678 RunCommand("SYSTEM PROPERTIES", {"getprop"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001679
Jin Qianf334d662017-10-10 14:41:37 -07001680 RunCommand("STORAGED IO INFO", {"storaged", "-u", "-p"});
ynwangf649a6e2016-07-17 21:56:00 -07001681
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001682 RunCommand("FILESYSTEMS & FREE SPACE", {"df"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001683
Colin Crossf45fa6b2012-03-26 12:38:26 -07001684 /* Binder state is expensive to look at as it uses a lot of memory. */
Hridya Valsaraju920ba712020-02-09 16:27:01 -08001685 std::string binder_logs_dir = access("/dev/binderfs/binder_logs", R_OK) ?
1686 "/sys/kernel/debug/binder" : "/dev/binderfs/binder_logs";
1687
1688 DumpFile("BINDER FAILED TRANSACTION LOG", binder_logs_dir + "/failed_transaction_log");
1689 DumpFile("BINDER TRANSACTION LOG", binder_logs_dir + "/transaction_log");
1690 DumpFile("BINDER TRANSACTIONS", binder_logs_dir + "/transactions");
1691 DumpFile("BINDER STATS", binder_logs_dir + "/stats");
1692 DumpFile("BINDER STATE", binder_logs_dir + "/state");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001693
Vishnu Nair36b4cdb2017-11-17 10:27:05 -08001694 /* Add window and surface trace files. */
1695 if (!PropertiesHelper::IsUserBuild()) {
1696 ds.AddDir(WMTRACE_DATA_DIR, false);
1697 }
1698
Yifan Hongd90cc652020-02-08 16:52:02 -08001699 ds.AddDir(SNAPSHOTCTL_LOG_DIR, false);
1700
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001701 if (ds.dump_pool_) {
1702 WAIT_TASK_WITH_CONSENT_CHECK(DUMP_BOARD_TASK, ds.dump_pool_);
1703 } else {
1704 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_BOARD_TASK, ds.DumpstateBoard);
1705 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001706
Steven Moreland7440ddb2016-12-15 16:13:39 -08001707 /* Migrate the ril_dumpstate to a device specific dumpstate? */
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001708 int rilDumpstateTimeout = android::base::GetIntProperty("ril.dumpstate.timeout", 0);
1709 if (rilDumpstateTimeout > 0) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001710 // su does not exist on user builds, so try running without it.
1711 // This way any implementations of vril-dump that do not require
1712 // root can run on user builds.
1713 CommandOptions::CommandOptionsBuilder options =
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001714 CommandOptions::WithTimeout(rilDumpstateTimeout);
Felipe Lemef0292972016-11-22 13:57:05 -08001715 if (!PropertiesHelper::IsUserBuild()) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001716 options.AsRoot();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001717 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001718 RunCommand("DUMP VENDOR RIL LOGS", {"vril-dump"}, options.Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001719 }
1720
Felipe Lemed8b94e52016-12-08 10:21:44 -08001721 printf("========================================================\n");
1722 printf("== Android Framework Services\n");
1723 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001724
Nandana Dutt5c390032019-03-12 10:52:56 +00001725 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunDumpsysNormal);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001726
Rhed Jaoe017f982020-07-21 17:58:41 +08001727 if (ds.dump_pool_) {
1728 WAIT_TASK_WITH_CONSENT_CHECK(DUMP_CHECKINS_TASK, ds.dump_pool_);
1729 } else {
1730 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_CHECKINS_TASK, DumpCheckins);
1731 }
Dianne Hackborn02bea972013-06-26 18:59:09 -07001732
Rhed Jaoe017f982020-07-21 17:58:41 +08001733 if (ds.dump_pool_) {
1734 WAIT_TASK_WITH_CONSENT_CHECK(DUMP_APP_INFOS_TASK, ds.dump_pool_);
1735 } else {
1736 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_APP_INFOS_TASK, DumpAppInfos);
1737 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001738
Adrian Roos8b397ab2017-04-04 16:35:44 -07001739 printf("========================================================\n");
1740 printf("== Dropbox crashes\n");
1741 printf("========================================================\n");
1742
1743 RunDumpsys("DROPBOX SYSTEM SERVER CRASHES", {"dropbox", "-p", "system_server_crash"});
1744 RunDumpsys("DROPBOX SYSTEM APP CRASHES", {"dropbox", "-p", "system_app_crash"});
1745
Felipe Lemed8b94e52016-12-08 10:21:44 -08001746 printf("========================================================\n");
1747 printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),
1748 ds.progress_->GetMax(), ds.progress_->GetInitialMax());
1749 printf("========================================================\n");
1750 printf("== dumpstate: done (id %d)\n", ds.id_);
1751 printf("========================================================\n");
Bookatz38472142018-09-28 10:20:24 -07001752
1753 printf("========================================================\n");
1754 printf("== Obtaining statsd metadata\n");
1755 printf("========================================================\n");
1756 // This differs from the usual dumpsys stats, which is the stats report data.
1757 RunDumpsys("STATSDSTATS", {"stats", "--metadata"});
Mike Ma5c267872019-08-21 11:31:34 -07001758
Kiyoung Kimc2d22ac2020-02-04 19:43:36 +09001759 // Add linker configuration directory
1760 ds.AddDir(LINKERCONFIG_DIR, true);
1761
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001762 if (ds.dump_pool_) {
1763 WAIT_TASK_WITH_CONSENT_CHECK(DUMP_INCIDENT_REPORT_TASK, ds.dump_pool_);
1764 } else {
1765 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_INCIDENT_REPORT_TASK,
1766 DumpIncidentReport);
1767 }
Mike Ma5c267872019-08-21 11:31:34 -07001768
Nandana Dutt5c390032019-03-12 10:52:56 +00001769 return Dumpstate::RunStatus::OK;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001770}
1771
Nandana Dutt5c390032019-03-12 10:52:56 +00001772/*
1773 * Dumps state for the default case; drops root after it's no longer necessary.
1774 *
1775 * Returns RunStatus::OK if everything went fine.
1776 * Returns RunStatus::ERROR if there was an error.
1777 * Returns RunStatus::USER_DENIED_CONSENT if user explicitly denied consent to sharing the bugreport
1778 * with the caller.
1779 */
Jichao Lie89d9c12019-11-21 19:02:51 -08001780Dumpstate::RunStatus Dumpstate::DumpstateDefaultAfterCritical() {
Nandana Duttdb379fa2019-10-09 16:54:41 +01001781 // Capture first logcat early on; useful to take a snapshot before dumpstate logs take over the
1782 // buffer.
1783 DoLogcat();
1784 // Capture timestamp after first logcat to use in next logcat
1785 time_t logcat_ts = time(nullptr);
1786
Nandana Dutt4be45d12018-09-26 15:04:23 +01001787 /* collect stack traces from Dalvik and native processes (needs root) */
Rhed Jao5377d792020-07-16 17:37:39 +08001788 if (dump_pool_) {
1789 RETURN_IF_USER_DENIED_CONSENT();
1790 // One thread is enough since we only need to enqueue DumpTraces here.
1791 dump_pool_->start(/* thread_counts = */1);
1792
1793 // DumpTraces takes long time, post it to the another thread in the
1794 // pool, if pool is available
1795 dump_pool_->enqueueTask(DUMP_TRACES_TASK, &Dumpstate::DumpTraces, &ds, &dump_traces_path);
1796 } else {
1797 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_TRACES_TASK, ds.DumpTraces,
1798 &dump_traces_path);
1799 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001800
1801 /* Run some operations that require root. */
1802 ds.tombstone_data_ = GetDumpFds(TOMBSTONE_DIR, TOMBSTONE_FILE_PREFIX, !ds.IsZipping());
1803 ds.anr_data_ = GetDumpFds(ANR_DIR, ANR_FILE_PREFIX, !ds.IsZipping());
1804
1805 ds.AddDir(RECOVERY_DIR, true);
1806 ds.AddDir(RECOVERY_DATA_DIR, true);
1807 ds.AddDir(UPDATE_ENGINE_LOG_DIR, true);
1808 ds.AddDir(LOGPERSIST_DATA_DIR, false);
1809 if (!PropertiesHelper::IsUserBuild()) {
1810 ds.AddDir(PROFILE_DATA_DIR_CUR, true);
1811 ds.AddDir(PROFILE_DATA_DIR_REF, true);
Calin Juravlef84d3692020-04-28 15:31:12 -07001812 ds.AddZipEntry(ZIP_ROOT_DIR + PACKAGE_DEX_USE_LIST, PACKAGE_DEX_USE_LIST);
Nandana Dutt4be45d12018-09-26 15:04:23 +01001813 }
Jerry Changa1df8a92020-01-02 16:03:39 +08001814 ds.AddDir(PREREBOOT_DATA_DIR, false);
Nandana Dutt4be45d12018-09-26 15:04:23 +01001815 add_mountinfo();
1816 DumpIpTablesAsRoot();
David Andersond9ba4752018-12-11 18:26:59 -08001817 DumpDynamicPartitionInfo();
Yifan Hong3945e1b2019-10-29 12:59:23 -07001818 ds.AddDir(OTA_METADATA_DIR, true);
Nandana Dutt4be45d12018-09-26 15:04:23 +01001819
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001820 // Capture any IPSec policies in play. No keys are exposed here.
Nandana Dutt4be45d12018-09-26 15:04:23 +01001821 RunCommand("IP XFRM POLICY", {"ip", "xfrm", "policy"}, CommandOptions::WithTimeout(10).Build());
1822
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001823 // Dump IPsec stats. No keys are exposed here.
1824 DumpFile("XFRM STATS", XFRM_STAT_PROC_FILE);
1825
Nandana Dutt4be45d12018-09-26 15:04:23 +01001826 // Run ss as root so we can see socket marks.
1827 RunCommand("DETAILED SOCKET STATE", {"ss", "-eionptu"}, CommandOptions::WithTimeout(10).Build());
1828
1829 // Run iotop as root to show top 100 IO threads
1830 RunCommand("IOTOP", {"iotop", "-n", "1", "-m", "100"});
1831
Erick Reyese68df822019-02-11 14:46:36 -08001832 // Gather shared memory buffer info if the product implements it
1833 struct stat st;
1834 if (!stat("/product/bin/dmabuf_dump", &st)) {
1835 RunCommand("Dmabuf dump", {"/product/bin/dmabuf_dump"});
1836 }
1837
Minchan Kim22c6a1e2019-09-30 15:58:10 -07001838 DumpFile("PSI cpu", "/proc/pressure/cpu");
1839 DumpFile("PSI memory", "/proc/pressure/memory");
1840 DumpFile("PSI io", "/proc/pressure/io");
1841
Rhed Jao5377d792020-07-16 17:37:39 +08001842 if (dump_pool_) {
1843 RETURN_IF_USER_DENIED_CONSENT();
1844 dump_pool_->waitForTask(DUMP_TRACES_TASK);
1845
1846 // Current running thread in the pool is the root user also. Shutdown
1847 // the pool and restart later to ensure all threads in the pool could
1848 // drop the root user.
1849 dump_pool_->shutdown();
1850 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001851 if (!DropRootUser()) {
Nandana Dutt5c390032019-03-12 10:52:56 +00001852 return Dumpstate::RunStatus::ERROR;
Nandana Dutt4be45d12018-09-26 15:04:23 +01001853 }
1854
Nandana Dutt5c390032019-03-12 10:52:56 +00001855 RETURN_IF_USER_DENIED_CONSENT();
Nandana Duttdb379fa2019-10-09 16:54:41 +01001856 Dumpstate::RunStatus status = dumpstate();
1857 // Capture logcat since the last time we did it.
1858 DoSystemLogcat(logcat_ts);
1859 return status;
Nandana Dutt4be45d12018-09-26 15:04:23 +01001860}
1861
Rhed Jaob5685b32020-08-14 17:19:17 +08001862// Common states for telephony and wifi which are needed to be collected before
1863// dumpstate drop the root user.
1864static void DumpstateRadioAsRoot() {
1865 DumpIpTablesAsRoot();
1866 ds.AddDir(LOGPERSIST_DATA_DIR, false);
1867}
1868
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001869// This method collects common dumpsys for telephony and wifi. Typically, wifi
1870// reports are fine to include all information, but telephony reports on user
1871// builds need to strip some content (see DumpstateTelephonyOnly).
1872static void DumpstateRadioCommon(bool include_sensitive_info = true) {
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001873 // We need to be picky about some stuff for telephony reports on user builds.
1874 if (!include_sensitive_info) {
1875 // Only dump the radio log buffer (other buffers and dumps contain too much unrelated info).
1876 DoRadioLogcat();
1877 } else {
Rhed Jaob5685b32020-08-14 17:19:17 +08001878 // DumpHals takes long time, post it to the another thread in the pool,
1879 // if pool is available.
1880 if (ds.dump_pool_) {
1881 ds.dump_pool_->enqueueTaskWithFd(DUMP_HALS_TASK, &DumpHals, _1);
1882 }
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001883 // Contains various system properties and process startup info.
1884 do_dmesg();
1885 // Logs other than the radio buffer may contain package/component names and potential PII.
1886 DoLogcat();
1887 // Too broad for connectivity problems.
1888 DoKmsg();
Rhed Jaob5685b32020-08-14 17:19:17 +08001889 // DumpHals contains unrelated hardware info (camera, NFC, biometrics, ...).
1890 if (ds.dump_pool_) {
1891 ds.dump_pool_->waitForTask(DUMP_HALS_TASK);
1892 } else {
1893 RUN_SLOW_FUNCTION_AND_LOG(DUMP_HALS_TASK, DumpHals);
1894 }
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001895 }
1896
Jayachandran Ca94c7172017-06-10 15:08:12 -07001897 DumpPacketStats();
Jayachandran Ca94c7172017-06-10 15:08:12 -07001898 DumpIpAddrAndRules();
1899 dump_route_tables();
Jayachandran Ca94c7172017-06-10 15:08:12 -07001900 RunDumpsys("NETWORK DIAGNOSTICS", {"connectivity", "--diag"},
1901 CommandOptions::WithTimeout(10).Build());
mukesh agrawal253dad42018-01-23 21:59:59 -08001902}
1903
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001904// We use "telephony" here for legacy reasons, though this now really means "connectivity" (cellular
1905// + wifi + networking). This method collects dumpsys for connectivity debugging only. General rules
1906// for what can be included on user builds: all reported information MUST directly relate to
1907// connectivity debugging or customer support and MUST NOT contain unrelated personally identifiable
1908// information. This information MUST NOT identify user-installed packages (UIDs are OK, package
1909// names are not), and MUST NOT contain logs of user application traffic.
1910// TODO(b/148168577) rename this and other related fields/methods to "connectivity" instead.
Hunter Knepshield0cc6c212020-01-07 16:57:10 -08001911static void DumpstateTelephonyOnly(const std::string& calling_package) {
mukesh agrawal253dad42018-01-23 21:59:59 -08001912 DurationReporter duration_reporter("DUMPSTATE");
Jichao Lie89d9c12019-11-21 19:02:51 -08001913
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07001914 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
mukesh agrawal253dad42018-01-23 21:59:59 -08001915
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001916 const bool include_sensitive_info = !PropertiesHelper::IsUserBuild();
Jayachandran Ca94c7172017-06-10 15:08:12 -07001917
Rhed Jaob5685b32020-08-14 17:19:17 +08001918 DumpstateRadioAsRoot();
1919 if (!DropRootUser()) {
1920 return;
1921 }
1922
1923 // Starts thread pool after the root user is dropped, and two additional threads
1924 // are created for DumpHals in the DumpstateRadioCommon and DumpstateBoard.
1925 if (ds.dump_pool_) {
1926 ds.dump_pool_->start(/*thread_counts =*/2);
1927
1928 // DumpstateBoard takes long time, post it to the another thread in the pool,
1929 // if pool is available.
1930 ds.dump_pool_->enqueueTaskWithFd(DUMP_BOARD_TASK, &Dumpstate::DumpstateBoard, &ds, _1);
1931 }
1932
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001933 DumpstateRadioCommon(include_sensitive_info);
1934
1935 if (include_sensitive_info) {
1936 // Contains too much unrelated PII, and given the unstructured nature of sysprops, we can't
1937 // really cherrypick all of the connectivity-related ones. Apps generally have no business
1938 // reading these anyway, and there should be APIs to supply the info in a more app-friendly
1939 // way.
1940 RunCommand("SYSTEM PROPERTIES", {"getprop"});
1941 }
Jayachandran Ca94c7172017-06-10 15:08:12 -07001942
1943 printf("========================================================\n");
1944 printf("== Android Framework Services\n");
1945 printf("========================================================\n");
1946
Vishnu Nair652cc802017-11-30 15:18:30 -08001947 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
1948 SEC_TO_MSEC(10));
Hunter Knepshield0cc6c212020-01-07 16:57:10 -08001949 if (include_sensitive_info) {
1950 // Carrier apps' services will be dumped below in dumpsys activity service all-non-platform.
1951 RunDumpsys("DUMPSYS", {"carrier_config"}, CommandOptions::WithTimeout(90).Build(),
1952 SEC_TO_MSEC(10));
1953 } else {
1954 // If the caller is a carrier app and has a carrier service, dump it here since we aren't
1955 // running dumpsys activity service all-non-platform below. Due to the increased output, we
1956 // give a higher timeout as well.
1957 RunDumpsys("DUMPSYS", {"carrier_config", "--requesting-package", calling_package},
1958 CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(30));
1959 }
1960 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001961 RunDumpsys("DUMPSYS", {"netpolicy"}, CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
1962 RunDumpsys("DUMPSYS", {"network_management"}, CommandOptions::WithTimeout(90).Build(),
Sooraj Sasindrane8d98912018-04-20 11:31:55 -07001963 SEC_TO_MSEC(10));
Hunter Knepshield0fe51b12020-03-05 16:58:20 -08001964 RunDumpsys("DUMPSYS", {"telephony.registry"}, CommandOptions::WithTimeout(90).Build(),
1965 SEC_TO_MSEC(10));
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001966 if (include_sensitive_info) {
1967 // Contains raw IP addresses, omit from reports on user builds.
1968 RunDumpsys("DUMPSYS", {"netd"}, CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
1969 // Contains raw destination IP/MAC addresses, omit from reports on user builds.
1970 RunDumpsys("DUMPSYS", {"connmetrics"}, CommandOptions::WithTimeout(90).Build(),
1971 SEC_TO_MSEC(10));
1972 // Contains package/component names, omit from reports on user builds.
1973 RunDumpsys("BATTERYSTATS", {"batterystats"}, CommandOptions::WithTimeout(90).Build(),
1974 SEC_TO_MSEC(10));
1975 // Contains package names, but should be relatively simple to remove them (also contains
1976 // UIDs already), omit from reports on user builds.
1977 RunDumpsys("BATTERYSTATS", {"deviceidle"}, CommandOptions::WithTimeout(90).Build(),
1978 SEC_TO_MSEC(10));
1979 }
Jayachandran Ca94c7172017-06-10 15:08:12 -07001980
1981 printf("========================================================\n");
1982 printf("== Running Application Services\n");
1983 printf("========================================================\n");
1984
1985 RunDumpsys("TELEPHONY SERVICES", {"activity", "service", "TelephonyDebugService"});
1986
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001987 if (include_sensitive_info) {
1988 printf("========================================================\n");
1989 printf("== Running Application Services (non-platform)\n");
1990 printf("========================================================\n");
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07001991
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001992 // Contains package/component names and potential PII, omit from reports on user builds.
1993 // To get dumps of the active CarrierService(s) on user builds, we supply an argument to the
1994 // carrier_config dumpsys instead.
1995 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
1996 DUMPSYS_COMPONENTS_OPTIONS);
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07001997
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001998 printf("========================================================\n");
1999 printf("== Checkins\n");
2000 printf("========================================================\n");
Kelly Rossmoyer769babb2018-08-21 18:06:38 -07002001
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002002 // Contains package/component names, omit from reports on user builds.
2003 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
2004 }
Kelly Rossmoyer769babb2018-08-21 18:06:38 -07002005
2006 printf("========================================================\n");
Jayachandran Ca94c7172017-06-10 15:08:12 -07002007 printf("== dumpstate: done (id %d)\n", ds.id_);
2008 printf("========================================================\n");
Rhed Jaob5685b32020-08-14 17:19:17 +08002009
2010 if (ds.dump_pool_) {
2011 ds.dump_pool_->waitForTask(DUMP_BOARD_TASK);
2012 } else {
2013 RUN_SLOW_FUNCTION_AND_LOG(DUMP_BOARD_TASK, ds.DumpstateBoard);
2014 }
Jayachandran Ca94c7172017-06-10 15:08:12 -07002015}
2016
mukesh agrawal253dad42018-01-23 21:59:59 -08002017// This method collects dumpsys for wifi debugging only
2018static void DumpstateWifiOnly() {
2019 DurationReporter duration_reporter("DUMPSTATE");
2020
Rhed Jaob5685b32020-08-14 17:19:17 +08002021 DumpstateRadioAsRoot();
2022 if (!DropRootUser()) {
2023 return;
2024 }
2025
2026 // Starts thread pool after the root user is dropped. Only one additional
2027 // thread is needed for DumpHals in the DumpstateRadioCommon.
2028 if (ds.dump_pool_) {
2029 ds.dump_pool_->start(/*thread_counts =*/1);
2030 }
2031
mukesh agrawal253dad42018-01-23 21:59:59 -08002032 DumpstateRadioCommon();
2033
2034 printf("========================================================\n");
2035 printf("== Android Framework Services\n");
2036 printf("========================================================\n");
2037
2038 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
2039 SEC_TO_MSEC(10));
2040 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(),
2041 SEC_TO_MSEC(10));
2042
2043 printf("========================================================\n");
2044 printf("== dumpstate: done (id %d)\n", ds.id_);
2045 printf("========================================================\n");
2046}
2047
Nandana Duttcf419a72019-03-14 10:40:17 +00002048Dumpstate::RunStatus Dumpstate::DumpTraces(const char** path) {
Nandana Duttfaafd522019-03-11 09:23:09 +00002049 const std::string temp_file_pattern = "/data/anr/dumptrace_XXXXXX";
2050 const size_t buf_size = temp_file_pattern.length() + 1;
2051 std::unique_ptr<char[]> file_name_buf(new char[buf_size]);
2052 memcpy(file_name_buf.get(), temp_file_pattern.c_str(), buf_size);
2053
2054 // Create a new, empty file to receive all trace dumps.
2055 //
2056 // TODO: This can be simplified once we remove support for the old style
2057 // dumps. We can have a file descriptor passed in to dump_traces instead
2058 // of creating a file, closing it and then reopening it again.
2059 android::base::unique_fd fd(mkostemp(file_name_buf.get(), O_APPEND | O_CLOEXEC));
2060 if (fd < 0) {
2061 MYLOGE("mkostemp on pattern %s: %s\n", file_name_buf.get(), strerror(errno));
Nandana Duttcf419a72019-03-14 10:40:17 +00002062 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002063 }
2064
2065 // Nobody should have access to this temporary file except dumpstate, but we
2066 // temporarily grant 'read' to 'others' here because this file is created
2067 // when tombstoned is still running as root, but dumped after dropping. This
2068 // can go away once support for old style dumping has.
2069 const int chmod_ret = fchmod(fd, 0666);
2070 if (chmod_ret < 0) {
2071 MYLOGE("fchmod on %s failed: %s\n", file_name_buf.get(), strerror(errno));
Nandana Duttcf419a72019-03-14 10:40:17 +00002072 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002073 }
2074
2075 std::unique_ptr<DIR, decltype(&closedir)> proc(opendir("/proc"), closedir);
2076 if (proc.get() == nullptr) {
2077 MYLOGE("opendir /proc failed: %s\n", strerror(errno));
Nandana Duttcf419a72019-03-14 10:40:17 +00002078 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002079 }
2080
2081 // Number of times process dumping has timed out. If we encounter too many
2082 // failures, we'll give up.
2083 int timeout_failures = 0;
2084 bool dalvik_found = false;
2085
2086 const std::set<int> hal_pids = get_interesting_hal_pids();
2087
2088 struct dirent* d;
2089 while ((d = readdir(proc.get()))) {
Nandana Duttcf419a72019-03-14 10:40:17 +00002090 RETURN_IF_USER_DENIED_CONSENT();
Nandana Duttfaafd522019-03-11 09:23:09 +00002091 int pid = atoi(d->d_name);
2092 if (pid <= 0) {
2093 continue;
2094 }
2095
2096 const std::string link_name = android::base::StringPrintf("/proc/%d/exe", pid);
2097 std::string exe;
2098 if (!android::base::Readlink(link_name, &exe)) {
2099 continue;
2100 }
2101
2102 bool is_java_process;
2103 if (exe == "/system/bin/app_process32" || exe == "/system/bin/app_process64") {
2104 // Don't bother dumping backtraces for the zygote.
2105 if (IsZygote(pid)) {
2106 continue;
2107 }
2108
2109 dalvik_found = true;
2110 is_java_process = true;
2111 } else if (should_dump_native_traces(exe.c_str()) || hal_pids.find(pid) != hal_pids.end()) {
2112 is_java_process = false;
2113 } else {
2114 // Probably a native process we don't care about, continue.
2115 continue;
2116 }
2117
2118 // If 3 backtrace dumps fail in a row, consider debuggerd dead.
2119 if (timeout_failures == 3) {
2120 dprintf(fd, "ERROR: Too many stack dump failures, exiting.\n");
2121 break;
2122 }
2123
2124 const uint64_t start = Nanotime();
2125 const int ret = dump_backtrace_to_file_timeout(
2126 pid, is_java_process ? kDebuggerdJavaBacktrace : kDebuggerdNativeBacktrace,
2127 is_java_process ? 5 : 20, fd);
2128
2129 if (ret == -1) {
2130 // For consistency, the header and footer to this message match those
2131 // dumped by debuggerd in the success case.
2132 dprintf(fd, "\n---- pid %d at [unknown] ----\n", pid);
2133 dprintf(fd, "Dump failed, likely due to a timeout.\n");
2134 dprintf(fd, "---- end %d ----", pid);
2135 timeout_failures++;
2136 continue;
2137 }
2138
2139 // We've successfully dumped stack traces, reset the failure count
2140 // and write a summary of the elapsed time to the file and continue with the
2141 // next process.
2142 timeout_failures = 0;
2143
2144 dprintf(fd, "[dump %s stack %d: %.3fs elapsed]\n", is_java_process ? "dalvik" : "native",
2145 pid, (float)(Nanotime() - start) / NANOS_PER_SEC);
2146 }
2147
2148 if (!dalvik_found) {
2149 MYLOGE("Warning: no Dalvik processes found to dump stacks\n");
2150 }
2151
Nandana Duttcf419a72019-03-14 10:40:17 +00002152 *path = file_name_buf.release();
2153 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002154}
2155
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08002156void Dumpstate::DumpstateBoard(int out_fd) {
2157 dprintf(out_fd, "========================================================\n");
2158 dprintf(out_fd, "== Board\n");
2159 dprintf(out_fd, "========================================================\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08002160
Felipe Leme6f674ae2016-11-18 17:10:33 -08002161 if (!IsZipping()) {
Steven Moreland7440ddb2016-12-15 16:13:39 -08002162 MYLOGD("Not dumping board info because it's not a zipped bugreport\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08002163 return;
2164 }
2165
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002166 std::vector<std::string> paths;
2167 std::vector<android::base::ScopeGuard<std::function<void()>>> remover;
Jie Song9fbfad02017-06-20 16:29:42 -07002168 for (int i = 0; i < NUM_OF_DUMPS; i++) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002169 paths.emplace_back(StringPrintf("%s/%s", ds.bugreport_internal_dir_.c_str(),
2170 kDumpstateBoardFiles[i].c_str()));
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002171 remover.emplace_back(android::base::make_scope_guard(
2172 std::bind([](std::string path) { android::os::UnlinkAndLogOnError(path); }, paths[i])));
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002173 }
Jie Song9fbfad02017-06-20 16:29:42 -07002174
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002175 sp<IDumpstateDevice_1_0> dumpstate_device_1_0(IDumpstateDevice_1_0::getService());
2176 if (dumpstate_device_1_0 == nullptr) {
Wei Wang587eac92018-04-05 12:17:20 -07002177 MYLOGE("No IDumpstateDevice implementation\n");
2178 return;
2179 }
2180
2181 using ScopedNativeHandle =
2182 std::unique_ptr<native_handle_t, std::function<void(native_handle_t*)>>;
2183 ScopedNativeHandle handle(native_handle_create(static_cast<int>(paths.size()), 0),
2184 [](native_handle_t* handle) {
2185 native_handle_close(handle);
2186 native_handle_delete(handle);
2187 });
2188 if (handle == nullptr) {
2189 MYLOGE("Could not create native_handle\n");
2190 return;
2191 }
2192
Nandana Dutt5c390032019-03-12 10:52:56 +00002193 // TODO(128270426): Check for consent in between?
Wei Wang587eac92018-04-05 12:17:20 -07002194 for (size_t i = 0; i < paths.size(); i++) {
2195 MYLOGI("Calling IDumpstateDevice implementation using path %s\n", paths[i].c_str());
2196
2197 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
2198 open(paths[i].c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
2199 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
2200 if (fd < 0) {
2201 MYLOGE("Could not open file %s: %s\n", paths[i].c_str(), strerror(errno));
2202 return;
2203 }
2204 handle.get()->data[i] = fd.release();
2205 }
2206
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002207 // Given that bugreport is required to diagnose failures, it's better to set an arbitrary amount
2208 // of timeout for IDumpstateDevice than to block the rest of bugreport. In the timeout case, we
2209 // will kill the HAL and grab whatever it dumped in time.
2210 constexpr size_t timeout_sec = 30;
2211 // Prefer version 1.1 if available. New devices launching with R are no longer allowed to
2212 // implement just 1.0.
2213 const char* descriptor_to_kill;
2214 using DumpstateBoardTask = std::packaged_task<bool()>;
2215 DumpstateBoardTask dumpstate_board_task;
2216 sp<IDumpstateDevice_1_1> dumpstate_device_1_1(
2217 IDumpstateDevice_1_1::castFrom(dumpstate_device_1_0));
2218 if (dumpstate_device_1_1 != nullptr) {
2219 MYLOGI("Using IDumpstateDevice v1.1");
2220 descriptor_to_kill = IDumpstateDevice_1_1::descriptor;
2221 dumpstate_board_task = DumpstateBoardTask([this, dumpstate_device_1_1, &handle]() -> bool {
2222 ::android::hardware::Return<DumpstateStatus> status =
2223 dumpstate_device_1_1->dumpstateBoard_1_1(handle.get(), options_->dumpstate_hal_mode,
2224 SEC_TO_MSEC(timeout_sec));
2225 if (!status.isOk()) {
2226 MYLOGE("dumpstateBoard failed: %s\n", status.description().c_str());
2227 return false;
2228 } else if (status != DumpstateStatus::OK) {
2229 MYLOGE("dumpstateBoard failed with DumpstateStatus::%s\n", toString(status).c_str());
2230 return false;
2231 }
2232 return true;
2233 });
2234 } else {
2235 MYLOGI("Using IDumpstateDevice v1.0");
2236 descriptor_to_kill = IDumpstateDevice_1_0::descriptor;
2237 dumpstate_board_task = DumpstateBoardTask([dumpstate_device_1_0, &handle]() -> bool {
2238 ::android::hardware::Return<void> status =
2239 dumpstate_device_1_0->dumpstateBoard(handle.get());
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002240 if (!status.isOk()) {
2241 MYLOGE("dumpstateBoard failed: %s\n", status.description().c_str());
Wei Wang587eac92018-04-05 12:17:20 -07002242 return false;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002243 }
Wei Wang587eac92018-04-05 12:17:20 -07002244 return true;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002245 });
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002246 }
2247 auto result = dumpstate_board_task.get_future();
2248 std::thread(std::move(dumpstate_board_task)).detach();
Wei Wang587eac92018-04-05 12:17:20 -07002249
Wei Wang587eac92018-04-05 12:17:20 -07002250 if (result.wait_for(std::chrono::seconds(timeout_sec)) != std::future_status::ready) {
2251 MYLOGE("dumpstateBoard timed out after %zus, killing dumpstate vendor HAL\n", timeout_sec);
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002252 if (!android::base::SetProperty(
2253 "ctl.interface_restart",
2254 android::base::StringPrintf("%s/default", descriptor_to_kill))) {
Wei Wang587eac92018-04-05 12:17:20 -07002255 MYLOGE("Couldn't restart dumpstate HAL\n");
2256 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002257 }
Wei Wang587eac92018-04-05 12:17:20 -07002258 // Wait some time for init to kill dumpstate vendor HAL
2259 constexpr size_t killing_timeout_sec = 10;
2260 if (result.wait_for(std::chrono::seconds(killing_timeout_sec)) != std::future_status::ready) {
2261 MYLOGE("killing dumpstateBoard timed out after %zus, continue and "
2262 "there might be racing in content\n", killing_timeout_sec);
2263 }
2264
2265 auto file_sizes = std::make_unique<ssize_t[]>(paths.size());
2266 for (size_t i = 0; i < paths.size(); i++) {
2267 struct stat s;
2268 if (fstat(handle.get()->data[i], &s) == -1) {
2269 MYLOGE("Failed to fstat %s: %s\n", kDumpstateBoardFiles[i].c_str(),
2270 strerror(errno));
2271 file_sizes[i] = -1;
2272 continue;
2273 }
2274 file_sizes[i] = s.st_size;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002275 }
2276
2277 for (size_t i = 0; i < paths.size(); i++) {
2278 if (file_sizes[i] == -1) {
2279 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07002280 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002281 if (file_sizes[i] == 0) {
Jie Song9fbfad02017-06-20 16:29:42 -07002282 MYLOGE("Ignoring empty %s\n", kDumpstateBoardFiles[i].c_str());
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002283 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07002284 }
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08002285 remover[i].Disable();
2286 EnqueueAddZipEntryAndCleanupIfNeeded(kDumpstateBoardFiles[i], paths[i]);
2287 dprintf(out_fd, "*** See %s entry ***\n", kDumpstateBoardFiles[i].c_str());
Jie Song9fbfad02017-06-20 16:29:42 -07002288 }
Felipe Leme6f674ae2016-11-18 17:10:33 -08002289}
2290
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002291static void ShowUsage() {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07002292 fprintf(stderr,
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002293 "usage: dumpstate [-h] [-b soundfile] [-e soundfile] [-o directory] [-p] "
2294 "[-s] [-S] [-q] [-P] [-R] [-L] [-V version]\n"
Felipe Leme4a0db9f2016-09-28 09:35:01 -07002295 " -h: display this help message\n"
2296 " -b: play sound file instead of vibrate, at beginning of job\n"
2297 " -e: play sound file instead of vibrate, at end of job\n"
mhasank2d75c442020-06-11 15:05:25 -07002298 " -o: write to custom directory (only in limited mode)\n"
Abhijeet Kaurbb55a3b2019-06-13 18:07:25 +01002299 " -p: capture screenshot to filename.png\n"
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002300 " -s: write zipped file to control socket (for init)\n"
2301 " -S: write file location to control socket (for init)\n"
Felipe Leme4a0db9f2016-09-28 09:35:01 -07002302 " -q: disable vibrate\n"
Abhijeet Kaure370d682019-10-01 16:49:30 +01002303 " -P: send broadcast when started and do progress updates\n"
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002304 " -R: take bugreport in remote mode (shouldn't be used with -P)\n"
Nandana Dutt235864b2019-01-22 12:10:16 +00002305 " -w: start binder service and make it wait for a call to startBugreport\n"
mhasankd451a472020-05-26 18:02:39 -07002306 " -L: output limited information that is safe for submission in feedback reports\n"
Felipe Lemed071c682016-10-20 16:48:00 -07002307 " -v: prints the dumpstate header and exit\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07002308}
2309
Wei Liuf87959e2016-08-26 14:51:42 -07002310static void register_sig_handler() {
Luis Hector Chavez558e1ef2018-03-22 15:39:17 -07002311 signal(SIGPIPE, SIG_IGN);
Wei Liuf87959e2016-08-26 14:51:42 -07002312}
2313
Felipe Leme1d486fe2016-10-14 18:06:47 -07002314bool Dumpstate::FinishZipFile() {
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08002315 // Runs all enqueued adding zip entry and cleanup tasks before finishing the zip file.
2316 if (zip_entry_tasks_) {
2317 zip_entry_tasks_->run(/* do_cancel = */false);
2318 }
2319
Felipe Leme9a523ae2016-10-20 15:10:33 -07002320 std::string entry_name = base_name_ + "-" + name_ + ".txt";
Felipe Leme1d486fe2016-10-14 18:06:47 -07002321 MYLOGD("Adding main entry (%s) from %s to .zip bugreport\n", entry_name.c_str(),
Felipe Leme9a523ae2016-10-20 15:10:33 -07002322 tmp_path_.c_str());
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07002323 // Final timestamp
2324 char date[80];
2325 time_t the_real_now_please_stand_up = time(nullptr);
2326 strftime(date, sizeof(date), "%Y/%m/%d %H:%M:%S", localtime(&the_real_now_please_stand_up));
Felipe Leme7447d7c2016-11-03 18:12:22 -07002327 MYLOGD("dumpstate id %d finished around %s (%ld s)\n", ds.id_, date,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07002328 the_real_now_please_stand_up - ds.now_);
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07002329
Felipe Leme9a523ae2016-10-20 15:10:33 -07002330 if (!ds.AddZipEntry(entry_name, tmp_path_)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08002331 MYLOGE("Failed to add text entry to .zip file\n");
Felipe Leme1e9edc62015-12-21 16:02:13 -08002332 return false;
2333 }
Felipe Leme1d486fe2016-10-14 18:06:47 -07002334 if (!AddTextZipEntry("main_entry.txt", entry_name)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08002335 MYLOGE("Failed to add main_entry.txt to .zip file\n");
Felipe Leme111b9d02016-02-03 09:28:24 -08002336 return false;
Felipe Leme809d74e2016-02-02 12:57:00 -08002337 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08002338
Felipe Leme0f3fb202016-06-10 17:10:53 -07002339 // Add log file (which contains stderr output) to zip...
2340 fprintf(stderr, "dumpstate_log.txt entry on zip file logged up to here\n");
Felipe Leme9a523ae2016-10-20 15:10:33 -07002341 if (!ds.AddZipEntry("dumpstate_log.txt", ds.log_path_.c_str())) {
Felipe Leme0f3fb202016-06-10 17:10:53 -07002342 MYLOGE("Failed to add dumpstate log to .zip file\n");
2343 return false;
2344 }
Nandana Dutt979388e2018-11-30 16:48:55 +00002345 // TODO: Should truncate the existing file.
2346 // ... and re-open it for further logging.
Nandana Dutta344cb62019-02-22 15:12:35 +00002347 if (!redirect_to_existing_file(stderr, const_cast<char*>(ds.log_path_.c_str()))) {
2348 return false;
2349 }
Felipe Leme0f3fb202016-06-10 17:10:53 -07002350 fprintf(stderr, "\n");
2351
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07002352 int32_t err = zip_writer_->Finish();
Felipe Leme1d486fe2016-10-14 18:06:47 -07002353 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07002354 MYLOGE("zip_writer_->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme1e9edc62015-12-21 16:02:13 -08002355 return false;
2356 }
2357
Felipe Leme1d486fe2016-10-14 18:06:47 -07002358 // TODO: remove once FinishZipFile() is automatically handled by Dumpstate's destructor.
2359 ds.zip_file.reset(nullptr);
2360
Felipe Lemee9d2c542016-11-15 11:48:26 -08002361 MYLOGD("Removing temporary file %s\n", tmp_path_.c_str())
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002362 android::os::UnlinkAndLogOnError(tmp_path_);
Felipe Lemec4eee562016-04-21 15:42:55 -07002363
Felipe Leme1e9edc62015-12-21 16:02:13 -08002364 return true;
2365}
Felipe Leme6e01fa62015-11-11 19:35:14 -08002366
Felipe Lemea4ef1f02017-02-15 17:27:40 -08002367static void SendBroadcast(const std::string& action, const std::vector<std::string>& args) {
2368 // clang-format off
2369 std::vector<std::string> am = {"/system/bin/cmd", "activity", "broadcast", "--user", "0",
2370 "--receiver-foreground", "--receiver-include-background", "-a", action};
2371 // clang-format on
Felipe Leme8d2410e2017-02-08 09:46:08 -08002372
2373 am.insert(am.end(), args.begin(), args.end());
2374
Felipe Leme8d2410e2017-02-08 09:46:08 -08002375 RunCommand("", am,
2376 CommandOptions::WithTimeout(20)
2377 .Log("Sending broadcast: '%s'\n")
2378 .Always()
2379 .DropRoot()
2380 .RedirectStderr()
2381 .Build());
2382}
2383
Felipe Leme35b8cf12017-02-10 15:47:29 -08002384static void Vibrate(int duration_ms) {
2385 // clang-format off
Chris Fries0c3de872019-09-14 15:49:41 +00002386 RunCommand("", {"cmd", "vibrator", "vibrate", "-f", std::to_string(duration_ms), "dumpstate"},
Felipe Leme35b8cf12017-02-10 15:47:29 -08002387 CommandOptions::WithTimeout(10)
2388 .Log("Vibrate: '%s'\n")
2389 .Always()
2390 .Build());
2391 // clang-format on
2392}
2393
Nandana Dutt979388e2018-11-30 16:48:55 +00002394static void MaybeResolveSymlink(std::string* path) {
2395 std::string resolved_path;
2396 if (android::base::Readlink(*path, &resolved_path)) {
2397 *path = resolved_path;
2398 }
2399}
2400
Nandana Dutt4be45d12018-09-26 15:04:23 +01002401/*
2402 * Prepares state like filename, screenshot path, etc in Dumpstate. Also initializes ZipWriter
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002403 * and adds the version file. Return false if zip_file could not be open to write.
Nandana Dutt4be45d12018-09-26 15:04:23 +01002404 */
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002405static bool PrepareToWriteToFile() {
Nandana Dutt979388e2018-11-30 16:48:55 +00002406 MaybeResolveSymlink(&ds.bugreport_internal_dir_);
2407
Nandana Dutt4be45d12018-09-26 15:04:23 +01002408 std::string build_id = android::base::GetProperty("ro.build.id", "UNKNOWN_BUILD");
2409 std::string device_name = android::base::GetProperty("ro.product.name", "UNKNOWN_DEVICE");
Nandana Dutt9a76d202019-01-21 15:56:48 +00002410 ds.base_name_ = StringPrintf("bugreport-%s-%s", device_name.c_str(), build_id.c_str());
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002411 char date[80];
2412 strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&ds.now_));
2413 ds.name_ = date;
Nandana Dutt4be45d12018-09-26 15:04:23 +01002414
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002415 if (ds.options_->telephony_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002416 ds.base_name_ += "-telephony";
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002417 } else if (ds.options_->wifi_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002418 ds.base_name_ += "-wifi";
2419 }
2420
Paul Chang0d2aad72020-02-13 20:04:03 +08002421 if (ds.options_->do_screenshot) {
Nandana Dutt9d17b942020-03-26 10:02:59 +00002422 ds.screenshot_path_ = ds.GetPath(ds.CalledByApi() ? "-png.tmp" : ".png");
Nandana Dutt4be45d12018-09-26 15:04:23 +01002423 }
2424 ds.tmp_path_ = ds.GetPath(".tmp");
2425 ds.log_path_ = ds.GetPath("-dumpstate_log-" + std::to_string(ds.pid_) + ".txt");
2426
Abhijeet Kaur359b1ff2019-07-26 16:01:36 +01002427 std::string destination = ds.CalledByApi()
Nandana Dutt54dbd672019-01-11 12:58:05 +00002428 ? StringPrintf("[fd:%d]", ds.options_->bugreport_fd.get())
Nandana Dutt9a76d202019-01-21 15:56:48 +00002429 : ds.bugreport_internal_dir_.c_str();
Nandana Dutt4be45d12018-09-26 15:04:23 +01002430 MYLOGD(
Nandana Dutt235c6672019-11-14 15:22:32 +00002431 "Bugreport dir: [%s] "
2432 "Base name: [%s] "
2433 "Suffix: [%s] "
2434 "Log path: [%s] "
2435 "Temporary path: [%s] "
2436 "Screenshot path: [%s]\n",
Nandana Dutt9a76d202019-01-21 15:56:48 +00002437 destination.c_str(), ds.base_name_.c_str(), ds.name_.c_str(), ds.log_path_.c_str(),
2438 ds.tmp_path_.c_str(), ds.screenshot_path_.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01002439
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002440 ds.path_ = ds.GetPath(ds.CalledByApi() ? "-zip.tmp" : ".zip");
2441 MYLOGD("Creating initial .zip file (%s)\n", ds.path_.c_str());
2442 create_parent_dirs(ds.path_.c_str());
2443 ds.zip_file.reset(fopen(ds.path_.c_str(), "wb"));
2444 if (ds.zip_file == nullptr) {
2445 MYLOGE("fopen(%s, 'wb'): %s\n", ds.path_.c_str(), strerror(errno));
2446 return false;
Nandana Dutt4be45d12018-09-26 15:04:23 +01002447 }
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002448 ds.zip_writer_.reset(new ZipWriter(ds.zip_file.get()));
2449 ds.AddTextZipEntry("version.txt", ds.version_);
2450 return true;
Nandana Dutt4be45d12018-09-26 15:04:23 +01002451}
2452
2453/*
Abhijeet Kaure370d682019-10-01 16:49:30 +01002454 * Finalizes writing to the file by zipping the tmp file to the final location,
Nandana Dutt4be45d12018-09-26 15:04:23 +01002455 * printing zipped file status, etc.
2456 */
2457static void FinalizeFile() {
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002458 bool do_text_file = !ds.FinishZipFile();
2459 if (do_text_file) {
2460 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
Nandana Dutt4be45d12018-09-26 15:04:23 +01002461 }
mhasank2d75c442020-06-11 15:05:25 -07002462
2463 std::string final_path = ds.path_;
2464 if (ds.options_->OutputToCustomFile()) {
mhasank3a4cfb42020-06-15 18:06:43 -07002465 final_path = ds.GetPath(ds.options_->out_dir, ".zip");
mhasank2d75c442020-06-11 15:05:25 -07002466 android::os::CopyFileToFile(ds.path_, final_path);
2467 }
2468
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002469 if (ds.options_->stream_to_socket) {
2470 android::os::CopyFileToFd(ds.path_, ds.control_socket_fd_);
2471 } else if (ds.options_->progress_updates_to_socket) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002472 if (do_text_file) {
2473 dprintf(ds.control_socket_fd_,
2474 "FAIL:could not create zip file, check %s "
2475 "for more details\n",
2476 ds.log_path_.c_str());
2477 } else {
mhasank2d75c442020-06-11 15:05:25 -07002478 dprintf(ds.control_socket_fd_, "OK:%s\n", final_path.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01002479 }
2480 }
2481}
2482
Nandana Dutt4be45d12018-09-26 15:04:23 +01002483
Nandana Dutt58d72e22018-11-16 10:30:48 +00002484static inline const char* ModeToString(Dumpstate::BugreportMode mode) {
2485 switch (mode) {
2486 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2487 return "BUGREPORT_FULL";
2488 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
2489 return "BUGREPORT_INTERACTIVE";
2490 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
2491 return "BUGREPORT_REMOTE";
2492 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
2493 return "BUGREPORT_WEAR";
2494 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
2495 return "BUGREPORT_TELEPHONY";
2496 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
2497 return "BUGREPORT_WIFI";
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002498 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2499 return "BUGREPORT_DEFAULT";
Nandana Dutt58d72e22018-11-16 10:30:48 +00002500 }
2501}
2502
Paul Changf59c2b72020-03-10 02:08:55 +08002503static void SetOptionsFromMode(Dumpstate::BugreportMode mode, Dumpstate::DumpOptions* options,
2504 bool is_screenshot_requested) {
Paul Chang0d2aad72020-02-13 20:04:03 +08002505 // Modify com.android.shell.BugreportProgressService#isDefaultScreenshotRequired as well for
2506 // default system screenshots.
Abhijeet Kaure370d682019-10-01 16:49:30 +01002507 options->bugreport_mode = ModeToString(mode);
Nandana Dutt58d72e22018-11-16 10:30:48 +00002508 switch (mode) {
2509 case Dumpstate::BugreportMode::BUGREPORT_FULL:
Paul Changf59c2b72020-03-10 02:08:55 +08002510 options->do_screenshot = is_screenshot_requested;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002511 options->dumpstate_hal_mode = DumpstateMode::FULL;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002512 break;
2513 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002514 // Currently, the dumpstate binder is only used by Shell to update progress.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002515 options->do_progress_updates = true;
Paul Changf59c2b72020-03-10 02:08:55 +08002516 options->do_screenshot = is_screenshot_requested;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002517 options->dumpstate_hal_mode = DumpstateMode::INTERACTIVE;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002518 break;
2519 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002520 options->do_vibrate = false;
2521 options->is_remote_mode = true;
Paul Chang0d2aad72020-02-13 20:04:03 +08002522 options->do_screenshot = false;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002523 options->dumpstate_hal_mode = DumpstateMode::REMOTE;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002524 break;
2525 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002526 options->do_progress_updates = true;
Paul Changf59c2b72020-03-10 02:08:55 +08002527 options->do_screenshot = is_screenshot_requested;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002528 options->dumpstate_hal_mode = DumpstateMode::WEAR;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002529 break;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002530 // TODO(b/148168577) rename TELEPHONY everywhere to CONNECTIVITY.
Nandana Dutt58d72e22018-11-16 10:30:48 +00002531 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002532 options->telephony_only = true;
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002533 options->do_progress_updates = true;
Paul Chang0d2aad72020-02-13 20:04:03 +08002534 options->do_screenshot = false;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002535 options->dumpstate_hal_mode = DumpstateMode::CONNECTIVITY;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002536 break;
2537 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002538 options->wifi_only = true;
Paul Chang0d2aad72020-02-13 20:04:03 +08002539 options->do_screenshot = false;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002540 options->dumpstate_hal_mode = DumpstateMode::WIFI;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002541 break;
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002542 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2543 break;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002544 }
2545}
2546
Nandana Dutt58d72e22018-11-16 10:30:48 +00002547static void LogDumpOptions(const Dumpstate::DumpOptions& options) {
Nandana Dutt235c6672019-11-14 15:22:32 +00002548 MYLOGI(
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002549 "do_vibrate: %d stream_to_socket: %d progress_updates_to_socket: %d do_screenshot: %d "
Rhed Jao25f50e02020-08-20 00:10:32 +08002550 "is_remote_mode: %d show_header_only: %d telephony_only: %d "
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002551 "wifi_only: %d do_progress_updates: %d fd: %d bugreport_mode: %s dumpstate_hal_mode: %s "
mhasankd451a472020-05-26 18:02:39 -07002552 "limited_only: %d args: %s\n",
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002553 options.do_vibrate, options.stream_to_socket, options.progress_updates_to_socket,
Paul Chang0d2aad72020-02-13 20:04:03 +08002554 options.do_screenshot, options.is_remote_mode, options.show_header_only,
Rhed Jao25f50e02020-08-20 00:10:32 +08002555 options.telephony_only, options.wifi_only,
mhasankd451a472020-05-26 18:02:39 -07002556 options.do_progress_updates, options.bugreport_fd.get(), options.bugreport_mode.c_str(),
2557 toString(options.dumpstate_hal_mode).c_str(), options.limited_only, options.args.c_str());
Nandana Dutt58d72e22018-11-16 10:30:48 +00002558}
2559
Nandana Dutt54dbd672019-01-11 12:58:05 +00002560void Dumpstate::DumpOptions::Initialize(BugreportMode bugreport_mode,
2561 const android::base::unique_fd& bugreport_fd_in,
Paul Changf59c2b72020-03-10 02:08:55 +08002562 const android::base::unique_fd& screenshot_fd_in,
2563 bool is_screenshot_requested) {
Nandana Dutt54dbd672019-01-11 12:58:05 +00002564 // Duplicate the fds because the passed in fds don't outlive the binder transaction.
2565 bugreport_fd.reset(dup(bugreport_fd_in.get()));
2566 screenshot_fd.reset(dup(screenshot_fd_in.get()));
Nandana Dutt58d72e22018-11-16 10:30:48 +00002567
Paul Changf59c2b72020-03-10 02:08:55 +08002568 SetOptionsFromMode(bugreport_mode, this, is_screenshot_requested);
Nandana Dutt58d72e22018-11-16 10:30:48 +00002569}
2570
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002571Dumpstate::RunStatus Dumpstate::DumpOptions::Initialize(int argc, char* argv[]) {
2572 RunStatus status = RunStatus::OK;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002573 int c;
mhasankd451a472020-05-26 18:02:39 -07002574 while ((c = getopt(argc, argv, "dho:svqzpLPBRSV:w")) != -1) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002575 switch (c) {
2576 // clang-format off
mhasank3a4cfb42020-06-15 18:06:43 -07002577 case 'o': out_dir = optarg; break;
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002578 case 's': stream_to_socket = true; break;
2579 case 'S': progress_updates_to_socket = true; break;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002580 case 'v': show_header_only = true; break;
2581 case 'q': do_vibrate = false; break;
Paul Chang0d2aad72020-02-13 20:04:03 +08002582 case 'p': do_screenshot = true; break;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002583 case 'P': do_progress_updates = true; break;
2584 case 'R': is_remote_mode = true; break;
mhasankd451a472020-05-26 18:02:39 -07002585 case 'L': limited_only = true; break;
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002586 case 'V':
2587 case 'd':
2588 case 'z':
2589 // compatibility no-op
2590 break;
Nandana Dutt235864b2019-01-22 12:10:16 +00002591 case 'w':
2592 // This was already processed
2593 break;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002594 case 'h':
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002595 status = RunStatus::HELP;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002596 break;
2597 default:
2598 fprintf(stderr, "Invalid option: %c\n", c);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002599 status = RunStatus::INVALID_INPUT;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002600 break;
2601 // clang-format on
2602 }
2603 }
Felipe Leme8fecfdd2016-02-09 10:40:07 -08002604
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002605 for (int i = 0; i < argc; i++) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002606 args += argv[i];
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002607 if (i < argc - 1) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002608 args += " ";
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002609 }
2610 }
2611
2612 // Reset next index used by getopt so this can be called multiple times, for eg, in tests.
2613 optind = 1;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002614
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002615 return status;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002616}
2617
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002618bool Dumpstate::DumpOptions::ValidateOptions() const {
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002619 if (bugreport_fd.get() != -1 && stream_to_socket) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002620 return false;
2621 }
2622
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002623 if ((progress_updates_to_socket || do_progress_updates) && stream_to_socket) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002624 return false;
2625 }
2626
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002627 if (is_remote_mode && (do_progress_updates || stream_to_socket)) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002628 return false;
2629 }
2630 return true;
2631}
2632
Nandana Dutt197661d2018-11-16 16:40:21 +00002633void Dumpstate::SetOptions(std::unique_ptr<DumpOptions> options) {
2634 options_ = std::move(options);
2635}
2636
Abhijeet Kaura407fb82020-03-27 12:51:12 +00002637void Dumpstate::Initialize() {
2638 /* gets the sequential id */
2639 uint32_t last_id = android::base::GetIntProperty(PROPERTY_LAST_ID, 0);
2640 id_ = ++last_id;
2641 android::base::SetProperty(PROPERTY_LAST_ID, std::to_string(last_id));
2642}
2643
Nandana Duttd2f5f082019-01-18 17:13:52 +00002644Dumpstate::RunStatus Dumpstate::Run(int32_t calling_uid, const std::string& calling_package) {
2645 Dumpstate::RunStatus status = RunInternal(calling_uid, calling_package);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002646 if (listener_ != nullptr) {
2647 switch (status) {
2648 case Dumpstate::RunStatus::OK:
Nandana Duttcc4ead82019-01-23 08:29:23 +00002649 listener_->onFinished();
Nandana Duttbabf6c72019-01-15 14:11:12 +00002650 break;
2651 case Dumpstate::RunStatus::HELP:
2652 break;
2653 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002654 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_INVALID_INPUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002655 break;
2656 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002657 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_RUNTIME_ERROR);
2658 break;
2659 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
2660 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_DENIED_CONSENT);
2661 break;
2662 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
2663 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_CONSENT_TIMED_OUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002664 break;
2665 }
2666 }
2667 return status;
2668}
2669
Nandana Dutt8ae16e62020-03-27 10:20:22 +00002670void Dumpstate::Cancel() {
2671 CleanupTmpFiles();
2672 android::os::UnlinkAndLogOnError(log_path_);
2673 for (int i = 0; i < NUM_OF_DUMPS; i++) {
2674 android::os::UnlinkAndLogOnError(ds.bugreport_internal_dir_ + "/" +
2675 kDumpstateBoardFiles[i]);
2676 }
2677 tombstone_data_.clear();
2678 anr_data_.clear();
Rhed Jao0daac912020-08-21 14:48:20 +08002679
2680 // Instead of shutdown the pool, we delete temporary files directly since
2681 // shutdown blocking the call.
2682 if (dump_pool_) {
2683 dump_pool_->deleteTempFiles();
2684 }
2685 if (zip_entry_tasks_) {
2686 zip_entry_tasks_->run(/*do_cancel =*/ true);
2687 }
Nandana Dutt8ae16e62020-03-27 10:20:22 +00002688}
2689
Nandana Dutt979388e2018-11-30 16:48:55 +00002690/*
2691 * Dumps relevant information to a bugreport based on the given options.
2692 *
2693 * The bugreport can be dumped to a file or streamed to a socket.
2694 *
2695 * How dumping to file works:
2696 * stdout is redirected to a temporary file. This will later become the main bugreport entry.
2697 * stderr is redirected a log file.
2698 *
2699 * The temporary bugreport is then populated via printfs, dumping contents of files and
2700 * output of commands to stdout.
2701 *
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002702 * A bunch of other files and dumps are added to the zip archive.
Nandana Dutt979388e2018-11-30 16:48:55 +00002703 *
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002704 * The temporary bugreport file and the log file also get added to the archive.
Nandana Dutt979388e2018-11-30 16:48:55 +00002705 *
mhasank2d75c442020-06-11 15:05:25 -07002706 * Bugreports are first generated in a local directory and later copied to the caller's fd
2707 * or directory if supplied.
Nandana Dutt979388e2018-11-30 16:48:55 +00002708 */
Nandana Duttd2f5f082019-01-18 17:13:52 +00002709Dumpstate::RunStatus Dumpstate::RunInternal(int32_t calling_uid,
2710 const std::string& calling_package) {
Rhed Jao5377d792020-07-16 17:37:39 +08002711 DurationReporter duration_reporter("RUN INTERNAL", /* logcat_only = */true);
Nandana Dutt979388e2018-11-30 16:48:55 +00002712 LogDumpOptions(*options_);
Nandana Dutt197661d2018-11-16 16:40:21 +00002713 if (!options_->ValidateOptions()) {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002714 MYLOGE("Invalid options specified\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002715 return RunStatus::INVALID_INPUT;
2716 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002717 /* set as high priority, and protect from OOM killer */
2718 setpriority(PRIO_PROCESS, 0, -20);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002719
Felipe Lemed071c682016-10-20 16:48:00 -07002720 FILE* oom_adj = fopen("/proc/self/oom_score_adj", "we");
Colin Crossf45fa6b2012-03-26 12:38:26 -07002721 if (oom_adj) {
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002722 fputs("-1000", oom_adj);
Colin Crossf45fa6b2012-03-26 12:38:26 -07002723 fclose(oom_adj);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002724 } else {
2725 /* fallback to kernels <= 2.6.35 */
2726 oom_adj = fopen("/proc/self/oom_adj", "we");
2727 if (oom_adj) {
2728 fputs("-17", oom_adj);
2729 fclose(oom_adj);
2730 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002731 }
2732
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002733 if (version_ == VERSION_DEFAULT) {
2734 version_ = VERSION_CURRENT;
Michal Karpinski4db754f2015-12-11 18:04:32 +00002735 }
2736
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002737 if (version_ != VERSION_CURRENT && version_ != VERSION_SPLIT_ANR) {
Vishnu Nair64afc022018-02-01 15:29:34 -08002738 MYLOGE("invalid version requested ('%s'); suppported values are: ('%s', '%s', '%s')\n",
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002739 version_.c_str(), VERSION_DEFAULT.c_str(), VERSION_CURRENT.c_str(),
Vishnu Nair64afc022018-02-01 15:29:34 -08002740 VERSION_SPLIT_ANR.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002741 return RunStatus::INVALID_INPUT;
Felipe Lemed071c682016-10-20 16:48:00 -07002742 }
2743
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002744 if (options_->show_header_only) {
2745 PrintHeader();
2746 return RunStatus::OK;
Felipe Lemed071c682016-10-20 16:48:00 -07002747 }
2748
Abhijeet Kaur3172b532019-10-15 15:07:03 +01002749 MYLOGD("dumpstate calling_uid = %d ; calling package = %s \n",
2750 calling_uid, calling_package.c_str());
Nandana Duttd2f5f082019-01-18 17:13:52 +00002751
Felipe Leme7447d7c2016-11-03 18:12:22 -07002752 // TODO: temporarily set progress until it's part of the Dumpstate constructor
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002753 std::string stats_path =
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002754 android::base::StringPrintf("%s/dumpstate-stats.txt", bugreport_internal_dir_.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002755 progress_.reset(new Progress(stats_path));
Felipe Leme7447d7c2016-11-03 18:12:22 -07002756
Sahana Raof35ed432019-07-12 10:47:52 +01002757 if (acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME) < 0) {
2758 MYLOGE("Failed to acquire wake lock: %s\n", strerror(errno));
2759 } else {
2760 // Wake lock will be released automatically on process death
2761 MYLOGD("Wake lock acquired.\n");
2762 }
2763
Felipe Leme6ae5c4f2017-01-10 14:13:22 -08002764 register_sig_handler();
Felipe Lemed071c682016-10-20 16:48:00 -07002765
Felipe Lemef0292972016-11-22 13:57:05 -08002766 if (PropertiesHelper::IsDryRun()) {
Felipe Lemed071c682016-10-20 16:48:00 -07002767 MYLOGI("Running on dry-run mode (to disable it, call 'setprop dumpstate.dry_run false')\n");
2768 }
2769
Nandana Dutt235c6672019-11-14 15:22:32 +00002770 MYLOGI("dumpstate info: id=%d, args='%s', bugreport_mode= %s bugreport format version: %s\n",
2771 id_, options_->args.c_str(), options_->bugreport_mode.c_str(), version_.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -08002772
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002773 do_early_screenshot_ = options_->do_progress_updates;
Felipe Lemee338bf62015-12-07 14:03:50 -08002774
Christopher Ferrised9354f2014-10-01 17:35:01 -07002775 // If we are going to use a socket, do it as early as possible
2776 // to avoid timeouts from bugreport.
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002777 if (options_->stream_to_socket || options_->progress_updates_to_socket) {
Felipe Leme2628e9e2016-04-12 16:36:51 -07002778 MYLOGD("Opening control socket\n");
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002779 control_socket_fd_ = open_socket_fn_("dumpstate");
Nandana Dutta344cb62019-02-22 15:12:35 +00002780 if (control_socket_fd_ == -1) {
2781 return ERROR;
2782 }
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002783 if (options_->progress_updates_to_socket) {
2784 options_->do_progress_updates = 1;
2785 }
Felipe Leme2628e9e2016-04-12 16:36:51 -07002786 }
2787
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002788 if (!PrepareToWriteToFile()) {
2789 return ERROR;
2790 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08002791
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002792 // Interactive, wear & telephony modes are default to true.
2793 // and may enable from cli option or when using control socket
2794 if (options_->do_progress_updates) {
2795 // clang-format off
2796 std::vector<std::string> am_args = {
2797 "--receiver-permission", "android.permission.DUMP",
2798 };
2799 // clang-format on
2800 // Send STARTED broadcast for apps that listen to bugreport generation events
2801 SendBroadcast("com.android.internal.intent.action.BUGREPORT_STARTED", am_args);
2802 if (options_->progress_updates_to_socket) {
2803 dprintf(control_socket_fd_, "BEGIN:%s\n", path_.c_str());
Felipe Leme71bbfc52015-11-23 14:14:51 -08002804 }
2805 }
2806
Nick Kralevichf3599b32016-01-25 15:05:16 -08002807 /* read /proc/cmdline before dropping root */
2808 FILE *cmdline = fopen("/proc/cmdline", "re");
2809 if (cmdline) {
2810 fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
2811 fclose(cmdline);
2812 }
2813
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002814 if (options_->do_vibrate) {
Felipe Leme35b8cf12017-02-10 15:47:29 -08002815 Vibrate(150);
John Michelau1f794c42012-09-17 11:20:19 -05002816 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002817
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002818 if (zip_file != nullptr) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002819 if (chown(path_.c_str(), AID_SHELL, AID_SHELL)) {
2820 MYLOGE("Unable to change ownership of zip file %s: %s\n", path_.c_str(),
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002821 strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08002822 }
2823 }
2824
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002825 int dup_stdout_fd;
2826 int dup_stderr_fd;
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002827 // Redirect stderr to log_path_ for debugging.
2828 TEMP_FAILURE_RETRY(dup_stderr_fd = dup(fileno(stderr)));
2829 if (!redirect_to_file(stderr, const_cast<char*>(log_path_.c_str()))) {
2830 return ERROR;
2831 }
2832 if (chown(log_path_.c_str(), AID_SHELL, AID_SHELL)) {
2833 MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n", log_path_.c_str(),
2834 strerror(errno));
2835 }
Nandana Dutt979388e2018-11-30 16:48:55 +00002836
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002837 // Redirect stdout to tmp_path_. This is the main bugreport entry and will be
2838 // moved into zip file later, if zipping.
2839 TEMP_FAILURE_RETRY(dup_stdout_fd = dup(fileno(stdout)));
2840 // TODO: why not write to a file instead of stdout to overcome this problem?
2841 /* TODO: rather than generating a text file now and zipping it later,
2842 it would be more efficient to redirect stdout to the zip entry
2843 directly, but the libziparchive doesn't support that option yet. */
2844 if (!redirect_to_file(stdout, const_cast<char*>(tmp_path_.c_str()))) {
2845 return ERROR;
2846 }
2847 if (chown(tmp_path_.c_str(), AID_SHELL, AID_SHELL)) {
2848 MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
2849 tmp_path_.c_str(), strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -07002850 }
Felipe Lemed8b94e52016-12-08 10:21:44 -08002851
2852 // Don't buffer stdout
2853 setvbuf(stdout, nullptr, _IONBF, 0);
2854
Rhed Jao5377d792020-07-16 17:37:39 +08002855 // Enable the parallel run if the client requests to output to a file.
2856 EnableParallelRunIfNeeded();
2857 // Using scope guard to make sure the dump pool can be shut down correctly.
2858 auto scope_guard_to_shutdown_pool = android::base::make_scope_guard([=]() {
2859 ShutdownDumpPool();
2860 });
2861
Felipe Leme608385d2016-02-01 10:35:38 -08002862 // NOTE: there should be no stdout output until now, otherwise it would break the header.
2863 // In particular, DurationReport objects should be created passing 'title, NULL', so their
Felipe Lemecbce55d2016-02-08 09:53:18 -08002864 // duration is logged into MYLOG instead.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002865 PrintHeader();
Colin Crossf45fa6b2012-03-26 12:38:26 -07002866
mhasankd451a472020-05-26 18:02:39 -07002867 // TODO(b/158737089) reduce code repetition in if branches
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002868 if (options_->telephony_only) {
Paul Chang0d2aad72020-02-13 20:04:03 +08002869 MaybeTakeEarlyScreenshot();
Paul Changeb4b4642020-05-28 22:05:47 +08002870 onUiIntensiveBugreportDumpsFinished(calling_uid);
Jichao Lie89d9c12019-11-21 19:02:51 -08002871 MaybeCheckUserConsent(calling_uid, calling_package);
Hunter Knepshield0cc6c212020-01-07 16:57:10 -08002872 DumpstateTelephonyOnly(calling_package);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002873 } else if (options_->wifi_only) {
Paul Chang0d2aad72020-02-13 20:04:03 +08002874 MaybeTakeEarlyScreenshot();
Paul Changeb4b4642020-05-28 22:05:47 +08002875 onUiIntensiveBugreportDumpsFinished(calling_uid);
Jichao Lie89d9c12019-11-21 19:02:51 -08002876 MaybeCheckUserConsent(calling_uid, calling_package);
mukesh agrawal253dad42018-01-23 21:59:59 -08002877 DumpstateWifiOnly();
mhasankd451a472020-05-26 18:02:39 -07002878 } else if (options_->limited_only) {
2879 MaybeTakeEarlyScreenshot();
Paul Changeb4b4642020-05-28 22:05:47 +08002880 onUiIntensiveBugreportDumpsFinished(calling_uid);
mhasankd451a472020-05-26 18:02:39 -07002881 MaybeCheckUserConsent(calling_uid, calling_package);
2882 DumpstateLimitedOnly();
Felipe Leme6ec6ac42017-01-10 15:29:53 -08002883 } else {
Paul Chang0d2aad72020-02-13 20:04:03 +08002884 // Invoke critical dumpsys first to preserve system state, before doing anything else.
Jichao Lie89d9c12019-11-21 19:02:51 -08002885 RunDumpsysCritical();
2886
Paul Chang0d2aad72020-02-13 20:04:03 +08002887 // Take screenshot and get consent only after critical dumpsys has finished.
2888 MaybeTakeEarlyScreenshot();
Paul Changeb4b4642020-05-28 22:05:47 +08002889 onUiIntensiveBugreportDumpsFinished(calling_uid);
Jichao Lie89d9c12019-11-21 19:02:51 -08002890 MaybeCheckUserConsent(calling_uid, calling_package);
2891
Nandana Dutt4be45d12018-09-26 15:04:23 +01002892 // Dump state for the default case. This also drops root.
Jichao Lie89d9c12019-11-21 19:02:51 -08002893 RunStatus s = DumpstateDefaultAfterCritical();
Nandana Dutt5c390032019-03-12 10:52:56 +00002894 if (s != RunStatus::OK) {
Nandana Duttaac6f582019-07-26 14:32:47 +01002895 if (s == RunStatus::USER_CONSENT_DENIED) {
Nandana Dutt5c390032019-03-12 10:52:56 +00002896 HandleUserConsentDenied();
2897 }
2898 return s;
Felipe Leme6ec6ac42017-01-10 15:29:53 -08002899 }
Zhengyin Qian068ecc72016-08-10 16:48:14 -07002900 }
Felipe Leme71a74ac2016-03-17 15:43:25 -07002901
Felipe Leme55b42a62015-11-10 17:39:08 -08002902 /* close output if needed */
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002903 TEMP_FAILURE_RETRY(dup2(dup_stdout_fd, fileno(stdout)));
Colin Crossf45fa6b2012-03-26 12:38:26 -07002904
Abhijeet Kaure370d682019-10-01 16:49:30 +01002905 // Zip the (now complete) .tmp file within the internal directory.
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002906 FinalizeFile();
Colin Crossf45fa6b2012-03-26 12:38:26 -07002907
Abhijeet Kaur3172b532019-10-15 15:07:03 +01002908 // Share the final file with the caller if the user has consented or Shell is the caller.
Nandana Duttd2f5f082019-01-18 17:13:52 +00002909 Dumpstate::RunStatus status = Dumpstate::RunStatus::OK;
Abhijeet Kaure370d682019-10-01 16:49:30 +01002910 if (CalledByApi()) {
Abhijeet Kaur3172b532019-10-15 15:07:03 +01002911 status = CopyBugreportIfUserConsented(calling_uid);
Nandana Duttd2f5f082019-01-18 17:13:52 +00002912 if (status != Dumpstate::RunStatus::OK &&
2913 status != Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
2914 // Do an early return if there were errors. We make an exception for consent
2915 // timing out because it's possible the user got distracted. In this case the
2916 // bugreport is not shared but made available for manual retrieval.
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002917 MYLOGI("User denied consent. Returning\n");
Nandana Duttd2f5f082019-01-18 17:13:52 +00002918 return status;
2919 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002920 if (status == Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
2921 MYLOGI(
2922 "Did not receive user consent yet."
2923 " Will not copy the bugreport artifacts to caller.\n");
Abhijeet Kaur57627412019-04-17 16:00:09 +01002924 const String16 incidentcompanion("incidentcompanion");
2925 sp<android::IBinder> ics(defaultServiceManager()->getService(incidentcompanion));
2926 if (ics != nullptr) {
2927 MYLOGD("Canceling user consent request via incidentcompanion service\n");
2928 android::interface_cast<android::os::IIncidentCompanion>(ics)->cancelAuthorization(
2929 consent_callback_.get());
2930 } else {
2931 MYLOGD("Unable to cancel user consent; incidentcompanion service unavailable\n");
2932 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002933 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00002934 }
2935
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08002936 /* vibrate a few but shortly times to let user know it's finished */
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002937 if (options_->do_vibrate) {
Takuya Ogawa47f644e2017-12-20 18:09:09 +09002938 for (int i = 0; i < 3; i++) {
2939 Vibrate(75);
2940 usleep((75 + 50) * 1000);
2941 }
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08002942 }
2943
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002944 MYLOGD("Final progress: %d/%d (estimated %d)\n", progress_->Get(), progress_->GetMax(),
2945 progress_->GetInitialMax());
2946 progress_->Save();
2947 MYLOGI("done (id %d)\n", id_);
Colin Crossf45fa6b2012-03-26 12:38:26 -07002948
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002949 TEMP_FAILURE_RETRY(dup2(dup_stderr_fd, fileno(stderr)));
Felipe Leme107a05f2016-03-08 15:11:15 -08002950
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002951 if (control_socket_fd_ != -1) {
Felipe Lemee844a9d2016-09-21 15:01:39 -07002952 MYLOGD("Closing control socket\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002953 close(control_socket_fd_);
Felipe Leme2628e9e2016-04-12 16:36:51 -07002954 }
2955
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002956 tombstone_data_.clear();
2957 anr_data_.clear();
Narayan Kamath6b9516c2017-10-27 11:15:51 +01002958
Nandana Duttd2f5f082019-01-18 17:13:52 +00002959 return (consent_callback_ != nullptr &&
2960 consent_callback_->getResult() == UserConsentResult::UNAVAILABLE)
2961 ? USER_CONSENT_TIMED_OUT
2962 : RunStatus::OK;
2963}
2964
Paul Chang0d2aad72020-02-13 20:04:03 +08002965void Dumpstate::MaybeTakeEarlyScreenshot() {
2966 if (!options_->do_screenshot || !do_early_screenshot_) {
2967 return;
2968 }
2969
2970 TakeScreenshot();
2971}
2972
Paul Changeb4b4642020-05-28 22:05:47 +08002973void Dumpstate::onUiIntensiveBugreportDumpsFinished(int32_t calling_uid) {
Paul Changc490e662020-04-11 18:14:09 +08002974 if (calling_uid == AID_SHELL || !CalledByApi()) {
2975 return;
2976 }
2977 if (listener_ != nullptr) {
2978 // Let listener know ui intensive bugreport dumps are finished, then it can do event
2979 // handling if required.
Paul Changeb4b4642020-05-28 22:05:47 +08002980 listener_->onUiIntensiveBugreportDumpsFinished();
Paul Changc490e662020-04-11 18:14:09 +08002981 }
2982}
2983
Jichao Lie89d9c12019-11-21 19:02:51 -08002984void Dumpstate::MaybeCheckUserConsent(int32_t calling_uid, const std::string& calling_package) {
2985 if (calling_uid == AID_SHELL || !CalledByApi()) {
2986 // No need to get consent for shell triggered dumpstates, or not through
2987 // bugreporting API (i.e. no fd to copy back).
Abhijeet Kaur3172b532019-10-15 15:07:03 +01002988 return;
2989 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00002990 consent_callback_ = new ConsentCallback();
2991 const String16 incidentcompanion("incidentcompanion");
2992 sp<android::IBinder> ics(defaultServiceManager()->getService(incidentcompanion));
Jichao Lie89d9c12019-11-21 19:02:51 -08002993 android::String16 package(calling_package.c_str());
Nandana Duttd2f5f082019-01-18 17:13:52 +00002994 if (ics != nullptr) {
2995 MYLOGD("Checking user consent via incidentcompanion service\n");
2996 android::interface_cast<android::os::IIncidentCompanion>(ics)->authorizeReport(
Jichao Lie89d9c12019-11-21 19:02:51 -08002997 calling_uid, package, String16(), String16(),
Joe Onorato1c36d752019-03-17 18:26:43 -07002998 0x1 /* FLAG_CONFIRMATION_DIALOG */, consent_callback_.get());
Nandana Duttd2f5f082019-01-18 17:13:52 +00002999 } else {
3000 MYLOGD("Unable to check user consent; incidentcompanion service unavailable\n");
3001 }
3002}
3003
Nandana Dutt5c390032019-03-12 10:52:56 +00003004bool Dumpstate::IsUserConsentDenied() const {
3005 return ds.consent_callback_ != nullptr &&
3006 ds.consent_callback_->getResult() == UserConsentResult::DENIED;
3007}
3008
Abhijeet Kaur359b1ff2019-07-26 16:01:36 +01003009bool Dumpstate::CalledByApi() const {
3010 return ds.options_->bugreport_fd.get() != -1 ? true : false;
3011}
3012
Nandana Dutt8ae16e62020-03-27 10:20:22 +00003013void Dumpstate::CleanupTmpFiles() {
Nandana Duttd2f5f082019-01-18 17:13:52 +00003014 android::os::UnlinkAndLogOnError(tmp_path_);
3015 android::os::UnlinkAndLogOnError(screenshot_path_);
3016 android::os::UnlinkAndLogOnError(path_);
3017}
3018
Rhed Jao5377d792020-07-16 17:37:39 +08003019void Dumpstate::EnableParallelRunIfNeeded() {
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003020 if (!PropertiesHelper::IsParallelRun()) {
Rhed Jao5377d792020-07-16 17:37:39 +08003021 return;
3022 }
3023 dump_pool_ = std::make_unique<DumpPool>(bugreport_internal_dir_);
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08003024 zip_entry_tasks_ = std::make_unique<TaskQueue>();
Rhed Jao5377d792020-07-16 17:37:39 +08003025}
3026
3027void Dumpstate::ShutdownDumpPool() {
3028 if (dump_pool_) {
3029 dump_pool_->shutdown();
3030 dump_pool_ = nullptr;
3031 }
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08003032 if (zip_entry_tasks_) {
3033 zip_entry_tasks_->run(/* do_cancel = */true);
3034 zip_entry_tasks_ = nullptr;
3035 }
3036}
3037
3038void Dumpstate::EnqueueAddZipEntryAndCleanupIfNeeded(const std::string& entry_name,
3039 const std::string& entry_path) {
3040 auto func_add_zip_entry_and_cleanup = [=](bool task_cancelled) {
3041 if (!task_cancelled) {
3042 AddZipEntry(entry_name, entry_path);
3043 }
3044 android::os::UnlinkAndLogOnError(entry_path);
3045 };
3046 if (zip_entry_tasks_) {
3047 // Enqueues AddZipEntryAndCleanup function if the parallel run is enabled.
3048 zip_entry_tasks_->add(func_add_zip_entry_and_cleanup, _1);
3049 } else {
3050 // Invokes AddZipEntryAndCleanup immediately
3051 std::invoke(func_add_zip_entry_and_cleanup, /* task_cancelled = */false);
3052 }
Rhed Jao5377d792020-07-16 17:37:39 +08003053}
3054
Nandana Duttd2f5f082019-01-18 17:13:52 +00003055Dumpstate::RunStatus Dumpstate::HandleUserConsentDenied() {
3056 MYLOGD("User denied consent; deleting files and returning\n");
Nandana Dutt8ae16e62020-03-27 10:20:22 +00003057 CleanupTmpFiles();
Nandana Duttd2f5f082019-01-18 17:13:52 +00003058 return USER_CONSENT_DENIED;
3059}
3060
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003061Dumpstate::RunStatus Dumpstate::CopyBugreportIfUserConsented(int32_t calling_uid) {
Nandana Duttd2f5f082019-01-18 17:13:52 +00003062 // If the caller has asked to copy the bugreport over to their directory, we need explicit
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003063 // user consent (unless the caller is Shell).
3064 UserConsentResult consent_result;
3065 if (calling_uid == AID_SHELL) {
3066 consent_result = UserConsentResult::APPROVED;
3067 } else {
3068 consent_result = consent_callback_->getResult();
3069 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003070 if (consent_result == UserConsentResult::UNAVAILABLE) {
3071 // User has not responded yet.
3072 uint64_t elapsed_ms = consent_callback_->getElapsedTimeMs();
Hunter Knepshield70610fa2020-01-03 15:27:33 -08003073 // Telephony is a fast report type, particularly on user builds where information may be
3074 // more aggressively limited. To give the user time to read the consent dialog, increase the
3075 // timeout.
3076 uint64_t timeout_ms = options_->telephony_only ? TELEPHONY_REPORT_USER_CONSENT_TIMEOUT_MS
3077 : USER_CONSENT_TIMEOUT_MS;
3078 if (elapsed_ms < timeout_ms) {
3079 uint delay_seconds = (timeout_ms - elapsed_ms) / 1000;
Nandana Duttd2f5f082019-01-18 17:13:52 +00003080 MYLOGD("Did not receive user consent yet; going to wait for %d seconds", delay_seconds);
3081 sleep(delay_seconds);
3082 }
3083 consent_result = consent_callback_->getResult();
3084 }
3085 if (consent_result == UserConsentResult::DENIED) {
3086 // User has explicitly denied sharing with the app. To be safe delete the
3087 // internal bugreport & tmp files.
3088 return HandleUserConsentDenied();
3089 }
3090 if (consent_result == UserConsentResult::APPROVED) {
Nandana Dutte78c3d72019-01-29 16:10:45 +00003091 bool copy_succeeded = android::os::CopyFileToFd(path_, options_->bugreport_fd.get());
3092 if (copy_succeeded) {
3093 android::os::UnlinkAndLogOnError(path_);
Abhijeet Kaur9ce94672020-04-01 17:22:36 +01003094 if (options_->do_screenshot &&
3095 options_->screenshot_fd.get() != -1 &&
3096 !options_->is_screenshot_copied) {
3097 copy_succeeded = android::os::CopyFileToFd(screenshot_path_,
3098 options_->screenshot_fd.get());
3099 options_->is_screenshot_copied = copy_succeeded;
3100 if (copy_succeeded) {
3101 android::os::UnlinkAndLogOnError(screenshot_path_);
3102 }
3103 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003104 }
3105 return copy_succeeded ? Dumpstate::RunStatus::OK : Dumpstate::RunStatus::ERROR;
3106 } else if (consent_result == UserConsentResult::UNAVAILABLE) {
3107 // consent_result is still UNAVAILABLE. The user has likely not responded yet.
3108 // Since we do not have user consent to share the bugreport it does not get
3109 // copied over to the calling app but remains in the internal directory from
3110 // where the user can manually pull it.
3111 return Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT;
3112 }
3113 // Unknown result; must be a programming error.
3114 MYLOGE("Unknown user consent result:%d\n", consent_result);
3115 return Dumpstate::RunStatus::ERROR;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003116}
3117
Nandana Duttf02564e2019-02-15 15:24:24 +00003118Dumpstate::RunStatus Dumpstate::ParseCommandlineAndRun(int argc, char* argv[]) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003119 std::unique_ptr<Dumpstate::DumpOptions> options = std::make_unique<Dumpstate::DumpOptions>();
3120 Dumpstate::RunStatus status = options->Initialize(argc, argv);
3121 if (status == Dumpstate::RunStatus::OK) {
Nandana Duttf02564e2019-02-15 15:24:24 +00003122 SetOptions(std::move(options));
Nandana Duttd2f5f082019-01-18 17:13:52 +00003123 // When directly running dumpstate binary, the output is not expected to be written
3124 // to any external file descriptor.
Nandana Duttf02564e2019-02-15 15:24:24 +00003125 assert(options_->bugreport_fd.get() == -1);
Nandana Duttd2f5f082019-01-18 17:13:52 +00003126
3127 // calling_uid and calling_package are for user consent to share the bugreport with
Abhijeet Kaura407fb82020-03-27 12:51:12 +00003128 // an app; they are irrelevant here because bugreport is triggered via command line.
3129 // Update Last ID before calling Run().
3130 Initialize();
Nandana Duttf02564e2019-02-15 15:24:24 +00003131 status = Run(-1 /* calling_uid */, "" /* calling_package */);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003132 }
Nandana Duttf02564e2019-02-15 15:24:24 +00003133 return status;
3134}
3135
3136/* Main entry point for dumpstate binary. */
3137int run_main(int argc, char* argv[]) {
3138 Dumpstate::RunStatus status = ds.ParseCommandlineAndRun(argc, argv);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003139
3140 switch (status) {
3141 case Dumpstate::RunStatus::OK:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003142 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003143 case Dumpstate::RunStatus::HELP:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003144 ShowUsage();
3145 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003146 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003147 fprintf(stderr, "Invalid combination of args\n");
3148 ShowUsage();
3149 exit(1);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003150 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00003151 FALLTHROUGH_INTENDED;
3152 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
3153 FALLTHROUGH_INTENDED;
3154 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003155 exit(2);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003156 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07003157}
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003158
3159// TODO(111441001): Default DumpOptions to sensible values.
3160Dumpstate::Dumpstate(const std::string& version)
3161 : pid_(getpid()),
3162 options_(new Dumpstate::DumpOptions()),
Nandana Dutt402a8392019-06-14 14:25:13 +01003163 last_reported_percent_progress_(0),
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003164 version_(version),
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003165 now_(time(nullptr)),
3166 open_socket_fn_(open_socket) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003167}
3168
3169Dumpstate& Dumpstate::GetInstance() {
3170 static Dumpstate singleton_(android::base::GetProperty("dumpstate.version", VERSION_CURRENT));
3171 return singleton_;
3172}
3173
Rhed Jao5377d792020-07-16 17:37:39 +08003174DurationReporter::DurationReporter(const std::string& title, bool logcat_only, bool verbose,
3175 int duration_fd) : title_(title), logcat_only_(logcat_only), verbose_(verbose),
3176 duration_fd_(duration_fd) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003177 if (!title_.empty()) {
3178 started_ = Nanotime();
3179 }
3180}
3181
3182DurationReporter::~DurationReporter() {
3183 if (!title_.empty()) {
3184 float elapsed = (float)(Nanotime() - started_) / NANOS_PER_SEC;
chenqiwuaf8b2d92019-12-12 18:53:51 +08003185 if (elapsed >= .5f || verbose_) {
3186 MYLOGD("Duration of '%s': %.2fs\n", title_.c_str(), elapsed);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003187 }
chenqiwuaf8b2d92019-12-12 18:53:51 +08003188 if (!logcat_only_) {
3189 // Use "Yoda grammar" to make it easier to grep|sort sections.
Rhed Jao5377d792020-07-16 17:37:39 +08003190 dprintf(duration_fd_, "------ %.3fs was the duration of '%s' ------\n",
3191 elapsed, title_.c_str());
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003192 }
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003193 }
3194}
3195
3196const int32_t Progress::kDefaultMax = 5000;
3197
3198Progress::Progress(const std::string& path) : Progress(Progress::kDefaultMax, 1.1, path) {
3199}
3200
3201Progress::Progress(int32_t initial_max, int32_t progress, float growth_factor)
3202 : Progress(initial_max, growth_factor, "") {
3203 progress_ = progress;
3204}
3205
3206Progress::Progress(int32_t initial_max, float growth_factor, const std::string& path)
3207 : initial_max_(initial_max),
3208 progress_(0),
3209 max_(initial_max),
3210 growth_factor_(growth_factor),
3211 n_runs_(0),
3212 average_max_(0),
3213 path_(path) {
3214 if (!path_.empty()) {
3215 Load();
3216 }
3217}
3218
3219void Progress::Load() {
3220 MYLOGD("Loading stats from %s\n", path_.c_str());
3221 std::string content;
3222 if (!android::base::ReadFileToString(path_, &content)) {
3223 MYLOGI("Could not read stats from %s; using max of %d\n", path_.c_str(), max_);
3224 return;
3225 }
3226 if (content.empty()) {
3227 MYLOGE("No stats (empty file) on %s; using max of %d\n", path_.c_str(), max_);
3228 return;
3229 }
3230 std::vector<std::string> lines = android::base::Split(content, "\n");
3231
3232 if (lines.size() < 1) {
3233 MYLOGE("Invalid stats on file %s: not enough lines (%d). Using max of %d\n", path_.c_str(),
3234 (int)lines.size(), max_);
3235 return;
3236 }
3237 char* ptr;
3238 n_runs_ = strtol(lines[0].c_str(), &ptr, 10);
3239 average_max_ = strtol(ptr, nullptr, 10);
3240 if (n_runs_ <= 0 || average_max_ <= 0 || n_runs_ > STATS_MAX_N_RUNS ||
3241 average_max_ > STATS_MAX_AVERAGE) {
3242 MYLOGE("Invalid stats line on file %s: %s\n", path_.c_str(), lines[0].c_str());
3243 initial_max_ = Progress::kDefaultMax;
3244 } else {
3245 initial_max_ = average_max_;
3246 }
3247 max_ = initial_max_;
3248
3249 MYLOGI("Average max progress: %d in %d runs; estimated max: %d\n", average_max_, n_runs_, max_);
3250}
3251
3252void Progress::Save() {
3253 int32_t total = n_runs_ * average_max_ + progress_;
3254 int32_t runs = n_runs_ + 1;
3255 int32_t average = floor(((float)total) / runs);
3256 MYLOGI("Saving stats (total=%d, runs=%d, average=%d) on %s\n", total, runs, average,
3257 path_.c_str());
3258 if (path_.empty()) {
3259 return;
3260 }
3261
3262 std::string content = android::base::StringPrintf("%d %d\n", runs, average);
3263 if (!android::base::WriteStringToFile(content, path_)) {
3264 MYLOGE("Could not save stats on %s\n", path_.c_str());
3265 }
3266}
3267
3268int32_t Progress::Get() const {
3269 return progress_;
3270}
3271
3272bool Progress::Inc(int32_t delta_sec) {
3273 bool changed = false;
3274 if (delta_sec >= 0) {
3275 progress_ += delta_sec;
3276 if (progress_ > max_) {
3277 int32_t old_max = max_;
3278 max_ = floor((float)progress_ * growth_factor_);
3279 MYLOGD("Adjusting max progress from %d to %d\n", old_max, max_);
3280 changed = true;
3281 }
3282 }
3283 return changed;
3284}
3285
3286int32_t Progress::GetMax() const {
3287 return max_;
3288}
3289
3290int32_t Progress::GetInitialMax() const {
3291 return initial_max_;
3292}
3293
3294void Progress::Dump(int fd, const std::string& prefix) const {
3295 const char* pr = prefix.c_str();
3296 dprintf(fd, "%sprogress: %d\n", pr, progress_);
3297 dprintf(fd, "%smax: %d\n", pr, max_);
3298 dprintf(fd, "%sinitial_max: %d\n", pr, initial_max_);
3299 dprintf(fd, "%sgrowth_factor: %0.2f\n", pr, growth_factor_);
3300 dprintf(fd, "%spath: %s\n", pr, path_.c_str());
3301 dprintf(fd, "%sn_runs: %d\n", pr, n_runs_);
3302 dprintf(fd, "%saverage_max: %d\n", pr, average_max_);
3303}
3304
3305bool Dumpstate::IsZipping() const {
3306 return zip_writer_ != nullptr;
3307}
3308
3309std::string Dumpstate::GetPath(const std::string& suffix) const {
3310 return GetPath(bugreport_internal_dir_, suffix);
3311}
3312
3313std::string Dumpstate::GetPath(const std::string& directory, const std::string& suffix) const {
3314 return android::base::StringPrintf("%s/%s-%s%s", directory.c_str(), base_name_.c_str(),
3315 name_.c_str(), suffix.c_str());
3316}
3317
3318void Dumpstate::SetProgress(std::unique_ptr<Progress> progress) {
3319 progress_ = std::move(progress);
3320}
3321
3322void for_each_userid(void (*func)(int), const char *header) {
3323 std::string title = header == nullptr ? "for_each_userid" : android::base::StringPrintf(
3324 "for_each_userid(%s)", header);
3325 DurationReporter duration_reporter(title);
3326 if (PropertiesHelper::IsDryRun()) return;
3327
3328 DIR *d;
3329 struct dirent *de;
3330
3331 if (header) printf("\n------ %s ------\n", header);
3332 func(0);
3333
3334 if (!(d = opendir("/data/system/users"))) {
3335 printf("Failed to open /data/system/users (%s)\n", strerror(errno));
3336 return;
3337 }
3338
3339 while ((de = readdir(d))) {
3340 int userid;
3341 if (de->d_type != DT_DIR || !(userid = atoi(de->d_name))) {
3342 continue;
3343 }
3344 func(userid);
3345 }
3346
3347 closedir(d);
3348}
3349
3350static void __for_each_pid(void (*helper)(int, const char *, void *), const char *header, void *arg) {
3351 DIR *d;
3352 struct dirent *de;
3353
3354 if (!(d = opendir("/proc"))) {
3355 printf("Failed to open /proc (%s)\n", strerror(errno));
3356 return;
3357 }
3358
3359 if (header) printf("\n------ %s ------\n", header);
3360 while ((de = readdir(d))) {
3361 if (ds.IsUserConsentDenied()) {
3362 MYLOGE(
3363 "Returning early because user denied consent to share bugreport with calling app.");
3364 closedir(d);
3365 return;
3366 }
3367 int pid;
3368 int fd;
3369 char cmdpath[255];
3370 char cmdline[255];
3371
3372 if (!(pid = atoi(de->d_name))) {
3373 continue;
3374 }
3375
3376 memset(cmdline, 0, sizeof(cmdline));
3377
3378 snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/cmdline", pid);
3379 if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) {
3380 TEMP_FAILURE_RETRY(read(fd, cmdline, sizeof(cmdline) - 2));
3381 close(fd);
3382 if (cmdline[0]) {
3383 helper(pid, cmdline, arg);
3384 continue;
3385 }
3386 }
3387
3388 // if no cmdline, a kernel thread has comm
3389 snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/comm", pid);
3390 if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) {
3391 TEMP_FAILURE_RETRY(read(fd, cmdline + 1, sizeof(cmdline) - 4));
3392 close(fd);
3393 if (cmdline[1]) {
3394 cmdline[0] = '[';
3395 size_t len = strcspn(cmdline, "\f\b\r\n");
3396 cmdline[len] = ']';
3397 cmdline[len+1] = '\0';
3398 }
3399 }
3400 if (!cmdline[0]) {
3401 strcpy(cmdline, "N/A");
3402 }
3403 helper(pid, cmdline, arg);
3404 }
3405
3406 closedir(d);
3407}
3408
3409static void for_each_pid_helper(int pid, const char *cmdline, void *arg) {
3410 for_each_pid_func *func = (for_each_pid_func*) arg;
3411 func(pid, cmdline);
3412}
3413
3414void for_each_pid(for_each_pid_func func, const char *header) {
3415 std::string title = header == nullptr ? "for_each_pid"
3416 : android::base::StringPrintf("for_each_pid(%s)", header);
3417 DurationReporter duration_reporter(title);
3418 if (PropertiesHelper::IsDryRun()) return;
3419
3420 __for_each_pid(for_each_pid_helper, header, (void *) func);
3421}
3422
3423static void for_each_tid_helper(int pid, const char *cmdline, void *arg) {
3424 DIR *d;
3425 struct dirent *de;
3426 char taskpath[255];
3427 for_each_tid_func *func = (for_each_tid_func *) arg;
3428
3429 snprintf(taskpath, sizeof(taskpath), "/proc/%d/task", pid);
3430
3431 if (!(d = opendir(taskpath))) {
3432 printf("Failed to open %s (%s)\n", taskpath, strerror(errno));
3433 return;
3434 }
3435
3436 func(pid, pid, cmdline);
3437
3438 while ((de = readdir(d))) {
3439 if (ds.IsUserConsentDenied()) {
3440 MYLOGE(
3441 "Returning early because user denied consent to share bugreport with calling app.");
3442 closedir(d);
3443 return;
3444 }
3445 int tid;
3446 int fd;
3447 char commpath[255];
3448 char comm[255];
3449
3450 if (!(tid = atoi(de->d_name))) {
3451 continue;
3452 }
3453
3454 if (tid == pid)
3455 continue;
3456
3457 snprintf(commpath, sizeof(commpath), "/proc/%d/comm", tid);
3458 memset(comm, 0, sizeof(comm));
3459 if ((fd = TEMP_FAILURE_RETRY(open(commpath, O_RDONLY | O_CLOEXEC))) < 0) {
3460 strcpy(comm, "N/A");
3461 } else {
3462 char *c;
3463 TEMP_FAILURE_RETRY(read(fd, comm, sizeof(comm) - 2));
3464 close(fd);
3465
3466 c = strrchr(comm, '\n');
3467 if (c) {
3468 *c = '\0';
3469 }
3470 }
3471 func(pid, tid, comm);
3472 }
3473
3474 closedir(d);
3475}
3476
3477void for_each_tid(for_each_tid_func func, const char *header) {
3478 std::string title = header == nullptr ? "for_each_tid"
3479 : android::base::StringPrintf("for_each_tid(%s)", header);
3480 DurationReporter duration_reporter(title);
3481
3482 if (PropertiesHelper::IsDryRun()) return;
3483
3484 __for_each_pid(for_each_tid_helper, header, (void *) func);
3485}
3486
3487void show_wchan(int pid, int tid, const char *name) {
3488 if (PropertiesHelper::IsDryRun()) return;
3489
3490 char path[255];
3491 char buffer[255];
3492 int fd, ret, save_errno;
3493 char name_buffer[255];
3494
3495 memset(buffer, 0, sizeof(buffer));
3496
3497 snprintf(path, sizeof(path), "/proc/%d/wchan", tid);
3498 if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) {
3499 printf("Failed to open '%s' (%s)\n", path, strerror(errno));
3500 return;
3501 }
3502
3503 ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
3504 save_errno = errno;
3505 close(fd);
3506
3507 if (ret < 0) {
3508 printf("Failed to read '%s' (%s)\n", path, strerror(save_errno));
3509 return;
3510 }
3511
3512 snprintf(name_buffer, sizeof(name_buffer), "%*s%s",
3513 pid == tid ? 0 : 3, "", name);
3514
3515 printf("%-7d %-32s %s\n", tid, name_buffer, buffer);
3516
3517 return;
3518}
3519
3520// print time in centiseconds
3521static void snprcent(char *buffer, size_t len, size_t spc,
3522 unsigned long long time) {
3523 static long hz; // cache discovered hz
3524
3525 if (hz <= 0) {
3526 hz = sysconf(_SC_CLK_TCK);
3527 if (hz <= 0) {
3528 hz = 1000;
3529 }
3530 }
3531
3532 // convert to centiseconds
3533 time = (time * 100 + (hz / 2)) / hz;
3534
3535 char str[16];
3536
3537 snprintf(str, sizeof(str), " %llu.%02u",
3538 time / 100, (unsigned)(time % 100));
3539 size_t offset = strlen(buffer);
3540 snprintf(buffer + offset, (len > offset) ? len - offset : 0,
3541 "%*s", (spc > offset) ? (int)(spc - offset) : 0, str);
3542}
3543
3544// print permille as a percent
3545static void snprdec(char *buffer, size_t len, size_t spc, unsigned permille) {
3546 char str[16];
3547
3548 snprintf(str, sizeof(str), " %u.%u%%", permille / 10, permille % 10);
3549 size_t offset = strlen(buffer);
3550 snprintf(buffer + offset, (len > offset) ? len - offset : 0,
3551 "%*s", (spc > offset) ? (int)(spc - offset) : 0, str);
3552}
3553
3554void show_showtime(int pid, const char *name) {
3555 if (PropertiesHelper::IsDryRun()) return;
3556
3557 char path[255];
3558 char buffer[1023];
3559 int fd, ret, save_errno;
3560
3561 memset(buffer, 0, sizeof(buffer));
3562
3563 snprintf(path, sizeof(path), "/proc/%d/stat", pid);
3564 if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) {
3565 printf("Failed to open '%s' (%s)\n", path, strerror(errno));
3566 return;
3567 }
3568
3569 ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
3570 save_errno = errno;
3571 close(fd);
3572
3573 if (ret < 0) {
3574 printf("Failed to read '%s' (%s)\n", path, strerror(save_errno));
3575 return;
3576 }
3577
3578 // field 14 is utime
3579 // field 15 is stime
3580 // field 42 is iotime
3581 unsigned long long utime = 0, stime = 0, iotime = 0;
3582 if (sscanf(buffer,
3583 "%*u %*s %*s %*d %*d %*d %*d %*d %*d %*d %*d "
3584 "%*d %*d %llu %llu %*d %*d %*d %*d %*d %*d "
3585 "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
3586 "%*d %*d %*d %*d %*d %*d %*d %*d %*d %llu ",
3587 &utime, &stime, &iotime) != 3) {
3588 return;
3589 }
3590
3591 unsigned long long total = utime + stime;
3592 if (!total) {
3593 return;
3594 }
3595
3596 unsigned permille = (iotime * 1000 + (total / 2)) / total;
3597 if (permille > 1000) {
3598 permille = 1000;
3599 }
3600
3601 // try to beautify and stabilize columns at <80 characters
3602 snprintf(buffer, sizeof(buffer), "%-6d%s", pid, name);
3603 if ((name[0] != '[') || utime) {
3604 snprcent(buffer, sizeof(buffer), 57, utime);
3605 }
3606 snprcent(buffer, sizeof(buffer), 65, stime);
3607 if ((name[0] != '[') || iotime) {
3608 snprcent(buffer, sizeof(buffer), 73, iotime);
3609 }
3610 if (iotime) {
3611 snprdec(buffer, sizeof(buffer), 79, permille);
3612 }
3613 puts(buffer); // adds a trailing newline
3614
3615 return;
3616}
3617
3618void do_dmesg() {
3619 const char *title = "KERNEL LOG (dmesg)";
3620 DurationReporter duration_reporter(title);
3621 printf("------ %s ------\n", title);
3622
3623 if (PropertiesHelper::IsDryRun()) return;
3624
3625 /* Get size of kernel buffer */
3626 int size = klogctl(KLOG_SIZE_BUFFER, nullptr, 0);
3627 if (size <= 0) {
3628 printf("Unexpected klogctl return value: %d\n\n", size);
3629 return;
3630 }
3631 char *buf = (char *) malloc(size + 1);
3632 if (buf == nullptr) {
3633 printf("memory allocation failed\n\n");
3634 return;
3635 }
3636 int retval = klogctl(KLOG_READ_ALL, buf, size);
3637 if (retval < 0) {
3638 printf("klogctl failure\n\n");
3639 free(buf);
3640 return;
3641 }
3642 buf[retval] = '\0';
3643 printf("%s\n\n", buf);
3644 free(buf);
3645 return;
3646}
3647
3648void do_showmap(int pid, const char *name) {
3649 char title[255];
3650 char arg[255];
3651
3652 snprintf(title, sizeof(title), "SHOW MAP %d (%s)", pid, name);
3653 snprintf(arg, sizeof(arg), "%d", pid);
3654 RunCommand(title, {"showmap", "-q", arg}, CommandOptions::AS_ROOT);
3655}
3656
3657int Dumpstate::DumpFile(const std::string& title, const std::string& path) {
3658 DurationReporter duration_reporter(title);
3659
3660 int status = DumpFileToFd(STDOUT_FILENO, title, path);
3661
3662 UpdateProgress(WEIGHT_FILE);
3663
3664 return status;
3665}
3666
3667int read_file_as_long(const char *path, long int *output) {
3668 int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC));
3669 if (fd < 0) {
3670 int err = errno;
3671 MYLOGE("Error opening file descriptor for %s: %s\n", path, strerror(err));
3672 return -1;
3673 }
3674 char buffer[50];
3675 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
3676 if (bytes_read == -1) {
3677 MYLOGE("Error reading file %s: %s\n", path, strerror(errno));
3678 return -2;
3679 }
3680 if (bytes_read == 0) {
3681 MYLOGE("File %s is empty\n", path);
3682 return -3;
3683 }
3684 *output = atoi(buffer);
3685 return 0;
3686}
3687
3688/* calls skip to gate calling dump_from_fd recursively
3689 * in the specified directory. dump_from_fd defaults to
3690 * dump_file_from_fd above when set to NULL. skip defaults
3691 * to false when set to NULL. dump_from_fd will always be
3692 * called with title NULL.
3693 */
3694int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path),
3695 int (*dump_from_fd)(const char* title, const char* path, int fd)) {
3696 DurationReporter duration_reporter(title);
3697 DIR *dirp;
3698 struct dirent *d;
3699 char *newpath = nullptr;
3700 const char *slash = "/";
3701 int retval = 0;
3702
3703 if (!title.empty()) {
3704 printf("------ %s (%s) ------\n", title.c_str(), dir);
3705 }
3706 if (PropertiesHelper::IsDryRun()) return 0;
3707
3708 if (dir[strlen(dir) - 1] == '/') {
3709 ++slash;
3710 }
3711 dirp = opendir(dir);
3712 if (dirp == nullptr) {
3713 retval = -errno;
3714 MYLOGE("%s: %s\n", dir, strerror(errno));
3715 return retval;
3716 }
3717
3718 if (!dump_from_fd) {
3719 dump_from_fd = dump_file_from_fd;
3720 }
3721 for (; ((d = readdir(dirp))); free(newpath), newpath = nullptr) {
3722 if ((d->d_name[0] == '.')
3723 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
3724 || (d->d_name[1] == '\0'))) {
3725 continue;
3726 }
3727 asprintf(&newpath, "%s%s%s%s", dir, slash, d->d_name,
3728 (d->d_type == DT_DIR) ? "/" : "");
3729 if (!newpath) {
3730 retval = -errno;
3731 continue;
3732 }
3733 if (skip && (*skip)(newpath)) {
3734 continue;
3735 }
3736 if (d->d_type == DT_DIR) {
3737 int ret = dump_files("", newpath, skip, dump_from_fd);
3738 if (ret < 0) {
3739 retval = ret;
3740 }
3741 continue;
3742 }
3743 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(newpath, O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
3744 if (fd.get() < 0) {
3745 retval = -1;
3746 printf("*** %s: %s\n", newpath, strerror(errno));
3747 continue;
3748 }
3749 (*dump_from_fd)(nullptr, newpath, fd.get());
3750 }
3751 closedir(dirp);
3752 if (!title.empty()) {
3753 printf("\n");
3754 }
3755 return retval;
3756}
3757
3758/* fd must have been opened with the flag O_NONBLOCK. With this flag set,
3759 * it's possible to avoid issues where opening the file itself can get
3760 * stuck.
3761 */
3762int dump_file_from_fd(const char *title, const char *path, int fd) {
3763 if (PropertiesHelper::IsDryRun()) return 0;
3764
3765 int flags = fcntl(fd, F_GETFL);
3766 if (flags == -1) {
3767 printf("*** %s: failed to get flags on fd %d: %s\n", path, fd, strerror(errno));
3768 return -1;
3769 } else if (!(flags & O_NONBLOCK)) {
3770 printf("*** %s: fd must have O_NONBLOCK set.\n", path);
3771 return -1;
3772 }
3773 return DumpFileFromFdToFd(title, path, fd, STDOUT_FILENO, PropertiesHelper::IsDryRun());
3774}
3775
3776int Dumpstate::RunCommand(const std::string& title, const std::vector<std::string>& full_command,
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08003777 const CommandOptions& options, bool verbose_duration, int out_fd) {
3778 DurationReporter duration_reporter(title, false /* logcat_only */,
3779 verbose_duration, out_fd);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003780
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08003781 int status = RunCommandToFd(out_fd, title, full_command, options);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003782
3783 /* TODO: for now we're simplifying the progress calculation by using the
3784 * timeout as the weight. It's a good approximation for most cases, except when calling dumpsys,
3785 * where its weight should be much higher proportionally to its timeout.
3786 * Ideally, it should use a options.EstimatedDuration() instead...*/
3787 UpdateProgress(options.Timeout());
3788
3789 return status;
3790}
3791
3792void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
Rhed Jaoe017f982020-07-21 17:58:41 +08003793 const CommandOptions& options, long dumpsysTimeoutMs, int out_fd) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003794 long timeout_ms = dumpsysTimeoutMs > 0 ? dumpsysTimeoutMs : options.TimeoutInMs();
3795 std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-T", std::to_string(timeout_ms)};
3796 dumpsys.insert(dumpsys.end(), dumpsys_args.begin(), dumpsys_args.end());
Rhed Jaoe017f982020-07-21 17:58:41 +08003797 RunCommand(title, dumpsys, options, false, out_fd);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003798}
3799
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003800static int open_socket(const char* service) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003801 int s = android_get_control_socket(service);
3802 if (s < 0) {
3803 MYLOGE("android_get_control_socket(%s): %s\n", service, strerror(errno));
3804 return -1;
3805 }
3806 fcntl(s, F_SETFD, FD_CLOEXEC);
3807
3808 // Set backlog to 0 to make sure that queue size will be minimum.
3809 // In Linux, because the minimum queue will be 1, connect() will be blocked
3810 // if the other clients already called connect() and the connection request was not accepted.
3811 if (listen(s, 0) < 0) {
3812 MYLOGE("listen(control socket): %s\n", strerror(errno));
3813 return -1;
3814 }
3815
3816 struct sockaddr addr;
3817 socklen_t alen = sizeof(addr);
Abhijeet Kaur2113cae2019-09-13 09:24:15 +01003818 int fd = accept4(s, &addr, &alen, SOCK_CLOEXEC);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003819
3820 // Close socket just after accept(), to make sure that connect() by client will get error
3821 // when the socket is used by the other services.
3822 // There is still a race condition possibility between accept and close, but there is no way
3823 // to close-on-accept atomically.
3824 // See detail; b/123306389#comment25
3825 close(s);
3826
3827 if (fd < 0) {
3828 MYLOGE("accept(control socket): %s\n", strerror(errno));
3829 return -1;
3830 }
3831
3832 return fd;
3833}
3834
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003835// TODO: should call is_valid_output_file and/or be merged into it.
3836void create_parent_dirs(const char *path) {
3837 char *chp = const_cast<char *> (path);
3838
3839 /* skip initial slash */
3840 if (chp[0] == '/')
3841 chp++;
3842
3843 /* create leading directories, if necessary */
3844 struct stat dir_stat;
3845 while (chp && chp[0]) {
3846 chp = strchr(chp, '/');
3847 if (chp) {
3848 *chp = 0;
3849 if (stat(path, &dir_stat) == -1 || !S_ISDIR(dir_stat.st_mode)) {
3850 MYLOGI("Creating directory %s\n", path);
3851 if (mkdir(path, 0770)) { /* drwxrwx--- */
3852 MYLOGE("Unable to create directory %s: %s\n", path, strerror(errno));
3853 } else if (chown(path, AID_SHELL, AID_SHELL)) {
3854 MYLOGE("Unable to change ownership of dir %s: %s\n", path, strerror(errno));
3855 }
3856 }
3857 *chp++ = '/';
3858 }
3859 }
3860}
3861
3862bool _redirect_to_file(FILE* redirect, char* path, int truncate_flag) {
3863 create_parent_dirs(path);
3864
3865 int fd = TEMP_FAILURE_RETRY(open(path,
3866 O_WRONLY | O_CREAT | truncate_flag | O_CLOEXEC | O_NOFOLLOW,
3867 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
3868 if (fd < 0) {
3869 MYLOGE("%s: %s\n", path, strerror(errno));
3870 return false;
3871 }
3872
3873 TEMP_FAILURE_RETRY(dup2(fd, fileno(redirect)));
3874 close(fd);
3875 return true;
3876}
3877
3878bool redirect_to_file(FILE* redirect, char* path) {
3879 return _redirect_to_file(redirect, path, O_TRUNC);
3880}
3881
3882bool redirect_to_existing_file(FILE* redirect, char* path) {
3883 return _redirect_to_file(redirect, path, O_APPEND);
3884}
3885
3886void dump_route_tables() {
3887 DurationReporter duration_reporter("DUMP ROUTE TABLES");
3888 if (PropertiesHelper::IsDryRun()) return;
3889 const char* const RT_TABLES_PATH = "/data/misc/net/rt_tables";
3890 ds.DumpFile("RT_TABLES", RT_TABLES_PATH);
3891 FILE* fp = fopen(RT_TABLES_PATH, "re");
3892 if (!fp) {
3893 printf("*** %s: %s\n", RT_TABLES_PATH, strerror(errno));
3894 return;
3895 }
3896 char table[16];
3897 // Each line has an integer (the table number), a space, and a string (the table name). We only
3898 // need the table number. It's a 32-bit unsigned number, so max 10 chars. Skip the table name.
3899 // Add a fixed max limit so this doesn't go awry.
3900 for (int i = 0; i < 64 && fscanf(fp, " %10s %*s", table) == 1; ++i) {
3901 RunCommand("ROUTE TABLE IPv4", {"ip", "-4", "route", "show", "table", table});
3902 RunCommand("ROUTE TABLE IPv6", {"ip", "-6", "route", "show", "table", table});
3903 }
3904 fclose(fp);
3905}
3906
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003907void Dumpstate::UpdateProgress(int32_t delta_sec) {
3908 if (progress_ == nullptr) {
3909 MYLOGE("UpdateProgress: progress_ not set\n");
3910 return;
3911 }
Rhed Jaobf63d8a2020-07-21 15:42:55 +08003912 // This function updates progress related members of the dumpstate and reports
3913 // progress percentage to the bugreport client. Since it could be called by
3914 // different dump tasks at the same time if the parallel run is enabled, a
3915 // mutex lock is necessary here to synchronize the call.
3916 std::lock_guard<std::recursive_mutex> lock(mutex_);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003917
3918 // Always update progess so stats can be tuned...
Nandana Dutt402a8392019-06-14 14:25:13 +01003919 progress_->Inc(delta_sec);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003920
3921 // ...but only notifiy listeners when necessary.
3922 if (!options_->do_progress_updates) return;
3923
3924 int progress = progress_->Get();
3925 int max = progress_->GetMax();
Nandana Dutt402a8392019-06-14 14:25:13 +01003926 int percent = 100 * progress / max;
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003927
Nandana Dutt402a8392019-06-14 14:25:13 +01003928 if (last_reported_percent_progress_ > 0 && percent <= last_reported_percent_progress_) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003929 return;
3930 }
Nandana Dutt402a8392019-06-14 14:25:13 +01003931 last_reported_percent_progress_ = percent;
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003932
3933 if (control_socket_fd_ >= 0) {
3934 dprintf(control_socket_fd_, "PROGRESS:%d/%d\n", progress, max);
3935 fsync(control_socket_fd_);
3936 }
3937
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003938 if (listener_ != nullptr) {
Nandana Dutt235c6672019-11-14 15:22:32 +00003939 if (percent % 10 == 0) {
3940 // We don't want to spam logcat, so only log multiples of 10.
Abhijeet Kaured5d6a62019-10-07 15:02:05 +01003941 MYLOGD("Setting progress: %d/%d (%d%%)\n", progress, max, percent);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003942 } else {
3943 // stderr is ignored on normal invocations, but useful when calling
3944 // /system/bin/dumpstate directly for debuggging.
Abhijeet Kaured5d6a62019-10-07 15:02:05 +01003945 fprintf(stderr, "Setting progress: %d/%d (%d%%)\n", progress, max, percent);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003946 }
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003947
3948 listener_->onProgress(percent);
3949 }
3950}
3951
3952void Dumpstate::TakeScreenshot(const std::string& path) {
3953 const std::string& real_path = path.empty() ? screenshot_path_ : path;
3954 int status =
3955 RunCommand("", {"/system/bin/screencap", "-p", real_path},
3956 CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build());
3957 if (status == 0) {
3958 MYLOGD("Screenshot saved on %s\n", real_path.c_str());
3959 } else {
3960 MYLOGE("Failed to take screenshot on %s\n", real_path.c_str());
3961 }
Paul Chang0d2aad72020-02-13 20:04:03 +08003962 if (listener_ != nullptr) {
3963 // Show a visual indication to indicate screenshot is taken via
3964 // IDumpstateListener.onScreenshotTaken()
3965 listener_->onScreenshotTaken(status == 0);
3966 }
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003967}
3968
3969bool is_dir(const char* pathname) {
3970 struct stat info;
3971 if (stat(pathname, &info) == -1) {
3972 return false;
3973 }
3974 return S_ISDIR(info.st_mode);
3975}
3976
3977time_t get_mtime(int fd, time_t default_mtime) {
3978 struct stat info;
3979 if (fstat(fd, &info) == -1) {
3980 return default_mtime;
3981 }
3982 return info.st_mtime;
3983}