blob: c2f7f6ac23df0528ccb687e5d429b4588b60479f [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
Felipe Lemec6bc8bc2016-10-27 15:58:27 -070028#include <android-base/macros.h>
Luis Hector Chavez91c2ae52018-03-14 15:12:46 -070029#include <android-base/unique_fd.h>
Jiyong Parkb22e65d2017-06-23 21:23:16 +090030#include <android/os/IDumpstateListener.h>
31#include <utils/StrongPointer.h>
Felipe Lemec6bc8bc2016-10-27 15:58:27 -070032#include <ziparchive/zip_writer.h>
33
Felipe Lemebda15a02016-11-16 17:48:25 -080034#include "DumpstateUtil.h"
Felipe Leme75876a22016-10-27 16:31:27 -070035
Felipe Leme35c94f32016-08-12 10:51:54 -070036// Workaround for const char *args[MAX_ARGS_ARRAY_SIZE] variables until they're converted to
37// std::vector<std::string>
Felipe Leme30dbfa12016-09-02 12:43:26 -070038// TODO: remove once not used
Felipe Leme35c94f32016-08-12 10:51:54 -070039#define MAX_ARGS_ARRAY_SIZE 1000
40
Felipe Leme47e9be22016-12-21 15:37:07 -080041// TODO: move everything under this namespace
42// TODO: and then remove explicitly android::os::dumpstate:: prefixes
43namespace android {
44namespace os {
45namespace dumpstate {
46
47class DumpstateTest;
48class ProgressTest;
49
50} // namespace dumpstate
51} // namespace os
52} // namespace android
53
Jiyong Parkb22e65d2017-06-23 21:23:16 +090054class ZipWriter;
55
Felipe Leme30dbfa12016-09-02 12:43:26 -070056// TODO: remove once moved to HAL
Felipe Leme8620bb42015-11-10 11:04:45 -080057#ifdef __cplusplus
58extern "C" {
59#endif
60
Felipe Leme30dbfa12016-09-02 12:43:26 -070061/*
Felipe Leme30dbfa12016-09-02 12:43:26 -070062 * Helper class used to report how long it takes for a section to finish.
63 *
64 * Typical usage:
65 *
66 * DurationReporter duration_reporter(title);
67 *
68 */
69class DurationReporter {
70 public:
Felipe Leme46b85da2016-11-21 17:40:45 -080071 DurationReporter(const std::string& title, bool log_only = false);
Felipe Leme30dbfa12016-09-02 12:43:26 -070072
73 ~DurationReporter();
74
Felipe Leme30dbfa12016-09-02 12:43:26 -070075 private:
Felipe Leme678727a2016-09-21 17:22:11 -070076 std::string title_;
Felipe Leme46b85da2016-11-21 17:40:45 -080077 bool log_only_;
Felipe Lemeb0f669d2016-09-26 18:26:11 -070078 uint64_t started_;
Felipe Leme062926e2016-10-27 15:51:12 -070079
80 DISALLOW_COPY_AND_ASSIGN(DurationReporter);
Felipe Leme30dbfa12016-09-02 12:43:26 -070081};
82
83/*
Felipe Leme7447d7c2016-11-03 18:12:22 -070084 * Keeps track of current progress and estimated max, saving stats on file to tune up future runs.
Felipe Leme71bbfc52015-11-23 14:14:51 -080085 *
Felipe Leme7447d7c2016-11-03 18:12:22 -070086 * Each `dumpstate` section contributes to the total weight by an individual weight, so the overall
87 * progress can be calculated by dividing the estimate max progress by the current progress.
Felipe Leme71bbfc52015-11-23 14:14:51 -080088 *
Felipe Leme7447d7c2016-11-03 18:12:22 -070089 * The estimated max progress is initially set to a value (`kDefaultMax) defined empirically, but
90 * it's adjusted after each dumpstate run by storing the average duration in a file.
Felipe Lemead5f6c42015-11-30 14:26:46 -080091 *
Felipe Leme71bbfc52015-11-23 14:14:51 -080092 */
Felipe Leme7447d7c2016-11-03 18:12:22 -070093class Progress {
Felipe Leme47e9be22016-12-21 15:37:07 -080094 friend class android::os::dumpstate::ProgressTest;
95 friend class android::os::dumpstate::DumpstateTest;
Felipe Leme7447d7c2016-11-03 18:12:22 -070096
97 public:
98 /*
99 * Default estimation of the max duration of a bugreport generation.
100 *
101 * It does not need to match the exact sum of all sections, but ideally it should to be slight
102 * more than such sum: a value too high will cause the bugreport to finish before the user
103 * expected (for example, jumping from 70% to 100%), while a value too low will cause the
104 * progress to get stuck at an almost-finished value (like 99%) for a while.
105 *
106 * This constant is only used when the average duration from previous runs cannot be used.
107 */
108 static const int kDefaultMax;
109
110 Progress(const std::string& path = "");
111
112 // Gets the current progress.
113 int32_t Get() const;
114
115 // Gets the current estimated max progress.
116 int32_t GetMax() const;
117
118 // Gets the initial estimated max progress.
119 int32_t GetInitialMax() const;
120
121 // Increments progress (ignored if not positive).
122 // Returns `true` if the max progress increased as well.
123 bool Inc(int32_t delta);
124
125 // Persist the stats.
126 void Save();
127
128 void Dump(int fd, const std::string& prefix) const;
129
130 private:
131 Progress(int32_t initial_max, float growth_factor,
132 const std::string& path = ""); // Used by test cases.
133 Progress(int32_t initial_max, int32_t progress, float growth_factor); // Used by test cases.
134 void Load();
135 int32_t initial_max_;
136 int32_t progress_;
137 int32_t max_;
138 float growth_factor_;
139 int32_t n_runs_;
140 int32_t average_max_;
141 const std::string& path_;
142};
Felipe Leme71bbfc52015-11-23 14:14:51 -0800143
Felipe Leme71bbfc52015-11-23 14:14:51 -0800144/*
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700145 * List of supported zip format versions.
146 *
147 * See bugreport-format.md for more info.
148 */
Vishnu Nair64afc022018-02-01 15:29:34 -0800149static std::string VERSION_CURRENT = "2.0";
Felipe Lemed071c682016-10-20 16:48:00 -0700150
151/*
Felipe Lemee184f662016-10-27 10:04:47 -0700152 * Temporary version that adds a anr-traces.txt entry. Once tools support it, the current version
Vishnu Nair64afc022018-02-01 15:29:34 -0800153 * will be bumped to 3.0.
Felipe Lemee184f662016-10-27 10:04:47 -0700154 */
Vishnu Nair64afc022018-02-01 15:29:34 -0800155static std::string VERSION_SPLIT_ANR = "3.0-dev-split-anr";
Felipe Lemee184f662016-10-27 10:04:47 -0700156
157/*
Felipe Lemed071c682016-10-20 16:48:00 -0700158 * "Alias" for the current version.
159 */
160static std::string VERSION_DEFAULT = "default";
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700161
162/*
Luis Hector Chavez91c2ae52018-03-14 15:12:46 -0700163 * Structure that contains the information of an open dump file.
164 */
165struct DumpData {
166 // Path of the file.
167 std::string name;
168
169 // Open file descriptor for the file.
170 android::base::unique_fd fd;
171
172 // Modification time of the file.
173 time_t mtime;
174};
175
176/*
Felipe Lemee844a9d2016-09-21 15:01:39 -0700177 * Main class driving a bugreport generation.
178 *
179 * Currently, it only contains variables that are accessed externally, but gradually the functions
180 * that are spread accross utils.cpp and dumpstate.cpp will be moved to it.
181 */
182class Dumpstate {
Felipe Leme4c2d6632016-09-28 14:32:00 -0700183 friend class DumpstateTest;
184
Felipe Lemee844a9d2016-09-21 15:01:39 -0700185 public:
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100186 enum RunStatus { OK, HELP, INVALID_INPUT, ERROR };
187
Felipe Leme47e9be22016-12-21 15:37:07 -0800188 static android::os::dumpstate::CommandOptions DEFAULT_DUMPSYS;
Felipe Lemebda15a02016-11-16 17:48:25 -0800189
Felipe Lemee844a9d2016-09-21 15:01:39 -0700190 static Dumpstate& GetInstance();
Felipe Leme71bbfc52015-11-23 14:14:51 -0800191
Felipe Leme1d486fe2016-10-14 18:06:47 -0700192 /* Checkes whether dumpstate is generating a zipped bugreport. */
193 bool IsZipping() const;
194
Felipe Leme6ad9c062016-09-28 11:58:36 -0700195 /*
Felipe Leme678727a2016-09-21 17:22:11 -0700196 * Forks a command, waits for it to finish, and returns its status.
197 *
198 * |title| description of the command printed on `stdout` (or empty to skip
199 * description).
200 * |full_command| array containing the command (first entry) and its arguments.
201 * Must contain at least one element.
202 * |options| optional argument defining the command's behavior.
203 */
204 int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
Felipe Leme47e9be22016-12-21 15:37:07 -0800205 const android::os::dumpstate::CommandOptions& options =
206 android::os::dumpstate::CommandOptions::DEFAULT);
Felipe Leme678727a2016-09-21 17:22:11 -0700207
208 /*
209 * Runs `dumpsys` with the given arguments, automatically setting its timeout
Vishnu Nair6921f802017-11-22 09:17:23 -0800210 * (`-T` argument)
Felipe Leme678727a2016-09-21 17:22:11 -0700211 * according to the command options.
212 *
213 * |title| description of the command printed on `stdout` (or empty to skip
214 * description).
215 * |dumpsys_args| `dumpsys` arguments (except `-t`).
216 * |options| optional argument defining the command's behavior.
Vishnu Nair6921f802017-11-22 09:17:23 -0800217 * |dumpsys_timeout| when > 0, defines the value passed to `dumpsys -T` (otherwise it uses the
Felipe Leme6ad9c062016-09-28 11:58:36 -0700218 * timeout from `options`)
Felipe Leme678727a2016-09-21 17:22:11 -0700219 */
Felipe Leme9a523ae2016-10-20 15:10:33 -0700220 void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
Felipe Leme47e9be22016-12-21 15:37:07 -0800221 const android::os::dumpstate::CommandOptions& options = DEFAULT_DUMPSYS,
Vishnu Nair6921f802017-11-22 09:17:23 -0800222 long dumpsys_timeout_ms = 0);
Felipe Leme678727a2016-09-21 17:22:11 -0700223
224 /*
225 * Prints the contents of a file.
226 *
227 * |title| description of the command printed on `stdout` (or empty to skip
228 * description).
229 * |path| location of the file to be dumped.
230 */
231 int DumpFile(const std::string& title, const std::string& path);
232
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700233 /*
Felipe Leme1d486fe2016-10-14 18:06:47 -0700234 * Adds a new entry to the existing zip file.
235 * */
236 bool AddZipEntry(const std::string& entry_name, const std::string& entry_path);
237
238 /*
239 * Adds a new entry to the existing zip file.
Vishnu Naire97d6122018-01-18 13:58:56 -0800240 *
241 * |entry_name| destination path of the new entry.
242 * |fd| file descriptor to read from.
243 * |timeout| timeout to terminate the read if not completed. Set
244 * value of 0s (default) to disable timeout.
Felipe Leme1d486fe2016-10-14 18:06:47 -0700245 */
Vishnu Naire97d6122018-01-18 13:58:56 -0800246 android::status_t AddZipEntryFromFd(const std::string& entry_name, int fd,
247 std::chrono::milliseconds timeout);
Felipe Leme1d486fe2016-10-14 18:06:47 -0700248
249 /*
250 * Adds a text entry entry to the existing zip file.
251 */
252 bool AddTextZipEntry(const std::string& entry_name, const std::string& content);
253
254 /*
255 * Adds all files from a directory to the zipped bugreport file.
256 */
257 void AddDir(const std::string& dir, bool recursive);
258
259 /*
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700260 * Takes a screenshot and save it to the given `path`.
261 *
262 * If `path` is empty, uses a standard path based on the bugreport name.
263 */
264 void TakeScreenshot(const std::string& path = "");
265
Felipe Leme7447d7c2016-11-03 18:12:22 -0700266 /////////////////////////////////////////////////////////////////////
267 // TODO: members below should be private once refactor is finished //
268 /////////////////////////////////////////////////////////////////////
269
270 // TODO: temporary method until Dumpstate object is properly set
271 void SetProgress(std::unique_ptr<Progress> progress);
Felipe Lemed80e6b62016-10-03 13:08:14 -0700272
Felipe Leme6f674ae2016-11-18 17:10:33 -0800273 void DumpstateBoard();
274
Felipe Lemed80e6b62016-10-03 13:08:14 -0700275 /*
276 * Updates the overall progress of the bugreport generation by the given weight increment.
277 */
Felipe Leme7447d7c2016-11-03 18:12:22 -0700278 void UpdateProgress(int32_t delta);
Felipe Lemed80e6b62016-10-03 13:08:14 -0700279
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700280 /* Prints the dumpstate header on `stdout`. */
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700281 void PrintHeader() const;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700282
Felipe Leme1d486fe2016-10-14 18:06:47 -0700283 /*
284 * Adds the temporary report to the existing .zip file, closes the .zip file, and removes the
285 * temporary file.
286 */
287 bool FinishZipFile();
288
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700289 /* Gets the path of a bugreport file with the given suffix. */
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700290 std::string GetPath(const std::string& suffix) const;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700291
Vishnu Nair780b1282017-10-10 13:57:24 -0700292 /* Returns true if the current version supports priority dump feature. */
293 bool CurrentVersionSupportsPriorityDumps() const;
294
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100295 struct DumpOptions;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700296
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100297 /* Main entry point for running a complete bugreport. Takes ownership of options. */
298 RunStatus RunWithOptions(std::unique_ptr<DumpOptions> options);
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100299
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100300 // TODO: add other options from DumpState.
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100301 /*
302 * Structure to hold options that determine the behavior of dumpstate.
303 */
304 struct DumpOptions {
305 bool do_add_date = false;
306 bool do_zip_file = false;
307 bool do_vibrate = true;
308 bool use_socket = false;
309 bool use_control_socket = false;
310 bool do_fb = false;
311 bool do_broadcast = false;
312 bool is_remote_mode = false;
313 bool show_header_only = false;
314 bool do_start_service = false;
315 bool telephony_only = false;
316 bool wifi_only = false;
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100317 // Whether progress updates should be published.
318 bool do_progress_updates = false;
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100319 std::string use_outfile;
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100320 // Extra options passed as system property.
321 std::string extra_options;
322 // Command-line arguments as string
323 std::string args;
324 // Notification title and description
325 std::string notification_title;
326 std::string notification_description;
327
328 /* Initializes options from commandline arguments and system properties. */
329 RunStatus Initialize(int argc, char* argv[]);
330
331 /* Returns true if the options set so far are consistent. */
332 bool ValidateOptions() const;
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100333 };
334
335 // TODO: initialize fields on constructor
Felipe Lemee844a9d2016-09-21 15:01:39 -0700336 // dumpstate id - unique after each device reboot.
Felipe Leme7447d7c2016-11-03 18:12:22 -0700337 uint32_t id_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700338
Felipe Leme75876a22016-10-27 16:31:27 -0700339 // dumpstate pid
340 pid_t pid_;
341
Nandana Dutt3f8c7172018-09-25 12:01:54 +0100342 // Runtime options.
Nandana Dutt5fb117b2018-09-27 09:23:36 +0100343 std::unique_ptr<DumpOptions> options_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700344
Felipe Leme009ecbb2016-11-07 10:18:44 -0800345 // How frequently the progess should be updated;the listener will only be notificated when the
346 // delta from the previous update is more than the threshold.
347 int32_t update_progress_threshold_ = 100;
348
349 // Last progress that triggered a listener updated
350 int32_t last_updated_progress_;
351
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700352 // Whether it should take an screenshot earlier in the process.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700353 bool do_early_screenshot_ = false;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700354
Felipe Leme7447d7c2016-11-03 18:12:22 -0700355 std::unique_ptr<Progress> progress_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700356
357 // When set, defines a socket file-descriptor use to report progress to bugreportz.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700358 int control_socket_fd_ = -1;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700359
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700360 // Bugreport format version;
Felipe Lemed071c682016-10-20 16:48:00 -0700361 std::string version_ = VERSION_CURRENT;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700362
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700363 // Full path of the directory where the bugreport files will be written.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700364 std::string bugreport_dir_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700365
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700366 // Full path of the temporary file containing the screenshot (when requested).
Felipe Leme9a523ae2016-10-20 15:10:33 -0700367 std::string screenshot_path_;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700368
369 time_t now_;
370
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700371 // Base name (without suffix or extensions) of the bugreport files, typically
372 // `bugreport-BUILD_ID`.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700373 std::string base_name_;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700374
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700375 // Name is the suffix part of the bugreport files - it's typically the date (when invoked with
376 // `-d`), but it could be changed by the user..
377 std::string name_;
378
Felipe Leme1d486fe2016-10-14 18:06:47 -0700379 // Full path of the temporary file containing the bugreport.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700380 std::string tmp_path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700381
382 // Full path of the file containing the dumpstate logs.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700383 std::string log_path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700384
385 // Pointer to the actual path, be it zip or text.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700386 std::string path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700387
388 // Pointer to the zipped file.
389 std::unique_ptr<FILE, int (*)(FILE*)> zip_file{nullptr, fclose};
390
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700391 // Pointer to the zip structure.
392 std::unique_ptr<ZipWriter> zip_writer_;
393
Vishnu Nair20cf5032018-01-05 13:15:49 -0800394 // Binder object listening to progress.
Felipe Leme75876a22016-10-27 16:31:27 -0700395 android::sp<android::os::IDumpstateListener> listener_;
396 std::string listener_name_;
Vishnu Nair20cf5032018-01-05 13:15:49 -0800397 bool report_section_;
Felipe Leme75876a22016-10-27 16:31:27 -0700398
Luis Hector Chavez91c2ae52018-03-14 15:12:46 -0700399 // List of open tombstone dump files.
400 std::vector<DumpData> tombstone_data_;
401
402 // List of open ANR dump files.
403 std::vector<DumpData> anr_data_;
404
Felipe Lemee844a9d2016-09-21 15:01:39 -0700405 private:
Felipe Lemed80e6b62016-10-03 13:08:14 -0700406 // Used by GetInstance() only.
Felipe Lemef0292972016-11-22 13:57:05 -0800407 Dumpstate(const std::string& version = VERSION_CURRENT);
Felipe Leme062926e2016-10-27 15:51:12 -0700408
409 DISALLOW_COPY_AND_ASSIGN(Dumpstate);
Felipe Lemee844a9d2016-09-21 15:01:39 -0700410};
411
412// for_each_pid_func = void (*)(int, const char*);
413// for_each_tid_func = void (*)(int, int, const char*);
414
415typedef void(for_each_pid_func)(int, const char*);
416typedef void(for_each_tid_func)(int, int, const char*);
Felipe Leme71ca15e2016-05-19 16:18:17 -0700417
Felipe Leme71a74ac2016-03-17 15:43:25 -0700418/* saves the the contents of a file as a long */
419int read_file_as_long(const char *path, long int *output);
420
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800421/* prints the contents of the fd
422 * fd must have been opened with the flag O_NONBLOCK.
423 */
Christopher Ferris1fe61072014-07-22 16:08:19 -0700424int dump_file_from_fd(const char *title, const char *path, int fd);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700425
Mark Salyzyn326842f2015-04-30 09:49:41 -0700426/* calls skip to gate calling dump_from_fd recursively
427 * in the specified directory. dump_from_fd defaults to
428 * dump_file_from_fd above when set to NULL. skip defaults
429 * to false when set to NULL. dump_from_fd will always be
430 * called with title NULL.
431 */
Felipe Leme678727a2016-09-21 17:22:11 -0700432int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path),
433 int (*dump_from_fd)(const char* title, const char* path, int fd));
Mark Salyzyn326842f2015-04-30 09:49:41 -0700434
Felipe Leme2628e9e2016-04-12 16:36:51 -0700435/** opens a socket and returns its file descriptor */
436int open_socket(const char *service);
437
Colin Crossf45fa6b2012-03-26 12:38:26 -0700438/* redirect output to a service control socket */
439void redirect_to_socket(FILE *redirect, const char *service);
440
Felipe Leme0f3fb202016-06-10 17:10:53 -0700441/* redirect output to a new file */
Christopher Ferrisff4a4dc2015-02-09 16:24:47 -0800442void redirect_to_file(FILE *redirect, char *path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700443
Felipe Leme0f3fb202016-06-10 17:10:53 -0700444/* redirect output to an existing file */
445void redirect_to_existing_file(FILE *redirect, char *path);
446
Felipe Leme111b9d02016-02-03 09:28:24 -0800447/* create leading directories, if necessary */
448void create_parent_dirs(const char *path);
449
Jeff Brownbf7f4922012-06-07 16:40:01 -0700450/* dump Dalvik and native stack traces, return the trace file location (NULL if none) */
451const char *dump_traces();
Colin Crossf45fa6b2012-03-26 12:38:26 -0700452
453/* for each process in the system, run the specified function */
Colin Cross0c22e8b2012-11-02 15:46:56 -0700454void for_each_pid(for_each_pid_func func, const char *header);
455
456/* for each thread in the system, run the specified function */
457void for_each_tid(for_each_tid_func func, const char *header);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700458
459/* Displays a blocked processes in-kernel wait channel */
Colin Cross0c22e8b2012-11-02 15:46:56 -0700460void show_wchan(int pid, int tid, const char *name);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700461
Mark Salyzyna297c322016-02-05 15:33:17 -0800462/* Displays a processes times */
463void show_showtime(int pid, const char *name);
464
Colin Crossf45fa6b2012-03-26 12:38:26 -0700465/* Runs "showmap" for a process */
466void do_showmap(int pid, const char *name);
467
468/* Gets the dmesg output for the kernel */
469void do_dmesg();
470
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700471/* Prints the contents of all the routing tables, both IPv4 and IPv6. */
472void dump_route_tables();
473
Colin Crossf45fa6b2012-03-26 12:38:26 -0700474/* Play a sound via Stagefright */
Christopher Ferris1fe61072014-07-22 16:08:19 -0700475void play_sound(const char *path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700476
Felipe Leme0c80cf02016-01-05 13:25:34 -0800477/* Checks if a given path is a directory. */
478bool is_dir(const char* pathname);
479
480/** Gets the last modification time of a file, or default time if file is not found. */
481time_t get_mtime(int fd, time_t default_mtime);
482
Calvin On249beee2016-06-03 15:17:07 -0700483/* Dumps eMMC Extended CSD data. */
Felipe Leme78f2c862015-12-21 09:55:22 -0800484void dump_emmc_ecsd(const char *ext_csd_path);
485
Calvin On249beee2016-06-03 15:17:07 -0700486/** Gets command-line arguments. */
Felipe Lemea34efb72016-03-11 09:33:32 -0800487void format_args(int argc, const char *argv[], std::string *args);
Felipe Leme88c79332016-02-22 11:06:49 -0800488
Vishnu Nair20cf5032018-01-05 13:15:49 -0800489/** Main entry point for dumpstate. */
490int run_main(int argc, char* argv[]);
491
Felipe Leme8620bb42015-11-10 11:04:45 -0800492#ifdef __cplusplus
493}
494#endif
495
Felipe Leme8268ed22016-08-02 18:18:25 -0700496#endif /* FRAMEWORK_NATIVE_CMD_DUMPSTATE_H_ */