blob: 69b0a5e014ae2c8656151e67faaa563ba49c3373 [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 Park522ae9a2017-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 Park522ae9a2017-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 */
Felipe Lemed071c682016-10-20 16:48:00 -0700149static std::string VERSION_CURRENT = "1.0";
150
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
153 * will be bumped to 2.0-dev-1.
154 */
155static std::string VERSION_SPLIT_ANR = "2.0-dev-1";
156
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:
Felipe Leme47e9be22016-12-21 15:37:07 -0800186 static android::os::dumpstate::CommandOptions DEFAULT_DUMPSYS;
Felipe Lemebda15a02016-11-16 17:48:25 -0800187
Felipe Lemee844a9d2016-09-21 15:01:39 -0700188 static Dumpstate& GetInstance();
Felipe Leme71bbfc52015-11-23 14:14:51 -0800189
Felipe Leme1d486fe2016-10-14 18:06:47 -0700190 /* Checkes whether dumpstate is generating a zipped bugreport. */
191 bool IsZipping() const;
192
Felipe Leme6ad9c062016-09-28 11:58:36 -0700193 /*
Felipe Leme678727a2016-09-21 17:22:11 -0700194 * Forks a command, waits for it to finish, and returns its status.
195 *
196 * |title| description of the command printed on `stdout` (or empty to skip
197 * description).
198 * |full_command| array containing the command (first entry) and its arguments.
199 * Must contain at least one element.
200 * |options| optional argument defining the command's behavior.
201 */
202 int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
Felipe Leme47e9be22016-12-21 15:37:07 -0800203 const android::os::dumpstate::CommandOptions& options =
204 android::os::dumpstate::CommandOptions::DEFAULT);
Felipe Leme678727a2016-09-21 17:22:11 -0700205
206 /*
207 * Runs `dumpsys` with the given arguments, automatically setting its timeout
208 * (`-t` argument)
209 * according to the command options.
210 *
211 * |title| description of the command printed on `stdout` (or empty to skip
212 * description).
213 * |dumpsys_args| `dumpsys` arguments (except `-t`).
214 * |options| optional argument defining the command's behavior.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700215 * |dumpsys_timeout| when > 0, defines the value passed to `dumpsys -t` (otherwise it uses the
Felipe Leme6ad9c062016-09-28 11:58:36 -0700216 * timeout from `options`)
Felipe Leme678727a2016-09-21 17:22:11 -0700217 */
Felipe Leme9a523ae2016-10-20 15:10:33 -0700218 void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
Felipe Leme47e9be22016-12-21 15:37:07 -0800219 const android::os::dumpstate::CommandOptions& options = DEFAULT_DUMPSYS,
220 long dumpsys_timeout = 0);
Felipe Leme678727a2016-09-21 17:22:11 -0700221
222 /*
223 * Prints the contents of a file.
224 *
225 * |title| description of the command printed on `stdout` (or empty to skip
226 * description).
227 * |path| location of the file to be dumped.
228 */
229 int DumpFile(const std::string& title, const std::string& path);
230
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700231 /*
Felipe Leme1d486fe2016-10-14 18:06:47 -0700232 * Adds a new entry to the existing zip file.
233 * */
234 bool AddZipEntry(const std::string& entry_name, const std::string& entry_path);
235
236 /*
237 * Adds a new entry to the existing zip file.
238 */
239 bool AddZipEntryFromFd(const std::string& entry_name, int fd);
240
241 /*
242 * Adds a text entry entry to the existing zip file.
243 */
244 bool AddTextZipEntry(const std::string& entry_name, const std::string& content);
245
246 /*
247 * Adds all files from a directory to the zipped bugreport file.
248 */
249 void AddDir(const std::string& dir, bool recursive);
250
251 /*
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700252 * Takes a screenshot and save it to the given `path`.
253 *
254 * If `path` is empty, uses a standard path based on the bugreport name.
255 */
256 void TakeScreenshot(const std::string& path = "");
257
Felipe Leme7447d7c2016-11-03 18:12:22 -0700258 /////////////////////////////////////////////////////////////////////
259 // TODO: members below should be private once refactor is finished //
260 /////////////////////////////////////////////////////////////////////
261
262 // TODO: temporary method until Dumpstate object is properly set
263 void SetProgress(std::unique_ptr<Progress> progress);
Felipe Lemed80e6b62016-10-03 13:08:14 -0700264
Felipe Leme6f674ae2016-11-18 17:10:33 -0800265 void DumpstateBoard();
266
Felipe Lemed80e6b62016-10-03 13:08:14 -0700267 /*
268 * Updates the overall progress of the bugreport generation by the given weight increment.
269 */
Felipe Leme7447d7c2016-11-03 18:12:22 -0700270 void UpdateProgress(int32_t delta);
Felipe Lemed80e6b62016-10-03 13:08:14 -0700271
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700272 /* Prints the dumpstate header on `stdout`. */
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700273 void PrintHeader() const;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700274
Felipe Leme1d486fe2016-10-14 18:06:47 -0700275 /*
276 * Adds the temporary report to the existing .zip file, closes the .zip file, and removes the
277 * temporary file.
278 */
279 bool FinishZipFile();
280
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700281 /* Gets the path of a bugreport file with the given suffix. */
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700282 std::string GetPath(const std::string& suffix) const;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700283
Felipe Lemee844a9d2016-09-21 15:01:39 -0700284 // TODO: initialize fields on constructor
285
286 // dumpstate id - unique after each device reboot.
Felipe Leme7447d7c2016-11-03 18:12:22 -0700287 uint32_t id_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700288
Felipe Leme75876a22016-10-27 16:31:27 -0700289 // dumpstate pid
290 pid_t pid_;
291
Felipe Lemee844a9d2016-09-21 15:01:39 -0700292 // Whether progress updates should be published.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700293 bool update_progress_ = false;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700294
Felipe Leme009ecbb2016-11-07 10:18:44 -0800295 // How frequently the progess should be updated;the listener will only be notificated when the
296 // delta from the previous update is more than the threshold.
297 int32_t update_progress_threshold_ = 100;
298
299 // Last progress that triggered a listener updated
300 int32_t last_updated_progress_;
301
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700302 // Whether it should take an screenshot earlier in the process.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700303 bool do_early_screenshot_ = false;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700304
Felipe Leme7447d7c2016-11-03 18:12:22 -0700305 std::unique_ptr<Progress> progress_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700306
307 // When set, defines a socket file-descriptor use to report progress to bugreportz.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700308 int control_socket_fd_ = -1;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700309
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700310 // Bugreport format version;
Felipe Lemed071c682016-10-20 16:48:00 -0700311 std::string version_ = VERSION_CURRENT;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700312
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700313 // Command-line arguments as string
314 std::string args_;
315
316 // Extra options passed as system property.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700317 std::string extra_options_;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700318
319 // Full path of the directory where the bugreport files will be written.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700320 std::string bugreport_dir_;
Felipe Lemee844a9d2016-09-21 15:01:39 -0700321
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700322 // Full path of the temporary file containing the screenshot (when requested).
Felipe Leme9a523ae2016-10-20 15:10:33 -0700323 std::string screenshot_path_;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700324
325 time_t now_;
326
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700327 // Base name (without suffix or extensions) of the bugreport files, typically
328 // `bugreport-BUILD_ID`.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700329 std::string base_name_;
Felipe Lemebbaf3c12016-10-11 14:32:25 -0700330
Felipe Leme2b9b06c2016-10-14 09:13:06 -0700331 // Name is the suffix part of the bugreport files - it's typically the date (when invoked with
332 // `-d`), but it could be changed by the user..
333 std::string name_;
334
Felipe Leme1d486fe2016-10-14 18:06:47 -0700335 // Full path of the temporary file containing the bugreport.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700336 std::string tmp_path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700337
338 // Full path of the file containing the dumpstate logs.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700339 std::string log_path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700340
341 // Pointer to the actual path, be it zip or text.
Felipe Leme9a523ae2016-10-20 15:10:33 -0700342 std::string path_;
Felipe Leme1d486fe2016-10-14 18:06:47 -0700343
344 // Pointer to the zipped file.
345 std::unique_ptr<FILE, int (*)(FILE*)> zip_file{nullptr, fclose};
346
Felipe Lemec6bc8bc2016-10-27 15:58:27 -0700347 // Pointer to the zip structure.
348 std::unique_ptr<ZipWriter> zip_writer_;
349
Felipe Leme75876a22016-10-27 16:31:27 -0700350 // Binder object listing to progress.
351 android::sp<android::os::IDumpstateListener> listener_;
352 std::string listener_name_;
353
Naveen Kallab53a1c92017-03-16 18:17:25 -0700354 // Notification title and description
355 std::string notification_title;
356 std::string notification_description;
357
Luis Hector Chavez91c2ae52018-03-14 15:12:46 -0700358 // List of open tombstone dump files.
359 std::vector<DumpData> tombstone_data_;
360
361 // List of open ANR dump files.
362 std::vector<DumpData> anr_data_;
363
Felipe Lemee844a9d2016-09-21 15:01:39 -0700364 private:
Felipe Lemed80e6b62016-10-03 13:08:14 -0700365 // Used by GetInstance() only.
Felipe Lemef0292972016-11-22 13:57:05 -0800366 Dumpstate(const std::string& version = VERSION_CURRENT);
Felipe Leme062926e2016-10-27 15:51:12 -0700367
368 DISALLOW_COPY_AND_ASSIGN(Dumpstate);
Felipe Lemee844a9d2016-09-21 15:01:39 -0700369};
370
371// for_each_pid_func = void (*)(int, const char*);
372// for_each_tid_func = void (*)(int, int, const char*);
373
374typedef void(for_each_pid_func)(int, const char*);
375typedef void(for_each_tid_func)(int, int, const char*);
Felipe Leme71ca15e2016-05-19 16:18:17 -0700376
Felipe Leme71a74ac2016-03-17 15:43:25 -0700377/* saves the the contents of a file as a long */
378int read_file_as_long(const char *path, long int *output);
379
Christopher Ferris54bcc5f2015-02-10 12:15:01 -0800380/* prints the contents of the fd
381 * fd must have been opened with the flag O_NONBLOCK.
382 */
Christopher Ferris1fe61072014-07-22 16:08:19 -0700383int dump_file_from_fd(const char *title, const char *path, int fd);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700384
Mark Salyzyn326842f2015-04-30 09:49:41 -0700385/* calls skip to gate calling dump_from_fd recursively
386 * in the specified directory. dump_from_fd defaults to
387 * dump_file_from_fd above when set to NULL. skip defaults
388 * to false when set to NULL. dump_from_fd will always be
389 * called with title NULL.
390 */
Felipe Leme678727a2016-09-21 17:22:11 -0700391int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path),
392 int (*dump_from_fd)(const char* title, const char* path, int fd));
Mark Salyzyn326842f2015-04-30 09:49:41 -0700393
Felipe Leme2628e9e2016-04-12 16:36:51 -0700394/** opens a socket and returns its file descriptor */
395int open_socket(const char *service);
396
Colin Crossf45fa6b2012-03-26 12:38:26 -0700397/* redirect output to a service control socket */
398void redirect_to_socket(FILE *redirect, const char *service);
399
Felipe Leme0f3fb202016-06-10 17:10:53 -0700400/* redirect output to a new file */
Christopher Ferrisff4a4dc2015-02-09 16:24:47 -0800401void redirect_to_file(FILE *redirect, char *path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700402
Felipe Leme0f3fb202016-06-10 17:10:53 -0700403/* redirect output to an existing file */
404void redirect_to_existing_file(FILE *redirect, char *path);
405
Felipe Leme111b9d02016-02-03 09:28:24 -0800406/* create leading directories, if necessary */
407void create_parent_dirs(const char *path);
408
Jeff Brownbf7f4922012-06-07 16:40:01 -0700409/* dump Dalvik and native stack traces, return the trace file location (NULL if none) */
410const char *dump_traces();
Colin Crossf45fa6b2012-03-26 12:38:26 -0700411
412/* for each process in the system, run the specified function */
Colin Cross0c22e8b2012-11-02 15:46:56 -0700413void for_each_pid(for_each_pid_func func, const char *header);
414
415/* for each thread in the system, run the specified function */
416void for_each_tid(for_each_tid_func func, const char *header);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700417
418/* Displays a blocked processes in-kernel wait channel */
Colin Cross0c22e8b2012-11-02 15:46:56 -0700419void show_wchan(int pid, int tid, const char *name);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700420
Mark Salyzyna297c322016-02-05 15:33:17 -0800421/* Displays a processes times */
422void show_showtime(int pid, const char *name);
423
Colin Crossf45fa6b2012-03-26 12:38:26 -0700424/* Runs "showmap" for a process */
425void do_showmap(int pid, const char *name);
426
427/* Gets the dmesg output for the kernel */
428void do_dmesg();
429
Sreeram Ramachandran2b3bba32014-07-08 15:40:55 -0700430/* Prints the contents of all the routing tables, both IPv4 and IPv6. */
431void dump_route_tables();
432
Colin Crossf45fa6b2012-03-26 12:38:26 -0700433/* Play a sound via Stagefright */
Christopher Ferris1fe61072014-07-22 16:08:19 -0700434void play_sound(const char *path);
Colin Crossf45fa6b2012-03-26 12:38:26 -0700435
Felipe Leme0c80cf02016-01-05 13:25:34 -0800436/* Checks if a given path is a directory. */
437bool is_dir(const char* pathname);
438
439/** Gets the last modification time of a file, or default time if file is not found. */
440time_t get_mtime(int fd, time_t default_mtime);
441
Calvin On249beee2016-06-03 15:17:07 -0700442/* Dumps eMMC Extended CSD data. */
Felipe Leme78f2c862015-12-21 09:55:22 -0800443void dump_emmc_ecsd(const char *ext_csd_path);
444
Calvin On249beee2016-06-03 15:17:07 -0700445/** Gets command-line arguments. */
Felipe Lemea34efb72016-03-11 09:33:32 -0800446void format_args(int argc, const char *argv[], std::string *args);
Felipe Leme88c79332016-02-22 11:06:49 -0800447
Felipe Leme8620bb42015-11-10 11:04:45 -0800448#ifdef __cplusplus
449}
450#endif
451
Felipe Leme8268ed22016-08-02 18:18:25 -0700452#endif /* FRAMEWORK_NATIVE_CMD_DUMPSTATE_H_ */