blob: 21de4db773c0772a1c5c959f3e05ba382eb2a5c5 [file] [log] [blame]
Colin Crossf45fa6b2012-03-26 12:38:26 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Felipe Lemef0292972016-11-22 13:57:05 -080016
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070017#define LOG_TAG "dumpstate"
Colin Crossf45fa6b2012-03-26 12:38:26 -070018
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -070019#include <dirent.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070020#include <errno.h>
21#include <fcntl.h>
Felipe Lemead5f6c42015-11-30 14:26:46 -080022#include <libgen.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070023#include <limits.h>
Mark Salyzyn8f37aa52015-06-12 12:28:24 -070024#include <stdbool.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070025#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080028#include <sys/poll.h>
Christopher Ferris7dc7f322014-07-22 16:08:19 -070029#include <sys/prctl.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070030#include <sys/resource.h>
31#include <sys/stat.h>
32#include <sys/time.h>
33#include <sys/wait.h>
34#include <unistd.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070035
36#include <chrono>
37#include <functional>
38#include <future>
Narayan Kamath8f788292017-05-25 13:20:39 +010039#include <memory>
40#include <regex>
41#include <set>
42#include <string>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070043#include <utility>
Narayan Kamath8f788292017-05-25 13:20:39 +010044#include <vector>
Colin Crossf45fa6b2012-03-26 12:38:26 -070045
Felipe Leme96c2bbb2016-09-26 09:21:21 -070046#include <android-base/file.h>
47#include <android-base/properties.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070048#include <android-base/scopeguard.h>
Elliott Hughes9dc117c2015-12-07 14:21:50 -080049#include <android-base/stringprintf.h>
Naveen Kalla058e1e82016-10-19 21:38:44 -070050#include <android-base/strings.h>
Andreas Gampeaff68432016-07-18 18:01:27 -070051#include <android-base/unique_fd.h>
Felipe Leme6f674ae2016-11-18 17:10:33 -080052#include <android/hardware/dumpstate/1.0/IDumpstateDevice.h>
Steven Moreland44cd9482018-01-04 16:24:13 -080053#include <android/hidl/manager/1.0/IServiceManager.h>
Nandana Duttd2f5f082019-01-18 17:13:52 +000054#include <android/os/IIncidentCompanion.h>
Felipe Leme6f674ae2016-11-18 17:10:33 -080055#include <cutils/native_handle.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070056#include <cutils/properties.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080057#include <dumpsys.h>
Steven Moreland44cd9482018-01-04 16:24:13 -080058#include <hidl/ServiceManagement.h>
Felipe Leme75876a22016-10-27 16:31:27 -070059#include <openssl/sha.h>
Mark Salyzyn6c3d90f2016-09-27 14:55:27 -070060#include <private/android_filesystem_config.h>
61#include <private/android_logger.h>
Vishnu Naire97d6122018-01-18 13:58:56 -080062#include <serviceutils/PriorityDumper.h>
Luis Hector Chavez7aecd382018-03-19 11:16:59 -070063#include <utils/StrongPointer.h>
Felipe Lemef0292972016-11-22 13:57:05 -080064#include "DumpstateInternal.h"
Vishnu Naire97d6122018-01-18 13:58:56 -080065#include "DumpstateSectionReporter.h"
Felipe Leme75876a22016-10-27 16:31:27 -070066#include "DumpstateService.h"
Colin Crossf45fa6b2012-03-26 12:38:26 -070067#include "dumpstate.h"
Felipe Leme6e01fa62015-11-11 19:35:14 -080068
Steven Morelandcb7ef822016-11-29 13:20:37 -080069using ::android::hardware::dumpstate::V1_0::IDumpstateDevice;
Vishnu Naire97d6122018-01-18 13:58:56 -080070using ::std::literals::chrono_literals::operator""ms;
71using ::std::literals::chrono_literals::operator""s;
Steven Morelandcb7ef822016-11-29 13:20:37 -080072
Felipe Leme47e9be22016-12-21 15:37:07 -080073// TODO: remove once moved to namespace
Vishnu Naire97d6122018-01-18 13:58:56 -080074using android::defaultServiceManager;
75using android::Dumpsys;
76using android::INVALID_OPERATION;
77using android::IServiceManager;
78using android::OK;
79using android::sp;
80using android::status_t;
81using android::String16;
82using android::String8;
83using android::TIMED_OUT;
84using android::UNKNOWN_ERROR;
85using android::Vector;
Nandana Dutt979388e2018-11-30 16:48:55 +000086using android::base::StringPrintf;
Nandana Duttd2f5f082019-01-18 17:13:52 +000087using android::os::IDumpstateListener;
Felipe Leme47e9be22016-12-21 15:37:07 -080088using android::os::dumpstate::CommandOptions;
89using android::os::dumpstate::DumpFileToFd;
Vishnu Naire97d6122018-01-18 13:58:56 -080090using android::os::dumpstate::DumpstateSectionReporter;
Felipe Leme47e9be22016-12-21 15:37:07 -080091using android::os::dumpstate::GetPidByName;
Vishnu Naire97d6122018-01-18 13:58:56 -080092using android::os::dumpstate::PropertiesHelper;
Felipe Leme47e9be22016-12-21 15:37:07 -080093
Nandana Duttd2f5f082019-01-18 17:13:52 +000094typedef Dumpstate::ConsentCallback::ConsentResult UserConsentResult;
95
Colin Crossf45fa6b2012-03-26 12:38:26 -070096/* read before root is shed */
97static char cmdline_buf[16384] = "(unknown)";
Yi Kong19d5c002018-07-20 13:39:55 -070098static const char *dump_traces_path = nullptr;
Nandana Duttd2f5f082019-01-18 17:13:52 +000099static const uint64_t USER_CONSENT_TIMEOUT_MS = 30 * 1000;
Colin Crossf45fa6b2012-03-26 12:38:26 -0700100
Felipe Leme1d486fe2016-10-14 18:06:47 -0700101// TODO: variables and functions below should be part of dumpstate object
102
Felipe Leme635ca312016-01-05 14:23:02 -0800103static std::set<std::string> mount_points;
104void add_mountinfo();
Felipe Leme78f2c862015-12-21 09:55:22 -0800105
Todd Poynor2a83daa2013-11-22 15:44:22 -0800106#define PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops"
Mark Salyzyn7d0a7622016-06-24 14:06:15 -0700107#define ALT_PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops-0"
Wei Wang509bb5d2017-06-09 14:42:12 -0700108#define BLK_DEV_SYS_DIR "/sys/block"
Todd Poynor2a83daa2013-11-22 15:44:22 -0800109
Felipe Lemee82a27d2016-01-05 13:35:44 -0800110#define RECOVERY_DIR "/cache/recovery"
Mark Salyzynd6ab0112016-03-25 12:56:39 -0700111#define RECOVERY_DATA_DIR "/data/misc/recovery"
Tianjie Xu75d53362018-04-11 16:42:28 -0700112#define UPDATE_ENGINE_LOG_DIR "/data/misc/update_engine_log"
Mark Salyzyn4d42dea2016-04-01 10:03:14 -0700113#define LOGPERSIST_DATA_DIR "/data/misc/logd"
David Brazdild2991962016-06-03 14:40:44 +0100114#define PROFILE_DATA_DIR_CUR "/data/misc/profiles/cur"
115#define PROFILE_DATA_DIR_REF "/data/misc/profiles/ref"
Benedict Wong8f9d8a42019-01-03 16:19:38 -0800116#define XFRM_STAT_PROC_FILE "/proc/net/xfrm_stat"
Erik Kline08165202016-05-30 11:55:44 +0900117#define WLUTIL "/vendor/xbin/wlutil"
Vishnu Nair36b4cdb2017-11-17 10:27:05 -0800118#define WMTRACE_DATA_DIR "/data/misc/wmtrace"
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700119
Narayan Kamath8f788292017-05-25 13:20:39 +0100120// TODO(narayan): Since this information has to be kept in sync
121// with tombstoned, we should just put it in a common header.
122//
123// File: system/core/debuggerd/tombstoned/tombstoned.cpp
Narayan Kamathbd863722017-06-01 18:50:12 +0100124static const std::string TOMBSTONE_DIR = "/data/tombstones/";
125static const std::string TOMBSTONE_FILE_PREFIX = "tombstone_";
126static const std::string ANR_DIR = "/data/anr/";
127static const std::string ANR_FILE_PREFIX = "anr_";
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700128
Felipe Lemee844a9d2016-09-21 15:01:39 -0700129// TODO: temporary variables and functions used during C++ refactoring
130static Dumpstate& ds = Dumpstate::GetInstance();
Nandana Dutt979388e2018-11-30 16:48:55 +0000131
132namespace android {
133namespace os {
134namespace {
135
136static int Open(std::string path, int flags, mode_t mode = 0) {
137 int fd = TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode));
138 if (fd == -1) {
139 MYLOGE("open(%s, %s)\n", path.c_str(), strerror(errno));
140 }
141 return fd;
142}
143
Nandana Dutt979388e2018-11-30 16:48:55 +0000144
145static int OpenForRead(std::string path) {
146 return Open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
147}
148
149bool CopyFile(int in_fd, int out_fd) {
150 char buf[4096];
151 ssize_t byte_count;
152 while ((byte_count = TEMP_FAILURE_RETRY(read(in_fd, buf, sizeof(buf)))) > 0) {
153 if (!android::base::WriteFully(out_fd, buf, byte_count)) {
154 return false;
155 }
156 }
157 return (byte_count != -1);
158}
159
160static bool CopyFileToFd(const std::string& input_file, int out_fd) {
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000161 MYLOGD("Going to copy file (%s) to %d\n", input_file.c_str(), out_fd);
Nandana Dutt979388e2018-11-30 16:48:55 +0000162
163 // Obtain a handle to the source file.
164 android::base::unique_fd in_fd(OpenForRead(input_file));
165 if (out_fd != -1 && in_fd.get() != -1) {
166 if (CopyFile(in_fd.get(), out_fd)) {
167 return true;
168 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000169 MYLOGE("Failed to copy file: %s\n", strerror(errno));
Nandana Dutt979388e2018-11-30 16:48:55 +0000170 }
171 return false;
172}
173
Nandana Duttd2f5f082019-01-18 17:13:52 +0000174static bool UnlinkAndLogOnError(const std::string& file) {
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000175 if (unlink(file.c_str())) {
176 MYLOGE("Failed to unlink file (%s): %s\n", file.c_str(), strerror(errno));
Nandana Duttd2f5f082019-01-18 17:13:52 +0000177 return false;
178 }
179 return true;
180}
Nandana Dutt979388e2018-11-30 16:48:55 +0000181
182} // namespace
183} // namespace os
184} // namespace android
185
Felipe Leme678727a2016-09-21 17:22:11 -0700186static int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
187 const CommandOptions& options = CommandOptions::DEFAULT) {
188 return ds.RunCommand(title, fullCommand, options);
189}
190static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
Felipe Lemebda15a02016-11-16 17:48:25 -0800191 const CommandOptions& options = Dumpstate::DEFAULT_DUMPSYS,
Vishnu Nair6921f802017-11-22 09:17:23 -0800192 long dumpsysTimeoutMs = 0) {
193 return ds.RunDumpsys(title, dumpsysArgs, options, dumpsysTimeoutMs);
Felipe Leme678727a2016-09-21 17:22:11 -0700194}
195static int DumpFile(const std::string& title, const std::string& path) {
196 return ds.DumpFile(title, path);
197}
Felipe Lemee82a27d2016-01-05 13:35:44 -0800198
Felipe Lemee844a9d2016-09-21 15:01:39 -0700199// Relative directory (inside the zip) for all files copied as-is into the bugreport.
200static const std::string ZIP_ROOT_DIR = "FS";
201
Vishnu Naire97d6122018-01-18 13:58:56 -0800202static const std::string kProtoPath = "proto/";
203static const std::string kProtoExt = ".proto";
Jie Song9fbfad02017-06-20 16:29:42 -0700204static const std::string kDumpstateBoardFiles[] = {
205 "dumpstate_board.txt",
Felipe Leme95d6ca52017-08-01 16:35:56 -0700206 "dumpstate_board.bin"
Jie Song9fbfad02017-06-20 16:29:42 -0700207};
208static const int NUM_OF_DUMPS = arraysize(kDumpstateBoardFiles);
209
Felipe Leme9ce6aa42016-09-21 10:02:25 -0700210static constexpr char PROPERTY_EXTRA_OPTIONS[] = "dumpstate.options";
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700211static constexpr char PROPERTY_LAST_ID[] = "dumpstate.last_id";
Felipe Lemed071c682016-10-20 16:48:00 -0700212static constexpr char PROPERTY_VERSION[] = "dumpstate.version";
Naveen Kallab53a1c92017-03-16 18:17:25 -0700213static constexpr char PROPERTY_EXTRA_TITLE[] = "dumpstate.options.title";
214static constexpr char PROPERTY_EXTRA_DESCRIPTION[] = "dumpstate.options.description";
Felipe Leme9ce6aa42016-09-21 10:02:25 -0700215
Felipe Lemef0292972016-11-22 13:57:05 -0800216static const CommandOptions AS_ROOT_20 = CommandOptions::WithTimeout(20).AsRoot().Build();
217
Narayan Kamath8f788292017-05-25 13:20:39 +0100218/*
Narayan Kamathbd863722017-06-01 18:50:12 +0100219 * Returns a vector of dump fds under |dir_path| with a given |file_prefix|.
220 * The returned vector is sorted by the mtimes of the dumps. If |limit_by_mtime|
221 * is set, the vector only contains files that were written in the last 30 minutes.
Andreas Gamped0d76952017-08-22 13:08:37 -0700222 * If |limit_by_count| is set, the vector only contains the ten latest files.
Narayan Kamath8f788292017-05-25 13:20:39 +0100223 */
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700224static std::vector<DumpData> GetDumpFds(const std::string& dir_path,
225 const std::string& file_prefix,
226 bool limit_by_mtime,
227 bool limit_by_count = true) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100228 const time_t thirty_minutes_ago = ds.now_ - 60 * 30;
229
Narayan Kamathbd863722017-06-01 18:50:12 +0100230 std::unique_ptr<DIR, decltype(&closedir)> dump_dir(opendir(dir_path.c_str()), closedir);
Narayan Kamath8f788292017-05-25 13:20:39 +0100231
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700232 if (dump_dir == nullptr) {
233 MYLOGW("Unable to open directory %s: %s\n", dir_path.c_str(), strerror(errno));
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700234 return std::vector<DumpData>();
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700235 }
236
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700237 std::vector<DumpData> dump_data;
Narayan Kamathbd863722017-06-01 18:50:12 +0100238 struct dirent* entry = nullptr;
239 while ((entry = readdir(dump_dir.get()))) {
240 if (entry->d_type != DT_REG) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100241 continue;
242 }
243
Narayan Kamathbd863722017-06-01 18:50:12 +0100244 const std::string base_name(entry->d_name);
245 if (base_name.find(file_prefix) != 0) {
246 continue;
247 }
248
249 const std::string abs_path = dir_path + base_name;
250 android::base::unique_fd fd(
251 TEMP_FAILURE_RETRY(open(abs_path.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK)));
252 if (fd == -1) {
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700253 MYLOGW("Unable to open dump file %s: %s\n", abs_path.c_str(), strerror(errno));
Narayan Kamathbd863722017-06-01 18:50:12 +0100254 break;
255 }
256
257 struct stat st = {};
258 if (fstat(fd, &st) == -1) {
Luis Hector Chavezd0512712018-03-14 12:15:56 -0700259 MYLOGW("Unable to stat dump file %s: %s\n", abs_path.c_str(), strerror(errno));
Narayan Kamath8f788292017-05-25 13:20:39 +0100260 continue;
261 }
262
Narayan Kamath3f31b632018-02-22 19:42:36 +0000263 if (limit_by_mtime && st.st_mtime < thirty_minutes_ago) {
Narayan Kamathbd863722017-06-01 18:50:12 +0100264 MYLOGI("Excluding stale dump file: %s\n", abs_path.c_str());
Narayan Kamath8f788292017-05-25 13:20:39 +0100265 continue;
266 }
267
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700268 dump_data.emplace_back(DumpData{abs_path, std::move(fd), st.st_mtime});
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700269 }
Narayan Kamath8f788292017-05-25 13:20:39 +0100270
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700271 // Sort in descending modification time so that we only keep the newest
272 // reports if |limit_by_count| is true.
273 std::sort(dump_data.begin(), dump_data.end(),
274 [](const DumpData& d1, const DumpData& d2) { return d1.mtime > d2.mtime; });
Narayan Kamath8f788292017-05-25 13:20:39 +0100275
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700276 if (limit_by_count && dump_data.size() > 10) {
277 dump_data.erase(dump_data.begin() + 10, dump_data.end());
Andreas Gamped0d76952017-08-22 13:08:37 -0700278 }
279
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700280 return dump_data;
Narayan Kamath8f788292017-05-25 13:20:39 +0100281}
282
Narayan Kamathbd863722017-06-01 18:50:12 +0100283static bool AddDumps(const std::vector<DumpData>::const_iterator start,
284 const std::vector<DumpData>::const_iterator end,
285 const char* type_name, const bool add_to_zip) {
Narayan Kamath8f788292017-05-25 13:20:39 +0100286 bool dumped = false;
Narayan Kamathbd863722017-06-01 18:50:12 +0100287 for (auto it = start; it != end; ++it) {
288 const std::string& name = it->name;
289 const int fd = it->fd;
Narayan Kamath8f788292017-05-25 13:20:39 +0100290 dumped = true;
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100291
292 // Seek to the beginning of the file before dumping any data. A given
293 // DumpData entry might be dumped multiple times in the report.
294 //
295 // For example, the most recent ANR entry is dumped to the body of the
296 // main entry and it also shows up as a separate entry in the bugreport
297 // ZIP file.
298 if (lseek(fd, 0, SEEK_SET) != static_cast<off_t>(0)) {
299 MYLOGE("Unable to add %s to zip file, lseek failed: %s\n", name.c_str(),
300 strerror(errno));
301 }
302
Narayan Kamath8f788292017-05-25 13:20:39 +0100303 if (ds.IsZipping() && add_to_zip) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800304 if (ds.AddZipEntryFromFd(ZIP_ROOT_DIR + name, fd, /* timeout = */ 0ms) != OK) {
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100305 MYLOGE("Unable to add %s to zip file, addZipEntryFromFd failed\n", name.c_str());
Narayan Kamath8f788292017-05-25 13:20:39 +0100306 }
307 } else {
308 dump_file_from_fd(type_name, name.c_str(), fd);
309 }
Narayan Kamath8f788292017-05-25 13:20:39 +0100310 }
311
312 return dumped;
Christopher Ferris7dc7f322014-07-22 16:08:19 -0700313}
314
Felipe Leme635ca312016-01-05 14:23:02 -0800315// for_each_pid() callback to get mount info about a process.
Felipe Leme4c2d6632016-09-28 14:32:00 -0700316void do_mountinfo(int pid, const char* name __attribute__((unused))) {
Felipe Leme635ca312016-01-05 14:23:02 -0800317 char path[PATH_MAX];
318
319 // Gets the the content of the /proc/PID/ns/mnt link, so only unique mount points
320 // are added.
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700321 snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
Felipe Leme635ca312016-01-05 14:23:02 -0800322 char linkname[PATH_MAX];
323 ssize_t r = readlink(path, linkname, PATH_MAX);
324 if (r == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800325 MYLOGE("Unable to read link for %s: %s\n", path, strerror(errno));
Felipe Leme635ca312016-01-05 14:23:02 -0800326 return;
327 }
328 linkname[r] = '\0';
329
330 if (mount_points.find(linkname) == mount_points.end()) {
331 // First time this mount point was found: add it
Nick Kralevichf0922cc2016-05-14 16:47:44 -0700332 snprintf(path, sizeof(path), "/proc/%d/mountinfo", pid);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700333 if (ds.AddZipEntry(ZIP_ROOT_DIR + path, path)) {
Felipe Leme635ca312016-01-05 14:23:02 -0800334 mount_points.insert(linkname);
335 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800336 MYLOGE("Unable to add mountinfo %s to zip file\n", path);
Felipe Leme635ca312016-01-05 14:23:02 -0800337 }
338 }
339}
340
341void add_mountinfo() {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700342 if (!ds.IsZipping()) return;
Felipe Leme678727a2016-09-21 17:22:11 -0700343 std::string title = "MOUNT INFO";
Felipe Leme635ca312016-01-05 14:23:02 -0800344 mount_points.clear();
Felipe Leme46b85da2016-11-21 17:40:45 -0800345 DurationReporter duration_reporter(title, true);
Felipe Leme678727a2016-09-21 17:22:11 -0700346 for_each_pid(do_mountinfo, nullptr);
347 MYLOGD("%s: %d entries added to zip file\n", title.c_str(), (int)mount_points.size());
Felipe Leme635ca312016-01-05 14:23:02 -0800348}
349
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700350static void dump_dev_files(const char *title, const char *driverpath, const char *filename)
351{
352 DIR *d;
353 struct dirent *de;
354 char path[PATH_MAX];
355
356 d = opendir(driverpath);
Yi Kong19d5c002018-07-20 13:39:55 -0700357 if (d == nullptr) {
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700358 return;
359 }
360
361 while ((de = readdir(d))) {
362 if (de->d_type != DT_LNK) {
363 continue;
364 }
365 snprintf(path, sizeof(path), "%s/%s/%s", driverpath, de->d_name, filename);
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700366 DumpFile(title, path);
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -0700367 }
368
369 closedir(d);
370}
371
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700372
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700373
374// dump anrd's trace and add to the zip file.
375// 1. check if anrd is running on this device.
376// 2. send a SIGUSR1 to its pid which will dump anrd's trace.
377// 3. wait until the trace generation completes and add to the zip file.
378static bool dump_anrd_trace() {
379 unsigned int pid;
380 char buf[50], path[PATH_MAX];
381 struct dirent *trace;
382 struct stat st;
383 DIR *trace_dir;
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700384 int retry = 5;
385 long max_ctime = 0, old_mtime;
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700386 long long cur_size = 0;
387 const char *trace_path = "/data/misc/anrd/";
388
Felipe Leme1d486fe2016-10-14 18:06:47 -0700389 if (!ds.IsZipping()) {
390 MYLOGE("Not dumping anrd trace because it's not a zipped bugreport\n");
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700391 return false;
392 }
393
394 // find anrd's pid if it is running.
Dan Willemsen4a0a8342018-05-04 13:05:01 -0700395 pid = GetPidByName("/system/bin/anrd");
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700396
397 if (pid > 0) {
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700398 if (stat(trace_path, &st) == 0) {
399 old_mtime = st.st_mtime;
400 } else {
401 MYLOGE("Failed to find: %s\n", trace_path);
402 return false;
403 }
404
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700405 // send SIGUSR1 to the anrd to generate a trace.
406 sprintf(buf, "%u", pid);
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700407 if (RunCommand("ANRD_DUMP", {"kill", "-SIGUSR1", buf},
Felipe Leme30dbfa12016-09-02 12:43:26 -0700408 CommandOptions::WithTimeout(1).Build())) {
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700409 MYLOGE("anrd signal timed out. Please manually collect trace\n");
410 return false;
411 }
412
Zhengyin Qianafc38fe2016-09-08 16:50:09 -0700413 while (retry-- > 0 && old_mtime == st.st_mtime) {
414 sleep(1);
415 stat(trace_path, &st);
416 }
417
418 if (retry < 0 && old_mtime == st.st_mtime) {
419 MYLOGE("Failed to stat %s or trace creation timeout\n", trace_path);
420 return false;
421 }
422
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700423 // identify the trace file by its creation time.
424 if (!(trace_dir = opendir(trace_path))) {
425 MYLOGE("Can't open trace file under %s\n", trace_path);
426 }
427 while ((trace = readdir(trace_dir))) {
428 if (strcmp(trace->d_name, ".") == 0
429 || strcmp(trace->d_name, "..") == 0) {
430 continue;
431 }
432 sprintf(path, "%s%s", trace_path, trace->d_name);
433 if (stat(path, &st) == 0) {
434 if (st.st_ctime > max_ctime) {
435 max_ctime = st.st_ctime;
436 sprintf(buf, "%s", trace->d_name);
437 }
438 }
439 }
440 closedir(trace_dir);
441
442 // Wait until the dump completes by checking the size of the trace.
443 if (max_ctime > 0) {
444 sprintf(path, "%s%s", trace_path, buf);
445 while(true) {
446 sleep(1);
447 if (stat(path, &st) == 0) {
448 if (st.st_size == cur_size) {
449 break;
450 } else if (st.st_size > cur_size) {
451 cur_size = st.st_size;
452 } else {
453 return false;
454 }
455 } else {
456 MYLOGE("Cant stat() %s anymore\n", path);
457 return false;
458 }
459 }
460 // Add to the zip file.
Felipe Leme1d486fe2016-10-14 18:06:47 -0700461 if (!ds.AddZipEntry("anrd_trace.txt", path)) {
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700462 MYLOGE("Unable to add anrd_trace file %s to zip file\n", path);
463 } else {
Nandana Dutt16d1aee2019-02-15 16:13:53 +0000464 android::os::UnlinkAndLogOnError(path);
Zhengyin Qian068ecc72016-08-10 16:48:14 -0700465 return true;
466 }
467 } else {
468 MYLOGE("Can't stats any trace file under %s\n", trace_path);
469 }
470 }
471 return false;
472}
473
Mark Salyzyn326842f2015-04-30 09:49:41 -0700474static bool skip_not_stat(const char *path) {
475 static const char stat[] = "/stat";
476 size_t len = strlen(path);
477 if (path[len - 1] == '/') { /* Directory? */
478 return false;
479 }
480 return strcmp(path + len - sizeof(stat) + 1, stat); /* .../stat? */
481}
482
Felipe Leme4c2d6632016-09-28 14:32:00 -0700483static bool skip_none(const char* path __attribute__((unused))) {
Felipe Lemee82a27d2016-01-05 13:35:44 -0800484 return false;
485}
486
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700487unsigned long worst_write_perf = 20000; /* in KB/s */
Mark Salyzyn326842f2015-04-30 09:49:41 -0700488
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800489//
490// stat offsets
491// Name units description
492// ---- ----- -----------
493// read I/Os requests number of read I/Os processed
494#define __STAT_READ_IOS 0
495// read merges requests number of read I/Os merged with in-queue I/O
496#define __STAT_READ_MERGES 1
497// read sectors sectors number of sectors read
498#define __STAT_READ_SECTORS 2
499// read ticks milliseconds total wait time for read requests
500#define __STAT_READ_TICKS 3
501// write I/Os requests number of write I/Os processed
502#define __STAT_WRITE_IOS 4
503// write merges requests number of write I/Os merged with in-queue I/O
504#define __STAT_WRITE_MERGES 5
505// write sectors sectors number of sectors written
506#define __STAT_WRITE_SECTORS 6
507// write ticks milliseconds total wait time for write requests
508#define __STAT_WRITE_TICKS 7
509// in_flight requests number of I/Os currently in flight
510#define __STAT_IN_FLIGHT 8
511// io_ticks milliseconds total time this block device has been active
512#define __STAT_IO_TICKS 9
513// time_in_queue milliseconds total wait time for all requests
514#define __STAT_IN_QUEUE 10
515#define __STAT_NUMBER_FIELD 11
516//
517// read I/Os, write I/Os
518// =====================
519//
520// These values increment when an I/O request completes.
521//
522// read merges, write merges
523// =========================
524//
525// These values increment when an I/O request is merged with an
526// already-queued I/O request.
527//
528// read sectors, write sectors
529// ===========================
530//
531// These values count the number of sectors read from or written to this
532// block device. The "sectors" in question are the standard UNIX 512-byte
533// sectors, not any device- or filesystem-specific block size. The
534// counters are incremented when the I/O completes.
535#define SECTOR_SIZE 512
536//
537// read ticks, write ticks
538// =======================
539//
540// These values count the number of milliseconds that I/O requests have
541// waited on this block device. If there are multiple I/O requests waiting,
542// these values will increase at a rate greater than 1000/second; for
543// example, if 60 read requests wait for an average of 30 ms, the read_ticks
544// field will increase by 60*30 = 1800.
545//
546// in_flight
547// =========
548//
549// This value counts the number of I/O requests that have been issued to
550// the device driver but have not yet completed. It does not include I/O
551// requests that are in the queue but not yet issued to the device driver.
552//
553// io_ticks
554// ========
555//
556// This value counts the number of milliseconds during which the device has
557// had I/O requests queued.
558//
559// time_in_queue
560// =============
561//
562// This value counts the number of milliseconds that I/O requests have waited
563// on this block device. If there are multiple I/O requests waiting, this
564// value will increase as the product of the number of milliseconds times the
565// number of requests waiting (see "read ticks" above for an example).
566#define S_TO_MS 1000
567//
568
Mark Salyzyn326842f2015-04-30 09:49:41 -0700569static int dump_stat_from_fd(const char *title __unused, const char *path, int fd) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800570 unsigned long long fields[__STAT_NUMBER_FIELD];
Mark Salyzyn326842f2015-04-30 09:49:41 -0700571 bool z;
Yi Kong19d5c002018-07-20 13:39:55 -0700572 char *cp, *buffer = nullptr;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700573 size_t i = 0;
Josh Gao7c4258c2018-06-25 13:40:08 -0700574 FILE *fp = fdopen(dup(fd), "rb");
Mark Salyzyn326842f2015-04-30 09:49:41 -0700575 getline(&buffer, &i, fp);
576 fclose(fp);
577 if (!buffer) {
578 return -errno;
579 }
580 i = strlen(buffer);
581 while ((i > 0) && (buffer[i - 1] == '\n')) {
582 buffer[--i] = '\0';
583 }
584 if (!*buffer) {
585 free(buffer);
586 return 0;
587 }
588 z = true;
589 for (cp = buffer, i = 0; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800590 fields[i] = strtoull(cp, &cp, 10);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700591 if (fields[i] != 0) {
592 z = false;
593 }
594 }
595 if (z) { /* never accessed */
596 free(buffer);
597 return 0;
598 }
599
Wei Wang509bb5d2017-06-09 14:42:12 -0700600 if (!strncmp(path, BLK_DEV_SYS_DIR, sizeof(BLK_DEV_SYS_DIR) - 1)) {
601 path += sizeof(BLK_DEV_SYS_DIR) - 1;
Mark Salyzyn326842f2015-04-30 09:49:41 -0700602 }
Wei Wang1dc1ef52017-06-12 11:28:37 -0700603
604 printf("%-30s:%9s%9s%9s%9s%9s%9s%9s%9s%9s%9s%9s\n%-30s:\t%s\n", "Block-Dev",
605 "R-IOs", "R-merg", "R-sect", "R-wait", "W-IOs", "W-merg", "W-sect",
606 "W-wait", "in-fli", "activ", "T-wait", path, buffer);
Mark Salyzyn326842f2015-04-30 09:49:41 -0700607 free(buffer);
608
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800609 if (fields[__STAT_IO_TICKS]) {
610 unsigned long read_perf = 0;
611 unsigned long read_ios = 0;
612 if (fields[__STAT_READ_TICKS]) {
613 unsigned long long divisor = fields[__STAT_READ_TICKS]
614 * fields[__STAT_IO_TICKS];
615 read_perf = ((unsigned long long)SECTOR_SIZE
616 * fields[__STAT_READ_SECTORS]
617 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
618 / divisor;
619 read_ios = ((unsigned long long)S_TO_MS * fields[__STAT_READ_IOS]
620 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
621 / divisor;
622 }
623
624 unsigned long write_perf = 0;
625 unsigned long write_ios = 0;
626 if (fields[__STAT_WRITE_TICKS]) {
627 unsigned long long divisor = fields[__STAT_WRITE_TICKS]
628 * fields[__STAT_IO_TICKS];
629 write_perf = ((unsigned long long)SECTOR_SIZE
630 * fields[__STAT_WRITE_SECTORS]
631 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
632 / divisor;
633 write_ios = ((unsigned long long)S_TO_MS * fields[__STAT_WRITE_IOS]
634 * fields[__STAT_IN_QUEUE] + (divisor >> 1))
635 / divisor;
636 }
637
638 unsigned queue = (fields[__STAT_IN_QUEUE]
639 + (fields[__STAT_IO_TICKS] >> 1))
640 / fields[__STAT_IO_TICKS];
641
642 if (!write_perf && !write_ios) {
Wei Wang1dc1ef52017-06-12 11:28:37 -0700643 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 -0800644 } else {
Wei Wang1dc1ef52017-06-12 11:28:37 -0700645 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 -0800646 read_ios, write_perf, write_ios, queue);
Mark Salyzyn01d6c392016-02-04 09:20:44 -0800647 }
648
649 /* bugreport timeout factor adjustment */
650 if ((write_perf > 1) && (write_perf < worst_write_perf)) {
651 worst_write_perf = write_perf;
652 }
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700653 }
Mark Salyzyn326842f2015-04-30 09:49:41 -0700654 return 0;
655}
656
Yao Chenbe3bbc12018-01-17 16:31:10 -0800657static const long MINIMUM_LOGCAT_TIMEOUT_MS = 50000;
658
659/* timeout in ms to read a list of buffers */
660static unsigned long logcat_timeout(const std::vector<std::string>& buffers) {
661 unsigned long timeout_ms = 0;
662 for (const auto& buffer : buffers) {
663 log_id_t id = android_name_to_log_id(buffer.c_str());
664 unsigned long property_size = __android_logger_get_buffer_size(id);
665 /* Engineering margin is ten-fold our guess */
666 timeout_ms += 10 * (property_size + worst_write_perf) / worst_write_perf;
667 }
668 return timeout_ms > MINIMUM_LOGCAT_TIMEOUT_MS ? timeout_ms : MINIMUM_LOGCAT_TIMEOUT_MS;
Mark Salyzyn8f37aa52015-06-12 12:28:24 -0700669}
670
Nandana Duttd2f5f082019-01-18 17:13:52 +0000671Dumpstate::ConsentCallback::ConsentCallback() : result_(UNAVAILABLE), start_time_(Nanotime()) {
672}
673
674android::binder::Status Dumpstate::ConsentCallback::onReportApproved() {
675 std::lock_guard<std::mutex> lock(lock_);
676 result_ = APPROVED;
677 MYLOGD("User approved consent to share bugreport\n");
678 return android::binder::Status::ok();
679}
680
681android::binder::Status Dumpstate::ConsentCallback::onReportDenied() {
682 std::lock_guard<std::mutex> lock(lock_);
683 result_ = DENIED;
684 MYLOGW("User denied consent to share bugreport\n");
685 return android::binder::Status::ok();
686}
687
688UserConsentResult Dumpstate::ConsentCallback::getResult() {
689 std::lock_guard<std::mutex> lock(lock_);
690 return result_;
691}
692
693uint64_t Dumpstate::ConsentCallback::getElapsedTimeMs() const {
694 return Nanotime() - start_time_;
695}
696
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700697void Dumpstate::PrintHeader() const {
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700698 std::string build, fingerprint, radio, bootloader, network;
699 char date[80];
Colin Crossf45fa6b2012-03-26 12:38:26 -0700700
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700701 build = android::base::GetProperty("ro.build.display.id", "(unknown)");
702 fingerprint = android::base::GetProperty("ro.build.fingerprint", "(unknown)");
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700703 radio = android::base::GetProperty("gsm.version.baseband", "(unknown)");
704 bootloader = android::base::GetProperty("ro.bootloader", "(unknown)");
705 network = android::base::GetProperty("gsm.operator.alpha", "(unknown)");
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700706 strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now_));
Colin Crossf45fa6b2012-03-26 12:38:26 -0700707
Felipe Lemed8b94e52016-12-08 10:21:44 -0800708 printf("========================================================\n");
709 printf("== dumpstate: %s\n", date);
710 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -0700711
Felipe Lemed8b94e52016-12-08 10:21:44 -0800712 printf("\n");
713 printf("Build: %s\n", build.c_str());
Felipe Leme96c2bbb2016-09-26 09:21:21 -0700714 // NOTE: fingerprint entry format is important for other tools.
Felipe Lemed8b94e52016-12-08 10:21:44 -0800715 printf("Build fingerprint: '%s'\n", fingerprint.c_str());
716 printf("Bootloader: %s\n", bootloader.c_str());
717 printf("Radio: %s\n", radio.c_str());
718 printf("Network: %s\n", network.c_str());
Colin Crossf45fa6b2012-03-26 12:38:26 -0700719
Felipe Lemed8b94e52016-12-08 10:21:44 -0800720 printf("Kernel: ");
Felipe Lemef0292972016-11-22 13:57:05 -0800721 DumpFileToFd(STDOUT_FILENO, "", "/proc/version");
Felipe Lemed8b94e52016-12-08 10:21:44 -0800722 printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
Felipe Leme7709f8a2017-12-05 09:30:09 -0800723 printf("Uptime: ");
724 RunCommandToFd(STDOUT_FILENO, "", {"uptime", "-p"},
725 CommandOptions::WithTimeout(1).Always().Build());
Felipe Lemed8b94e52016-12-08 10:21:44 -0800726 printf("Bugreport format version: %s\n", version_.c_str());
727 printf("Dumpstate info: id=%d pid=%d dry_run=%d args=%s extra_options=%s\n", id_, pid_,
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100728 PropertiesHelper::IsDryRun(), options_->args.c_str(), options_->extra_options.c_str());
Felipe Lemed8b94e52016-12-08 10:21:44 -0800729 printf("\n");
Felipe Leme78f2c862015-12-21 09:55:22 -0800730}
731
Felipe Leme24b66ee2016-06-16 10:55:26 -0700732// List of file extensions that can cause a zip file attachment to be rejected by some email
733// service providers.
734static const std::set<std::string> PROBLEMATIC_FILE_EXTENSIONS = {
735 ".ade", ".adp", ".bat", ".chm", ".cmd", ".com", ".cpl", ".exe", ".hta", ".ins", ".isp",
736 ".jar", ".jse", ".lib", ".lnk", ".mde", ".msc", ".msp", ".mst", ".pif", ".scr", ".sct",
737 ".shb", ".sys", ".vb", ".vbe", ".vbs", ".vxd", ".wsc", ".wsf", ".wsh"
738};
739
Vishnu Naire97d6122018-01-18 13:58:56 -0800740status_t Dumpstate::AddZipEntryFromFd(const std::string& entry_name, int fd,
741 std::chrono::milliseconds timeout = 0ms) {
Felipe Leme1d486fe2016-10-14 18:06:47 -0700742 if (!IsZipping()) {
743 MYLOGD("Not adding zip entry %s from fd because it's not a zipped bugreport\n",
744 entry_name.c_str());
Vishnu Naire97d6122018-01-18 13:58:56 -0800745 return INVALID_OPERATION;
Felipe Leme111b9d02016-02-03 09:28:24 -0800746 }
Felipe Leme24b66ee2016-06-16 10:55:26 -0700747 std::string valid_name = entry_name;
748
749 // Rename extension if necessary.
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -0700750 size_t idx = entry_name.rfind('.');
Felipe Leme24b66ee2016-06-16 10:55:26 -0700751 if (idx != std::string::npos) {
752 std::string extension = entry_name.substr(idx);
753 std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
754 if (PROBLEMATIC_FILE_EXTENSIONS.count(extension) != 0) {
755 valid_name = entry_name + ".renamed";
756 MYLOGI("Renaming entry %s to %s\n", entry_name.c_str(), valid_name.c_str());
757 }
758 }
759
Felipe Leme6fe9db62016-02-12 09:04:16 -0800760 // Logging statement below is useful to time how long each entry takes, but it's too verbose.
761 // MYLOGD("Adding zip entry %s\n", entry_name.c_str());
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700762 int32_t err = zip_writer_->StartEntryWithTime(valid_name.c_str(), ZipWriter::kCompress,
763 get_mtime(fd, ds.now_));
Felipe Leme1d486fe2016-10-14 18:06:47 -0700764 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700765 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", valid_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700766 ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800767 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800768 }
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000769 bool finished_entry = false;
770 auto finish_entry = [this, &finished_entry] {
771 if (!finished_entry) {
772 // This should only be called when we're going to return an earlier error,
773 // which would've been logged. This may imply the file is already corrupt
774 // and any further logging from FinishEntry is more likely to mislead than
775 // not.
776 this->zip_writer_->FinishEntry();
777 }
778 };
779 auto scope_guard = android::base::make_scope_guard(finish_entry);
Vishnu Naire97d6122018-01-18 13:58:56 -0800780 auto start = std::chrono::steady_clock::now();
781 auto end = start + timeout;
782 struct pollfd pfd = {fd, POLLIN};
Felipe Lemee82a27d2016-01-05 13:35:44 -0800783
Felipe Leme770410d2016-01-26 17:07:14 -0800784 std::vector<uint8_t> buffer(65536);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800785 while (1) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800786 if (timeout.count() > 0) {
787 // lambda to recalculate the timeout.
788 auto time_left_ms = [end]() {
789 auto now = std::chrono::steady_clock::now();
790 auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - now);
791 return std::max(diff.count(), 0LL);
792 };
793
794 int rc = TEMP_FAILURE_RETRY(poll(&pfd, 1, time_left_ms()));
795 if (rc < 0) {
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000796 MYLOGE("Error in poll while adding from fd to zip entry %s:%s\n",
797 entry_name.c_str(), strerror(errno));
Vishnu Naire97d6122018-01-18 13:58:56 -0800798 return -errno;
799 } else if (rc == 0) {
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000800 MYLOGE("Timed out adding from fd to zip entry %s:%s Timeout:%lldms\n",
Vishnu Naire97d6122018-01-18 13:58:56 -0800801 entry_name.c_str(), strerror(errno), timeout.count());
802 return TIMED_OUT;
803 }
804 }
805
Zach Riggle22200402016-08-18 01:01:24 -0400806 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), buffer.size()));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800807 if (bytes_read == 0) {
808 break;
809 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800810 MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
Vishnu Naire97d6122018-01-18 13:58:56 -0800811 return -errno;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800812 }
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700813 err = zip_writer_->WriteBytes(buffer.data(), bytes_read);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800814 if (err) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700815 MYLOGE("zip_writer_->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800816 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800817 }
818 }
819
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700820 err = zip_writer_->FinishEntry();
Narayan Kamath895f8fc2019-02-08 18:18:08 +0000821 finished_entry = true;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700822 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700823 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800824 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800825 }
826
Vishnu Naire97d6122018-01-18 13:58:56 -0800827 return OK;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800828}
829
Felipe Leme1d486fe2016-10-14 18:06:47 -0700830bool Dumpstate::AddZipEntry(const std::string& entry_name, const std::string& entry_path) {
831 android::base::unique_fd fd(
832 TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
Andreas Gampeaff68432016-07-18 18:01:27 -0700833 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800834 MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800835 return false;
836 }
837
Vishnu Naire97d6122018-01-18 13:58:56 -0800838 return (AddZipEntryFromFd(entry_name, fd.get()) == OK);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800839}
840
841/* adds a file to the existing zipped bugreport */
Felipe Leme4c2d6632016-09-28 14:32:00 -0700842static int _add_file_from_fd(const char* title __attribute__((unused)), const char* path, int fd) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800843 return (ds.AddZipEntryFromFd(ZIP_ROOT_DIR + path, fd) == OK) ? 0 : 1;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800844}
845
Felipe Leme1d486fe2016-10-14 18:06:47 -0700846void Dumpstate::AddDir(const std::string& dir, bool recursive) {
847 if (!IsZipping()) {
848 MYLOGD("Not adding dir %s because it's not a zipped bugreport\n", dir.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800849 return;
850 }
Felipe Leme678727a2016-09-21 17:22:11 -0700851 MYLOGD("Adding dir %s (recursive: %d)\n", dir.c_str(), recursive);
Felipe Leme46b85da2016-11-21 17:40:45 -0800852 DurationReporter duration_reporter(dir, true);
Felipe Leme678727a2016-09-21 17:22:11 -0700853 dump_files("", dir.c_str(), recursive ? skip_none : is_dir, _add_file_from_fd);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800854}
855
Felipe Leme1d486fe2016-10-14 18:06:47 -0700856bool Dumpstate::AddTextZipEntry(const std::string& entry_name, const std::string& content) {
857 if (!IsZipping()) {
858 MYLOGD("Not adding text zip entry %s because it's not a zipped bugreport\n",
859 entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800860 return false;
861 }
Felipe Lemecbce55d2016-02-08 09:53:18 -0800862 MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700863 int32_t err = zip_writer_->StartEntryWithTime(entry_name.c_str(), ZipWriter::kCompress, ds.now_);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700864 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700865 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700866 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800867 return false;
868 }
869
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700870 err = zip_writer_->WriteBytes(content.c_str(), content.length());
Felipe Leme1d486fe2016-10-14 18:06:47 -0700871 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700872 MYLOGE("zip_writer_->WriteBytes(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700873 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800874 return false;
875 }
876
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700877 err = zip_writer_->FinishEntry();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700878 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700879 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800880 return false;
881 }
882
883 return true;
884}
885
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800886static void DoKmsg() {
887 struct stat st;
888 if (!stat(PSTORE_LAST_KMSG, &st)) {
889 /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
890 DumpFile("LAST KMSG", PSTORE_LAST_KMSG);
891 } else if (!stat(ALT_PSTORE_LAST_KMSG, &st)) {
892 DumpFile("LAST KMSG", ALT_PSTORE_LAST_KMSG);
893 } else {
894 /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
895 DumpFile("LAST KMSG", "/proc/last_kmsg");
896 }
897}
898
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800899static void DoKernelLogcat() {
Yao Chenbe3bbc12018-01-17 16:31:10 -0800900 unsigned long timeout_ms = logcat_timeout({"kernel"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800901 RunCommand(
902 "KERNEL LOG",
903 {"logcat", "-b", "kernel", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
904 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
905}
906
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800907static void DoLogcat() {
Vishnu Nair6921f802017-11-22 09:17:23 -0800908 unsigned long timeout_ms;
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800909 // DumpFile("EVENT LOG TAGS", "/etc/event-log-tags");
910 // calculate timeout
Yao Chenbe3bbc12018-01-17 16:31:10 -0800911 timeout_ms = logcat_timeout({"main", "system", "crash"});
Tony Makae737652017-03-30 17:47:09 +0100912 RunCommand("SYSTEM LOG",
Vishnu Nair6921f802017-11-22 09:17:23 -0800913 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
914 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Yao Chenbe3bbc12018-01-17 16:31:10 -0800915 timeout_ms = logcat_timeout({"events"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800916 RunCommand(
917 "EVENT LOG",
918 {"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
919 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Yao Chenbe3bbc12018-01-17 16:31:10 -0800920 timeout_ms = logcat_timeout({"stats"});
921 RunCommand(
922 "STATS LOG",
923 {"logcat", "-b", "stats", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
924 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
925 timeout_ms = logcat_timeout({"radio"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800926 RunCommand(
927 "RADIO LOG",
928 {"logcat", "-b", "radio", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
929 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800930
931 RunCommand("LOG STATISTICS", {"logcat", "-b", "all", "-S"});
932
933 /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800934 RunCommand("LAST LOGCAT", {"logcat", "-L", "-b", "all", "-v", "threadtime", "-v", "printable",
935 "-v", "uid", "-d", "*:v"});
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800936}
937
Jayachandran Ca94c7172017-06-10 15:08:12 -0700938static void DumpIpTablesAsRoot() {
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700939 RunCommand("IPTABLES", {"iptables", "-L", "-nvx"});
940 RunCommand("IP6TABLES", {"ip6tables", "-L", "-nvx"});
Erik Kline32af8c22016-09-28 17:26:26 +0900941 RunCommand("IPTABLES NAT", {"iptables", "-t", "nat", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -0700942 /* no ip6 nat */
Erik Kline32af8c22016-09-28 17:26:26 +0900943 RunCommand("IPTABLES MANGLE", {"iptables", "-t", "mangle", "-L", "-nvx"});
944 RunCommand("IP6TABLES MANGLE", {"ip6tables", "-t", "mangle", "-L", "-nvx"});
945 RunCommand("IPTABLES RAW", {"iptables", "-t", "raw", "-L", "-nvx"});
946 RunCommand("IP6TABLES RAW", {"ip6tables", "-t", "raw", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -0700947}
948
Narayan Kamath8f788292017-05-25 13:20:39 +0100949static void AddAnrTraceDir(const bool add_to_zip, const std::string& anr_traces_dir) {
950 MYLOGD("AddAnrTraceDir(): dump_traces_file=%s, anr_traces_dir=%s\n", dump_traces_path,
951 anr_traces_dir.c_str());
952
953 // If we're here, dump_traces_path will always be a temporary file
954 // (created with mkostemp or similar) that contains dumps taken earlier
955 // on in the process.
956 if (dump_traces_path != nullptr) {
957 if (add_to_zip) {
958 ds.AddZipEntry(ZIP_ROOT_DIR + anr_traces_dir + "/traces-just-now.txt", dump_traces_path);
959 } else {
960 MYLOGD("Dumping current ANR traces (%s) to the main bugreport entry\n",
961 dump_traces_path);
962 ds.DumpFile("VM TRACES JUST NOW", dump_traces_path);
963 }
964
965 const int ret = unlink(dump_traces_path);
966 if (ret == -1) {
967 MYLOGW("Error unlinking temporary trace path %s: %s\n", dump_traces_path,
968 strerror(errno));
Felipe Lemee184f662016-10-27 10:04:47 -0700969 }
970 }
971
Narayan Kamathbd863722017-06-01 18:50:12 +0100972 // Add a specific message for the first ANR Dump.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700973 if (ds.anr_data_.size() > 0) {
974 AddDumps(ds.anr_data_.begin(), ds.anr_data_.begin() + 1,
Narayan Kamathbd863722017-06-01 18:50:12 +0100975 "VM TRACES AT LAST ANR", add_to_zip);
976
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100977 // The "last" ANR will always be included as separate entry in the zip file. In addition,
978 // it will be present in the body of the main entry if |add_to_zip| == false.
979 //
980 // Historical ANRs are always included as separate entries in the bugreport zip file.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700981 AddDumps(ds.anr_data_.begin() + ((add_to_zip) ? 1 : 0), ds.anr_data_.end(),
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100982 "HISTORICAL ANR", true /* add_to_zip */);
Narayan Kamathbd863722017-06-01 18:50:12 +0100983 } else {
Narayan Kamath8f788292017-05-25 13:20:39 +0100984 printf("*** NO ANRs to dump in %s\n\n", ANR_DIR.c_str());
985 }
986}
987
988static void AddAnrTraceFiles() {
989 const bool add_to_zip = ds.IsZipping() && ds.version_ == VERSION_SPLIT_ANR;
990
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700991 std::string anr_traces_dir = "/data/anr";
Narayan Kamath8f788292017-05-25 13:20:39 +0100992
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700993 AddAnrTraceDir(add_to_zip, anr_traces_dir);
Narayan Kamath8f788292017-05-25 13:20:39 +0100994
Makoto Onuki83ec63f2019-01-31 17:08:59 -0800995 RunCommand("ANR FILES", {"ls", "-lt", ANR_DIR});
996
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700997 // Slow traces for slow operations.
Felipe Lemee184f662016-10-27 10:04:47 -0700998 struct stat st;
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700999 int i = 0;
1000 while (true) {
1001 const std::string slow_trace_path =
1002 anr_traces_dir + android::base::StringPrintf("slow%02d.txt", i);
1003 if (stat(slow_trace_path.c_str(), &st)) {
1004 // No traces file at this index, done with the files.
1005 break;
Felipe Lemee184f662016-10-27 10:04:47 -07001006 }
Elliott Hughes69fe5ec2018-03-23 11:04:25 -07001007 ds.DumpFile("VM TRACES WHEN SLOW", slow_trace_path.c_str());
1008 i++;
Felipe Lemee184f662016-10-27 10:04:47 -07001009 }
1010}
1011
Wei Wang509bb5d2017-06-09 14:42:12 -07001012static void DumpBlockStatFiles() {
1013 DurationReporter duration_reporter("DUMP BLOCK STAT");
Wei Wang509bb5d2017-06-09 14:42:12 -07001014
Wei Wang1dc1ef52017-06-12 11:28:37 -07001015 std::unique_ptr<DIR, std::function<int(DIR*)>> dirptr(opendir(BLK_DEV_SYS_DIR), closedir);
1016
1017 if (dirptr == nullptr) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001018 MYLOGE("Failed to open %s: %s\n", BLK_DEV_SYS_DIR, strerror(errno));
1019 return;
1020 }
1021
1022 printf("------ DUMP BLOCK STAT ------\n\n");
Wei Wang1dc1ef52017-06-12 11:28:37 -07001023 while (struct dirent *d = readdir(dirptr.get())) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001024 if ((d->d_name[0] == '.')
1025 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
1026 || (d->d_name[1] == '\0'))) {
1027 continue;
1028 }
1029 const std::string new_path =
1030 android::base::StringPrintf("%s/%s", BLK_DEV_SYS_DIR, d->d_name);
1031 printf("------ BLOCK STAT (%s) ------\n", new_path.c_str());
1032 dump_files("", new_path.c_str(), skip_not_stat, dump_stat_from_fd);
1033 printf("\n");
1034 }
Wei Wang1dc1ef52017-06-12 11:28:37 -07001035 return;
Wei Wang509bb5d2017-06-09 14:42:12 -07001036}
Jayachandran Ca94c7172017-06-10 15:08:12 -07001037
1038static void DumpPacketStats() {
1039 DumpFile("NETWORK DEV INFO", "/proc/net/dev");
1040 DumpFile("QTAGUID NETWORK INTERFACES INFO", "/proc/net/xt_qtaguid/iface_stat_all");
1041 DumpFile("QTAGUID NETWORK INTERFACES INFO (xt)", "/proc/net/xt_qtaguid/iface_stat_fmt");
1042 DumpFile("QTAGUID CTRL INFO", "/proc/net/xt_qtaguid/ctrl");
1043 DumpFile("QTAGUID STATS INFO", "/proc/net/xt_qtaguid/stats");
1044}
1045
1046static void DumpIpAddrAndRules() {
1047 /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
1048 RunCommand("NETWORK INTERFACES", {"ip", "link"});
1049 RunCommand("IPv4 ADDRESSES", {"ip", "-4", "addr", "show"});
1050 RunCommand("IPv6 ADDRESSES", {"ip", "-6", "addr", "show"});
1051 RunCommand("IP RULES", {"ip", "rule", "show"});
1052 RunCommand("IP RULES v6", {"ip", "-6", "rule", "show"});
1053}
1054
Vishnu Nair64afc022018-02-01 15:29:34 -08001055static void RunDumpsysTextByPriority(const std::string& title, int priority,
1056 std::chrono::milliseconds timeout,
1057 std::chrono::milliseconds service_timeout) {
1058 auto start = std::chrono::steady_clock::now();
Vishnu Naire97d6122018-01-18 13:58:56 -08001059 sp<android::IServiceManager> sm = defaultServiceManager();
1060 Dumpsys dumpsys(sm.get());
Vishnu Naire97d6122018-01-18 13:58:56 -08001061 Vector<String16> args;
1062 Dumpsys::setServiceArgs(args, /* asProto = */ false, priority);
Vishnu Naire97d6122018-01-18 13:58:56 -08001063 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ false);
1064 for (const String16& service : services) {
1065 std::string path(title);
1066 path.append(" - ").append(String8(service).c_str());
1067 DumpstateSectionReporter section_reporter(path, ds.listener_, ds.report_section_);
1068 size_t bytes_written = 0;
1069 status_t status = dumpsys.startDumpThread(service, args);
1070 if (status == OK) {
1071 dumpsys.writeDumpHeader(STDOUT_FILENO, service, priority);
1072 std::chrono::duration<double> elapsed_seconds;
1073 status = dumpsys.writeDump(STDOUT_FILENO, service, service_timeout,
1074 /* as_proto = */ false, elapsed_seconds, bytes_written);
1075 section_reporter.setSize(bytes_written);
1076 dumpsys.writeDumpFooter(STDOUT_FILENO, service, elapsed_seconds);
1077 bool dump_complete = (status == OK);
1078 dumpsys.stopDumpThread(dump_complete);
1079 }
1080 section_reporter.setStatus(status);
1081
1082 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1083 std::chrono::steady_clock::now() - start);
1084 if (elapsed_duration > timeout) {
1085 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1086 elapsed_duration.count());
1087 break;
1088 }
1089 }
1090}
1091
Vishnu Nair64afc022018-02-01 15:29:34 -08001092static void RunDumpsysText(const std::string& title, int priority,
1093 std::chrono::milliseconds timeout,
1094 std::chrono::milliseconds service_timeout) {
1095 DurationReporter duration_reporter(title);
1096 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1097 fsync(STDOUT_FILENO);
1098 RunDumpsysTextByPriority(title, priority, timeout, service_timeout);
1099}
1100
1101/* Dump all services registered with Normal or Default priority. */
1102static void RunDumpsysTextNormalPriority(const std::string& title,
1103 std::chrono::milliseconds timeout,
1104 std::chrono::milliseconds service_timeout) {
1105 DurationReporter duration_reporter(title);
1106 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1107 fsync(STDOUT_FILENO);
1108 RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_NORMAL, timeout,
1109 service_timeout);
1110 RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT, timeout,
1111 service_timeout);
1112}
1113
1114static void RunDumpsysProto(const std::string& title, int priority,
1115 std::chrono::milliseconds timeout,
1116 std::chrono::milliseconds service_timeout) {
Luis Hector Chavez1e27b082018-03-22 15:36:42 -07001117 if (!ds.IsZipping()) {
1118 MYLOGD("Not dumping %s because it's not a zipped bugreport\n", title.c_str());
1119 return;
1120 }
Vishnu Naire97d6122018-01-18 13:58:56 -08001121 sp<android::IServiceManager> sm = defaultServiceManager();
1122 Dumpsys dumpsys(sm.get());
1123 Vector<String16> args;
1124 Dumpsys::setServiceArgs(args, /* asProto = */ true, priority);
1125 DurationReporter duration_reporter(title);
1126
1127 auto start = std::chrono::steady_clock::now();
1128 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ true);
1129 for (const String16& service : services) {
1130 std::string path(kProtoPath);
1131 path.append(String8(service).c_str());
1132 if (priority == IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL) {
1133 path.append("_CRITICAL");
1134 } else if (priority == IServiceManager::DUMP_FLAG_PRIORITY_HIGH) {
1135 path.append("_HIGH");
1136 }
1137 path.append(kProtoExt);
1138 DumpstateSectionReporter section_reporter(path, ds.listener_, ds.report_section_);
1139 status_t status = dumpsys.startDumpThread(service, args);
1140 if (status == OK) {
1141 status = ds.AddZipEntryFromFd(path, dumpsys.getDumpFd(), service_timeout);
1142 bool dumpTerminated = (status == OK);
1143 dumpsys.stopDumpThread(dumpTerminated);
1144 }
1145 ZipWriter::FileEntry file_entry;
1146 ds.zip_writer_->GetLastEntry(&file_entry);
1147 section_reporter.setSize(file_entry.compressed_size);
1148 section_reporter.setStatus(status);
1149
1150 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1151 std::chrono::steady_clock::now() - start);
1152 if (elapsed_duration > timeout) {
1153 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1154 elapsed_duration.count());
1155 break;
1156 }
1157 }
1158}
1159
Nandana Dutta7db6342018-11-21 14:53:34 +00001160// Runs dumpsys on services that must dump first and will take less than 100ms to dump.
Vishnu Nair780b1282017-10-10 13:57:24 -07001161static void RunDumpsysCritical() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001162 RunDumpsysText("DUMPSYS CRITICAL", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1163 /* timeout= */ 5s, /* service_timeout= */ 500ms);
1164 RunDumpsysProto("DUMPSYS CRITICAL PROTO", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1165 /* timeout= */ 5s, /* service_timeout= */ 500ms);
Vishnu Nair780b1282017-10-10 13:57:24 -07001166}
1167
1168// Runs dumpsys on services that must dump first but can take up to 250ms to dump.
1169static void RunDumpsysHigh() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001170 // TODO meminfo takes ~10s, connectivity takes ~5sec to dump. They are both
1171 // high priority. Reduce timeout once they are able to dump in a shorter time or
1172 // moved to a parallel task.
1173 RunDumpsysText("DUMPSYS HIGH", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1174 /* timeout= */ 90s, /* service_timeout= */ 30s);
1175 RunDumpsysProto("DUMPSYS HIGH PROTO", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1176 /* timeout= */ 5s, /* service_timeout= */ 1s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001177}
1178
1179// Runs dumpsys on services that must dump but can take up to 10s to dump.
1180static void RunDumpsysNormal() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001181 RunDumpsysTextNormalPriority("DUMPSYS", /* timeout= */ 90s, /* service_timeout= */ 10s);
1182 RunDumpsysProto("DUMPSYS PROTO", IServiceManager::DUMP_FLAG_PRIORITY_NORMAL,
1183 /* timeout= */ 90s, /* service_timeout= */ 10s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001184}
1185
Steven Moreland44cd9482018-01-04 16:24:13 -08001186static void DumpHals() {
Steven Moreland44cd9482018-01-04 16:24:13 -08001187 using android::hidl::manager::V1_0::IServiceManager;
1188 using android::hardware::defaultServiceManager;
1189
1190 sp<IServiceManager> sm = defaultServiceManager();
1191 if (sm == nullptr) {
1192 MYLOGE("Could not retrieve hwservicemanager to dump hals.\n");
1193 return;
1194 }
1195
1196 auto ret = sm->list([&](const auto& interfaces) {
1197 for (const std::string& interface : interfaces) {
1198 std::string cleanName = interface;
1199 std::replace_if(cleanName.begin(),
1200 cleanName.end(),
1201 [](char c) {
1202 return !isalnum(c) &&
1203 std::string("@-_:.").find(c) == std::string::npos;
1204 }, '_');
Nandana Dutt979388e2018-11-30 16:48:55 +00001205 const std::string path = ds.bugreport_internal_dir_ + "/lshal_debug_" + cleanName;
Steven Moreland44cd9482018-01-04 16:24:13 -08001206
1207 {
1208 auto fd = android::base::unique_fd(
1209 TEMP_FAILURE_RETRY(open(path.c_str(),
1210 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1211 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1212 if (fd < 0) {
1213 MYLOGE("Could not open %s to dump additional hal information.\n", path.c_str());
1214 continue;
1215 }
1216 RunCommandToFd(fd,
1217 "",
Steven Morelandc81cd3c2018-01-18 14:36:26 -08001218 {"lshal", "debug", "-E", interface},
Steven Moreland44cd9482018-01-04 16:24:13 -08001219 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
1220
1221 bool empty = 0 == lseek(fd, 0, SEEK_END);
1222 if (!empty) {
1223 ds.AddZipEntry("lshal-debug/" + cleanName + ".txt", path);
1224 }
1225 }
1226
1227 unlink(path.c_str());
1228 }
1229 });
1230
1231 if (!ret.isOk()) {
1232 MYLOGE("Could not list hals from hwservicemanager.\n");
1233 }
1234}
1235
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001236static void dumpstate() {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001237 DurationReporter duration_reporter("DUMPSTATE");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001238
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -07001239 dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001240 RunCommand("UPTIME", {"uptime"});
Wei Wang509bb5d2017-06-09 14:42:12 -07001241 DumpBlockStatFiles();
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001242 dump_emmc_ecsd("/d/mmc0/mmc0:0001/ext_csd");
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001243 DumpFile("MEMORY INFO", "/proc/meminfo");
1244 RunCommand("CPU INFO", {"top", "-b", "-n", "1", "-H", "-s", "6", "-o",
Felipe Leme30dbfa12016-09-02 12:43:26 -07001245 "pid,tid,user,pr,ni,%cpu,s,virt,res,pcy,cmd,name"});
Felipe Lemef0292972016-11-22 13:57:05 -08001246 RunCommand("PROCRANK", {"procrank"}, AS_ROOT_20);
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001247 DumpFile("VIRTUAL MEMORY STATS", "/proc/vmstat");
1248 DumpFile("VMALLOC INFO", "/proc/vmallocinfo");
1249 DumpFile("SLAB INFO", "/proc/slabinfo");
1250 DumpFile("ZONEINFO", "/proc/zoneinfo");
1251 DumpFile("PAGETYPEINFO", "/proc/pagetypeinfo");
1252 DumpFile("BUDDYINFO", "/proc/buddyinfo");
1253 DumpFile("FRAGMENTATION INFO", "/d/extfrag/unusable_index");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001254
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001255 DumpFile("KERNEL WAKE SOURCES", "/d/wakeup_sources");
1256 DumpFile("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
1257 DumpFile("KERNEL SYNC", "/d/sync");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001258
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001259 RunCommand("PROCESSES AND THREADS",
Yohei Yukawa591a72d2017-10-05 21:36:35 -07001260 {"ps", "-A", "-T", "-Z", "-O", "pri,nice,rtprio,sched,pcy,time"});
Felipe Lemef0292972016-11-22 13:57:05 -08001261 RunCommand("LIBRANK", {"librank"}, CommandOptions::AS_ROOT);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001262
Andreas Huber69ec3ac2017-03-23 09:47:51 -07001263 if (ds.IsZipping()) {
Yifan Hong90e8d8d2018-06-28 13:14:39 -07001264 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z"},
1265 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
Steven Moreland44cd9482018-01-04 16:24:13 -08001266 DumpHals();
Andreas Huber69ec3ac2017-03-23 09:47:51 -07001267 } else {
Yifan Hong90e8d8d2018-06-28 13:14:39 -07001268 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z", "--debug"},
1269 CommandOptions::WithTimeout(10).AsRootIfAvailable().Build());
Andreas Huber69ec3ac2017-03-23 09:47:51 -07001270 }
Steven Moreland81b429e2017-01-31 19:50:46 -08001271
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001272 RunCommand("PRINTENV", {"printenv"});
Elliott Hughes21b7c8d2016-10-28 08:53:02 -07001273 RunCommand("NETSTAT", {"netstat", "-nW"});
Felipe Lemee4eca582016-06-10 17:48:08 -07001274 struct stat s;
1275 if (stat("/proc/modules", &s) != 0) {
1276 MYLOGD("Skipping 'lsmod' because /proc/modules does not exist\n");
1277 } else {
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001278 RunCommand("LSMOD", {"lsmod"});
Felipe Lemee4eca582016-06-10 17:48:08 -07001279 }
Michal Karpinski4db754f2015-12-11 18:04:32 +00001280
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001281 if (__android_logger_property_get_bool(
1282 "ro.logd.kernel", BOOL_DEFAULT_TRUE | BOOL_DEFAULT_FLAG_ENG | BOOL_DEFAULT_FLAG_SVELTE)) {
1283 DoKernelLogcat();
1284 } else {
1285 do_dmesg();
1286 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001287
Felipe Lemef0292972016-11-22 13:57:05 -08001288 RunCommand("LIST OF OPEN FILES", {"lsof"}, CommandOptions::AS_ROOT);
Jeff Brown1dc94e32014-09-11 14:15:27 -07001289 for_each_pid(do_showmap, "SMAPS OF ALL PROCESSES");
1290 for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
Mark Salyzyna297c322016-02-05 15:33:17 -08001291 for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001292
Ajay Panicker2ff8e872017-04-27 14:04:32 -07001293 /* Dump Bluetooth HCI logs */
1294 ds.AddDir("/data/misc/bluetooth/logs", true);
Ajay Panickerd886ec42016-09-14 12:26:46 -07001295
Felipe Leme9a523ae2016-10-20 15:10:33 -07001296 if (!ds.do_early_screenshot_) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001297 MYLOGI("taking late screenshot\n");
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001298 ds.TakeScreenshot();
Jeff Sharkey5a930032013-03-19 15:05:19 -07001299 }
1300
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001301 DoLogcat();
Mark Salyzynecc07632015-07-30 14:57:09 -07001302
Felipe Lemee184f662016-10-27 10:04:47 -07001303 AddAnrTraceFiles();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001304
Narayan Kamath8f788292017-05-25 13:20:39 +01001305 // NOTE: tombstones are always added as separate entries in the zip archive
1306 // and are not interspersed with the main report.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001307 const bool tombstones_dumped = AddDumps(ds.tombstone_data_.begin(), ds.tombstone_data_.end(),
Narayan Kamathbd863722017-06-01 18:50:12 +01001308 "TOMBSTONE", true /* add_to_zip */);
Narayan Kamath8f788292017-05-25 13:20:39 +01001309 if (!tombstones_dumped) {
1310 printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR.c_str());
Christopher Ferris7dc7f322014-07-22 16:08:19 -07001311 }
1312
Jayachandran Ca94c7172017-06-10 15:08:12 -07001313 DumpPacketStats();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001314
Chenbo Feng276a3b62018-08-07 11:44:49 -07001315 RunDumpsys("EBPF MAP STATS", {"netd", "trafficcontroller"});
1316
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001317 DoKmsg();
Mark Salyzyn2262c162014-12-16 09:09:26 -08001318
Jayachandran Ca94c7172017-06-10 15:08:12 -07001319 DumpIpAddrAndRules();
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -07001320
1321 dump_route_tables();
1322
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001323 RunCommand("ARP CACHE", {"ip", "-4", "neigh", "show"});
1324 RunCommand("IPv6 ND CACHE", {"ip", "-6", "neigh", "show"});
1325 RunCommand("MULTICAST ADDRESSES", {"ip", "maddr"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001326
Vishnu Nair780b1282017-10-10 13:57:24 -07001327 RunDumpsysHigh();
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001328
Elliott Hughes23ccc622017-02-28 10:14:22 -08001329 RunCommand("SYSTEM PROPERTIES", {"getprop"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001330
Jin Qianf334d662017-10-10 14:41:37 -07001331 RunCommand("STORAGED IO INFO", {"storaged", "-u", "-p"});
ynwangf649a6e2016-07-17 21:56:00 -07001332
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001333 RunCommand("FILESYSTEMS & FREE SPACE", {"df"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001334
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001335 RunCommand("LAST RADIO LOG", {"parse_radio_log", "/proc/last_radio_log"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001336
Colin Crossf45fa6b2012-03-26 12:38:26 -07001337 /* Binder state is expensive to look at as it uses a lot of memory. */
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001338 DumpFile("BINDER FAILED TRANSACTION LOG", "/sys/kernel/debug/binder/failed_transaction_log");
1339 DumpFile("BINDER TRANSACTION LOG", "/sys/kernel/debug/binder/transaction_log");
1340 DumpFile("BINDER TRANSACTIONS", "/sys/kernel/debug/binder/transactions");
1341 DumpFile("BINDER STATS", "/sys/kernel/debug/binder/stats");
1342 DumpFile("BINDER STATE", "/sys/kernel/debug/binder/state");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001343
Nataniel Borgesbc73f522019-01-25 16:37:16 -08001344 RunDumpsys("WINSCOPE TRACE", {"window", "trace"});
Vishnu Nair36b4cdb2017-11-17 10:27:05 -08001345 /* Add window and surface trace files. */
1346 if (!PropertiesHelper::IsUserBuild()) {
1347 ds.AddDir(WMTRACE_DATA_DIR, false);
1348 }
1349
Felipe Leme6f674ae2016-11-18 17:10:33 -08001350 ds.DumpstateBoard();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001351
Steven Moreland7440ddb2016-12-15 16:13:39 -08001352 /* Migrate the ril_dumpstate to a device specific dumpstate? */
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001353 int rilDumpstateTimeout = android::base::GetIntProperty("ril.dumpstate.timeout", 0);
1354 if (rilDumpstateTimeout > 0) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001355 // su does not exist on user builds, so try running without it.
1356 // This way any implementations of vril-dump that do not require
1357 // root can run on user builds.
1358 CommandOptions::CommandOptionsBuilder options =
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001359 CommandOptions::WithTimeout(rilDumpstateTimeout);
Felipe Lemef0292972016-11-22 13:57:05 -08001360 if (!PropertiesHelper::IsUserBuild()) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001361 options.AsRoot();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001362 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001363 RunCommand("DUMP VENDOR RIL LOGS", {"vril-dump"}, options.Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001364 }
1365
Felipe Lemed8b94e52016-12-08 10:21:44 -08001366 printf("========================================================\n");
1367 printf("== Android Framework Services\n");
1368 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001369
Vishnu Nair780b1282017-10-10 13:57:24 -07001370 RunDumpsysNormal();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001371
Felipe Lemed8b94e52016-12-08 10:21:44 -08001372 printf("========================================================\n");
1373 printf("== Checkins\n");
1374 printf("========================================================\n");
Dianne Hackborn02bea972013-06-26 18:59:09 -07001375
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001376 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
1377 RunDumpsys("CHECKIN MEMINFO", {"meminfo", "--checkin"});
1378 RunDumpsys("CHECKIN NETSTATS", {"netstats", "--checkin"});
1379 RunDumpsys("CHECKIN PROCSTATS", {"procstats", "-c"});
1380 RunDumpsys("CHECKIN USAGESTATS", {"usagestats", "-c"});
1381 RunDumpsys("CHECKIN PACKAGE", {"package", "--checkin"});
Dianne Hackborn02bea972013-06-26 18:59:09 -07001382
Felipe Lemed8b94e52016-12-08 10:21:44 -08001383 printf("========================================================\n");
1384 printf("== Running Application Activities\n");
1385 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001386
Makoto Onuki60780982018-04-16 15:34:00 -07001387 // The following dumpsys internally collects output from running apps, so it can take a long
1388 // time. So let's extend the timeout.
1389
1390 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
1391
1392 RunDumpsys("APP ACTIVITIES", {"activity", "-v", "all"}, DUMPSYS_COMPONENTS_OPTIONS);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001393
Felipe Lemed8b94e52016-12-08 10:21:44 -08001394 printf("========================================================\n");
Makoto Onuki60780982018-04-16 15:34:00 -07001395 printf("== Running Application Services (platform)\n");
Felipe Lemed8b94e52016-12-08 10:21:44 -08001396 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001397
Vishnu Nairc6e6ea72018-07-02 14:20:06 -07001398 RunDumpsys("APP SERVICES PLATFORM", {"activity", "service", "all-platform-non-critical"},
Makoto Onuki60780982018-04-16 15:34:00 -07001399 DUMPSYS_COMPONENTS_OPTIONS);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001400
Felipe Lemed8b94e52016-12-08 10:21:44 -08001401 printf("========================================================\n");
Makoto Onuki60780982018-04-16 15:34:00 -07001402 printf("== Running Application Services (non-platform)\n");
Felipe Lemed8b94e52016-12-08 10:21:44 -08001403 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001404
Makoto Onuki60780982018-04-16 15:34:00 -07001405 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
1406 DUMPSYS_COMPONENTS_OPTIONS);
1407
1408 printf("========================================================\n");
1409 printf("== Running Application Providers (platform)\n");
1410 printf("========================================================\n");
1411
1412 RunDumpsys("APP PROVIDERS PLATFORM", {"activity", "provider", "all-platform"},
1413 DUMPSYS_COMPONENTS_OPTIONS);
1414
1415 printf("========================================================\n");
1416 printf("== Running Application Providers (non-platform)\n");
1417 printf("========================================================\n");
1418
1419 RunDumpsys("APP PROVIDERS NON-PLATFORM", {"activity", "provider", "all-non-platform"},
1420 DUMPSYS_COMPONENTS_OPTIONS);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001421
Adrian Roos8b397ab2017-04-04 16:35:44 -07001422 printf("========================================================\n");
1423 printf("== Dropbox crashes\n");
1424 printf("========================================================\n");
1425
1426 RunDumpsys("DROPBOX SYSTEM SERVER CRASHES", {"dropbox", "-p", "system_server_crash"});
1427 RunDumpsys("DROPBOX SYSTEM APP CRASHES", {"dropbox", "-p", "system_app_crash"});
1428
Felipe Lemed8b94e52016-12-08 10:21:44 -08001429 printf("========================================================\n");
1430 printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),
1431 ds.progress_->GetMax(), ds.progress_->GetInitialMax());
1432 printf("========================================================\n");
1433 printf("== dumpstate: done (id %d)\n", ds.id_);
1434 printf("========================================================\n");
Bookatz38472142018-09-28 10:20:24 -07001435
1436 printf("========================================================\n");
1437 printf("== Obtaining statsd metadata\n");
1438 printf("========================================================\n");
1439 // This differs from the usual dumpsys stats, which is the stats report data.
1440 RunDumpsys("STATSDSTATS", {"stats", "--metadata"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001441}
1442
Nandana Dutt4be45d12018-09-26 15:04:23 +01001443/* Dumps state for the default case. Returns true if everything went fine. */
1444static bool DumpstateDefault() {
Primiano Tucci2d7f5c22019-01-17 15:51:14 +00001445 // Try to dump anrd trace if the daemon is running.
1446 dump_anrd_trace();
Nandana Dutt4be45d12018-09-26 15:04:23 +01001447
1448 // Invoking the following dumpsys calls before dump_traces() to try and
1449 // keep the system stats as close to its initial state as possible.
1450 RunDumpsysCritical();
1451
1452 /* collect stack traces from Dalvik and native processes (needs root) */
1453 dump_traces_path = dump_traces();
1454
1455 /* Run some operations that require root. */
1456 ds.tombstone_data_ = GetDumpFds(TOMBSTONE_DIR, TOMBSTONE_FILE_PREFIX, !ds.IsZipping());
1457 ds.anr_data_ = GetDumpFds(ANR_DIR, ANR_FILE_PREFIX, !ds.IsZipping());
1458
1459 ds.AddDir(RECOVERY_DIR, true);
1460 ds.AddDir(RECOVERY_DATA_DIR, true);
1461 ds.AddDir(UPDATE_ENGINE_LOG_DIR, true);
1462 ds.AddDir(LOGPERSIST_DATA_DIR, false);
1463 if (!PropertiesHelper::IsUserBuild()) {
1464 ds.AddDir(PROFILE_DATA_DIR_CUR, true);
1465 ds.AddDir(PROFILE_DATA_DIR_REF, true);
1466 }
1467 add_mountinfo();
1468 DumpIpTablesAsRoot();
1469
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001470 // Capture any IPSec policies in play. No keys are exposed here.
Nandana Dutt4be45d12018-09-26 15:04:23 +01001471 RunCommand("IP XFRM POLICY", {"ip", "xfrm", "policy"}, CommandOptions::WithTimeout(10).Build());
1472
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001473 // Dump IPsec stats. No keys are exposed here.
1474 DumpFile("XFRM STATS", XFRM_STAT_PROC_FILE);
1475
Nandana Dutt4be45d12018-09-26 15:04:23 +01001476 // Run ss as root so we can see socket marks.
1477 RunCommand("DETAILED SOCKET STATE", {"ss", "-eionptu"}, CommandOptions::WithTimeout(10).Build());
1478
1479 // Run iotop as root to show top 100 IO threads
1480 RunCommand("IOTOP", {"iotop", "-n", "1", "-m", "100"});
1481
Erick Reyese68df822019-02-11 14:46:36 -08001482 // Gather shared memory buffer info if the product implements it
1483 struct stat st;
1484 if (!stat("/product/bin/dmabuf_dump", &st)) {
1485 RunCommand("Dmabuf dump", {"/product/bin/dmabuf_dump"});
1486 }
1487
Nandana Dutt4be45d12018-09-26 15:04:23 +01001488 if (!DropRootUser()) {
1489 return false;
1490 }
1491
1492 dumpstate();
1493 return true;
1494}
1495
mukesh agrawal253dad42018-01-23 21:59:59 -08001496// This method collects common dumpsys for telephony and wifi
1497static void DumpstateRadioCommon() {
Jayachandran Ca94c7172017-06-10 15:08:12 -07001498 DumpIpTablesAsRoot();
1499
1500 if (!DropRootUser()) {
1501 return;
1502 }
1503
1504 do_dmesg();
1505 DoLogcat();
1506 DumpPacketStats();
1507 DoKmsg();
1508 DumpIpAddrAndRules();
1509 dump_route_tables();
1510
1511 RunDumpsys("NETWORK DIAGNOSTICS", {"connectivity", "--diag"},
1512 CommandOptions::WithTimeout(10).Build());
mukesh agrawal253dad42018-01-23 21:59:59 -08001513}
1514
1515// This method collects dumpsys for telephony debugging only
1516static void DumpstateTelephonyOnly() {
1517 DurationReporter duration_reporter("DUMPSTATE");
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07001518 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
mukesh agrawal253dad42018-01-23 21:59:59 -08001519
1520 DumpstateRadioCommon();
Jayachandran Ca94c7172017-06-10 15:08:12 -07001521
1522 RunCommand("SYSTEM PROPERTIES", {"getprop"});
1523
1524 printf("========================================================\n");
1525 printf("== Android Framework Services\n");
1526 printf("========================================================\n");
1527
Vishnu Nair652cc802017-11-30 15:18:30 -08001528 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
1529 SEC_TO_MSEC(10));
1530 RunDumpsys("DUMPSYS", {"carrier_config"}, CommandOptions::WithTimeout(90).Build(),
1531 SEC_TO_MSEC(10));
Amruth Ramachandrand25a9142018-04-02 16:16:09 -07001532 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(),
1533 SEC_TO_MSEC(10));
Sooraj Sasindrane8d98912018-04-20 11:31:55 -07001534 RunDumpsys("BATTERYSTATS", {"batterystats"}, CommandOptions::WithTimeout(90).Build(),
1535 SEC_TO_MSEC(10));
Jayachandran Ca94c7172017-06-10 15:08:12 -07001536
1537 printf("========================================================\n");
1538 printf("== Running Application Services\n");
1539 printf("========================================================\n");
1540
1541 RunDumpsys("TELEPHONY SERVICES", {"activity", "service", "TelephonyDebugService"});
1542
1543 printf("========================================================\n");
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07001544 printf("== Running Application Services (non-platform)\n");
1545 printf("========================================================\n");
1546
1547 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
1548 DUMPSYS_COMPONENTS_OPTIONS);
1549
1550 printf("========================================================\n");
Kelly Rossmoyer769babb2018-08-21 18:06:38 -07001551 printf("== Checkins\n");
1552 printf("========================================================\n");
1553
1554 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
1555
1556 printf("========================================================\n");
Jayachandran Ca94c7172017-06-10 15:08:12 -07001557 printf("== dumpstate: done (id %d)\n", ds.id_);
1558 printf("========================================================\n");
1559}
1560
mukesh agrawal253dad42018-01-23 21:59:59 -08001561// This method collects dumpsys for wifi debugging only
1562static void DumpstateWifiOnly() {
1563 DurationReporter duration_reporter("DUMPSTATE");
1564
1565 DumpstateRadioCommon();
1566
1567 printf("========================================================\n");
1568 printf("== Android Framework Services\n");
1569 printf("========================================================\n");
1570
1571 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
1572 SEC_TO_MSEC(10));
1573 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(),
1574 SEC_TO_MSEC(10));
1575
Roger Wang70399032019-01-08 16:10:37 +08001576 if (ds.IsZipping()) {
1577 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z"},
1578 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
1579 DumpHals();
1580 } else {
1581 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z", "--debug"},
1582 CommandOptions::WithTimeout(10).AsRootIfAvailable().Build());
1583 }
1584
mukesh agrawal253dad42018-01-23 21:59:59 -08001585 printf("========================================================\n");
1586 printf("== dumpstate: done (id %d)\n", ds.id_);
1587 printf("========================================================\n");
1588}
1589
Felipe Leme6f674ae2016-11-18 17:10:33 -08001590void Dumpstate::DumpstateBoard() {
1591 DurationReporter duration_reporter("dumpstate_board()");
Felipe Lemed8b94e52016-12-08 10:21:44 -08001592 printf("========================================================\n");
1593 printf("== Board\n");
1594 printf("========================================================\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08001595
Felipe Leme6f674ae2016-11-18 17:10:33 -08001596 if (!IsZipping()) {
Steven Moreland7440ddb2016-12-15 16:13:39 -08001597 MYLOGD("Not dumping board info because it's not a zipped bugreport\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08001598 return;
1599 }
1600
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001601 std::vector<std::string> paths;
1602 std::vector<android::base::ScopeGuard<std::function<void()>>> remover;
Jie Song9fbfad02017-06-20 16:29:42 -07001603 for (int i = 0; i < NUM_OF_DUMPS; i++) {
Nandana Dutt979388e2018-11-30 16:48:55 +00001604 paths.emplace_back(StringPrintf("%s/%s", ds.bugreport_internal_dir_.c_str(),
1605 kDumpstateBoardFiles[i].c_str()));
Nandana Dutt16d1aee2019-02-15 16:13:53 +00001606 remover.emplace_back(android::base::make_scope_guard(
1607 std::bind([](std::string path) { android::os::UnlinkAndLogOnError(path); }, paths[i])));
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001608 }
Jie Song9fbfad02017-06-20 16:29:42 -07001609
Wei Wang587eac92018-04-05 12:17:20 -07001610 sp<IDumpstateDevice> dumpstate_device(IDumpstateDevice::getService());
1611 if (dumpstate_device == nullptr) {
1612 MYLOGE("No IDumpstateDevice implementation\n");
1613 return;
1614 }
1615
1616 using ScopedNativeHandle =
1617 std::unique_ptr<native_handle_t, std::function<void(native_handle_t*)>>;
1618 ScopedNativeHandle handle(native_handle_create(static_cast<int>(paths.size()), 0),
1619 [](native_handle_t* handle) {
1620 native_handle_close(handle);
1621 native_handle_delete(handle);
1622 });
1623 if (handle == nullptr) {
1624 MYLOGE("Could not create native_handle\n");
1625 return;
1626 }
1627
1628 for (size_t i = 0; i < paths.size(); i++) {
1629 MYLOGI("Calling IDumpstateDevice implementation using path %s\n", paths[i].c_str());
1630
1631 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
1632 open(paths[i].c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1633 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1634 if (fd < 0) {
1635 MYLOGE("Could not open file %s: %s\n", paths[i].c_str(), strerror(errno));
1636 return;
1637 }
1638 handle.get()->data[i] = fd.release();
1639 }
1640
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001641 // Given that bugreport is required to diagnose failures, it's better to
Wei Wang587eac92018-04-05 12:17:20 -07001642 // set an arbitrary amount of timeout for IDumpstateDevice than to block the
1643 // rest of bugreport. In the timeout case, we will kill dumpstate board HAL
1644 // and grab whatever dumped
1645 std::packaged_task<bool()>
1646 dumpstate_task([paths, dumpstate_device, &handle]() -> bool {
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001647 android::hardware::Return<void> status = dumpstate_device->dumpstateBoard(handle.get());
1648 if (!status.isOk()) {
1649 MYLOGE("dumpstateBoard failed: %s\n", status.description().c_str());
Wei Wang587eac92018-04-05 12:17:20 -07001650 return false;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001651 }
Wei Wang587eac92018-04-05 12:17:20 -07001652 return true;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001653 });
Wei Wang587eac92018-04-05 12:17:20 -07001654
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001655 auto result = dumpstate_task.get_future();
1656 std::thread(std::move(dumpstate_task)).detach();
Wei Wang587eac92018-04-05 12:17:20 -07001657
1658 constexpr size_t timeout_sec = 30;
1659 if (result.wait_for(std::chrono::seconds(timeout_sec)) != std::future_status::ready) {
1660 MYLOGE("dumpstateBoard timed out after %zus, killing dumpstate vendor HAL\n", timeout_sec);
1661 if (!android::base::SetProperty("ctl.interface_restart",
1662 android::base::StringPrintf("%s/default",
1663 IDumpstateDevice::descriptor))) {
1664 MYLOGE("Couldn't restart dumpstate HAL\n");
1665 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001666 }
Wei Wang587eac92018-04-05 12:17:20 -07001667 // Wait some time for init to kill dumpstate vendor HAL
1668 constexpr size_t killing_timeout_sec = 10;
1669 if (result.wait_for(std::chrono::seconds(killing_timeout_sec)) != std::future_status::ready) {
1670 MYLOGE("killing dumpstateBoard timed out after %zus, continue and "
1671 "there might be racing in content\n", killing_timeout_sec);
1672 }
1673
1674 auto file_sizes = std::make_unique<ssize_t[]>(paths.size());
1675 for (size_t i = 0; i < paths.size(); i++) {
1676 struct stat s;
1677 if (fstat(handle.get()->data[i], &s) == -1) {
1678 MYLOGE("Failed to fstat %s: %s\n", kDumpstateBoardFiles[i].c_str(),
1679 strerror(errno));
1680 file_sizes[i] = -1;
1681 continue;
1682 }
1683 file_sizes[i] = s.st_size;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001684 }
1685
1686 for (size_t i = 0; i < paths.size(); i++) {
1687 if (file_sizes[i] == -1) {
1688 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07001689 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001690 if (file_sizes[i] == 0) {
Jie Song9fbfad02017-06-20 16:29:42 -07001691 MYLOGE("Ignoring empty %s\n", kDumpstateBoardFiles[i].c_str());
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001692 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07001693 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001694 AddZipEntry(kDumpstateBoardFiles[i], paths[i]);
Jie Song9fbfad02017-06-20 16:29:42 -07001695 }
1696
Felipe Lemed8b94e52016-12-08 10:21:44 -08001697 printf("*** See dumpstate-board.txt entry ***\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08001698}
1699
Nandana Dutt12ae14a2019-01-09 10:35:53 +00001700static void ShowUsage() {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001701 fprintf(stderr,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001702 "usage: dumpstate [-h] [-b soundfile] [-e soundfile] [-o file] [-d] [-p] "
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001703 "[-z]] [-s] [-S] [-q] [-B] [-P] [-R] [-V version]\n"
1704 " -h: display this help message\n"
1705 " -b: play sound file instead of vibrate, at beginning of job\n"
1706 " -e: play sound file instead of vibrate, at end of job\n"
1707 " -o: write to file (instead of stdout)\n"
1708 " -d: append date to filename (requires -o)\n"
1709 " -p: capture screenshot to filename.png (requires -o)\n"
1710 " -z: generate zipped file (requires -o)\n"
1711 " -s: write output to control socket (for init)\n"
Takuya Ogawa47f644e2017-12-20 18:09:09 +09001712 " -S: write file location to control socket (for init; requires -o and -z)\n"
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001713 " -q: disable vibrate\n"
1714 " -B: send broadcast when finished (requires -o)\n"
1715 " -P: send broadcast when started and update system properties on "
1716 "progress (requires -o and -B)\n"
1717 " -R: take bugreport in remote mode (requires -o, -z, -d and -B, "
1718 "shouldn't be used with -P)\n"
Nandana Dutt235864b2019-01-22 12:10:16 +00001719 " -w: start binder service and make it wait for a call to startBugreport\n"
Felipe Lemed071c682016-10-20 16:48:00 -07001720 " -v: prints the dumpstate header and exit\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001721}
1722
Wei Liuf87959e2016-08-26 14:51:42 -07001723static void register_sig_handler() {
Luis Hector Chavez558e1ef2018-03-22 15:39:17 -07001724 signal(SIGPIPE, SIG_IGN);
Wei Liuf87959e2016-08-26 14:51:42 -07001725}
1726
Felipe Leme1d486fe2016-10-14 18:06:47 -07001727bool Dumpstate::FinishZipFile() {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001728 std::string entry_name = base_name_ + "-" + name_ + ".txt";
Felipe Leme1d486fe2016-10-14 18:06:47 -07001729 MYLOGD("Adding main entry (%s) from %s to .zip bugreport\n", entry_name.c_str(),
Felipe Leme9a523ae2016-10-20 15:10:33 -07001730 tmp_path_.c_str());
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07001731 // Final timestamp
1732 char date[80];
1733 time_t the_real_now_please_stand_up = time(nullptr);
1734 strftime(date, sizeof(date), "%Y/%m/%d %H:%M:%S", localtime(&the_real_now_please_stand_up));
Felipe Leme7447d7c2016-11-03 18:12:22 -07001735 MYLOGD("dumpstate id %d finished around %s (%ld s)\n", ds.id_, date,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001736 the_real_now_please_stand_up - ds.now_);
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07001737
Felipe Leme9a523ae2016-10-20 15:10:33 -07001738 if (!ds.AddZipEntry(entry_name, tmp_path_)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001739 MYLOGE("Failed to add text entry to .zip file\n");
Felipe Leme1e9edc62015-12-21 16:02:13 -08001740 return false;
1741 }
Felipe Leme1d486fe2016-10-14 18:06:47 -07001742 if (!AddTextZipEntry("main_entry.txt", entry_name)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001743 MYLOGE("Failed to add main_entry.txt to .zip file\n");
Felipe Leme111b9d02016-02-03 09:28:24 -08001744 return false;
Felipe Leme809d74e2016-02-02 12:57:00 -08001745 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08001746
Felipe Leme0f3fb202016-06-10 17:10:53 -07001747 // Add log file (which contains stderr output) to zip...
1748 fprintf(stderr, "dumpstate_log.txt entry on zip file logged up to here\n");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001749 if (!ds.AddZipEntry("dumpstate_log.txt", ds.log_path_.c_str())) {
Felipe Leme0f3fb202016-06-10 17:10:53 -07001750 MYLOGE("Failed to add dumpstate log to .zip file\n");
1751 return false;
1752 }
Nandana Dutt979388e2018-11-30 16:48:55 +00001753 // TODO: Should truncate the existing file.
1754 // ... and re-open it for further logging.
Nandana Dutta344cb62019-02-22 15:12:35 +00001755 if (!redirect_to_existing_file(stderr, const_cast<char*>(ds.log_path_.c_str()))) {
1756 return false;
1757 }
Felipe Leme0f3fb202016-06-10 17:10:53 -07001758 fprintf(stderr, "\n");
1759
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07001760 int32_t err = zip_writer_->Finish();
Felipe Leme1d486fe2016-10-14 18:06:47 -07001761 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07001762 MYLOGE("zip_writer_->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001763 return false;
1764 }
1765
Felipe Leme1d486fe2016-10-14 18:06:47 -07001766 // TODO: remove once FinishZipFile() is automatically handled by Dumpstate's destructor.
1767 ds.zip_file.reset(nullptr);
1768
Felipe Lemee9d2c542016-11-15 11:48:26 -08001769 MYLOGD("Removing temporary file %s\n", tmp_path_.c_str())
Nandana Dutt16d1aee2019-02-15 16:13:53 +00001770 android::os::UnlinkAndLogOnError(tmp_path_);
Felipe Lemec4eee562016-04-21 15:42:55 -07001771
Felipe Leme1e9edc62015-12-21 16:02:13 -08001772 return true;
1773}
Felipe Leme6e01fa62015-11-11 19:35:14 -08001774
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07001775static std::string SHA256_file_hash(const std::string& filepath) {
Andreas Gampe27cd7b22016-07-18 18:24:05 -07001776 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK
1777 | O_CLOEXEC | O_NOFOLLOW)));
Andreas Gampeaff68432016-07-18 18:01:27 -07001778 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001779 MYLOGE("open(%s): %s\n", filepath.c_str(), strerror(errno));
Yi Kong19d5c002018-07-20 13:39:55 -07001780 return nullptr;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001781 }
1782
1783 SHA256_CTX ctx;
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001784 SHA256_Init(&ctx);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001785
1786 std::vector<uint8_t> buffer(65536);
1787 while (1) {
1788 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd.get(), buffer.data(), buffer.size()));
1789 if (bytes_read == 0) {
1790 break;
1791 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001792 MYLOGE("read(%s): %s\n", filepath.c_str(), strerror(errno));
Yi Kong19d5c002018-07-20 13:39:55 -07001793 return nullptr;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001794 }
1795
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001796 SHA256_Update(&ctx, buffer.data(), bytes_read);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001797 }
1798
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001799 uint8_t hash[SHA256_DIGEST_LENGTH];
1800 SHA256_Final(hash, &ctx);
1801
1802 char hash_buffer[SHA256_DIGEST_LENGTH * 2 + 1];
1803 for(size_t i = 0; i < SHA256_DIGEST_LENGTH; i++) {
Michal Karpinskicbbdf732016-01-07 20:45:02 +00001804 sprintf(hash_buffer + (i * 2), "%02x", hash[i]);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001805 }
1806 hash_buffer[sizeof(hash_buffer) - 1] = 0;
1807 return std::string(hash_buffer);
1808}
1809
Felipe Lemea4ef1f02017-02-15 17:27:40 -08001810static void SendBroadcast(const std::string& action, const std::vector<std::string>& args) {
1811 // clang-format off
1812 std::vector<std::string> am = {"/system/bin/cmd", "activity", "broadcast", "--user", "0",
1813 "--receiver-foreground", "--receiver-include-background", "-a", action};
1814 // clang-format on
Felipe Leme8d2410e2017-02-08 09:46:08 -08001815
1816 am.insert(am.end(), args.begin(), args.end());
1817
Felipe Leme8d2410e2017-02-08 09:46:08 -08001818 RunCommand("", am,
1819 CommandOptions::WithTimeout(20)
1820 .Log("Sending broadcast: '%s'\n")
1821 .Always()
1822 .DropRoot()
1823 .RedirectStderr()
1824 .Build());
1825}
1826
Felipe Leme35b8cf12017-02-10 15:47:29 -08001827static void Vibrate(int duration_ms) {
1828 // clang-format off
1829 RunCommand("", {"cmd", "vibrator", "vibrate", std::to_string(duration_ms), "dumpstate"},
1830 CommandOptions::WithTimeout(10)
1831 .Log("Vibrate: '%s'\n")
1832 .Always()
1833 .Build());
1834 // clang-format on
1835}
1836
Nandana Dutt979388e2018-11-30 16:48:55 +00001837static void MaybeResolveSymlink(std::string* path) {
1838 std::string resolved_path;
1839 if (android::base::Readlink(*path, &resolved_path)) {
1840 *path = resolved_path;
1841 }
1842}
1843
Nandana Dutt4be45d12018-09-26 15:04:23 +01001844/*
1845 * Prepares state like filename, screenshot path, etc in Dumpstate. Also initializes ZipWriter
1846 * if we are writing zip files and adds the version file.
1847 */
1848static void PrepareToWriteToFile() {
Nandana Dutt979388e2018-11-30 16:48:55 +00001849 MaybeResolveSymlink(&ds.bugreport_internal_dir_);
1850
Nandana Dutt4be45d12018-09-26 15:04:23 +01001851 std::string build_id = android::base::GetProperty("ro.build.id", "UNKNOWN_BUILD");
1852 std::string device_name = android::base::GetProperty("ro.product.name", "UNKNOWN_DEVICE");
Nandana Dutt9a76d202019-01-21 15:56:48 +00001853 ds.base_name_ = StringPrintf("bugreport-%s-%s", device_name.c_str(), build_id.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001854 if (ds.options_->do_add_date) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001855 char date[80];
1856 strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&ds.now_));
1857 ds.name_ = date;
1858 } else {
1859 ds.name_ = "undated";
1860 }
1861
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001862 if (ds.options_->telephony_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001863 ds.base_name_ += "-telephony";
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001864 } else if (ds.options_->wifi_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001865 ds.base_name_ += "-wifi";
1866 }
1867
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001868 if (ds.options_->do_fb) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001869 ds.screenshot_path_ = ds.GetPath(".png");
1870 }
1871 ds.tmp_path_ = ds.GetPath(".tmp");
1872 ds.log_path_ = ds.GetPath("-dumpstate_log-" + std::to_string(ds.pid_) + ".txt");
1873
Nandana Dutt54dbd672019-01-11 12:58:05 +00001874 std::string destination = ds.options_->bugreport_fd.get() != -1
1875 ? StringPrintf("[fd:%d]", ds.options_->bugreport_fd.get())
Nandana Dutt9a76d202019-01-21 15:56:48 +00001876 : ds.bugreport_internal_dir_.c_str();
Nandana Dutt4be45d12018-09-26 15:04:23 +01001877 MYLOGD(
1878 "Bugreport dir: %s\n"
1879 "Base name: %s\n"
1880 "Suffix: %s\n"
1881 "Log path: %s\n"
1882 "Temporary path: %s\n"
1883 "Screenshot path: %s\n",
Nandana Dutt9a76d202019-01-21 15:56:48 +00001884 destination.c_str(), ds.base_name_.c_str(), ds.name_.c_str(), ds.log_path_.c_str(),
1885 ds.tmp_path_.c_str(), ds.screenshot_path_.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01001886
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001887 if (ds.options_->do_zip_file) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001888 ds.path_ = ds.GetPath(".zip");
1889 MYLOGD("Creating initial .zip file (%s)\n", ds.path_.c_str());
1890 create_parent_dirs(ds.path_.c_str());
1891 ds.zip_file.reset(fopen(ds.path_.c_str(), "wb"));
1892 if (ds.zip_file == nullptr) {
1893 MYLOGE("fopen(%s, 'wb'): %s\n", ds.path_.c_str(), strerror(errno));
1894 } else {
1895 ds.zip_writer_.reset(new ZipWriter(ds.zip_file.get()));
1896 }
1897 ds.AddTextZipEntry("version.txt", ds.version_);
1898 }
1899}
1900
1901/*
1902 * Finalizes writing to the file by renaming or zipping the tmp file to the final location,
1903 * printing zipped file status, etc.
1904 */
1905static void FinalizeFile() {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001906 /* check if user changed the suffix using system properties */
1907 std::string name =
1908 android::base::GetProperty(android::base::StringPrintf("dumpstate.%d.name", ds.pid_), "");
1909 bool change_suffix = false;
1910 if (!name.empty()) {
1911 /* must whitelist which characters are allowed, otherwise it could cross directories */
1912 std::regex valid_regex("^[-_a-zA-Z0-9]+$");
1913 if (std::regex_match(name.c_str(), valid_regex)) {
1914 change_suffix = true;
1915 } else {
1916 MYLOGE("invalid suffix provided by user: %s\n", name.c_str());
1917 }
1918 }
1919 if (change_suffix) {
1920 MYLOGI("changing suffix from %s to %s\n", ds.name_.c_str(), name.c_str());
1921 ds.name_ = name;
1922 if (!ds.screenshot_path_.empty()) {
1923 std::string new_screenshot_path = ds.GetPath(".png");
1924 if (rename(ds.screenshot_path_.c_str(), new_screenshot_path.c_str())) {
1925 MYLOGE("rename(%s, %s): %s\n", ds.screenshot_path_.c_str(),
1926 new_screenshot_path.c_str(), strerror(errno));
1927 } else {
1928 ds.screenshot_path_ = new_screenshot_path;
1929 }
1930 }
1931 }
1932
1933 bool do_text_file = true;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001934 if (ds.options_->do_zip_file) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001935 if (!ds.FinishZipFile()) {
1936 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
1937 do_text_file = true;
1938 } else {
1939 do_text_file = false;
Nandana Dutt383d0c12018-11-30 15:54:56 +00001940 // If the user has changed the suffix, we need to change the zip file name.
1941 std::string new_path = ds.GetPath(".zip");
1942 if (ds.path_ != new_path) {
1943 MYLOGD("Renaming zip file from %s to %s\n", ds.path_.c_str(), new_path.c_str());
1944 if (rename(ds.path_.c_str(), new_path.c_str())) {
1945 MYLOGE("rename(%s, %s): %s\n", ds.path_.c_str(), new_path.c_str(),
1946 strerror(errno));
1947 } else {
1948 ds.path_ = new_path;
1949 }
1950 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001951 }
1952 }
1953 if (do_text_file) {
1954 ds.path_ = ds.GetPath(".txt");
1955 MYLOGD("Generating .txt bugreport at %s from %s\n", ds.path_.c_str(), ds.tmp_path_.c_str());
1956 if (rename(ds.tmp_path_.c_str(), ds.path_.c_str())) {
1957 MYLOGE("rename(%s, %s): %s\n", ds.tmp_path_.c_str(), ds.path_.c_str(), strerror(errno));
1958 ds.path_.clear();
1959 }
1960 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001961 if (ds.options_->use_control_socket) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001962 if (do_text_file) {
1963 dprintf(ds.control_socket_fd_,
1964 "FAIL:could not create zip file, check %s "
1965 "for more details\n",
1966 ds.log_path_.c_str());
1967 } else {
1968 dprintf(ds.control_socket_fd_, "OK:%s\n", ds.path_.c_str());
1969 }
1970 }
1971}
1972
1973/* Broadcasts that we are done with the bugreport */
1974static void SendBugreportFinishedBroadcast() {
Nandana Dutt979388e2018-11-30 16:48:55 +00001975 // TODO(b/111441001): use callback instead of broadcast.
Nandana Dutt9a76d202019-01-21 15:56:48 +00001976 if (!ds.path_.empty()) {
1977 MYLOGI("Final bugreport path: %s\n", ds.path_.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01001978 // clang-format off
1979
1980 std::vector<std::string> am_args = {
1981 "--receiver-permission", "android.permission.DUMP",
1982 "--ei", "android.intent.extra.ID", std::to_string(ds.id_),
1983 "--ei", "android.intent.extra.PID", std::to_string(ds.pid_),
1984 "--ei", "android.intent.extra.MAX", std::to_string(ds.progress_->GetMax()),
Nandana Dutt9a76d202019-01-21 15:56:48 +00001985 "--es", "android.intent.extra.BUGREPORT", ds.path_,
Nandana Dutt4be45d12018-09-26 15:04:23 +01001986 "--es", "android.intent.extra.DUMPSTATE_LOG", ds.log_path_
1987 };
1988 // clang-format on
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001989 if (ds.options_->do_fb) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001990 am_args.push_back("--es");
1991 am_args.push_back("android.intent.extra.SCREENSHOT");
1992 am_args.push_back(ds.screenshot_path_);
1993 }
Nandana Dutt15b89d72018-11-16 14:14:12 +00001994 if (!ds.options_->notification_title.empty()) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001995 am_args.push_back("--es");
1996 am_args.push_back("android.intent.extra.TITLE");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001997 am_args.push_back(ds.options_->notification_title);
1998 if (!ds.options_->notification_description.empty()) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001999 am_args.push_back("--es");
2000 am_args.push_back("android.intent.extra.DESCRIPTION");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002001 am_args.push_back(ds.options_->notification_description);
Nandana Dutt4be45d12018-09-26 15:04:23 +01002002 }
2003 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002004 if (ds.options_->is_remote_mode) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002005 am_args.push_back("--es");
2006 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
Nandana Dutt9a76d202019-01-21 15:56:48 +00002007 am_args.push_back(SHA256_file_hash(ds.path_));
Nandana Dutt4be45d12018-09-26 15:04:23 +01002008 SendBroadcast("com.android.internal.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
2009 } else {
2010 SendBroadcast("com.android.internal.intent.action.BUGREPORT_FINISHED", am_args);
2011 }
2012 } else {
2013 MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
2014 }
2015}
2016
Nandana Dutt58d72e22018-11-16 10:30:48 +00002017static inline const char* ModeToString(Dumpstate::BugreportMode mode) {
2018 switch (mode) {
2019 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2020 return "BUGREPORT_FULL";
2021 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
2022 return "BUGREPORT_INTERACTIVE";
2023 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
2024 return "BUGREPORT_REMOTE";
2025 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
2026 return "BUGREPORT_WEAR";
2027 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
2028 return "BUGREPORT_TELEPHONY";
2029 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
2030 return "BUGREPORT_WIFI";
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002031 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2032 return "BUGREPORT_DEFAULT";
Nandana Dutt58d72e22018-11-16 10:30:48 +00002033 }
2034}
2035
2036static void SetOptionsFromMode(Dumpstate::BugreportMode mode, Dumpstate::DumpOptions* options) {
Abhijeet Kaur8ca245e2018-12-12 10:34:21 +00002037 options->extra_options = ModeToString(mode);
Nandana Dutt58d72e22018-11-16 10:30:48 +00002038 switch (mode) {
2039 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2040 options->do_broadcast = true;
2041 options->do_fb = true;
2042 break;
2043 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002044 // Currently, the dumpstate binder is only used by Shell to update progress.
2045 options->do_start_service = true;
2046 options->do_progress_updates = true;
2047 options->do_fb = false;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002048 options->do_broadcast = true;
2049 break;
2050 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002051 options->do_vibrate = false;
2052 options->is_remote_mode = true;
2053 options->do_fb = false;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002054 options->do_broadcast = true;
2055 break;
2056 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002057 options->do_start_service = true;
2058 options->do_progress_updates = true;
2059 options->do_zip_file = true;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002060 options->do_fb = true;
2061 options->do_broadcast = true;
2062 break;
2063 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002064 options->telephony_only = true;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002065 options->do_fb = true;
2066 options->do_broadcast = true;
2067 break;
2068 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002069 options->wifi_only = true;
2070 options->do_zip_file = true;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002071 options->do_fb = true;
2072 options->do_broadcast = true;
2073 break;
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002074 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2075 break;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002076 }
2077}
2078
2079static Dumpstate::BugreportMode getBugreportModeFromProperty() {
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002080 // If the system property is not set, it's assumed to be a default bugreport.
2081 Dumpstate::BugreportMode mode = Dumpstate::BugreportMode::BUGREPORT_DEFAULT;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002082
2083 std::string extra_options = android::base::GetProperty(PROPERTY_EXTRA_OPTIONS, "");
2084 if (!extra_options.empty()) {
2085 // Framework uses a system property to override some command-line args.
2086 // Currently, it contains the type of the requested bugreport.
2087 if (extra_options == "bugreportplus") {
2088 mode = Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE;
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002089 } else if (extra_options == "bugreportfull") {
2090 mode = Dumpstate::BugreportMode::BUGREPORT_FULL;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002091 } else if (extra_options == "bugreportremote") {
2092 mode = Dumpstate::BugreportMode::BUGREPORT_REMOTE;
2093 } else if (extra_options == "bugreportwear") {
2094 mode = Dumpstate::BugreportMode::BUGREPORT_WEAR;
2095 } else if (extra_options == "bugreporttelephony") {
2096 mode = Dumpstate::BugreportMode::BUGREPORT_TELEPHONY;
2097 } else if (extra_options == "bugreportwifi") {
2098 mode = Dumpstate::BugreportMode::BUGREPORT_WIFI;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002099 } else {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002100 MYLOGE("Unknown extra option: %s\n", extra_options.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002101 }
2102 // Reset the property
2103 android::base::SetProperty(PROPERTY_EXTRA_OPTIONS, "");
2104 }
Nandana Dutt58d72e22018-11-16 10:30:48 +00002105 return mode;
2106}
2107
2108// TODO: Move away from system properties when we have options passed via binder calls.
2109/* Sets runtime options from the system properties and then clears those properties. */
2110static void SetOptionsFromProperties(Dumpstate::DumpOptions* options) {
2111 Dumpstate::BugreportMode mode = getBugreportModeFromProperty();
2112 SetOptionsFromMode(mode, options);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002113
2114 options->notification_title = android::base::GetProperty(PROPERTY_EXTRA_TITLE, "");
2115 if (!options->notification_title.empty()) {
2116 // Reset the property
2117 android::base::SetProperty(PROPERTY_EXTRA_TITLE, "");
2118
Nandana Duttdd8cca32018-11-14 10:10:29 +00002119 options->notification_description =
2120 android::base::GetProperty(PROPERTY_EXTRA_DESCRIPTION, "");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002121 if (!options->notification_description.empty()) {
2122 // Reset the property
2123 android::base::SetProperty(PROPERTY_EXTRA_DESCRIPTION, "");
2124 }
2125 MYLOGD("notification (title: %s, description: %s)\n", options->notification_title.c_str(),
2126 options->notification_description.c_str());
2127 }
2128}
2129
Nandana Dutt58d72e22018-11-16 10:30:48 +00002130static void LogDumpOptions(const Dumpstate::DumpOptions& options) {
2131 MYLOGI("do_zip_file: %d\n", options.do_zip_file);
2132 MYLOGI("do_add_date: %d\n", options.do_add_date);
2133 MYLOGI("do_vibrate: %d\n", options.do_vibrate);
2134 MYLOGI("use_socket: %d\n", options.use_socket);
2135 MYLOGI("use_control_socket: %d\n", options.use_control_socket);
2136 MYLOGI("do_fb: %d\n", options.do_fb);
2137 MYLOGI("do_broadcast: %d\n", options.do_broadcast);
2138 MYLOGI("is_remote_mode: %d\n", options.is_remote_mode);
2139 MYLOGI("show_header_only: %d\n", options.show_header_only);
2140 MYLOGI("do_start_service: %d\n", options.do_start_service);
2141 MYLOGI("telephony_only: %d\n", options.telephony_only);
2142 MYLOGI("wifi_only: %d\n", options.wifi_only);
2143 MYLOGI("do_progress_updates: %d\n", options.do_progress_updates);
Nandana Dutt54dbd672019-01-11 12:58:05 +00002144 MYLOGI("fd: %d\n", options.bugreport_fd.get());
Nandana Dutt58d72e22018-11-16 10:30:48 +00002145 MYLOGI("extra_options: %s\n", options.extra_options.c_str());
2146 MYLOGI("args: %s\n", options.args.c_str());
2147 MYLOGI("notification_title: %s\n", options.notification_title.c_str());
2148 MYLOGI("notification_description: %s\n", options.notification_description.c_str());
2149}
2150
Nandana Dutt54dbd672019-01-11 12:58:05 +00002151void Dumpstate::DumpOptions::Initialize(BugreportMode bugreport_mode,
2152 const android::base::unique_fd& bugreport_fd_in,
2153 const android::base::unique_fd& screenshot_fd_in) {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002154 // In the new API world, date is always added; output is always a zip file.
2155 // TODO(111441001): remove these options once they are obsolete.
2156 do_add_date = true;
2157 do_zip_file = true;
2158
Nandana Dutt54dbd672019-01-11 12:58:05 +00002159 // Duplicate the fds because the passed in fds don't outlive the binder transaction.
2160 bugreport_fd.reset(dup(bugreport_fd_in.get()));
2161 screenshot_fd.reset(dup(screenshot_fd_in.get()));
Nandana Dutt58d72e22018-11-16 10:30:48 +00002162
2163 extra_options = ModeToString(bugreport_mode);
2164 SetOptionsFromMode(bugreport_mode, this);
2165}
2166
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002167Dumpstate::RunStatus Dumpstate::DumpOptions::Initialize(int argc, char* argv[]) {
2168 RunStatus status = RunStatus::OK;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002169 int c;
Nandana Dutt235864b2019-01-22 12:10:16 +00002170 while ((c = getopt(argc, argv, "dho:svqzpPBRSV:w")) != -1) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002171 switch (c) {
2172 // clang-format off
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002173 case 'd': do_add_date = true; break;
2174 case 'z': do_zip_file = true; break;
Nandana Dutt9a76d202019-01-21 15:56:48 +00002175 // o=use_outfile not supported anymore.
2176 // TODO(b/111441001): Remove when all callers have migrated.
2177 case 'o': break;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002178 case 's': use_socket = true; break;
2179 case 'S': use_control_socket = true; break;
2180 case 'v': show_header_only = true; break;
2181 case 'q': do_vibrate = false; break;
2182 case 'p': do_fb = true; break;
2183 case 'P': do_progress_updates = true; break;
2184 case 'R': is_remote_mode = true; break;
2185 case 'B': do_broadcast = true; break;
2186 case 'V': break; // compatibility no-op
Nandana Dutt235864b2019-01-22 12:10:16 +00002187 case 'w':
2188 // This was already processed
2189 break;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002190 case 'h':
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002191 status = RunStatus::HELP;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002192 break;
2193 default:
2194 fprintf(stderr, "Invalid option: %c\n", c);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002195 status = RunStatus::INVALID_INPUT;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002196 break;
2197 // clang-format on
2198 }
2199 }
Felipe Leme8fecfdd2016-02-09 10:40:07 -08002200
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002201 // TODO: use helper function to convert argv into a string
2202 for (int i = 0; i < argc; i++) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002203 args += argv[i];
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002204 if (i < argc - 1) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002205 args += " ";
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002206 }
2207 }
2208
2209 // Reset next index used by getopt so this can be called multiple times, for eg, in tests.
2210 optind = 1;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002211
2212 SetOptionsFromProperties(this);
2213 return status;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002214}
2215
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002216bool Dumpstate::DumpOptions::ValidateOptions() const {
Nandana Dutt54dbd672019-01-11 12:58:05 +00002217 if (bugreport_fd.get() != -1 && !do_zip_file) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002218 return false;
2219 }
2220
Nandana Dutt9a76d202019-01-21 15:56:48 +00002221 if ((do_zip_file || do_add_date || do_progress_updates || do_broadcast) && !OutputToFile()) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002222 return false;
2223 }
2224
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002225 if (use_control_socket && !do_zip_file) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002226 return false;
2227 }
2228
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002229 if (do_progress_updates && !do_broadcast) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002230 return false;
2231 }
2232
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002233 if (is_remote_mode && (do_progress_updates || !do_broadcast || !do_zip_file || !do_add_date)) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002234 return false;
2235 }
2236 return true;
2237}
2238
Nandana Dutt197661d2018-11-16 16:40:21 +00002239void Dumpstate::SetOptions(std::unique_ptr<DumpOptions> options) {
2240 options_ = std::move(options);
2241}
2242
Nandana Duttd2f5f082019-01-18 17:13:52 +00002243Dumpstate::RunStatus Dumpstate::Run(int32_t calling_uid, const std::string& calling_package) {
2244 Dumpstate::RunStatus status = RunInternal(calling_uid, calling_package);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002245 if (listener_ != nullptr) {
2246 switch (status) {
2247 case Dumpstate::RunStatus::OK:
Nandana Duttcc4ead82019-01-23 08:29:23 +00002248 listener_->onFinished();
Nandana Duttbabf6c72019-01-15 14:11:12 +00002249 break;
2250 case Dumpstate::RunStatus::HELP:
2251 break;
2252 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002253 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_INVALID_INPUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002254 break;
2255 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002256 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_RUNTIME_ERROR);
2257 break;
2258 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
2259 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_DENIED_CONSENT);
2260 break;
2261 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
2262 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_CONSENT_TIMED_OUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002263 break;
2264 }
2265 }
2266 return status;
2267}
2268
Nandana Dutt979388e2018-11-30 16:48:55 +00002269/*
2270 * Dumps relevant information to a bugreport based on the given options.
2271 *
2272 * The bugreport can be dumped to a file or streamed to a socket.
2273 *
2274 * How dumping to file works:
2275 * stdout is redirected to a temporary file. This will later become the main bugreport entry.
2276 * stderr is redirected a log file.
2277 *
2278 * The temporary bugreport is then populated via printfs, dumping contents of files and
2279 * output of commands to stdout.
2280 *
2281 * If zipping, the temporary bugreport file is added to the zip archive. Else it's renamed to final
2282 * text file.
2283 *
2284 * If zipping, a bunch of other files and dumps also get added to the zip archive. The log file also
2285 * gets added to the archive.
2286 *
Nandana Dutt9a76d202019-01-21 15:56:48 +00002287 * Bugreports are first generated in a local directory and later copied to the caller's fd if
2288 * supplied.
Nandana Dutt979388e2018-11-30 16:48:55 +00002289 */
Nandana Duttd2f5f082019-01-18 17:13:52 +00002290Dumpstate::RunStatus Dumpstate::RunInternal(int32_t calling_uid,
2291 const std::string& calling_package) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002292 LogDumpOptions(*options_);
Nandana Dutt197661d2018-11-16 16:40:21 +00002293 if (!options_->ValidateOptions()) {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002294 MYLOGE("Invalid options specified\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002295 return RunStatus::INVALID_INPUT;
2296 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002297 /* set as high priority, and protect from OOM killer */
2298 setpriority(PRIO_PROCESS, 0, -20);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002299
Felipe Lemed071c682016-10-20 16:48:00 -07002300 FILE* oom_adj = fopen("/proc/self/oom_score_adj", "we");
Colin Crossf45fa6b2012-03-26 12:38:26 -07002301 if (oom_adj) {
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002302 fputs("-1000", oom_adj);
Colin Crossf45fa6b2012-03-26 12:38:26 -07002303 fclose(oom_adj);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002304 } else {
2305 /* fallback to kernels <= 2.6.35 */
2306 oom_adj = fopen("/proc/self/oom_adj", "we");
2307 if (oom_adj) {
2308 fputs("-17", oom_adj);
2309 fclose(oom_adj);
2310 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002311 }
2312
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002313 if (version_ == VERSION_DEFAULT) {
2314 version_ = VERSION_CURRENT;
Michal Karpinski4db754f2015-12-11 18:04:32 +00002315 }
2316
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002317 if (version_ != VERSION_CURRENT && version_ != VERSION_SPLIT_ANR) {
Vishnu Nair64afc022018-02-01 15:29:34 -08002318 MYLOGE("invalid version requested ('%s'); suppported values are: ('%s', '%s', '%s')\n",
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002319 version_.c_str(), VERSION_DEFAULT.c_str(), VERSION_CURRENT.c_str(),
Vishnu Nair64afc022018-02-01 15:29:34 -08002320 VERSION_SPLIT_ANR.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002321 return RunStatus::INVALID_INPUT;
Felipe Lemed071c682016-10-20 16:48:00 -07002322 }
2323
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002324 if (options_->show_header_only) {
2325 PrintHeader();
2326 return RunStatus::OK;
Felipe Lemed071c682016-10-20 16:48:00 -07002327 }
2328
Nandana Duttd2f5f082019-01-18 17:13:52 +00002329 if (options_->bugreport_fd.get() != -1) {
2330 // If the output needs to be copied over to the caller's fd, get user consent.
2331 android::String16 package(calling_package.c_str());
2332 CheckUserConsent(calling_uid, package);
2333 }
2334
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002335 // Redirect output if needed
Nandana Dutt9a76d202019-01-21 15:56:48 +00002336 bool is_redirecting = options_->OutputToFile();
Felipe Leme7447d7c2016-11-03 18:12:22 -07002337
2338 // TODO: temporarily set progress until it's part of the Dumpstate constructor
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002339 std::string stats_path =
Nandana Dutt979388e2018-11-30 16:48:55 +00002340 is_redirecting
2341 ? android::base::StringPrintf("%s/dumpstate-stats.txt", bugreport_internal_dir_.c_str())
2342 : "";
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002343 progress_.reset(new Progress(stats_path));
Felipe Leme7447d7c2016-11-03 18:12:22 -07002344
Felipe Lemed071c682016-10-20 16:48:00 -07002345 /* gets the sequential id */
Felipe Leme7447d7c2016-11-03 18:12:22 -07002346 uint32_t last_id = android::base::GetIntProperty(PROPERTY_LAST_ID, 0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002347 id_ = ++last_id;
Felipe Lemed071c682016-10-20 16:48:00 -07002348 android::base::SetProperty(PROPERTY_LAST_ID, std::to_string(last_id));
2349
2350 MYLOGI("begin\n");
2351
Felipe Leme6ae5c4f2017-01-10 14:13:22 -08002352 register_sig_handler();
Felipe Lemed071c682016-10-20 16:48:00 -07002353
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002354 // TODO(b/111441001): maybe skip if already started?
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002355 if (options_->do_start_service) {
Felipe Leme75876a22016-10-27 16:31:27 -07002356 MYLOGI("Starting 'dumpstate' service\n");
2357 android::status_t ret;
2358 if ((ret = android::os::DumpstateService::Start()) != android::OK) {
2359 MYLOGE("Unable to start DumpstateService: %d\n", ret);
2360 }
2361 }
2362
Felipe Lemef0292972016-11-22 13:57:05 -08002363 if (PropertiesHelper::IsDryRun()) {
Felipe Lemed071c682016-10-20 16:48:00 -07002364 MYLOGI("Running on dry-run mode (to disable it, call 'setprop dumpstate.dry_run false')\n");
2365 }
2366
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002367 MYLOGI("dumpstate info: id=%d, args='%s', extra_options= %s)\n", id_, options_->args.c_str(),
2368 options_->extra_options.c_str());
Felipe Lemed071c682016-10-20 16:48:00 -07002369
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002370 MYLOGI("bugreport format version: %s\n", version_.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -08002371
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002372 do_early_screenshot_ = options_->do_progress_updates;
Felipe Lemee338bf62015-12-07 14:03:50 -08002373
Christopher Ferrised9354f2014-10-01 17:35:01 -07002374 // If we are going to use a socket, do it as early as possible
2375 // to avoid timeouts from bugreport.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002376 if (options_->use_socket) {
Nandana Dutta344cb62019-02-22 15:12:35 +00002377 if (!redirect_to_socket(stdout, "dumpstate")) {
2378 return ERROR;
2379 }
Christopher Ferrised9354f2014-10-01 17:35:01 -07002380 }
2381
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002382 if (options_->use_control_socket) {
Felipe Leme2628e9e2016-04-12 16:36:51 -07002383 MYLOGD("Opening control socket\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002384 control_socket_fd_ = open_socket("dumpstate");
Nandana Dutta344cb62019-02-22 15:12:35 +00002385 if (control_socket_fd_ == -1) {
2386 return ERROR;
2387 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002388 options_->do_progress_updates = 1;
Felipe Leme2628e9e2016-04-12 16:36:51 -07002389 }
2390
Felipe Leme71bbfc52015-11-23 14:14:51 -08002391 if (is_redirecting) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002392 PrepareToWriteToFile();
Felipe Leme1e9edc62015-12-21 16:02:13 -08002393
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002394 if (options_->do_progress_updates) {
2395 if (options_->do_broadcast) {
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07002396 // clang-format off
2397 std::vector<std::string> am_args = {
Felipe Lemea4ef1f02017-02-15 17:27:40 -08002398 "--receiver-permission", "android.permission.DUMP",
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002399 "--es", "android.intent.extra.NAME", name_,
2400 "--ei", "android.intent.extra.ID", std::to_string(id_),
2401 "--ei", "android.intent.extra.PID", std::to_string(pid_),
2402 "--ei", "android.intent.extra.MAX", std::to_string(progress_->GetMax()),
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07002403 };
2404 // clang-format on
Felipe Lemea4ef1f02017-02-15 17:27:40 -08002405 SendBroadcast("com.android.internal.intent.action.BUGREPORT_STARTED", am_args);
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07002406 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002407 if (options_->use_control_socket) {
2408 dprintf(control_socket_fd_, "BEGIN:%s\n", path_.c_str());
Felipe Lemeaabfcae2016-07-29 09:49:04 -07002409 }
Felipe Leme71bbfc52015-11-23 14:14:51 -08002410 }
2411 }
2412
Nick Kralevichf3599b32016-01-25 15:05:16 -08002413 /* read /proc/cmdline before dropping root */
2414 FILE *cmdline = fopen("/proc/cmdline", "re");
2415 if (cmdline) {
2416 fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
2417 fclose(cmdline);
2418 }
2419
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002420 if (options_->do_vibrate) {
Felipe Leme35b8cf12017-02-10 15:47:29 -08002421 Vibrate(150);
John Michelau1f794c42012-09-17 11:20:19 -05002422 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002423
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002424 if (options_->do_fb && do_early_screenshot_) {
2425 if (screenshot_path_.empty()) {
Felipe Leme3634a1e2015-12-09 10:11:47 -08002426 // should not have happened
Felipe Lemecbce55d2016-02-08 09:53:18 -08002427 MYLOGE("INTERNAL ERROR: skipping early screenshot because path was not set\n");
Felipe Leme3634a1e2015-12-09 10:11:47 -08002428 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08002429 MYLOGI("taking early screenshot\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002430 TakeScreenshot();
Felipe Lemee338bf62015-12-07 14:03:50 -08002431 }
2432 }
2433
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002434 if (options_->do_zip_file && zip_file != nullptr) {
2435 if (chown(path_.c_str(), AID_SHELL, AID_SHELL)) {
2436 MYLOGE("Unable to change ownership of zip file %s: %s\n", path_.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -07002437 strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08002438 }
2439 }
2440
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002441 int dup_stdout_fd;
2442 int dup_stderr_fd;
Felipe Leme71bbfc52015-11-23 14:14:51 -08002443 if (is_redirecting) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002444 // Redirect stderr to log_path_ for debugging.
Vishnu Nair20cf5032018-01-05 13:15:49 -08002445 TEMP_FAILURE_RETRY(dup_stderr_fd = dup(fileno(stderr)));
Nandana Dutta344cb62019-02-22 15:12:35 +00002446 if (!redirect_to_file(stderr, const_cast<char*>(log_path_.c_str()))) {
2447 return ERROR;
2448 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002449 if (chown(log_path_.c_str(), AID_SHELL, AID_SHELL)) {
2450 MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n", log_path_.c_str(),
2451 strerror(errno));
Felipe Leme6fe9db62016-02-12 09:04:16 -08002452 }
Nandana Dutt979388e2018-11-30 16:48:55 +00002453
2454 // Redirect stdout to tmp_path_. This is the main bugreport entry and will be
2455 // moved into zip file later, if zipping.
Vishnu Nair20cf5032018-01-05 13:15:49 -08002456 TEMP_FAILURE_RETRY(dup_stdout_fd = dup(fileno(stdout)));
Nandana Dutt979388e2018-11-30 16:48:55 +00002457 // TODO: why not write to a file instead of stdout to overcome this problem?
Felipe Leme6e01fa62015-11-11 19:35:14 -08002458 /* TODO: rather than generating a text file now and zipping it later,
2459 it would be more efficient to redirect stdout to the zip entry
2460 directly, but the libziparchive doesn't support that option yet. */
Nandana Dutta344cb62019-02-22 15:12:35 +00002461 if (!redirect_to_file(stdout, const_cast<char*>(tmp_path_.c_str()))) {
2462 return ERROR;
2463 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002464 if (chown(tmp_path_.c_str(), AID_SHELL, AID_SHELL)) {
Felipe Leme6fe9db62016-02-12 09:04:16 -08002465 MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002466 tmp_path_.c_str(), strerror(errno));
Felipe Leme6fe9db62016-02-12 09:04:16 -08002467 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002468 }
Felipe Lemed8b94e52016-12-08 10:21:44 -08002469
2470 // Don't buffer stdout
2471 setvbuf(stdout, nullptr, _IONBF, 0);
2472
Felipe Leme608385d2016-02-01 10:35:38 -08002473 // NOTE: there should be no stdout output until now, otherwise it would break the header.
2474 // In particular, DurationReport objects should be created passing 'title, NULL', so their
Felipe Lemecbce55d2016-02-08 09:53:18 -08002475 // duration is logged into MYLOG instead.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002476 PrintHeader();
Colin Crossf45fa6b2012-03-26 12:38:26 -07002477
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002478 if (options_->telephony_only) {
Jayachandran Ca94c7172017-06-10 15:08:12 -07002479 DumpstateTelephonyOnly();
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002480 DumpstateBoard();
2481 } else if (options_->wifi_only) {
mukesh agrawal253dad42018-01-23 21:59:59 -08002482 DumpstateWifiOnly();
Felipe Leme6ec6ac42017-01-10 15:29:53 -08002483 } else {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002484 // Dump state for the default case. This also drops root.
2485 if (!DumpstateDefault()) {
2486 // Something went wrong.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002487 return RunStatus::ERROR;
Felipe Leme6ec6ac42017-01-10 15:29:53 -08002488 }
Zhengyin Qian068ecc72016-08-10 16:48:14 -07002489 }
Felipe Leme71a74ac2016-03-17 15:43:25 -07002490
Felipe Leme55b42a62015-11-10 17:39:08 -08002491 /* close output if needed */
Felipe Leme71bbfc52015-11-23 14:14:51 -08002492 if (is_redirecting) {
Vishnu Nair20cf5032018-01-05 13:15:49 -08002493 TEMP_FAILURE_RETRY(dup2(dup_stdout_fd, fileno(stdout)));
Colin Crossf45fa6b2012-03-26 12:38:26 -07002494 }
2495
Nandana Duttd2f5f082019-01-18 17:13:52 +00002496 // Rename, and/or zip the (now complete) .tmp file within the internal directory.
Nandana Dutt9a76d202019-01-21 15:56:48 +00002497 if (options_->OutputToFile()) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002498 FinalizeFile();
Colin Crossf45fa6b2012-03-26 12:38:26 -07002499 }
2500
Nandana Duttd2f5f082019-01-18 17:13:52 +00002501 // Share the final file with the caller if the user has consented.
2502 Dumpstate::RunStatus status = Dumpstate::RunStatus::OK;
2503 if (options_->bugreport_fd.get() != -1) {
2504 status = CopyBugreportIfUserConsented();
2505 if (status != Dumpstate::RunStatus::OK &&
2506 status != Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
2507 // Do an early return if there were errors. We make an exception for consent
2508 // timing out because it's possible the user got distracted. In this case the
2509 // bugreport is not shared but made available for manual retrieval.
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002510 MYLOGI("User denied consent. Returning\n");
Nandana Duttd2f5f082019-01-18 17:13:52 +00002511 return status;
2512 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002513 if (options_->do_fb && options_->screenshot_fd.get() != -1) {
Nandana Dutte78c3d72019-01-29 16:10:45 +00002514 bool copy_succeeded = android::os::CopyFileToFd(screenshot_path_,
2515 options_->screenshot_fd.get());
2516 if (copy_succeeded) {
2517 android::os::UnlinkAndLogOnError(screenshot_path_);
2518 }
2519 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002520 if (status == Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
2521 MYLOGI(
2522 "Did not receive user consent yet."
2523 " Will not copy the bugreport artifacts to caller.\n");
2524 // TODO(b/111441001):
2525 // 1. cancel outstanding requests
2526 // 2. check for result more frequently
2527 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00002528 }
2529
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08002530 /* vibrate a few but shortly times to let user know it's finished */
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002531 if (options_->do_vibrate) {
Takuya Ogawa47f644e2017-12-20 18:09:09 +09002532 for (int i = 0; i < 3; i++) {
2533 Vibrate(75);
2534 usleep((75 + 50) * 1000);
2535 }
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08002536 }
2537
Jeff Brown1dc94e32014-09-11 14:15:27 -07002538 /* tell activity manager we're done */
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002539 if (options_->do_broadcast) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002540 SendBugreportFinishedBroadcast();
Nandana Duttbabf6c72019-01-15 14:11:12 +00002541 // Note that listener_ is notified in Run();
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07002542 }
2543
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002544 MYLOGD("Final progress: %d/%d (estimated %d)\n", progress_->Get(), progress_->GetMax(),
2545 progress_->GetInitialMax());
2546 progress_->Save();
2547 MYLOGI("done (id %d)\n", id_);
Colin Crossf45fa6b2012-03-26 12:38:26 -07002548
Felipe Leme107a05f2016-03-08 15:11:15 -08002549 if (is_redirecting) {
Vishnu Nair20cf5032018-01-05 13:15:49 -08002550 TEMP_FAILURE_RETRY(dup2(dup_stderr_fd, fileno(stderr)));
Felipe Leme107a05f2016-03-08 15:11:15 -08002551 }
2552
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002553 if (options_->use_control_socket && control_socket_fd_ != -1) {
Felipe Lemee844a9d2016-09-21 15:01:39 -07002554 MYLOGD("Closing control socket\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002555 close(control_socket_fd_);
Felipe Leme2628e9e2016-04-12 16:36:51 -07002556 }
2557
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002558 tombstone_data_.clear();
2559 anr_data_.clear();
Narayan Kamath6b9516c2017-10-27 11:15:51 +01002560
Nandana Duttd2f5f082019-01-18 17:13:52 +00002561 return (consent_callback_ != nullptr &&
2562 consent_callback_->getResult() == UserConsentResult::UNAVAILABLE)
2563 ? USER_CONSENT_TIMED_OUT
2564 : RunStatus::OK;
2565}
2566
2567void Dumpstate::CheckUserConsent(int32_t calling_uid, const android::String16& calling_package) {
2568 consent_callback_ = new ConsentCallback();
2569 const String16 incidentcompanion("incidentcompanion");
2570 sp<android::IBinder> ics(defaultServiceManager()->getService(incidentcompanion));
2571 if (ics != nullptr) {
2572 MYLOGD("Checking user consent via incidentcompanion service\n");
2573 android::interface_cast<android::os::IIncidentCompanion>(ics)->authorizeReport(
2574 calling_uid, calling_package, 0x1 /* FLAG_CONFIRMATION_DIALOG */,
2575 consent_callback_.get());
2576 } else {
2577 MYLOGD("Unable to check user consent; incidentcompanion service unavailable\n");
2578 }
2579}
2580
2581void Dumpstate::CleanupFiles() {
2582 android::os::UnlinkAndLogOnError(tmp_path_);
2583 android::os::UnlinkAndLogOnError(screenshot_path_);
2584 android::os::UnlinkAndLogOnError(path_);
2585}
2586
2587Dumpstate::RunStatus Dumpstate::HandleUserConsentDenied() {
2588 MYLOGD("User denied consent; deleting files and returning\n");
2589 CleanupFiles();
2590 return USER_CONSENT_DENIED;
2591}
2592
2593Dumpstate::RunStatus Dumpstate::CopyBugreportIfUserConsented() {
2594 // If the caller has asked to copy the bugreport over to their directory, we need explicit
2595 // user consent.
2596 UserConsentResult consent_result = consent_callback_->getResult();
2597 if (consent_result == UserConsentResult::UNAVAILABLE) {
2598 // User has not responded yet.
2599 uint64_t elapsed_ms = consent_callback_->getElapsedTimeMs();
2600 if (elapsed_ms < USER_CONSENT_TIMEOUT_MS) {
2601 uint delay_seconds = (USER_CONSENT_TIMEOUT_MS - elapsed_ms) / 1000;
2602 MYLOGD("Did not receive user consent yet; going to wait for %d seconds", delay_seconds);
2603 sleep(delay_seconds);
2604 }
2605 consent_result = consent_callback_->getResult();
2606 }
2607 if (consent_result == UserConsentResult::DENIED) {
2608 // User has explicitly denied sharing with the app. To be safe delete the
2609 // internal bugreport & tmp files.
2610 return HandleUserConsentDenied();
2611 }
2612 if (consent_result == UserConsentResult::APPROVED) {
Nandana Dutte78c3d72019-01-29 16:10:45 +00002613 bool copy_succeeded = android::os::CopyFileToFd(path_, options_->bugreport_fd.get());
2614 if (copy_succeeded) {
2615 android::os::UnlinkAndLogOnError(path_);
Nandana Duttd2f5f082019-01-18 17:13:52 +00002616 }
2617 return copy_succeeded ? Dumpstate::RunStatus::OK : Dumpstate::RunStatus::ERROR;
2618 } else if (consent_result == UserConsentResult::UNAVAILABLE) {
2619 // consent_result is still UNAVAILABLE. The user has likely not responded yet.
2620 // Since we do not have user consent to share the bugreport it does not get
2621 // copied over to the calling app but remains in the internal directory from
2622 // where the user can manually pull it.
2623 return Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT;
2624 }
2625 // Unknown result; must be a programming error.
2626 MYLOGE("Unknown user consent result:%d\n", consent_result);
2627 return Dumpstate::RunStatus::ERROR;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002628}
2629
Nandana Duttf02564e2019-02-15 15:24:24 +00002630Dumpstate::RunStatus Dumpstate::ParseCommandlineAndRun(int argc, char* argv[]) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002631 std::unique_ptr<Dumpstate::DumpOptions> options = std::make_unique<Dumpstate::DumpOptions>();
2632 Dumpstate::RunStatus status = options->Initialize(argc, argv);
2633 if (status == Dumpstate::RunStatus::OK) {
Nandana Duttf02564e2019-02-15 15:24:24 +00002634 SetOptions(std::move(options));
Nandana Duttd2f5f082019-01-18 17:13:52 +00002635 // When directly running dumpstate binary, the output is not expected to be written
2636 // to any external file descriptor.
Nandana Duttf02564e2019-02-15 15:24:24 +00002637 assert(options_->bugreport_fd.get() == -1);
Nandana Duttd2f5f082019-01-18 17:13:52 +00002638
2639 // calling_uid and calling_package are for user consent to share the bugreport with
2640 // an app; they are irrelvant here because bugreport is only written to a local
2641 // directory, and not shared.
Nandana Duttf02564e2019-02-15 15:24:24 +00002642 status = Run(-1 /* calling_uid */, "" /* calling_package */);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002643 }
Nandana Duttf02564e2019-02-15 15:24:24 +00002644 return status;
2645}
2646
2647/* Main entry point for dumpstate binary. */
2648int run_main(int argc, char* argv[]) {
2649 Dumpstate::RunStatus status = ds.ParseCommandlineAndRun(argc, argv);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002650
2651 switch (status) {
2652 case Dumpstate::RunStatus::OK:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002653 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002654 case Dumpstate::RunStatus::HELP:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002655 ShowUsage();
2656 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002657 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002658 fprintf(stderr, "Invalid combination of args\n");
2659 ShowUsage();
2660 exit(1);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002661 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002662 FALLTHROUGH_INTENDED;
2663 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
2664 FALLTHROUGH_INTENDED;
2665 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002666 exit(2);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002667 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002668}