blob: 852b9a8e24c2069398280d3d9c26e80402d1bcdf [file] [log] [blame]
Colin Crossf45fa6b2012-03-26 12:38:26 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Felipe Leme8268ed22016-08-02 18:18:25 -070017#ifndef FRAMEWORK_NATIVE_CMD_DUMPSTATE_H_
18#define FRAMEWORK_NATIVE_CMD_DUMPSTATE_H_
Colin Crossf45fa6b2012-03-26 12:38:26 -070019
20#include <time.h>
21#include <unistd.h>
Colin Cross0c22e8b2012-11-02 15:46:56 -070022#include <stdbool.h>
Colin Crossf45fa6b2012-03-26 12:38:26 -070023#include <stdio.h>
Felipe Leme30dbfa12016-09-02 12:43:26 -070024
25#include <string>
Felipe Leme36b3f6f2015-11-19 15:41:04 -080026#include <vector>
Colin Crossf45fa6b2012-03-26 12:38:26 -070027
Kedar Chitnis9fd8c052021-11-16 09:09:22 +000028#include <aidl/android/hardware/dumpstate/IDumpstateDevice.h>
Felipe Lemec6bc8bc2016-10-27 15:58:27 -070029#include <android-base/macros.h>
Luis Hector Chavez91c2ae52018-03-14 15:12:46 -070030#include <android-base/unique_fd.h>
Hunter Knepshield8540faf2020-02-04 19:47:20 -080031#include <android/hardware/dumpstate/1.1/types.h>
Nandana Duttd2f5f082019-01-18 17:13:52 +000032#include <android/os/BnIncidentAuthListener.h>
Nandana Dutt197661d2018-11-16 16:40:21 +000033#include <android/os/IDumpstate.h>
Jiyong Parkb22e65d2017-06-23 21:23:16 +090034#include <android/os/IDumpstateListener.h>
35#include <utils/StrongPointer.h>
Felipe Lemec6bc8bc2016-10-27 15:58:27 -070036#include <ziparchive/zip_writer.h>
37
Felipe Lemebda15a02016-11-16 17:48:25 -080038#include "DumpstateUtil.h"
Rhed Jao1c855122020-07-16 17:37:39 +080039#include "DumpPool.h"
Rhed Jao4875aa62020-07-20 17:46:29 +080040#include "TaskQueue.h"
Felipe Leme75876a22016-10-27 16:31:27 -070041
Felipe Leme47e9be22016-12-21 15:37:07 -080042// TODO: move everything under this namespace
43// TODO: and then remove explicitly android::os::dumpstate:: prefixes
44namespace android {
45namespace os {
Nandana Dutt58d72e22018-11-16 10:30:48 +000046
47struct DumpstateOptions;
48
Felipe Leme47e9be22016-12-21 15:37:07 -080049namespace dumpstate {
50
51class DumpstateTest;
52class ProgressTest;
Dieter Hsu105ad0c2020-09-29 15:23:33 +080053class ZippedBugReportStreamTest;
Felipe Leme47e9be22016-12-21 15:37:07 -080054
55} // namespace dumpstate
56} // namespace os
57} // namespace android
58
Jiyong Parkb22e65d2017-06-23 21:23:16 +090059class ZipWriter;
60
Felipe Leme30dbfa12016-09-02 12:43:26 -070061// TODO: remove once moved to HAL
Felipe Leme8620bb42015-11-10 11:04:45 -080062#ifdef __cplusplus
63extern "C" {
64#endif
65
Felipe Leme30dbfa12016-09-02 12:43:26 -070066/*
Felipe Leme30dbfa12016-09-02 12:43:26 -070067 * Helper class used to report how long it takes for a section to finish.
68 *
69 * Typical usage:
70 *
71 * DurationReporter duration_reporter(title);
72 *
73 */
74class DurationReporter {
75 public:
Nandana Dutt8d945c02019-08-14 13:30:07 +010076 explicit DurationReporter(const std::string& title, bool logcat_only = false,
Rhed Jao1c855122020-07-16 17:37:39 +080077 bool verbose = false, int duration_fd = STDOUT_FILENO);
Felipe Leme30dbfa12016-09-02 12:43:26 -070078
79 ~DurationReporter();
80
Felipe Leme30dbfa12016-09-02 12:43:26 -070081 private:
Felipe Leme678727a2016-09-21 17:22:11 -070082 std::string title_;
Nandana Dutta8470b82019-03-11 11:00:58 +000083 bool logcat_only_;
Nandana Dutt8d945c02019-08-14 13:30:07 +010084 bool verbose_;
Felipe Lemeb0f669d2016-09-26 18:26:11 -070085 uint64_t started_;
Rhed Jao1c855122020-07-16 17:37:39 +080086 int duration_fd_;
Felipe Leme062926e2016-10-27 15:51:12 -070087
88 DISALLOW_COPY_AND_ASSIGN(DurationReporter);
Felipe Leme30dbfa12016-09-02 12:43:26 -070089};
90
91/*
Felipe Leme7447d7c2016-11-03 18:12:22 -070092 * Keeps track of current progress and estimated max, saving stats on file to tune up future runs.
Felipe Leme71bbfc52015-11-23 14:14:51 -080093 *
Felipe Leme7447d7c2016-11-03 18:12:22 -070094 * Each `dumpstate` section contributes to the total weight by an individual weight, so the overall
95 * progress can be calculated by dividing the estimate max progress by the current progress.
Felipe Leme71bbfc52015-11-23 14:14:51 -080096 *
Felipe Leme7447d7c2016-11-03 18:12:22 -070097 * The estimated max progress is initially set to a value (`kDefaultMax) defined empirically, but
98 * it's adjusted after each dumpstate run by storing the average duration in a file.
Felipe Lemead5f6c42015-11-30 14:26:46 -080099 *
Felipe Leme71bbfc52015-11-23 14:14:51 -0800100 */
Felipe Leme7447d7c2016-11-03 18:12:22 -0700101class Progress {
Felipe Leme47e9be22016-12-21 15:37:07 -0800102 friend class android::os::dumpstate::ProgressTest;
103 friend class android::os::dumpstate::DumpstateTest;
Felipe Leme7447d7c2016-11-03 18:12:22 -0700104
105 public:
106 /*
107 * Default estimation of the max duration of a bugreport generation.
108 *
109 * It does not need to match the exact sum of all sections, but ideally it should to be slight
110 * more than such sum: a value too high will cause the bugreport to finish before the user
111 * expected (for example, jumping from 70% to 100%), while a value too low will cause the
112 * progress to get stuck at an almost-finished value (like 99%) for a while.
113 *
114 * This constant is only used when the average duration from previous runs cannot be used.
115 */
116 static const int kDefaultMax;
117
Chih-Hung Hsiehd0937e62018-12-20 15:43:57 -0800118 explicit Progress(const std::string& path = "");
Felipe Leme7447d7c2016-11-03 18:12:22 -0700119
120 // Gets the current progress.
121 int32_t Get() const;
122
123 // Gets the current estimated max progress.
124 int32_t GetMax() const;
125
126 // Gets the initial estimated max progress.
127 int32_t GetInitialMax() const;
128
129 // Increments progress (ignored if not positive).
130 // Returns `true` if the max progress increased as well.
131 bool Inc(int32_t delta);
132
133 // Persist the stats.
134 void Save();
135
136 void Dump(int fd, const std::string& prefix) const;
137
138 private:
139 Progress(int32_t initial_max, float growth_factor,
140 const std::string& path = ""); // Used by test cases.
141 Progress(int32_t initial_max, int32_t progress, float growth_factor); // Used by test cases.
142 void Load();
143 int32_t initial_max_;
144 int32_t progress_;
145 int32_t max_;
146 float growth_factor_;
147 int32_t n_runs_;
148 int32_t average_max_;
Nandana Dutt979388e2018-11-30 16:48:55 +0000149 std::string path_;
Felipe Leme7447d7c2016-11-03 18:12:22 -0700150};
Felipe Leme71bbfc52015-11-23 14:14:51 -0800151
Felipe Leme71bbfc52015-11-23 14:14:51 -0800152/*
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700153 * List of supported zip format versions.
154 *
155 * See bugreport-format.md for more info.
156 */
Vishnu Nair64afc022018-02-01 15:29:34 -0800157static std::string VERSION_CURRENT = "2.0";
Felipe Lemed071c682016-10-20 16:48:00 -0700158
159/*
Felipe Lemee184f662016-10-27 10:04:47 -0700160 * Temporary version that adds a anr-traces.txt entry. Once tools support it, the current version
Vishnu Nair64afc022018-02-01 15:29:34 -0800161 * will be bumped to 3.0.
Felipe Lemee184f662016-10-27 10:04:47 -0700162 */
Vishnu Nair64afc022018-02-01 15:29:34 -0800163static std::string VERSION_SPLIT_ANR = "3.0-dev-split-anr";
Felipe Lemee184f662016-10-27 10:04:47 -0700164
165/*
Felipe Lemed071c682016-10-20 16:48:00 -0700166 * "Alias" for the current version.
167 */
168static std::string VERSION_DEFAULT = "default";
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700169
170/*
Nandana Dutt979388e2018-11-30 16:48:55 +0000171 * Directory used by Dumpstate binary to keep its local files.
172 */
173static const std::string DUMPSTATE_DIRECTORY = "/bugreports";
174
175/*
Luis Hector Chavez91c2ae52018-03-14 15:12:46 -0700176 * Structure that contains the information of an open dump file.
177 */
178struct DumpData {
179 // Path of the file.
180 std::string name;
181
182 // Open file descriptor for the file.
183 android::base::unique_fd fd;
184
185 // Modification time of the file.
186 time_t mtime;
187};
188
189/*
Felipe Lemee844a9d2016-09-21 15:01:39 -0700190 * Main class driving a bugreport generation.
191 *
192 * Currently, it only contains variables that are accessed externally, but gradually the functions
193 * that are spread accross utils.cpp and dumpstate.cpp will be moved to it.
194 */
195class Dumpstate {
Rhed Jao1c855122020-07-16 17:37:39 +0800196 friend class android::os::dumpstate::DumpstateTest;
Dieter Hsu105ad0c2020-09-29 15:23:33 +0800197 friend class android::os::dumpstate::ZippedBugReportStreamTest;
Felipe Leme4c2d6632016-09-28 14:32:00 -0700198
Felipe Lemee844a9d2016-09-21 15:01:39 -0700199 public:
Nandana Duttd2f5f082019-01-18 17:13:52 +0000200 enum RunStatus { OK, HELP, INVALID_INPUT, ERROR, USER_CONSENT_DENIED, USER_CONSENT_TIMED_OUT };
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100201
Nandana Dutt58d72e22018-11-16 10:30:48 +0000202 // The mode under which the bugreport should be run. Each mode encapsulates a few options.
203 enum BugreportMode {
Nandana Dutt197661d2018-11-16 16:40:21 +0000204 BUGREPORT_FULL = android::os::IDumpstate::BUGREPORT_MODE_FULL,
205 BUGREPORT_INTERACTIVE = android::os::IDumpstate::BUGREPORT_MODE_INTERACTIVE,
206 BUGREPORT_REMOTE = android::os::IDumpstate::BUGREPORT_MODE_REMOTE,
207 BUGREPORT_WEAR = android::os::IDumpstate::BUGREPORT_MODE_WEAR,
208 BUGREPORT_TELEPHONY = android::os::IDumpstate::BUGREPORT_MODE_TELEPHONY,
Abhijeet Kaur904e0e02018-12-05 14:03:01 +0000209 BUGREPORT_WIFI = android::os::IDumpstate::BUGREPORT_MODE_WIFI,
210 BUGREPORT_DEFAULT = android::os::IDumpstate::BUGREPORT_MODE_DEFAULT
Nandana Dutt58d72e22018-11-16 10:30:48 +0000211 };
212
Felipe Leme47e9be22016-12-21 15:37:07 -0800213 static android::os::dumpstate::CommandOptions DEFAULT_DUMPSYS;
Felipe Lemebda15a02016-11-16 17:48:25 -0800214
Felipe Lemee844a9d2016-09-21 15:01:39 -0700215 static Dumpstate& GetInstance();
Felipe Leme71bbfc52015-11-23 14:14:51 -0800216
Felipe Leme1d486fe2016-10-14 18:06:47 -0700217 /* Checkes whether dumpstate is generating a zipped bugreport. */
218 bool IsZipping() const;
219
Abhijeet Kaura407fb82020-03-27 12:51:12 +0000220 /* Initialize dumpstate fields before starting bugreport generation */
221 void Initialize();
222
Felipe Leme6ad9c062016-09-28 11:58:36 -0700223 /*
Felipe Leme678727a2016-09-21 17:22:11 -0700224 * Forks a command, waits for it to finish, and returns its status.
225 *
226 * |title| description of the command printed on `stdout` (or empty to skip
227 * description).
228 * |full_command| array containing the command (first entry) and its arguments.
229 * Must contain at least one element.
230 * |options| optional argument defining the command's behavior.
Rhed Jao4875aa62020-07-20 17:46:29 +0800231 * |out_fd| A fd to support the DumpPool to output results to a temporary
232 * file. Using STDOUT_FILENO if it's not running in the parallel task.
Felipe Leme678727a2016-09-21 17:22:11 -0700233 */
234 int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
Felipe Leme47e9be22016-12-21 15:37:07 -0800235 const android::os::dumpstate::CommandOptions& options =
Nandana Dutt8d945c02019-08-14 13:30:07 +0100236 android::os::dumpstate::CommandOptions::DEFAULT,
Rhed Jao4875aa62020-07-20 17:46:29 +0800237 bool verbose_duration = false, int out_fd = STDOUT_FILENO);
Felipe Leme678727a2016-09-21 17:22:11 -0700238
239 /*
240 * Runs `dumpsys` with the given arguments, automatically setting its timeout
Vishnu Nair6921f802017-11-22 09:17:23 -0800241 * (`-T` argument)
Felipe Leme678727a2016-09-21 17:22:11 -0700242 * according to the command options.
243 *
244 * |title| description of the command printed on `stdout` (or empty to skip
245 * description).
246 * |dumpsys_args| `dumpsys` arguments (except `-t`).
247 * |options| optional argument defining the command's behavior.
Vishnu Nair6921f802017-11-22 09:17:23 -0800248 * |dumpsys_timeout| when > 0, defines the value passed to `dumpsys -T` (otherwise it uses the
Felipe Leme6ad9c062016-09-28 11:58:36 -0700249 * timeout from `options`)
Rhed Jao6b1ea2d2020-07-21 17:58:41 +0800250 * |out_fd| A fd to support the DumpPool to output results to a temporary
251 * file. Using STDOUT_FILENO if it's not running in the parallel task.
Felipe Leme678727a2016-09-21 17:22:11 -0700252 */
Felipe Leme9a523ae2016-10-20 15:10:33 -0700253 void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
Felipe Leme47e9be22016-12-21 15:37:07 -0800254 const android::os::dumpstate::CommandOptions& options = DEFAULT_DUMPSYS,
Rhed Jao6b1ea2d2020-07-21 17:58:41 +0800255 long dumpsys_timeout_ms = 0, int out_fd = STDOUT_FILENO);
Felipe Leme678727a2016-09-21 17:22:11 -0700256
257 /*
258 * Prints the contents of a file.
259 *
260 * |title| description of the command printed on `stdout` (or empty to skip
261 * description).
262 * |path| location of the file to be dumped.
263 */
264 int DumpFile(const std::string& title, const std::string& path);
265
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700266 /*
Felipe Leme1d486fe2016-10-14 18:06:47 -0700267 * Adds a new entry to the existing zip file.
268 * */
269 bool AddZipEntry(const std::string& entry_name, const std::string& entry_path);
270
271 /*
272 * Adds a new entry to the existing zip file.
Vishnu Naire97d6122018-01-18 13:58:56 -0800273 *
274 * |entry_name| destination path of the new entry.
275 * |fd| file descriptor to read from.
276 * |timeout| timeout to terminate the read if not completed. Set
277 * value of 0s (default) to disable timeout.
Felipe Leme1d486fe2016-10-14 18:06:47 -0700278 */
Vishnu Naire97d6122018-01-18 13:58:56 -0800279 android::status_t AddZipEntryFromFd(const std::string& entry_name, int fd,
280 std::chrono::milliseconds timeout);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700281
282 /*
Nandana Dutta7db6342018-11-21 14:53:34 +0000283 * Adds a text entry to the existing zip file.
Felipe Leme1d486fe2016-10-14 18:06:47 -0700284 */
285 bool AddTextZipEntry(const std::string& entry_name, const std::string& content);
286
287 /*
288 * Adds all files from a directory to the zipped bugreport file.
289 */
290 void AddDir(const std::string& dir, bool recursive);
291
292 /*
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700293 * Takes a screenshot and save it to the given `path`.
294 *
295 * If `path` is empty, uses a standard path based on the bugreport name.
296 */
297 void TakeScreenshot(const std::string& path = "");
298
Felipe Leme7447d7c2016-11-03 18:12:22 -0700299 /////////////////////////////////////////////////////////////////////
300 // TODO: members below should be private once refactor is finished //
301 /////////////////////////////////////////////////////////////////////
302
303 // TODO: temporary method until Dumpstate object is properly set
304 void SetProgress(std::unique_ptr<Progress> progress);
Felipe Lemed80e6b62016-10-03 13:08:14 -0700305
Nandana Duttcf419a72019-03-14 10:40:17 +0000306 // Dumps Dalvik and native stack traces, sets the trace file location to path
307 // if it succeeded.
308 // Note that it returns early if user consent is denied with status USER_CONSENT_DENIED.
309 // Returns OK in all other cases.
310 RunStatus DumpTraces(const char** path);
Nandana Duttfaafd522019-03-11 09:23:09 +0000311
Rhed Jao4875aa62020-07-20 17:46:29 +0800312 /*
313 * |out_fd| A fd to support the DumpPool to output results to a temporary file.
314 * Dumpstate can pick up later and output to the bugreport. Using STDOUT_FILENO
315 * if it's not running in the parallel task.
316 */
317 void DumpstateBoard(int out_fd = STDOUT_FILENO);
Felipe Leme6f674ae2016-11-18 17:10:33 -0800318
Felipe Lemed80e6b62016-10-03 13:08:14 -0700319 /*
320 * Updates the overall progress of the bugreport generation by the given weight increment.
321 */
Felipe Leme7447d7c2016-11-03 18:12:22 -0700322 void UpdateProgress(int32_t delta);
Felipe Lemed80e6b62016-10-03 13:08:14 -0700323
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700324 /* Prints the dumpstate header on `stdout`. */
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700325 void PrintHeader() const;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700326
Felipe Leme1d486fe2016-10-14 18:06:47 -0700327 /*
328 * Adds the temporary report to the existing .zip file, closes the .zip file, and removes the
329 * temporary file.
330 */
331 bool FinishZipFile();
332
Nandana Dutt979388e2018-11-30 16:48:55 +0000333 /* Constructs a full path inside directory with file name formatted using the given suffix. */
334 std::string GetPath(const std::string& directory, const std::string& suffix) const;
335
336 /* Constructs a full path inside bugreport_internal_dir_ with file name formatted using the
337 * given suffix. */
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700338 std::string GetPath(const std::string& suffix) const;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700339
Vishnu Nair780b1282017-10-10 13:57:24 -0700340 /* Returns true if the current version supports priority dump feature. */
341 bool CurrentVersionSupportsPriorityDumps() const;
342
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100343 struct DumpOptions;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700344
Abhijeet Kaura407fb82020-03-27 12:51:12 +0000345 /*
346 * Main entry point for running a complete bugreport.
347 *
348 * Initialize() dumpstate before calling this method.
349 *
350 */
Nandana Duttd2f5f082019-01-18 17:13:52 +0000351 RunStatus Run(int32_t calling_uid, const std::string& calling_package);
Nandana Dutt197661d2018-11-16 16:40:21 +0000352
Nandana Duttf02564e2019-02-15 15:24:24 +0000353 RunStatus ParseCommandlineAndRun(int argc, char* argv[]);
354
Nandana Dutt8ae16e62020-03-27 10:20:22 +0000355 /* Deletes in-progress files */
356 void Cancel();
357
Nandana Dutt197661d2018-11-16 16:40:21 +0000358 /* Sets runtime options. */
359 void SetOptions(std::unique_ptr<DumpOptions> options);
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100360
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100361 /*
Nandana Duttbbdb5b42019-03-12 10:52:56 +0000362 * Returns true if user consent is necessary and has been denied.
363 * Consent is only necessary if the caller has asked to copy over the bugreport to a file they
364 * provided.
365 */
366 bool IsUserConsentDenied() const;
367
368 /*
Abhijeet Kaur359b1ff2019-07-26 16:01:36 +0100369 * Returns true if dumpstate is called by bugreporting API
370 */
371 bool CalledByApi() const;
372
373 /*
Rhed Jao4875aa62020-07-20 17:46:29 +0800374 * Enqueues a task to the dumpstate's TaskQueue if the parallel run is enabled,
375 * otherwise invokes it immediately. The task adds file at path entry_path
376 * as a zip file entry with name entry_name. Unlinks entry_path when done.
377 *
378 * All enqueued tasks will be executed in the dumpstate's FinishZipFile method
379 * before the zip file is finished. Tasks will be cancelled in dumpstate's
380 * ShutdownDumpPool method if they have never been called.
381 */
382 void EnqueueAddZipEntryAndCleanupIfNeeded(const std::string& entry_name,
383 const std::string& entry_path);
384
385 /*
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100386 * Structure to hold options that determine the behavior of dumpstate.
387 */
388 struct DumpOptions {
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100389 bool do_vibrate = true;
Dieter Hsu105ad0c2020-09-29 15:23:33 +0800390 // Writes bugreport zipped file to a socket.
391 bool stream_to_socket = false;
392 // Writes generation progress updates to a socket.
393 bool progress_updates_to_socket = false;
Paul Chang0d2aad72020-02-13 20:04:03 +0800394 bool do_screenshot = false;
395 bool is_screenshot_copied = false;
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100396 bool is_remote_mode = false;
397 bool show_header_only = false;
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100398 bool telephony_only = false;
399 bool wifi_only = false;
mhasankd451a472020-05-26 18:02:39 -0700400 // Trimmed-down version of dumpstate to only include whitelisted logs.
401 bool limited_only = false;
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100402 // Whether progress updates should be published.
403 bool do_progress_updates = false;
Kedar Chitnis9fd8c052021-11-16 09:09:22 +0000404 // this is used to derive dumpstate HAL bug report mode
Hunter Knepshield8540faf2020-02-04 19:47:20 -0800405 // TODO(b/148168577) get rid of the AIDL values, replace them with the HAL values instead.
406 // The HAL is actually an API surface that can be validated, while the AIDL is not (@hide).
Kedar Chitnis9fd8c052021-11-16 09:09:22 +0000407 BugreportMode bugreport_mode = Dumpstate::BugreportMode::BUGREPORT_DEFAULT;
mhasank3a4cfb42020-06-15 18:06:43 -0700408 // File descriptor to output zip file. Takes precedence over out_dir.
Nandana Dutt54dbd672019-01-11 12:58:05 +0000409 android::base::unique_fd bugreport_fd;
410 // File descriptor to screenshot file.
Nandana Dutt54dbd672019-01-11 12:58:05 +0000411 android::base::unique_fd screenshot_fd;
mhasank3a4cfb42020-06-15 18:06:43 -0700412 // Custom output directory.
413 std::string out_dir;
Kedar Chitnis9fd8c052021-11-16 09:09:22 +0000414 // Bugreport mode of the bugreport as a string
415 std::string bugreport_mode_string;
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100416 // Command-line arguments as string
417 std::string args;
418 // Notification title and description
419 std::string notification_title;
420 std::string notification_description;
421
Abhijeet Kaure370d682019-10-01 16:49:30 +0100422 /* Initializes options from commandline arguments. */
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100423 RunStatus Initialize(int argc, char* argv[]);
424
Nandana Dutt58d72e22018-11-16 10:30:48 +0000425 /* Initializes options from the requested mode. */
Nandana Dutt54dbd672019-01-11 12:58:05 +0000426 void Initialize(BugreportMode bugreport_mode, const android::base::unique_fd& bugreport_fd,
Paul Changf59c2b72020-03-10 02:08:55 +0800427 const android::base::unique_fd& screenshot_fd,
428 bool is_screenshot_requested);
Nandana Dutt58d72e22018-11-16 10:30:48 +0000429
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100430 /* Returns true if the options set so far are consistent. */
431 bool ValidateOptions() const;
Nandana Dutt9a76d202019-01-21 15:56:48 +0000432
mhasank2d75c442020-06-11 15:05:25 -0700433 /* Returns if options specified require writing to custom file location */
434 bool OutputToCustomFile() {
435 // Custom location is only honored in limited mode.
mhasank3a4cfb42020-06-15 18:06:43 -0700436 return limited_only && !out_dir.empty() && bugreport_fd.get() == -1;
mhasank2d75c442020-06-11 15:05:25 -0700437 }
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100438 };
439
440 // TODO: initialize fields on constructor
Felipe Lemee844a9d2016-09-21 15:01:39 -0700441 // dumpstate id - unique after each device reboot.
Felipe Leme7447d7c2016-11-03 18:12:22 -0700442 uint32_t id_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700443
Felipe Leme75876a22016-10-27 16:31:27 -0700444 // dumpstate pid
445 pid_t pid_;
446
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100447 // Runtime options.
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100448 std::unique_ptr<DumpOptions> options_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700449
Nandana Dutt402a8392019-06-14 14:25:13 +0100450 // Last progress that was sent to the listener [0-100].
451 int last_reported_percent_progress_ = 0;
Felipe Leme009ecbb2016-11-07 10:18:44 -0800452
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700453 // Whether it should take an screenshot earlier in the process.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700454 bool do_early_screenshot_ = false;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700455
Primiano Tuccifaaaafb2021-01-14 12:26:29 +0000456 // This is set to true when the trace snapshot request in the early call to
457 // MaybeSnapshotSystemTrace(). When this is true, the later stages of
458 // dumpstate will append the trace to the zip archive.
459 bool has_system_trace_ = false;
460
Felipe Leme7447d7c2016-11-03 18:12:22 -0700461 std::unique_ptr<Progress> progress_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700462
Dieter Hsu105ad0c2020-09-29 15:23:33 +0800463 // When set, defines a socket file-descriptor use to report progress to bugreportz
464 // or to stream the zipped file to.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700465 int control_socket_fd_ = -1;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700466
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700467 // Bugreport format version;
Felipe Lemed071c682016-10-20 16:48:00 -0700468 std::string version_ = VERSION_CURRENT;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700469
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700470 time_t now_;
471
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700472 // Base name (without suffix or extensions) of the bugreport files, typically
473 // `bugreport-BUILD_ID`.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700474 std::string base_name_;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700475
Dieter Hsu105ad0c2020-09-29 15:23:33 +0800476 // Name is the suffix part of the bugreport files - it's typically the date,
477 // but it could be changed by the user..
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700478 std::string name_;
479
Nandana Dutt979388e2018-11-30 16:48:55 +0000480 std::string bugreport_internal_dir_ = DUMPSTATE_DIRECTORY;
481
482 // Full path of the temporary file containing the bugreport, inside bugreport_internal_dir_.
483 // At the very end this file is pulled into the zip file.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700484 std::string tmp_path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700485
Nandana Dutt979388e2018-11-30 16:48:55 +0000486 // Full path of the file containing the dumpstate logs, inside bugreport_internal_dir_.
487 // This is useful for debugging.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700488 std::string log_path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700489
Nandana Dutt979388e2018-11-30 16:48:55 +0000490 // Full path of the bugreport file, be it zip or text, inside bugreport_internal_dir_.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700491 std::string path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700492
Nandana Duttf531f4b2019-06-14 12:20:03 +0100493 // Full path of the file containing the screenshot (when requested).
Nandana Dutt979388e2018-11-30 16:48:55 +0000494 std::string screenshot_path_;
495
Felipe Leme1d486fe2016-10-14 18:06:47 -0700496 // Pointer to the zipped file.
497 std::unique_ptr<FILE, int (*)(FILE*)> zip_file{nullptr, fclose};
498
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700499 // Pointer to the zip structure.
500 std::unique_ptr<ZipWriter> zip_writer_;
501
Vishnu Nair20cf5032018-01-05 13:15:49 -0800502 // Binder object listening to progress.
Felipe Leme75876a22016-10-27 16:31:27 -0700503 android::sp<android::os::IDumpstateListener> listener_;
Felipe Leme75876a22016-10-27 16:31:27 -0700504
Luis Hector Chavez91c2ae52018-03-14 15:12:46 -0700505 // List of open tombstone dump files.
506 std::vector<DumpData> tombstone_data_;
507
508 // List of open ANR dump files.
509 std::vector<DumpData> anr_data_;
510
Rhed Jao1c855122020-07-16 17:37:39 +0800511 // A thread pool to execute dump tasks simultaneously if the parallel run is enabled.
512 std::unique_ptr<android::os::dumpstate::DumpPool> dump_pool_;
513
Rhed Jao4875aa62020-07-20 17:46:29 +0800514 // A task queue to collect adding zip entry tasks inside dump tasks if the
515 // parallel run is enabled.
516 std::unique_ptr<android::os::dumpstate::TaskQueue> zip_entry_tasks_;
517
Nandana Duttd2f5f082019-01-18 17:13:52 +0000518 // A callback to IncidentCompanion service, which checks user consent for sharing the
519 // bugreport with the calling app. If the user has not responded yet to the dialog it will
520 // be neither confirmed nor denied.
521 class ConsentCallback : public android::os::BnIncidentAuthListener {
522 public:
523 ConsentCallback();
524 android::binder::Status onReportApproved() override;
525 android::binder::Status onReportDenied() override;
526
527 enum ConsentResult { APPROVED, DENIED, UNAVAILABLE };
528
529 ConsentResult getResult();
530
531 // Returns the time since creating this listener
532 uint64_t getElapsedTimeMs() const;
533
534 private:
535 ConsentResult result_;
536 uint64_t start_time_;
537 std::mutex lock_;
538 };
539
Felipe Lemee844a9d2016-09-21 15:01:39 -0700540 private:
Nandana Duttd2f5f082019-01-18 17:13:52 +0000541 RunStatus RunInternal(int32_t calling_uid, const std::string& calling_package);
542
Jichao Lie89d9c12019-11-21 19:02:51 -0800543 RunStatus DumpstateDefaultAfterCritical();
544
Paul Chang0d2aad72020-02-13 20:04:03 +0800545 void MaybeTakeEarlyScreenshot();
Primiano Tuccifaaaafb2021-01-14 12:26:29 +0000546 void MaybeSnapshotSystemTrace();
Yohei Yukawa95305b32021-03-09 07:54:27 -0800547 void MaybeSnapshotWinTrace();
Paul Chang0d2aad72020-02-13 20:04:03 +0800548
Paul Chang5702b482020-05-28 22:05:47 +0800549 void onUiIntensiveBugreportDumpsFinished(int32_t calling_uid);
Paul Changc490e662020-04-11 18:14:09 +0800550
Jichao Lie89d9c12019-11-21 19:02:51 -0800551 void MaybeCheckUserConsent(int32_t calling_uid, const std::string& calling_package);
Nandana Duttd2f5f082019-01-18 17:13:52 +0000552
553 // Removes the in progress files output files (tmp file, zip/txt file, screenshot),
554 // but leaves the log file alone.
Nandana Dutt8ae16e62020-03-27 10:20:22 +0000555 void CleanupTmpFiles();
Nandana Duttd2f5f082019-01-18 17:13:52 +0000556
Rhed Jao1c855122020-07-16 17:37:39 +0800557 // Create the thread pool to enable the parallel run function.
558 void EnableParallelRunIfNeeded();
559 void ShutdownDumpPool();
560
Nandana Duttd2f5f082019-01-18 17:13:52 +0000561 RunStatus HandleUserConsentDenied();
562
Abhijeet Kaur3172b532019-10-15 15:07:03 +0100563 // Copies bugreport artifacts over to the caller's directories provided there is user consent or
564 // called by Shell.
565 RunStatus CopyBugreportIfUserConsented(int32_t calling_uid);
Nandana Duttbabf6c72019-01-15 14:11:12 +0000566
Dieter Hsu105ad0c2020-09-29 15:23:33 +0800567 std::function<int(const char *)> open_socket_fn_;
568
Felipe Lemed80e6b62016-10-03 13:08:14 -0700569 // Used by GetInstance() only.
Chih-Hung Hsiehd0937e62018-12-20 15:43:57 -0800570 explicit Dumpstate(const std::string& version = VERSION_CURRENT);
Felipe Leme062926e2016-10-27 15:51:12 -0700571
Nandana Duttd2f5f082019-01-18 17:13:52 +0000572 android::sp<ConsentCallback> consent_callback_;
573
Rhed Jao2cc4eec2020-07-21 15:42:55 +0800574 std::recursive_mutex mutex_;
575
Felipe Leme062926e2016-10-27 15:51:12 -0700576 DISALLOW_COPY_AND_ASSIGN(Dumpstate);
Felipe Lemee844a9d2016-09-21 15:01:39 -0700577};
578
579// for_each_pid_func = void (*)(int, const char*);
580// for_each_tid_func = void (*)(int, int, const char*);
581
582typedef void(for_each_pid_func)(int, const char*);
583typedef void(for_each_tid_func)(int, int, const char*);
Felipe Leme71ca15e2016-05-19 16:18:17 -0700584
Felipe Leme71a74ac2016-03-17 15:43:25 -0700585/* saves the the contents of a file as a long */
586int read_file_as_long(const char *path, long int *output);
587
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800588/* prints the contents of the fd
589 * fd must have been opened with the flag O_NONBLOCK.
590 */
Christopher Ferris1fe61072014-07-22 16:08:19 -0700591int dump_file_from_fd(const char *title, const char *path, int fd);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700592
Mark Salyzyn326842f2015-04-30 09:49:41 -0700593/* calls skip to gate calling dump_from_fd recursively
594 * in the specified directory. dump_from_fd defaults to
595 * dump_file_from_fd above when set to NULL. skip defaults
596 * to false when set to NULL. dump_from_fd will always be
597 * called with title NULL.
598 */
Felipe Leme678727a2016-09-21 17:22:11 -0700599int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path),
600 int (*dump_from_fd)(const char* title, const char* path, int fd));
Mark Salyzyn326842f2015-04-30 09:49:41 -0700601
Nandana Dutta344cb62019-02-22 15:12:35 +0000602/*
603 * Redirects 'redirect' to a file indicated by 'path', truncating it.
604 *
605 * Returns true if redirect succeeds.
606 */
607bool redirect_to_file(FILE* redirect, char* path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700608
Nandana Dutta344cb62019-02-22 15:12:35 +0000609/*
610 * Redirects 'redirect' to an existing file indicated by 'path', appending it.
611 *
612 * Returns true if redirect succeeds.
613 */
614bool redirect_to_existing_file(FILE* redirect, char* path);
Felipe Leme0f3fb202016-06-10 17:10:53 -0700615
Felipe Leme111b9d02016-02-03 09:28:24 -0800616/* create leading directories, if necessary */
617void create_parent_dirs(const char *path);
618
Colin Crossf45fa6b2012-03-26 12:38:26 -0700619/* for each process in the system, run the specified function */
Colin Cross0c22e8b2012-11-02 15:46:56 -0700620void for_each_pid(for_each_pid_func func, const char *header);
621
622/* for each thread in the system, run the specified function */
623void for_each_tid(for_each_tid_func func, const char *header);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700624
625/* Displays a blocked processes in-kernel wait channel */
Colin Cross0c22e8b2012-11-02 15:46:56 -0700626void show_wchan(int pid, int tid, const char *name);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700627
Mark Salyzyna297c322016-02-05 15:33:17 -0800628/* Displays a processes times */
629void show_showtime(int pid, const char *name);
630
Colin Crossf45fa6b2012-03-26 12:38:26 -0700631/* Runs "showmap" for a process */
632void do_showmap(int pid, const char *name);
633
634/* Gets the dmesg output for the kernel */
635void do_dmesg();
636
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700637/* Prints the contents of all the routing tables, both IPv4 and IPv6. */
638void dump_route_tables();
639
Li Li830179f2022-01-04 12:53:29 -0800640/* Dump subdirectories of cgroupfs if the corresponding process is frozen */
641void dump_frozen_cgroupfs();
642
Colin Crossf45fa6b2012-03-26 12:38:26 -0700643/* Play a sound via Stagefright */
Christopher Ferris1fe61072014-07-22 16:08:19 -0700644void play_sound(const char *path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700645
Felipe Leme0c80cf02016-01-05 13:25:34 -0800646/* Checks if a given path is a directory. */
647bool is_dir(const char* pathname);
648
649/** Gets the last modification time of a file, or default time if file is not found. */
650time_t get_mtime(int fd, time_t default_mtime);
651
Calvin On249beee2016-06-03 15:17:07 -0700652/** Gets command-line arguments. */
Felipe Lemea34efb72016-03-11 09:33:32 -0800653void format_args(int argc, const char *argv[], std::string *args);
Felipe Leme88c79332016-02-22 11:06:49 -0800654
Vishnu Nair20cf5032018-01-05 13:15:49 -0800655/** Main entry point for dumpstate. */
656int run_main(int argc, char* argv[]);
657
Felipe Leme8620bb42015-11-10 11:04:45 -0800658#ifdef __cplusplus
659}
660#endif
661
Felipe Leme8268ed22016-08-02 18:18:25 -0700662#endif /* FRAMEWORK_NATIVE_CMD_DUMPSTATE_H_ */