blob: 90c16094d86f0fd429b039c2255f55ae74df3596 [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 }
Vishnu Naire97d6122018-01-18 13:58:56 -0800769 auto start = std::chrono::steady_clock::now();
770 auto end = start + timeout;
771 struct pollfd pfd = {fd, POLLIN};
Felipe Lemee82a27d2016-01-05 13:35:44 -0800772
Felipe Leme770410d2016-01-26 17:07:14 -0800773 std::vector<uint8_t> buffer(65536);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800774 while (1) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800775 if (timeout.count() > 0) {
776 // lambda to recalculate the timeout.
777 auto time_left_ms = [end]() {
778 auto now = std::chrono::steady_clock::now();
779 auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - now);
780 return std::max(diff.count(), 0LL);
781 };
782
783 int rc = TEMP_FAILURE_RETRY(poll(&pfd, 1, time_left_ms()));
784 if (rc < 0) {
785 MYLOGE("Error in poll while adding from fd to zip entry %s:%s", entry_name.c_str(),
786 strerror(errno));
787 return -errno;
788 } else if (rc == 0) {
789 MYLOGE("Timed out adding from fd to zip entry %s:%s Timeout:%lldms",
790 entry_name.c_str(), strerror(errno), timeout.count());
791 return TIMED_OUT;
792 }
793 }
794
Zach Riggle22200402016-08-18 01:01:24 -0400795 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), buffer.size()));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800796 if (bytes_read == 0) {
797 break;
798 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800799 MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
Vishnu Naire97d6122018-01-18 13:58:56 -0800800 return -errno;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800801 }
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700802 err = zip_writer_->WriteBytes(buffer.data(), bytes_read);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800803 if (err) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700804 MYLOGE("zip_writer_->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800805 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800806 }
807 }
808
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700809 err = zip_writer_->FinishEntry();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700810 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700811 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Vishnu Naire97d6122018-01-18 13:58:56 -0800812 return UNKNOWN_ERROR;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800813 }
814
Vishnu Naire97d6122018-01-18 13:58:56 -0800815 return OK;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800816}
817
Felipe Leme1d486fe2016-10-14 18:06:47 -0700818bool Dumpstate::AddZipEntry(const std::string& entry_name, const std::string& entry_path) {
819 android::base::unique_fd fd(
820 TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
Andreas Gampeaff68432016-07-18 18:01:27 -0700821 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -0800822 MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
Felipe Lemee82a27d2016-01-05 13:35:44 -0800823 return false;
824 }
825
Vishnu Naire97d6122018-01-18 13:58:56 -0800826 return (AddZipEntryFromFd(entry_name, fd.get()) == OK);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800827}
828
829/* adds a file to the existing zipped bugreport */
Felipe Leme4c2d6632016-09-28 14:32:00 -0700830static int _add_file_from_fd(const char* title __attribute__((unused)), const char* path, int fd) {
Vishnu Naire97d6122018-01-18 13:58:56 -0800831 return (ds.AddZipEntryFromFd(ZIP_ROOT_DIR + path, fd) == OK) ? 0 : 1;
Felipe Lemee82a27d2016-01-05 13:35:44 -0800832}
833
Felipe Leme1d486fe2016-10-14 18:06:47 -0700834void Dumpstate::AddDir(const std::string& dir, bool recursive) {
835 if (!IsZipping()) {
836 MYLOGD("Not adding dir %s because it's not a zipped bugreport\n", dir.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800837 return;
838 }
Felipe Leme678727a2016-09-21 17:22:11 -0700839 MYLOGD("Adding dir %s (recursive: %d)\n", dir.c_str(), recursive);
Felipe Leme46b85da2016-11-21 17:40:45 -0800840 DurationReporter duration_reporter(dir, true);
Felipe Leme678727a2016-09-21 17:22:11 -0700841 dump_files("", dir.c_str(), recursive ? skip_none : is_dir, _add_file_from_fd);
Felipe Lemee82a27d2016-01-05 13:35:44 -0800842}
843
Felipe Leme1d486fe2016-10-14 18:06:47 -0700844bool Dumpstate::AddTextZipEntry(const std::string& entry_name, const std::string& content) {
845 if (!IsZipping()) {
846 MYLOGD("Not adding text zip entry %s because it's not a zipped bugreport\n",
847 entry_name.c_str());
Felipe Leme111b9d02016-02-03 09:28:24 -0800848 return false;
849 }
Felipe Lemecbce55d2016-02-08 09:53:18 -0800850 MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700851 int32_t err = zip_writer_->StartEntryWithTime(entry_name.c_str(), ZipWriter::kCompress, ds.now_);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700852 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700853 MYLOGE("zip_writer_->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700854 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800855 return false;
856 }
857
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700858 err = zip_writer_->WriteBytes(content.c_str(), content.length());
Felipe Leme1d486fe2016-10-14 18:06:47 -0700859 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700860 MYLOGE("zip_writer_->WriteBytes(%s): %s\n", entry_name.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -0700861 ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800862 return false;
863 }
864
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700865 err = zip_writer_->FinishEntry();
Felipe Leme1d486fe2016-10-14 18:06:47 -0700866 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700867 MYLOGE("zip_writer_->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme809d74e2016-02-02 12:57:00 -0800868 return false;
869 }
870
871 return true;
872}
873
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800874static void DoKmsg() {
875 struct stat st;
876 if (!stat(PSTORE_LAST_KMSG, &st)) {
877 /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
878 DumpFile("LAST KMSG", PSTORE_LAST_KMSG);
879 } else if (!stat(ALT_PSTORE_LAST_KMSG, &st)) {
880 DumpFile("LAST KMSG", ALT_PSTORE_LAST_KMSG);
881 } else {
882 /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
883 DumpFile("LAST KMSG", "/proc/last_kmsg");
884 }
885}
886
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800887static void DoKernelLogcat() {
Yao Chenbe3bbc12018-01-17 16:31:10 -0800888 unsigned long timeout_ms = logcat_timeout({"kernel"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800889 RunCommand(
890 "KERNEL LOG",
891 {"logcat", "-b", "kernel", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
892 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
893}
894
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800895static void DoLogcat() {
Vishnu Nair6921f802017-11-22 09:17:23 -0800896 unsigned long timeout_ms;
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800897 // DumpFile("EVENT LOG TAGS", "/etc/event-log-tags");
898 // calculate timeout
Yao Chenbe3bbc12018-01-17 16:31:10 -0800899 timeout_ms = logcat_timeout({"main", "system", "crash"});
Tony Makae737652017-03-30 17:47:09 +0100900 RunCommand("SYSTEM LOG",
Vishnu Nair6921f802017-11-22 09:17:23 -0800901 {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
902 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Yao Chenbe3bbc12018-01-17 16:31:10 -0800903 timeout_ms = logcat_timeout({"events"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800904 RunCommand(
905 "EVENT LOG",
906 {"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
907 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Yao Chenbe3bbc12018-01-17 16:31:10 -0800908 timeout_ms = logcat_timeout({"stats"});
909 RunCommand(
910 "STATS LOG",
911 {"logcat", "-b", "stats", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
912 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
913 timeout_ms = logcat_timeout({"radio"});
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800914 RunCommand(
915 "RADIO LOG",
916 {"logcat", "-b", "radio", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
917 CommandOptions::WithTimeoutInMs(timeout_ms).Build());
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800918
919 RunCommand("LOG STATISTICS", {"logcat", "-b", "all", "-S"});
920
921 /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -0800922 RunCommand("LAST LOGCAT", {"logcat", "-L", "-b", "all", "-v", "threadtime", "-v", "printable",
923 "-v", "uid", "-d", "*:v"});
Felipe Leme6ec6ac42017-01-10 15:29:53 -0800924}
925
Jayachandran Ca94c7172017-06-10 15:08:12 -0700926static void DumpIpTablesAsRoot() {
Felipe Lemeb0f669d2016-09-26 18:26:11 -0700927 RunCommand("IPTABLES", {"iptables", "-L", "-nvx"});
928 RunCommand("IP6TABLES", {"ip6tables", "-L", "-nvx"});
Erik Kline32af8c22016-09-28 17:26:26 +0900929 RunCommand("IPTABLES NAT", {"iptables", "-t", "nat", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -0700930 /* no ip6 nat */
Erik Kline32af8c22016-09-28 17:26:26 +0900931 RunCommand("IPTABLES MANGLE", {"iptables", "-t", "mangle", "-L", "-nvx"});
932 RunCommand("IP6TABLES MANGLE", {"ip6tables", "-t", "mangle", "-L", "-nvx"});
933 RunCommand("IPTABLES RAW", {"iptables", "-t", "raw", "-L", "-nvx"});
934 RunCommand("IP6TABLES RAW", {"ip6tables", "-t", "raw", "-L", "-nvx"});
Felipe Lemec0808152016-06-17 17:37:13 -0700935}
936
Narayan Kamath8f788292017-05-25 13:20:39 +0100937static void AddAnrTraceDir(const bool add_to_zip, const std::string& anr_traces_dir) {
938 MYLOGD("AddAnrTraceDir(): dump_traces_file=%s, anr_traces_dir=%s\n", dump_traces_path,
939 anr_traces_dir.c_str());
940
941 // If we're here, dump_traces_path will always be a temporary file
942 // (created with mkostemp or similar) that contains dumps taken earlier
943 // on in the process.
944 if (dump_traces_path != nullptr) {
945 if (add_to_zip) {
946 ds.AddZipEntry(ZIP_ROOT_DIR + anr_traces_dir + "/traces-just-now.txt", dump_traces_path);
947 } else {
948 MYLOGD("Dumping current ANR traces (%s) to the main bugreport entry\n",
949 dump_traces_path);
950 ds.DumpFile("VM TRACES JUST NOW", dump_traces_path);
951 }
952
953 const int ret = unlink(dump_traces_path);
954 if (ret == -1) {
955 MYLOGW("Error unlinking temporary trace path %s: %s\n", dump_traces_path,
956 strerror(errno));
Felipe Lemee184f662016-10-27 10:04:47 -0700957 }
958 }
959
Narayan Kamathbd863722017-06-01 18:50:12 +0100960 // Add a specific message for the first ANR Dump.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700961 if (ds.anr_data_.size() > 0) {
962 AddDumps(ds.anr_data_.begin(), ds.anr_data_.begin() + 1,
Narayan Kamathbd863722017-06-01 18:50:12 +0100963 "VM TRACES AT LAST ANR", add_to_zip);
964
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100965 // The "last" ANR will always be included as separate entry in the zip file. In addition,
966 // it will be present in the body of the main entry if |add_to_zip| == false.
967 //
968 // Historical ANRs are always included as separate entries in the bugreport zip file.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -0700969 AddDumps(ds.anr_data_.begin() + ((add_to_zip) ? 1 : 0), ds.anr_data_.end(),
Narayan Kamath6b9516c2017-10-27 11:15:51 +0100970 "HISTORICAL ANR", true /* add_to_zip */);
Narayan Kamathbd863722017-06-01 18:50:12 +0100971 } else {
Narayan Kamath8f788292017-05-25 13:20:39 +0100972 printf("*** NO ANRs to dump in %s\n\n", ANR_DIR.c_str());
973 }
974}
975
976static void AddAnrTraceFiles() {
977 const bool add_to_zip = ds.IsZipping() && ds.version_ == VERSION_SPLIT_ANR;
978
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700979 std::string anr_traces_dir = "/data/anr";
Narayan Kamath8f788292017-05-25 13:20:39 +0100980
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700981 AddAnrTraceDir(add_to_zip, anr_traces_dir);
Narayan Kamath8f788292017-05-25 13:20:39 +0100982
Makoto Onuki83ec63f2019-01-31 17:08:59 -0800983 RunCommand("ANR FILES", {"ls", "-lt", ANR_DIR});
984
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700985 // Slow traces for slow operations.
Felipe Lemee184f662016-10-27 10:04:47 -0700986 struct stat st;
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700987 int i = 0;
988 while (true) {
989 const std::string slow_trace_path =
990 anr_traces_dir + android::base::StringPrintf("slow%02d.txt", i);
991 if (stat(slow_trace_path.c_str(), &st)) {
992 // No traces file at this index, done with the files.
993 break;
Felipe Lemee184f662016-10-27 10:04:47 -0700994 }
Elliott Hughes69fe5ec2018-03-23 11:04:25 -0700995 ds.DumpFile("VM TRACES WHEN SLOW", slow_trace_path.c_str());
996 i++;
Felipe Lemee184f662016-10-27 10:04:47 -0700997 }
998}
999
Wei Wang509bb5d2017-06-09 14:42:12 -07001000static void DumpBlockStatFiles() {
1001 DurationReporter duration_reporter("DUMP BLOCK STAT");
Wei Wang509bb5d2017-06-09 14:42:12 -07001002
Wei Wang1dc1ef52017-06-12 11:28:37 -07001003 std::unique_ptr<DIR, std::function<int(DIR*)>> dirptr(opendir(BLK_DEV_SYS_DIR), closedir);
1004
1005 if (dirptr == nullptr) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001006 MYLOGE("Failed to open %s: %s\n", BLK_DEV_SYS_DIR, strerror(errno));
1007 return;
1008 }
1009
1010 printf("------ DUMP BLOCK STAT ------\n\n");
Wei Wang1dc1ef52017-06-12 11:28:37 -07001011 while (struct dirent *d = readdir(dirptr.get())) {
Wei Wang509bb5d2017-06-09 14:42:12 -07001012 if ((d->d_name[0] == '.')
1013 && (((d->d_name[1] == '.') && (d->d_name[2] == '\0'))
1014 || (d->d_name[1] == '\0'))) {
1015 continue;
1016 }
1017 const std::string new_path =
1018 android::base::StringPrintf("%s/%s", BLK_DEV_SYS_DIR, d->d_name);
1019 printf("------ BLOCK STAT (%s) ------\n", new_path.c_str());
1020 dump_files("", new_path.c_str(), skip_not_stat, dump_stat_from_fd);
1021 printf("\n");
1022 }
Wei Wang1dc1ef52017-06-12 11:28:37 -07001023 return;
Wei Wang509bb5d2017-06-09 14:42:12 -07001024}
Jayachandran Ca94c7172017-06-10 15:08:12 -07001025
1026static void DumpPacketStats() {
1027 DumpFile("NETWORK DEV INFO", "/proc/net/dev");
1028 DumpFile("QTAGUID NETWORK INTERFACES INFO", "/proc/net/xt_qtaguid/iface_stat_all");
1029 DumpFile("QTAGUID NETWORK INTERFACES INFO (xt)", "/proc/net/xt_qtaguid/iface_stat_fmt");
1030 DumpFile("QTAGUID CTRL INFO", "/proc/net/xt_qtaguid/ctrl");
1031 DumpFile("QTAGUID STATS INFO", "/proc/net/xt_qtaguid/stats");
1032}
1033
1034static void DumpIpAddrAndRules() {
1035 /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
1036 RunCommand("NETWORK INTERFACES", {"ip", "link"});
1037 RunCommand("IPv4 ADDRESSES", {"ip", "-4", "addr", "show"});
1038 RunCommand("IPv6 ADDRESSES", {"ip", "-6", "addr", "show"});
1039 RunCommand("IP RULES", {"ip", "rule", "show"});
1040 RunCommand("IP RULES v6", {"ip", "-6", "rule", "show"});
1041}
1042
Vishnu Nair64afc022018-02-01 15:29:34 -08001043static void RunDumpsysTextByPriority(const std::string& title, int priority,
1044 std::chrono::milliseconds timeout,
1045 std::chrono::milliseconds service_timeout) {
1046 auto start = std::chrono::steady_clock::now();
Vishnu Naire97d6122018-01-18 13:58:56 -08001047 sp<android::IServiceManager> sm = defaultServiceManager();
1048 Dumpsys dumpsys(sm.get());
Vishnu Naire97d6122018-01-18 13:58:56 -08001049 Vector<String16> args;
1050 Dumpsys::setServiceArgs(args, /* asProto = */ false, priority);
Vishnu Naire97d6122018-01-18 13:58:56 -08001051 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ false);
1052 for (const String16& service : services) {
1053 std::string path(title);
1054 path.append(" - ").append(String8(service).c_str());
1055 DumpstateSectionReporter section_reporter(path, ds.listener_, ds.report_section_);
1056 size_t bytes_written = 0;
1057 status_t status = dumpsys.startDumpThread(service, args);
1058 if (status == OK) {
1059 dumpsys.writeDumpHeader(STDOUT_FILENO, service, priority);
1060 std::chrono::duration<double> elapsed_seconds;
1061 status = dumpsys.writeDump(STDOUT_FILENO, service, service_timeout,
1062 /* as_proto = */ false, elapsed_seconds, bytes_written);
1063 section_reporter.setSize(bytes_written);
1064 dumpsys.writeDumpFooter(STDOUT_FILENO, service, elapsed_seconds);
1065 bool dump_complete = (status == OK);
1066 dumpsys.stopDumpThread(dump_complete);
1067 }
1068 section_reporter.setStatus(status);
1069
1070 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1071 std::chrono::steady_clock::now() - start);
1072 if (elapsed_duration > timeout) {
1073 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1074 elapsed_duration.count());
1075 break;
1076 }
1077 }
1078}
1079
Vishnu Nair64afc022018-02-01 15:29:34 -08001080static void RunDumpsysText(const std::string& title, int priority,
1081 std::chrono::milliseconds timeout,
1082 std::chrono::milliseconds service_timeout) {
1083 DurationReporter duration_reporter(title);
1084 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1085 fsync(STDOUT_FILENO);
1086 RunDumpsysTextByPriority(title, priority, timeout, service_timeout);
1087}
1088
1089/* Dump all services registered with Normal or Default priority. */
1090static void RunDumpsysTextNormalPriority(const std::string& title,
1091 std::chrono::milliseconds timeout,
1092 std::chrono::milliseconds service_timeout) {
1093 DurationReporter duration_reporter(title);
1094 dprintf(STDOUT_FILENO, "------ %s (/system/bin/dumpsys) ------\n", title.c_str());
1095 fsync(STDOUT_FILENO);
1096 RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_NORMAL, timeout,
1097 service_timeout);
1098 RunDumpsysTextByPriority(title, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT, timeout,
1099 service_timeout);
1100}
1101
1102static void RunDumpsysProto(const std::string& title, int priority,
1103 std::chrono::milliseconds timeout,
1104 std::chrono::milliseconds service_timeout) {
Luis Hector Chavez1e27b082018-03-22 15:36:42 -07001105 if (!ds.IsZipping()) {
1106 MYLOGD("Not dumping %s because it's not a zipped bugreport\n", title.c_str());
1107 return;
1108 }
Vishnu Naire97d6122018-01-18 13:58:56 -08001109 sp<android::IServiceManager> sm = defaultServiceManager();
1110 Dumpsys dumpsys(sm.get());
1111 Vector<String16> args;
1112 Dumpsys::setServiceArgs(args, /* asProto = */ true, priority);
1113 DurationReporter duration_reporter(title);
1114
1115 auto start = std::chrono::steady_clock::now();
1116 Vector<String16> services = dumpsys.listServices(priority, /* supports_proto = */ true);
1117 for (const String16& service : services) {
1118 std::string path(kProtoPath);
1119 path.append(String8(service).c_str());
1120 if (priority == IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL) {
1121 path.append("_CRITICAL");
1122 } else if (priority == IServiceManager::DUMP_FLAG_PRIORITY_HIGH) {
1123 path.append("_HIGH");
1124 }
1125 path.append(kProtoExt);
1126 DumpstateSectionReporter section_reporter(path, ds.listener_, ds.report_section_);
1127 status_t status = dumpsys.startDumpThread(service, args);
1128 if (status == OK) {
1129 status = ds.AddZipEntryFromFd(path, dumpsys.getDumpFd(), service_timeout);
1130 bool dumpTerminated = (status == OK);
1131 dumpsys.stopDumpThread(dumpTerminated);
1132 }
1133 ZipWriter::FileEntry file_entry;
1134 ds.zip_writer_->GetLastEntry(&file_entry);
1135 section_reporter.setSize(file_entry.compressed_size);
1136 section_reporter.setStatus(status);
1137
1138 auto elapsed_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
1139 std::chrono::steady_clock::now() - start);
1140 if (elapsed_duration > timeout) {
1141 MYLOGE("*** command '%s' timed out after %llums\n", title.c_str(),
1142 elapsed_duration.count());
1143 break;
1144 }
1145 }
1146}
1147
Nandana Dutta7db6342018-11-21 14:53:34 +00001148// Runs dumpsys on services that must dump first and will take less than 100ms to dump.
Vishnu Nair780b1282017-10-10 13:57:24 -07001149static void RunDumpsysCritical() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001150 RunDumpsysText("DUMPSYS CRITICAL", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1151 /* timeout= */ 5s, /* service_timeout= */ 500ms);
1152 RunDumpsysProto("DUMPSYS CRITICAL PROTO", IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL,
1153 /* timeout= */ 5s, /* service_timeout= */ 500ms);
Vishnu Nair780b1282017-10-10 13:57:24 -07001154}
1155
1156// Runs dumpsys on services that must dump first but can take up to 250ms to dump.
1157static void RunDumpsysHigh() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001158 // TODO meminfo takes ~10s, connectivity takes ~5sec to dump. They are both
1159 // high priority. Reduce timeout once they are able to dump in a shorter time or
1160 // moved to a parallel task.
1161 RunDumpsysText("DUMPSYS HIGH", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1162 /* timeout= */ 90s, /* service_timeout= */ 30s);
1163 RunDumpsysProto("DUMPSYS HIGH PROTO", IServiceManager::DUMP_FLAG_PRIORITY_HIGH,
1164 /* timeout= */ 5s, /* service_timeout= */ 1s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001165}
1166
1167// Runs dumpsys on services that must dump but can take up to 10s to dump.
1168static void RunDumpsysNormal() {
Vishnu Nair64afc022018-02-01 15:29:34 -08001169 RunDumpsysTextNormalPriority("DUMPSYS", /* timeout= */ 90s, /* service_timeout= */ 10s);
1170 RunDumpsysProto("DUMPSYS PROTO", IServiceManager::DUMP_FLAG_PRIORITY_NORMAL,
1171 /* timeout= */ 90s, /* service_timeout= */ 10s);
Vishnu Nair780b1282017-10-10 13:57:24 -07001172}
1173
Steven Moreland44cd9482018-01-04 16:24:13 -08001174static void DumpHals() {
Steven Moreland44cd9482018-01-04 16:24:13 -08001175 using android::hidl::manager::V1_0::IServiceManager;
1176 using android::hardware::defaultServiceManager;
1177
1178 sp<IServiceManager> sm = defaultServiceManager();
1179 if (sm == nullptr) {
1180 MYLOGE("Could not retrieve hwservicemanager to dump hals.\n");
1181 return;
1182 }
1183
1184 auto ret = sm->list([&](const auto& interfaces) {
1185 for (const std::string& interface : interfaces) {
1186 std::string cleanName = interface;
1187 std::replace_if(cleanName.begin(),
1188 cleanName.end(),
1189 [](char c) {
1190 return !isalnum(c) &&
1191 std::string("@-_:.").find(c) == std::string::npos;
1192 }, '_');
Nandana Dutt979388e2018-11-30 16:48:55 +00001193 const std::string path = ds.bugreport_internal_dir_ + "/lshal_debug_" + cleanName;
Steven Moreland44cd9482018-01-04 16:24:13 -08001194
1195 {
1196 auto fd = android::base::unique_fd(
1197 TEMP_FAILURE_RETRY(open(path.c_str(),
1198 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1199 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1200 if (fd < 0) {
1201 MYLOGE("Could not open %s to dump additional hal information.\n", path.c_str());
1202 continue;
1203 }
1204 RunCommandToFd(fd,
1205 "",
Steven Morelandc81cd3c2018-01-18 14:36:26 -08001206 {"lshal", "debug", "-E", interface},
Steven Moreland44cd9482018-01-04 16:24:13 -08001207 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
1208
1209 bool empty = 0 == lseek(fd, 0, SEEK_END);
1210 if (!empty) {
1211 ds.AddZipEntry("lshal-debug/" + cleanName + ".txt", path);
1212 }
1213 }
1214
1215 unlink(path.c_str());
1216 }
1217 });
1218
1219 if (!ret.isOk()) {
1220 MYLOGE("Could not list hals from hwservicemanager.\n");
1221 }
1222}
1223
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001224static void dumpstate() {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001225 DurationReporter duration_reporter("DUMPSTATE");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001226
Arve Hjønnevåg2db0f5f2014-10-15 18:08:37 -07001227 dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001228 RunCommand("UPTIME", {"uptime"});
Wei Wang509bb5d2017-06-09 14:42:12 -07001229 DumpBlockStatFiles();
Mark Salyzyn8c8130e2015-12-09 11:21:28 -08001230 dump_emmc_ecsd("/d/mmc0/mmc0:0001/ext_csd");
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001231 DumpFile("MEMORY INFO", "/proc/meminfo");
1232 RunCommand("CPU INFO", {"top", "-b", "-n", "1", "-H", "-s", "6", "-o",
Felipe Leme30dbfa12016-09-02 12:43:26 -07001233 "pid,tid,user,pr,ni,%cpu,s,virt,res,pcy,cmd,name"});
Felipe Lemef0292972016-11-22 13:57:05 -08001234 RunCommand("PROCRANK", {"procrank"}, AS_ROOT_20);
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001235 DumpFile("VIRTUAL MEMORY STATS", "/proc/vmstat");
1236 DumpFile("VMALLOC INFO", "/proc/vmallocinfo");
1237 DumpFile("SLAB INFO", "/proc/slabinfo");
1238 DumpFile("ZONEINFO", "/proc/zoneinfo");
1239 DumpFile("PAGETYPEINFO", "/proc/pagetypeinfo");
1240 DumpFile("BUDDYINFO", "/proc/buddyinfo");
1241 DumpFile("FRAGMENTATION INFO", "/d/extfrag/unusable_index");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001242
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001243 DumpFile("KERNEL WAKE SOURCES", "/d/wakeup_sources");
1244 DumpFile("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
1245 DumpFile("KERNEL SYNC", "/d/sync");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001246
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001247 RunCommand("PROCESSES AND THREADS",
Yohei Yukawa591a72d2017-10-05 21:36:35 -07001248 {"ps", "-A", "-T", "-Z", "-O", "pri,nice,rtprio,sched,pcy,time"});
Felipe Lemef0292972016-11-22 13:57:05 -08001249 RunCommand("LIBRANK", {"librank"}, CommandOptions::AS_ROOT);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001250
Andreas Huber69ec3ac2017-03-23 09:47:51 -07001251 if (ds.IsZipping()) {
Yifan Hong90e8d8d2018-06-28 13:14:39 -07001252 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z"},
1253 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
Steven Moreland44cd9482018-01-04 16:24:13 -08001254 DumpHals();
Andreas Huber69ec3ac2017-03-23 09:47:51 -07001255 } else {
Yifan Hong90e8d8d2018-06-28 13:14:39 -07001256 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z", "--debug"},
1257 CommandOptions::WithTimeout(10).AsRootIfAvailable().Build());
Andreas Huber69ec3ac2017-03-23 09:47:51 -07001258 }
Steven Moreland81b429e2017-01-31 19:50:46 -08001259
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001260 RunCommand("PRINTENV", {"printenv"});
Elliott Hughes21b7c8d2016-10-28 08:53:02 -07001261 RunCommand("NETSTAT", {"netstat", "-nW"});
Felipe Lemee4eca582016-06-10 17:48:08 -07001262 struct stat s;
1263 if (stat("/proc/modules", &s) != 0) {
1264 MYLOGD("Skipping 'lsmod' because /proc/modules does not exist\n");
1265 } else {
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001266 RunCommand("LSMOD", {"lsmod"});
Felipe Lemee4eca582016-06-10 17:48:08 -07001267 }
Michal Karpinski4db754f2015-12-11 18:04:32 +00001268
Siarhei Vishniakou4a0a8772017-12-05 16:22:49 -08001269 if (__android_logger_property_get_bool(
1270 "ro.logd.kernel", BOOL_DEFAULT_TRUE | BOOL_DEFAULT_FLAG_ENG | BOOL_DEFAULT_FLAG_SVELTE)) {
1271 DoKernelLogcat();
1272 } else {
1273 do_dmesg();
1274 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07001275
Felipe Lemef0292972016-11-22 13:57:05 -08001276 RunCommand("LIST OF OPEN FILES", {"lsof"}, CommandOptions::AS_ROOT);
Jeff Brown1dc94e32014-09-11 14:15:27 -07001277 for_each_pid(do_showmap, "SMAPS OF ALL PROCESSES");
1278 for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
Mark Salyzyna297c322016-02-05 15:33:17 -08001279 for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001280
Ajay Panicker2ff8e872017-04-27 14:04:32 -07001281 /* Dump Bluetooth HCI logs */
1282 ds.AddDir("/data/misc/bluetooth/logs", true);
Ajay Panickerd886ec42016-09-14 12:26:46 -07001283
Felipe Leme9a523ae2016-10-20 15:10:33 -07001284 if (!ds.do_early_screenshot_) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001285 MYLOGI("taking late screenshot\n");
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001286 ds.TakeScreenshot();
Jeff Sharkey5a930032013-03-19 15:05:19 -07001287 }
1288
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001289 DoLogcat();
Mark Salyzynecc07632015-07-30 14:57:09 -07001290
Felipe Lemee184f662016-10-27 10:04:47 -07001291 AddAnrTraceFiles();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001292
Narayan Kamath8f788292017-05-25 13:20:39 +01001293 // NOTE: tombstones are always added as separate entries in the zip archive
1294 // and are not interspersed with the main report.
Luis Hector Chavez5f6ee4a2018-03-14 15:12:46 -07001295 const bool tombstones_dumped = AddDumps(ds.tombstone_data_.begin(), ds.tombstone_data_.end(),
Narayan Kamathbd863722017-06-01 18:50:12 +01001296 "TOMBSTONE", true /* add_to_zip */);
Narayan Kamath8f788292017-05-25 13:20:39 +01001297 if (!tombstones_dumped) {
1298 printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR.c_str());
Christopher Ferris7dc7f322014-07-22 16:08:19 -07001299 }
1300
Jayachandran Ca94c7172017-06-10 15:08:12 -07001301 DumpPacketStats();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001302
Chenbo Feng276a3b62018-08-07 11:44:49 -07001303 RunDumpsys("EBPF MAP STATS", {"netd", "trafficcontroller"});
1304
Felipe Leme6ec6ac42017-01-10 15:29:53 -08001305 DoKmsg();
Mark Salyzyn2262c162014-12-16 09:09:26 -08001306
Jayachandran Ca94c7172017-06-10 15:08:12 -07001307 DumpIpAddrAndRules();
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -07001308
1309 dump_route_tables();
1310
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001311 RunCommand("ARP CACHE", {"ip", "-4", "neigh", "show"});
1312 RunCommand("IPv6 ND CACHE", {"ip", "-6", "neigh", "show"});
1313 RunCommand("MULTICAST ADDRESSES", {"ip", "maddr"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001314
Vishnu Nair780b1282017-10-10 13:57:24 -07001315 RunDumpsysHigh();
Lorenzo Colitti6afc38c2015-09-09 22:59:25 +09001316
Elliott Hughes23ccc622017-02-28 10:14:22 -08001317 RunCommand("SYSTEM PROPERTIES", {"getprop"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001318
Jin Qianf334d662017-10-10 14:41:37 -07001319 RunCommand("STORAGED IO INFO", {"storaged", "-u", "-p"});
ynwangf649a6e2016-07-17 21:56:00 -07001320
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001321 RunCommand("FILESYSTEMS & FREE SPACE", {"df"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001322
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001323 RunCommand("LAST RADIO LOG", {"parse_radio_log", "/proc/last_radio_log"});
Colin Crossf45fa6b2012-03-26 12:38:26 -07001324
Colin Crossf45fa6b2012-03-26 12:38:26 -07001325 /* Binder state is expensive to look at as it uses a lot of memory. */
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001326 DumpFile("BINDER FAILED TRANSACTION LOG", "/sys/kernel/debug/binder/failed_transaction_log");
1327 DumpFile("BINDER TRANSACTION LOG", "/sys/kernel/debug/binder/transaction_log");
1328 DumpFile("BINDER TRANSACTIONS", "/sys/kernel/debug/binder/transactions");
1329 DumpFile("BINDER STATS", "/sys/kernel/debug/binder/stats");
1330 DumpFile("BINDER STATE", "/sys/kernel/debug/binder/state");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001331
Nataniel Borgesbc73f522019-01-25 16:37:16 -08001332 RunDumpsys("WINSCOPE TRACE", {"window", "trace"});
Vishnu Nair36b4cdb2017-11-17 10:27:05 -08001333 /* Add window and surface trace files. */
1334 if (!PropertiesHelper::IsUserBuild()) {
1335 ds.AddDir(WMTRACE_DATA_DIR, false);
1336 }
1337
Felipe Leme6f674ae2016-11-18 17:10:33 -08001338 ds.DumpstateBoard();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001339
Steven Moreland7440ddb2016-12-15 16:13:39 -08001340 /* Migrate the ril_dumpstate to a device specific dumpstate? */
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001341 int rilDumpstateTimeout = android::base::GetIntProperty("ril.dumpstate.timeout", 0);
1342 if (rilDumpstateTimeout > 0) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001343 // su does not exist on user builds, so try running without it.
1344 // This way any implementations of vril-dump that do not require
1345 // root can run on user builds.
1346 CommandOptions::CommandOptionsBuilder options =
Felipe Leme96c2bbb2016-09-26 09:21:21 -07001347 CommandOptions::WithTimeout(rilDumpstateTimeout);
Felipe Lemef0292972016-11-22 13:57:05 -08001348 if (!PropertiesHelper::IsUserBuild()) {
Felipe Leme30dbfa12016-09-02 12:43:26 -07001349 options.AsRoot();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001350 }
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001351 RunCommand("DUMP VENDOR RIL LOGS", {"vril-dump"}, options.Build());
Colin Crossf45fa6b2012-03-26 12:38:26 -07001352 }
1353
Felipe Lemed8b94e52016-12-08 10:21:44 -08001354 printf("========================================================\n");
1355 printf("== Android Framework Services\n");
1356 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001357
Vishnu Nair780b1282017-10-10 13:57:24 -07001358 RunDumpsysNormal();
Colin Crossf45fa6b2012-03-26 12:38:26 -07001359
Felipe Lemed8b94e52016-12-08 10:21:44 -08001360 printf("========================================================\n");
1361 printf("== Checkins\n");
1362 printf("========================================================\n");
Dianne Hackborn02bea972013-06-26 18:59:09 -07001363
Felipe Lemeb0f669d2016-09-26 18:26:11 -07001364 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
1365 RunDumpsys("CHECKIN MEMINFO", {"meminfo", "--checkin"});
1366 RunDumpsys("CHECKIN NETSTATS", {"netstats", "--checkin"});
1367 RunDumpsys("CHECKIN PROCSTATS", {"procstats", "-c"});
1368 RunDumpsys("CHECKIN USAGESTATS", {"usagestats", "-c"});
1369 RunDumpsys("CHECKIN PACKAGE", {"package", "--checkin"});
Dianne Hackborn02bea972013-06-26 18:59:09 -07001370
Felipe Lemed8b94e52016-12-08 10:21:44 -08001371 printf("========================================================\n");
1372 printf("== Running Application Activities\n");
1373 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001374
Makoto Onuki60780982018-04-16 15:34:00 -07001375 // The following dumpsys internally collects output from running apps, so it can take a long
1376 // time. So let's extend the timeout.
1377
1378 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
1379
1380 RunDumpsys("APP ACTIVITIES", {"activity", "-v", "all"}, DUMPSYS_COMPONENTS_OPTIONS);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001381
Felipe Lemed8b94e52016-12-08 10:21:44 -08001382 printf("========================================================\n");
Makoto Onuki60780982018-04-16 15:34:00 -07001383 printf("== Running Application Services (platform)\n");
Felipe Lemed8b94e52016-12-08 10:21:44 -08001384 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001385
Vishnu Nairc6e6ea72018-07-02 14:20:06 -07001386 RunDumpsys("APP SERVICES PLATFORM", {"activity", "service", "all-platform-non-critical"},
Makoto Onuki60780982018-04-16 15:34:00 -07001387 DUMPSYS_COMPONENTS_OPTIONS);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001388
Felipe Lemed8b94e52016-12-08 10:21:44 -08001389 printf("========================================================\n");
Makoto Onuki60780982018-04-16 15:34:00 -07001390 printf("== Running Application Services (non-platform)\n");
Felipe Lemed8b94e52016-12-08 10:21:44 -08001391 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001392
Makoto Onuki60780982018-04-16 15:34:00 -07001393 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
1394 DUMPSYS_COMPONENTS_OPTIONS);
1395
1396 printf("========================================================\n");
1397 printf("== Running Application Providers (platform)\n");
1398 printf("========================================================\n");
1399
1400 RunDumpsys("APP PROVIDERS PLATFORM", {"activity", "provider", "all-platform"},
1401 DUMPSYS_COMPONENTS_OPTIONS);
1402
1403 printf("========================================================\n");
1404 printf("== Running Application Providers (non-platform)\n");
1405 printf("========================================================\n");
1406
1407 RunDumpsys("APP PROVIDERS NON-PLATFORM", {"activity", "provider", "all-non-platform"},
1408 DUMPSYS_COMPONENTS_OPTIONS);
Colin Crossf45fa6b2012-03-26 12:38:26 -07001409
Adrian Roos8b397ab2017-04-04 16:35:44 -07001410 printf("========================================================\n");
1411 printf("== Dropbox crashes\n");
1412 printf("========================================================\n");
1413
1414 RunDumpsys("DROPBOX SYSTEM SERVER CRASHES", {"dropbox", "-p", "system_server_crash"});
1415 RunDumpsys("DROPBOX SYSTEM APP CRASHES", {"dropbox", "-p", "system_app_crash"});
1416
Felipe Lemed8b94e52016-12-08 10:21:44 -08001417 printf("========================================================\n");
1418 printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),
1419 ds.progress_->GetMax(), ds.progress_->GetInitialMax());
1420 printf("========================================================\n");
1421 printf("== dumpstate: done (id %d)\n", ds.id_);
1422 printf("========================================================\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001423}
1424
Nandana Dutt4be45d12018-09-26 15:04:23 +01001425/* Dumps state for the default case. Returns true if everything went fine. */
1426static bool DumpstateDefault() {
Primiano Tucci2d7f5c22019-01-17 15:51:14 +00001427 // Try to dump anrd trace if the daemon is running.
1428 dump_anrd_trace();
Nandana Dutt4be45d12018-09-26 15:04:23 +01001429
1430 // Invoking the following dumpsys calls before dump_traces() to try and
1431 // keep the system stats as close to its initial state as possible.
1432 RunDumpsysCritical();
1433
1434 /* collect stack traces from Dalvik and native processes (needs root) */
1435 dump_traces_path = dump_traces();
1436
1437 /* Run some operations that require root. */
1438 ds.tombstone_data_ = GetDumpFds(TOMBSTONE_DIR, TOMBSTONE_FILE_PREFIX, !ds.IsZipping());
1439 ds.anr_data_ = GetDumpFds(ANR_DIR, ANR_FILE_PREFIX, !ds.IsZipping());
1440
1441 ds.AddDir(RECOVERY_DIR, true);
1442 ds.AddDir(RECOVERY_DATA_DIR, true);
1443 ds.AddDir(UPDATE_ENGINE_LOG_DIR, true);
1444 ds.AddDir(LOGPERSIST_DATA_DIR, false);
1445 if (!PropertiesHelper::IsUserBuild()) {
1446 ds.AddDir(PROFILE_DATA_DIR_CUR, true);
1447 ds.AddDir(PROFILE_DATA_DIR_REF, true);
1448 }
1449 add_mountinfo();
1450 DumpIpTablesAsRoot();
1451
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001452 // Capture any IPSec policies in play. No keys are exposed here.
Nandana Dutt4be45d12018-09-26 15:04:23 +01001453 RunCommand("IP XFRM POLICY", {"ip", "xfrm", "policy"}, CommandOptions::WithTimeout(10).Build());
1454
Benedict Wong8f9d8a42019-01-03 16:19:38 -08001455 // Dump IPsec stats. No keys are exposed here.
1456 DumpFile("XFRM STATS", XFRM_STAT_PROC_FILE);
1457
Nandana Dutt4be45d12018-09-26 15:04:23 +01001458 // Run ss as root so we can see socket marks.
1459 RunCommand("DETAILED SOCKET STATE", {"ss", "-eionptu"}, CommandOptions::WithTimeout(10).Build());
1460
1461 // Run iotop as root to show top 100 IO threads
1462 RunCommand("IOTOP", {"iotop", "-n", "1", "-m", "100"});
1463
Erick Reyese68df822019-02-11 14:46:36 -08001464 // Gather shared memory buffer info if the product implements it
1465 struct stat st;
1466 if (!stat("/product/bin/dmabuf_dump", &st)) {
1467 RunCommand("Dmabuf dump", {"/product/bin/dmabuf_dump"});
1468 }
1469
Nandana Dutt4be45d12018-09-26 15:04:23 +01001470 if (!DropRootUser()) {
1471 return false;
1472 }
1473
1474 dumpstate();
1475 return true;
1476}
1477
mukesh agrawal253dad42018-01-23 21:59:59 -08001478// This method collects common dumpsys for telephony and wifi
1479static void DumpstateRadioCommon() {
Jayachandran Ca94c7172017-06-10 15:08:12 -07001480 DumpIpTablesAsRoot();
1481
1482 if (!DropRootUser()) {
1483 return;
1484 }
1485
1486 do_dmesg();
1487 DoLogcat();
1488 DumpPacketStats();
1489 DoKmsg();
1490 DumpIpAddrAndRules();
1491 dump_route_tables();
1492
1493 RunDumpsys("NETWORK DIAGNOSTICS", {"connectivity", "--diag"},
1494 CommandOptions::WithTimeout(10).Build());
mukesh agrawal253dad42018-01-23 21:59:59 -08001495}
1496
1497// This method collects dumpsys for telephony debugging only
1498static void DumpstateTelephonyOnly() {
1499 DurationReporter duration_reporter("DUMPSTATE");
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07001500 const CommandOptions DUMPSYS_COMPONENTS_OPTIONS = CommandOptions::WithTimeout(60).Build();
mukesh agrawal253dad42018-01-23 21:59:59 -08001501
1502 DumpstateRadioCommon();
Jayachandran Ca94c7172017-06-10 15:08:12 -07001503
1504 RunCommand("SYSTEM PROPERTIES", {"getprop"});
1505
1506 printf("========================================================\n");
1507 printf("== Android Framework Services\n");
1508 printf("========================================================\n");
1509
Vishnu Nair652cc802017-11-30 15:18:30 -08001510 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
1511 SEC_TO_MSEC(10));
1512 RunDumpsys("DUMPSYS", {"carrier_config"}, CommandOptions::WithTimeout(90).Build(),
1513 SEC_TO_MSEC(10));
Amruth Ramachandrand25a9142018-04-02 16:16:09 -07001514 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(),
1515 SEC_TO_MSEC(10));
Sooraj Sasindrane8d98912018-04-20 11:31:55 -07001516 RunDumpsys("BATTERYSTATS", {"batterystats"}, CommandOptions::WithTimeout(90).Build(),
1517 SEC_TO_MSEC(10));
Jayachandran Ca94c7172017-06-10 15:08:12 -07001518
1519 printf("========================================================\n");
1520 printf("== Running Application Services\n");
1521 printf("========================================================\n");
1522
1523 RunDumpsys("TELEPHONY SERVICES", {"activity", "service", "TelephonyDebugService"});
1524
1525 printf("========================================================\n");
Sooraj Sasindrana0829e72018-05-19 15:52:17 -07001526 printf("== Running Application Services (non-platform)\n");
1527 printf("========================================================\n");
1528
1529 RunDumpsys("APP SERVICES NON-PLATFORM", {"activity", "service", "all-non-platform"},
1530 DUMPSYS_COMPONENTS_OPTIONS);
1531
1532 printf("========================================================\n");
Kelly Rossmoyer769babb2018-08-21 18:06:38 -07001533 printf("== Checkins\n");
1534 printf("========================================================\n");
1535
1536 RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
1537
1538 printf("========================================================\n");
Jayachandran Ca94c7172017-06-10 15:08:12 -07001539 printf("== dumpstate: done (id %d)\n", ds.id_);
1540 printf("========================================================\n");
1541}
1542
mukesh agrawal253dad42018-01-23 21:59:59 -08001543// This method collects dumpsys for wifi debugging only
1544static void DumpstateWifiOnly() {
1545 DurationReporter duration_reporter("DUMPSTATE");
1546
1547 DumpstateRadioCommon();
1548
1549 printf("========================================================\n");
1550 printf("== Android Framework Services\n");
1551 printf("========================================================\n");
1552
1553 RunDumpsys("DUMPSYS", {"connectivity"}, CommandOptions::WithTimeout(90).Build(),
1554 SEC_TO_MSEC(10));
1555 RunDumpsys("DUMPSYS", {"wifi"}, CommandOptions::WithTimeout(90).Build(),
1556 SEC_TO_MSEC(10));
1557
Roger Wang70399032019-01-08 16:10:37 +08001558 if (ds.IsZipping()) {
1559 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z"},
1560 CommandOptions::WithTimeout(2).AsRootIfAvailable().Build());
1561 DumpHals();
1562 } else {
1563 RunCommand("HARDWARE HALS", {"lshal", "-lVSietrpc", "--types=b,c,l,z", "--debug"},
1564 CommandOptions::WithTimeout(10).AsRootIfAvailable().Build());
1565 }
1566
mukesh agrawal253dad42018-01-23 21:59:59 -08001567 printf("========================================================\n");
1568 printf("== dumpstate: done (id %d)\n", ds.id_);
1569 printf("========================================================\n");
1570}
1571
Felipe Leme6f674ae2016-11-18 17:10:33 -08001572void Dumpstate::DumpstateBoard() {
1573 DurationReporter duration_reporter("dumpstate_board()");
Felipe Lemed8b94e52016-12-08 10:21:44 -08001574 printf("========================================================\n");
1575 printf("== Board\n");
1576 printf("========================================================\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08001577
Felipe Leme6f674ae2016-11-18 17:10:33 -08001578 if (!IsZipping()) {
Steven Moreland7440ddb2016-12-15 16:13:39 -08001579 MYLOGD("Not dumping board info because it's not a zipped bugreport\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08001580 return;
1581 }
1582
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001583 std::vector<std::string> paths;
1584 std::vector<android::base::ScopeGuard<std::function<void()>>> remover;
Jie Song9fbfad02017-06-20 16:29:42 -07001585 for (int i = 0; i < NUM_OF_DUMPS; i++) {
Nandana Dutt979388e2018-11-30 16:48:55 +00001586 paths.emplace_back(StringPrintf("%s/%s", ds.bugreport_internal_dir_.c_str(),
1587 kDumpstateBoardFiles[i].c_str()));
Nandana Dutt16d1aee2019-02-15 16:13:53 +00001588 remover.emplace_back(android::base::make_scope_guard(
1589 std::bind([](std::string path) { android::os::UnlinkAndLogOnError(path); }, paths[i])));
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001590 }
Jie Song9fbfad02017-06-20 16:29:42 -07001591
Wei Wang587eac92018-04-05 12:17:20 -07001592 sp<IDumpstateDevice> dumpstate_device(IDumpstateDevice::getService());
1593 if (dumpstate_device == nullptr) {
1594 MYLOGE("No IDumpstateDevice implementation\n");
1595 return;
1596 }
1597
1598 using ScopedNativeHandle =
1599 std::unique_ptr<native_handle_t, std::function<void(native_handle_t*)>>;
1600 ScopedNativeHandle handle(native_handle_create(static_cast<int>(paths.size()), 0),
1601 [](native_handle_t* handle) {
1602 native_handle_close(handle);
1603 native_handle_delete(handle);
1604 });
1605 if (handle == nullptr) {
1606 MYLOGE("Could not create native_handle\n");
1607 return;
1608 }
1609
1610 for (size_t i = 0; i < paths.size(); i++) {
1611 MYLOGI("Calling IDumpstateDevice implementation using path %s\n", paths[i].c_str());
1612
1613 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
1614 open(paths[i].c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,
1615 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));
1616 if (fd < 0) {
1617 MYLOGE("Could not open file %s: %s\n", paths[i].c_str(), strerror(errno));
1618 return;
1619 }
1620 handle.get()->data[i] = fd.release();
1621 }
1622
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001623 // Given that bugreport is required to diagnose failures, it's better to
Wei Wang587eac92018-04-05 12:17:20 -07001624 // set an arbitrary amount of timeout for IDumpstateDevice than to block the
1625 // rest of bugreport. In the timeout case, we will kill dumpstate board HAL
1626 // and grab whatever dumped
1627 std::packaged_task<bool()>
1628 dumpstate_task([paths, dumpstate_device, &handle]() -> bool {
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001629 android::hardware::Return<void> status = dumpstate_device->dumpstateBoard(handle.get());
1630 if (!status.isOk()) {
1631 MYLOGE("dumpstateBoard failed: %s\n", status.description().c_str());
Wei Wang587eac92018-04-05 12:17:20 -07001632 return false;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001633 }
Wei Wang587eac92018-04-05 12:17:20 -07001634 return true;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001635 });
Wei Wang587eac92018-04-05 12:17:20 -07001636
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001637 auto result = dumpstate_task.get_future();
1638 std::thread(std::move(dumpstate_task)).detach();
Wei Wang587eac92018-04-05 12:17:20 -07001639
1640 constexpr size_t timeout_sec = 30;
1641 if (result.wait_for(std::chrono::seconds(timeout_sec)) != std::future_status::ready) {
1642 MYLOGE("dumpstateBoard timed out after %zus, killing dumpstate vendor HAL\n", timeout_sec);
1643 if (!android::base::SetProperty("ctl.interface_restart",
1644 android::base::StringPrintf("%s/default",
1645 IDumpstateDevice::descriptor))) {
1646 MYLOGE("Couldn't restart dumpstate HAL\n");
1647 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001648 }
Wei Wang587eac92018-04-05 12:17:20 -07001649 // Wait some time for init to kill dumpstate vendor HAL
1650 constexpr size_t killing_timeout_sec = 10;
1651 if (result.wait_for(std::chrono::seconds(killing_timeout_sec)) != std::future_status::ready) {
1652 MYLOGE("killing dumpstateBoard timed out after %zus, continue and "
1653 "there might be racing in content\n", killing_timeout_sec);
1654 }
1655
1656 auto file_sizes = std::make_unique<ssize_t[]>(paths.size());
1657 for (size_t i = 0; i < paths.size(); i++) {
1658 struct stat s;
1659 if (fstat(handle.get()->data[i], &s) == -1) {
1660 MYLOGE("Failed to fstat %s: %s\n", kDumpstateBoardFiles[i].c_str(),
1661 strerror(errno));
1662 file_sizes[i] = -1;
1663 continue;
1664 }
1665 file_sizes[i] = s.st_size;
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001666 }
1667
1668 for (size_t i = 0; i < paths.size(); i++) {
1669 if (file_sizes[i] == -1) {
1670 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07001671 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001672 if (file_sizes[i] == 0) {
Jie Song9fbfad02017-06-20 16:29:42 -07001673 MYLOGE("Ignoring empty %s\n", kDumpstateBoardFiles[i].c_str());
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001674 continue;
Jie Song9fbfad02017-06-20 16:29:42 -07001675 }
Luis Hector Chavez7aecd382018-03-19 11:16:59 -07001676 AddZipEntry(kDumpstateBoardFiles[i], paths[i]);
Jie Song9fbfad02017-06-20 16:29:42 -07001677 }
1678
Felipe Lemed8b94e52016-12-08 10:21:44 -08001679 printf("*** See dumpstate-board.txt entry ***\n");
Felipe Leme6f674ae2016-11-18 17:10:33 -08001680}
1681
Nandana Dutt12ae14a2019-01-09 10:35:53 +00001682static void ShowUsage() {
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001683 fprintf(stderr,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001684 "usage: dumpstate [-h] [-b soundfile] [-e soundfile] [-o file] [-d] [-p] "
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001685 "[-z]] [-s] [-S] [-q] [-B] [-P] [-R] [-V version]\n"
1686 " -h: display this help message\n"
1687 " -b: play sound file instead of vibrate, at beginning of job\n"
1688 " -e: play sound file instead of vibrate, at end of job\n"
1689 " -o: write to file (instead of stdout)\n"
1690 " -d: append date to filename (requires -o)\n"
1691 " -p: capture screenshot to filename.png (requires -o)\n"
1692 " -z: generate zipped file (requires -o)\n"
1693 " -s: write output to control socket (for init)\n"
Takuya Ogawa47f644e2017-12-20 18:09:09 +09001694 " -S: write file location to control socket (for init; requires -o and -z)\n"
Felipe Leme4a0db9f2016-09-28 09:35:01 -07001695 " -q: disable vibrate\n"
1696 " -B: send broadcast when finished (requires -o)\n"
1697 " -P: send broadcast when started and update system properties on "
1698 "progress (requires -o and -B)\n"
1699 " -R: take bugreport in remote mode (requires -o, -z, -d and -B, "
1700 "shouldn't be used with -P)\n"
Nandana Dutt235864b2019-01-22 12:10:16 +00001701 " -w: start binder service and make it wait for a call to startBugreport\n"
Felipe Lemed071c682016-10-20 16:48:00 -07001702 " -v: prints the dumpstate header and exit\n");
Colin Crossf45fa6b2012-03-26 12:38:26 -07001703}
1704
Wei Liuf87959e2016-08-26 14:51:42 -07001705static void register_sig_handler() {
Luis Hector Chavez558e1ef2018-03-22 15:39:17 -07001706 signal(SIGPIPE, SIG_IGN);
Wei Liuf87959e2016-08-26 14:51:42 -07001707}
1708
Felipe Leme1d486fe2016-10-14 18:06:47 -07001709bool Dumpstate::FinishZipFile() {
Felipe Leme9a523ae2016-10-20 15:10:33 -07001710 std::string entry_name = base_name_ + "-" + name_ + ".txt";
Felipe Leme1d486fe2016-10-14 18:06:47 -07001711 MYLOGD("Adding main entry (%s) from %s to .zip bugreport\n", entry_name.c_str(),
Felipe Leme9a523ae2016-10-20 15:10:33 -07001712 tmp_path_.c_str());
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07001713 // Final timestamp
1714 char date[80];
1715 time_t the_real_now_please_stand_up = time(nullptr);
1716 strftime(date, sizeof(date), "%Y/%m/%d %H:%M:%S", localtime(&the_real_now_please_stand_up));
Felipe Leme7447d7c2016-11-03 18:12:22 -07001717 MYLOGD("dumpstate id %d finished around %s (%ld s)\n", ds.id_, date,
Felipe Lemebbaf3c12016-10-11 14:32:25 -07001718 the_real_now_please_stand_up - ds.now_);
Felipe Leme5b9d3bf2016-08-16 17:20:21 -07001719
Felipe Leme9a523ae2016-10-20 15:10:33 -07001720 if (!ds.AddZipEntry(entry_name, tmp_path_)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001721 MYLOGE("Failed to add text entry to .zip file\n");
Felipe Leme1e9edc62015-12-21 16:02:13 -08001722 return false;
1723 }
Felipe Leme1d486fe2016-10-14 18:06:47 -07001724 if (!AddTextZipEntry("main_entry.txt", entry_name)) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001725 MYLOGE("Failed to add main_entry.txt to .zip file\n");
Felipe Leme111b9d02016-02-03 09:28:24 -08001726 return false;
Felipe Leme809d74e2016-02-02 12:57:00 -08001727 }
Felipe Leme1e9edc62015-12-21 16:02:13 -08001728
Felipe Leme0f3fb202016-06-10 17:10:53 -07001729 // Add log file (which contains stderr output) to zip...
1730 fprintf(stderr, "dumpstate_log.txt entry on zip file logged up to here\n");
Felipe Leme9a523ae2016-10-20 15:10:33 -07001731 if (!ds.AddZipEntry("dumpstate_log.txt", ds.log_path_.c_str())) {
Felipe Leme0f3fb202016-06-10 17:10:53 -07001732 MYLOGE("Failed to add dumpstate log to .zip file\n");
1733 return false;
1734 }
Nandana Dutt979388e2018-11-30 16:48:55 +00001735 // TODO: Should truncate the existing file.
1736 // ... and re-open it for further logging.
Felipe Leme9a523ae2016-10-20 15:10:33 -07001737 redirect_to_existing_file(stderr, const_cast<char*>(ds.log_path_.c_str()));
Felipe Leme0f3fb202016-06-10 17:10:53 -07001738 fprintf(stderr, "\n");
1739
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07001740 int32_t err = zip_writer_->Finish();
Felipe Leme1d486fe2016-10-14 18:06:47 -07001741 if (err != 0) {
Felipe Lemec6bc8bc2016-10-27 15:58:27 -07001742 MYLOGE("zip_writer_->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
Felipe Leme1e9edc62015-12-21 16:02:13 -08001743 return false;
1744 }
1745
Felipe Leme1d486fe2016-10-14 18:06:47 -07001746 // TODO: remove once FinishZipFile() is automatically handled by Dumpstate's destructor.
1747 ds.zip_file.reset(nullptr);
1748
Felipe Lemee9d2c542016-11-15 11:48:26 -08001749 MYLOGD("Removing temporary file %s\n", tmp_path_.c_str())
Nandana Dutt16d1aee2019-02-15 16:13:53 +00001750 android::os::UnlinkAndLogOnError(tmp_path_);
Felipe Lemec4eee562016-04-21 15:42:55 -07001751
Felipe Leme1e9edc62015-12-21 16:02:13 -08001752 return true;
1753}
Felipe Leme6e01fa62015-11-11 19:35:14 -08001754
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07001755static std::string SHA256_file_hash(const std::string& filepath) {
Andreas Gampe27cd7b22016-07-18 18:24:05 -07001756 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK
1757 | O_CLOEXEC | O_NOFOLLOW)));
Andreas Gampeaff68432016-07-18 18:01:27 -07001758 if (fd == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001759 MYLOGE("open(%s): %s\n", filepath.c_str(), strerror(errno));
Yi Kong19d5c002018-07-20 13:39:55 -07001760 return nullptr;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001761 }
1762
1763 SHA256_CTX ctx;
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001764 SHA256_Init(&ctx);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001765
1766 std::vector<uint8_t> buffer(65536);
1767 while (1) {
1768 ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd.get(), buffer.data(), buffer.size()));
1769 if (bytes_read == 0) {
1770 break;
1771 } else if (bytes_read == -1) {
Felipe Lemecbce55d2016-02-08 09:53:18 -08001772 MYLOGE("read(%s): %s\n", filepath.c_str(), strerror(errno));
Yi Kong19d5c002018-07-20 13:39:55 -07001773 return nullptr;
Michal Karpinski4db754f2015-12-11 18:04:32 +00001774 }
1775
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001776 SHA256_Update(&ctx, buffer.data(), bytes_read);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001777 }
1778
Elliott Hughesc4dc1412016-04-12 16:28:31 -07001779 uint8_t hash[SHA256_DIGEST_LENGTH];
1780 SHA256_Final(hash, &ctx);
1781
1782 char hash_buffer[SHA256_DIGEST_LENGTH * 2 + 1];
1783 for(size_t i = 0; i < SHA256_DIGEST_LENGTH; i++) {
Michal Karpinskicbbdf732016-01-07 20:45:02 +00001784 sprintf(hash_buffer + (i * 2), "%02x", hash[i]);
Michal Karpinski4db754f2015-12-11 18:04:32 +00001785 }
1786 hash_buffer[sizeof(hash_buffer) - 1] = 0;
1787 return std::string(hash_buffer);
1788}
1789
Felipe Lemea4ef1f02017-02-15 17:27:40 -08001790static void SendBroadcast(const std::string& action, const std::vector<std::string>& args) {
1791 // clang-format off
1792 std::vector<std::string> am = {"/system/bin/cmd", "activity", "broadcast", "--user", "0",
1793 "--receiver-foreground", "--receiver-include-background", "-a", action};
1794 // clang-format on
Felipe Leme8d2410e2017-02-08 09:46:08 -08001795
1796 am.insert(am.end(), args.begin(), args.end());
1797
Felipe Leme8d2410e2017-02-08 09:46:08 -08001798 RunCommand("", am,
1799 CommandOptions::WithTimeout(20)
1800 .Log("Sending broadcast: '%s'\n")
1801 .Always()
1802 .DropRoot()
1803 .RedirectStderr()
1804 .Build());
1805}
1806
Felipe Leme35b8cf12017-02-10 15:47:29 -08001807static void Vibrate(int duration_ms) {
1808 // clang-format off
1809 RunCommand("", {"cmd", "vibrator", "vibrate", std::to_string(duration_ms), "dumpstate"},
1810 CommandOptions::WithTimeout(10)
1811 .Log("Vibrate: '%s'\n")
1812 .Always()
1813 .Build());
1814 // clang-format on
1815}
1816
Nandana Dutt979388e2018-11-30 16:48:55 +00001817static void MaybeResolveSymlink(std::string* path) {
1818 std::string resolved_path;
1819 if (android::base::Readlink(*path, &resolved_path)) {
1820 *path = resolved_path;
1821 }
1822}
1823
Nandana Dutt4be45d12018-09-26 15:04:23 +01001824/*
1825 * Prepares state like filename, screenshot path, etc in Dumpstate. Also initializes ZipWriter
1826 * if we are writing zip files and adds the version file.
1827 */
1828static void PrepareToWriteToFile() {
Nandana Dutt979388e2018-11-30 16:48:55 +00001829 MaybeResolveSymlink(&ds.bugreport_internal_dir_);
1830
Nandana Dutt4be45d12018-09-26 15:04:23 +01001831 std::string build_id = android::base::GetProperty("ro.build.id", "UNKNOWN_BUILD");
1832 std::string device_name = android::base::GetProperty("ro.product.name", "UNKNOWN_DEVICE");
Nandana Dutt9a76d202019-01-21 15:56:48 +00001833 ds.base_name_ = StringPrintf("bugreport-%s-%s", device_name.c_str(), build_id.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001834 if (ds.options_->do_add_date) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001835 char date[80];
1836 strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&ds.now_));
1837 ds.name_ = date;
1838 } else {
1839 ds.name_ = "undated";
1840 }
1841
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001842 if (ds.options_->telephony_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001843 ds.base_name_ += "-telephony";
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001844 } else if (ds.options_->wifi_only) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001845 ds.base_name_ += "-wifi";
1846 }
1847
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001848 if (ds.options_->do_fb) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001849 ds.screenshot_path_ = ds.GetPath(".png");
1850 }
1851 ds.tmp_path_ = ds.GetPath(".tmp");
1852 ds.log_path_ = ds.GetPath("-dumpstate_log-" + std::to_string(ds.pid_) + ".txt");
1853
Nandana Dutt54dbd672019-01-11 12:58:05 +00001854 std::string destination = ds.options_->bugreport_fd.get() != -1
1855 ? StringPrintf("[fd:%d]", ds.options_->bugreport_fd.get())
Nandana Dutt9a76d202019-01-21 15:56:48 +00001856 : ds.bugreport_internal_dir_.c_str();
Nandana Dutt4be45d12018-09-26 15:04:23 +01001857 MYLOGD(
1858 "Bugreport dir: %s\n"
1859 "Base name: %s\n"
1860 "Suffix: %s\n"
1861 "Log path: %s\n"
1862 "Temporary path: %s\n"
1863 "Screenshot path: %s\n",
Nandana Dutt9a76d202019-01-21 15:56:48 +00001864 destination.c_str(), ds.base_name_.c_str(), ds.name_.c_str(), ds.log_path_.c_str(),
1865 ds.tmp_path_.c_str(), ds.screenshot_path_.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01001866
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001867 if (ds.options_->do_zip_file) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001868 ds.path_ = ds.GetPath(".zip");
1869 MYLOGD("Creating initial .zip file (%s)\n", ds.path_.c_str());
1870 create_parent_dirs(ds.path_.c_str());
1871 ds.zip_file.reset(fopen(ds.path_.c_str(), "wb"));
1872 if (ds.zip_file == nullptr) {
1873 MYLOGE("fopen(%s, 'wb'): %s\n", ds.path_.c_str(), strerror(errno));
1874 } else {
1875 ds.zip_writer_.reset(new ZipWriter(ds.zip_file.get()));
1876 }
1877 ds.AddTextZipEntry("version.txt", ds.version_);
1878 }
1879}
1880
1881/*
1882 * Finalizes writing to the file by renaming or zipping the tmp file to the final location,
1883 * printing zipped file status, etc.
1884 */
1885static void FinalizeFile() {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001886 /* check if user changed the suffix using system properties */
1887 std::string name =
1888 android::base::GetProperty(android::base::StringPrintf("dumpstate.%d.name", ds.pid_), "");
1889 bool change_suffix = false;
1890 if (!name.empty()) {
1891 /* must whitelist which characters are allowed, otherwise it could cross directories */
1892 std::regex valid_regex("^[-_a-zA-Z0-9]+$");
1893 if (std::regex_match(name.c_str(), valid_regex)) {
1894 change_suffix = true;
1895 } else {
1896 MYLOGE("invalid suffix provided by user: %s\n", name.c_str());
1897 }
1898 }
1899 if (change_suffix) {
1900 MYLOGI("changing suffix from %s to %s\n", ds.name_.c_str(), name.c_str());
1901 ds.name_ = name;
1902 if (!ds.screenshot_path_.empty()) {
1903 std::string new_screenshot_path = ds.GetPath(".png");
1904 if (rename(ds.screenshot_path_.c_str(), new_screenshot_path.c_str())) {
1905 MYLOGE("rename(%s, %s): %s\n", ds.screenshot_path_.c_str(),
1906 new_screenshot_path.c_str(), strerror(errno));
1907 } else {
1908 ds.screenshot_path_ = new_screenshot_path;
1909 }
1910 }
1911 }
1912
1913 bool do_text_file = true;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001914 if (ds.options_->do_zip_file) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001915 if (!ds.FinishZipFile()) {
1916 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
1917 do_text_file = true;
1918 } else {
1919 do_text_file = false;
Nandana Dutt383d0c12018-11-30 15:54:56 +00001920 // If the user has changed the suffix, we need to change the zip file name.
1921 std::string new_path = ds.GetPath(".zip");
1922 if (ds.path_ != new_path) {
1923 MYLOGD("Renaming zip file from %s to %s\n", ds.path_.c_str(), new_path.c_str());
1924 if (rename(ds.path_.c_str(), new_path.c_str())) {
1925 MYLOGE("rename(%s, %s): %s\n", ds.path_.c_str(), new_path.c_str(),
1926 strerror(errno));
1927 } else {
1928 ds.path_ = new_path;
1929 }
1930 }
Nandana Dutt4be45d12018-09-26 15:04:23 +01001931 }
1932 }
1933 if (do_text_file) {
1934 ds.path_ = ds.GetPath(".txt");
1935 MYLOGD("Generating .txt bugreport at %s from %s\n", ds.path_.c_str(), ds.tmp_path_.c_str());
1936 if (rename(ds.tmp_path_.c_str(), ds.path_.c_str())) {
1937 MYLOGE("rename(%s, %s): %s\n", ds.tmp_path_.c_str(), ds.path_.c_str(), strerror(errno));
1938 ds.path_.clear();
1939 }
1940 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001941 if (ds.options_->use_control_socket) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001942 if (do_text_file) {
1943 dprintf(ds.control_socket_fd_,
1944 "FAIL:could not create zip file, check %s "
1945 "for more details\n",
1946 ds.log_path_.c_str());
1947 } else {
1948 dprintf(ds.control_socket_fd_, "OK:%s\n", ds.path_.c_str());
1949 }
1950 }
1951}
1952
1953/* Broadcasts that we are done with the bugreport */
1954static void SendBugreportFinishedBroadcast() {
Nandana Dutt979388e2018-11-30 16:48:55 +00001955 // TODO(b/111441001): use callback instead of broadcast.
Nandana Dutt9a76d202019-01-21 15:56:48 +00001956 if (!ds.path_.empty()) {
1957 MYLOGI("Final bugreport path: %s\n", ds.path_.c_str());
Nandana Dutt4be45d12018-09-26 15:04:23 +01001958 // clang-format off
1959
1960 std::vector<std::string> am_args = {
1961 "--receiver-permission", "android.permission.DUMP",
1962 "--ei", "android.intent.extra.ID", std::to_string(ds.id_),
1963 "--ei", "android.intent.extra.PID", std::to_string(ds.pid_),
1964 "--ei", "android.intent.extra.MAX", std::to_string(ds.progress_->GetMax()),
Nandana Dutt9a76d202019-01-21 15:56:48 +00001965 "--es", "android.intent.extra.BUGREPORT", ds.path_,
Nandana Dutt4be45d12018-09-26 15:04:23 +01001966 "--es", "android.intent.extra.DUMPSTATE_LOG", ds.log_path_
1967 };
1968 // clang-format on
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001969 if (ds.options_->do_fb) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001970 am_args.push_back("--es");
1971 am_args.push_back("android.intent.extra.SCREENSHOT");
1972 am_args.push_back(ds.screenshot_path_);
1973 }
Nandana Dutt15b89d72018-11-16 14:14:12 +00001974 if (!ds.options_->notification_title.empty()) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001975 am_args.push_back("--es");
1976 am_args.push_back("android.intent.extra.TITLE");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001977 am_args.push_back(ds.options_->notification_title);
1978 if (!ds.options_->notification_description.empty()) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001979 am_args.push_back("--es");
1980 am_args.push_back("android.intent.extra.DESCRIPTION");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001981 am_args.push_back(ds.options_->notification_description);
Nandana Dutt4be45d12018-09-26 15:04:23 +01001982 }
1983 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01001984 if (ds.options_->is_remote_mode) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01001985 am_args.push_back("--es");
1986 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
Nandana Dutt9a76d202019-01-21 15:56:48 +00001987 am_args.push_back(SHA256_file_hash(ds.path_));
Nandana Dutt4be45d12018-09-26 15:04:23 +01001988 SendBroadcast("com.android.internal.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
1989 } else {
1990 SendBroadcast("com.android.internal.intent.action.BUGREPORT_FINISHED", am_args);
1991 }
1992 } else {
1993 MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
1994 }
1995}
1996
Nandana Dutt58d72e22018-11-16 10:30:48 +00001997static inline const char* ModeToString(Dumpstate::BugreportMode mode) {
1998 switch (mode) {
1999 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2000 return "BUGREPORT_FULL";
2001 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
2002 return "BUGREPORT_INTERACTIVE";
2003 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
2004 return "BUGREPORT_REMOTE";
2005 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
2006 return "BUGREPORT_WEAR";
2007 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
2008 return "BUGREPORT_TELEPHONY";
2009 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
2010 return "BUGREPORT_WIFI";
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002011 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2012 return "BUGREPORT_DEFAULT";
Nandana Dutt58d72e22018-11-16 10:30:48 +00002013 }
2014}
2015
2016static void SetOptionsFromMode(Dumpstate::BugreportMode mode, Dumpstate::DumpOptions* options) {
Abhijeet Kaur8ca245e2018-12-12 10:34:21 +00002017 options->extra_options = ModeToString(mode);
Nandana Dutt58d72e22018-11-16 10:30:48 +00002018 switch (mode) {
2019 case Dumpstate::BugreportMode::BUGREPORT_FULL:
2020 options->do_broadcast = true;
2021 options->do_fb = true;
2022 break;
2023 case Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002024 // Currently, the dumpstate binder is only used by Shell to update progress.
2025 options->do_start_service = true;
2026 options->do_progress_updates = true;
2027 options->do_fb = false;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002028 options->do_broadcast = true;
2029 break;
2030 case Dumpstate::BugreportMode::BUGREPORT_REMOTE:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002031 options->do_vibrate = false;
2032 options->is_remote_mode = true;
2033 options->do_fb = false;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002034 options->do_broadcast = true;
2035 break;
2036 case Dumpstate::BugreportMode::BUGREPORT_WEAR:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002037 options->do_start_service = true;
2038 options->do_progress_updates = true;
2039 options->do_zip_file = true;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002040 options->do_fb = true;
2041 options->do_broadcast = true;
2042 break;
2043 case Dumpstate::BugreportMode::BUGREPORT_TELEPHONY:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002044 options->telephony_only = true;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002045 options->do_fb = true;
2046 options->do_broadcast = true;
2047 break;
2048 case Dumpstate::BugreportMode::BUGREPORT_WIFI:
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002049 options->wifi_only = true;
2050 options->do_zip_file = true;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002051 options->do_fb = true;
2052 options->do_broadcast = true;
2053 break;
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002054 case Dumpstate::BugreportMode::BUGREPORT_DEFAULT:
2055 break;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002056 }
2057}
2058
2059static Dumpstate::BugreportMode getBugreportModeFromProperty() {
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002060 // If the system property is not set, it's assumed to be a default bugreport.
2061 Dumpstate::BugreportMode mode = Dumpstate::BugreportMode::BUGREPORT_DEFAULT;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002062
2063 std::string extra_options = android::base::GetProperty(PROPERTY_EXTRA_OPTIONS, "");
2064 if (!extra_options.empty()) {
2065 // Framework uses a system property to override some command-line args.
2066 // Currently, it contains the type of the requested bugreport.
2067 if (extra_options == "bugreportplus") {
2068 mode = Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE;
Abhijeet Kaur904e0e02018-12-05 14:03:01 +00002069 } else if (extra_options == "bugreportfull") {
2070 mode = Dumpstate::BugreportMode::BUGREPORT_FULL;
Nandana Dutt58d72e22018-11-16 10:30:48 +00002071 } else if (extra_options == "bugreportremote") {
2072 mode = Dumpstate::BugreportMode::BUGREPORT_REMOTE;
2073 } else if (extra_options == "bugreportwear") {
2074 mode = Dumpstate::BugreportMode::BUGREPORT_WEAR;
2075 } else if (extra_options == "bugreporttelephony") {
2076 mode = Dumpstate::BugreportMode::BUGREPORT_TELEPHONY;
2077 } else if (extra_options == "bugreportwifi") {
2078 mode = Dumpstate::BugreportMode::BUGREPORT_WIFI;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002079 } else {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002080 MYLOGE("Unknown extra option: %s\n", extra_options.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002081 }
2082 // Reset the property
2083 android::base::SetProperty(PROPERTY_EXTRA_OPTIONS, "");
2084 }
Nandana Dutt58d72e22018-11-16 10:30:48 +00002085 return mode;
2086}
2087
2088// TODO: Move away from system properties when we have options passed via binder calls.
2089/* Sets runtime options from the system properties and then clears those properties. */
2090static void SetOptionsFromProperties(Dumpstate::DumpOptions* options) {
2091 Dumpstate::BugreportMode mode = getBugreportModeFromProperty();
2092 SetOptionsFromMode(mode, options);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002093
2094 options->notification_title = android::base::GetProperty(PROPERTY_EXTRA_TITLE, "");
2095 if (!options->notification_title.empty()) {
2096 // Reset the property
2097 android::base::SetProperty(PROPERTY_EXTRA_TITLE, "");
2098
Nandana Duttdd8cca32018-11-14 10:10:29 +00002099 options->notification_description =
2100 android::base::GetProperty(PROPERTY_EXTRA_DESCRIPTION, "");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002101 if (!options->notification_description.empty()) {
2102 // Reset the property
2103 android::base::SetProperty(PROPERTY_EXTRA_DESCRIPTION, "");
2104 }
2105 MYLOGD("notification (title: %s, description: %s)\n", options->notification_title.c_str(),
2106 options->notification_description.c_str());
2107 }
2108}
2109
Nandana Dutt58d72e22018-11-16 10:30:48 +00002110static void LogDumpOptions(const Dumpstate::DumpOptions& options) {
2111 MYLOGI("do_zip_file: %d\n", options.do_zip_file);
2112 MYLOGI("do_add_date: %d\n", options.do_add_date);
2113 MYLOGI("do_vibrate: %d\n", options.do_vibrate);
2114 MYLOGI("use_socket: %d\n", options.use_socket);
2115 MYLOGI("use_control_socket: %d\n", options.use_control_socket);
2116 MYLOGI("do_fb: %d\n", options.do_fb);
2117 MYLOGI("do_broadcast: %d\n", options.do_broadcast);
2118 MYLOGI("is_remote_mode: %d\n", options.is_remote_mode);
2119 MYLOGI("show_header_only: %d\n", options.show_header_only);
2120 MYLOGI("do_start_service: %d\n", options.do_start_service);
2121 MYLOGI("telephony_only: %d\n", options.telephony_only);
2122 MYLOGI("wifi_only: %d\n", options.wifi_only);
2123 MYLOGI("do_progress_updates: %d\n", options.do_progress_updates);
Nandana Dutt54dbd672019-01-11 12:58:05 +00002124 MYLOGI("fd: %d\n", options.bugreport_fd.get());
Nandana Dutt58d72e22018-11-16 10:30:48 +00002125 MYLOGI("extra_options: %s\n", options.extra_options.c_str());
2126 MYLOGI("args: %s\n", options.args.c_str());
2127 MYLOGI("notification_title: %s\n", options.notification_title.c_str());
2128 MYLOGI("notification_description: %s\n", options.notification_description.c_str());
2129}
2130
Nandana Dutt54dbd672019-01-11 12:58:05 +00002131void Dumpstate::DumpOptions::Initialize(BugreportMode bugreport_mode,
2132 const android::base::unique_fd& bugreport_fd_in,
2133 const android::base::unique_fd& screenshot_fd_in) {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002134 // In the new API world, date is always added; output is always a zip file.
2135 // TODO(111441001): remove these options once they are obsolete.
2136 do_add_date = true;
2137 do_zip_file = true;
2138
Nandana Dutt54dbd672019-01-11 12:58:05 +00002139 // Duplicate the fds because the passed in fds don't outlive the binder transaction.
2140 bugreport_fd.reset(dup(bugreport_fd_in.get()));
2141 screenshot_fd.reset(dup(screenshot_fd_in.get()));
Nandana Dutt58d72e22018-11-16 10:30:48 +00002142
2143 extra_options = ModeToString(bugreport_mode);
2144 SetOptionsFromMode(bugreport_mode, this);
2145}
2146
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002147Dumpstate::RunStatus Dumpstate::DumpOptions::Initialize(int argc, char* argv[]) {
2148 RunStatus status = RunStatus::OK;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002149 int c;
Nandana Dutt235864b2019-01-22 12:10:16 +00002150 while ((c = getopt(argc, argv, "dho:svqzpPBRSV:w")) != -1) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002151 switch (c) {
2152 // clang-format off
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002153 case 'd': do_add_date = true; break;
2154 case 'z': do_zip_file = true; break;
Nandana Dutt9a76d202019-01-21 15:56:48 +00002155 // o=use_outfile not supported anymore.
2156 // TODO(b/111441001): Remove when all callers have migrated.
2157 case 'o': break;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002158 case 's': use_socket = true; break;
2159 case 'S': use_control_socket = true; break;
2160 case 'v': show_header_only = true; break;
2161 case 'q': do_vibrate = false; break;
2162 case 'p': do_fb = true; break;
2163 case 'P': do_progress_updates = true; break;
2164 case 'R': is_remote_mode = true; break;
2165 case 'B': do_broadcast = true; break;
2166 case 'V': break; // compatibility no-op
Nandana Dutt235864b2019-01-22 12:10:16 +00002167 case 'w':
2168 // This was already processed
2169 break;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002170 case 'h':
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002171 status = RunStatus::HELP;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002172 break;
2173 default:
2174 fprintf(stderr, "Invalid option: %c\n", c);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002175 status = RunStatus::INVALID_INPUT;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002176 break;
2177 // clang-format on
2178 }
2179 }
Felipe Leme8fecfdd2016-02-09 10:40:07 -08002180
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002181 // TODO: use helper function to convert argv into a string
2182 for (int i = 0; i < argc; i++) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002183 args += argv[i];
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002184 if (i < argc - 1) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002185 args += " ";
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002186 }
2187 }
2188
2189 // Reset next index used by getopt so this can be called multiple times, for eg, in tests.
2190 optind = 1;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002191
2192 SetOptionsFromProperties(this);
2193 return status;
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002194}
2195
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002196bool Dumpstate::DumpOptions::ValidateOptions() const {
Nandana Dutt54dbd672019-01-11 12:58:05 +00002197 if (bugreport_fd.get() != -1 && !do_zip_file) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002198 return false;
2199 }
2200
Nandana Dutt9a76d202019-01-21 15:56:48 +00002201 if ((do_zip_file || do_add_date || do_progress_updates || do_broadcast) && !OutputToFile()) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002202 return false;
2203 }
2204
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002205 if (use_control_socket && !do_zip_file) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002206 return false;
2207 }
2208
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002209 if (do_progress_updates && !do_broadcast) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002210 return false;
2211 }
2212
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002213 if (is_remote_mode && (do_progress_updates || !do_broadcast || !do_zip_file || !do_add_date)) {
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002214 return false;
2215 }
2216 return true;
2217}
2218
Nandana Dutt197661d2018-11-16 16:40:21 +00002219void Dumpstate::SetOptions(std::unique_ptr<DumpOptions> options) {
2220 options_ = std::move(options);
2221}
2222
Nandana Duttd2f5f082019-01-18 17:13:52 +00002223Dumpstate::RunStatus Dumpstate::Run(int32_t calling_uid, const std::string& calling_package) {
2224 Dumpstate::RunStatus status = RunInternal(calling_uid, calling_package);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002225 if (listener_ != nullptr) {
2226 switch (status) {
2227 case Dumpstate::RunStatus::OK:
Nandana Duttcc4ead82019-01-23 08:29:23 +00002228 listener_->onFinished();
Nandana Duttbabf6c72019-01-15 14:11:12 +00002229 break;
2230 case Dumpstate::RunStatus::HELP:
2231 break;
2232 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002233 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_INVALID_INPUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002234 break;
2235 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002236 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_RUNTIME_ERROR);
2237 break;
2238 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
2239 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_DENIED_CONSENT);
2240 break;
2241 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
2242 listener_->onError(IDumpstateListener::BUGREPORT_ERROR_USER_CONSENT_TIMED_OUT);
Nandana Duttbabf6c72019-01-15 14:11:12 +00002243 break;
2244 }
2245 }
2246 return status;
2247}
2248
Nandana Dutt979388e2018-11-30 16:48:55 +00002249/*
2250 * Dumps relevant information to a bugreport based on the given options.
2251 *
2252 * The bugreport can be dumped to a file or streamed to a socket.
2253 *
2254 * How dumping to file works:
2255 * stdout is redirected to a temporary file. This will later become the main bugreport entry.
2256 * stderr is redirected a log file.
2257 *
2258 * The temporary bugreport is then populated via printfs, dumping contents of files and
2259 * output of commands to stdout.
2260 *
2261 * If zipping, the temporary bugreport file is added to the zip archive. Else it's renamed to final
2262 * text file.
2263 *
2264 * If zipping, a bunch of other files and dumps also get added to the zip archive. The log file also
2265 * gets added to the archive.
2266 *
Nandana Dutt9a76d202019-01-21 15:56:48 +00002267 * Bugreports are first generated in a local directory and later copied to the caller's fd if
2268 * supplied.
Nandana Dutt979388e2018-11-30 16:48:55 +00002269 */
Nandana Duttd2f5f082019-01-18 17:13:52 +00002270Dumpstate::RunStatus Dumpstate::RunInternal(int32_t calling_uid,
2271 const std::string& calling_package) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002272 LogDumpOptions(*options_);
Nandana Dutt197661d2018-11-16 16:40:21 +00002273 if (!options_->ValidateOptions()) {
Nandana Dutt58d72e22018-11-16 10:30:48 +00002274 MYLOGE("Invalid options specified\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002275 return RunStatus::INVALID_INPUT;
2276 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002277 /* set as high priority, and protect from OOM killer */
2278 setpriority(PRIO_PROCESS, 0, -20);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002279
Felipe Lemed071c682016-10-20 16:48:00 -07002280 FILE* oom_adj = fopen("/proc/self/oom_score_adj", "we");
Colin Crossf45fa6b2012-03-26 12:38:26 -07002281 if (oom_adj) {
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002282 fputs("-1000", oom_adj);
Colin Crossf45fa6b2012-03-26 12:38:26 -07002283 fclose(oom_adj);
Wei Wang9c1f9bb2016-06-28 14:32:35 -07002284 } else {
2285 /* fallback to kernels <= 2.6.35 */
2286 oom_adj = fopen("/proc/self/oom_adj", "we");
2287 if (oom_adj) {
2288 fputs("-17", oom_adj);
2289 fclose(oom_adj);
2290 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002291 }
2292
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002293 if (version_ == VERSION_DEFAULT) {
2294 version_ = VERSION_CURRENT;
Michal Karpinski4db754f2015-12-11 18:04:32 +00002295 }
2296
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002297 if (version_ != VERSION_CURRENT && version_ != VERSION_SPLIT_ANR) {
Vishnu Nair64afc022018-02-01 15:29:34 -08002298 MYLOGE("invalid version requested ('%s'); suppported values are: ('%s', '%s', '%s')\n",
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002299 version_.c_str(), VERSION_DEFAULT.c_str(), VERSION_CURRENT.c_str(),
Vishnu Nair64afc022018-02-01 15:29:34 -08002300 VERSION_SPLIT_ANR.c_str());
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002301 return RunStatus::INVALID_INPUT;
Felipe Lemed071c682016-10-20 16:48:00 -07002302 }
2303
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002304 if (options_->show_header_only) {
2305 PrintHeader();
2306 return RunStatus::OK;
Felipe Lemed071c682016-10-20 16:48:00 -07002307 }
2308
Nandana Duttd2f5f082019-01-18 17:13:52 +00002309 if (options_->bugreport_fd.get() != -1) {
2310 // If the output needs to be copied over to the caller's fd, get user consent.
2311 android::String16 package(calling_package.c_str());
2312 CheckUserConsent(calling_uid, package);
2313 }
2314
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002315 // Redirect output if needed
Nandana Dutt9a76d202019-01-21 15:56:48 +00002316 bool is_redirecting = options_->OutputToFile();
Felipe Leme7447d7c2016-11-03 18:12:22 -07002317
2318 // TODO: temporarily set progress until it's part of the Dumpstate constructor
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002319 std::string stats_path =
Nandana Dutt979388e2018-11-30 16:48:55 +00002320 is_redirecting
2321 ? android::base::StringPrintf("%s/dumpstate-stats.txt", bugreport_internal_dir_.c_str())
2322 : "";
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002323 progress_.reset(new Progress(stats_path));
Felipe Leme7447d7c2016-11-03 18:12:22 -07002324
Felipe Lemed071c682016-10-20 16:48:00 -07002325 /* gets the sequential id */
Felipe Leme7447d7c2016-11-03 18:12:22 -07002326 uint32_t last_id = android::base::GetIntProperty(PROPERTY_LAST_ID, 0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002327 id_ = ++last_id;
Felipe Lemed071c682016-10-20 16:48:00 -07002328 android::base::SetProperty(PROPERTY_LAST_ID, std::to_string(last_id));
2329
2330 MYLOGI("begin\n");
2331
Felipe Leme6ae5c4f2017-01-10 14:13:22 -08002332 register_sig_handler();
Felipe Lemed071c682016-10-20 16:48:00 -07002333
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002334 // TODO(b/111441001): maybe skip if already started?
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002335 if (options_->do_start_service) {
Felipe Leme75876a22016-10-27 16:31:27 -07002336 MYLOGI("Starting 'dumpstate' service\n");
2337 android::status_t ret;
2338 if ((ret = android::os::DumpstateService::Start()) != android::OK) {
2339 MYLOGE("Unable to start DumpstateService: %d\n", ret);
2340 }
2341 }
2342
Felipe Lemef0292972016-11-22 13:57:05 -08002343 if (PropertiesHelper::IsDryRun()) {
Felipe Lemed071c682016-10-20 16:48:00 -07002344 MYLOGI("Running on dry-run mode (to disable it, call 'setprop dumpstate.dry_run false')\n");
2345 }
2346
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002347 MYLOGI("dumpstate info: id=%d, args='%s', extra_options= %s)\n", id_, options_->args.c_str(),
2348 options_->extra_options.c_str());
Felipe Lemed071c682016-10-20 16:48:00 -07002349
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002350 MYLOGI("bugreport format version: %s\n", version_.c_str());
Felipe Leme809d74e2016-02-02 12:57:00 -08002351
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002352 do_early_screenshot_ = options_->do_progress_updates;
Felipe Lemee338bf62015-12-07 14:03:50 -08002353
Christopher Ferrised9354f2014-10-01 17:35:01 -07002354 // If we are going to use a socket, do it as early as possible
2355 // to avoid timeouts from bugreport.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002356 if (options_->use_socket) {
Christopher Ferrised9354f2014-10-01 17:35:01 -07002357 redirect_to_socket(stdout, "dumpstate");
2358 }
2359
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002360 if (options_->use_control_socket) {
Felipe Leme2628e9e2016-04-12 16:36:51 -07002361 MYLOGD("Opening control socket\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002362 control_socket_fd_ = open_socket("dumpstate");
2363 options_->do_progress_updates = 1;
Felipe Leme2628e9e2016-04-12 16:36:51 -07002364 }
2365
Felipe Leme71bbfc52015-11-23 14:14:51 -08002366 if (is_redirecting) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002367 PrepareToWriteToFile();
Felipe Leme1e9edc62015-12-21 16:02:13 -08002368
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002369 if (options_->do_progress_updates) {
2370 if (options_->do_broadcast) {
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07002371 // clang-format off
2372 std::vector<std::string> am_args = {
Felipe Lemea4ef1f02017-02-15 17:27:40 -08002373 "--receiver-permission", "android.permission.DUMP",
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002374 "--es", "android.intent.extra.NAME", name_,
2375 "--ei", "android.intent.extra.ID", std::to_string(id_),
2376 "--ei", "android.intent.extra.PID", std::to_string(pid_),
2377 "--ei", "android.intent.extra.MAX", std::to_string(progress_->GetMax()),
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07002378 };
2379 // clang-format on
Felipe Lemea4ef1f02017-02-15 17:27:40 -08002380 SendBroadcast("com.android.internal.intent.action.BUGREPORT_STARTED", am_args);
Felipe Lemedcd1f0d2016-08-04 12:48:50 -07002381 }
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002382 if (options_->use_control_socket) {
2383 dprintf(control_socket_fd_, "BEGIN:%s\n", path_.c_str());
Felipe Lemeaabfcae2016-07-29 09:49:04 -07002384 }
Felipe Leme71bbfc52015-11-23 14:14:51 -08002385 }
2386 }
2387
Nick Kralevichf3599b32016-01-25 15:05:16 -08002388 /* read /proc/cmdline before dropping root */
2389 FILE *cmdline = fopen("/proc/cmdline", "re");
2390 if (cmdline) {
2391 fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
2392 fclose(cmdline);
2393 }
2394
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002395 if (options_->do_vibrate) {
Felipe Leme35b8cf12017-02-10 15:47:29 -08002396 Vibrate(150);
John Michelau1f794c42012-09-17 11:20:19 -05002397 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002398
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002399 if (options_->do_fb && do_early_screenshot_) {
2400 if (screenshot_path_.empty()) {
Felipe Leme3634a1e2015-12-09 10:11:47 -08002401 // should not have happened
Felipe Lemecbce55d2016-02-08 09:53:18 -08002402 MYLOGE("INTERNAL ERROR: skipping early screenshot because path was not set\n");
Felipe Leme3634a1e2015-12-09 10:11:47 -08002403 } else {
Felipe Lemecbce55d2016-02-08 09:53:18 -08002404 MYLOGI("taking early screenshot\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002405 TakeScreenshot();
Felipe Lemee338bf62015-12-07 14:03:50 -08002406 }
2407 }
2408
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002409 if (options_->do_zip_file && zip_file != nullptr) {
2410 if (chown(path_.c_str(), AID_SHELL, AID_SHELL)) {
2411 MYLOGE("Unable to change ownership of zip file %s: %s\n", path_.c_str(),
Felipe Leme1d486fe2016-10-14 18:06:47 -07002412 strerror(errno));
Felipe Leme1e9edc62015-12-21 16:02:13 -08002413 }
2414 }
2415
Nandana Dutt3f8c7172018-09-25 12:01:54 +01002416 int dup_stdout_fd;
2417 int dup_stderr_fd;
Felipe Leme71bbfc52015-11-23 14:14:51 -08002418 if (is_redirecting) {
Nandana Dutt979388e2018-11-30 16:48:55 +00002419 // Redirect stderr to log_path_ for debugging.
Vishnu Nair20cf5032018-01-05 13:15:49 -08002420 TEMP_FAILURE_RETRY(dup_stderr_fd = dup(fileno(stderr)));
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002421 redirect_to_file(stderr, const_cast<char*>(log_path_.c_str()));
2422 if (chown(log_path_.c_str(), AID_SHELL, AID_SHELL)) {
2423 MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n", log_path_.c_str(),
2424 strerror(errno));
Felipe Leme6fe9db62016-02-12 09:04:16 -08002425 }
Nandana Dutt979388e2018-11-30 16:48:55 +00002426
2427 // Redirect stdout to tmp_path_. This is the main bugreport entry and will be
2428 // moved into zip file later, if zipping.
Vishnu Nair20cf5032018-01-05 13:15:49 -08002429 TEMP_FAILURE_RETRY(dup_stdout_fd = dup(fileno(stdout)));
Nandana Dutt979388e2018-11-30 16:48:55 +00002430 // TODO: why not write to a file instead of stdout to overcome this problem?
Felipe Leme6e01fa62015-11-11 19:35:14 -08002431 /* TODO: rather than generating a text file now and zipping it later,
2432 it would be more efficient to redirect stdout to the zip entry
2433 directly, but the libziparchive doesn't support that option yet. */
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002434 redirect_to_file(stdout, const_cast<char*>(tmp_path_.c_str()));
2435 if (chown(tmp_path_.c_str(), AID_SHELL, AID_SHELL)) {
Felipe Leme6fe9db62016-02-12 09:04:16 -08002436 MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002437 tmp_path_.c_str(), strerror(errno));
Felipe Leme6fe9db62016-02-12 09:04:16 -08002438 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002439 }
Felipe Lemed8b94e52016-12-08 10:21:44 -08002440
2441 // Don't buffer stdout
2442 setvbuf(stdout, nullptr, _IONBF, 0);
2443
Felipe Leme608385d2016-02-01 10:35:38 -08002444 // NOTE: there should be no stdout output until now, otherwise it would break the header.
2445 // In particular, DurationReport objects should be created passing 'title, NULL', so their
Felipe Lemecbce55d2016-02-08 09:53:18 -08002446 // duration is logged into MYLOG instead.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002447 PrintHeader();
Colin Crossf45fa6b2012-03-26 12:38:26 -07002448
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002449 if (options_->telephony_only) {
Jayachandran Ca94c7172017-06-10 15:08:12 -07002450 DumpstateTelephonyOnly();
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002451 DumpstateBoard();
2452 } else if (options_->wifi_only) {
mukesh agrawal253dad42018-01-23 21:59:59 -08002453 DumpstateWifiOnly();
Felipe Leme6ec6ac42017-01-10 15:29:53 -08002454 } else {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002455 // Dump state for the default case. This also drops root.
2456 if (!DumpstateDefault()) {
2457 // Something went wrong.
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002458 return RunStatus::ERROR;
Felipe Leme6ec6ac42017-01-10 15:29:53 -08002459 }
Zhengyin Qian068ecc72016-08-10 16:48:14 -07002460 }
Felipe Leme71a74ac2016-03-17 15:43:25 -07002461
Felipe Leme55b42a62015-11-10 17:39:08 -08002462 /* close output if needed */
Felipe Leme71bbfc52015-11-23 14:14:51 -08002463 if (is_redirecting) {
Vishnu Nair20cf5032018-01-05 13:15:49 -08002464 TEMP_FAILURE_RETRY(dup2(dup_stdout_fd, fileno(stdout)));
Colin Crossf45fa6b2012-03-26 12:38:26 -07002465 }
2466
Nandana Duttd2f5f082019-01-18 17:13:52 +00002467 // Rename, and/or zip the (now complete) .tmp file within the internal directory.
Nandana Dutt9a76d202019-01-21 15:56:48 +00002468 if (options_->OutputToFile()) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002469 FinalizeFile();
Colin Crossf45fa6b2012-03-26 12:38:26 -07002470 }
2471
Nandana Duttd2f5f082019-01-18 17:13:52 +00002472 // Share the final file with the caller if the user has consented.
2473 Dumpstate::RunStatus status = Dumpstate::RunStatus::OK;
2474 if (options_->bugreport_fd.get() != -1) {
2475 status = CopyBugreportIfUserConsented();
2476 if (status != Dumpstate::RunStatus::OK &&
2477 status != Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
2478 // Do an early return if there were errors. We make an exception for consent
2479 // timing out because it's possible the user got distracted. In this case the
2480 // bugreport is not shared but made available for manual retrieval.
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002481 MYLOGI("User denied consent. Returning\n");
Nandana Duttd2f5f082019-01-18 17:13:52 +00002482 return status;
2483 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002484 if (options_->do_fb && options_->screenshot_fd.get() != -1) {
Nandana Dutte78c3d72019-01-29 16:10:45 +00002485 bool copy_succeeded = android::os::CopyFileToFd(screenshot_path_,
2486 options_->screenshot_fd.get());
2487 if (copy_succeeded) {
2488 android::os::UnlinkAndLogOnError(screenshot_path_);
2489 }
2490 }
Nandana Dutt16d1aee2019-02-15 16:13:53 +00002491 if (status == Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT) {
2492 MYLOGI(
2493 "Did not receive user consent yet."
2494 " Will not copy the bugreport artifacts to caller.\n");
2495 // TODO(b/111441001):
2496 // 1. cancel outstanding requests
2497 // 2. check for result more frequently
2498 }
Nandana Duttd2f5f082019-01-18 17:13:52 +00002499 }
2500
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08002501 /* vibrate a few but shortly times to let user know it's finished */
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002502 if (options_->do_vibrate) {
Takuya Ogawa47f644e2017-12-20 18:09:09 +09002503 for (int i = 0; i < 3; i++) {
2504 Vibrate(75);
2505 usleep((75 + 50) * 1000);
2506 }
Felipe Lemecc2a2fa2016-02-25 14:02:44 -08002507 }
2508
Jeff Brown1dc94e32014-09-11 14:15:27 -07002509 /* tell activity manager we're done */
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002510 if (options_->do_broadcast) {
Nandana Dutt4be45d12018-09-26 15:04:23 +01002511 SendBugreportFinishedBroadcast();
Nandana Duttbabf6c72019-01-15 14:11:12 +00002512 // Note that listener_ is notified in Run();
Jeff Sharkey27f9e6d2013-03-13 15:45:50 -07002513 }
2514
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002515 MYLOGD("Final progress: %d/%d (estimated %d)\n", progress_->Get(), progress_->GetMax(),
2516 progress_->GetInitialMax());
2517 progress_->Save();
2518 MYLOGI("done (id %d)\n", id_);
Colin Crossf45fa6b2012-03-26 12:38:26 -07002519
Felipe Leme107a05f2016-03-08 15:11:15 -08002520 if (is_redirecting) {
Vishnu Nair20cf5032018-01-05 13:15:49 -08002521 TEMP_FAILURE_RETRY(dup2(dup_stderr_fd, fileno(stderr)));
Felipe Leme107a05f2016-03-08 15:11:15 -08002522 }
2523
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002524 if (options_->use_control_socket && control_socket_fd_ != -1) {
Felipe Lemee844a9d2016-09-21 15:01:39 -07002525 MYLOGD("Closing control socket\n");
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002526 close(control_socket_fd_);
Felipe Leme2628e9e2016-04-12 16:36:51 -07002527 }
2528
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002529 tombstone_data_.clear();
2530 anr_data_.clear();
Narayan Kamath6b9516c2017-10-27 11:15:51 +01002531
Nandana Duttd2f5f082019-01-18 17:13:52 +00002532 return (consent_callback_ != nullptr &&
2533 consent_callback_->getResult() == UserConsentResult::UNAVAILABLE)
2534 ? USER_CONSENT_TIMED_OUT
2535 : RunStatus::OK;
2536}
2537
2538void Dumpstate::CheckUserConsent(int32_t calling_uid, const android::String16& calling_package) {
2539 consent_callback_ = new ConsentCallback();
2540 const String16 incidentcompanion("incidentcompanion");
2541 sp<android::IBinder> ics(defaultServiceManager()->getService(incidentcompanion));
2542 if (ics != nullptr) {
2543 MYLOGD("Checking user consent via incidentcompanion service\n");
2544 android::interface_cast<android::os::IIncidentCompanion>(ics)->authorizeReport(
2545 calling_uid, calling_package, 0x1 /* FLAG_CONFIRMATION_DIALOG */,
2546 consent_callback_.get());
2547 } else {
2548 MYLOGD("Unable to check user consent; incidentcompanion service unavailable\n");
2549 }
2550}
2551
2552void Dumpstate::CleanupFiles() {
2553 android::os::UnlinkAndLogOnError(tmp_path_);
2554 android::os::UnlinkAndLogOnError(screenshot_path_);
2555 android::os::UnlinkAndLogOnError(path_);
2556}
2557
2558Dumpstate::RunStatus Dumpstate::HandleUserConsentDenied() {
2559 MYLOGD("User denied consent; deleting files and returning\n");
2560 CleanupFiles();
2561 return USER_CONSENT_DENIED;
2562}
2563
2564Dumpstate::RunStatus Dumpstate::CopyBugreportIfUserConsented() {
2565 // If the caller has asked to copy the bugreport over to their directory, we need explicit
2566 // user consent.
2567 UserConsentResult consent_result = consent_callback_->getResult();
2568 if (consent_result == UserConsentResult::UNAVAILABLE) {
2569 // User has not responded yet.
2570 uint64_t elapsed_ms = consent_callback_->getElapsedTimeMs();
2571 if (elapsed_ms < USER_CONSENT_TIMEOUT_MS) {
2572 uint delay_seconds = (USER_CONSENT_TIMEOUT_MS - elapsed_ms) / 1000;
2573 MYLOGD("Did not receive user consent yet; going to wait for %d seconds", delay_seconds);
2574 sleep(delay_seconds);
2575 }
2576 consent_result = consent_callback_->getResult();
2577 }
2578 if (consent_result == UserConsentResult::DENIED) {
2579 // User has explicitly denied sharing with the app. To be safe delete the
2580 // internal bugreport & tmp files.
2581 return HandleUserConsentDenied();
2582 }
2583 if (consent_result == UserConsentResult::APPROVED) {
Nandana Dutte78c3d72019-01-29 16:10:45 +00002584 bool copy_succeeded = android::os::CopyFileToFd(path_, options_->bugreport_fd.get());
2585 if (copy_succeeded) {
2586 android::os::UnlinkAndLogOnError(path_);
Nandana Duttd2f5f082019-01-18 17:13:52 +00002587 }
2588 return copy_succeeded ? Dumpstate::RunStatus::OK : Dumpstate::RunStatus::ERROR;
2589 } else if (consent_result == UserConsentResult::UNAVAILABLE) {
2590 // consent_result is still UNAVAILABLE. The user has likely not responded yet.
2591 // Since we do not have user consent to share the bugreport it does not get
2592 // copied over to the calling app but remains in the internal directory from
2593 // where the user can manually pull it.
2594 return Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT;
2595 }
2596 // Unknown result; must be a programming error.
2597 MYLOGE("Unknown user consent result:%d\n", consent_result);
2598 return Dumpstate::RunStatus::ERROR;
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002599}
2600
Nandana Duttf02564e2019-02-15 15:24:24 +00002601Dumpstate::RunStatus Dumpstate::ParseCommandlineAndRun(int argc, char* argv[]) {
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002602 std::unique_ptr<Dumpstate::DumpOptions> options = std::make_unique<Dumpstate::DumpOptions>();
2603 Dumpstate::RunStatus status = options->Initialize(argc, argv);
2604 if (status == Dumpstate::RunStatus::OK) {
Nandana Duttf02564e2019-02-15 15:24:24 +00002605 SetOptions(std::move(options));
Nandana Duttd2f5f082019-01-18 17:13:52 +00002606 // When directly running dumpstate binary, the output is not expected to be written
2607 // to any external file descriptor.
Nandana Duttf02564e2019-02-15 15:24:24 +00002608 assert(options_->bugreport_fd.get() == -1);
Nandana Duttd2f5f082019-01-18 17:13:52 +00002609
2610 // calling_uid and calling_package are for user consent to share the bugreport with
2611 // an app; they are irrelvant here because bugreport is only written to a local
2612 // directory, and not shared.
Nandana Duttf02564e2019-02-15 15:24:24 +00002613 status = Run(-1 /* calling_uid */, "" /* calling_package */);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002614 }
Nandana Duttf02564e2019-02-15 15:24:24 +00002615 return status;
2616}
2617
2618/* Main entry point for dumpstate binary. */
2619int run_main(int argc, char* argv[]) {
2620 Dumpstate::RunStatus status = ds.ParseCommandlineAndRun(argc, argv);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002621
2622 switch (status) {
2623 case Dumpstate::RunStatus::OK:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002624 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002625 case Dumpstate::RunStatus::HELP:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002626 ShowUsage();
2627 exit(0);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002628 case Dumpstate::RunStatus::INVALID_INPUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002629 fprintf(stderr, "Invalid combination of args\n");
2630 ShowUsage();
2631 exit(1);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002632 case Dumpstate::RunStatus::ERROR:
Nandana Duttd2f5f082019-01-18 17:13:52 +00002633 FALLTHROUGH_INTENDED;
2634 case Dumpstate::RunStatus::USER_CONSENT_DENIED:
2635 FALLTHROUGH_INTENDED;
2636 case Dumpstate::RunStatus::USER_CONSENT_TIMED_OUT:
Nandana Dutt12ae14a2019-01-09 10:35:53 +00002637 exit(2);
Nandana Dutt5fb117b2018-09-27 09:23:36 +01002638 }
Colin Crossf45fa6b2012-03-26 12:38:26 -07002639}