Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 52952b1b authored by Dan Egnor's avatar Dan Egnor
Browse files

Overhaul of dumpstate (aka bugreport) with cleanups & enhancements: 

- include basic build & timestamp information in the header
- collect stack traces immediately at bugreport time
- *also* show stack traces from last ANR (as before), if in the last 15 minutes
- alphabetize system properties dump
- remove now-obsolete (and always questionable) "dumpcrash" functionality
- write to a .tmp file first, then rename to the final filename
- friendly usage message
- output sections include the exact file/command run
- source de-weirdification -- it's several hundred lines shorter now

The same data is present in the same order as before, and I've tried
to preserve all the grep/search targets people might use to find their
way through the file.
parent 96e40b4b

cmds/dumpstate/Android.mk

+0 −11
Original line number Diff line number Diff line
@@ -15,15 +15,4 @@ LOCAL_SHARED_LIBRARIES := libcutils 


include $(BUILD_EXECUTABLE)



COMMANDS = dumpcrash

SYMLINKS := $(addprefix $(TARGET_OUT_EXECUTABLES)/,$(COMMANDS))

$(SYMLINKS): DUMPSTATE_BINARY := dumpstate

$(SYMLINKS): $(LOCAL_INSTALLED_MODULE) $(LOCAL_PATH)/Android.mk

	@echo "Symlink: $@ -> $(DUMPSTATE_BINARY)"

	@mkdir -p $(dir $@)

	@rm -rf $@

	$(hide) ln -sf $(DUMPSTATE_BINARY) $@



ALL_DEFAULT_INSTALLED_MODULES += $(SYMLINKS)



endif

cmds/dumpstate/dumpstate.c

+197 −304
Original line number Diff line number Diff line
@@ -14,361 +14,254 @@ 
 * limitations under the License.

 */



#include <errno.h>

#include <fcntl.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <limits.h>

#include <errno.h>

#include <fcntl.h>

#include <sys/time.h>

#include <sys/resource.h>

#include <unistd.h>



#include <cutils/sockets.h>

#include "private/android_filesystem_config.h"

#include <cutils/properties.h>



#include "private/android_filesystem_config.h"



#define LOG_TAG "dumpstate"

#include <utils/Log.h>



#include "dumpstate.h"



static char* const gzip_args[] = { "gzip", "-6", 0 };

static int start_pattern[] = { 150, 0 };

static int end_pattern[] = { 75, 50, 75, 50, 75, 0 };

/* read before root is shed */

static char cmdline_buf[16384] = "(unknown)";

static const char *dump_traces_path = NULL;



static struct tm now;

/* dumps the current system state to stdout */

static void dumpstate() {

    time_t now = time(NULL);

    char build[PROPERTY_VALUE_MAX], fingerprint[PROPERTY_VALUE_MAX];

    char radio[PROPERTY_VALUE_MAX], bootloader[PROPERTY_VALUE_MAX];

    char network[PROPERTY_VALUE_MAX], date[80];



    property_get("ro.build.display.id", build, "(unknown)");

    property_get("ro.build.fingerprint", fingerprint, "(unknown)");

    property_get("ro.baseband", radio, "(unknown)");

    property_get("ro.bootloader", bootloader, "(unknown)");

    property_get("gsm.operator.alpha", network, "(unknown)");

    strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now));



    printf("========================================================\n");

    printf("== dumpstate: %s\n", date);

    printf("========================================================\n");



    printf("\n");

    printf("Build: %s\n", build);

    printf("Bootloader: %s\n", bootloader);

    printf("Radio: %s\n", radio);

    printf("Network: %s\n", network);



    printf("Kernel: ");

    dump_file(NULL, "/proc/version");

    printf("Command line: %s\n", strtok(cmdline_buf, "\n"));

    printf("\n");



    dump_file("MEMORY INFO", "/proc/meminfo");

    run_command("CPU INFO", 10, "top", "-n", "1", "-d", "1", "-m", "30", "-t", NULL);

    run_command("PROCRANK", 20, "procrank", NULL);

    dump_file("VIRTUAL MEMORY STATS", "/proc/vmstat");

    dump_file("VMALLOC INFO", "/proc/vmallocinfo");

    dump_file("SLAB INFO", "/proc/slabinfo");

    dump_file("ZONEINFO", "/proc/zoneinfo");



    run_command("SYSTEM LOG", 20, "logcat", "-v", "time", "-d", "*:v", NULL);



    /* show the traces we collected in main(), if that was done */

    if (dump_traces_path != NULL) {

        dump_file("VM TRACES JUST NOW", dump_traces_path);

    }



