blob: 4fb08c573f8b92167b322cda474cb284bcee5e65 [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"
Kevin Jeon2c02e8e2022-07-07 21:45:17 +000018#define ATRACE_TAG ATRACE_TAG_ALWAYS
Colin Crossf45fa6b2012-03-26 12:38:26 -070019
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -070020#include <dirent.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070021#include <errno.h>
22#include <fcntl.h>
Nikita Ioffea325a572019-05-16 19:49:47 +010023#include <inttypes.h>
Felipe Lemead5f6c42015-11-30 14:26:46 -080024#include <libgen.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070025#include <limits.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010026#include <math.h>
27#include <poll.h>
Mark Salyzyn8f37aa52015-06-12 12:28:24 -070028#include <stdbool.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070029#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
Hridya Valsaraju9376bfa2020-10-21 15:48:48 -070032#include <sys/mount.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080033#include <sys/poll.h>
Christopher Ferris7dc7f322014-07-22 16:08:19 -070034#include <sys/prctl.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070035#include <sys/resource.h>
36#include <sys/stat.h>
37#include <sys/time.h>
38#include <sys/wait.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010039#include <signal.h>
40#include <stdarg.h>
41#include <string.h>
42#include <sys/capability.h>
43#include <sys/inotify.h>
44#include <sys/klog.h>
45#include <time.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070046#include <unistd.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070047
48#include <chrono>
Hridya Valsarajuac582cd2019-08-05 15:39:54 -070049#include <cmath>
Abhijeet Kaurd3cca0d2019-03-25 12:04:16 +000050#include <fstream>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070051#include <functional>
52#include <future>
Narayan Kamath8f788292017-05-25 13:20:39 +010053#include <memory>
Hridya Valsarajuac582cd2019-08-05 15:39:54 -070054#include <numeric>
Narayan Kamath8f788292017-05-25 13:20:39 +010055#include <regex>
56#include <set>
57#include <string>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070058#include <utility>
Narayan Kamath8f788292017-05-25 13:20:39 +010059#include <vector>
Colin Crossf45fa6b2012-03-26 12:38:26 -070060
Kedar Chitnis9fd8c052021-11-16 09:09:22 +000061#include <aidl/android/hardware/dumpstate/IDumpstateDevice.h>
Felipe Leme96c2bbb2016-09-26 09:21:21 -070062#include <android-base/file.h>
63#include <android-base/properties.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070064#include <android-base/scopeguard.h>
Elliott Hughes9dc117c2015-12-07 14:21:50 -080065#include <android-base/stringprintf.h>
Naveen Kalla058e1e82016-10-19 21:38:44 -070066#include <android-base/strings.h>
Andreas Gampeaff68432016-07-18 18:01:27 -070067#include <android-base/unique_fd.h>
Kedar Chitnis9fd8c052021-11-16 09:09:22 +000068#include <android/binder_manager.h>
69#include <android/binder_process.h>
Nikita Ioffea325a572019-05-16 19:49:47 +010070#include <android/content/pm/IPackageManagerNative.h>
Felipe Leme6f674ae2016-11-18 17:10:33 -080071#include <android/hardware/dumpstate/1.0/IDumpstateDevice.h>
Hunter Knepshield8540faf2020-02-04 19:47:20 -080072#include <android/hardware/dumpstate/1.1/IDumpstateDevice.h>
73#include <android/hardware/dumpstate/1.1/types.h>
Steven Moreland44cd9482018-01-04 16:24:13 -080074#include <android/hidl/manager/1.0/IServiceManager.h>
Nandana Duttd2f5f082019-01-18 17:13:52 +000075#include <android/os/IIncidentCompanion.h>
Nikita Ioffea325a572019-05-16 19:49:47 +010076#include <binder/IServiceManager.h>
Felipe Leme6f674ae2016-11-18 17:10:33 -080077#include <cutils/native_handle.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070078#include <cutils/properties.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010079#include <cutils/sockets.h>
Kevin Jeon2c02e8e2022-07-07 21:45:17 +000080#include <cutils/trace.h>
Nandana Duttfaafd522019-03-11 09:23:09 +000081#include <debuggerd/client.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080082#include <dumpsys.h>
Nandana Duttfaafd522019-03-11 09:23:09 +000083#include <dumputils/dump_utils.h>
Sahana Raof35ed432019-07-12 10:47:52 +010084#include <hardware_legacy/power.h>
Steven Moreland44cd9482018-01-04 16:24:13 -080085#include <hidl/ServiceManagement.h>
Abhijeet Kaurcf234e82019-07-01 14:53:55 +010086#include <log/log.h>
Tom Cherryf4472f32020-08-05 09:31:17 -070087#include <log/log_read.h>
Felipe Leme75876a22016-10-27 16:31:27 -070088#include <openssl/sha.h>
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070089#include <private/android_filesystem_config.h>
90#include <private/android_logger.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080091#include <serviceutils/PriorityDumper.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070092#include <utils/StrongPointer.h>
Devin Moore8df81bb2022-06-08 22:47:02 +000093#include <vintf/VintfObject.h>
Felipe Lemef0292972016-11-22 13:57:05 -080094#include "DumpstateInternal.h"
Felipe Leme75876a22016-10-27 16:31:27 -070095#include "DumpstateService.h"
Colin Crossf45fa6b2012-03-26 12:38:26 -070096#include "dumpstate.h"
Felipe Leme6e01fa62015-11-11 19:35:14 -080097
Kedar Chitnis9fd8c052021-11-16 09:09:22 +000098namespace dumpstate_hal_hidl_1_0 = android::hardware::dumpstate::V1_0;
99namespace dumpstate_hal_hidl = android::hardware::dumpstate::V1_1;
100namespace dumpstate_hal_aidl = aidl::android::hardware::dumpstate;
101
Vishnu Naire97d6122018-01-18 13:58:56 -0800102using ::std::literals::chrono_literals::operator""ms;
103using ::std::literals::chrono_literals::operator""s;
Rhed Jao5377d792020-07-16 17:37:39 +0800104using ::std::placeholders::_1;
Steven Morelandcb7ef822016-11-29 13:20:37 -0800105
Felipe Leme47e9be22016-12-21 15:37:07 -0800106// TODO: remove once moved to namespace
Vishnu Naire97d6122018-01-18 13:58:56 -0800107using android::defaultServiceManager;
108using android::Dumpsys;
109using android::INVALID_OPERATION;
110using android::IServiceManager;
111using android::OK;
112using android::sp;
113using android::status_t;
114using android::String16;
115using android::String8;
116using android::TIMED_OUT;
117using android::UNKNOWN_ERROR;
118using android::Vector;
Nandana Dutt979388e2018-11-30 16:48:55 +0000119using android::base::StringPrintf;
Nandana Duttd2f5f082019-01-18 17:13:52 +0000120using android::os::IDumpstateListener;
Felipe Leme47e9be22016-12-21 15:37:07 -0800121using android::os::dumpstate::CommandOptions;
122using android::os::dumpstate::DumpFileToFd;
Rhed Jao5377d792020-07-16 17:37:39 +0800123using android::os::dumpstate::DumpPool;
Vishnu Naire97d6122018-01-18 13:58:56 -0800124using android::os::dumpstate::PropertiesHelper;
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800125using android::os::dumpstate::TaskQueue;
Chris Morinbc223142022-02-04 14:17:11 -0800126using android::os::dumpstate::WaitForTask;
Felipe Leme47e9be22016-12-21 15:37:07 -0800127
Abhijeet Kaurcf234e82019-07-01 14:53:55 +0100128// Keep in sync with
129// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
130static const int TRACE_DUMP_TIMEOUT_MS = 10000; // 10 seconds
131
132/* Most simple commands have 10 as timeout, so 5 is a good estimate */
133static const int32_t WEIGHT_FILE = 5;
134
135// TODO: temporary variables and functions used during C++ refactoring
136static Dumpstate& ds = Dumpstate::GetInstance();
137static int RunCommand(const std::string& title, const std::vector<std::string>& full_command,
Nandana Dutt8d945c02019-08-14 13:30:07 +0100138 const CommandOptions& options = CommandOptions::DEFAULT,
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800139 bool verbose_duration = false, int out_fd = STDOUT_FILENO) {
140 return ds.RunCommand(title, full_command, options, verbose_duration, out_fd);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +0100141}
142
143// Reasonable value for max stats.
144static const int STATS_MAX_N_RUNS = 1000;
145static const long STATS_MAX_AVERAGE = 100000;
146
147CommandOptions Dumpstate::DEFAULT_DUMPSYS = CommandOptions::WithTimeout(30).Build();
148
Nandana Duttd2f5f082019-01-18 17:13:52 +0000149typedef Dumpstate::ConsentCallback::ConsentResult UserConsentResult;
150
Colin Crossf45fa6b2012-03-26 12:38:26 -0700151/* read before root is shed */
152static char cmdline_buf[16384] = "(unknown)";
Yi Kong19d5c002018-07-20 13:39:55 -0700153static const char *dump_traces_path = nullptr;
Nandana Duttd2f5f082019-01-18 17:13:52 +0000154static const uint64_t USER_CONSENT_TIMEOUT_MS = 30 * 1000;
Hunter Knepshield70610fa2020-01-03 15:27:33 -0800155// Because telephony reports are significantly faster to collect (< 10 seconds vs. > 2 minutes),
156// it's often the case that they time out far too quickly for consent with such a hefty dialog for
157// the user to read. For telephony reports only, we increase the default timeout to 2 minutes to
158// roughly match full reports' durations.
159static const uint64_t TELEPHONY_REPORT_USER_CONSENT_TIMEOUT_MS = 2 * 60 * 1000;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700160
Felipe Leme1d486fe2016-10-14 18:06:47 -0700161// TODO: variables and functions below should be part of dumpstate object
162
Felipe Leme635ca312016-01-05 14:23:02 -0800163static std::set<std::string> mount_points;
164void add_mountinfo();
Felipe Leme78f2c862015-12-21 09:55:22 -0800165
Todd Poynor2a83daa2013-11-22 15:44:22 -0800166#define PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops"
Mark Salyzyn7d0a7622016-06-24 14:06:15 -0700167#define ALT_PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops-0"
Wei Wang509bb5d2017-06-09 14:42:12 -0700168#define BLK_DEV_SYS_DIR "/sys/block"
Todd Poynor2a83daa2013-11-22 15:44:22 -0800169
Felipe Lemee82a27d2016-01-05 13:35:44 -0800170#define RECOVERY_DIR "/cache/recovery"
Mark Salyzynd6ab0112016-03-25 12:56:39 -0700171#define RECOVERY_DATA_DIR "/data/misc/recovery"
Tianjie Xu75d53362018-04-11 16:42:28 -0700172#define UPDATE_ENGINE_LOG_DIR "/data/misc/update_engine_log"
Kelvin Zhang6eaa0f92022-09-12 09:29:19 -0700173#define UPDATE_ENGINE_PREF_DIR "/data/misc/update_engine/prefs"
Mark Salyzyn4d42dea2016-04-01 10:03:14 -0700174#define LOGPERSIST_DATA_DIR "/data/misc/logd"
Jerry Changa1df8a92020-01-02 16:03:39 +0800175#define PREREBOOT_DATA_DIR "/data/misc/prereboot"
David Brazdild2991962016-06-03 14:40:44 +0100176#define PROFILE_DATA_DIR_CUR "/data/misc/profiles/cur"
177#define PROFILE_DATA_DIR_REF "/data/misc/profiles/ref"
Benedict Wong8f9d8a42019-01-03 16:19:38 -0800178#define XFRM_STAT_PROC_FILE "/proc/net/xfrm_stat"
Erik Kline08165202016-05-30 11:55:44 +0900179#define WLUTIL "/vendor/xbin/wlutil"
Vishnu Nair36b4cdb2017-11-17 10:27:05 -0800180#define WMTRACE_DATA_DIR "/data/misc/wmtrace"
Yifan Hong3945e1b2019-10-29 12:59:23 -0700181#define OTA_METADATA_DIR "/metadata/ota"
Yifan Hong0efa7972020-02-03 16:45:02 -0800182#define SNAPSHOTCTL_LOG_DIR "/data/misc/snapshotctl_log"
Kiyoung Kimc2d22ac2020-02-04 19:43:36 +0900183#define LINKERCONFIG_DIR "/linkerconfig"
Calin Juravlef84d3692020-04-28 15:31:12 -0700184#define PACKAGE_DEX_USE_LIST "/data/system/package-dex-usage.list"
Primiano Tuccifaaaafb2021-01-14 12:26:29 +0000185#define SYSTEM_TRACE_SNAPSHOT "/data/misc/perfetto-traces/bugreport/systrace.pftrace"
Li Li2eedd412021-06-30 15:11:53 -0700186#define CGROUPFS_DIR "/sys/fs/cgroup"
Mårten Kongstad60195a72022-09-20 14:14:20 +0200187#define SDK_EXT_INFO "/apex/com.android.sdkext/bin/derive_sdk"
Jeff Sharkey9df29d52023-02-06 14:26:30 -0700188#define DROPBOX_DIR "/data/system/dropbox"
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700189
Narayan Kamath8f788292017-05-25 13:20:39 +0100190// TODO(narayan): Since this information has to be kept in sync
191// with tombstoned, we should just put it in a common header.
192//
193// File: system/core/debuggerd/tombstoned/tombstoned.cpp
Narayan Kamathbd863722017-06-01 18:50:12 +0100194static const std::string TOMBSTONE_DIR = "/data/tombstones/";
195static const std::string TOMBSTONE_FILE_PREFIX = "tombstone_";
196static const std::string ANR_DIR = "/data/anr/";
197static const std::string ANR_FILE_PREFIX = "anr_";
Woody Lin20767a92022-11-29 15:50:24 +0800198static const std::string SHUTDOWN_CHECKPOINTS_DIR = "/data/system/shutdown-checkpoints/";
199static const std::string SHUTDOWN_CHECKPOINTS_FILE_PREFIX = "checkpoints-";
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700200
Felipe Lemee844a9d2016-09-21 15:01:39 -0700201// TODO: temporary variables and functions used during C++ refactoring
Nandana Dutt979388e2018-11-30 16:48:55 +0000202
Nandana Dutt5c390032019-03-12 10:52:56 +0000203#define RETURN_IF_USER_DENIED_CONSENT() \
204 if (ds.IsUserConsentDenied()) { \
205 MYLOGE("Returning early as user denied consent to share bugreport with calling app."); \
206 return Dumpstate::RunStatus::USER_CONSENT_DENIED; \
207 }
208
209// Runs func_ptr, but checks user consent before and after running it. Returns USER_CONSENT_DENIED
210// if consent is found to be denied.
211#define RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(func_ptr, ...) \
212 RETURN_IF_USER_DENIED_CONSENT(); \
213 func_ptr(__VA_ARGS__); \
214 RETURN_IF_USER_DENIED_CONSENT();
215
Rhed Jao5377d792020-07-16 17:37:39 +0800216// Runs func_ptr, and logs a duration report after it's finished.
217#define RUN_SLOW_FUNCTION_AND_LOG(log_title, func_ptr, ...) \
218 { \
219 DurationReporter duration_reporter_in_macro(log_title); \
220 func_ptr(__VA_ARGS__); \
221 }
222
223// Similar with RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK, an additional duration report
224// is output after a slow function is finished.
225#define RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(log_title, func_ptr, ...) \
226 RETURN_IF_USER_DENIED_CONSENT(); \
227 RUN_SLOW_FUNCTION_AND_LOG(log_title, func_ptr, __VA_ARGS__); \
228 RETURN_IF_USER_DENIED_CONSENT();
229
Chris Morinbc223142022-02-04 14:17:11 -0800230#define WAIT_TASK_WITH_CONSENT_CHECK(future) \
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800231 RETURN_IF_USER_DENIED_CONSENT(); \
Chris Morinbc223142022-02-04 14:17:11 -0800232 WaitForTask(future); \
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800233 RETURN_IF_USER_DENIED_CONSENT();
234
Sahana Raof35ed432019-07-12 10:47:52 +0100235static const char* WAKE_LOCK_NAME = "dumpstate_wakelock";
236
Rhed Jao5377d792020-07-16 17:37:39 +0800237// Names of parallel tasks, they are used for the DumpPool to identify the dump
238// task and the log title of the duration report.
239static const std::string DUMP_TRACES_TASK = "DUMP TRACES";
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800240static const std::string DUMP_INCIDENT_REPORT_TASK = "INCIDENT REPORT";
Aaron Huanga99452a2022-04-27 18:51:16 +0800241static const std::string DUMP_NETSTATS_PROTO_TASK = "DUMP NETSTATS PROTO";
Rhed Jao3c2fdbd2020-07-20 17:46:29 +0800242static const std::string DUMP_HALS_TASK = "DUMP HALS";
243static const std::string DUMP_BOARD_TASK = "dumpstate_board()";
Rhed Jaoe017f982020-07-21 17:58:41 +0800244static const std::string DUMP_CHECKINS_TASK = "DUMP CHECKINS";
Rhed Jao5377d792020-07-16 17:37:39 +0800245
Nandana Dutt979388e2018-11-30 16:48:55 +0000246namespace android {
247namespace os {
248namespace {
249
250static int Open(std::string path, int flags, mode_t mode = 0) {
251 int fd = TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode));
252 if (fd == -1) {
253 MYLOGE("open(%s, %s)\n", path.c_str(), strerror(errno));
254 }
255 return fd;
256}
257
mhasank2d75c442020-06-11 15:05:25 -0700258static int OpenForWrite(std::string path) {
259 return Open(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
260 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
261}
Nandana Dutt979388e2018-11-30 16:48:55 +0000262
263static int OpenForRead(std::string path) {
264 return Open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
265}
266
267bool CopyFile(int in_fd, int out_fd) {
268 char buf[4096];
269 ssize_t byte_count;
270 while ((byte_count = TEMP_FAILURE_RETRY(read(in_fd, buf, sizeof(buf)))) > 0) {
271 if (!android::base::WriteFully(out_fd, buf, byte_count)) {
272 return false;
273 }
274 }
275 return (byte_count != -1);
276}
277
278static bool CopyFileToFd(const std::string& input_file, int out_fd) {
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000279 MYLOGD("Going to copy file (%s) to %d\n", input_file.c_str(), out_fd);
Nandana Dutt979388e2018-11-30 16:48:55 +0000280
281 // Obtain a handle to the source file.
282 android::base::unique_fd in_fd(OpenForRead(input_file));
283 if (out_fd != -1 && in_fd.get() != -1) {
284 if (CopyFile(in_fd.get(), out_fd)) {
285 return true;
286 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000287 MYLOGE("Failed to copy file: %s\n", strerror(errno));
Nandana Dutt979388e2018-11-30 16:48:55 +0000288 }
289 return false;
290}
291
Nandana Duttd2f5f082019-01-18 17:13:52 +0000292static bool UnlinkAndLogOnError(const std::string& file) {
Nandana Dutt8ae16e62020-03-27 10:20:22 +0000293 if (file.empty()) {
294 return false;
295 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000296 if (unlink(file.c_str())) {
297 MYLOGE("Failed to unlink file (%s): %s\n", file.c_str(), strerror(errno));
Nandana Duttd2f5f082019-01-18 17:13:52 +0000298 return false;
299 }
300 return true;
301}
Nandana Dutt979388e2018-11-30 16:48:55 +0000302
Nikita Ioffea325a572019-05-16 19:49:47 +0100303int64_t GetModuleMetadataVersion() {
304 auto binder = defaultServiceManager()->getService(android::String16("package_native"));
305 if (binder == nullptr) {
306 MYLOGE("Failed to retrieve package_native service");
307 return 0L;
308 }
309 auto package_service = android::interface_cast<content::pm::IPackageManagerNative>(binder);
310 std::string package_name;
311 auto status = package_service->getModuleMetadataPackageName(&package_name);
312 if (!status.isOk()) {
313 MYLOGE("Failed to retrieve module metadata package name: %s", status.toString8().c_str());
314 return 0L;
315 }
Nandana Duttdb379fa2019-10-09 16:54:41 +0100316 MYLOGD("Module metadata package name: %s\n", package_name.c_str());
Nikita Ioffea325a572019-05-16 19:49:47 +0100317 int64_t version_code;
318 status = package_service->getVersionCodeForPackage(android::String16(package_name.c_str()),
319 &version_code);
320 if (!status.isOk()) {
321 MYLOGE("Failed to retrieve module metadata version: %s", status.toString8().c_str());
322 return 0L;
323 }
324 return version_code;
325}
326
mhasank2d75c442020-06-11 15:05:25 -0700327static bool PathExists(const std::string& path) {
328 struct stat sb;
329 return stat(path.c_str(), &sb) == 0;
330}
331
332static bool CopyFileToFile(const std::string& input_file, const std::string& output_file) {
333 if (input_file == output_file) {
334 MYLOGD("Skipping copying bugreport file since the destination is the same (%s)\n",
335 output_file.c_str());
336 return false;
337 }
338 else if (PathExists(output_file)) {
339 MYLOGD("Cannot overwrite an existing file (%s)\n", output_file.c_str());
340 return false;
341 }
342
343 MYLOGD("Going to copy bugreport file (%s) to %s\n", input_file.c_str(), output_file.c_str());
344 android::base::unique_fd out_fd(OpenForWrite(output_file));
345 return CopyFileToFd(input_file, out_fd.get());
346}
347
Nandana Dutt979388e2018-11-30 16:48:55 +0000348} // namespace
349} // namespace os
350} // namespace android
351
Felipe Leme678727a2016-09-21 17:22:11 -0700352static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
Felipe Lemebda15a02016-11-16 17:48:25 -0800353 const CommandOptions& options = Dumpstate::DEFAULT_DUMPSYS,
Rhed Jaoe017f982020-07-21 17:58:41 +0800354 long dumpsysTimeoutMs = 0, int out_fd = STDOUT_FILENO) {
355 return ds.RunDumpsys(title, dumpsysArgs, options, dumpsysTimeoutMs, out_fd);
356}
357static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
358 int out_fd) {
359 return ds.RunDumpsys(title, dumpsysArgs, Dumpstate::DEFAULT_DUMPSYS, 0, out_fd);
Felipe Leme678727a2016-09-21 17:22:11 -0700360}
361static int DumpFile(const std::string& title, const std::string& path) {
362 return ds.DumpFile(title, path);
363}
Felipe Lemee82a27d2016-01-05 13:35:44 -0800364
Felipe Lemee844a9d2016-09-21 15:01:39 -0700365// Relative directory (inside the zip) for all files copied as-is into the bugreport.
366static const std::string ZIP_ROOT_DIR = "FS";
367
Vishnu Naire97d6122018-01-18 13:58:56 -0800368static const std::string kProtoPath = "proto/";
369static const std::string kProtoExt = ".proto";
Jie Song9fbfad02017-06-20 16:29:42 -0700370static const std::string kDumpstateBoardFiles[] = {
371 "dumpstate_board.txt",
Felipe Leme95d6ca52017-08-01 16:35:56 -0700372 "dumpstate_board.bin"
Jie Song9fbfad02017-06-20 16:29:42 -0700373};
374static const int NUM_OF_DUMPS = arraysize(kDumpstateBoardFiles);
375
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700376static constexpr char PROPERTY_LAST_ID[] = "dumpstate.last_id";
Felipe Lemed071c682016-10-20 16:48:00 -0700377static constexpr char PROPERTY_VERSION[] = "dumpstate.version";
Felipe Leme9ce6aa42016-09-21 10:02:25 -0700378
Felipe Lemef0292972016-11-22 13:57:05 -0800379static const CommandOptions AS_ROOT_20 = CommandOptions::WithTimeout(20).AsRoot().Build();
380
Narayan Kamath8f788292017-05-25 13:20:39 +0100381/*
Narayan Kamathbd863722017-06-01 18:50:12 +0100382 * Returns a vector of dump fds under |dir_path| with a given |file_prefix|.
Rhed Jao01dc0c62020-06-03 17:13:30 +0800383 * The returned vector is sorted by the mtimes of the dumps with descending
Chris Morinc2cba7a2022-02-01 17:06:50 -0800384 * order.
Narayan Kamath8f788292017-05-25 13:20:39 +0100385 */
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700386static std::vector<DumpData> GetDumpFds(const std::string& dir_path,
Chris Morinc2cba7a2022-02-01 17:06:50 -0800387 const std::string& file_prefix) {
Narayan Kamathbd863722017-06-01 18:50:12 +0100388 std::unique_ptr<DIR, decltype(&closedir)> dump_dir(opendir(dir_path.c_str()), closedir);
Narayan Kamath8f788292017-05-25 13:20:39 +0100389
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700390 if (dump_dir == nullptr) {
391 MYLOGW("Unable to open directory %s: %s\n", dir_path.c_str(), strerror(errno));
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700392 return std::vector<DumpData>();
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700393 }
394
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700395 std::vector<DumpData> dump_data;
Narayan Kamathbd863722017-06-01 18:50:12 +0100396 struct dirent* entry = nullptr;
397 while ((entry = readdir(dump_dir.get()))) {
398 if (entry->d_type != DT_REG) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100399 continue;
400 }
401
Narayan Kamathbd863722017-06-01 18:50:12 +0100402 const std::string base_name(entry->d_name);
403 if (base_name.find(file_prefix) != 0) {
404 continue;
405 }
406
407 const std::string abs_path = dir_path + base_name;
408 android::base::unique_fd fd(
409 TEMP_FAILURE_RETRY(open(abs_path.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK)));
410 if (fd == -1) {
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700411 MYLOGW("Unable to open dump file %s: %s\n", abs_path.c_str(), strerror(errno));
Narayan Kamathbd863722017-06-01 18:50:12 +0100412 break;
413 }
414
415 struct stat st = {};
416 if (fstat(fd, &st) == -1) {
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700417 MYLOGW("Unable to stat dump file %s: %s\n", abs_path.c_str(), strerror(errno));
Narayan Kamath8f788292017-05-25 13:20:39 +0100418 continue;
419 }
420
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700421 dump_data.emplace_back(DumpData{abs_path, std::move(fd), st.st_mtime});
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700422 }
Rhed Jao01dc0c62020-06-03 17:13:30 +0800423 if (!dump_data.empty()) {
424 std::sort(dump_data.begin(), dump_data.end(),
425 [](const auto& a, const auto& b) { return a.mtime > b.mtime; });
426 }
Narayan Kamath8f788292017-05-25 13:20:39 +0100427
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700428 return dump_data;
Narayan Kamath8f788292017-05-25 13:20:39 +0100429}
430
Narayan Kamathbd863722017-06-01 18:50:12 +0100431static bool AddDumps(const std::vector<DumpData>::const_iterator start,
432 const std::vector<DumpData>::const_iterator end,
433 const char* type_name, const bool add_to_zip) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100434 bool dumped = false;
Narayan Kamathbd863722017-06-01 18:50:12 +0100435 for (auto it = start; it != end; ++it) {
436 const std::string& name = it->name;
437 const int fd = it->fd;
Narayan Kamath8f788292017-05-25 13:20:39 +0100438 dumped = true;
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100439
440 // Seek to the beginning of the file before dumping any data. A given
441 // DumpData entry might be dumped multiple times in the report.
442 //
443 // For example, the most recent ANR entry is dumped to the body of the
444 // main entry and it also shows up as a separate entry in the bugreport
445 // ZIP file.
446 if (lseek(fd, 0, SEEK_SET) != static_cast<off_t>(0)) {
447 MYLOGE("Unable to add %s to zip file, lseek failed: %s\n", name.c_str(),
448 strerror(errno));
449 }
450
Chris Morinc2cba7a2022-02-01 17:06:50 -0800451 if (add_to_zip) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800452 if (ds.AddZipEntryFromFd(ZIP_ROOT_DIR + name, fd, /* timeout = */ 0ms) != OK) {
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100453 MYLOGE("Unable to add %s to zip file, addZipEntryFromFd failed\n", name.c_str());
Narayan Kamath8f788292017-05-25 13:20:39 +0100454 }
455 } else {
456 dump_file_from_fd(type_name, name.c_str(), fd);
457 }
Narayan Kamath8f788292017-05-25 13:20:39 +0100458 }
459
460 return dumped;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700461}
462
Felipe Leme635ca312016-01-05 14:23:02 -0800463// for_each_pid() callback to get mount info about a process.
Felipe Leme4c2d6632016-09-28 14:32:00 -0700464void do_mountinfo(int pid, const char* name __attribute__((unused))) {
Felipe Leme635ca312016-01-05 14:23:02 -0800465 char path[PATH_MAX];
466
467 // Gets the the content of the /proc/PID/ns/mnt link, so only unique mount points
468 // are added.
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700469 snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800470 char linkname[PATH_MAX];
471 ssize_t r = readlink(path, linkname, PATH_MAX);
472 if (r == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800473 MYLOGE("Unable to read link for %s: %s\n", path, strerror(errno));
Felipe Leme635ca312016-01-05 14:23:02 -0800474 return;
475 }
476 linkname[r] = '\0';
477
478 if (mount_points.find(linkname) == mount_points.end()) {
479 // First time this mount point was found: add it
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700480 snprintf(path, sizeof(path), "/proc/%d/mountinfo", pid);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700481 if (ds.AddZipEntry(ZIP_ROOT_DIR + path, path)) {
Felipe Leme635ca312016-01-05 14:23:02 -0800482 mount_points.insert(linkname);
483 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800484 MYLOGE("Unable to add mountinfo %s to zip file\n", path);
Felipe Leme635ca312016-01-05 14:23:02 -0800485 }
486 }
487}
488
489void add_mountinfo() {
Felipe Leme678727a2016-09-21 17:22:11 -0700490 std::string title = "MOUNT INFO";
Felipe Leme635ca312016-01-05 14:23:02 -0800491 mount_points.clear();
Felipe Leme46b85da2016-11-21 17:40:45 -0800492 DurationReporter duration_reporter(title, true);
Felipe Leme678727a2016-09-21 17:22:11 -0700493 for_each_pid(do_mountinfo, nullptr);
494 MYLOGD("%s: %d entries added to zip file\n", title.c_str(), (int)mount_points.size());
Felipe Leme635ca312016-01-05 14:23:02 -0800495}
496
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700497static void dump_dev_files(const char *title, const char *driverpath, const char *filename)
498{
499 DIR *d;
500 struct dirent *de;
501 char path[PATH_MAX];
502
503 d = opendir(driverpath);
Yi Kong19d5c002018-07-20 13:39:55 -0700504 if (d == nullptr) {
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700505 return;
506 }
507
508 while ((de = readdir(d))) {
509 if (de->d_type != DT_LNK) {
510 continue;
511 }
512 snprintf(path, sizeof(path), "%s/%s/%s", driverpath, de->d_name, filename);
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700513 DumpFile(title, path);
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700514 }
515
516 closedir(d);
517}
518
Mark Salyzyn326842f2015-04-30 09:49:41 -0700519static bool skip_not_stat(const char *path) {
520 static const char stat[] = "/stat";
521 size_t len = strlen(path);
522 if (path[len - 1] == '/') { /* Directory? */
523 return false;
524 }
525 return strcmp(path + len - sizeof(stat) + 1, stat); /* .../stat? */
526}
527
Jeff Sharkey9df29d52023-02-06 14:26:30 -0700528static bool skip_wtf_strictmode(const char *path) {
529 if (strstr(path, "_wtf")) {
530 return true;
531 } else if (strstr(path, "_strictmode")) {
532 return true;
533 }
534 return false;
535}
536
Felipe Leme4c2d6632016-09-28 14:32:00 -0700537static bool skip_none(const char* path __attribute__((unused))) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800538 return false;
539}
540
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700541unsigned long worst_write_perf = 20000; /* in KB/s */
Mark Salyzyn326842f2015-04-30 09:49:41 -0700542
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800543//
544// stat offsets
545// Name units description
546// ---- ----- -----------
547// read I/Os requests number of read I/Os processed
548#define __STAT_READ_IOS 0
549// read merges requests number of read I/Os merged with in-queue I/O
550#define __STAT_READ_MERGES 1
551// read sectors sectors number of sectors read
552#define __STAT_READ_SECTORS 2
553// read ticks milliseconds total wait time for read requests
554#define __STAT_READ_TICKS 3
555// write I/Os requests number of write I/Os processed
556#define __STAT_WRITE_IOS 4
557// write merges requests number of write I/Os merged with in-queue I/O
558#define __STAT_WRITE_MERGES 5
559// write sectors sectors number of sectors written
560#define __STAT_WRITE_SECTORS 6
561// write ticks milliseconds total wait time for write requests
562#define __STAT_WRITE_TICKS 7
563// in_flight requests number of I/Os currently in flight
564#define __STAT_IN_FLIGHT 8
565// io_ticks milliseconds total time this block device has been active
566#define __STAT_IO_TICKS 9
567// time_in_queue milliseconds total wait time for all requests
568#define __STAT_IN_QUEUE 10
569#define __STAT_NUMBER_FIELD 11
570//
571// read I/Os, write I/Os
572// =====================
573//
574// These values increment when an I/O request completes.
575//
576// read merges, write merges
577// =========================
578//
579// These values increment when an I/O request is merged with an
580// already-queued I/O request.
581//
582// read sectors, write sectors
583// ===========================
584//
585// These values count the number of sectors read from or written to this
586// block device. The "sectors" in question are the standard UNIX 512-byte
587// sectors, not any device- or filesystem-specific block size. The
588// counters are incremented when the I/O completes.
589#define SECTOR_SIZE 512
590//
591// read ticks, write ticks
592// =======================
593//
594// These values count the number of milliseconds that I/O requests have
595// waited on this block device. If there are multiple I/O requests waiting,
596// these values will increase at a rate greater than 1000/second; for
597// example, if 60 read requests wait for an average of 30 ms, the read_ticks
598// field will increase by 60*30 = 1800.
599//
600// in_flight
601// =========
602//
603// This value counts the number of I/O requests that have been issued to
604// the device driver but have not yet completed. It does not include I/O
605// requests that are in the queue but not yet issued to the device driver.
606//
607// io_ticks
608// ========
609//
610// This value counts the number of milliseconds during which the device has
611// had I/O requests queued.
612//
613// time_in_queue
614// =============
615//
616// This value counts the number of milliseconds that I/O requests have waited
617// on this block device. If there are multiple I/O requests waiting, this
618// value will increase as the product of the number of milliseconds times the
619// number of requests waiting (see "read ticks" above for an example).
620#define S_TO_MS 1000
621//
622
Mark Salyzyn326842f2015-04-30 09:49:41 -0700623static int dump_stat_from_fd(const char *title __unused, const char *path, int fd) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800624 unsigned long long fields[__STAT_NUMBER_FIELD];
Mark Salyzyn326842f2015-04-30 09:49:41 -0700625 bool z;
Yi Kong19d5c002018-07-20 13:39:55 -0700626 char *cp, *buffer = nullptr;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700627 size_t i = 0;
Josh Gao7c4258c2018-06-25 13:40:08 -0700628 FILE *fp = fdopen(dup(fd), "rb");
Mark Salyzyn326842f2015-04-30 09:49:41 -0700629 getline(&buffer, &i, fp);
630 fclose(fp);
631 if (!buffer) {
632 return -errno;
633 }
634 i = strlen(buffer);
635 while ((i > 0) && (buffer[i - 1] == '\n')) {
636 buffer[--i] = '\0';
637 }
638 if (!*buffer) {
639 free(buffer);
640 return 0;
641 }
642 z = true;
643 for (cp = buffer, i = 0; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800644 fields[i] = strtoull(cp, &cp, 10);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700645 if (fields[i] != 0) {
646 z = false;
647 }
648 }
649 if (z) { /* never accessed */
650 free(buffer);
651 return 0;
652 }
653
Wei Wang509bb5d2017-06-09 14:42:12 -0700654 if (!strncmp(path, BLK_DEV_SYS_DIR, sizeof(BLK_DEV_SYS_DIR) - 1)) {
655 path += sizeof(BLK_DEV_SYS_DIR) - 1;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700656 }
Wei Wang1dc1ef52017-06-12 11:28:37 -0700657
658 printf("%-30s:%9s%9s%9s%9s%9s%9s%9s%9s%9s%9s%9s\n%-30s:\t%s\n", "Block-Dev",
659 "R-IOs", "R-merg", "R-sect", "R-wait", "W-IOs", "W-merg", "W-sect",
660 "W-wait", "in-fli", "activ", "T-wait", path, buffer);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700661 free(buffer);
662
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800663 if (fields[__STAT_IO_TICKS]) {
664 unsigned long read_perf = 0;
665 unsigned long read_ios = 0;
666 if (fields[__STAT_READ_TICKS]) {
667 unsigned long long divisor = fields[__STAT_READ_TICKS]
668 * fields[__STAT_IO_TICKS];
669 read_perf = ((unsigned long long)SECTOR_SIZE
670 * fields[__STAT_READ_SECTORS]
671 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
672 / divisor;
673 read_ios = ((unsigned long long)S_TO_MS * fields[__STAT_READ_IOS]
674 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
675 / divisor;
676 }
677
678 unsigned long write_perf = 0;
679 unsigned long write_ios = 0;
680 if (fields[__STAT_WRITE_TICKS]) {
681 unsigned long long divisor = fields[__STAT_WRITE_TICKS]
682 * fields[__STAT_IO_TICKS];
683 write_perf = ((unsigned long long)SECTOR_SIZE
684 * fields[__STAT_WRITE_SECTORS]
685 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
686 / divisor;
687 write_ios = ((unsigned long long)S_TO_MS * fields[__STAT_WRITE_IOS]
688 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
689 / divisor;
690 }
691
692 unsigned queue = (fields[__STAT_IN_QUEUE]
693 + (fields[__STAT_IO_TICKS] >> 1))
694 / fields[__STAT_IO_TICKS];
695
696 if (!write_perf && !write_ios) {
Wei Wang1dc1ef52017-06-12 11:28:37 -0700697 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 -0800698 } else {
Wei Wang1dc1ef52017-06-12 11:28:37 -0700699 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 -0800700 read_ios, write_perf, write_ios, queue);
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800701 }
702
703 /* bugreport timeout factor adjustment */
704 if ((write_perf > 1) && (write_perf < worst_write_perf)) {
705 worst_write_perf = write_perf;
706 }
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700707 }
Mark Salyzyn326842f2015-04-30 09:49:41 -0700708 return 0;
709}
710
Yao Chenbe3bbc12018-01-17 16:31:10 -0800711static const long MINIMUM_LOGCAT_TIMEOUT_MS = 50000;
712
Tom Cherryf4472f32020-08-05 09:31:17 -0700713// Returns the actual readable size of the given buffer or -1 on error.
714static long logcat_buffer_readable_size(const std::string& buffer) {
715 std::unique_ptr<logger_list, decltype(&android_logger_list_free)> logger_list{
716 android_logger_list_alloc(0, 0, 0), &android_logger_list_free};
717 auto logger = android_logger_open(logger_list.get(), android_name_to_log_id(buffer.c_str()));
718
719 return android_logger_get_log_readable_size(logger);
720}
721
722// Returns timeout in ms to read a list of buffers.
Yao Chenbe3bbc12018-01-17 16:31:10 -0800723static unsigned long logcat_timeout(const std::vector<std::string>& buffers) {
724 unsigned long timeout_ms = 0;
725 for (const auto& buffer : buffers) {
Tom Cherryf4472f32020-08-05 09:31:17 -0700726 long readable_size = logcat_buffer_readable_size(buffer);
727 if (readable_size > 0) {
728 // Engineering margin is ten-fold our guess.
729 timeout_ms += 10 * (readable_size + worst_write_perf) / worst_write_perf;
730 }
Yao Chenbe3bbc12018-01-17 16:31:10 -0800731 }
732 return timeout_ms > MINIMUM_LOGCAT_TIMEOUT_MS ? timeout_ms : MINIMUM_LOGCAT_TIMEOUT_MS;
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700733}
734
Dieter Hsu105ad0c2020-09-29 15:23:33 +0800735// Opens a socket and returns its file descriptor.
736static int open_socket(const char* service);
737
Nandana Duttd2f5f082019-01-18 17:13:52 +0000738Dumpstate::ConsentCallback::ConsentCallback() : result_(UNAVAILABLE), start_time_(Nanotime()) {
739}
740
741android::binder::Status Dumpstate::ConsentCallback::onReportApproved() {
742 std::lock_guard<std::mutex> lock(lock_);
743 result_ = APPROVED;
744 MYLOGD("User approved consent to share bugreport\n");
Paul Chang0d2aad72020-02-13 20:04:03 +0800745
746 // Maybe copy screenshot so calling app can display the screenshot to the user as soon as
747 // consent is granted.
748 if (ds.options_->is_screenshot_copied) {
749 return android::binder::Status::ok();
750 }
751
752 if (!ds.options_->do_screenshot || ds.options_->screenshot_fd.get() == -1 ||
753 !ds.do_early_screenshot_) {
754 return android::binder::Status::ok();
755 }
756
757 bool copy_succeeded = android::os::CopyFileToFd(ds.screenshot_path_,
758 ds.options_->screenshot_fd.get());
759 ds.options_->is_screenshot_copied = copy_succeeded;
760 if (copy_succeeded) {
761 android::os::UnlinkAndLogOnError(ds.screenshot_path_);
762 }
Nandana Duttd2f5f082019-01-18 17:13:52 +0000763 return android::binder::Status::ok();
764}
765
766android::binder::Status Dumpstate::ConsentCallback::onReportDenied() {
767 std::lock_guard<std::mutex> lock(lock_);
768 result_ = DENIED;
769 MYLOGW("User denied consent to share bugreport\n");
770 return android::binder::Status::ok();
771}
772
773UserConsentResult Dumpstate::ConsentCallback::getResult() {
774 std::lock_guard<std::mutex> lock(lock_);
775 return result_;
776}
777
778uint64_t Dumpstate::ConsentCallback::getElapsedTimeMs() const {
Hunter Knepshieldf0a39052020-01-03 14:53:04 -0800779 return (Nanotime() - start_time_) / NANOS_PER_MILLI;
Nandana Duttd2f5f082019-01-18 17:13:52 +0000780}
781
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700782void Dumpstate::PrintHeader() const {
Mårten Kongstad60195a72022-09-20 14:14:20 +0200783 std::string build, fingerprint, radio, bootloader, network, sdkversion;
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700784 char date[80];
Colin Crossf45fa6b2012-03-26 12:38:26 -0700785
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700786 build = android::base::GetProperty("ro.build.display.id", "(unknown)");
787 fingerprint = android::base::GetProperty("ro.build.fingerprint", "(unknown)");
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700788 radio = android::base::GetProperty("gsm.version.baseband", "(unknown)");
789 bootloader = android::base::GetProperty("ro.bootloader", "(unknown)");
790 network = android::base::GetProperty("gsm.operator.alpha", "(unknown)");
Mårten Kongstad60195a72022-09-20 14:14:20 +0200791 sdkversion = android::base::GetProperty("ro.build.version.sdk", "(unknown)");
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700792 strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now_));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700793
Felipe Lemed8b94e52016-12-08 10:21:44 -0800794 printf("========================================================\n");
795 printf("== dumpstate: %s\n", date);
796 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700797
Felipe Lemed8b94e52016-12-08 10:21:44 -0800798 printf("\n");
799 printf("Build: %s\n", build.c_str());
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700800 // NOTE: fingerprint entry format is important for other tools.
Felipe Lemed8b94e52016-12-08 10:21:44 -0800801 printf("Build fingerprint: '%s'\n", fingerprint.c_str());
802 printf("Bootloader: %s\n", bootloader.c_str());
803 printf("Radio: %s\n", radio.c_str());
804 printf("Network: %s\n", network.c_str());
Nikita Ioffea325a572019-05-16 19:49:47 +0100805 int64_t module_metadata_version = android::os::GetModuleMetadataVersion();
806 if (module_metadata_version != 0) {
807 printf("Module Metadata version: %" PRId64 "\n", module_metadata_version);
808 }
Mårten Kongstad60195a72022-09-20 14:14:20 +0200809 printf("Android SDK version: %s\n", sdkversion.c_str());
810 printf("SDK extensions: ");
811 RunCommandToFd(STDOUT_FILENO, "", {SDK_EXT_INFO, "--header"},
812 CommandOptions::WithTimeout(1).Always().DropRoot().Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700813
Felipe Lemed8b94e52016-12-08 10:21:44 -0800814 printf("Kernel: ");
Felipe Lemef0292972016-11-22 13:57:05 -0800815 DumpFileToFd(STDOUT_FILENO, "", "/proc/version");
Felipe Lemed8b94e52016-12-08 10:21:44 -0800816 printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
Felipe Leme7709f8a2017-12-05 09:30:09 -0800817 printf("Uptime: ");
818 RunCommandToFd(STDOUT_FILENO, "", {"uptime", "-p"},
819 CommandOptions::WithTimeout(1).Always().Build());
Felipe Lemed8b94e52016-12-08 10:21:44 -0800820 printf("Bugreport format version: %s\n", version_.c_str());
Rhed Jao5377d792020-07-16 17:37:39 +0800821 printf("Dumpstate info: id=%d pid=%d dry_run=%d parallel_run=%d args=%s bugreport_mode=%s\n",
822 id_, pid_, PropertiesHelper::IsDryRun(), PropertiesHelper::IsParallelRun(),
Kedar Chitnis9fd8c052021-11-16 09:09:22 +0000823 options_->args.c_str(), options_->bugreport_mode_string.c_str());
Felipe Lemed8b94e52016-12-08 10:21:44 -0800824 printf("\n");
Felipe Leme78f2c862015-12-21 09:55:22 -0800825}
826
Felipe Leme24b66ee2016-06-16 10:55:26 -0700827// List of file extensions that can cause a zip file attachment to be rejected by some email
828// service providers.
829static const std::set<std::string> PROBLEMATIC_FILE_EXTENSIONS = {
830 ".ade", ".adp", ".bat", ".chm", ".cmd", ".com", ".cpl", ".exe", ".hta", ".ins", ".isp",
831 ".jar", ".jse", ".lib", ".lnk", ".mde", ".msc", ".msp", ".mst", ".pif", ".scr", ".sct",
832 ".shb", ".sys", ".vb", ".vbe", ".vbs", ".vxd", ".wsc", ".wsf", ".wsh"
833};
834
Vishnu Naire97d6122018-01-18 13:58:56 -0800835status_t Dumpstate::AddZipEntryFromFd(const std::string& entry_name, int fd,
836 std::chrono::milliseconds timeout = 0ms) {
Felipe Leme24b66ee2016-06-16 10:55:26 -0700837 std::string valid_name = entry_name;
838
839 // Rename extension if necessary.
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -0700840 size_t idx = entry_name.rfind('.');
Felipe Leme24b66ee2016-06-16 10:55:26 -0700841 if (idx != std::string::npos) {
842 std::string extension = entry_name.substr(idx);
843 std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
844 if (PROBLEMATIC_FILE_EXTENSIONS.count(extension) != 0) {
845 valid_name = entry_name + ".renamed";
846 MYLOGI("Renaming entry %s to %s\n", entry_name.c_str(), valid_name.c_str());
847 }
848 }
849
Felipe Leme6fe9db62016-02-12 09:04:16 -0800850 // Logging statement below is useful to time how long each entry takes, but it's too verbose.
851 // MYLOGD("Adding zip entry %s\n", entry_name.c_str());
Kevin Jeon9bbe0ac2022-05-05 22:05:43 +0000852 size_t flags = ZipWriter::kCompress | ZipWriter::kDefaultCompression;
853 int32_t err = zip_writer_->StartEntryWithTime(valid_name.c_str(), flags,
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700854 get_mtime(fd, ds.now_));
Felipe Leme1d486fe2016-10-14 18:06:47 -0700855 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700856 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", valid_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700857 ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800858 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800859 }
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000860 bool finished_entry = false;
861 auto finish_entry = [this, &finished_entry] {
862 if (!finished_entry) {
863 // This should only be called when we're going to return an earlier error,
864 // which would've been logged. This may imply the file is already corrupt
865 // and any further logging from FinishEntry is more likely to mislead than
866 // not.
867 this->zip_writer_->FinishEntry();
868 }
869 };
870 auto scope_guard = android::base::make_scope_guard(finish_entry);
Vishnu Naire97d6122018-01-18 13:58:56 -0800871 auto start = std::chrono::steady_clock::now();
872 auto end = start + timeout;
873 struct pollfd pfd = {fd, POLLIN};
Felipe Lemee82a27d2016-01-05 13:35:44 -0800874
Felipe Leme770410d2016-01-26 17:07:14 -0800875 std::vector<uint8_t> buffer(65536);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800876 while (1) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800877 if (timeout.count() > 0) {
878 // lambda to recalculate the timeout.
879 auto time_left_ms = [end]() {
880 auto now = std::chrono::steady_clock::now();
881 auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - now);
882 return std::max(diff.count(), 0LL);
883 };
884
885 int rc = TEMP_FAILURE_RETRY(poll(&pfd, 1, time_left_ms()));
886 if (rc < 0) {
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000887 MYLOGE("Error in poll while adding from fd to zip entry %s:%s\n",
888 entry_name.c_str(), strerror(errno));
Vishnu Naire97d6122018-01-18 13:58:56 -0800889 return -errno;
890 } else if (rc == 0) {
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000891 MYLOGE("Timed out adding from fd to zip entry %s:%s Timeout:%lldms\n",
Vishnu Naire97d6122018-01-18 13:58:56 -0800892 entry_name.c_str(), strerror(errno), timeout.count());
893 return TIMED_OUT;
894 }
895 }
896
Zach Riggle22200402016-08-18 01:01:24 -0400897 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), buffer.size()));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800898 if (bytes_read == 0) {
899 break;
900 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800901 MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
Vishnu Naire97d6122018-01-18 13:58:56 -0800902 return -errno;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800903 }
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700904 err = zip_writer_->WriteBytes(buffer.data(), bytes_read);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800905 if (err) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700906 MYLOGE("zip_writer_->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800907 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800908 }
909 }
910
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700911 err = zip_writer_->FinishEntry();
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000912 finished_entry = true;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700913 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700914 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800915 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800916 }
917
Vishnu Naire97d6122018-01-18 13:58:56 -0800918 return OK;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800919}
920
Felipe Leme1d486fe2016-10-14 18:06:47 -0700921bool Dumpstate::AddZipEntry(const std::string& entry_name, const std::string& entry_path) {
922 android::base::unique_fd fd(
923 TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
Andreas Gampeaff68432016-07-18 18:01:27 -0700924 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800925 MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800926 return false;
927 }
928
Vishnu Naire97d6122018-01-18 13:58:56 -0800929 return (AddZipEntryFromFd(entry_name, fd.get()) == OK);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800930}
931
932/* adds a file to the existing zipped bugreport */
Felipe Leme4c2d6632016-09-28 14:32:00 -0700933static int _add_file_from_fd(const char* title __attribute__((unused)), const char* path, int fd) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800934 return (ds.AddZipEntryFromFd(ZIP_ROOT_DIR + path, fd) == OK) ? 0 : 1;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800935}
936
Felipe Leme1d486fe2016-10-14 18:06:47 -0700937void Dumpstate::AddDir(const std::string& dir, bool recursive) {
Felipe Leme678727a2016-09-21 17:22:11 -0700938 MYLOGD("Adding dir %s (recursive: %d)\n", dir.c_str(), recursive);
Felipe Leme46b85da2016-11-21 17:40:45 -0800939 DurationReporter duration_reporter(dir, true);
Felipe Leme678727a2016-09-21 17:22:11 -0700940 dump_files("", dir.c_str(), recursive ? skip_none : is_dir, _add_file_from_fd);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800941}
942
Felipe Leme1d486fe2016-10-14 18:06:47 -0700943bool Dumpstate::AddTextZipEntry(const std::string& entry_name, const std::string& content) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800944 MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
Kevin Jeon9bbe0ac2022-05-05 22:05:43 +0000945 size_t flags = ZipWriter::kCompress | ZipWriter::kDefaultCompression;
946 int32_t err = zip_writer_->StartEntryWithTime(entry_name.c_str(), flags, ds.now_);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700947 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700948 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700949 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800950 return false;
951 }
952
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700953 err = zip_writer_->WriteBytes(content.c_str(), content.length());
Felipe Leme1d486fe2016-10-14 18:06:47 -0700954 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700955 MYLOGE("zip_writer_->WriteBytes(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700956 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800957 return false;
958 }
959
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700960 err = zip_writer_->FinishEntry();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700961 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700962 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800963 return false;
964 }
965
966 return true;
967}
968
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800969static void DoKmsg() {
970 struct stat st;
971 if (!stat(PSTORE_LAST_KMSG, &st)) {
972 /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
973 DumpFile("LAST KMSG", PSTORE_LAST_KMSG);
974 } else if (!stat(ALT_PSTORE_LAST_KMSG, &st)) {
975 DumpFile("LAST KMSG", ALT_PSTORE_LAST_KMSG);
976 } else {
977 /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
978 DumpFile("LAST KMSG", "/proc/last_kmsg");
979 }
980}
981
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800982static void DoKernelLogcat() {
Yao Chenbe3bbc12018-01-17 16:31:10 -0800983 unsigned long timeout_ms = logcat_timeout({"kernel"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800984 RunCommand(
985 "KERNEL LOG",
986 {"logcat", "-b", "kernel", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
987 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
988}
989
Nandana Duttdb379fa2019-10-09 16:54:41 +0100990static void DoSystemLogcat(time_t since) {
991 char since_str[80];
992 strftime(since_str, sizeof(since_str), "%Y-%m-%d %H:%M:%S.000", localtime(&since));
993
994 unsigned long timeout_ms = logcat_timeout({"main", "system", "crash"});
995 RunCommand("SYSTEM LOG",
996 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v", "-T",
997 since_str},
998 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
999}
1000
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001001static void DoRadioLogcat() {
1002 unsigned long timeout_ms = logcat_timeout({"radio"});
1003 RunCommand(
1004 "RADIO LOG",
1005 {"logcat", "-b", "radio", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1006 CommandOptions::WithTimeoutInMs(timeout_ms).Build(), true /* verbose_duration */);
1007}
1008
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001009static void DoLogcat() {
Vishnu Nair6921f802017-11-22 09:17:23 -08001010 unsigned long timeout_ms;
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001011 // DumpFile("EVENT LOG TAGS", "/etc/event-log-tags");
1012 // calculate timeout
Yao Chenbe3bbc12018-01-17 16:31:10 -08001013 timeout_ms = logcat_timeout({"main", "system", "crash"});
Tony Makae737652017-03-30 17:47:09 +01001014 RunCommand("SYSTEM LOG",
Vishnu Nair6921f802017-11-22 09:17:23 -08001015 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1016 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Yao Chenbe3bbc12018-01-17 16:31:10 -08001017 timeout_ms = logcat_timeout({"events"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001018 RunCommand(
1019 "EVENT LOG",
1020 {"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
Nandana Dutt8d945c02019-08-14 13:30:07 +01001021 CommandOptions::WithTimeoutInMs(timeout_ms).Build(), true /* verbose_duration */);
Yao Chenbe3bbc12018-01-17 16:31:10 -08001022 timeout_ms = logcat_timeout({"stats"});
1023 RunCommand(
1024 "STATS LOG",
1025 {"logcat", "-b", "stats", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
Nandana Dutt8d945c02019-08-14 13:30:07 +01001026 CommandOptions::WithTimeoutInMs(timeout_ms).Build(), true /* verbose_duration */);
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001027 DoRadioLogcat();
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001028
1029 RunCommand("LOG STATISTICS", {"logcat", "-b", "all", "-S"});
1030
1031 /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001032 RunCommand("LAST LOGCAT", {"logcat", "-L", "-b", "all", "-v", "threadtime", "-v", "printable",
1033 "-v", "uid", "-d", "*:v"});
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001034}
1035
Mike Ma5c267872019-08-21 11:31:34 -07001036static void DumpIncidentReport() {
Mike Ma5c267872019-08-21 11:31:34 -07001037 const std::string path = ds.bugreport_internal_dir_ + "/tmp_incident_report";
1038 auto fd = android::base::unique_fd(TEMP_FAILURE_RETRY(open(path.c_str(),
1039 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1040 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1041 if (fd < 0) {
1042 MYLOGE("Could not open %s to dump incident report.\n", path.c_str());
1043 return;
1044 }
Kevin Jeon774abde2022-09-28 18:20:43 +00001045 RunCommandToFd(fd, "", {"incident", "-u"}, CommandOptions::WithTimeout(20).Build());
Mike Ma5c267872019-08-21 11:31:34 -07001046 bool empty = 0 == lseek(fd, 0, SEEK_END);
1047 if (!empty) {
1048 // Use a different name from "incident.proto"
1049 // /proto/incident.proto is reserved for incident service dump
1050 // i.e. metadata for debugging.
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001051 ds.EnqueueAddZipEntryAndCleanupIfNeeded(kProtoPath + "incident_report" + kProtoExt,
1052 path);
1053 } else {
1054 unlink(path.c_str());
Mike Ma5c267872019-08-21 11:31:34 -07001055 }
Mike Ma5c267872019-08-21 11:31:34 -07001056}
1057
Aaron Huanga99452a2022-04-27 18:51:16 +08001058static void DumpNetstatsProto() {
1059 const std::string path = ds.bugreport_internal_dir_ + "/tmp_netstats_proto";
1060 auto fd = android::base::unique_fd(TEMP_FAILURE_RETRY(open(path.c_str(),
1061 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1062 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1063 if (fd < 0) {
1064 MYLOGE("Could not open %s to dump netstats proto.\n", path.c_str());
1065 return;
1066 }
1067 RunCommandToFd(fd, "", {"dumpsys", "netstats", "--proto"},
1068 CommandOptions::WithTimeout(120).Build());
1069 bool empty = 0 == lseek(fd, 0, SEEK_END);
1070 if (!empty) {
1071 ds.EnqueueAddZipEntryAndCleanupIfNeeded(kProtoPath + "netstats" + kProtoExt,
1072 path);
1073 } else {
1074 unlink(path.c_str());
1075 }
1076}
1077
Primiano Tuccifaaaafb2021-01-14 12:26:29 +00001078static void MaybeAddSystemTraceToZip() {
1079 // This function copies into the .zip the system trace that was snapshotted
1080 // by the early call to MaybeSnapshotSystemTrace(), if any background
1081 // tracing was happening.
Primiano Tuccifaaaafb2021-01-14 12:26:29 +00001082 if (!ds.has_system_trace_) {
1083 // No background trace was happening at the time dumpstate was invoked.
1084 return;
1085 }
1086 ds.AddZipEntry(
1087 ZIP_ROOT_DIR + SYSTEM_TRACE_SNAPSHOT,
1088 SYSTEM_TRACE_SNAPSHOT);
1089 android::os::UnlinkAndLogOnError(SYSTEM_TRACE_SNAPSHOT);
1090}
1091
Sunny Goyal35949782019-11-19 15:54:36 -08001092static void DumpVisibleWindowViews() {
Sunny Goyal35949782019-11-19 15:54:36 -08001093 DurationReporter duration_reporter("VISIBLE WINDOW VIEWS");
1094 const std::string path = ds.bugreport_internal_dir_ + "/tmp_visible_window_views";
1095 auto fd = android::base::unique_fd(TEMP_FAILURE_RETRY(open(path.c_str(),
1096 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1097 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1098 if (fd < 0) {
1099 MYLOGE("Could not open %s to dump visible views.\n", path.c_str());
1100 return;
1101 }
1102 RunCommandToFd(fd, "", {"cmd", "window", "dump-visible-window-views"},
Kevin Jeon774abde2022-09-28 18:20:43 +00001103 CommandOptions::WithTimeout(10).Build());
Sunny Goyal35949782019-11-19 15:54:36 -08001104 bool empty = 0 == lseek(fd, 0, SEEK_END);
1105 if (!empty) {
1106 ds.AddZipEntry("visible_windows.zip", path);
1107 } else {
1108 MYLOGW("Failed to dump visible windows\n");
1109 }
1110 unlink(path.c_str());
1111}
1112
Jayachandran Ca94c7172017-06-10 15:08:12 -07001113static void DumpIpTablesAsRoot() {
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001114 RunCommand("IPTABLES", {"iptables", "-L", "-nvx"});
1115 RunCommand("IP6TABLES", {"ip6tables", "-L", "-nvx"});
Erik Kline32af8c22016-09-28 17:26:26 +09001116 RunCommand("IPTABLES NAT", {"iptables", "-t", "nat", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -07001117 /* no ip6 nat */
Erik Kline32af8c22016-09-28 17:26:26 +09001118 RunCommand("IPTABLES MANGLE", {"iptables", "-t", "mangle", "-L", "-nvx"});
1119 RunCommand("IP6TABLES MANGLE", {"ip6tables", "-t", "mangle", "-L", "-nvx"});
1120 RunCommand("IPTABLES RAW", {"iptables", "-t", "raw", "-L", "-nvx"});
1121 RunCommand("IP6TABLES RAW", {"ip6tables", "-t", "raw", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -07001122}
1123
Woody Lin20767a92022-11-29 15:50:24 +08001124static void DumpShutdownCheckpoints() {
1125 const bool shutdown_checkpoints_dumped = AddDumps(
1126 ds.shutdown_checkpoints_.begin(), ds.shutdown_checkpoints_.end(),
1127 "SHUTDOWN CHECKPOINTS", false /* add_to_zip */);
1128 if (!shutdown_checkpoints_dumped) {
1129 printf("*** NO SHUTDOWN CHECKPOINTS to dump in %s\n\n",
1130 SHUTDOWN_CHECKPOINTS_DIR.c_str());
1131 }
1132}
1133
David Andersond9ba4752018-12-11 18:26:59 -08001134static void DumpDynamicPartitionInfo() {
1135 if (!::android::base::GetBoolProperty("ro.boot.dynamic_partitions", false)) {
1136 return;
1137 }
1138
1139 RunCommand("LPDUMP", {"lpdump", "--all"});
David Anderson6650ade2019-10-02 15:18:59 -07001140 RunCommand("DEVICE-MAPPER", {"gsid", "dump-device-mapper"});
David Andersond9ba4752018-12-11 18:26:59 -08001141}
1142
Chris Morin5a50d482022-02-01 17:41:18 -08001143static void AddAnrTraceDir(const std::string& anr_traces_dir) {
Narayan Kamath8f788292017-05-25 13:20:39 +01001144 MYLOGD("AddAnrTraceDir(): dump_traces_file=%s, anr_traces_dir=%s\n", dump_traces_path,
1145 anr_traces_dir.c_str());
1146
1147 // If we're here, dump_traces_path will always be a temporary file
1148 // (created with mkostemp or similar) that contains dumps taken earlier
1149 // on in the process.
1150 if (dump_traces_path != nullptr) {
Chris Morin5a50d482022-02-01 17:41:18 -08001151 MYLOGD("Dumping current ANR traces (%s) to the main bugreport entry\n",
1152 dump_traces_path);
1153 ds.DumpFile("VM TRACES JUST NOW", dump_traces_path);
Narayan Kamath8f788292017-05-25 13:20:39 +01001154
1155 const int ret = unlink(dump_traces_path);
1156 if (ret == -1) {
1157 MYLOGW("Error unlinking temporary trace path %s: %s\n", dump_traces_path,
1158 strerror(errno));
Felipe Lemee184f662016-10-27 10:04:47 -07001159 }
1160 }
1161
Narayan Kamathbd863722017-06-01 18:50:12 +01001162 // Add a specific message for the first ANR Dump.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001163 if (ds.anr_data_.size() > 0) {
Chris Morin5a50d482022-02-01 17:41:18 -08001164 // The "last" ANR will always be present in the body of the main entry.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001165 AddDumps(ds.anr_data_.begin(), ds.anr_data_.begin() + 1,
Chris Morin5a50d482022-02-01 17:41:18 -08001166 "VM TRACES AT LAST ANR", false /* add_to_zip */);
Narayan Kamathbd863722017-06-01 18:50:12 +01001167
Narayan Kamath6b9516c2017-10-27 11:15:51 +01001168 // Historical ANRs are always included as separate entries in the bugreport zip file.
Chris Morin5a50d482022-02-01 17:41:18 -08001169 AddDumps(ds.anr_data_.begin(), ds.anr_data_.end(),
Narayan Kamath6b9516c2017-10-27 11:15:51 +01001170 "HISTORICAL ANR", true /* add_to_zip */);
Narayan Kamathbd863722017-06-01 18:50:12 +01001171 } else {
Narayan Kamath8f788292017-05-25 13:20:39 +01001172 printf("*** NO ANRs to dump in %s\n\n", ANR_DIR.c_str());
1173 }
1174}
1175
1176static void AddAnrTraceFiles() {
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001177 std::string anr_traces_dir = "/data/anr";
Narayan Kamath8f788292017-05-25 13:20:39 +01001178
Chris Morin5a50d482022-02-01 17:41:18 -08001179 AddAnrTraceDir(anr_traces_dir);
Narayan Kamath8f788292017-05-25 13:20:39 +01001180
Makoto Onuki83ec63f2019-01-31 17:08:59 -08001181 RunCommand("ANR FILES", {"ls", "-lt", ANR_DIR});
1182
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001183 // Slow traces for slow operations.
Felipe Lemee184f662016-10-27 10:04:47 -07001184 struct stat st;
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001185 int i = 0;
1186 while (true) {
1187 const std::string slow_trace_path =
1188 anr_traces_dir + android::base::StringPrintf("slow%02d.txt", i);
1189 if (stat(slow_trace_path.c_str(), &st)) {
1190 // No traces file at this index, done with the files.
1191 break;
Felipe Lemee184f662016-10-27 10:04:47 -07001192 }
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001193 ds.DumpFile("VM TRACES WHEN SLOW", slow_trace_path.c_str());
1194 i++;
Felipe Lemee184f662016-10-27 10:04:47 -07001195 }
1196}
1197
Wei Wang509bb5d2017-06-09 14:42:12 -07001198static void DumpBlockStatFiles() {
1199 DurationReporter duration_reporter("DUMP BLOCK STAT");
Wei Wang509bb5d2017-06-09 14:42:12 -07001200
Wei Wang1dc1ef52017-06-12 11:28:37 -07001201 std::unique_ptr<DIR, std::function<int(DIR*)>> dirptr(opendir(BLK_DEV_SYS_DIR), closedir);
1202
1203 if (dirptr == nullptr) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001204 MYLOGE("Failed to open %s: %s\n", BLK_DEV_SYS_DIR, strerror(errno));
1205 return;
1206 }
1207
1208 printf("------ DUMP BLOCK STAT ------\n\n");
Wei Wang1dc1ef52017-06-12 11:28:37 -07001209 while (struct dirent *d = readdir(dirptr.get())) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001210 if ((d->d_name[0] == '.')
1211 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
1212 || (d->d_name[1] == '\0'))) {
1213 continue;
1214 }
1215 const std::string new_path =
1216 android::base::StringPrintf("%s/%s", BLK_DEV_SYS_DIR, d->d_name);
1217 printf("------ BLOCK STAT (%s) ------\n", new_path.c_str());
1218 dump_files("", new_path.c_str(), skip_not_stat, dump_stat_from_fd);
1219 printf("\n");
1220 }
Wei Wang1dc1ef52017-06-12 11:28:37 -07001221 return;
Wei Wang509bb5d2017-06-09 14:42:12 -07001222}
Jayachandran Ca94c7172017-06-10 15:08:12 -07001223
1224static void DumpPacketStats() {
1225 DumpFile("NETWORK DEV INFO", "/proc/net/dev");
Jayachandran Ca94c7172017-06-10 15:08:12 -07001226}
1227
1228static void DumpIpAddrAndRules() {
1229 /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
1230 RunCommand("NETWORK INTERFACES", {"ip", "link"});
1231 RunCommand("IPv4 ADDRESSES", {"ip", "-4", "addr", "show"});
1232 RunCommand("IPv6 ADDRESSES", {"ip", "-6", "addr", "show"});
1233 RunCommand("IP RULES", {"ip", "rule", "show"});
1234 RunCommand("IP RULES v6", {"ip", "-6", "rule", "show"});
1235}
1236
Nandana Dutt5c390032019-03-12 10:52:56 +00001237static Dumpstate::RunStatus RunDumpsysTextByPriority(const std::string& title, int priority,
1238 std::chrono::milliseconds timeout,
1239 std::chrono::milliseconds service_timeout) {
Vishnu Nair64afc022018-02-01 15:29:34 -08001240 auto start = std::chrono::steady_clock::now();
Vishnu Naire97d6122018-01-18 13:58:56 -08001241 sp<android::IServiceManager> sm = defaultServiceManager();
1242 Dumpsys dumpsys(sm.get());
Vishnu Naire97d6122018-01-18 13:58:56 -08001243 Vector<String16> args;
1244 Dumpsys::setServiceArgs(args, /* asProto = */ false, priority);
Vishnu Naire97d6122018-01-18 13:58:56 -08001245 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ false);
1246 for (const String16& service : services) {
Nandana Dutt5c390032019-03-12 10:52:56 +00001247 RETURN_IF_USER_DENIED_CONSENT();
Vishnu Naire97d6122018-01-18 13:58:56 -08001248 std::string path(title);
1249 path.append(" - ").append(String8(service).c_str());
Vishnu Naire97d6122018-01-18 13:58:56 -08001250 size_t bytes_written = 0;
Gavin Corkeryf18d1832021-08-25 17:23:40 +01001251 if (PropertiesHelper::IsDryRun()) {
1252 dumpsys.writeDumpHeader(STDOUT_FILENO, service, priority);
1253 dumpsys.writeDumpFooter(STDOUT_FILENO, service, std::chrono::milliseconds(1));
1254 } else {
Devin Mooref492c1a2023-03-15 19:19:03 +00001255 status_t status = dumpsys.startDumpThread(Dumpsys::TYPE_DUMP | Dumpsys::TYPE_PID |
1256 Dumpsys::TYPE_CLIENTS | Dumpsys::TYPE_THREAD,
Devin Mooreae68df22023-02-24 20:59:51 +00001257 service, args);
1258 if (status == OK) {
Gavin Corkeryf18d1832021-08-25 17:23:40 +01001259 dumpsys.writeDumpHeader(STDOUT_FILENO, service, priority);
1260 std::chrono::duration<double> elapsed_seconds;
1261 if (priority == IServiceManager::DUMP_FLAG_PRIORITY_HIGH &&
1262 service == String16("meminfo")) {
1263 // Use a longer timeout for meminfo, since 30s is not always enough.
1264 status = dumpsys.writeDump(STDOUT_FILENO, service, 60s,
1265 /* as_proto = */ false, elapsed_seconds,
1266 bytes_written);
1267 } else {
1268 status = dumpsys.writeDump(STDOUT_FILENO, service, service_timeout,
1269 /* as_proto = */ false, elapsed_seconds,
1270 bytes_written);
1271 }
1272 dumpsys.writeDumpFooter(STDOUT_FILENO, service, elapsed_seconds);
1273 bool dump_complete = (status == OK);
1274 dumpsys.stopDumpThread(dump_complete);
Devin Moorecdfa4602023-03-16 20:49:39 +00001275 } else {
1276 MYLOGE("Failed to start dump thread for service: %s, status: %d",
1277 String8(service).c_str(), status);
Gavin Corkeryfac7e2b2021-07-08 22:39:02 +01001278 }
Vishnu Naire97d6122018-01-18 13:58:56 -08001279 }
Vishnu Naire97d6122018-01-18 13:58:56 -08001280
1281 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1282 std::chrono::steady_clock::now() - start);
1283 if (elapsed_duration > timeout) {
1284 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1285 elapsed_duration.count());
1286 break;
1287 }
1288 }
Nandana Dutt5c390032019-03-12 10:52:56 +00001289 return Dumpstate::RunStatus::OK;
Vishnu Naire97d6122018-01-18 13:58:56 -08001290}
1291
Vishnu Nair64afc022018-02-01 15:29:34 -08001292static void RunDumpsysText(const std::string& title, int priority,
1293 std::chrono::milliseconds timeout,
1294 std::chrono::milliseconds service_timeout) {
1295 DurationReporter duration_reporter(title);
1296 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1297 fsync(STDOUT_FILENO);
1298 RunDumpsysTextByPriority(title, priority, timeout, service_timeout);
1299}
1300
1301/* Dump all services registered with Normal or Default priority. */
Nandana Dutt5c390032019-03-12 10:52:56 +00001302static Dumpstate::RunStatus RunDumpsysTextNormalPriority(const std::string& title,
1303 std::chrono::milliseconds timeout,
1304 std::chrono::milliseconds service_timeout) {
Vishnu Nair64afc022018-02-01 15:29:34 -08001305 DurationReporter duration_reporter(title);
1306 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1307 fsync(STDOUT_FILENO);
1308 RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_NORMAL, timeout,
1309 service_timeout);
Nandana Dutt5c390032019-03-12 10:52:56 +00001310
1311 RETURN_IF_USER_DENIED_CONSENT();
1312
1313 return RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT, timeout,
1314 service_timeout);
Vishnu Nair64afc022018-02-01 15:29:34 -08001315}
1316
Nandana Dutt5c390032019-03-12 10:52:56 +00001317static Dumpstate::RunStatus RunDumpsysProto(const std::string& title, int priority,
1318 std::chrono::milliseconds timeout,
1319 std::chrono::milliseconds service_timeout) {
Vishnu Naire97d6122018-01-18 13:58:56 -08001320 sp<android::IServiceManager> sm = defaultServiceManager();
1321 Dumpsys dumpsys(sm.get());
1322 Vector<String16> args;
1323 Dumpsys::setServiceArgs(args, /* asProto = */ true, priority);
1324 DurationReporter duration_reporter(title);
1325
1326 auto start = std::chrono::steady_clock::now();
1327 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ true);
1328 for (const String16& service : services) {
Nandana Dutt5c390032019-03-12 10:52:56 +00001329 RETURN_IF_USER_DENIED_CONSENT();
Vishnu Naire97d6122018-01-18 13:58:56 -08001330 std::string path(kProtoPath);
1331 path.append(String8(service).c_str());
1332 if (priority == IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL) {
1333 path.append("_CRITICAL");
1334 } else if (priority == IServiceManager::DUMP_FLAG_PRIORITY_HIGH) {
1335 path.append("_HIGH");
1336 }
1337 path.append(kProtoExt);
Steven Morelandcbd69fc2021-07-20 20:45:43 +00001338 status_t status = dumpsys.startDumpThread(Dumpsys::TYPE_DUMP, service, args);
Vishnu Naire97d6122018-01-18 13:58:56 -08001339 if (status == OK) {
1340 status = ds.AddZipEntryFromFd(path, dumpsys.getDumpFd(), service_timeout);
1341 bool dumpTerminated = (status == OK);
1342 dumpsys.stopDumpThread(dumpTerminated);
1343 }
1344 ZipWriter::FileEntry file_entry;
1345 ds.zip_writer_->GetLastEntry(&file_entry);
Vishnu Naire97d6122018-01-18 13:58:56 -08001346
1347 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1348 std::chrono::steady_clock::now() - start);
1349 if (elapsed_duration > timeout) {
1350 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1351 elapsed_duration.count());
1352 break;
1353 }
1354 }
Nandana Dutt5c390032019-03-12 10:52:56 +00001355 return Dumpstate::RunStatus::OK;
Vishnu Naire97d6122018-01-18 13:58:56 -08001356}
1357
Nandana Dutta7db6342018-11-21 14:53:34 +00001358// Runs dumpsys on services that must dump first and will take less than 100ms to dump.
Nandana Dutt5c390032019-03-12 10:52:56 +00001359static Dumpstate::RunStatus RunDumpsysCritical() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001360 RunDumpsysText("DUMPSYS CRITICAL", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1361 /* timeout= */ 5s, /* service_timeout= */ 500ms);
Nandana Dutt5c390032019-03-12 10:52:56 +00001362
1363 RETURN_IF_USER_DENIED_CONSENT();
1364
1365 return RunDumpsysProto("DUMPSYS CRITICAL PROTO", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1366 /* timeout= */ 5s, /* service_timeout= */ 500ms);
Vishnu Nair780b1282017-10-10 13:57:24 -07001367}
1368
1369// Runs dumpsys on services that must dump first but can take up to 250ms to dump.
Nandana Dutt5c390032019-03-12 10:52:56 +00001370static Dumpstate::RunStatus RunDumpsysHigh() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001371 // TODO meminfo takes ~10s, connectivity takes ~5sec to dump. They are both
1372 // high priority. Reduce timeout once they are able to dump in a shorter time or
1373 // moved to a parallel task.
1374 RunDumpsysText("DUMPSYS HIGH", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1375 /* timeout= */ 90s, /* service_timeout= */ 30s);
Nandana Dutt5c390032019-03-12 10:52:56 +00001376
1377 RETURN_IF_USER_DENIED_CONSENT();
1378
1379 return RunDumpsysProto("DUMPSYS HIGH PROTO", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1380 /* timeout= */ 5s, /* service_timeout= */ 1s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001381}
1382
1383// Runs dumpsys on services that must dump but can take up to 10s to dump.
Nandana Dutt5c390032019-03-12 10:52:56 +00001384static Dumpstate::RunStatus RunDumpsysNormal() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001385 RunDumpsysTextNormalPriority("DUMPSYS", /* timeout= */ 90s, /* service_timeout= */ 10s);
Nandana Dutt5c390032019-03-12 10:52:56 +00001386
1387 RETURN_IF_USER_DENIED_CONSENT();
1388
1389 return RunDumpsysProto("DUMPSYS PROTO", IServiceManager::DUMP_FLAG_PRIORITY_NORMAL,
1390 /* timeout= */ 90s, /* service_timeout= */ 10s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001391}
1392
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001393/*
1394 * |out_fd| A fd to support the DumpPool to output results to a temporary file.
1395 * Dumpstate can pick up later and output to the bugreport. Using STDOUT_FILENO
1396 * if it's not running in the parallel task.
1397 */
1398static void DumpHals(int out_fd = STDOUT_FILENO) {
Yifan Hong30528a22020-08-07 18:24:06 -07001399 RunCommand("HARDWARE HALS", {"lshal", "--all", "--types=all"},
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001400 CommandOptions::WithTimeout(10).AsRootIfAvailable().Build(),
1401 false, out_fd);
Nandana Dutt6ad9a602019-03-11 16:33:24 +00001402
Steven Moreland44cd9482018-01-04 16:24:13 -08001403 using android::hidl::manager::V1_0::IServiceManager;
1404 using android::hardware::defaultServiceManager;
1405
1406 sp<IServiceManager> sm = defaultServiceManager();
1407 if (sm == nullptr) {
1408 MYLOGE("Could not retrieve hwservicemanager to dump hals.\n");
1409 return;
1410 }
1411
1412 auto ret = sm->list([&](const auto& interfaces) {
1413 for (const std::string& interface : interfaces) {
1414 std::string cleanName = interface;
1415 std::replace_if(cleanName.begin(),
1416 cleanName.end(),
1417 [](char c) {
1418 return !isalnum(c) &&
1419 std::string("@-_:.").find(c) == std::string::npos;
1420 }, '_');
Nandana Dutt979388e2018-11-30 16:48:55 +00001421 const std::string path = ds.bugreport_internal_dir_ + "/lshal_debug_" + cleanName;
Steven Moreland44cd9482018-01-04 16:24:13 -08001422
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001423 bool empty = false;
Steven Moreland44cd9482018-01-04 16:24:13 -08001424 {
1425 auto fd = android::base::unique_fd(
1426 TEMP_FAILURE_RETRY(open(path.c_str(),
1427 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1428 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1429 if (fd < 0) {
1430 MYLOGE("Could not open %s to dump additional hal information.\n", path.c_str());
1431 continue;
1432 }
1433 RunCommandToFd(fd,
1434 "",
Steven Morelandc81cd3c2018-01-18 14:36:26 -08001435 {"lshal", "debug", "-E", interface},
Steven Moreland44cd9482018-01-04 16:24:13 -08001436 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
1437
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001438 empty = 0 == lseek(fd, 0, SEEK_END);
Steven Moreland44cd9482018-01-04 16:24:13 -08001439 }
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001440 if (!empty) {
1441 ds.EnqueueAddZipEntryAndCleanupIfNeeded("lshal-debug/" + cleanName + ".txt",
1442 path);
1443 } else {
1444 unlink(path.c_str());
1445 }
Steven Moreland44cd9482018-01-04 16:24:13 -08001446 }
1447 });
1448
1449 if (!ret.isOk()) {
1450 MYLOGE("Could not list hals from hwservicemanager.\n");
1451 }
1452}
1453
Devin Moore8df81bb2022-06-08 22:47:02 +00001454// Dump all of the files that make up the vendor interface.
1455// See the files listed in dumpFileList() for the latest list of files.
1456static void DumpVintf() {
Devin Moore16271d92022-09-22 18:28:48 +00001457
1458 const std::string sku = android::base::GetProperty("ro.boot.product.hardware.sku", "");
1459 const auto vintfFiles = android::vintf::details::dumpFileList(sku);
Devin Moore8df81bb2022-06-08 22:47:02 +00001460 for (const auto vintfFile : vintfFiles) {
1461 struct stat st;
1462 if (stat(vintfFile.c_str(), &st) == 0) {
1463 if (S_ISDIR(st.st_mode)) {
1464 ds.AddDir(vintfFile, true /* recursive */);
1465 } else {
1466 ds.EnqueueAddZipEntryAndCleanupIfNeeded(ZIP_ROOT_DIR + vintfFile,
1467 vintfFile);
1468 }
1469 }
1470 }
1471}
1472
Hridya Valsarajuac582cd2019-08-05 15:39:54 -07001473static void DumpExternalFragmentationInfo() {
1474 struct stat st;
1475 if (stat("/proc/buddyinfo", &st) != 0) {
1476 MYLOGE("Unable to dump external fragmentation info\n");
1477 return;
1478 }
1479
1480 printf("------ EXTERNAL FRAGMENTATION INFO ------\n");
1481 std::ifstream ifs("/proc/buddyinfo");
1482 auto unusable_index_regex = std::regex{"Node\\s+([0-9]+),\\s+zone\\s+(\\S+)\\s+(.*)"};
1483 for (std::string line; std::getline(ifs, line);) {
1484 std::smatch match_results;
1485 if (std::regex_match(line, match_results, unusable_index_regex)) {
1486 std::stringstream free_pages(std::string{match_results[3]});
1487 std::vector<int> free_pages_per_order(std::istream_iterator<int>{free_pages},
1488 std::istream_iterator<int>());
1489
1490 int total_free_pages = 0;
1491 for (size_t i = 0; i < free_pages_per_order.size(); i++) {
1492 total_free_pages += (free_pages_per_order[i] * std::pow(2, i));
1493 }
1494
1495 printf("Node %s, zone %8s", match_results[1].str().c_str(),
1496 match_results[2].str().c_str());
1497
1498 int usable_free_pages = total_free_pages;
1499 for (size_t i = 0; i < free_pages_per_order.size(); i++) {
1500 auto unusable_index = (total_free_pages - usable_free_pages) /
1501 static_cast<double>(total_free_pages);
1502 printf(" %5.3f", unusable_index);
1503 usable_free_pages -= (free_pages_per_order[i] * std::pow(2, i));
1504 }
1505
1506 printf("\n");
1507 }
1508 }
1509 printf("\n");
1510}
1511
mhasankd451a472020-05-26 18:02:39 -07001512static void DumpstateLimitedOnly() {
1513 // Trimmed-down version of dumpstate to only include a whitelisted
1514 // set of logs (system log, event log, and system server / system app
1515 // crashes, and networking logs). See b/136273873 and b/138459828
1516 // for context.
1517 DurationReporter duration_reporter("DUMPSTATE");
1518 unsigned long timeout_ms;
1519 // calculate timeout
1520 timeout_ms = logcat_timeout({"main", "system", "crash"});
1521 RunCommand("SYSTEM LOG",
1522 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1523 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
1524 timeout_ms = logcat_timeout({"events"});
1525 RunCommand(
1526 "EVENT LOG",
1527 {"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
1528 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
1529
1530 printf("========================================================\n");
1531 printf("== Networking Service\n");
1532 printf("========================================================\n");
1533
1534 RunDumpsys("DUMPSYS NETWORK_SERVICE_LIMITED", {"wifi", "-a"},
1535 CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
Hugo Benichiaa162682020-10-30 23:28:56 +09001536 RunDumpsys("DUMPSYS CONNECTIVITY REQUESTS", {"connectivity", "requests"},
1537 CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
mhasankd451a472020-05-26 18:02:39 -07001538
1539 printf("========================================================\n");
1540 printf("== Dropbox crashes\n");
1541 printf("========================================================\n");
1542
1543 RunDumpsys("DROPBOX SYSTEM SERVER CRASHES", {"dropbox", "-p", "system_server_crash"});
1544 RunDumpsys("DROPBOX SYSTEM APP CRASHES", {"dropbox", "-p", "system_app_crash"});
1545
1546 printf("========================================================\n");
1547 printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),
1548 ds.progress_->GetMax(), ds.progress_->GetInitialMax());
1549 printf("========================================================\n");
1550 printf("== dumpstate: done (id %d)\n", ds.id_);
1551 printf("========================================================\n");
1552}
1553
Rhed Jaoe017f982020-07-21 17:58:41 +08001554/*
1555 * |out_fd| A fd to support the DumpPool to output results to a temporary file.
1556 * Dumpstate can pick up later and output to the bugreport. Using STDOUT_FILENO
1557 * if it's not running in the parallel task.
1558 */
1559static void DumpCheckins(int out_fd = STDOUT_FILENO) {
1560 dprintf(out_fd, "========================================================\n");
1561 dprintf(out_fd, "== Checkins\n");
1562 dprintf(out_fd, "========================================================\n");
1563
1564 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"}, out_fd);
Rhed Jaoe017f982020-07-21 17:58:41 +08001565 RunDumpsys("CHECKIN NETSTATS", {"netstats", "--checkin"}, out_fd);
1566 RunDumpsys("CHECKIN PROCSTATS", {"procstats", "-c"}, out_fd);
1567 RunDumpsys("CHECKIN USAGESTATS", {"usagestats", "-c"}, out_fd);
1568 RunDumpsys("CHECKIN PACKAGE", {"package", "--checkin"}, out_fd);
1569}
1570
1571/*
1572 * Runs dumpsys on activity service to dump all application activities, services
1573 * and providers in the device.
1574 *
1575 * |out_fd| A fd to support the DumpPool to output results to a temporary file.
1576 * Dumpstate can pick up later and output to the bugreport. Using STDOUT_FILENO
1577 * if it's not running in the parallel task.
1578 */
1579static void DumpAppInfos(int out_fd = STDOUT_FILENO) {
1580 dprintf(out_fd, "========================================================\n");
1581 dprintf(out_fd, "== Running Application Activities\n");
1582 dprintf(out_fd, "========================================================\n");
1583
1584 // The following dumpsys internally collects output from running apps, so it can take a long
1585 // time. So let's extend the timeout.
1586
1587 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
1588
1589 RunDumpsys("APP ACTIVITIES", {"activity", "-v", "all"}, DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1590
1591 dprintf(out_fd, "========================================================\n");
1592 dprintf(out_fd, "== Running Application Services (platform)\n");
1593 dprintf(out_fd, "========================================================\n");
1594
1595 RunDumpsys("APP SERVICES PLATFORM", {"activity", "service", "all-platform-non-critical"},
1596 DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1597
1598 dprintf(out_fd, "========================================================\n");
1599 dprintf(out_fd, "== Running Application Services (non-platform)\n");
1600 dprintf(out_fd, "========================================================\n");
1601
1602 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
1603 DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1604
1605 dprintf(out_fd, "========================================================\n");
1606 dprintf(out_fd, "== Running Application Providers (platform)\n");
1607 dprintf(out_fd, "========================================================\n");
1608
1609 RunDumpsys("APP PROVIDERS PLATFORM", {"activity", "provider", "all-platform"},
Rhed Jaob049f182021-01-11 21:08:43 +08001610 DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
Rhed Jaoe017f982020-07-21 17:58:41 +08001611
1612 dprintf(out_fd, "========================================================\n");
1613 dprintf(out_fd, "== Running Application Providers (non-platform)\n");
1614 dprintf(out_fd, "========================================================\n");
1615
1616 RunDumpsys("APP PROVIDERS NON-PLATFORM", {"activity", "provider", "all-non-platform"},
1617 DUMPSYS_COMPONENTS_OPTIONS, 0, out_fd);
1618}
1619
Nandana Dutt5c390032019-03-12 10:52:56 +00001620// Dumps various things. Returns early with status USER_CONSENT_DENIED if user denies consent
1621// via the consent they are shown. Ignores other errors that occur while running various
1622// commands. The consent checking is currently done around long running tasks, which happen to
1623// be distributed fairly evenly throughout the function.
1624static Dumpstate::RunStatus dumpstate() {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001625 DurationReporter duration_reporter("DUMPSTATE");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001626
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001627 // Enqueue slow functions into the thread pool, if the parallel run is enabled.
Aaron Huanga99452a2022-04-27 18:51:16 +08001628 std::future<std::string> dump_hals, dump_incident_report, dump_board, dump_checkins,
1629 dump_netstats_report;
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001630 if (ds.dump_pool_) {
1631 // Pool was shutdown in DumpstateDefaultAfterCritical method in order to
1632 // drop root user. Restarts it with two threads for the parallel run.
1633 ds.dump_pool_->start(/* thread_counts = */2);
1634
Chris Morinbc223142022-02-04 14:17:11 -08001635 dump_hals = ds.dump_pool_->enqueueTaskWithFd(DUMP_HALS_TASK, &DumpHals, _1);
1636 dump_incident_report = ds.dump_pool_->enqueueTask(
1637 DUMP_INCIDENT_REPORT_TASK, &DumpIncidentReport);
Aaron Huanga99452a2022-04-27 18:51:16 +08001638 dump_netstats_report = ds.dump_pool_->enqueueTask(
1639 DUMP_NETSTATS_PROTO_TASK, &DumpNetstatsProto);
Chris Morinbc223142022-02-04 14:17:11 -08001640 dump_board = ds.dump_pool_->enqueueTaskWithFd(
1641 DUMP_BOARD_TASK, &Dumpstate::DumpstateBoard, &ds, _1);
1642 dump_checkins = ds.dump_pool_->enqueueTaskWithFd(DUMP_CHECKINS_TASK, &DumpCheckins, _1);
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001643 }
1644
Nandana Dutt5c390032019-03-12 10:52:56 +00001645 // Dump various things. Note that anything that takes "long" (i.e. several seconds) should
1646 // check intermittently (if it's intrerruptable like a foreach on pids) and/or should be wrapped
1647 // in a consent check (via RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK).
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -07001648 dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001649 RunCommand("UPTIME", {"uptime"});
Wei Wang509bb5d2017-06-09 14:42:12 -07001650 DumpBlockStatFiles();
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001651 DumpFile("MEMORY INFO", "/proc/meminfo");
1652 RunCommand("CPU INFO", {"top", "-b", "-n", "1", "-H", "-s", "6", "-o",
Felipe Leme30dbfa12016-09-02 12:43:26 -07001653 "pid,tid,user,pr,ni,%cpu,s,virt,res,pcy,cmd,name"});
Nandana Dutt5c390032019-03-12 10:52:56 +00001654
Kevin Jeon947922b2022-09-21 00:29:18 +00001655 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunCommand, "BUGREPORT_PROCDUMP", {"bugreport_procdump"},
1656 CommandOptions::AS_ROOT);
Nandana Dutt5c390032019-03-12 10:52:56 +00001657
Sunny Goyal35949782019-11-19 15:54:36 -08001658 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(DumpVisibleWindowViews);
1659
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001660 DumpFile("VIRTUAL MEMORY STATS", "/proc/vmstat");
1661 DumpFile("VMALLOC INFO", "/proc/vmallocinfo");
1662 DumpFile("SLAB INFO", "/proc/slabinfo");
1663 DumpFile("ZONEINFO", "/proc/zoneinfo");
1664 DumpFile("PAGETYPEINFO", "/proc/pagetypeinfo");
1665 DumpFile("BUDDYINFO", "/proc/buddyinfo");
Hridya Valsarajuac582cd2019-08-05 15:39:54 -07001666 DumpExternalFragmentationInfo();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001667
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001668 DumpFile("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001669
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001670 RunCommand("PROCESSES AND THREADS",
Yohei Yukawa591a72d2017-10-05 21:36:35 -07001671 {"ps", "-A", "-T", "-Z", "-O", "pri,nice,rtprio,sched,pcy,time"});
Nandana Dutt5c390032019-03-12 10:52:56 +00001672
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001673 if (ds.dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08001674 WAIT_TASK_WITH_CONSENT_CHECK(std::move(dump_hals));
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001675 } else {
1676 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_HALS_TASK, DumpHals);
1677 }
Steven Moreland81b429e2017-01-31 19:50:46 -08001678
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001679 RunCommand("PRINTENV", {"printenv"});
Elliott Hughes21b7c8d2016-10-28 08:53:02 -07001680 RunCommand("NETSTAT", {"netstat", "-nW"});
Felipe Lemee4eca582016-06-10 17:48:08 -07001681 struct stat s;
1682 if (stat("/proc/modules", &s) != 0) {
1683 MYLOGD("Skipping 'lsmod' because /proc/modules does not exist\n");
1684 } else {
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001685 RunCommand("LSMOD", {"lsmod"});
Woody Linc198f252021-05-04 16:37:11 +08001686 RunCommand("MODULES INFO",
1687 {"sh", "-c", "cat /proc/modules | cut -d' ' -f1 | "
1688 " while read MOD ; do echo modinfo:$MOD ; modinfo $MOD ; "
1689 "done"}, CommandOptions::AS_ROOT);
Felipe Lemee4eca582016-06-10 17:48:08 -07001690 }
Michal Karpinski4db754f2015-12-11 18:04:32 +00001691
Tom Cherryb87dbfa2020-07-28 11:28:53 -07001692 if (android::base::GetBoolProperty("ro.logd.kernel", false)) {
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001693 DoKernelLogcat();
1694 } else {
1695 do_dmesg();
1696 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001697
Devin Moore8df81bb2022-06-08 22:47:02 +00001698 DumpVintf();
1699
Felipe Lemef0292972016-11-22 13:57:05 -08001700 RunCommand("LIST OF OPEN FILES", {"lsof"}, CommandOptions::AS_ROOT);
Nandana Dutt5c390032019-03-12 10:52:56 +00001701
Jeff Brown1dc94e32014-09-11 14:15:27 -07001702 for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
Mark Salyzyna297c322016-02-05 15:33:17 -08001703 for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001704
Jack Yu5a6b2e22020-08-14 18:13:35 +08001705 /* Dump Nfc NCI logs */
1706 ds.AddDir("/data/misc/nfc/logs", true);
Ajay Panickerd886ec42016-09-14 12:26:46 -07001707
Paul Chang0d2aad72020-02-13 20:04:03 +08001708 if (ds.options_->do_screenshot && !ds.do_early_screenshot_) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001709 MYLOGI("taking late screenshot\n");
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001710 ds.TakeScreenshot();
Jeff Sharkey5a930032013-03-19 15:05:19 -07001711 }
1712
Felipe Lemee184f662016-10-27 10:04:47 -07001713 AddAnrTraceFiles();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001714
Primiano Tuccifaaaafb2021-01-14 12:26:29 +00001715 MaybeAddSystemTraceToZip();
1716
Narayan Kamath8f788292017-05-25 13:20:39 +01001717 // NOTE: tombstones are always added as separate entries in the zip archive
1718 // and are not interspersed with the main report.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001719 const bool tombstones_dumped = AddDumps(ds.tombstone_data_.begin(), ds.tombstone_data_.end(),
Narayan Kamathbd863722017-06-01 18:50:12 +01001720 "TOMBSTONE", true /* add_to_zip */);
Narayan Kamath8f788292017-05-25 13:20:39 +01001721 if (!tombstones_dumped) {
1722 printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR.c_str());
Christopher Ferris7dc7f322014-07-22 16:08:19 -07001723 }
1724
Jayachandran Ca94c7172017-06-10 15:08:12 -07001725 DumpPacketStats();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001726
Lorenzo Colitti807f2dd2022-05-27 12:48:37 +09001727 RunDumpsys("EBPF MAP STATS", {"connectivity", "trafficcontroller"});
Chenbo Feng276a3b62018-08-07 11:44:49 -07001728
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001729 DoKmsg();
Mark Salyzyn2262c162014-12-16 09:09:26 -08001730
Woody Lin20767a92022-11-29 15:50:24 +08001731 DumpShutdownCheckpoints();
1732
Jayachandran Ca94c7172017-06-10 15:08:12 -07001733 DumpIpAddrAndRules();
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -07001734
1735 dump_route_tables();
1736
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001737 RunCommand("ARP CACHE", {"ip", "-4", "neigh", "show"});
1738 RunCommand("IPv6 ND CACHE", {"ip", "-6", "neigh", "show"});
1739 RunCommand("MULTICAST ADDRESSES", {"ip", "maddr"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001740
Nandana Dutt5c390032019-03-12 10:52:56 +00001741 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunDumpsysHigh);
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001742
Chiachang Wang668ede42021-05-17 17:14:20 +08001743 // The dump mechanism in connectivity is refactored due to modularization work. Connectivity can
1744 // only register with a default priority(NORMAL priority). Dumpstate has to call connectivity
1745 // dump with priority parameters to dump high priority information.
1746 RunDumpsys("SERVICE HIGH connectivity", {"connectivity", "--dump-priority", "HIGH"},
1747 CommandOptions::WithTimeout(10).Build());
1748
Elliott Hughes23ccc622017-02-28 10:14:22 -08001749 RunCommand("SYSTEM PROPERTIES", {"getprop"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001750
Jin Qianf334d662017-10-10 14:41:37 -07001751 RunCommand("STORAGED IO INFO", {"storaged", "-u", "-p"});
ynwangf649a6e2016-07-17 21:56:00 -07001752
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001753 RunCommand("FILESYSTEMS & FREE SPACE", {"df"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001754
Colin Crossf45fa6b2012-03-26 12:38:26 -07001755 /* Binder state is expensive to look at as it uses a lot of memory. */
Hridya Valsaraju920ba712020-02-09 16:27:01 -08001756 std::string binder_logs_dir = access("/dev/binderfs/binder_logs", R_OK) ?
1757 "/sys/kernel/debug/binder" : "/dev/binderfs/binder_logs";
1758
1759 DumpFile("BINDER FAILED TRANSACTION LOG", binder_logs_dir + "/failed_transaction_log");
1760 DumpFile("BINDER TRANSACTION LOG", binder_logs_dir + "/transaction_log");
1761 DumpFile("BINDER TRANSACTIONS", binder_logs_dir + "/transactions");
1762 DumpFile("BINDER STATS", binder_logs_dir + "/stats");
1763 DumpFile("BINDER STATE", binder_logs_dir + "/state");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001764
Vishnu Nair36b4cdb2017-11-17 10:27:05 -08001765 /* Add window and surface trace files. */
1766 if (!PropertiesHelper::IsUserBuild()) {
1767 ds.AddDir(WMTRACE_DATA_DIR, false);
1768 }
1769
Yifan Hongd90cc652020-02-08 16:52:02 -08001770 ds.AddDir(SNAPSHOTCTL_LOG_DIR, false);
1771
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001772 if (ds.dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08001773 WAIT_TASK_WITH_CONSENT_CHECK(std::move(dump_board));
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001774 } else {
1775 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_BOARD_TASK, ds.DumpstateBoard);
1776 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001777
Steven Moreland7440ddb2016-12-15 16:13:39 -08001778 /* Migrate the ril_dumpstate to a device specific dumpstate? */
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001779 int rilDumpstateTimeout = android::base::GetIntProperty("ril.dumpstate.timeout", 0);
1780 if (rilDumpstateTimeout > 0) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001781 // su does not exist on user builds, so try running without it.
1782 // This way any implementations of vril-dump that do not require
1783 // root can run on user builds.
1784 CommandOptions::CommandOptionsBuilder options =
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001785 CommandOptions::WithTimeout(rilDumpstateTimeout);
Felipe Lemef0292972016-11-22 13:57:05 -08001786 if (!PropertiesHelper::IsUserBuild()) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001787 options.AsRoot();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001788 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001789 RunCommand("DUMP VENDOR RIL LOGS", {"vril-dump"}, options.Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001790 }
1791
Felipe Lemed8b94e52016-12-08 10:21:44 -08001792 printf("========================================================\n");
1793 printf("== Android Framework Services\n");
1794 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001795
Nandana Dutt5c390032019-03-12 10:52:56 +00001796 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunDumpsysNormal);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001797
Jack He91ff2fe2021-02-18 18:23:43 -08001798 /* Dump Bluetooth HCI logs after getting bluetooth_manager dumpsys */
1799 ds.AddDir("/data/misc/bluetooth/logs", true);
1800
Rhed Jaoe017f982020-07-21 17:58:41 +08001801 if (ds.dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08001802 WAIT_TASK_WITH_CONSENT_CHECK(std::move(dump_checkins));
Rhed Jaoe017f982020-07-21 17:58:41 +08001803 } else {
1804 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_CHECKINS_TASK, DumpCheckins);
1805 }
Dianne Hackborn02bea972013-06-26 18:59:09 -07001806
Rhed Jaoc5f7ec32020-12-22 22:11:08 +08001807 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(DumpAppInfos);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001808
Adrian Roos8b397ab2017-04-04 16:35:44 -07001809 printf("========================================================\n");
1810 printf("== Dropbox crashes\n");
1811 printf("========================================================\n");
1812
1813 RunDumpsys("DROPBOX SYSTEM SERVER CRASHES", {"dropbox", "-p", "system_server_crash"});
1814 RunDumpsys("DROPBOX SYSTEM APP CRASHES", {"dropbox", "-p", "system_app_crash"});
1815
Felipe Lemed8b94e52016-12-08 10:21:44 -08001816 printf("========================================================\n");
1817 printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),
1818 ds.progress_->GetMax(), ds.progress_->GetInitialMax());
1819 printf("========================================================\n");
1820 printf("== dumpstate: done (id %d)\n", ds.id_);
1821 printf("========================================================\n");
Bookatz38472142018-09-28 10:20:24 -07001822
1823 printf("========================================================\n");
1824 printf("== Obtaining statsd metadata\n");
1825 printf("========================================================\n");
1826 // This differs from the usual dumpsys stats, which is the stats report data.
1827 RunDumpsys("STATSDSTATS", {"stats", "--metadata"});
Mike Ma5c267872019-08-21 11:31:34 -07001828
Kiyoung Kimc2d22ac2020-02-04 19:43:36 +09001829 // Add linker configuration directory
1830 ds.AddDir(LINKERCONFIG_DIR, true);
1831
Li Li830179f2022-01-04 12:53:29 -08001832 /* Dump frozen cgroupfs */
1833 dump_frozen_cgroupfs();
Li Li2eedd412021-06-30 15:11:53 -07001834
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001835 if (ds.dump_pool_) {
Aaron Huanga99452a2022-04-27 18:51:16 +08001836 WAIT_TASK_WITH_CONSENT_CHECK(std::move(dump_netstats_report));
1837 } else {
1838 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_NETSTATS_PROTO_TASK,
1839 DumpNetstatsProto);
1840 }
1841
1842 if (ds.dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08001843 WAIT_TASK_WITH_CONSENT_CHECK(std::move(dump_incident_report));
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08001844 } else {
1845 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_INCIDENT_REPORT_TASK,
1846 DumpIncidentReport);
1847 }
Mike Ma5c267872019-08-21 11:31:34 -07001848
Nandana Dutt5c390032019-03-12 10:52:56 +00001849 return Dumpstate::RunStatus::OK;
Colin Crossf45fa6b2012-03-26 12:38:26 -07001850}
1851
Nandana Dutt5c390032019-03-12 10:52:56 +00001852/*
1853 * Dumps state for the default case; drops root after it's no longer necessary.
1854 *
1855 * Returns RunStatus::OK if everything went fine.
1856 * Returns RunStatus::ERROR if there was an error.
1857 * Returns RunStatus::USER_DENIED_CONSENT if user explicitly denied consent to sharing the bugreport
1858 * with the caller.
1859 */
Jichao Lie89d9c12019-11-21 19:02:51 -08001860Dumpstate::RunStatus Dumpstate::DumpstateDefaultAfterCritical() {
Nandana Duttdb379fa2019-10-09 16:54:41 +01001861 // Capture first logcat early on; useful to take a snapshot before dumpstate logs take over the
1862 // buffer.
1863 DoLogcat();
1864 // Capture timestamp after first logcat to use in next logcat
1865 time_t logcat_ts = time(nullptr);
1866
Nandana Dutt4be45d12018-09-26 15:04:23 +01001867 /* collect stack traces from Dalvik and native processes (needs root) */
Chris Morinbc223142022-02-04 14:17:11 -08001868 std::future<std::string> dump_traces;
Rhed Jao5377d792020-07-16 17:37:39 +08001869 if (dump_pool_) {
1870 RETURN_IF_USER_DENIED_CONSENT();
1871 // One thread is enough since we only need to enqueue DumpTraces here.
1872 dump_pool_->start(/* thread_counts = */1);
1873
1874 // DumpTraces takes long time, post it to the another thread in the
1875 // pool, if pool is available
Chris Morinbc223142022-02-04 14:17:11 -08001876 dump_traces = dump_pool_->enqueueTask(
1877 DUMP_TRACES_TASK, &Dumpstate::DumpTraces, &ds, &dump_traces_path);
Rhed Jao5377d792020-07-16 17:37:39 +08001878 } else {
1879 RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK_AND_LOG(DUMP_TRACES_TASK, ds.DumpTraces,
1880 &dump_traces_path);
1881 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001882
1883 /* Run some operations that require root. */
Gavin Corkeryf18d1832021-08-25 17:23:40 +01001884 if (!PropertiesHelper::IsDryRun()) {
Chris Morinc2cba7a2022-02-01 17:06:50 -08001885 ds.tombstone_data_ = GetDumpFds(TOMBSTONE_DIR, TOMBSTONE_FILE_PREFIX);
1886 ds.anr_data_ = GetDumpFds(ANR_DIR, ANR_FILE_PREFIX);
Woody Lin20767a92022-11-29 15:50:24 +08001887 ds.shutdown_checkpoints_ = GetDumpFds(
1888 SHUTDOWN_CHECKPOINTS_DIR, SHUTDOWN_CHECKPOINTS_FILE_PREFIX);
Gavin Corkeryf18d1832021-08-25 17:23:40 +01001889 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001890
1891 ds.AddDir(RECOVERY_DIR, true);
1892 ds.AddDir(RECOVERY_DATA_DIR, true);
1893 ds.AddDir(UPDATE_ENGINE_LOG_DIR, true);
Kelvin Zhang6eaa0f92022-09-12 09:29:19 -07001894 ds.AddDir(UPDATE_ENGINE_PREF_DIR, true);
Nandana Dutt4be45d12018-09-26 15:04:23 +01001895 ds.AddDir(LOGPERSIST_DATA_DIR, false);
1896 if (!PropertiesHelper::IsUserBuild()) {
1897 ds.AddDir(PROFILE_DATA_DIR_CUR, true);
1898 ds.AddDir(PROFILE_DATA_DIR_REF, true);
Calin Juravlef84d3692020-04-28 15:31:12 -07001899 ds.AddZipEntry(ZIP_ROOT_DIR + PACKAGE_DEX_USE_LIST, PACKAGE_DEX_USE_LIST);
Nandana Dutt4be45d12018-09-26 15:04:23 +01001900 }
Jerry Changa1df8a92020-01-02 16:03:39 +08001901 ds.AddDir(PREREBOOT_DATA_DIR, false);
Nandana Dutt4be45d12018-09-26 15:04:23 +01001902 add_mountinfo();
Peter Collingbourne78aa2942023-02-15 14:50:31 -08001903 for (const char* path : {"/proc/cpuinfo", "/proc/meminfo"}) {
1904 ds.AddZipEntry(ZIP_ROOT_DIR + path, path);
1905 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001906 DumpIpTablesAsRoot();
David Andersond9ba4752018-12-11 18:26:59 -08001907 DumpDynamicPartitionInfo();
Yifan Hong3945e1b2019-10-29 12:59:23 -07001908 ds.AddDir(OTA_METADATA_DIR, true);
Jeff Sharkey9df29d52023-02-06 14:26:30 -07001909 if (!PropertiesHelper::IsUserBuild()) {
1910 // Include dropbox entry files inside ZIP, but exclude
1911 // noisy WTF and StrictMode entries
1912 dump_files("", DROPBOX_DIR, skip_wtf_strictmode, _add_file_from_fd);
1913 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001914
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001915 // Capture any IPSec policies in play. No keys are exposed here.
Nandana Dutt4be45d12018-09-26 15:04:23 +01001916 RunCommand("IP XFRM POLICY", {"ip", "xfrm", "policy"}, CommandOptions::WithTimeout(10).Build());
1917
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001918 // Dump IPsec stats. No keys are exposed here.
1919 DumpFile("XFRM STATS", XFRM_STAT_PROC_FILE);
1920
Nandana Dutt4be45d12018-09-26 15:04:23 +01001921 // Run ss as root so we can see socket marks.
1922 RunCommand("DETAILED SOCKET STATE", {"ss", "-eionptu"}, CommandOptions::WithTimeout(10).Build());
1923
1924 // Run iotop as root to show top 100 IO threads
1925 RunCommand("IOTOP", {"iotop", "-n", "1", "-m", "100"});
1926
Erick Reyese68df822019-02-11 14:46:36 -08001927 // Gather shared memory buffer info if the product implements it
Hridya Valsaraju1da80c52021-01-09 22:10:11 -08001928 RunCommand("Dmabuf dump", {"dmabuf_dump"});
1929 RunCommand("Dmabuf per-buffer/per-exporter/per-device stats", {"dmabuf_dump", "-b"});
Erick Reyese68df822019-02-11 14:46:36 -08001930
Minchan Kim22c6a1e2019-09-30 15:58:10 -07001931 DumpFile("PSI cpu", "/proc/pressure/cpu");
1932 DumpFile("PSI memory", "/proc/pressure/memory");
1933 DumpFile("PSI io", "/proc/pressure/io");
1934
Mårten Kongstad60195a72022-09-20 14:14:20 +02001935 RunCommand("SDK EXTENSIONS", {SDK_EXT_INFO, "--dump"},
1936 CommandOptions::WithTimeout(10).Always().DropRoot().Build());
1937
Rhed Jao5377d792020-07-16 17:37:39 +08001938 if (dump_pool_) {
1939 RETURN_IF_USER_DENIED_CONSENT();
Chris Morinbc223142022-02-04 14:17:11 -08001940 WaitForTask(std::move(dump_traces));
Rhed Jao5377d792020-07-16 17:37:39 +08001941
Chris Morinbc223142022-02-04 14:17:11 -08001942 // Current running thread in the pool is the root user also. Delete
1943 // the pool and make a new one later to ensure none of threads in the pool are root.
1944 dump_pool_ = std::make_unique<DumpPool>(bugreport_internal_dir_);
Rhed Jao5377d792020-07-16 17:37:39 +08001945 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001946 if (!DropRootUser()) {
Nandana Dutt5c390032019-03-12 10:52:56 +00001947 return Dumpstate::RunStatus::ERROR;
Nandana Dutt4be45d12018-09-26 15:04:23 +01001948 }
1949
Nandana Dutt5c390032019-03-12 10:52:56 +00001950 RETURN_IF_USER_DENIED_CONSENT();
Nandana Duttdb379fa2019-10-09 16:54:41 +01001951 Dumpstate::RunStatus status = dumpstate();
1952 // Capture logcat since the last time we did it.
1953 DoSystemLogcat(logcat_ts);
1954 return status;
Nandana Dutt4be45d12018-09-26 15:04:23 +01001955}
1956
Rhed Jaob5685b32020-08-14 17:19:17 +08001957// Common states for telephony and wifi which are needed to be collected before
1958// dumpstate drop the root user.
1959static void DumpstateRadioAsRoot() {
1960 DumpIpTablesAsRoot();
1961 ds.AddDir(LOGPERSIST_DATA_DIR, false);
1962}
1963
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001964// This method collects common dumpsys for telephony and wifi. Typically, wifi
1965// reports are fine to include all information, but telephony reports on user
1966// builds need to strip some content (see DumpstateTelephonyOnly).
1967static void DumpstateRadioCommon(bool include_sensitive_info = true) {
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001968 // We need to be picky about some stuff for telephony reports on user builds.
1969 if (!include_sensitive_info) {
1970 // Only dump the radio log buffer (other buffers and dumps contain too much unrelated info).
1971 DoRadioLogcat();
1972 } else {
Rhed Jaob5685b32020-08-14 17:19:17 +08001973 // DumpHals takes long time, post it to the another thread in the pool,
1974 // if pool is available.
Chris Morinbc223142022-02-04 14:17:11 -08001975 std::future<std::string> dump_hals;
Rhed Jaob5685b32020-08-14 17:19:17 +08001976 if (ds.dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08001977 dump_hals = ds.dump_pool_->enqueueTaskWithFd(DUMP_HALS_TASK, &DumpHals, _1);
Rhed Jaob5685b32020-08-14 17:19:17 +08001978 }
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001979 // Contains various system properties and process startup info.
1980 do_dmesg();
1981 // Logs other than the radio buffer may contain package/component names and potential PII.
1982 DoLogcat();
1983 // Too broad for connectivity problems.
1984 DoKmsg();
Rhed Jaob5685b32020-08-14 17:19:17 +08001985 // DumpHals contains unrelated hardware info (camera, NFC, biometrics, ...).
1986 if (ds.dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08001987 WaitForTask(std::move(dump_hals));
Rhed Jaob5685b32020-08-14 17:19:17 +08001988 } else {
1989 RUN_SLOW_FUNCTION_AND_LOG(DUMP_HALS_TASK, DumpHals);
1990 }
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08001991 }
1992
Jayachandran Ca94c7172017-06-10 15:08:12 -07001993 DumpPacketStats();
Jayachandran Ca94c7172017-06-10 15:08:12 -07001994 DumpIpAddrAndRules();
1995 dump_route_tables();
Jayachandran Ca94c7172017-06-10 15:08:12 -07001996 RunDumpsys("NETWORK DIAGNOSTICS", {"connectivity", "--diag"},
1997 CommandOptions::WithTimeout(10).Build());
mukesh agrawal253dad42018-01-23 21:59:59 -08001998}
1999
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002000// We use "telephony" here for legacy reasons, though this now really means "connectivity" (cellular
2001// + wifi + networking). This method collects dumpsys for connectivity debugging only. General rules
2002// for what can be included on user builds: all reported information MUST directly relate to
2003// connectivity debugging or customer support and MUST NOT contain unrelated personally identifiable
2004// information. This information MUST NOT identify user-installed packages (UIDs are OK, package
2005// names are not), and MUST NOT contain logs of user application traffic.
2006// TODO(b/148168577) rename this and other related fields/methods to "connectivity" instead.
Hunter Knepshield0cc6c212020-01-07 16:57:10 -08002007static void DumpstateTelephonyOnly(const std::string& calling_package) {
mukesh agrawal253dad42018-01-23 21:59:59 -08002008 DurationReporter duration_reporter("DUMPSTATE");
Jichao Lie89d9c12019-11-21 19:02:51 -08002009
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07002010 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
mukesh agrawal253dad42018-01-23 21:59:59 -08002011
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002012 const bool include_sensitive_info = !PropertiesHelper::IsUserBuild();
Jayachandran Ca94c7172017-06-10 15:08:12 -07002013
Rhed Jaob5685b32020-08-14 17:19:17 +08002014 DumpstateRadioAsRoot();
2015 if (!DropRootUser()) {
2016 return;
2017 }
2018
2019 // Starts thread pool after the root user is dropped, and two additional threads
2020 // are created for DumpHals in the DumpstateRadioCommon and DumpstateBoard.
Chris Morinbc223142022-02-04 14:17:11 -08002021 std::future<std::string> dump_board;
Rhed Jaob5685b32020-08-14 17:19:17 +08002022 if (ds.dump_pool_) {
2023 ds.dump_pool_->start(/*thread_counts =*/2);
2024
2025 // DumpstateBoard takes long time, post it to the another thread in the pool,
2026 // if pool is available.
Chris Morinbc223142022-02-04 14:17:11 -08002027 dump_board = ds.dump_pool_->enqueueTaskWithFd(
2028 DUMP_BOARD_TASK, &Dumpstate::DumpstateBoard, &ds, _1);
Rhed Jaob5685b32020-08-14 17:19:17 +08002029 }
2030
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002031 DumpstateRadioCommon(include_sensitive_info);
2032
2033 if (include_sensitive_info) {
2034 // Contains too much unrelated PII, and given the unstructured nature of sysprops, we can't
2035 // really cherrypick all of the connectivity-related ones. Apps generally have no business
2036 // reading these anyway, and there should be APIs to supply the info in a more app-friendly
2037 // way.
2038 RunCommand("SYSTEM PROPERTIES", {"getprop"});
2039 }
Jayachandran Ca94c7172017-06-10 15:08:12 -07002040
2041 printf("========================================================\n");
2042 printf("== Android Framework Services\n");
2043 printf("========================================================\n");
2044
Vishnu Nair652cc802017-11-30 15:18:30 -08002045 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
2046 SEC_TO_MSEC(10));
Hunter Knepshield31cbae12021-05-11 16:23:24 -07002047 RunDumpsys("DUMPSYS", {"vcn_management"}, CommandOptions::WithTimeout(90).Build(),
2048 SEC_TO_MSEC(10));
Hunter Knepshield0cc6c212020-01-07 16:57:10 -08002049 if (include_sensitive_info) {
2050 // Carrier apps' services will be dumped below in dumpsys activity service all-non-platform.
2051 RunDumpsys("DUMPSYS", {"carrier_config"}, CommandOptions::WithTimeout(90).Build(),
2052 SEC_TO_MSEC(10));
2053 } else {
2054 // If the caller is a carrier app and has a carrier service, dump it here since we aren't
2055 // running dumpsys activity service all-non-platform below. Due to the increased output, we
2056 // give a higher timeout as well.
2057 RunDumpsys("DUMPSYS", {"carrier_config", "--requesting-package", calling_package},
2058 CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(30));
2059 }
2060 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002061 RunDumpsys("DUMPSYS", {"netpolicy"}, CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
2062 RunDumpsys("DUMPSYS", {"network_management"}, CommandOptions::WithTimeout(90).Build(),
Sooraj Sasindrane8d98912018-04-20 11:31:55 -07002063 SEC_TO_MSEC(10));
Hunter Knepshield0fe51b12020-03-05 16:58:20 -08002064 RunDumpsys("DUMPSYS", {"telephony.registry"}, CommandOptions::WithTimeout(90).Build(),
2065 SEC_TO_MSEC(10));
Jack Yu773cc032023-03-16 22:43:39 -07002066 RunDumpsys("DUMPSYS", {"isub"}, CommandOptions::WithTimeout(90).Build(),
2067 SEC_TO_MSEC(10));
Grant Menke9bf3b2b2023-02-24 13:11:07 -08002068 RunDumpsys("DUMPSYS", {"telecom"}, CommandOptions::WithTimeout(90).Build(),
2069 SEC_TO_MSEC(10));
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002070 if (include_sensitive_info) {
2071 // Contains raw IP addresses, omit from reports on user builds.
2072 RunDumpsys("DUMPSYS", {"netd"}, CommandOptions::WithTimeout(90).Build(), SEC_TO_MSEC(10));
2073 // Contains raw destination IP/MAC addresses, omit from reports on user builds.
2074 RunDumpsys("DUMPSYS", {"connmetrics"}, CommandOptions::WithTimeout(90).Build(),
2075 SEC_TO_MSEC(10));
2076 // Contains package/component names, omit from reports on user builds.
2077 RunDumpsys("BATTERYSTATS", {"batterystats"}, CommandOptions::WithTimeout(90).Build(),
2078 SEC_TO_MSEC(10));
2079 // Contains package names, but should be relatively simple to remove them (also contains
2080 // UIDs already), omit from reports on user builds.
2081 RunDumpsys("BATTERYSTATS", {"deviceidle"}, CommandOptions::WithTimeout(90).Build(),
2082 SEC_TO_MSEC(10));
2083 }
Jayachandran Ca94c7172017-06-10 15:08:12 -07002084
2085 printf("========================================================\n");
2086 printf("== Running Application Services\n");
2087 printf("========================================================\n");
2088
2089 RunDumpsys("TELEPHONY SERVICES", {"activity", "service", "TelephonyDebugService"});
2090
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002091 if (include_sensitive_info) {
2092 printf("========================================================\n");
2093 printf("== Running Application Services (non-platform)\n");
2094 printf("========================================================\n");
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07002095
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002096 // Contains package/component names and potential PII, omit from reports on user builds.
2097 // To get dumps of the active CarrierService(s) on user builds, we supply an argument to the
2098 // carrier_config dumpsys instead.
2099 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
2100 DUMPSYS_COMPONENTS_OPTIONS);
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07002101
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002102 printf("========================================================\n");
2103 printf("== Checkins\n");
2104 printf("========================================================\n");
Kelly Rossmoyer769babb2018-08-21 18:06:38 -07002105
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002106 // Contains package/component names, omit from reports on user builds.
2107 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
2108 }
Kelly Rossmoyer769babb2018-08-21 18:06:38 -07002109
2110 printf("========================================================\n");
Jayachandran Ca94c7172017-06-10 15:08:12 -07002111 printf("== dumpstate: done (id %d)\n", ds.id_);
2112 printf("========================================================\n");
Rhed Jaob5685b32020-08-14 17:19:17 +08002113
2114 if (ds.dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08002115 WaitForTask(std::move(dump_board));
Rhed Jaob5685b32020-08-14 17:19:17 +08002116 } else {
2117 RUN_SLOW_FUNCTION_AND_LOG(DUMP_BOARD_TASK, ds.DumpstateBoard);
2118 }
Jayachandran Ca94c7172017-06-10 15:08:12 -07002119}
2120
mukesh agrawal253dad42018-01-23 21:59:59 -08002121// This method collects dumpsys for wifi debugging only
2122static void DumpstateWifiOnly() {
2123 DurationReporter duration_reporter("DUMPSTATE");
2124
Rhed Jaob5685b32020-08-14 17:19:17 +08002125 DumpstateRadioAsRoot();
2126 if (!DropRootUser()) {
2127 return;
2128 }
2129
2130 // Starts thread pool after the root user is dropped. Only one additional
2131 // thread is needed for DumpHals in the DumpstateRadioCommon.
2132 if (ds.dump_pool_) {
2133 ds.dump_pool_->start(/*thread_counts =*/1);
2134 }
2135
mukesh agrawal253dad42018-01-23 21:59:59 -08002136 DumpstateRadioCommon();
2137
2138 printf("========================================================\n");
2139 printf("== Android Framework Services\n");
2140 printf("========================================================\n");
2141
2142 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
2143 SEC_TO_MSEC(10));
2144 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(),
2145 SEC_TO_MSEC(10));
2146
2147 printf("========================================================\n");
2148 printf("== dumpstate: done (id %d)\n", ds.id_);
2149 printf("========================================================\n");
2150}
2151
Nandana Duttcf419a72019-03-14 10:40:17 +00002152Dumpstate::RunStatus Dumpstate::DumpTraces(const char** path) {
Gavin Corkery789d7a52021-02-24 23:52:35 +00002153 const std::string temp_file_pattern = ds.bugreport_internal_dir_ + "/dumptrace_XXXXXX";
Nandana Duttfaafd522019-03-11 09:23:09 +00002154 const size_t buf_size = temp_file_pattern.length() + 1;
2155 std::unique_ptr<char[]> file_name_buf(new char[buf_size]);
2156 memcpy(file_name_buf.get(), temp_file_pattern.c_str(), buf_size);
2157
2158 // Create a new, empty file to receive all trace dumps.
2159 //
2160 // TODO: This can be simplified once we remove support for the old style
2161 // dumps. We can have a file descriptor passed in to dump_traces instead
2162 // of creating a file, closing it and then reopening it again.
2163 android::base::unique_fd fd(mkostemp(file_name_buf.get(), O_APPEND | O_CLOEXEC));
2164 if (fd < 0) {
2165 MYLOGE("mkostemp on pattern %s: %s\n", file_name_buf.get(), strerror(errno));
Nandana Duttcf419a72019-03-14 10:40:17 +00002166 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002167 }
2168
2169 // Nobody should have access to this temporary file except dumpstate, but we
2170 // temporarily grant 'read' to 'others' here because this file is created
2171 // when tombstoned is still running as root, but dumped after dropping. This
2172 // can go away once support for old style dumping has.
2173 const int chmod_ret = fchmod(fd, 0666);
2174 if (chmod_ret < 0) {
2175 MYLOGE("fchmod on %s failed: %s\n", file_name_buf.get(), strerror(errno));
Nandana Duttcf419a72019-03-14 10:40:17 +00002176 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002177 }
2178
2179 std::unique_ptr<DIR, decltype(&closedir)> proc(opendir("/proc"), closedir);
2180 if (proc.get() == nullptr) {
2181 MYLOGE("opendir /proc failed: %s\n", strerror(errno));
Nandana Duttcf419a72019-03-14 10:40:17 +00002182 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002183 }
2184
2185 // Number of times process dumping has timed out. If we encounter too many
2186 // failures, we'll give up.
2187 int timeout_failures = 0;
2188 bool dalvik_found = false;
2189
Jayant Chowdharya0a8eb22022-05-20 03:30:09 +00002190 const std::set<int> hal_pids = get_interesting_pids();
Nandana Duttfaafd522019-03-11 09:23:09 +00002191
2192 struct dirent* d;
2193 while ((d = readdir(proc.get()))) {
Nandana Duttcf419a72019-03-14 10:40:17 +00002194 RETURN_IF_USER_DENIED_CONSENT();
Nandana Duttfaafd522019-03-11 09:23:09 +00002195 int pid = atoi(d->d_name);
2196 if (pid <= 0) {
2197 continue;
2198 }
2199
2200 const std::string link_name = android::base::StringPrintf("/proc/%d/exe", pid);
2201 std::string exe;
2202 if (!android::base::Readlink(link_name, &exe)) {
2203 continue;
2204 }
2205
2206 bool is_java_process;
2207 if (exe == "/system/bin/app_process32" || exe == "/system/bin/app_process64") {
2208 // Don't bother dumping backtraces for the zygote.
2209 if (IsZygote(pid)) {
2210 continue;
2211 }
2212
2213 dalvik_found = true;
2214 is_java_process = true;
2215 } else if (should_dump_native_traces(exe.c_str()) || hal_pids.find(pid) != hal_pids.end()) {
2216 is_java_process = false;
2217 } else {
2218 // Probably a native process we don't care about, continue.
2219 continue;
2220 }
2221
2222 // If 3 backtrace dumps fail in a row, consider debuggerd dead.
2223 if (timeout_failures == 3) {
2224 dprintf(fd, "ERROR: Too many stack dump failures, exiting.\n");
2225 break;
2226 }
2227
2228 const uint64_t start = Nanotime();
2229 const int ret = dump_backtrace_to_file_timeout(
2230 pid, is_java_process ? kDebuggerdJavaBacktrace : kDebuggerdNativeBacktrace,
2231 is_java_process ? 5 : 20, fd);
2232
2233 if (ret == -1) {
2234 // For consistency, the header and footer to this message match those
2235 // dumped by debuggerd in the success case.
2236 dprintf(fd, "\n---- pid %d at [unknown] ----\n", pid);
2237 dprintf(fd, "Dump failed, likely due to a timeout.\n");
2238 dprintf(fd, "---- end %d ----", pid);
2239 timeout_failures++;
2240 continue;
2241 }
2242
2243 // We've successfully dumped stack traces, reset the failure count
2244 // and write a summary of the elapsed time to the file and continue with the
2245 // next process.
2246 timeout_failures = 0;
2247
2248 dprintf(fd, "[dump %s stack %d: %.3fs elapsed]\n", is_java_process ? "dalvik" : "native",
2249 pid, (float)(Nanotime() - start) / NANOS_PER_SEC);
2250 }
2251
2252 if (!dalvik_found) {
2253 MYLOGE("Warning: no Dalvik processes found to dump stacks\n");
2254 }
2255
Nandana Duttcf419a72019-03-14 10:40:17 +00002256 *path = file_name_buf.release();
2257 return RunStatus::OK;
Nandana Duttfaafd522019-03-11 09:23:09 +00002258}
2259
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002260static dumpstate_hal_hidl::DumpstateMode GetDumpstateHalModeHidl(
2261 const Dumpstate::BugreportMode bugreport_mode) {
2262 switch (bugreport_mode) {
2263 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2264 return dumpstate_hal_hidl::DumpstateMode::FULL;
2265 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
2266 return dumpstate_hal_hidl::DumpstateMode::INTERACTIVE;
2267 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
2268 return dumpstate_hal_hidl::DumpstateMode::REMOTE;
2269 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
2270 return dumpstate_hal_hidl::DumpstateMode::WEAR;
2271 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
2272 return dumpstate_hal_hidl::DumpstateMode::CONNECTIVITY;
2273 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
2274 return dumpstate_hal_hidl::DumpstateMode::WIFI;
2275 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2276 return dumpstate_hal_hidl::DumpstateMode::DEFAULT;
2277 }
2278 return dumpstate_hal_hidl::DumpstateMode::DEFAULT;
2279}
2280
2281static dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode GetDumpstateHalModeAidl(
2282 const Dumpstate::BugreportMode bugreport_mode) {
2283 switch (bugreport_mode) {
2284 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2285 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::FULL;
2286 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
2287 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::INTERACTIVE;
2288 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
2289 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::REMOTE;
2290 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
2291 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::WEAR;
2292 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
2293 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::CONNECTIVITY;
2294 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
2295 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::WIFI;
2296 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2297 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::DEFAULT;
2298 }
2299 return dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode::DEFAULT;
2300}
2301
2302static void DoDumpstateBoardHidl(
2303 const sp<dumpstate_hal_hidl_1_0::IDumpstateDevice> dumpstate_hal_1_0,
2304 const std::vector<::ndk::ScopedFileDescriptor>& dumpstate_fds,
2305 const Dumpstate::BugreportMode bugreport_mode,
2306 const size_t timeout_sec) {
2307
2308 using ScopedNativeHandle =
2309 std::unique_ptr<native_handle_t, std::function<void(native_handle_t*)>>;
2310 ScopedNativeHandle handle(native_handle_create(static_cast<int>(dumpstate_fds.size()), 0),
2311 [](native_handle_t* handle) {
2312 // we don't close file handle's here
2313 // via native_handle_close(handle)
2314 // instead we let dumpstate_fds close the file handles when
2315 // dumpstate_fds gets destroyed
2316 native_handle_delete(handle);
2317 });
2318 if (handle == nullptr) {
2319 MYLOGE("Could not create native_handle for dumpstate HAL\n");
2320 return;
2321 }
2322
2323 for (size_t i = 0; i < dumpstate_fds.size(); i++) {
2324 handle.get()->data[i] = dumpstate_fds[i].get();
2325 }
2326
2327 // Prefer version 1.1 if available. New devices launching with R are no longer allowed to
2328 // implement just 1.0.
2329 const char* descriptor_to_kill;
2330 using DumpstateBoardTask = std::packaged_task<bool()>;
2331 DumpstateBoardTask dumpstate_board_task;
2332 sp<dumpstate_hal_hidl::IDumpstateDevice> dumpstate_hal(
2333 dumpstate_hal_hidl::IDumpstateDevice::castFrom(dumpstate_hal_1_0));
2334 if (dumpstate_hal != nullptr) {
2335 MYLOGI("Using IDumpstateDevice v1.1 HIDL HAL");
2336
2337 dumpstate_hal_hidl::DumpstateMode dumpstate_hal_mode =
2338 GetDumpstateHalModeHidl(bugreport_mode);
2339
2340 descriptor_to_kill = dumpstate_hal_hidl::IDumpstateDevice::descriptor;
2341 dumpstate_board_task =
2342 DumpstateBoardTask([timeout_sec, dumpstate_hal_mode, dumpstate_hal, &handle]() -> bool {
2343 ::android::hardware::Return<dumpstate_hal_hidl::DumpstateStatus> status =
2344 dumpstate_hal->dumpstateBoard_1_1(handle.get(), dumpstate_hal_mode,
2345 SEC_TO_MSEC(timeout_sec));
2346 if (!status.isOk()) {
2347 MYLOGE("dumpstateBoard failed: %s\n", status.description().c_str());
2348 return false;
2349 } else if (status != dumpstate_hal_hidl::DumpstateStatus::OK) {
2350 MYLOGE("dumpstateBoard failed with DumpstateStatus::%s\n",
2351 dumpstate_hal_hidl::toString(status).c_str());
2352 return false;
2353 }
2354 return true;
2355 });
2356 } else {
2357 MYLOGI("Using IDumpstateDevice v1.0 HIDL HAL");
2358
2359 descriptor_to_kill = dumpstate_hal_hidl_1_0::IDumpstateDevice::descriptor;
2360 dumpstate_board_task = DumpstateBoardTask([dumpstate_hal_1_0, &handle]() -> bool {
2361 ::android::hardware::Return<void> status =
2362 dumpstate_hal_1_0->dumpstateBoard(handle.get());
2363 if (!status.isOk()) {
2364 MYLOGE("dumpstateBoard failed: %s\n", status.description().c_str());
2365 return false;
2366 }
2367 return true;
2368 });
2369 }
2370 auto result = dumpstate_board_task.get_future();
2371 std::thread(std::move(dumpstate_board_task)).detach();
2372
2373 if (result.wait_for(std::chrono::seconds(timeout_sec)) != std::future_status::ready) {
2374 MYLOGE("dumpstateBoard timed out after %zus, killing dumpstate HAL\n", timeout_sec);
2375 if (!android::base::SetProperty(
2376 "ctl.interface_restart",
2377 android::base::StringPrintf("%s/default", descriptor_to_kill))) {
2378 MYLOGE("Couldn't restart dumpstate HAL\n");
2379 }
2380 }
2381 // Wait some time for init to kill dumpstate vendor HAL
2382 constexpr size_t killing_timeout_sec = 10;
2383 if (result.wait_for(std::chrono::seconds(killing_timeout_sec)) != std::future_status::ready) {
2384 MYLOGE(
2385 "killing dumpstateBoard timed out after %zus, continue and "
2386 "there might be racing in content\n",
2387 killing_timeout_sec);
2388 }
2389}
2390
2391static void DoDumpstateBoardAidl(
2392 const std::shared_ptr<dumpstate_hal_aidl::IDumpstateDevice> dumpstate_hal,
2393 const std::vector<::ndk::ScopedFileDescriptor>& dumpstate_fds,
2394 const Dumpstate::BugreportMode bugreport_mode, const size_t timeout_sec) {
2395 MYLOGI("Using IDumpstateDevice AIDL HAL");
2396
2397 const char* descriptor_to_kill;
2398 using DumpstateBoardTask = std::packaged_task<bool()>;
2399 DumpstateBoardTask dumpstate_board_task;
2400 dumpstate_hal_aidl::IDumpstateDevice::DumpstateMode dumpstate_hal_mode =
2401 GetDumpstateHalModeAidl(bugreport_mode);
2402
2403 descriptor_to_kill = dumpstate_hal_aidl::IDumpstateDevice::descriptor;
2404 dumpstate_board_task = DumpstateBoardTask([dumpstate_hal, &dumpstate_fds, dumpstate_hal_mode,
2405 timeout_sec]() -> bool {
2406 auto status = dumpstate_hal->dumpstateBoard(dumpstate_fds, dumpstate_hal_mode, timeout_sec);
2407
2408 if (!status.isOk()) {
2409 MYLOGE("dumpstateBoard failed: %s\n", status.getDescription().c_str());
2410 return false;
2411 }
2412 return true;
2413 });
2414 auto result = dumpstate_board_task.get_future();
2415 std::thread(std::move(dumpstate_board_task)).detach();
2416
2417 if (result.wait_for(std::chrono::seconds(timeout_sec)) != std::future_status::ready) {
2418 MYLOGE("dumpstateBoard timed out after %zus, killing dumpstate HAL\n", timeout_sec);
2419 if (!android::base::SetProperty(
2420 "ctl.interface_restart",
2421 android::base::StringPrintf("%s/default", descriptor_to_kill))) {
2422 MYLOGE("Couldn't restart dumpstate HAL\n");
2423 }
2424 }
2425 // Wait some time for init to kill dumpstate vendor HAL
2426 constexpr size_t killing_timeout_sec = 10;
2427 if (result.wait_for(std::chrono::seconds(killing_timeout_sec)) != std::future_status::ready) {
2428 MYLOGE(
2429 "killing dumpstateBoard timed out after %zus, continue and "
2430 "there might be racing in content\n",
2431 killing_timeout_sec);
2432 }
2433}
2434
2435static std::shared_ptr<dumpstate_hal_aidl::IDumpstateDevice> GetDumpstateBoardAidlService() {
2436 const std::string aidl_instance_name =
2437 std::string(dumpstate_hal_aidl::IDumpstateDevice::descriptor) + "/default";
2438
2439 if (!AServiceManager_isDeclared(aidl_instance_name.c_str())) {
2440 return nullptr;
2441 }
2442
2443 ndk::SpAIBinder dumpstateBinder(AServiceManager_waitForService(aidl_instance_name.c_str()));
2444
2445 return dumpstate_hal_aidl::IDumpstateDevice::fromBinder(dumpstateBinder);
2446}
2447
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08002448void Dumpstate::DumpstateBoard(int out_fd) {
2449 dprintf(out_fd, "========================================================\n");
2450 dprintf(out_fd, "== Board\n");
2451 dprintf(out_fd, "========================================================\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08002452
Hridya Valsaraju9376bfa2020-10-21 15:48:48 -07002453 /*
Hridya Valsarajud09460c2021-04-15 22:11:18 -07002454 * mount debugfs for non-user builds with ro.product.debugfs_restrictions.enabled
Hridya Valsaraju51101602021-04-02 14:32:46 -07002455 * set to true and unmount it after invoking dumpstateBoard_* methods.
2456 * This is to enable debug builds to not have debugfs mounted during runtime.
2457 * It will also ensure that debugfs is only accessed by the dumpstate HAL.
Hridya Valsaraju9376bfa2020-10-21 15:48:48 -07002458 */
Hridya Valsaraju51101602021-04-02 14:32:46 -07002459 auto mount_debugfs =
Hridya Valsarajud09460c2021-04-15 22:11:18 -07002460 android::base::GetBoolProperty("ro.product.debugfs_restrictions.enabled", false);
Hridya Valsaraju9376bfa2020-10-21 15:48:48 -07002461 if (mount_debugfs) {
2462 RunCommand("mount debugfs", {"mount", "-t", "debugfs", "debugfs", "/sys/kernel/debug"},
2463 AS_ROOT_20);
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002464 RunCommand("chmod debugfs", {"chmod", "0755", "/sys/kernel/debug"}, AS_ROOT_20);
Hridya Valsaraju9376bfa2020-10-21 15:48:48 -07002465 }
2466
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002467 std::vector<std::string> paths;
2468 std::vector<android::base::ScopeGuard<std::function<void()>>> remover;
Jie Song9fbfad02017-06-20 16:29:42 -07002469 for (int i = 0; i < NUM_OF_DUMPS; i++) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002470 paths.emplace_back(StringPrintf("%s/%s", ds.bugreport_internal_dir_.c_str(),
2471 kDumpstateBoardFiles[i].c_str()));
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002472 remover.emplace_back(android::base::make_scope_guard(
2473 std::bind([](std::string path) { android::os::UnlinkAndLogOnError(path); }, paths[i])));
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002474 }
Jie Song9fbfad02017-06-20 16:29:42 -07002475
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002476 // get dumpstate HAL AIDL implementation
2477 std::shared_ptr<dumpstate_hal_aidl::IDumpstateDevice> dumpstate_hal_handle_aidl(
2478 GetDumpstateBoardAidlService());
2479 if (dumpstate_hal_handle_aidl == nullptr) {
2480 MYLOGI("No IDumpstateDevice AIDL implementation\n");
2481 }
2482
2483 // get dumpstate HAL HIDL implementation, only if AIDL HAL implementation not found
2484 sp<dumpstate_hal_hidl_1_0::IDumpstateDevice> dumpstate_hal_handle_hidl_1_0 = nullptr;
2485 if (dumpstate_hal_handle_aidl == nullptr) {
2486 dumpstate_hal_handle_hidl_1_0 = dumpstate_hal_hidl_1_0::IDumpstateDevice::getService();
2487 if (dumpstate_hal_handle_hidl_1_0 == nullptr) {
2488 MYLOGI("No IDumpstateDevice HIDL implementation\n");
2489 }
2490 }
2491
2492 // if neither HIDL nor AIDL implementation found, then return
2493 if (dumpstate_hal_handle_hidl_1_0 == nullptr && dumpstate_hal_handle_aidl == nullptr) {
2494 MYLOGE("Could not find IDumpstateDevice implementation\n");
Wei Wang587eac92018-04-05 12:17:20 -07002495 return;
2496 }
2497
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002498 // this is used to hold the file descriptors and when this variable goes out of scope
2499 // the file descriptors are closed
2500 std::vector<::ndk::ScopedFileDescriptor> dumpstate_fds;
Wei Wang587eac92018-04-05 12:17:20 -07002501
Nandana Dutt5c390032019-03-12 10:52:56 +00002502 // TODO(128270426): Check for consent in between?
Wei Wang587eac92018-04-05 12:17:20 -07002503 for (size_t i = 0; i < paths.size(); i++) {
2504 MYLOGI("Calling IDumpstateDevice implementation using path %s\n", paths[i].c_str());
2505
2506 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
2507 open(paths[i].c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
2508 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
2509 if (fd < 0) {
2510 MYLOGE("Could not open file %s: %s\n", paths[i].c_str(), strerror(errno));
2511 return;
2512 }
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002513
2514 dumpstate_fds.emplace_back(fd.release());
2515 // we call fd.release() here to make sure "fd" does not get closed
2516 // after "fd" goes out of scope after this block.
2517 // "fd" will be closed when "dumpstate_fds" goes out of scope
2518 // i.e. when we exit this function
Wei Wang587eac92018-04-05 12:17:20 -07002519 }
2520
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002521 // Given that bugreport is required to diagnose failures, it's better to set an arbitrary amount
2522 // of timeout for IDumpstateDevice than to block the rest of bugreport. In the timeout case, we
2523 // will kill the HAL and grab whatever it dumped in time.
Michael Eastwood8523ea02022-03-10 16:33:08 -08002524 constexpr size_t timeout_sec = 45;
Wei Wang587eac92018-04-05 12:17:20 -07002525
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002526 if (dumpstate_hal_handle_aidl != nullptr) {
2527 DoDumpstateBoardAidl(dumpstate_hal_handle_aidl, dumpstate_fds, options_->bugreport_mode,
2528 timeout_sec);
2529 } else if (dumpstate_hal_handle_hidl_1_0 != nullptr) {
2530 // run HIDL HAL only if AIDL HAL not found
2531 DoDumpstateBoardHidl(dumpstate_hal_handle_hidl_1_0, dumpstate_fds, options_->bugreport_mode,
2532 timeout_sec);
Wei Wang587eac92018-04-05 12:17:20 -07002533 }
2534
Hridya Valsaraju9376bfa2020-10-21 15:48:48 -07002535 if (mount_debugfs) {
Hridya Valsaraju51101602021-04-02 14:32:46 -07002536 auto keep_debugfs_mounted =
2537 android::base::GetProperty("persist.dbg.keep_debugfs_mounted", "");
2538 if (keep_debugfs_mounted.empty())
2539 RunCommand("unmount debugfs", {"umount", "/sys/kernel/debug"}, AS_ROOT_20);
Hridya Valsaraju9376bfa2020-10-21 15:48:48 -07002540 }
2541
Wei Wang587eac92018-04-05 12:17:20 -07002542 auto file_sizes = std::make_unique<ssize_t[]>(paths.size());
2543 for (size_t i = 0; i < paths.size(); i++) {
2544 struct stat s;
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002545 if (fstat(dumpstate_fds[i].get(), &s) == -1) {
2546 MYLOGE("Failed to fstat %s: %s\n", kDumpstateBoardFiles[i].c_str(), strerror(errno));
Wei Wang587eac92018-04-05 12:17:20 -07002547 file_sizes[i] = -1;
2548 continue;
2549 }
2550 file_sizes[i] = s.st_size;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002551 }
2552
2553 for (size_t i = 0; i < paths.size(); i++) {
2554 if (file_sizes[i] == -1) {
2555 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07002556 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002557 if (file_sizes[i] == 0) {
Jie Song9fbfad02017-06-20 16:29:42 -07002558 MYLOGE("Ignoring empty %s\n", kDumpstateBoardFiles[i].c_str());
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07002559 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07002560 }
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08002561 remover[i].Disable();
2562 EnqueueAddZipEntryAndCleanupIfNeeded(kDumpstateBoardFiles[i], paths[i]);
2563 dprintf(out_fd, "*** See %s entry ***\n", kDumpstateBoardFiles[i].c_str());
Jie Song9fbfad02017-06-20 16:29:42 -07002564 }
Felipe Leme6f674ae2016-11-18 17:10:33 -08002565}
2566
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002567static void ShowUsage() {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07002568 fprintf(stderr,
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002569 "usage: dumpstate [-h] [-b soundfile] [-e soundfile] [-o directory] [-p] "
2570 "[-s] [-S] [-q] [-P] [-R] [-L] [-V version]\n"
Felipe Leme4a0db9f2016-09-28 09:35:01 -07002571 " -h: display this help message\n"
2572 " -b: play sound file instead of vibrate, at beginning of job\n"
2573 " -e: play sound file instead of vibrate, at end of job\n"
mhasank2d75c442020-06-11 15:05:25 -07002574 " -o: write to custom directory (only in limited mode)\n"
Abhijeet Kaurbb55a3b2019-06-13 18:07:25 +01002575 " -p: capture screenshot to filename.png\n"
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002576 " -s: write zipped file to control socket (for init)\n"
2577 " -S: write file location to control socket (for init)\n"
Felipe Leme4a0db9f2016-09-28 09:35:01 -07002578 " -q: disable vibrate\n"
Abhijeet Kaure370d682019-10-01 16:49:30 +01002579 " -P: send broadcast when started and do progress updates\n"
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002580 " -R: take bugreport in remote mode (shouldn't be used with -P)\n"
Nandana Dutt235864b2019-01-22 12:10:16 +00002581 " -w: start binder service and make it wait for a call to startBugreport\n"
mhasankd451a472020-05-26 18:02:39 -07002582 " -L: output limited information that is safe for submission in feedback reports\n"
Felipe Lemed071c682016-10-20 16:48:00 -07002583 " -v: prints the dumpstate header and exit\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07002584}
2585
Wei Liuf87959e2016-08-26 14:51:42 -07002586static void register_sig_handler() {
Luis Hector Chavez558e1ef2018-03-22 15:39:17 -07002587 signal(SIGPIPE, SIG_IGN);
Wei Liuf87959e2016-08-26 14:51:42 -07002588}
2589
Felipe Leme1d486fe2016-10-14 18:06:47 -07002590bool Dumpstate::FinishZipFile() {
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08002591 // Runs all enqueued adding zip entry and cleanup tasks before finishing the zip file.
2592 if (zip_entry_tasks_) {
2593 zip_entry_tasks_->run(/* do_cancel = */false);
2594 }
2595
Felipe Leme9a523ae2016-10-20 15:10:33 -07002596 std::string entry_name = base_name_ + "-" + name_ + ".txt";
Felipe Leme1d486fe2016-10-14 18:06:47 -07002597 MYLOGD("Adding main entry (%s) from %s to .zip bugreport\n", entry_name.c_str(),
Felipe Leme9a523ae2016-10-20 15:10:33 -07002598 tmp_path_.c_str());
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07002599 // Final timestamp
2600 char date[80];
2601 time_t the_real_now_please_stand_up = time(nullptr);
2602 strftime(date, sizeof(date), "%Y/%m/%d %H:%M:%S", localtime(&the_real_now_please_stand_up));
Felipe Leme7447d7c2016-11-03 18:12:22 -07002603 MYLOGD("dumpstate id %d finished around %s (%ld s)\n", ds.id_, date,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07002604 the_real_now_please_stand_up - ds.now_);
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07002605
Felipe Leme9a523ae2016-10-20 15:10:33 -07002606 if (!ds.AddZipEntry(entry_name, tmp_path_)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08002607 MYLOGE("Failed to add text entry to .zip file\n");
Felipe Leme1e9edc62015-12-21 16:02:13 -08002608 return false;
2609 }
Felipe Leme1d486fe2016-10-14 18:06:47 -07002610 if (!AddTextZipEntry("main_entry.txt", entry_name)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08002611 MYLOGE("Failed to add main_entry.txt to .zip file\n");
Felipe Leme111b9d02016-02-03 09:28:24 -08002612 return false;
Felipe Leme809d74e2016-02-02 12:57:00 -08002613 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08002614
Felipe Leme0f3fb202016-06-10 17:10:53 -07002615 // Add log file (which contains stderr output) to zip...
2616 fprintf(stderr, "dumpstate_log.txt entry on zip file logged up to here\n");
Felipe Leme9a523ae2016-10-20 15:10:33 -07002617 if (!ds.AddZipEntry("dumpstate_log.txt", ds.log_path_.c_str())) {
Felipe Leme0f3fb202016-06-10 17:10:53 -07002618 MYLOGE("Failed to add dumpstate log to .zip file\n");
2619 return false;
2620 }
Nandana Dutt979388e2018-11-30 16:48:55 +00002621 // TODO: Should truncate the existing file.
2622 // ... and re-open it for further logging.
Nandana Dutta344cb62019-02-22 15:12:35 +00002623 if (!redirect_to_existing_file(stderr, const_cast<char*>(ds.log_path_.c_str()))) {
2624 return false;
2625 }
Felipe Leme0f3fb202016-06-10 17:10:53 -07002626 fprintf(stderr, "\n");
2627
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07002628 int32_t err = zip_writer_->Finish();
Felipe Leme1d486fe2016-10-14 18:06:47 -07002629 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07002630 MYLOGE("zip_writer_->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme1e9edc62015-12-21 16:02:13 -08002631 return false;
2632 }
2633
Felipe Leme1d486fe2016-10-14 18:06:47 -07002634 // TODO: remove once FinishZipFile() is automatically handled by Dumpstate's destructor.
2635 ds.zip_file.reset(nullptr);
2636
Felipe Lemee9d2c542016-11-15 11:48:26 -08002637 MYLOGD("Removing temporary file %s\n", tmp_path_.c_str())
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002638 android::os::UnlinkAndLogOnError(tmp_path_);
Felipe Lemec4eee562016-04-21 15:42:55 -07002639
Felipe Leme1e9edc62015-12-21 16:02:13 -08002640 return true;
2641}
Felipe Leme6e01fa62015-11-11 19:35:14 -08002642
Felipe Lemea4ef1f02017-02-15 17:27:40 -08002643static void SendBroadcast(const std::string& action, const std::vector<std::string>& args) {
2644 // clang-format off
2645 std::vector<std::string> am = {"/system/bin/cmd", "activity", "broadcast", "--user", "0",
2646 "--receiver-foreground", "--receiver-include-background", "-a", action};
2647 // clang-format on
Felipe Leme8d2410e2017-02-08 09:46:08 -08002648
2649 am.insert(am.end(), args.begin(), args.end());
2650
Felipe Leme8d2410e2017-02-08 09:46:08 -08002651 RunCommand("", am,
2652 CommandOptions::WithTimeout(20)
2653 .Log("Sending broadcast: '%s'\n")
2654 .Always()
2655 .DropRoot()
2656 .RedirectStderr()
2657 .Build());
2658}
2659
Felipe Leme35b8cf12017-02-10 15:47:29 -08002660static void Vibrate(int duration_ms) {
2661 // clang-format off
Lais Andrade51156962021-02-22 19:21:35 +00002662 std::vector<std::string> args = {"cmd", "vibrator_manager", "synced", "-f", "-d", "dumpstate",
2663 "oneshot", std::to_string(duration_ms)};
2664 RunCommand("", args,
Felipe Leme35b8cf12017-02-10 15:47:29 -08002665 CommandOptions::WithTimeout(10)
2666 .Log("Vibrate: '%s'\n")
2667 .Always()
2668 .Build());
2669 // clang-format on
2670}
2671
Nandana Dutt979388e2018-11-30 16:48:55 +00002672static void MaybeResolveSymlink(std::string* path) {
2673 std::string resolved_path;
2674 if (android::base::Readlink(*path, &resolved_path)) {
2675 *path = resolved_path;
2676 }
2677}
2678
Nandana Dutt4be45d12018-09-26 15:04:23 +01002679/*
2680 * Prepares state like filename, screenshot path, etc in Dumpstate. Also initializes ZipWriter
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002681 * and adds the version file. Return false if zip_file could not be open to write.
Nandana Dutt4be45d12018-09-26 15:04:23 +01002682 */
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002683static bool PrepareToWriteToFile() {
Nandana Dutt979388e2018-11-30 16:48:55 +00002684 MaybeResolveSymlink(&ds.bugreport_internal_dir_);
2685
Nandana Dutt4be45d12018-09-26 15:04:23 +01002686 std::string build_id = android::base::GetProperty("ro.build.id", "UNKNOWN_BUILD");
2687 std::string device_name = android::base::GetProperty("ro.product.name", "UNKNOWN_DEVICE");
Nandana Dutt9a76d202019-01-21 15:56:48 +00002688 ds.base_name_ = StringPrintf("bugreport-%s-%s", device_name.c_str(), build_id.c_str());
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002689 char date[80];
2690 strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&ds.now_));
2691 ds.name_ = date;
Nandana Dutt4be45d12018-09-26 15:04:23 +01002692
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002693 if (ds.options_->telephony_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002694 ds.base_name_ += "-telephony";
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002695 } else if (ds.options_->wifi_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002696 ds.base_name_ += "-wifi";
2697 }
2698
Paul Chang0d2aad72020-02-13 20:04:03 +08002699 if (ds.options_->do_screenshot) {
Nandana Dutt9d17b942020-03-26 10:02:59 +00002700 ds.screenshot_path_ = ds.GetPath(ds.CalledByApi() ? "-png.tmp" : ".png");
Nandana Dutt4be45d12018-09-26 15:04:23 +01002701 }
2702 ds.tmp_path_ = ds.GetPath(".tmp");
2703 ds.log_path_ = ds.GetPath("-dumpstate_log-" + std::to_string(ds.pid_) + ".txt");
2704
Abhijeet Kaur359b1ff2019-07-26 16:01:36 +01002705 std::string destination = ds.CalledByApi()
Nandana Dutt54dbd672019-01-11 12:58:05 +00002706 ? StringPrintf("[fd:%d]", ds.options_->bugreport_fd.get())
Nandana Dutt9a76d202019-01-21 15:56:48 +00002707 : ds.bugreport_internal_dir_.c_str();
Nandana Dutt4be45d12018-09-26 15:04:23 +01002708 MYLOGD(
Nandana Dutt235c6672019-11-14 15:22:32 +00002709 "Bugreport dir: [%s] "
2710 "Base name: [%s] "
2711 "Suffix: [%s] "
2712 "Log path: [%s] "
2713 "Temporary path: [%s] "
2714 "Screenshot path: [%s]\n",
Nandana Dutt9a76d202019-01-21 15:56:48 +00002715 destination.c_str(), ds.base_name_.c_str(), ds.name_.c_str(), ds.log_path_.c_str(),
2716 ds.tmp_path_.c_str(), ds.screenshot_path_.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01002717
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002718 ds.path_ = ds.GetPath(ds.CalledByApi() ? "-zip.tmp" : ".zip");
2719 MYLOGD("Creating initial .zip file (%s)\n", ds.path_.c_str());
2720 create_parent_dirs(ds.path_.c_str());
2721 ds.zip_file.reset(fopen(ds.path_.c_str(), "wb"));
2722 if (ds.zip_file == nullptr) {
2723 MYLOGE("fopen(%s, 'wb'): %s\n", ds.path_.c_str(), strerror(errno));
2724 return false;
Nandana Dutt4be45d12018-09-26 15:04:23 +01002725 }
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002726 ds.zip_writer_.reset(new ZipWriter(ds.zip_file.get()));
2727 ds.AddTextZipEntry("version.txt", ds.version_);
2728 return true;
Nandana Dutt4be45d12018-09-26 15:04:23 +01002729}
2730
2731/*
Abhijeet Kaure370d682019-10-01 16:49:30 +01002732 * Finalizes writing to the file by zipping the tmp file to the final location,
Nandana Dutt4be45d12018-09-26 15:04:23 +01002733 * printing zipped file status, etc.
2734 */
2735static void FinalizeFile() {
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002736 bool do_text_file = !ds.FinishZipFile();
2737 if (do_text_file) {
2738 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
Nandana Dutt4be45d12018-09-26 15:04:23 +01002739 }
mhasank2d75c442020-06-11 15:05:25 -07002740
2741 std::string final_path = ds.path_;
2742 if (ds.options_->OutputToCustomFile()) {
mhasank3a4cfb42020-06-15 18:06:43 -07002743 final_path = ds.GetPath(ds.options_->out_dir, ".zip");
mhasank2d75c442020-06-11 15:05:25 -07002744 android::os::CopyFileToFile(ds.path_, final_path);
2745 }
2746
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002747 if (ds.options_->stream_to_socket) {
2748 android::os::CopyFileToFd(ds.path_, ds.control_socket_fd_);
2749 } else if (ds.options_->progress_updates_to_socket) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002750 if (do_text_file) {
2751 dprintf(ds.control_socket_fd_,
2752 "FAIL:could not create zip file, check %s "
2753 "for more details\n",
2754 ds.log_path_.c_str());
2755 } else {
mhasank2d75c442020-06-11 15:05:25 -07002756 dprintf(ds.control_socket_fd_, "OK:%s\n", final_path.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01002757 }
2758 }
2759}
2760
Nandana Dutt4be45d12018-09-26 15:04:23 +01002761
Nandana Dutt58d72e22018-11-16 10:30:48 +00002762static inline const char* ModeToString(Dumpstate::BugreportMode mode) {
2763 switch (mode) {
2764 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2765 return "BUGREPORT_FULL";
2766 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
2767 return "BUGREPORT_INTERACTIVE";
2768 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
2769 return "BUGREPORT_REMOTE";
2770 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
2771 return "BUGREPORT_WEAR";
2772 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
2773 return "BUGREPORT_TELEPHONY";
2774 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
2775 return "BUGREPORT_WIFI";
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002776 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2777 return "BUGREPORT_DEFAULT";
Nandana Dutt58d72e22018-11-16 10:30:48 +00002778 }
2779}
2780
Paul Changf59c2b72020-03-10 02:08:55 +08002781static void SetOptionsFromMode(Dumpstate::BugreportMode mode, Dumpstate::DumpOptions* options,
2782 bool is_screenshot_requested) {
Paul Chang0d2aad72020-02-13 20:04:03 +08002783 // Modify com.android.shell.BugreportProgressService#isDefaultScreenshotRequired as well for
2784 // default system screenshots.
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002785 options->bugreport_mode = mode;
2786 options->bugreport_mode_string = ModeToString(mode);
Nandana Dutt58d72e22018-11-16 10:30:48 +00002787 switch (mode) {
2788 case Dumpstate::BugreportMode::BUGREPORT_FULL:
Paul Changf59c2b72020-03-10 02:08:55 +08002789 options->do_screenshot = is_screenshot_requested;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002790 break;
2791 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002792 // Currently, the dumpstate binder is only used by Shell to update progress.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002793 options->do_progress_updates = true;
Paul Changf59c2b72020-03-10 02:08:55 +08002794 options->do_screenshot = is_screenshot_requested;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002795 break;
2796 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002797 options->do_vibrate = false;
2798 options->is_remote_mode = true;
Paul Chang0d2aad72020-02-13 20:04:03 +08002799 options->do_screenshot = false;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002800 break;
2801 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002802 options->do_progress_updates = true;
Paul Changf59c2b72020-03-10 02:08:55 +08002803 options->do_screenshot = is_screenshot_requested;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002804 break;
Hunter Knepshield8540faf2020-02-04 19:47:20 -08002805 // TODO(b/148168577) rename TELEPHONY everywhere to CONNECTIVITY.
Nandana Dutt58d72e22018-11-16 10:30:48 +00002806 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002807 options->telephony_only = true;
Hunter Knepshield820f9bc2020-02-05 20:10:53 -08002808 options->do_progress_updates = true;
Paul Chang0d2aad72020-02-13 20:04:03 +08002809 options->do_screenshot = false;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002810 break;
2811 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002812 options->wifi_only = true;
Paul Chang0d2aad72020-02-13 20:04:03 +08002813 options->do_screenshot = false;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002814 break;
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002815 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2816 break;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002817 }
2818}
2819
Nandana Dutt58d72e22018-11-16 10:30:48 +00002820static void LogDumpOptions(const Dumpstate::DumpOptions& options) {
Nandana Dutt235c6672019-11-14 15:22:32 +00002821 MYLOGI(
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002822 "do_vibrate: %d stream_to_socket: %d progress_updates_to_socket: %d do_screenshot: %d "
Rhed Jao25f50e02020-08-20 00:10:32 +08002823 "is_remote_mode: %d show_header_only: %d telephony_only: %d "
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002824 "wifi_only: %d do_progress_updates: %d fd: %d bugreport_mode: %s "
mhasankd451a472020-05-26 18:02:39 -07002825 "limited_only: %d args: %s\n",
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002826 options.do_vibrate, options.stream_to_socket, options.progress_updates_to_socket,
Paul Chang0d2aad72020-02-13 20:04:03 +08002827 options.do_screenshot, options.is_remote_mode, options.show_header_only,
Rhed Jao25f50e02020-08-20 00:10:32 +08002828 options.telephony_only, options.wifi_only,
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00002829 options.do_progress_updates, options.bugreport_fd.get(),
2830 options.bugreport_mode_string.c_str(),
2831 options.limited_only, options.args.c_str());
Nandana Dutt58d72e22018-11-16 10:30:48 +00002832}
2833
Nandana Dutt54dbd672019-01-11 12:58:05 +00002834void Dumpstate::DumpOptions::Initialize(BugreportMode bugreport_mode,
2835 const android::base::unique_fd& bugreport_fd_in,
Paul Changf59c2b72020-03-10 02:08:55 +08002836 const android::base::unique_fd& screenshot_fd_in,
2837 bool is_screenshot_requested) {
Nandana Dutt54dbd672019-01-11 12:58:05 +00002838 // Duplicate the fds because the passed in fds don't outlive the binder transaction.
Todd Frederick621533f2022-03-26 02:54:17 +00002839 bugreport_fd.reset(fcntl(bugreport_fd_in.get(), F_DUPFD_CLOEXEC, 0));
2840 screenshot_fd.reset(fcntl(screenshot_fd_in.get(), F_DUPFD_CLOEXEC, 0));
Nandana Dutt58d72e22018-11-16 10:30:48 +00002841
Paul Changf59c2b72020-03-10 02:08:55 +08002842 SetOptionsFromMode(bugreport_mode, this, is_screenshot_requested);
Nandana Dutt58d72e22018-11-16 10:30:48 +00002843}
2844
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002845Dumpstate::RunStatus Dumpstate::DumpOptions::Initialize(int argc, char* argv[]) {
2846 RunStatus status = RunStatus::OK;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002847 int c;
mhasankd451a472020-05-26 18:02:39 -07002848 while ((c = getopt(argc, argv, "dho:svqzpLPBRSV:w")) != -1) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002849 switch (c) {
2850 // clang-format off
mhasank3a4cfb42020-06-15 18:06:43 -07002851 case 'o': out_dir = optarg; break;
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002852 case 's': stream_to_socket = true; break;
2853 case 'S': progress_updates_to_socket = true; break;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002854 case 'v': show_header_only = true; break;
2855 case 'q': do_vibrate = false; break;
Paul Chang0d2aad72020-02-13 20:04:03 +08002856 case 'p': do_screenshot = true; break;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002857 case 'P': do_progress_updates = true; break;
2858 case 'R': is_remote_mode = true; break;
mhasankd451a472020-05-26 18:02:39 -07002859 case 'L': limited_only = true; break;
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002860 case 'V':
2861 case 'd':
2862 case 'z':
2863 // compatibility no-op
2864 break;
Nandana Dutt235864b2019-01-22 12:10:16 +00002865 case 'w':
2866 // This was already processed
2867 break;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002868 case 'h':
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002869 status = RunStatus::HELP;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002870 break;
2871 default:
2872 fprintf(stderr, "Invalid option: %c\n", c);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002873 status = RunStatus::INVALID_INPUT;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002874 break;
2875 // clang-format on
2876 }
2877 }
Felipe Leme8fecfdd2016-02-09 10:40:07 -08002878
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002879 for (int i = 0; i < argc; i++) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002880 args += argv[i];
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002881 if (i < argc - 1) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002882 args += " ";
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002883 }
2884 }
2885
2886 // Reset next index used by getopt so this can be called multiple times, for eg, in tests.
2887 optind = 1;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002888
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002889 return status;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002890}
2891
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002892bool Dumpstate::DumpOptions::ValidateOptions() const {
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002893 if (bugreport_fd.get() != -1 && stream_to_socket) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002894 return false;
2895 }
2896
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002897 if ((progress_updates_to_socket || do_progress_updates) && stream_to_socket) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002898 return false;
2899 }
2900
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002901 if (is_remote_mode && (do_progress_updates || stream_to_socket)) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002902 return false;
2903 }
2904 return true;
2905}
2906
Nandana Dutt197661d2018-11-16 16:40:21 +00002907void Dumpstate::SetOptions(std::unique_ptr<DumpOptions> options) {
2908 options_ = std::move(options);
2909}
2910
Abhijeet Kaura407fb82020-03-27 12:51:12 +00002911void Dumpstate::Initialize() {
2912 /* gets the sequential id */
2913 uint32_t last_id = android::base::GetIntProperty(PROPERTY_LAST_ID, 0);
2914 id_ = ++last_id;
2915 android::base::SetProperty(PROPERTY_LAST_ID, std::to_string(last_id));
2916}
2917
Nandana Duttd2f5f082019-01-18 17:13:52 +00002918Dumpstate::RunStatus Dumpstate::Run(int32_t calling_uid, const std::string& calling_package) {
2919 Dumpstate::RunStatus status = RunInternal(calling_uid, calling_package);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002920 if (listener_ != nullptr) {
2921 switch (status) {
2922 case Dumpstate::RunStatus::OK:
Nandana Duttcc4ead82019-01-23 08:29:23 +00002923 listener_->onFinished();
Nandana Duttbabf6c72019-01-15 14:11:12 +00002924 break;
2925 case Dumpstate::RunStatus::HELP:
2926 break;
2927 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002928 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_INVALID_INPUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002929 break;
2930 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002931 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_RUNTIME_ERROR);
2932 break;
2933 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
2934 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_DENIED_CONSENT);
2935 break;
2936 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
2937 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_CONSENT_TIMED_OUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002938 break;
2939 }
2940 }
2941 return status;
2942}
2943
Nandana Dutt8ae16e62020-03-27 10:20:22 +00002944void Dumpstate::Cancel() {
2945 CleanupTmpFiles();
2946 android::os::UnlinkAndLogOnError(log_path_);
2947 for (int i = 0; i < NUM_OF_DUMPS; i++) {
2948 android::os::UnlinkAndLogOnError(ds.bugreport_internal_dir_ + "/" +
2949 kDumpstateBoardFiles[i]);
2950 }
2951 tombstone_data_.clear();
2952 anr_data_.clear();
Woody Lin20767a92022-11-29 15:50:24 +08002953 shutdown_checkpoints_.clear();
Rhed Jao0daac912020-08-21 14:48:20 +08002954
2955 // Instead of shutdown the pool, we delete temporary files directly since
2956 // shutdown blocking the call.
2957 if (dump_pool_) {
2958 dump_pool_->deleteTempFiles();
2959 }
2960 if (zip_entry_tasks_) {
2961 zip_entry_tasks_->run(/*do_cancel =*/ true);
2962 }
Nandana Dutt8ae16e62020-03-27 10:20:22 +00002963}
2964
Nandana Dutt979388e2018-11-30 16:48:55 +00002965/*
2966 * Dumps relevant information to a bugreport based on the given options.
2967 *
2968 * The bugreport can be dumped to a file or streamed to a socket.
2969 *
2970 * How dumping to file works:
2971 * stdout is redirected to a temporary file. This will later become the main bugreport entry.
2972 * stderr is redirected a log file.
2973 *
2974 * The temporary bugreport is then populated via printfs, dumping contents of files and
2975 * output of commands to stdout.
2976 *
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002977 * A bunch of other files and dumps are added to the zip archive.
Nandana Dutt979388e2018-11-30 16:48:55 +00002978 *
Dieter Hsu105ad0c2020-09-29 15:23:33 +08002979 * The temporary bugreport file and the log file also get added to the archive.
Nandana Dutt979388e2018-11-30 16:48:55 +00002980 *
mhasank2d75c442020-06-11 15:05:25 -07002981 * Bugreports are first generated in a local directory and later copied to the caller's fd
2982 * or directory if supplied.
Nandana Dutt979388e2018-11-30 16:48:55 +00002983 */
Nandana Duttd2f5f082019-01-18 17:13:52 +00002984Dumpstate::RunStatus Dumpstate::RunInternal(int32_t calling_uid,
2985 const std::string& calling_package) {
Rhed Jao5377d792020-07-16 17:37:39 +08002986 DurationReporter duration_reporter("RUN INTERNAL", /* logcat_only = */true);
Nandana Dutt979388e2018-11-30 16:48:55 +00002987 LogDumpOptions(*options_);
Nandana Dutt197661d2018-11-16 16:40:21 +00002988 if (!options_->ValidateOptions()) {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002989 MYLOGE("Invalid options specified\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002990 return RunStatus::INVALID_INPUT;
2991 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002992 /* set as high priority, and protect from OOM killer */
2993 setpriority(PRIO_PROCESS, 0, -20);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002994
Felipe Lemed071c682016-10-20 16:48:00 -07002995 FILE* oom_adj = fopen("/proc/self/oom_score_adj", "we");
Colin Crossf45fa6b2012-03-26 12:38:26 -07002996 if (oom_adj) {
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002997 fputs("-1000", oom_adj);
Colin Crossf45fa6b2012-03-26 12:38:26 -07002998 fclose(oom_adj);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002999 } else {
3000 /* fallback to kernels <= 2.6.35 */
3001 oom_adj = fopen("/proc/self/oom_adj", "we");
3002 if (oom_adj) {
3003 fputs("-17", oom_adj);
3004 fclose(oom_adj);
3005 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07003006 }
3007
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003008 if (version_ == VERSION_DEFAULT) {
3009 version_ = VERSION_CURRENT;
Michal Karpinski4db754f2015-12-11 18:04:32 +00003010 }
3011
Chris Morin5a50d482022-02-01 17:41:18 -08003012 if (version_ != VERSION_CURRENT) {
3013 MYLOGE("invalid version requested ('%s'); supported values are: ('%s', '%s')\n",
3014 version_.c_str(), VERSION_DEFAULT.c_str(), VERSION_CURRENT.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003015 return RunStatus::INVALID_INPUT;
Felipe Lemed071c682016-10-20 16:48:00 -07003016 }
3017
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003018 if (options_->show_header_only) {
3019 PrintHeader();
3020 return RunStatus::OK;
Felipe Lemed071c682016-10-20 16:48:00 -07003021 }
3022
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003023 MYLOGD("dumpstate calling_uid = %d ; calling package = %s \n",
3024 calling_uid, calling_package.c_str());
Nandana Duttd2f5f082019-01-18 17:13:52 +00003025
Felipe Leme7447d7c2016-11-03 18:12:22 -07003026 // TODO: temporarily set progress until it's part of the Dumpstate constructor
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003027 std::string stats_path =
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003028 android::base::StringPrintf("%s/dumpstate-stats.txt", bugreport_internal_dir_.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003029 progress_.reset(new Progress(stats_path));
Felipe Leme7447d7c2016-11-03 18:12:22 -07003030
Sahana Raof35ed432019-07-12 10:47:52 +01003031 if (acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME) < 0) {
3032 MYLOGE("Failed to acquire wake lock: %s\n", strerror(errno));
3033 } else {
3034 // Wake lock will be released automatically on process death
3035 MYLOGD("Wake lock acquired.\n");
3036 }
3037
Felipe Leme6ae5c4f2017-01-10 14:13:22 -08003038 register_sig_handler();
Felipe Lemed071c682016-10-20 16:48:00 -07003039
Felipe Lemef0292972016-11-22 13:57:05 -08003040 if (PropertiesHelper::IsDryRun()) {
Felipe Lemed071c682016-10-20 16:48:00 -07003041 MYLOGI("Running on dry-run mode (to disable it, call 'setprop dumpstate.dry_run false')\n");
3042 }
3043
Nandana Dutt235c6672019-11-14 15:22:32 +00003044 MYLOGI("dumpstate info: id=%d, args='%s', bugreport_mode= %s bugreport format version: %s\n",
Kedar Chitnis9fd8c052021-11-16 09:09:22 +00003045 id_, options_->args.c_str(), options_->bugreport_mode_string.c_str(), version_.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -08003046
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003047 do_early_screenshot_ = options_->do_progress_updates;
Felipe Lemee338bf62015-12-07 14:03:50 -08003048
Christopher Ferrised9354f2014-10-01 17:35:01 -07003049 // If we are going to use a socket, do it as early as possible
3050 // to avoid timeouts from bugreport.
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003051 if (options_->stream_to_socket || options_->progress_updates_to_socket) {
Felipe Leme2628e9e2016-04-12 16:36:51 -07003052 MYLOGD("Opening control socket\n");
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003053 control_socket_fd_ = open_socket_fn_("dumpstate");
Nandana Dutta344cb62019-02-22 15:12:35 +00003054 if (control_socket_fd_ == -1) {
3055 return ERROR;
3056 }
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003057 if (options_->progress_updates_to_socket) {
3058 options_->do_progress_updates = 1;
3059 }
Felipe Leme2628e9e2016-04-12 16:36:51 -07003060 }
3061
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003062 if (!PrepareToWriteToFile()) {
3063 return ERROR;
3064 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08003065
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003066 // Interactive, wear & telephony modes are default to true.
3067 // and may enable from cli option or when using control socket
3068 if (options_->do_progress_updates) {
3069 // clang-format off
3070 std::vector<std::string> am_args = {
3071 "--receiver-permission", "android.permission.DUMP",
3072 };
3073 // clang-format on
3074 // Send STARTED broadcast for apps that listen to bugreport generation events
3075 SendBroadcast("com.android.internal.intent.action.BUGREPORT_STARTED", am_args);
3076 if (options_->progress_updates_to_socket) {
3077 dprintf(control_socket_fd_, "BEGIN:%s\n", path_.c_str());
Felipe Leme71bbfc52015-11-23 14:14:51 -08003078 }
3079 }
3080
Nick Kralevichf3599b32016-01-25 15:05:16 -08003081 /* read /proc/cmdline before dropping root */
3082 FILE *cmdline = fopen("/proc/cmdline", "re");
3083 if (cmdline) {
3084 fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
3085 fclose(cmdline);
3086 }
3087
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003088 if (options_->do_vibrate) {
Felipe Leme35b8cf12017-02-10 15:47:29 -08003089 Vibrate(150);
John Michelau1f794c42012-09-17 11:20:19 -05003090 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07003091
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003092 if (zip_file != nullptr) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003093 if (chown(path_.c_str(), AID_SHELL, AID_SHELL)) {
3094 MYLOGE("Unable to change ownership of zip file %s: %s\n", path_.c_str(),
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003095 strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08003096 }
3097 }
3098
Nandana Dutt3f8c7172018-09-25 12:01:54 +01003099 int dup_stdout_fd;
3100 int dup_stderr_fd;
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003101 // Redirect stderr to log_path_ for debugging.
3102 TEMP_FAILURE_RETRY(dup_stderr_fd = dup(fileno(stderr)));
3103 if (!redirect_to_file(stderr, const_cast<char*>(log_path_.c_str()))) {
3104 return ERROR;
3105 }
3106 if (chown(log_path_.c_str(), AID_SHELL, AID_SHELL)) {
3107 MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n", log_path_.c_str(),
3108 strerror(errno));
3109 }
Nandana Dutt979388e2018-11-30 16:48:55 +00003110
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003111 // Redirect stdout to tmp_path_. This is the main bugreport entry and will be
3112 // moved into zip file later, if zipping.
3113 TEMP_FAILURE_RETRY(dup_stdout_fd = dup(fileno(stdout)));
3114 // TODO: why not write to a file instead of stdout to overcome this problem?
3115 /* TODO: rather than generating a text file now and zipping it later,
3116 it would be more efficient to redirect stdout to the zip entry
3117 directly, but the libziparchive doesn't support that option yet. */
3118 if (!redirect_to_file(stdout, const_cast<char*>(tmp_path_.c_str()))) {
3119 return ERROR;
3120 }
3121 if (chown(tmp_path_.c_str(), AID_SHELL, AID_SHELL)) {
3122 MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
3123 tmp_path_.c_str(), strerror(errno));
Colin Crossf45fa6b2012-03-26 12:38:26 -07003124 }
Felipe Lemed8b94e52016-12-08 10:21:44 -08003125
3126 // Don't buffer stdout
3127 setvbuf(stdout, nullptr, _IONBF, 0);
3128
Rhed Jao5377d792020-07-16 17:37:39 +08003129 // Enable the parallel run if the client requests to output to a file.
3130 EnableParallelRunIfNeeded();
3131 // Using scope guard to make sure the dump pool can be shut down correctly.
3132 auto scope_guard_to_shutdown_pool = android::base::make_scope_guard([=]() {
3133 ShutdownDumpPool();
3134 });
3135
Felipe Leme608385d2016-02-01 10:35:38 -08003136 // NOTE: there should be no stdout output until now, otherwise it would break the header.
3137 // In particular, DurationReport objects should be created passing 'title, NULL', so their
Felipe Lemecbce55d2016-02-08 09:53:18 -08003138 // duration is logged into MYLOG instead.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003139 PrintHeader();
Colin Crossf45fa6b2012-03-26 12:38:26 -07003140
Gavin Corkery6968f552020-11-22 18:09:05 +00003141 bool is_dumpstate_restricted = options_->telephony_only
3142 || options_->wifi_only
3143 || options_->limited_only;
3144 if (!is_dumpstate_restricted) {
Paul Chang0d2aad72020-02-13 20:04:03 +08003145 // Invoke critical dumpsys first to preserve system state, before doing anything else.
Jichao Lie89d9c12019-11-21 19:02:51 -08003146 RunDumpsysCritical();
Gavin Corkery6968f552020-11-22 18:09:05 +00003147 }
3148 MaybeTakeEarlyScreenshot();
Primiano Tuccifaaaafb2021-01-14 12:26:29 +00003149
3150 if (!is_dumpstate_restricted) {
3151 // Snapshot the system trace now (if running) to avoid that dumpstate's
3152 // own activity pushes out interesting data from the trace ring buffer.
3153 // The trace file is added to the zip by MaybeAddSystemTraceToZip().
3154 MaybeSnapshotSystemTrace();
Yohei Yukawa95305b32021-03-09 07:54:27 -08003155
3156 // If a winscope trace is running, snapshot it now. It will be pulled into bugreport later
3157 // from WMTRACE_DATA_DIR.
3158 MaybeSnapshotWinTrace();
Primiano Tuccifaaaafb2021-01-14 12:26:29 +00003159 }
Gavin Corkery6968f552020-11-22 18:09:05 +00003160 onUiIntensiveBugreportDumpsFinished(calling_uid);
3161 MaybeCheckUserConsent(calling_uid, calling_package);
3162 if (options_->telephony_only) {
3163 DumpstateTelephonyOnly(calling_package);
3164 } else if (options_->wifi_only) {
3165 DumpstateWifiOnly();
3166 } else if (options_->limited_only) {
3167 DumpstateLimitedOnly();
3168 } else {
Nandana Dutt4be45d12018-09-26 15:04:23 +01003169 // Dump state for the default case. This also drops root.
Jichao Lie89d9c12019-11-21 19:02:51 -08003170 RunStatus s = DumpstateDefaultAfterCritical();
Nandana Dutt5c390032019-03-12 10:52:56 +00003171 if (s != RunStatus::OK) {
Nandana Duttaac6f582019-07-26 14:32:47 +01003172 if (s == RunStatus::USER_CONSENT_DENIED) {
Nandana Dutt5c390032019-03-12 10:52:56 +00003173 HandleUserConsentDenied();
3174 }
3175 return s;
Felipe Leme6ec6ac42017-01-10 15:29:53 -08003176 }
Zhengyin Qian068ecc72016-08-10 16:48:14 -07003177 }
Felipe Leme71a74ac2016-03-17 15:43:25 -07003178
Felipe Leme55b42a62015-11-10 17:39:08 -08003179 /* close output if needed */
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003180 TEMP_FAILURE_RETRY(dup2(dup_stdout_fd, fileno(stdout)));
Colin Crossf45fa6b2012-03-26 12:38:26 -07003181
Abhijeet Kaure370d682019-10-01 16:49:30 +01003182 // Zip the (now complete) .tmp file within the internal directory.
Kevin Jeon2c02e8e2022-07-07 21:45:17 +00003183 ATRACE_BEGIN("FinalizeFile");
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003184 FinalizeFile();
Kevin Jeon2c02e8e2022-07-07 21:45:17 +00003185 ATRACE_END();
Colin Crossf45fa6b2012-03-26 12:38:26 -07003186
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003187 // Share the final file with the caller if the user has consented or Shell is the caller.
Nandana Duttd2f5f082019-01-18 17:13:52 +00003188 Dumpstate::RunStatus status = Dumpstate::RunStatus::OK;
Abhijeet Kaure370d682019-10-01 16:49:30 +01003189 if (CalledByApi()) {
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003190 status = CopyBugreportIfUserConsented(calling_uid);
Nandana Duttd2f5f082019-01-18 17:13:52 +00003191 if (status != Dumpstate::RunStatus::OK &&
3192 status != Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
3193 // Do an early return if there were errors. We make an exception for consent
3194 // timing out because it's possible the user got distracted. In this case the
3195 // bugreport is not shared but made available for manual retrieval.
Nandana Dutt16d1aee2019-02-15 16:13:53 +00003196 MYLOGI("User denied consent. Returning\n");
Nandana Duttd2f5f082019-01-18 17:13:52 +00003197 return status;
3198 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00003199 if (status == Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
3200 MYLOGI(
3201 "Did not receive user consent yet."
3202 " Will not copy the bugreport artifacts to caller.\n");
Abhijeet Kaur57627412019-04-17 16:00:09 +01003203 const String16 incidentcompanion("incidentcompanion");
3204 sp<android::IBinder> ics(defaultServiceManager()->getService(incidentcompanion));
3205 if (ics != nullptr) {
3206 MYLOGD("Canceling user consent request via incidentcompanion service\n");
3207 android::interface_cast<android::os::IIncidentCompanion>(ics)->cancelAuthorization(
3208 consent_callback_.get());
3209 } else {
3210 MYLOGD("Unable to cancel user consent; incidentcompanion service unavailable\n");
3211 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00003212 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003213 }
3214
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08003215 /* vibrate a few but shortly times to let user know it's finished */
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003216 if (options_->do_vibrate) {
Takuya Ogawa47f644e2017-12-20 18:09:09 +09003217 for (int i = 0; i < 3; i++) {
3218 Vibrate(75);
3219 usleep((75 + 50) * 1000);
3220 }
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08003221 }
3222
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003223 MYLOGD("Final progress: %d/%d (estimated %d)\n", progress_->Get(), progress_->GetMax(),
3224 progress_->GetInitialMax());
3225 progress_->Save();
3226 MYLOGI("done (id %d)\n", id_);
Colin Crossf45fa6b2012-03-26 12:38:26 -07003227
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003228 TEMP_FAILURE_RETRY(dup2(dup_stderr_fd, fileno(stderr)));
Felipe Leme107a05f2016-03-08 15:11:15 -08003229
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003230 if (control_socket_fd_ != -1) {
Felipe Lemee844a9d2016-09-21 15:01:39 -07003231 MYLOGD("Closing control socket\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003232 close(control_socket_fd_);
Felipe Leme2628e9e2016-04-12 16:36:51 -07003233 }
3234
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003235 tombstone_data_.clear();
3236 anr_data_.clear();
Woody Lin20767a92022-11-29 15:50:24 +08003237 shutdown_checkpoints_.clear();
Narayan Kamath6b9516c2017-10-27 11:15:51 +01003238
Nandana Duttd2f5f082019-01-18 17:13:52 +00003239 return (consent_callback_ != nullptr &&
3240 consent_callback_->getResult() == UserConsentResult::UNAVAILABLE)
3241 ? USER_CONSENT_TIMED_OUT
3242 : RunStatus::OK;
3243}
3244
Paul Chang0d2aad72020-02-13 20:04:03 +08003245void Dumpstate::MaybeTakeEarlyScreenshot() {
3246 if (!options_->do_screenshot || !do_early_screenshot_) {
3247 return;
3248 }
3249
3250 TakeScreenshot();
3251}
3252
Primiano Tuccifaaaafb2021-01-14 12:26:29 +00003253void Dumpstate::MaybeSnapshotSystemTrace() {
3254 // If a background system trace is happening and is marked as "suitable for
3255 // bugreport" (i.e. bugreport_score > 0 in the trace config), this command
3256 // will stop it and serialize into SYSTEM_TRACE_SNAPSHOT. In the (likely)
3257 // case that no trace is ongoing, this command is a no-op.
3258 // Note: this should not be enqueued as we need to freeze the trace before
3259 // dumpstate starts. Otherwise the trace ring buffers will contain mostly
3260 // the dumpstate's own activity which is irrelevant.
3261 int res = RunCommand(
3262 "SERIALIZE PERFETTO TRACE",
3263 {"perfetto", "--save-for-bugreport"},
3264 CommandOptions::WithTimeout(10)
3265 .DropRoot()
3266 .CloseAllFileDescriptorsOnExec()
3267 .Build());
3268 has_system_trace_ = res == 0;
3269 // MaybeAddSystemTraceToZip() will take care of copying the trace in the zip
3270 // file in the later stages.
3271}
3272
Yohei Yukawa95305b32021-03-09 07:54:27 -08003273void Dumpstate::MaybeSnapshotWinTrace() {
Hongwei Wang9ec5c252023-01-24 15:09:59 -08003274 // Include the proto logging from WMShell.
3275 RunCommand(
3276 // Empty name because it's not intended to be classified as a bugreport section.
3277 // Actual logging files can be found as "/data/misc/wmtrace/shell_log.winscope"
3278 // in the bugreport.
3279 "", {"dumpsys", "activity", "service", "SystemUIService",
3280 "WMShell", "protolog", "save-for-bugreport"},
3281 CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build());
3282
Yohei Yukawa02b1d2c2021-03-16 09:20:30 -07003283 // Currently WindowManagerService and InputMethodManagerSerivice support WinScope protocol.
3284 for (const auto& service : {"window", "input_method"}) {
3285 RunCommand(
3286 // Empty name because it's not intended to be classified as a bugreport section.
3287 // Actual tracing files can be found in "/data/misc/wmtrace/" in the bugreport.
3288 "", {"cmd", service, "tracing", "save-for-bugreport"},
3289 CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build());
3290 }
Yohei Yukawa95305b32021-03-09 07:54:27 -08003291}
3292
Paul Changeb4b4642020-05-28 22:05:47 +08003293void Dumpstate::onUiIntensiveBugreportDumpsFinished(int32_t calling_uid) {
Paul Changc490e662020-04-11 18:14:09 +08003294 if (calling_uid == AID_SHELL || !CalledByApi()) {
3295 return;
3296 }
3297 if (listener_ != nullptr) {
3298 // Let listener know ui intensive bugreport dumps are finished, then it can do event
3299 // handling if required.
Paul Changeb4b4642020-05-28 22:05:47 +08003300 listener_->onUiIntensiveBugreportDumpsFinished();
Paul Changc490e662020-04-11 18:14:09 +08003301 }
3302}
3303
Jichao Lie89d9c12019-11-21 19:02:51 -08003304void Dumpstate::MaybeCheckUserConsent(int32_t calling_uid, const std::string& calling_package) {
3305 if (calling_uid == AID_SHELL || !CalledByApi()) {
3306 // No need to get consent for shell triggered dumpstates, or not through
3307 // bugreporting API (i.e. no fd to copy back).
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003308 return;
3309 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003310 consent_callback_ = new ConsentCallback();
3311 const String16 incidentcompanion("incidentcompanion");
3312 sp<android::IBinder> ics(defaultServiceManager()->getService(incidentcompanion));
Jichao Lie89d9c12019-11-21 19:02:51 -08003313 android::String16 package(calling_package.c_str());
Nandana Duttd2f5f082019-01-18 17:13:52 +00003314 if (ics != nullptr) {
3315 MYLOGD("Checking user consent via incidentcompanion service\n");
3316 android::interface_cast<android::os::IIncidentCompanion>(ics)->authorizeReport(
Jichao Lie89d9c12019-11-21 19:02:51 -08003317 calling_uid, package, String16(), String16(),
Joe Onorato1c36d752019-03-17 18:26:43 -07003318 0x1 /* FLAG_CONFIRMATION_DIALOG */, consent_callback_.get());
Nandana Duttd2f5f082019-01-18 17:13:52 +00003319 } else {
3320 MYLOGD("Unable to check user consent; incidentcompanion service unavailable\n");
3321 }
3322}
3323
Nandana Dutt5c390032019-03-12 10:52:56 +00003324bool Dumpstate::IsUserConsentDenied() const {
3325 return ds.consent_callback_ != nullptr &&
3326 ds.consent_callback_->getResult() == UserConsentResult::DENIED;
3327}
3328
Abhijeet Kaur359b1ff2019-07-26 16:01:36 +01003329bool Dumpstate::CalledByApi() const {
3330 return ds.options_->bugreport_fd.get() != -1 ? true : false;
3331}
3332
Nandana Dutt8ae16e62020-03-27 10:20:22 +00003333void Dumpstate::CleanupTmpFiles() {
Nandana Duttd2f5f082019-01-18 17:13:52 +00003334 android::os::UnlinkAndLogOnError(tmp_path_);
3335 android::os::UnlinkAndLogOnError(screenshot_path_);
3336 android::os::UnlinkAndLogOnError(path_);
Gavin Corkery789d7a52021-02-24 23:52:35 +00003337 if (dump_traces_path != nullptr) {
3338 android::os::UnlinkAndLogOnError(dump_traces_path);
3339 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003340}
3341
Rhed Jao5377d792020-07-16 17:37:39 +08003342void Dumpstate::EnableParallelRunIfNeeded() {
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003343 if (!PropertiesHelper::IsParallelRun()) {
Rhed Jao5377d792020-07-16 17:37:39 +08003344 return;
3345 }
3346 dump_pool_ = std::make_unique<DumpPool>(bugreport_internal_dir_);
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08003347 zip_entry_tasks_ = std::make_unique<TaskQueue>();
Rhed Jao5377d792020-07-16 17:37:39 +08003348}
3349
3350void Dumpstate::ShutdownDumpPool() {
3351 if (dump_pool_) {
Chris Morinbc223142022-02-04 14:17:11 -08003352 dump_pool_.reset();
Rhed Jao5377d792020-07-16 17:37:39 +08003353 }
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08003354 if (zip_entry_tasks_) {
3355 zip_entry_tasks_->run(/* do_cancel = */true);
3356 zip_entry_tasks_ = nullptr;
3357 }
3358}
3359
3360void Dumpstate::EnqueueAddZipEntryAndCleanupIfNeeded(const std::string& entry_name,
3361 const std::string& entry_path) {
3362 auto func_add_zip_entry_and_cleanup = [=](bool task_cancelled) {
3363 if (!task_cancelled) {
3364 AddZipEntry(entry_name, entry_path);
3365 }
3366 android::os::UnlinkAndLogOnError(entry_path);
3367 };
3368 if (zip_entry_tasks_) {
3369 // Enqueues AddZipEntryAndCleanup function if the parallel run is enabled.
3370 zip_entry_tasks_->add(func_add_zip_entry_and_cleanup, _1);
3371 } else {
3372 // Invokes AddZipEntryAndCleanup immediately
3373 std::invoke(func_add_zip_entry_and_cleanup, /* task_cancelled = */false);
3374 }
Rhed Jao5377d792020-07-16 17:37:39 +08003375}
3376
Nandana Duttd2f5f082019-01-18 17:13:52 +00003377Dumpstate::RunStatus Dumpstate::HandleUserConsentDenied() {
3378 MYLOGD("User denied consent; deleting files and returning\n");
Nandana Dutt8ae16e62020-03-27 10:20:22 +00003379 CleanupTmpFiles();
Nandana Duttd2f5f082019-01-18 17:13:52 +00003380 return USER_CONSENT_DENIED;
3381}
3382
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003383Dumpstate::RunStatus Dumpstate::CopyBugreportIfUserConsented(int32_t calling_uid) {
Nandana Duttd2f5f082019-01-18 17:13:52 +00003384 // If the caller has asked to copy the bugreport over to their directory, we need explicit
Abhijeet Kaur3172b532019-10-15 15:07:03 +01003385 // user consent (unless the caller is Shell).
3386 UserConsentResult consent_result;
3387 if (calling_uid == AID_SHELL) {
3388 consent_result = UserConsentResult::APPROVED;
3389 } else {
3390 consent_result = consent_callback_->getResult();
3391 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003392 if (consent_result == UserConsentResult::UNAVAILABLE) {
3393 // User has not responded yet.
3394 uint64_t elapsed_ms = consent_callback_->getElapsedTimeMs();
Hunter Knepshield70610fa2020-01-03 15:27:33 -08003395 // Telephony is a fast report type, particularly on user builds where information may be
3396 // more aggressively limited. To give the user time to read the consent dialog, increase the
3397 // timeout.
3398 uint64_t timeout_ms = options_->telephony_only ? TELEPHONY_REPORT_USER_CONSENT_TIMEOUT_MS
3399 : USER_CONSENT_TIMEOUT_MS;
3400 if (elapsed_ms < timeout_ms) {
3401 uint delay_seconds = (timeout_ms - elapsed_ms) / 1000;
Nandana Duttd2f5f082019-01-18 17:13:52 +00003402 MYLOGD("Did not receive user consent yet; going to wait for %d seconds", delay_seconds);
3403 sleep(delay_seconds);
3404 }
3405 consent_result = consent_callback_->getResult();
3406 }
3407 if (consent_result == UserConsentResult::DENIED) {
3408 // User has explicitly denied sharing with the app. To be safe delete the
3409 // internal bugreport & tmp files.
3410 return HandleUserConsentDenied();
3411 }
3412 if (consent_result == UserConsentResult::APPROVED) {
Nandana Dutte78c3d72019-01-29 16:10:45 +00003413 bool copy_succeeded = android::os::CopyFileToFd(path_, options_->bugreport_fd.get());
3414 if (copy_succeeded) {
3415 android::os::UnlinkAndLogOnError(path_);
Abhijeet Kaur9ce94672020-04-01 17:22:36 +01003416 if (options_->do_screenshot &&
3417 options_->screenshot_fd.get() != -1 &&
3418 !options_->is_screenshot_copied) {
3419 copy_succeeded = android::os::CopyFileToFd(screenshot_path_,
3420 options_->screenshot_fd.get());
3421 options_->is_screenshot_copied = copy_succeeded;
3422 if (copy_succeeded) {
3423 android::os::UnlinkAndLogOnError(screenshot_path_);
3424 }
3425 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003426 }
3427 return copy_succeeded ? Dumpstate::RunStatus::OK : Dumpstate::RunStatus::ERROR;
3428 } else if (consent_result == UserConsentResult::UNAVAILABLE) {
3429 // consent_result is still UNAVAILABLE. The user has likely not responded yet.
3430 // Since we do not have user consent to share the bugreport it does not get
3431 // copied over to the calling app but remains in the internal directory from
3432 // where the user can manually pull it.
Paul Changce644212021-05-11 16:06:45 +08003433 std::string final_path = GetPath(".zip");
3434 bool copy_succeeded = android::os::CopyFileToFile(path_, final_path);
3435 if (copy_succeeded) {
3436 android::os::UnlinkAndLogOnError(path_);
3437 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00003438 return Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT;
3439 }
3440 // Unknown result; must be a programming error.
3441 MYLOGE("Unknown user consent result:%d\n", consent_result);
3442 return Dumpstate::RunStatus::ERROR;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003443}
3444
Nandana Duttf02564e2019-02-15 15:24:24 +00003445Dumpstate::RunStatus Dumpstate::ParseCommandlineAndRun(int argc, char* argv[]) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003446 std::unique_ptr<Dumpstate::DumpOptions> options = std::make_unique<Dumpstate::DumpOptions>();
3447 Dumpstate::RunStatus status = options->Initialize(argc, argv);
3448 if (status == Dumpstate::RunStatus::OK) {
Nandana Duttf02564e2019-02-15 15:24:24 +00003449 SetOptions(std::move(options));
Nandana Duttd2f5f082019-01-18 17:13:52 +00003450 // When directly running dumpstate binary, the output is not expected to be written
3451 // to any external file descriptor.
Nandana Duttf02564e2019-02-15 15:24:24 +00003452 assert(options_->bugreport_fd.get() == -1);
Nandana Duttd2f5f082019-01-18 17:13:52 +00003453
3454 // calling_uid and calling_package are for user consent to share the bugreport with
Abhijeet Kaura407fb82020-03-27 12:51:12 +00003455 // an app; they are irrelevant here because bugreport is triggered via command line.
3456 // Update Last ID before calling Run().
3457 Initialize();
Nandana Duttf02564e2019-02-15 15:24:24 +00003458 status = Run(-1 /* calling_uid */, "" /* calling_package */);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003459 }
Nandana Duttf02564e2019-02-15 15:24:24 +00003460 return status;
3461}
3462
3463/* Main entry point for dumpstate binary. */
3464int run_main(int argc, char* argv[]) {
3465 Dumpstate::RunStatus status = ds.ParseCommandlineAndRun(argc, argv);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003466
3467 switch (status) {
3468 case Dumpstate::RunStatus::OK:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003469 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003470 case Dumpstate::RunStatus::HELP:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003471 ShowUsage();
3472 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003473 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003474 fprintf(stderr, "Invalid combination of args\n");
3475 ShowUsage();
3476 exit(1);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003477 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00003478 FALLTHROUGH_INTENDED;
3479 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
3480 FALLTHROUGH_INTENDED;
3481 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00003482 exit(2);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01003483 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07003484}
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003485
3486// TODO(111441001): Default DumpOptions to sensible values.
3487Dumpstate::Dumpstate(const std::string& version)
3488 : pid_(getpid()),
3489 options_(new Dumpstate::DumpOptions()),
Nandana Dutt402a8392019-06-14 14:25:13 +01003490 last_reported_percent_progress_(0),
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003491 version_(version),
Dieter Hsu105ad0c2020-09-29 15:23:33 +08003492 now_(time(nullptr)),
3493 open_socket_fn_(open_socket) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003494}
3495
3496Dumpstate& Dumpstate::GetInstance() {
3497 static Dumpstate singleton_(android::base::GetProperty("dumpstate.version", VERSION_CURRENT));
3498 return singleton_;
3499}
3500
Rhed Jao5377d792020-07-16 17:37:39 +08003501DurationReporter::DurationReporter(const std::string& title, bool logcat_only, bool verbose,
3502 int duration_fd) : title_(title), logcat_only_(logcat_only), verbose_(verbose),
3503 duration_fd_(duration_fd) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003504 if (!title_.empty()) {
3505 started_ = Nanotime();
Kevin Jeon2c02e8e2022-07-07 21:45:17 +00003506 if (title_.find("SHOW MAP") == std::string::npos) {
3507 ATRACE_ASYNC_BEGIN(title_.c_str(), 0);
3508 }
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003509 }
3510}
3511
3512DurationReporter::~DurationReporter() {
3513 if (!title_.empty()) {
3514 float elapsed = (float)(Nanotime() - started_) / NANOS_PER_SEC;
chenqiwuaf8b2d92019-12-12 18:53:51 +08003515 if (elapsed >= .5f || verbose_) {
3516 MYLOGD("Duration of '%s': %.2fs\n", title_.c_str(), elapsed);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003517 }
chenqiwuaf8b2d92019-12-12 18:53:51 +08003518 if (!logcat_only_) {
3519 // Use "Yoda grammar" to make it easier to grep|sort sections.
Rhed Jao5377d792020-07-16 17:37:39 +08003520 dprintf(duration_fd_, "------ %.3fs was the duration of '%s' ------\n",
3521 elapsed, title_.c_str());
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003522 }
Kevin Jeon2c02e8e2022-07-07 21:45:17 +00003523 if (title_.find("SHOW MAP") == std::string::npos) {
3524 ATRACE_ASYNC_END(title_.c_str(), 0);
3525 }
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003526 }
3527}
3528
3529const int32_t Progress::kDefaultMax = 5000;
3530
3531Progress::Progress(const std::string& path) : Progress(Progress::kDefaultMax, 1.1, path) {
3532}
3533
3534Progress::Progress(int32_t initial_max, int32_t progress, float growth_factor)
3535 : Progress(initial_max, growth_factor, "") {
3536 progress_ = progress;
3537}
3538
3539Progress::Progress(int32_t initial_max, float growth_factor, const std::string& path)
3540 : initial_max_(initial_max),
3541 progress_(0),
3542 max_(initial_max),
3543 growth_factor_(growth_factor),
3544 n_runs_(0),
3545 average_max_(0),
3546 path_(path) {
3547 if (!path_.empty()) {
3548 Load();
3549 }
3550}
3551
3552void Progress::Load() {
3553 MYLOGD("Loading stats from %s\n", path_.c_str());
3554 std::string content;
3555 if (!android::base::ReadFileToString(path_, &content)) {
3556 MYLOGI("Could not read stats from %s; using max of %d\n", path_.c_str(), max_);
3557 return;
3558 }
3559 if (content.empty()) {
3560 MYLOGE("No stats (empty file) on %s; using max of %d\n", path_.c_str(), max_);
3561 return;
3562 }
3563 std::vector<std::string> lines = android::base::Split(content, "\n");
3564
3565 if (lines.size() < 1) {
3566 MYLOGE("Invalid stats on file %s: not enough lines (%d). Using max of %d\n", path_.c_str(),
3567 (int)lines.size(), max_);
3568 return;
3569 }
3570 char* ptr;
3571 n_runs_ = strtol(lines[0].c_str(), &ptr, 10);
3572 average_max_ = strtol(ptr, nullptr, 10);
3573 if (n_runs_ <= 0 || average_max_ <= 0 || n_runs_ > STATS_MAX_N_RUNS ||
3574 average_max_ > STATS_MAX_AVERAGE) {
3575 MYLOGE("Invalid stats line on file %s: %s\n", path_.c_str(), lines[0].c_str());
3576 initial_max_ = Progress::kDefaultMax;
3577 } else {
3578 initial_max_ = average_max_;
3579 }
3580 max_ = initial_max_;
3581
3582 MYLOGI("Average max progress: %d in %d runs; estimated max: %d\n", average_max_, n_runs_, max_);
3583}
3584
3585void Progress::Save() {
3586 int32_t total = n_runs_ * average_max_ + progress_;
3587 int32_t runs = n_runs_ + 1;
3588 int32_t average = floor(((float)total) / runs);
3589 MYLOGI("Saving stats (total=%d, runs=%d, average=%d) on %s\n", total, runs, average,
3590 path_.c_str());
3591 if (path_.empty()) {
3592 return;
3593 }
3594
3595 std::string content = android::base::StringPrintf("%d %d\n", runs, average);
3596 if (!android::base::WriteStringToFile(content, path_)) {
3597 MYLOGE("Could not save stats on %s\n", path_.c_str());
3598 }
3599}
3600
3601int32_t Progress::Get() const {
3602 return progress_;
3603}
3604
3605bool Progress::Inc(int32_t delta_sec) {
3606 bool changed = false;
3607 if (delta_sec >= 0) {
3608 progress_ += delta_sec;
3609 if (progress_ > max_) {
3610 int32_t old_max = max_;
3611 max_ = floor((float)progress_ * growth_factor_);
3612 MYLOGD("Adjusting max progress from %d to %d\n", old_max, max_);
3613 changed = true;
3614 }
3615 }
3616 return changed;
3617}
3618
3619int32_t Progress::GetMax() const {
3620 return max_;
3621}
3622
3623int32_t Progress::GetInitialMax() const {
3624 return initial_max_;
3625}
3626
3627void Progress::Dump(int fd, const std::string& prefix) const {
3628 const char* pr = prefix.c_str();
3629 dprintf(fd, "%sprogress: %d\n", pr, progress_);
3630 dprintf(fd, "%smax: %d\n", pr, max_);
3631 dprintf(fd, "%sinitial_max: %d\n", pr, initial_max_);
3632 dprintf(fd, "%sgrowth_factor: %0.2f\n", pr, growth_factor_);
3633 dprintf(fd, "%spath: %s\n", pr, path_.c_str());
3634 dprintf(fd, "%sn_runs: %d\n", pr, n_runs_);
3635 dprintf(fd, "%saverage_max: %d\n", pr, average_max_);
3636}
3637
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003638std::string Dumpstate::GetPath(const std::string& suffix) const {
3639 return GetPath(bugreport_internal_dir_, suffix);
3640}
3641
3642std::string Dumpstate::GetPath(const std::string& directory, const std::string& suffix) const {
3643 return android::base::StringPrintf("%s/%s-%s%s", directory.c_str(), base_name_.c_str(),
3644 name_.c_str(), suffix.c_str());
3645}
3646
3647void Dumpstate::SetProgress(std::unique_ptr<Progress> progress) {
3648 progress_ = std::move(progress);
3649}
3650
3651void for_each_userid(void (*func)(int), const char *header) {
3652 std::string title = header == nullptr ? "for_each_userid" : android::base::StringPrintf(
3653 "for_each_userid(%s)", header);
3654 DurationReporter duration_reporter(title);
3655 if (PropertiesHelper::IsDryRun()) return;
3656
3657 DIR *d;
3658 struct dirent *de;
3659
3660 if (header) printf("\n------ %s ------\n", header);
3661 func(0);
3662
3663 if (!(d = opendir("/data/system/users"))) {
3664 printf("Failed to open /data/system/users (%s)\n", strerror(errno));
3665 return;
3666 }
3667
3668 while ((de = readdir(d))) {
3669 int userid;
3670 if (de->d_type != DT_DIR || !(userid = atoi(de->d_name))) {
3671 continue;
3672 }
3673 func(userid);
3674 }
3675
3676 closedir(d);
3677}
3678
3679static void __for_each_pid(void (*helper)(int, const char *, void *), const char *header, void *arg) {
3680 DIR *d;
3681 struct dirent *de;
3682
3683 if (!(d = opendir("/proc"))) {
3684 printf("Failed to open /proc (%s)\n", strerror(errno));
3685 return;
3686 }
3687
3688 if (header) printf("\n------ %s ------\n", header);
3689 while ((de = readdir(d))) {
3690 if (ds.IsUserConsentDenied()) {
3691 MYLOGE(
3692 "Returning early because user denied consent to share bugreport with calling app.");
3693 closedir(d);
3694 return;
3695 }
3696 int pid;
3697 int fd;
3698 char cmdpath[255];
3699 char cmdline[255];
3700
3701 if (!(pid = atoi(de->d_name))) {
3702 continue;
3703 }
3704
3705 memset(cmdline, 0, sizeof(cmdline));
3706
3707 snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/cmdline", pid);
3708 if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) {
3709 TEMP_FAILURE_RETRY(read(fd, cmdline, sizeof(cmdline) - 2));
3710 close(fd);
3711 if (cmdline[0]) {
3712 helper(pid, cmdline, arg);
3713 continue;
3714 }
3715 }
3716
3717 // if no cmdline, a kernel thread has comm
3718 snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/comm", pid);
3719 if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) {
3720 TEMP_FAILURE_RETRY(read(fd, cmdline + 1, sizeof(cmdline) - 4));
3721 close(fd);
3722 if (cmdline[1]) {
3723 cmdline[0] = '[';
3724 size_t len = strcspn(cmdline, "\f\b\r\n");
3725 cmdline[len] = ']';
3726 cmdline[len+1] = '\0';
3727 }
3728 }
3729 if (!cmdline[0]) {
3730 strcpy(cmdline, "N/A");
3731 }
3732 helper(pid, cmdline, arg);
3733 }
3734
3735 closedir(d);
3736}
3737
3738static void for_each_pid_helper(int pid, const char *cmdline, void *arg) {
3739 for_each_pid_func *func = (for_each_pid_func*) arg;
3740 func(pid, cmdline);
3741}
3742
3743void for_each_pid(for_each_pid_func func, const char *header) {
3744 std::string title = header == nullptr ? "for_each_pid"
3745 : android::base::StringPrintf("for_each_pid(%s)", header);
3746 DurationReporter duration_reporter(title);
3747 if (PropertiesHelper::IsDryRun()) return;
3748
3749 __for_each_pid(for_each_pid_helper, header, (void *) func);
3750}
3751
3752static void for_each_tid_helper(int pid, const char *cmdline, void *arg) {
3753 DIR *d;
3754 struct dirent *de;
3755 char taskpath[255];
3756 for_each_tid_func *func = (for_each_tid_func *) arg;
3757
3758 snprintf(taskpath, sizeof(taskpath), "/proc/%d/task", pid);
3759
3760 if (!(d = opendir(taskpath))) {
3761 printf("Failed to open %s (%s)\n", taskpath, strerror(errno));
3762 return;
3763 }
3764
3765 func(pid, pid, cmdline);
3766
3767 while ((de = readdir(d))) {
3768 if (ds.IsUserConsentDenied()) {
3769 MYLOGE(
3770 "Returning early because user denied consent to share bugreport with calling app.");
3771 closedir(d);
3772 return;
3773 }
3774 int tid;
3775 int fd;
3776 char commpath[255];
3777 char comm[255];
3778
3779 if (!(tid = atoi(de->d_name))) {
3780 continue;
3781 }
3782
3783 if (tid == pid)
3784 continue;
3785
3786 snprintf(commpath, sizeof(commpath), "/proc/%d/comm", tid);
3787 memset(comm, 0, sizeof(comm));
3788 if ((fd = TEMP_FAILURE_RETRY(open(commpath, O_RDONLY | O_CLOEXEC))) < 0) {
3789 strcpy(comm, "N/A");
3790 } else {
3791 char *c;
3792 TEMP_FAILURE_RETRY(read(fd, comm, sizeof(comm) - 2));
3793 close(fd);
3794
3795 c = strrchr(comm, '\n');
3796 if (c) {
3797 *c = '\0';
3798 }
3799 }
3800 func(pid, tid, comm);
3801 }
3802
3803 closedir(d);
3804}
3805
3806void for_each_tid(for_each_tid_func func, const char *header) {
3807 std::string title = header == nullptr ? "for_each_tid"
3808 : android::base::StringPrintf("for_each_tid(%s)", header);
3809 DurationReporter duration_reporter(title);
3810
3811 if (PropertiesHelper::IsDryRun()) return;
3812
3813 __for_each_pid(for_each_tid_helper, header, (void *) func);
3814}
3815
3816void show_wchan(int pid, int tid, const char *name) {
3817 if (PropertiesHelper::IsDryRun()) return;
3818
3819 char path[255];
3820 char buffer[255];
3821 int fd, ret, save_errno;
3822 char name_buffer[255];
3823
3824 memset(buffer, 0, sizeof(buffer));
3825
3826 snprintf(path, sizeof(path), "/proc/%d/wchan", tid);
3827 if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) {
3828 printf("Failed to open '%s' (%s)\n", path, strerror(errno));
3829 return;
3830 }
3831
3832 ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
3833 save_errno = errno;
3834 close(fd);
3835
3836 if (ret < 0) {
3837 printf("Failed to read '%s' (%s)\n", path, strerror(save_errno));
3838 return;
3839 }
3840
3841 snprintf(name_buffer, sizeof(name_buffer), "%*s%s",
3842 pid == tid ? 0 : 3, "", name);
3843
3844 printf("%-7d %-32s %s\n", tid, name_buffer, buffer);
3845
3846 return;
3847}
3848
3849// print time in centiseconds
3850static void snprcent(char *buffer, size_t len, size_t spc,
3851 unsigned long long time) {
3852 static long hz; // cache discovered hz
3853
3854 if (hz <= 0) {
3855 hz = sysconf(_SC_CLK_TCK);
3856 if (hz <= 0) {
3857 hz = 1000;
3858 }
3859 }
3860
3861 // convert to centiseconds
3862 time = (time * 100 + (hz / 2)) / hz;
3863
3864 char str[16];
3865
3866 snprintf(str, sizeof(str), " %llu.%02u",
3867 time / 100, (unsigned)(time % 100));
3868 size_t offset = strlen(buffer);
3869 snprintf(buffer + offset, (len > offset) ? len - offset : 0,
3870 "%*s", (spc > offset) ? (int)(spc - offset) : 0, str);
3871}
3872
3873// print permille as a percent
3874static void snprdec(char *buffer, size_t len, size_t spc, unsigned permille) {
3875 char str[16];
3876
3877 snprintf(str, sizeof(str), " %u.%u%%", permille / 10, permille % 10);
3878 size_t offset = strlen(buffer);
3879 snprintf(buffer + offset, (len > offset) ? len - offset : 0,
3880 "%*s", (spc > offset) ? (int)(spc - offset) : 0, str);
3881}
3882
3883void show_showtime(int pid, const char *name) {
3884 if (PropertiesHelper::IsDryRun()) return;
3885
3886 char path[255];
3887 char buffer[1023];
3888 int fd, ret, save_errno;
3889
3890 memset(buffer, 0, sizeof(buffer));
3891
3892 snprintf(path, sizeof(path), "/proc/%d/stat", pid);
3893 if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) {
3894 printf("Failed to open '%s' (%s)\n", path, strerror(errno));
3895 return;
3896 }
3897
3898 ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
3899 save_errno = errno;
3900 close(fd);
3901
3902 if (ret < 0) {
3903 printf("Failed to read '%s' (%s)\n", path, strerror(save_errno));
3904 return;
3905 }
3906
3907 // field 14 is utime
3908 // field 15 is stime
3909 // field 42 is iotime
3910 unsigned long long utime = 0, stime = 0, iotime = 0;
3911 if (sscanf(buffer,
3912 "%*u %*s %*s %*d %*d %*d %*d %*d %*d %*d %*d "
3913 "%*d %*d %llu %llu %*d %*d %*d %*d %*d %*d "
3914 "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
3915 "%*d %*d %*d %*d %*d %*d %*d %*d %*d %llu ",
3916 &utime, &stime, &iotime) != 3) {
3917 return;
3918 }
3919
3920 unsigned long long total = utime + stime;
3921 if (!total) {
3922 return;
3923 }
3924
3925 unsigned permille = (iotime * 1000 + (total / 2)) / total;
3926 if (permille > 1000) {
3927 permille = 1000;
3928 }
3929
3930 // try to beautify and stabilize columns at <80 characters
3931 snprintf(buffer, sizeof(buffer), "%-6d%s", pid, name);
3932 if ((name[0] != '[') || utime) {
3933 snprcent(buffer, sizeof(buffer), 57, utime);
3934 }
3935 snprcent(buffer, sizeof(buffer), 65, stime);
3936 if ((name[0] != '[') || iotime) {
3937 snprcent(buffer, sizeof(buffer), 73, iotime);
3938 }
3939 if (iotime) {
3940 snprdec(buffer, sizeof(buffer), 79, permille);
3941 }
3942 puts(buffer); // adds a trailing newline
3943
3944 return;
3945}
3946
3947void do_dmesg() {
3948 const char *title = "KERNEL LOG (dmesg)";
3949 DurationReporter duration_reporter(title);
3950 printf("------ %s ------\n", title);
3951
3952 if (PropertiesHelper::IsDryRun()) return;
3953
3954 /* Get size of kernel buffer */
3955 int size = klogctl(KLOG_SIZE_BUFFER, nullptr, 0);
3956 if (size <= 0) {
3957 printf("Unexpected klogctl return value: %d\n\n", size);
3958 return;
3959 }
3960 char *buf = (char *) malloc(size + 1);
3961 if (buf == nullptr) {
3962 printf("memory allocation failed\n\n");
3963 return;
3964 }
3965 int retval = klogctl(KLOG_READ_ALL, buf, size);
3966 if (retval < 0) {
3967 printf("klogctl failure\n\n");
3968 free(buf);
3969 return;
3970 }
3971 buf[retval] = '\0';
3972 printf("%s\n\n", buf);
3973 free(buf);
3974 return;
3975}
3976
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01003977int Dumpstate::DumpFile(const std::string& title, const std::string& path) {
3978 DurationReporter duration_reporter(title);
3979
3980 int status = DumpFileToFd(STDOUT_FILENO, title, path);
3981
3982 UpdateProgress(WEIGHT_FILE);
3983
3984 return status;
3985}
3986
3987int read_file_as_long(const char *path, long int *output) {
3988 int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC));
3989 if (fd < 0) {
3990 int err = errno;
3991 MYLOGE("Error opening file descriptor for %s: %s\n", path, strerror(err));
3992 return -1;
3993 }
3994 char buffer[50];
3995 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
3996 if (bytes_read == -1) {
3997 MYLOGE("Error reading file %s: %s\n", path, strerror(errno));
3998 return -2;
3999 }
4000 if (bytes_read == 0) {
4001 MYLOGE("File %s is empty\n", path);
4002 return -3;
4003 }
4004 *output = atoi(buffer);
4005 return 0;
4006}
4007
4008/* calls skip to gate calling dump_from_fd recursively
4009 * in the specified directory. dump_from_fd defaults to
4010 * dump_file_from_fd above when set to NULL. skip defaults
4011 * to false when set to NULL. dump_from_fd will always be
4012 * called with title NULL.
4013 */
4014int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path),
4015 int (*dump_from_fd)(const char* title, const char* path, int fd)) {
4016 DurationReporter duration_reporter(title);
4017 DIR *dirp;
4018 struct dirent *d;
4019 char *newpath = nullptr;
4020 const char *slash = "/";
4021 int retval = 0;
4022
4023 if (!title.empty()) {
4024 printf("------ %s (%s) ------\n", title.c_str(), dir);
4025 }
4026 if (PropertiesHelper::IsDryRun()) return 0;
4027
4028 if (dir[strlen(dir) - 1] == '/') {
4029 ++slash;
4030 }
4031 dirp = opendir(dir);
4032 if (dirp == nullptr) {
4033 retval = -errno;
4034 MYLOGE("%s: %s\n", dir, strerror(errno));
4035 return retval;
4036 }
4037
4038 if (!dump_from_fd) {
4039 dump_from_fd = dump_file_from_fd;
4040 }
4041 for (; ((d = readdir(dirp))); free(newpath), newpath = nullptr) {
4042 if ((d->d_name[0] == '.')
4043 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
4044 || (d->d_name[1] == '\0'))) {
4045 continue;
4046 }
4047 asprintf(&newpath, "%s%s%s%s", dir, slash, d->d_name,
4048 (d->d_type == DT_DIR) ? "/" : "");
4049 if (!newpath) {
4050 retval = -errno;
4051 continue;
4052 }
4053 if (skip && (*skip)(newpath)) {
4054 continue;
4055 }
4056 if (d->d_type == DT_DIR) {
4057 int ret = dump_files("", newpath, skip, dump_from_fd);
4058 if (ret < 0) {
4059 retval = ret;
4060 }
4061 continue;
4062 }
4063 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(newpath, O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
4064 if (fd.get() < 0) {
4065 retval = -1;
4066 printf("*** %s: %s\n", newpath, strerror(errno));
4067 continue;
4068 }
4069 (*dump_from_fd)(nullptr, newpath, fd.get());
4070 }
4071 closedir(dirp);
4072 if (!title.empty()) {
4073 printf("\n");
4074 }
4075 return retval;
4076}
4077
4078/* fd must have been opened with the flag O_NONBLOCK. With this flag set,
4079 * it's possible to avoid issues where opening the file itself can get
4080 * stuck.
4081 */
4082int dump_file_from_fd(const char *title, const char *path, int fd) {
4083 if (PropertiesHelper::IsDryRun()) return 0;
4084
4085 int flags = fcntl(fd, F_GETFL);
4086 if (flags == -1) {
4087 printf("*** %s: failed to get flags on fd %d: %s\n", path, fd, strerror(errno));
4088 return -1;
4089 } else if (!(flags & O_NONBLOCK)) {
4090 printf("*** %s: fd must have O_NONBLOCK set.\n", path);
4091 return -1;
4092 }
4093 return DumpFileFromFdToFd(title, path, fd, STDOUT_FILENO, PropertiesHelper::IsDryRun());
4094}
4095
4096int Dumpstate::RunCommand(const std::string& title, const std::vector<std::string>& full_command,
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08004097 const CommandOptions& options, bool verbose_duration, int out_fd) {
4098 DurationReporter duration_reporter(title, false /* logcat_only */,
4099 verbose_duration, out_fd);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004100
Rhed Jao3c2fdbd2020-07-20 17:46:29 +08004101 int status = RunCommandToFd(out_fd, title, full_command, options);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004102
4103 /* TODO: for now we're simplifying the progress calculation by using the
4104 * timeout as the weight. It's a good approximation for most cases, except when calling dumpsys,
4105 * where its weight should be much higher proportionally to its timeout.
4106 * Ideally, it should use a options.EstimatedDuration() instead...*/
4107 UpdateProgress(options.Timeout());
4108
4109 return status;
4110}
4111
4112void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
Rhed Jaoe017f982020-07-21 17:58:41 +08004113 const CommandOptions& options, long dumpsysTimeoutMs, int out_fd) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004114 long timeout_ms = dumpsysTimeoutMs > 0 ? dumpsysTimeoutMs : options.TimeoutInMs();
4115 std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-T", std::to_string(timeout_ms)};
4116 dumpsys.insert(dumpsys.end(), dumpsys_args.begin(), dumpsys_args.end());
Rhed Jaoe017f982020-07-21 17:58:41 +08004117 RunCommand(title, dumpsys, options, false, out_fd);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004118}
4119
Dieter Hsu105ad0c2020-09-29 15:23:33 +08004120static int open_socket(const char* service) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004121 int s = android_get_control_socket(service);
4122 if (s < 0) {
4123 MYLOGE("android_get_control_socket(%s): %s\n", service, strerror(errno));
4124 return -1;
4125 }
4126 fcntl(s, F_SETFD, FD_CLOEXEC);
4127
4128 // Set backlog to 0 to make sure that queue size will be minimum.
4129 // In Linux, because the minimum queue will be 1, connect() will be blocked
4130 // if the other clients already called connect() and the connection request was not accepted.
4131 if (listen(s, 0) < 0) {
4132 MYLOGE("listen(control socket): %s\n", strerror(errno));
4133 return -1;
4134 }
4135
4136 struct sockaddr addr;
4137 socklen_t alen = sizeof(addr);
Abhijeet Kaur2113cae2019-09-13 09:24:15 +01004138 int fd = accept4(s, &addr, &alen, SOCK_CLOEXEC);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004139
4140 // Close socket just after accept(), to make sure that connect() by client will get error
4141 // when the socket is used by the other services.
4142 // There is still a race condition possibility between accept and close, but there is no way
4143 // to close-on-accept atomically.
4144 // See detail; b/123306389#comment25
4145 close(s);
4146
4147 if (fd < 0) {
4148 MYLOGE("accept(control socket): %s\n", strerror(errno));
4149 return -1;
4150 }
4151
4152 return fd;
4153}
4154
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004155// TODO: should call is_valid_output_file and/or be merged into it.
4156void create_parent_dirs(const char *path) {
4157 char *chp = const_cast<char *> (path);
4158
4159 /* skip initial slash */
4160 if (chp[0] == '/')
4161 chp++;
4162
4163 /* create leading directories, if necessary */
4164 struct stat dir_stat;
4165 while (chp && chp[0]) {
4166 chp = strchr(chp, '/');
4167 if (chp) {
4168 *chp = 0;
4169 if (stat(path, &dir_stat) == -1 || !S_ISDIR(dir_stat.st_mode)) {
4170 MYLOGI("Creating directory %s\n", path);
4171 if (mkdir(path, 0770)) { /* drwxrwx--- */
4172 MYLOGE("Unable to create directory %s: %s\n", path, strerror(errno));
4173 } else if (chown(path, AID_SHELL, AID_SHELL)) {
4174 MYLOGE("Unable to change ownership of dir %s: %s\n", path, strerror(errno));
4175 }
4176 }
4177 *chp++ = '/';
4178 }
4179 }
4180}
4181
4182bool _redirect_to_file(FILE* redirect, char* path, int truncate_flag) {
4183 create_parent_dirs(path);
4184
4185 int fd = TEMP_FAILURE_RETRY(open(path,
4186 O_WRONLY | O_CREAT | truncate_flag | O_CLOEXEC | O_NOFOLLOW,
4187 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
4188 if (fd < 0) {
4189 MYLOGE("%s: %s\n", path, strerror(errno));
4190 return false;
4191 }
4192
4193 TEMP_FAILURE_RETRY(dup2(fd, fileno(redirect)));
4194 close(fd);
4195 return true;
4196}
4197
4198bool redirect_to_file(FILE* redirect, char* path) {
4199 return _redirect_to_file(redirect, path, O_TRUNC);
4200}
4201
4202bool redirect_to_existing_file(FILE* redirect, char* path) {
4203 return _redirect_to_file(redirect, path, O_APPEND);
4204}
4205
4206void dump_route_tables() {
4207 DurationReporter duration_reporter("DUMP ROUTE TABLES");
4208 if (PropertiesHelper::IsDryRun()) return;
4209 const char* const RT_TABLES_PATH = "/data/misc/net/rt_tables";
4210 ds.DumpFile("RT_TABLES", RT_TABLES_PATH);
4211 FILE* fp = fopen(RT_TABLES_PATH, "re");
4212 if (!fp) {
4213 printf("*** %s: %s\n", RT_TABLES_PATH, strerror(errno));
4214 return;
4215 }
4216 char table[16];
4217 // Each line has an integer (the table number), a space, and a string (the table name). We only
4218 // need the table number. It's a 32-bit unsigned number, so max 10 chars. Skip the table name.
4219 // Add a fixed max limit so this doesn't go awry.
4220 for (int i = 0; i < 64 && fscanf(fp, " %10s %*s", table) == 1; ++i) {
4221 RunCommand("ROUTE TABLE IPv4", {"ip", "-4", "route", "show", "table", table});
4222 RunCommand("ROUTE TABLE IPv6", {"ip", "-6", "route", "show", "table", table});
4223 }
4224 fclose(fp);
4225}
4226
Li Li830179f2022-01-04 12:53:29 -08004227void dump_frozen_cgroupfs(const char *dir, int level,
4228 int (*dump_from_fd)(const char* title, const char* path, int fd)) {
4229 DIR *dirp;
4230 struct dirent *d;
4231 char *newpath = nullptr;
4232
4233 dirp = opendir(dir);
4234 if (dirp == nullptr) {
4235 MYLOGE("%s: %s\n", dir, strerror(errno));
4236 return;
4237 }
4238
4239 for (; ((d = readdir(dirp))); free(newpath), newpath = nullptr) {
4240 if ((d->d_name[0] == '.')
4241 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
4242 || (d->d_name[1] == '\0'))) {
4243 continue;
4244 }
4245 if (d->d_type == DT_DIR) {
4246 asprintf(&newpath, "%s/%s/", dir, d->d_name);
4247 if (!newpath) {
4248 continue;
4249 }
4250 if (level == 0 && !strncmp(d->d_name, "uid_", 4)) {
4251 dump_frozen_cgroupfs(newpath, 1, dump_from_fd);
4252 } else if (level == 1 && !strncmp(d->d_name, "pid_", 4)) {
4253 char *freezer = nullptr;
4254 asprintf(&freezer, "%s/%s", newpath, "cgroup.freeze");
4255 if (freezer) {
4256 FILE* fp = fopen(freezer, "r");
4257 if (fp != NULL) {
4258 int frozen;
4259 fscanf(fp, "%d", &frozen);
4260 if (frozen > 0) {
4261 dump_files("", newpath, skip_none, dump_from_fd);
4262 }
4263 fclose(fp);
4264 }
4265 free(freezer);
4266 }
4267 }
4268 }
4269 }
4270 closedir(dirp);
4271}
4272
4273void dump_frozen_cgroupfs() {
Li Li830179f2022-01-04 12:53:29 -08004274 MYLOGD("Adding frozen processes from %s\n", CGROUPFS_DIR);
4275 DurationReporter duration_reporter("FROZEN CGROUPFS");
4276 if (PropertiesHelper::IsDryRun()) return;
4277 dump_frozen_cgroupfs(CGROUPFS_DIR, 0, _add_file_from_fd);
4278}
4279
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004280void Dumpstate::UpdateProgress(int32_t delta_sec) {
4281 if (progress_ == nullptr) {
4282 MYLOGE("UpdateProgress: progress_ not set\n");
4283 return;
4284 }
Rhed Jaobf63d8a2020-07-21 15:42:55 +08004285 // This function updates progress related members of the dumpstate and reports
4286 // progress percentage to the bugreport client. Since it could be called by
4287 // different dump tasks at the same time if the parallel run is enabled, a
4288 // mutex lock is necessary here to synchronize the call.
4289 std::lock_guard<std::recursive_mutex> lock(mutex_);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004290
4291 // Always update progess so stats can be tuned...
Nandana Dutt402a8392019-06-14 14:25:13 +01004292 progress_->Inc(delta_sec);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004293
4294 // ...but only notifiy listeners when necessary.
4295 if (!options_->do_progress_updates) return;
4296
4297 int progress = progress_->Get();
4298 int max = progress_->GetMax();
Nandana Dutt402a8392019-06-14 14:25:13 +01004299 int percent = 100 * progress / max;
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004300
Nandana Dutt402a8392019-06-14 14:25:13 +01004301 if (last_reported_percent_progress_ > 0 && percent <= last_reported_percent_progress_) {
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004302 return;
4303 }
Nandana Dutt402a8392019-06-14 14:25:13 +01004304 last_reported_percent_progress_ = percent;
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004305
4306 if (control_socket_fd_ >= 0) {
4307 dprintf(control_socket_fd_, "PROGRESS:%d/%d\n", progress, max);
4308 fsync(control_socket_fd_);
4309 }
4310
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004311 if (listener_ != nullptr) {
Nandana Dutt235c6672019-11-14 15:22:32 +00004312 if (percent % 10 == 0) {
4313 // We don't want to spam logcat, so only log multiples of 10.
Abhijeet Kaured5d6a62019-10-07 15:02:05 +01004314 MYLOGD("Setting progress: %d/%d (%d%%)\n", progress, max, percent);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004315 } else {
4316 // stderr is ignored on normal invocations, but useful when calling
4317 // /system/bin/dumpstate directly for debuggging.
Abhijeet Kaured5d6a62019-10-07 15:02:05 +01004318 fprintf(stderr, "Setting progress: %d/%d (%d%%)\n", progress, max, percent);
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004319 }
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004320
4321 listener_->onProgress(percent);
4322 }
4323}
4324
4325void Dumpstate::TakeScreenshot(const std::string& path) {
4326 const std::string& real_path = path.empty() ? screenshot_path_ : path;
4327 int status =
4328 RunCommand("", {"/system/bin/screencap", "-p", real_path},
4329 CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build());
4330 if (status == 0) {
4331 MYLOGD("Screenshot saved on %s\n", real_path.c_str());
4332 } else {
4333 MYLOGE("Failed to take screenshot on %s\n", real_path.c_str());
4334 }
Paul Chang0d2aad72020-02-13 20:04:03 +08004335 if (listener_ != nullptr) {
4336 // Show a visual indication to indicate screenshot is taken via
4337 // IDumpstateListener.onScreenshotTaken()
4338 listener_->onScreenshotTaken(status == 0);
4339 }
Abhijeet Kaurcf234e82019-07-01 14:53:55 +01004340}
4341
4342bool is_dir(const char* pathname) {
4343 struct stat info;
4344 if (stat(pathname, &info) == -1) {
4345 return false;
4346 }
4347 return S_ISDIR(info.st_mode);
4348}
4349
4350time_t get_mtime(int fd, time_t default_mtime) {
4351 struct stat info;
4352 if (fstat(fd, &info) == -1) {
4353 return default_mtime;
4354 }
4355 return info.st_mtime;
4356}