Home | History | Annotate | Download | only in dumpstate 
      1 /*
      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 
     17 #ifndef _DUMPSTATE_H_
     18 #define _DUMPSTATE_H_
     19 
     20 /* When defined, skips the real dumps and just print the section headers.
     21    Useful when debugging dumpstate itself. */
     22 //#define _DUMPSTATE_DRY_RUN_
     23 
     24 #ifdef _DUMPSTATE_DRY_RUN_
     25 #define ON_DRY_RUN_RETURN(X) return X
     26 #define ON_DRY_RUN(code) code
     27 #else
     28 #define ON_DRY_RUN_RETURN(X)
     29 #define ON_DRY_RUN(code)
     30 #endif
     31 
     32 #ifndef MYLOGD
     33 #define MYLOGD(...) fprintf(stderr, __VA_ARGS__); ALOGD(__VA_ARGS__);
     34 #endif
     35 
     36 #ifndef MYLOGI
     37 #define MYLOGI(...) fprintf(stderr, __VA_ARGS__); ALOGI(__VA_ARGS__);
     38 #endif
     39 
     40 #ifndef MYLOGE
     41 #define MYLOGE(...) fprintf(stderr, __VA_ARGS__); ALOGE(__VA_ARGS__);
     42 #endif
     43 
     44 #include <time.h>
     45 #include <unistd.h>
     46 #include <stdbool.h>
     47 #include <stdio.h>
     48 #include <vector>
     49 
     50 #define SU_PATH "/system/xbin/su"
     51 
     52 #ifdef __cplusplus
     53 extern "C" {
     54 #endif
     55 
     56 typedef void (for_each_pid_func)(int, const char *);
     57 typedef void (for_each_tid_func)(int, int, const char *);
     58 
     59 /* Estimated total weight of bugreport generation.
     60  *
     61  * Each section contributes to the total weight by an individual weight, so the overall progress
     62  * can be calculated by dividing the all completed weight by the total weight.
     63  *
     64  * This value is defined empirically and it need to be adjusted as more sections are added.
     65  *
     66  * It does not need to match the exact sum of all sections, but ideally it should to be slight more
     67  * than such sum: a value too high will cause the bugreport to finish before the user expected (for
     68  * example, jumping from 70% to 100%), while a value too low will cause the progress to get stuck
     69  * at an almost-finished value (like 99%) for a while.
     70  */
     71 static const int WEIGHT_TOTAL = 6500;
     72 
     73 /* Most simple commands have 10 as timeout, so 5 is a good estimate */
     74 static const int WEIGHT_FILE = 5;
     75 
     76 /*
     77  * TODO: the dumpstate internal state is getting fragile; for example, this variable is defined
     78  * here, declared at utils.cpp, and used on utils.cpp and dumpstate.cpp.
     79  * It would be better to take advantage of the C++ migration and encapsulate the state in an object,
     80  * but that will be better handled in a major C++ refactoring, which would also get rid of other C
     81  * idioms (like using std::string instead of char*, removing varargs, etc...) */
     82 extern int do_update_progress, progress, weight_total;
     83 
     84 /* full path of the directory where the bugreport files will be written */
     85 extern std::string bugreport_dir;
     86 
     87 /* root dir for all files copied as-is into the bugreport. */
     88 extern const std::string ZIP_ROOT_DIR;
     89 
     90 /* adds a new entry to the existing zip file. */
     91 bool add_zip_entry(const std::string& entry_name, const std::string& entry_path);
     92 
     93 /* adds a new entry to the existing zip file. */
     94 bool add_zip_entry_from_fd(const std::string& entry_name, int fd);
     95 
     96 /* adds all files from a directory to the zipped bugreport file */
     97 void add_dir(const char *dir, bool recursive);
     98 
     99 /* prints the contents of a file */
    100 int dump_file(const char *title, const char *path);
    101 
    102 /* saves the the contents of a file as a long */
    103 int read_file_as_long(const char *path, long int *output);
    104 
    105 /* prints the contents of the fd
    106  * fd must have been opened with the flag O_NONBLOCK.
    107  */
    108 int dump_file_from_fd(const char *title, const char *path, int fd);
    109 
    110 /* calls skip to gate calling dump_from_fd recursively
    111  * in the specified directory. dump_from_fd defaults to
    112  * dump_file_from_fd above when set to NULL. skip defaults
    113  * to false when set to NULL. dump_from_fd will always be
    114  * called with title NULL.
    115  */
    116 int dump_files(const char *title, const char *dir,
    117         bool (*skip)(const char *path),
    118         int (*dump_from_fd)(const char *title, const char *path, int fd));
    119 
    120 // TODO: need to refactor all those run_command variations; there shold be just one, receiving an
    121 // optional CommandOptions objects with values such as run_always, drop_root, etc...
    122 
    123 /* forks a command and waits for it to finish -- terminate args with NULL */
    124 int run_command_as_shell(const char *title, int timeout_seconds, const char *command, ...);
    125 int run_command(const char *title, int timeout_seconds, const char *command, ...);
    126 
    127 enum RootMode { DROP_ROOT, DONT_DROP_ROOT };
    128 enum StdoutMode { NORMAL_STDOUT, REDIRECT_TO_STDERR };
    129 
    130 /* forks a command and waits for it to finish
    131    first element of args is the command, and last must be NULL.
    132    command is always ran, even when _DUMPSTATE_DRY_RUN_ is defined. */
    133 int run_command_always(const char *title, RootMode root_mode, StdoutMode stdout_mode,
    134         int timeout_seconds, const char *args[]);
    135 
    136 /* switch to non-root user and group */
    137 bool drop_root_user();
    138 
    139 /* sends a broadcast using Activity Manager */
    140 void send_broadcast(const std::string& action, const std::vector<std::string>& args);
    141 
    142 /* updates the overall progress of dumpstate by the given weight increment */
    143 void update_progress(int weight);
    144 
    145 /* prints all the system properties */
    146 void print_properties();
    147 
    148 /** opens a socket and returns its file descriptor */
    149 int open_socket(const char *service);
    150 
    151 /* redirect output to a service control socket */
    152 void redirect_to_socket(FILE *redirect, const char *service);
    153 
    154 /* redirect output to a file */
    155 void redirect_to_file(FILE *redirect, char *path);
    156 
    157 /* create leading directories, if necessary */
    158 void create_parent_dirs(const char *path);
    159 
    160 /* dump Dalvik and native stack traces, return the trace file location (NULL if none) */
    161 const char *dump_traces();
    162 
    163 /* for each process in the system, run the specified function */
    164 void for_each_pid(for_each_pid_func func, const char *header);
    165 
    166 /* for each thread in the system, run the specified function */
    167 void for_each_tid(for_each_tid_func func, const char *header);
    168 
    169 /* Displays a blocked processes in-kernel wait channel */
    170 void show_wchan(int pid, int tid, const char *name);
    171 
    172 /* Displays a processes times */
    173 void show_showtime(int pid, const char *name);
    174 
    175 /* Runs "showmap" for a process */
    176 void do_showmap(int pid, const char *name);
    177 
    178 /* Gets the dmesg output for the kernel */
    179 void do_dmesg();
    180 
    181 /* Prints the contents of all the routing tables, both IPv4 and IPv6. */
    182 void dump_route_tables();
    183 
    184 /* Play a sound via Stagefright */
    185 void play_sound(const char *path);
    186 
    187 /* Implemented by libdumpstate_board to dump board-specific info */
    188 void dumpstate_board();
    189 
    190 /* Takes a screenshot and save it to the given file */
    191 void take_screenshot(const std::string& path);
    192 
    193 /* Vibrates for a given durating (in milliseconds). */
    194 void vibrate(FILE* vibrator, int ms);
    195 
    196 /* Checks if a given path is a directory. */
    197 bool is_dir(const char* pathname);
    198 
    199 /** Gets the last modification time of a file, or default time if file is not found. */
    200 time_t get_mtime(int fd, time_t default_mtime);
    201 
    202 /* Dumps eMMC Extended CSD data. */
    203 void dump_emmc_ecsd(const char *ext_csd_path);
    204 
    205 /** Gets command-line arguments. */
    206 void format_args(int argc, const char *argv[], std::string *args);
    207 
    208 /** Tells if the device is running a user build. */
    209 bool is_user_build();
    210 
    211 /*
    212  * Helper class used to report how long it takes for a section to finish.
    213  *
    214  * Typical usage:
    215  *
    216  *    DurationReporter duration_reporter(title);
    217  *
    218  */
    219 class DurationReporter {
    220 public:
    221     DurationReporter(const char *title);
    222     DurationReporter(const char *title, FILE* out);
    223 
    224     ~DurationReporter();
    225 
    226     static uint64_t nanotime();
    227 
    228 private:
    229     const char* title_;
    230     FILE* out_;
    231     uint64_t started_;
    232 };
    233 
    234 #ifdef __cplusplus
    235 }
    236 #endif
    237 
    238 #endif /* _DUMPSTATE_H_ */
    239