static void dump_kernel_log(const char *path, const char *title) ;

    /* only show ANR traces if they're less than 15 minutes old */

    struct stat st;

    char anr_traces_path[PATH_MAX];

    property_get("dalvik.vm.stack-trace-file", anr_traces_path, "");

    if (anr_traces_path[0] && !stat(anr_traces_path, &st) && time(NULL) - st.st_mtime < 15 * 60) {

        dump_file("VM TRACES AT LAST ANR", anr_traces_path);

    }



    // dump_file("EVENT LOG TAGS", "/etc/event-log-tags");

    run_command("EVENT LOG", 20, "logcat", "-b", "events", "-v", "time", "-d", "*:v", NULL);

    run_command("RADIO LOG", 20, "logcat", "-b", "radio", "-v", "time", "-d", "*:v", NULL);



    run_command("NETWORK INTERFACES", 10, "netcfg", NULL);

    dump_file("NETWORK ROUTES", "/proc/net/route");



/* dumps the current system state to stdout */

static void dumpstate(int full) {

    if (full) {

        PRINT("========================================================");

        PRINT("== dumpstate");

        PRINT("========================================================");

        PRINT("------ MEMORY INFO ------");

        DUMP("/proc/meminfo");

        PRINT("------ CPU INFO ------");

        EXEC7("top", "-n", "1", "-d", "1", "-m", "30", "-t");

        PRINT("------ PROCRANK ------");

        EXEC_XBIN("procrank");

        PRINT("------ VIRTUAL MEMORY STATS ------");

        DUMP("/proc/vmstat");

        PRINT("------ VMALLOC INFO ------");

        DUMP("/proc/vmallocinfo");

        PRINT("------ SLAB INFO ------");

        DUMP("/proc/slabinfo");

        PRINT("------ ZONEINFO ------");

        DUMP("/proc/zoneinfo");

        PRINT("------ SYSTEM LOG ------");

        EXEC4("logcat", "-v", "time", "-d", "*:v");

        PRINT("------ VM TRACES ------");

        DUMP("/data/anr/traces.txt");

        PRINT("------ EVENT LOG TAGS ------");

        DUMP("/etc/event-log-tags");

        PRINT("------ EVENT LOG ------");

        EXEC6("logcat", "-b", "events", "-v", "time", "-d", "*:v");

        PRINT("------ RADIO LOG ------");

        EXEC6("logcat", "-b", "radio", "-v", "time", "-d", "*:v");

        PRINT("------ NETWORK STATE ------");

        PRINT("Interfaces:");

        EXEC("netcfg");

        PRINT("");

        PRINT("Routes:");

        DUMP("/proc/net/route");

#ifdef FWDUMP_bcm4329

        PRINT("Dump wlan FW log");

        EXEC_XBIN6("su", "root","dhdutil","-i","eth0","upload","/data/local/tmp/wlan_crash.dump");

    run_command("DUMP WIFI FIRMWARE LOG", 60,

            "dhdutil", "-i", "eth0", "upload", "/data/local/tmp/wlan_crash.dump", NULL);

#endif

        PRINT("------ SYSTEM PROPERTIES ------");



    print_properties();

        PRINT("------ KERNEL LOG ------");

        EXEC("dmesg");

        PRINT("------ KERNEL WAKELOCKS ------");

        DUMP("/proc/wakelocks");

        PRINT("------ KERNEL CPUFREQ ------");

        DUMP("/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");

        PRINT("");

        PRINT("------ PROCESSES ------");

        EXEC1("ps", "-P");

        PRINT("------ PROCESSES AND THREADS ------");

        EXEC3("ps", "-t", "-p", "-P");

        PRINT("------ LIBRANK ------");

        EXEC_XBIN("librank");

        PRINT("------ BINDER FAILED TRANSACTION LOG ------");

        DUMP("/proc/binder/failed_transaction_log");

        PRINT("");

        PRINT("------ BINDER TRANSACTION LOG ------");

        DUMP("/proc/binder/transaction_log");

        PRINT("");

        PRINT("------ BINDER TRANSACTIONS ------");

        DUMP("/proc/binder/transactions");

        PRINT("");

        PRINT("------ BINDER STATS ------");

        DUMP("/proc/binder/stats");

        PRINT("");

        PRINT("------ BINDER PROCESS STATE: $i ------");

        DUMP_FILES("/proc/binder/proc");

        PRINT("------ FILESYSTEMS ------");

        EXEC("df");

        PRINT("------ PACKAGE SETTINGS ------");

        DUMP("/data/system/packages.xml");

        PRINT("------ PACKAGE UID ERRORS ------");

        DUMP("/data/system/uiderrors.txt");



        dump_kernel_log("/proc/last_kmsg", "LAST KMSG");



        PRINT("------ LAST RADIO LOG ------");

        EXEC1("parse_radio_log", "/proc/last_radio_log");



        dump_kernel_log("/data/dontpanic/apanic_console",

                        "PANIC CONSOLE");

        dump_kernel_log("/data/dontpanic/apanic_threads",

                        "PANIC THREADS");



        PRINT("------ BACKLIGHTS ------");

        DUMP_PROMPT("LCD brightness=", "/sys/class/leds/lcd-backlight/brightness");

        DUMP_PROMPT("Button brightness=", "/sys/class/leds/button-backlight/brightness");

        DUMP_PROMPT("Keyboard brightness=", "/sys/class/leds/keyboard-backlight/brightness");

        DUMP_PROMPT("ALS mode=", "/sys/class/leds/lcd-backlight/als");

        DUMP_PROMPT("LCD driver registers:\n", "/sys/class/leds/lcd-backlight/registers");

    }

    PRINT("========================================================");

    PRINT("== build.prop");

    PRINT("========================================================");



    /* the crash server parses key-value pairs between the VERSION INFO and

     * END lines so we can aggregate crash reports based on this data.

     */

    PRINT("------ VERSION INFO ------");

    print_date("currenttime=", &now);

    DUMP_PROMPT("kernel.version=", "/proc/version");

    DUMP_PROMPT("kernel.cmdline=", "/proc/cmdline");

    DUMP("/system/build.prop");

    PROPERTY("gsm.version.ril-impl");

    PROPERTY("gsm.version.baseband");

    PROPERTY("gsm.imei");

    PROPERTY("gsm.sim.operator.numeric");

    PROPERTY("gsm.operator.alpha");

    PRINT("------ END ------");



    if (full) {

        PRINT("========================================================");

        PRINT("== dumpsys");

        PRINT("========================================================");

        /* the full dumpsys is starting to take a long time, so we need

           to increase its timeout.  we really need to do the timeouts in

           dumpsys itself... */

        EXEC_TIMEOUT("dumpsys", 60);

    }

}

    run_command("KERNEL LOG", 20, "dmesg", NULL);



/* used to check the file name passed via argv[0] */

static int check_command_name(const char* name, const char* test) {

    int name_length, test_length;

    dump_file("KERNEL WAKELOCKS", "/proc/wakelocks");

    dump_file("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");



    if (!strcmp(name, test))

        return 1;

    run_command("PROCESSES", 10, "ps", "-P", NULL);

    run_command("PROCESSES AND THREADS", 10, "ps", "-t", "-p", "-P", NULL);

    run_command("LIBRANK", 10, "librank", NULL);



    name_length = strlen(name);

    test_length = strlen(test);

    dump_file("BINDER FAILED TRANSACTION LOG", "/proc/binder/failed_transaction_log");

    dump_file("BINDER TRANSACTION LOG", "/proc/binder/transaction_log");

    dump_file("BINDER TRANSACTIONS", "/proc/binder/transactions");

    dump_file("BINDER STATS", "/proc/binder/stats");

    run_command("BINDER PROCESS STATE", 10, "sh", "-c", "cat /proc/binder/proc/*");



    if (name_length > test_length + 2) {

        name += (name_length - test_length);

        if (name[-1] != '/')

            return 0;

        if (!strcmp(name, test))

            return 1;

    run_command("FILESYSTEMS & FREE SPACE", 10, "df", NULL);



    dump_file("PACKAGE SETTINGS", "/data/system/packages.xml");

    dump_file("PACKAGE UID ERRORS", "/data/system/uiderrors.txt");



    dump_file("LAST KMSG", "/proc/last_kmsg");

    run_command("LAST RADIO LOG", 10, "parse_radio_log", "/proc/last_radio_log", NULL);

    dump_file("LAST PANIC CONSOLE", "/data/dontpanic/apanic_console");

    dump_file("LAST PANIC THREADS", "/data/dontpanic/apanic_threads");



    printf("----- BACKLIGHTS -----\n");

    printf("LCD brightness=");

    dump_file(NULL, "/sys/class/leds/lcd-backlight/brightness");

    printf("Button brightness=");

    dump_file(NULL, "/sys/class/leds/button-backlight/brightness");

    printf("Keyboard brightness=");

    dump_file(NULL, "/sys/class/leds/keyboard-backlight/brightness");

    printf("ALS mode=");

    dump_file(NULL, "/sys/class/leds/lcd-backlight/als");

    printf("LCD driver registers:\n");

    dump_file(NULL, "/sys/class/leds/lcd-backlight/registers");

    printf("\n");



    printf("========================================================\n");

    printf("== Android Framework Services\n");

    printf("========================================================\n");



    /* the full dumpsys is starting to take a long time, so we need

       to increase its timeout.  we really need to do the timeouts in

       dumpsys itself... */

    run_command("DUMPSYS", 60, "dumpsys", NULL);

}



    return 0;



static void usage() {

    fprintf(stderr, "usage: dumpstate [-d] [-o file] [-s] [-z]\n"

            "  -d: append date to filename (requires -o)\n"

            "  -o: write to file (instead of stdout)\n"

            "  -s: write output to control socket (for init)\n"

            "  -z: gzip output (requires -o)\n");

}



int main(int argc, char *argv[]) {

    int dumpcrash = check_command_name(argv[0], "dumpcrash");

    int add_date = 0;

    char* outfile = 0;

    int vibrate = 0;

    int compress = 0;

    int socket = 0;

    int c, fd, vibrate_fd, fds[2];

    char path[PATH_MAX];

    pid_t   pid;

    gid_t groups[] = { AID_LOG, AID_SDCARD_RW };

    int do_add_date = 0;

    int do_compress = 0;

    char* use_outfile = 0;

    int use_socket = 0;



    LOGI("begin\n");



    /* set as high priority, and protect from OOM killer */

    setpriority(PRIO_PROCESS, 0, -20);

    protect_from_oom_killer();

    FILE *oom_adj = fopen("/proc/self/oom_adj", "w");

    if (oom_adj) {

        fputs("-17", oom_adj);

        fclose(oom_adj);

    }



    get_time(&now);

    /* very first thing, collect VM traces from Dalvik (needs root) */

    dump_traces_path = dump_vm_traces();



    do {

        c = getopt(argc, argv, "do:svz");

        if (c == EOF)

            break;

    int c;

    while ((c = getopt(argc, argv, "dho:svz")) != -1) {

        switch (c) {

            case 'd':

                add_date = 1;

                break;

            case 'o':

                outfile = optarg;

                break;

            case 'v':

                vibrate = 1;

                break;

            case 'z':

                compress = 1;

                break;

            case 's':

                socket = 1;

                break;

            case '?':

            fprintf(stderr, "%s: invalid option -%c\n",

                argv[0], optopt);

            case 'd': do_add_date = 1;       break;

            case 'o': use_outfile = optarg;  break;

            case 's': use_socket = 1;        break;

            case 'v': break;  // compatibility no-op

            case 'z': do_compress = 6;       break;

            case '?': printf("\n");

            case 'h':

                usage();

                exit(1);

        }

    } while (1);

    }



    /* open vibrator before switching user */

    if (vibrate) {

        vibrate_fd = open("/sys/class/timed_output/vibrator/enable", O_WRONLY);

        if (vibrate_fd > 0)

            fcntl(vibrate_fd, F_SETFD, FD_CLOEXEC);

    } else

        vibrate_fd = -1;

    /* open the vibrator before dropping root */

    FILE *vibrator = fopen("/sys/class/timed_output/vibrator/enable", "w");

    if (vibrator) fcntl(fileno(vibrator), F_SETFD, FD_CLOEXEC);



    /* read /proc/cmdline before dropping root */

    FILE *cmdline = fopen("/proc/cmdline", "r");

    if (cmdline != NULL) {

        fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);

        fclose(cmdline);

    }



    /* switch to non-root user and group */

    gid_t groups[] = { AID_LOG, AID_SDCARD_RW };

    setgroups(sizeof(groups)/sizeof(groups[0]), groups);

    setuid(AID_SHELL);



    /* make it safe to use both printf and STDOUT_FILENO */ 

    setvbuf(stdout, 0, _IONBF, 0);



    if (socket) {

        struct sockaddr addr;

        socklen_t alen;



        int s = android_get_control_socket("dumpstate");

        if (s < 0) {

            fprintf(stderr, "could not open dumpstate socket\n");

            exit(1);

    char path[PATH_MAX], tmp_path[PATH_MAX];

    pid_t gzip_pid = -1;



    if (use_socket) {

        redirect_to_socket(stdout, "dumpstate");

    } else if (use_outfile) {

        strlcpy(path, use_outfile, sizeof(path));

        if (do_add_date) {

            char date[80];

            time_t now = time(NULL);

            strftime(date, sizeof(date), "-%Y-%m-%d-%H-%M-%S", localtime(&now));

            strlcat(path, date, sizeof(path));

        }

        if (listen(s, 4) < 0) {

            fprintf(stderr, "could not listen on dumpstate socket\n");

            exit(1);

        strlcat(path, ".txt", sizeof(path));

        if (do_compress) strlcat(path, ".gz", sizeof(path));

        strlcpy(tmp_path, path, sizeof(tmp_path));

        strlcat(tmp_path, ".tmp", sizeof(tmp_path));

        gzip_pid = redirect_to_file(stdout, tmp_path, do_compress);

    }



        alen = sizeof(addr);

        fd = accept(s, &addr, &alen);

        if (fd < 0) {

            fprintf(stderr, "could not accept dumpstate socket\n");

            exit(1);

    /* bzzzzzz */

    if (vibrator) {

        fputs("150", vibrator);

        fflush(vibrator);

    }



        /* redirect stdout to the socket */

        dup2(fd, STDOUT_FILENO);

        close(fd);

    } else if (outfile) {

        if (strlen(outfile) > sizeof(path) - 100)

            exit(1);

    dumpstate();



        strcpy(path, outfile);

        if (add_date) {

            char date[260];

            strftime(date, sizeof(date),

                "-%Y-%m-%d-%H-%M-%S",

                &now);

            strcat(path, date);

    /* bzzz bzzz bzzz */

    if (vibrator) {

        int i;

        for (i = 0; i < 3; i++) {

            fputs("75\n", vibrator);

            fflush(vibrator);

            usleep((75 + 50) * 1000);

        }

        if (compress)

            strcat(path, ".gz");

        else

            strcat(path, ".txt");



        /* ensure that all directories in the path exist */ 

        create_directories(path);

        fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

        if (fd < 0)

            return fd;



        if (compress) {

            pipe(fds);



            /* redirect our stdout to the pipe */

            dup2(fds[1], STDOUT_FILENO);

            close(fds[1]);



            if ((pid = fork()) < 0)

            {

                fprintf(stderr, "fork error\n");

                exit(1);

        fclose(vibrator);

    }



            if (pid) {

                /* parent case */



                /* close our copy of the input to gzip */

                close(fds[0]);

                /* close our copy of the output file */

                close(fd);

            } else {

                /* child case */



               /* redirect our input pipe to stdin */

                dup2(fds[0], STDIN_FILENO);

                close(fds[0]);



                /* redirect stdout to the output file */

                dup2(fd, STDOUT_FILENO);

                close(fd);



                /* run gzip to postprocess our output */

                execv("/system/bin/gzip", gzip_args);

                fprintf(stderr, "execv returned\n");

            }

        } else {

            /* redirect stdout to the output file */

            dup2(fd, STDOUT_FILENO);

            close(fd);

        }

    /* wait for gzip to finish, otherwise it might get killed when we exit */

    if (gzip_pid > 0) {

        fclose(stdout);

        waitpid(gzip_pid, NULL, 0);

    }

    /* else everything will print to stdout */



    if (vibrate) {

        vibrate_pattern(vibrate_fd, start_pattern);

    /* rename the (now complete) .tmp file to its final location */

    if (use_outfile && rename(tmp_path, path)) {

        fprintf(stderr, "rename(%s, %s): %s\n", tmp_path, path, strerror(errno));

    }

    dumpstate(!dumpcrash);

    if (vibrate) {

        vibrate_pattern(vibrate_fd, end_pattern);

        close(vibrate_fd);

    }



    /* so gzip will terminate */

    close(STDOUT_FILENO);



    LOGI("done\n");



    return 0;

}
 


static void dump_kernel_log(const char *path, const char *title) 



{

    printf("------ KERNEL %s LOG ------\n", title);

    if (access(path, R_OK) < 0)

        printf("%s: %s\n", path, strerror(errno));

    else {

        struct stat sbuf;



        if (stat(path, &sbuf) < 0)

            printf("%s: stat failed (%s)\n", path, strerror(errno));

        else

            printf("Harvested %s", ctime(&sbuf.st_mtime));

    

        DUMP(path);

    }

}

cmds/dumpstate/dumpstate.h

+10 −143
Original line number Diff line number Diff line
@@ -18,157 +18,24 @@ 
#define _DUMPSTATE_H_



#include <time.h>



// Commands time out after 60 seconds

#define TIMEOUT     60



#define PRINT(s) printf("%s\n", s)



#define DUMP(file) dump_file(file)



#define DUMP_FILES(path) dump_files(path)



#define DUMP_PROMPT(prompt, file)   \

{                                   \

    printf(prompt);                 \

    dump_file(file);                \

}



#define EXEC(cmd)               \

{                               \

    static struct Command c = { \

        "/system/bin/" cmd,     \

        { cmd, 0 }              \

    };                          \

    run_command(&c, TIMEOUT);   \

}



#define EXEC_TIMEOUT(cmd, tmout)\

{                               \

    static struct Command c = { \

        "/system/bin/" cmd,     \

        { cmd, 0 }              \

    };                          \

    run_command(&c, tmout);     \

}



#define EXEC_XBIN(cmd)          \

{                               \

    static struct Command c = { \

        "/system/xbin/" cmd,    \

        { cmd, 0 }              \

    };                          \

    run_command(&c, TIMEOUT);   \

}



#define EXEC1(cmd, a1)          \

{                               \

    static struct Command c = { \

        "/system/bin/" cmd,     \

        { cmd, a1, 0 }          \

    };                          \

    run_command(&c, TIMEOUT);   \

}



#define EXEC2(cmd, a1, a2)      \

{                               \

    static struct Command c = { \

        "/system/bin/" cmd,     \

        { cmd, a1, a2, 0 }      \

    };                          \

    run_command(&c, TIMEOUT);   \

}



#define EXEC3(cmd, a1, a2, a3)      \

{                                   \

    static struct Command c = {     \

        "/system/bin/" cmd,         \

        { cmd, a1, a2, a3, 0 }      \

    };                              \

    run_command(&c, TIMEOUT);       \

}



#define EXEC4(cmd, a1, a2, a3, a4)  \

{                                   \

    static struct Command c = {     \

        "/system/bin/" cmd,         \

        { cmd, a1, a2, a3, a4, 0 }  \

    };                              \

    run_command(&c, TIMEOUT);       \

}



#define EXEC6(cmd, a1, a2, a3, a4, a5, a6)  \

{                                           \

    static struct Command c = {             \

        "/system/bin/" cmd,                 \

        { cmd, a1, a2, a3, a4, a5, a6, 0 }  \

    };                                      \

    run_command(&c, TIMEOUT);               \

}



#define EXEC7(cmd, a1, a2, a3, a4, a5, a6, a7)  \

{                                               \

    static struct Command c = {                 \

        "/system/bin/" cmd,                     \

        { cmd, a1, a2, a3, a4, a5, a6, a7, 0 }  \

    };                                          \

    run_command(&c, TIMEOUT);                   \

}



#define EXEC8(cmd, a1, a2, a3, a4, a5, a6, a7, a8)  \

{                                                   \

    static struct Command c = {                     \

        "/system/bin/" cmd,                         \

        { cmd, a1, a2, a3, a4, a5, a6, a7, a8, 0 }  \

    };                                              \

    run_command(&c, TIMEOUT);                       \

}



#define EXEC_XBIN6(cmd, a1, a2, a3, a4, a5, a6)  \

{                                           \

    static struct Command c = {             \

        "/system/xbin/" cmd,                \

        { cmd, a1, a2, a3, a4, a5, a6, 0 }  \

    };                                      \

    run_command(&c, TIMEOUT);               \

}



#define PROPERTY(name) print_property(name)



struct Command {

    const char* path;

    char* const args[];

};

typedef struct Command Command;

#include <unistd.h>



/* prints the contents of a file */

int dump_file(const char* path);



/* prints the contents of all files in a directory */

void dump_files(const char* path);



/* forks a command and waits for it to finish */

int run_command(struct Command* cmd, int timeout);



/* reads the current time into tm */

void get_time(struct tm *tm);



/* prints the date in tm */

void print_date(const char* prompt, struct tm *tm);

int dump_file(const char *title, const char* path);



/* prints the name and value of a system property */

int print_property(const char* name);

/* forks a command and waits for it to finish -- terminate args with NULL */

int run_command(const char *title, int timeout_seconds, const char *command, ...);



/* prints all the system properties */

void print_properties();



/* creates directories as needed for the given path */

void create_directories(char *path);

/* redirect output to a service control socket */

void redirect_to_socket(FILE *redirect, const char *service);



/* runs the vibrator using the given pattern */

void vibrate_pattern(int fd, int* pattern);

/* redirect output to a file, optionally gzipping; returns gzip pid */

pid_t redirect_to_file(FILE *redirect, char *path, int gzip_level);



/* prevents the OOM killer from killing us */

void protect_from_oom_killer();

/* dump Dalvik stack traces, return the trace file location (NULL if none) */

const char *dump_vm_traces();



#endif /* _DUMPSTATE_H_ */

cmds/dumpstate/utils.c

+266 −146

File changed.

Preview size limit exceeded, changes collapsed.