cmds/dumpstate/dumpstate.cpp

   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 #include <dirent.h>
  18 #include <errno.h>
  19 #include <fcntl.h>
  20 #include <libgen.h>
  21 #include <limits.h>
  22 #include <memory>
  23 #include <regex>
  24 #include <set>
  25 #include <stdbool.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string>
  29 #include <string.h>
  30 #include <sys/capability.h>
  31 #include <sys/prctl.h>
  32 #include <sys/resource.h>
  33 #include <sys/stat.h>
  34 #include <sys/time.h>
  35 #include <sys/wait.h>
  36 #include <unistd.h>
  37
  38 #include <android-base/stringprintf.h>
  39 #include <cutils/properties.h>
  40
  41 #include "private/android_filesystem_config.h"
  42
  43 #define LOG_TAG "dumpstate"
  44 #include <cutils/log.h>
  45
  46 #include "dumpstate.h"
  47 #include "ScopedFd.h"
  48 #include "ziparchive/zip_writer.h"
  49
  50 #include "mincrypt/sha256.h"
  51
  52 using android::base::StringPrintf;
  53
  54 /* read before root is shed */
  55 static char cmdline_buf[16384] = "(unknown)";
  56 static const char *dump_traces_path = NULL;
  57
  58 // TODO: should be part of dumpstate object
  59 static char build_type[PROPERTY_VALUE_MAX];
  60 static time_t now;
  61 static std::unique_ptr<ZipWriter> zip_writer;
  62 static std::set<std::string> mount_points;
  63 void add_mountinfo();
  64 static bool add_zip_entry(const std::string& entry_name, const std::string& entry_path);
  65
  66 #define PSTORE_LAST_KMSG "/sys/fs/pstore/console-ramoops"
  67
  68 #define RAFT_DIR "/data/misc/raft/"
  69 #define RECOVERY_DIR "/cache/recovery"
  70 #define TOMBSTONE_DIR "/data/tombstones"
  71 #define TOMBSTONE_FILE_PREFIX TOMBSTONE_DIR "/tombstone_"
  72 /* Can accomodate a tombstone number up to 9999. */
  73 #define TOMBSTONE_MAX_LEN (sizeof(TOMBSTONE_FILE_PREFIX) + 4)
  74 #define NUM_TOMBSTONES  10
  75
  76 typedef struct {
  77   char name[TOMBSTONE_MAX_LEN];
  78   int fd;
  79 } tombstone_data_t;
  80
  81 static tombstone_data_t tombstone_data[NUM_TOMBSTONES];
  82
  83 // Root dir for all files copied as-is into the bugreport
  84 const std::string& ZIP_ROOT_DIR = "FS";
  85
  86 /*
  87  * List of supported zip format versions.
  88  *
  89  * See bugreport-format.txt for more info.
  90  */
  91 // TODO: change to "v1" before final N build
  92 static std::string VERSION_DEFAULT = "v1-dev1";
  93 // TODO: remove before final N build
  94 static std::string VERSION_DUMPSYS_SPLIT = "v1-dev1-dumpsys-split";
  95
  96 /* gets the tombstone data, according to the bugreport type: if zipped gets all tombstones,
  97  * otherwise gets just those modified in the last half an hour. */
  98 static void get_tombstone_fds(tombstone_data_t data[NUM_TOMBSTONES]) {
  99     time_t thirty_minutes_ago = now - 60*30;
 100     for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
 101         snprintf(data[i].name, sizeof(data[i].name), "%s%02zu", TOMBSTONE_FILE_PREFIX, i);
 102         int fd = TEMP_FAILURE_RETRY(open(data[i].name,
 103                                          O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
 104         struct stat st;
 105         if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode) &&
 106             (zip_writer || (time_t) st.st_mtime >= thirty_minutes_ago)) {
 107         data[i].fd = fd;
 108         } else {
 109         close(fd);
 110             data[i].fd = -1;
 111         }
 112     }
 113 }
 114
 115 // for_each_pid() callback to get mount info about a process.
 116 void do_mountinfo(int pid, const char *name) {
 117     char path[PATH_MAX];
 118
 119     // Gets the the content of the /proc/PID/ns/mnt link, so only unique mount points
 120     // are added.
 121     sprintf(path, "/proc/%d/ns/mnt", pid);
 122     char linkname[PATH_MAX];
 123     ssize_t r = readlink(path, linkname, PATH_MAX);
 124     if (r == -1) {
 125         MYLOGE("Unable to read link for %s: %s\n", path, strerror(errno));
 126         return;
 127     }
 128     linkname[r] = '\0';
 129
 130     if (mount_points.find(linkname) == mount_points.end()) {
 131         // First time this mount point was found: add it
 132         sprintf(path, "/proc/%d/mountinfo", pid);
 133         if (add_zip_entry(ZIP_ROOT_DIR + path, path)) {
 134             mount_points.insert(linkname);
 135         } else {
 136             MYLOGE("Unable to add mountinfo %s to zip file\n", path);
 137         }
 138     }
 139 }
 140
 141 void add_mountinfo() {
 142     if (!zip_writer) return;
 143     const char *title = "MOUNT INFO";
 144     mount_points.clear();
 145     DurationReporter duration_reporter(title, NULL);
 146     for_each_pid(do_mountinfo, NULL);
 147     MYLOGD("%s: %d entries added to zip file\n", title, (int) mount_points.size());
 148 }
 149
 150 static void dump_dev_files(const char *title, const char *driverpath, const char *filename)
 151 {
 152     DIR *d;
 153     struct dirent *de;
 154     char path[PATH_MAX];
 155
 156     d = opendir(driverpath);
 157     if (d == NULL) {
 158         return;
 159     }
 160
 161     while ((de = readdir(d))) {
 162         if (de->d_type != DT_LNK) {
 163             continue;
 164         }
 165         snprintf(path, sizeof(path), "%s/%s/%s", driverpath, de->d_name, filename);
 166         dump_file(title, path);
 167     }
 168
 169     closedir(d);
 170 }
 171
 172 static bool skip_not_stat(const char *path) {
 173     static const char stat[] = "/stat";
 174     size_t len = strlen(path);
 175     if (path[len - 1] == '/') { /* Directory? */
 176         return false;
 177     }
 178     return strcmp(path + len - sizeof(stat) + 1, stat); /* .../stat? */
 179 }
 180
 181 static bool skip_none(const char *path) {
 182     return false;
 183 }
 184
 185 static const char mmcblk0[] = "/sys/block/mmcblk0/";
 186 unsigned long worst_write_perf = 20000; /* in KB/s */
 187
 188 //
 189 //  stat offsets
 190 // Name            units         description
 191 // ----            -----         -----------
 192 // read I/Os       requests      number of read I/Os processed
 193 #define __STAT_READ_IOS      0
 194 // read merges     requests      number of read I/Os merged with in-queue I/O
 195 #define __STAT_READ_MERGES   1
 196 // read sectors    sectors       number of sectors read
 197 #define __STAT_READ_SECTORS  2
 198 // read ticks      milliseconds  total wait time for read requests
 199 #define __STAT_READ_TICKS    3
 200 // write I/Os      requests      number of write I/Os processed
 201 #define __STAT_WRITE_IOS     4
 202 // write merges    requests      number of write I/Os merged with in-queue I/O
 203 #define __STAT_WRITE_MERGES  5
 204 // write sectors   sectors       number of sectors written
 205 #define __STAT_WRITE_SECTORS 6
 206 // write ticks     milliseconds  total wait time for write requests
 207 #define __STAT_WRITE_TICKS   7
 208 // in_flight       requests      number of I/Os currently in flight
 209 #define __STAT_IN_FLIGHT     8
 210 // io_ticks        milliseconds  total time this block device has been active
 211 #define __STAT_IO_TICKS      9
 212 // time_in_queue   milliseconds  total wait time for all requests
 213 #define __STAT_IN_QUEUE     10
 214 #define __STAT_NUMBER_FIELD 11
 215 //
 216 // read I/Os, write I/Os
 217 // =====================
 218 //
 219 // These values increment when an I/O request completes.
 220 //
 221 // read merges, write merges
 222 // =========================
 223 //
 224 // These values increment when an I/O request is merged with an
 225 // already-queued I/O request.
 226 //
 227 // read sectors, write sectors
 228 // ===========================
 229 //
 230 // These values count the number of sectors read from or written to this
 231 // block device.  The "sectors" in question are the standard UNIX 512-byte
 232 // sectors, not any device- or filesystem-specific block size.  The
 233 // counters are incremented when the I/O completes.
 234 #define SECTOR_SIZE 512
 235 //
 236 // read ticks, write ticks
 237 // =======================
 238 //
 239 // These values count the number of milliseconds that I/O requests have
 240 // waited on this block device.  If there are multiple I/O requests waiting,
 241 // these values will increase at a rate greater than 1000/second; for
 242 // example, if 60 read requests wait for an average of 30 ms, the read_ticks
 243 // field will increase by 60*30 = 1800.
 244 //
 245 // in_flight
 246 // =========
 247 //
 248 // This value counts the number of I/O requests that have been issued to
 249 // the device driver but have not yet completed.  It does not include I/O
 250 // requests that are in the queue but not yet issued to the device driver.
 251 //
 252 // io_ticks
 253 // ========
 254 //
 255 // This value counts the number of milliseconds during which the device has
 256 // had I/O requests queued.
 257 //
 258 // time_in_queue
 259 // =============
 260 //
 261 // This value counts the number of milliseconds that I/O requests have waited
 262 // on this block device.  If there are multiple I/O requests waiting, this
 263 // value will increase as the product of the number of milliseconds times the
 264 // number of requests waiting (see "read ticks" above for an example).
 265 #define S_TO_MS 1000
 266 //
 267
 268 static int dump_stat_from_fd(const char *title __unused, const char *path, int fd) {
 269     unsigned long long fields[__STAT_NUMBER_FIELD];
 270     bool z;
 271     char *cp, *buffer = NULL;
 272     size_t i = 0;
 273     FILE *fp = fdopen(fd, "rb");
 274     getline(&buffer, &i, fp);
 275     fclose(fp);
 276     if (!buffer) {
 277         return -errno;
 278     }
 279     i = strlen(buffer);
 280     while ((i > 0) && (buffer[i - 1] == '\n')) {
 281         buffer[--i] = '\0';
 282     }
 283     if (!*buffer) {
 284         free(buffer);
 285         return 0;
 286     }
 287     z = true;
 288     for (cp = buffer, i = 0; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
 289         fields[i] = strtoull(cp, &cp, 10);
 290         if (fields[i] != 0) {
 291             z = false;
 292         }
 293     }
 294     if (z) { /* never accessed */
 295         free(buffer);
 296         return 0;
 297     }
 298
 299     if (!strncmp(path, mmcblk0, sizeof(mmcblk0) - 1)) {
 300         path += sizeof(mmcblk0) - 1;
 301     }
 302
 303     printf("%s: %s\n", path, buffer);
 304     free(buffer);
 305
 306     if (fields[__STAT_IO_TICKS]) {
 307         unsigned long read_perf = 0;
 308         unsigned long read_ios = 0;
 309         if (fields[__STAT_READ_TICKS]) {
 310             unsigned long long divisor = fields[__STAT_READ_TICKS]
 311                                        * fields[__STAT_IO_TICKS];
 312             read_perf = ((unsigned long long)SECTOR_SIZE
 313                            * fields[__STAT_READ_SECTORS]
 314                            * fields[__STAT_IN_QUEUE] + (divisor >> 1))
 315                                         / divisor;
 316             read_ios = ((unsigned long long)S_TO_MS * fields[__STAT_READ_IOS]
 317                            * fields[__STAT_IN_QUEUE] + (divisor >> 1))
 318                                         / divisor;
 319         }
 320
 321         unsigned long write_perf = 0;
 322         unsigned long write_ios = 0;
 323         if (fields[__STAT_WRITE_TICKS]) {
 324             unsigned long long divisor = fields[__STAT_WRITE_TICKS]
 325                                        * fields[__STAT_IO_TICKS];
 326             write_perf = ((unsigned long long)SECTOR_SIZE
 327                            * fields[__STAT_WRITE_SECTORS]
 328                            * fields[__STAT_IN_QUEUE] + (divisor >> 1))
 329                                         / divisor;
 330             write_ios = ((unsigned long long)S_TO_MS * fields[__STAT_WRITE_IOS]
 331                            * fields[__STAT_IN_QUEUE] + (divisor >> 1))
 332                                         / divisor;
 333         }
 334
 335         unsigned queue = (fields[__STAT_IN_QUEUE]
 336                              + (fields[__STAT_IO_TICKS] >> 1))
 337                                  / fields[__STAT_IO_TICKS];
 338
 339         if (!write_perf && !write_ios) {
 340             printf("%s: perf(ios) rd: %luKB/s(%lu/s) q: %u\n",
 341                    path, read_perf, read_ios, queue);
 342         } else {
 343             printf("%s: perf(ios) rd: %luKB/s(%lu/s) wr: %luKB/s(%lu/s) q: %u\n",
 344                    path, read_perf, read_ios, write_perf, write_ios, queue);
 345         }
 346
 347         /* bugreport timeout factor adjustment */
 348         if ((write_perf > 1) && (write_perf < worst_write_perf)) {
 349             worst_write_perf = write_perf;
 350         }
 351     }
 352     return 0;
 353 }
 354
 355 /* Copied policy from system/core/logd/LogBuffer.cpp */
 356
 357 #define LOG_BUFFER_SIZE (256 * 1024)
 358 #define LOG_BUFFER_MIN_SIZE (64 * 1024UL)
 359 #define LOG_BUFFER_MAX_SIZE (256 * 1024 * 1024UL)
 360
 361 static bool valid_size(unsigned long value) {
 362     if ((value < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < value)) {
 363         return false;
 364     }
 365
 366     long pages = sysconf(_SC_PHYS_PAGES);
 367     if (pages < 1) {
 368         return true;
 369     }
 370
 371     long pagesize = sysconf(_SC_PAGESIZE);
 372     if (pagesize <= 1) {
 373         pagesize = PAGE_SIZE;
 374     }
 375
 376     // maximum memory impact a somewhat arbitrary ~3%
 377     pages = (pages + 31) / 32;
 378     unsigned long maximum = pages * pagesize;
 379
 380     if ((maximum < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < maximum)) {
 381         return true;
 382     }
 383
 384     return value <= maximum;
 385 }
 386
 387 static unsigned long property_get_size(const char *key) {
 388     unsigned long value;
 389     char *cp, property[PROPERTY_VALUE_MAX];
 390
 391     property_get(key, property, "");
 392     value = strtoul(property, &cp, 10);
 393
 394     switch(*cp) {
 395     case 'm':
 396     case 'M':
 397         value *= 1024;
 398     /* FALLTHRU */
 399     case 'k':
 400     case 'K':
 401         value *= 1024;
 402     /* FALLTHRU */
 403     case '\0':
 404         break;
 405
 406     default:
 407         value = 0;
 408     }
 409
 410     if (!valid_size(value)) {
 411         value = 0;
 412     }
 413
 414     return value;
 415 }
 416
 417 /* timeout in ms */
 418 static unsigned long logcat_timeout(const char *name) {
 419     static const char global_tuneable[] = "persist.logd.size"; // Settings App
 420     static const char global_default[] = "ro.logd.size";       // BoardConfig.mk
 421     char key[PROP_NAME_MAX];
 422     unsigned long property_size, default_size;
 423
 424     default_size = property_get_size(global_tuneable);
 425     if (!default_size) {
 426         default_size = property_get_size(global_default);
 427     }
 428
 429     snprintf(key, sizeof(key), "%s.%s", global_tuneable, name);
 430     property_size = property_get_size(key);
 431
 432     if (!property_size) {
 433         snprintf(key, sizeof(key), "%s.%s", global_default, name);
 434         property_size = property_get_size(key);
 435     }
 436
 437     if (!property_size) {
 438         property_size = default_size;
 439     }
 440
 441     if (!property_size) {
 442         property_size = LOG_BUFFER_SIZE;
 443     }
 444
 445     /* Engineering margin is ten-fold our guess */
 446     return 10 * (property_size + worst_write_perf) / worst_write_perf;
 447 }
 448
 449 /* End copy from system/core/logd/LogBuffer.cpp */
 450
 451 /* dumps the current system state to stdout */
 452 static void print_header(std::string version) {
 453     char build[PROPERTY_VALUE_MAX], fingerprint[PROPERTY_VALUE_MAX];
 454     char radio[PROPERTY_VALUE_MAX], bootloader[PROPERTY_VALUE_MAX];
 455     char network[PROPERTY_VALUE_MAX], date[80];
 456
 457     property_get("ro.build.display.id", build, "(unknown)");
 458     property_get("ro.build.fingerprint", fingerprint, "(unknown)");
 459     property_get("ro.build.type", build_type, "(unknown)");
 460     property_get("ro.baseband", radio, "(unknown)");
 461     property_get("ro.bootloader", bootloader, "(unknown)");
 462     property_get("gsm.operator.alpha", network, "(unknown)");
 463     strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", localtime(&now));
 464
 465     printf("========================================================\n");
 466     printf("== dumpstate: %s\n", date);
 467     printf("========================================================\n");
 468
 469     printf("\n");
 470     printf("Build: %s\n", build);
 471     printf("Build fingerprint: '%s'\n", fingerprint); /* format is important for other tools */
 472     printf("Bootloader: %s\n", bootloader);
 473     printf("Radio: %s\n", radio);
 474     printf("Network: %s\n", network);
 475
 476     printf("Kernel: ");
 477     dump_file(NULL, "/proc/version");
 478     printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
 479     printf("Bugreport format version: %s\n", version.c_str());
 480     printf("\n");
 481 }
 482
 483 /* adds a new entry to the existing zip file. */
 484 static bool add_zip_entry_from_fd(const std::string& entry_name, int fd) {
 485     if (!zip_writer) {
 486         MYLOGD("Not adding zip entry %s from fd because zip_writer is not set\n", entry_name.c_str());
 487         return false;
 488     }
 489     MYLOGD("Adding zip entry %s\n", entry_name.c_str());
 490     int32_t err = zip_writer->StartEntryWithTime(entry_name.c_str(),
 491             ZipWriter::kCompress, get_mtime(fd, now));
 492     if (err) {
 493         MYLOGE("zip_writer->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
 494                 ZipWriter::ErrorCodeString(err));
 495         return false;
 496     }
 497
 498     std::vector<uint8_t> buffer(65536);
 499     while (1) {
 500         ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer.data(), sizeof(buffer)));
 501         if (bytes_read == 0) {
 502             break;
 503         } else if (bytes_read == -1) {
 504             MYLOGE("read(%s): %s\n", entry_name.c_str(), strerror(errno));
 505             return false;
 506         }
 507         err = zip_writer->WriteBytes(buffer.data(), bytes_read);
 508         if (err) {
 509             MYLOGE("zip_writer->WriteBytes(): %s\n", ZipWriter::ErrorCodeString(err));
 510             return false;
 511         }
 512     }
 513
 514     err = zip_writer->FinishEntry();
 515     if (err) {
 516         MYLOGE("zip_writer->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
 517         return false;
 518     }
 519
 520     return true;
 521 }
 522
 523 /* adds a new entry to the existing zip file. */
 524 static bool add_zip_entry(const std::string& entry_name, const std::string& entry_path) {
 525     ScopedFd fd(TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
 526     if (fd.get() == -1) {
 527         MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
 528         return false;
 529     }
 530
 531     return add_zip_entry_from_fd(entry_name, fd.get());
 532 }
 533
 534 /* adds a file to the existing zipped bugreport */
 535 static int _add_file_from_fd(const char *title, const char *path, int fd) {
 536     return add_zip_entry_from_fd(ZIP_ROOT_DIR + path, fd) ? 0 : 1;
 537 }
 538
 539 /* adds all files from a directory to the zipped bugreport file */
 540 void add_dir(const char *dir, bool recursive) {
 541     if (!zip_writer) {
 542         MYLOGD("Not adding dir %s because zip_writer is not set\n", dir);
 543         return;
 544     }
 545     DurationReporter duration_reporter(dir, NULL);
 546     dump_files(NULL, dir, recursive ? skip_none : is_dir, _add_file_from_fd);
 547 }
 548
 549 /* adds a text entry entry to the existing zip file. */
 550 static bool add_text_zip_entry(const std::string& entry_name, const std::string& content) {
 551     if (!zip_writer) {
 552         MYLOGD("Not adding text zip entry %s because zip_writer is not set\n", entry_name.c_str());
 553         return false;
 554     }
 555     MYLOGD("Adding zip text entry %s\n", entry_name.c_str());
 556     int32_t err = zip_writer->StartEntryWithTime(entry_name.c_str(), ZipWriter::kCompress, now);
 557     if (err) {
 558         MYLOGE("zip_writer->StartEntryWithTime(%s): %s\n", entry_name.c_str(),
 559                 ZipWriter::ErrorCodeString(err));
 560         return false;
 561     }
 562
 563     err = zip_writer->WriteBytes(content.c_str(), content.length());
 564     if (err) {
 565         MYLOGE("zip_writer->WriteBytes(%s): %s\n", entry_name.c_str(),
 566                 ZipWriter::ErrorCodeString(err));
 567         return false;
 568     }
 569
 570     err = zip_writer->FinishEntry();
 571     if (err) {
 572         MYLOGE("zip_writer->FinishEntry(): %s\n", ZipWriter::ErrorCodeString(err));
 573         return false;
 574     }
 575
 576     return true;
 577 }
 578
 579 static void dumpstate(const std::string& screenshot_path) {
 580     DurationReporter duration_reporter("DUMPSTATE");
 581     unsigned long timeout;
 582
 583     dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
 584     run_command("UPTIME", 10, "uptime", NULL);
 585     dump_files("UPTIME MMC PERF", mmcblk0, skip_not_stat, dump_stat_from_fd);
 586     dump_emmc_ecsd("/d/mmc0/mmc0:0001/ext_csd");
 587     dump_file("MEMORY INFO", "/proc/meminfo");
 588     run_command("CPU INFO", 10, "top", "-n", "1", "-d", "1", "-m", "30", "-H", NULL);
 589     run_command("PROCRANK", 20, SU_PATH, "root", "procrank", NULL);
 590     dump_file("VIRTUAL MEMORY STATS", "/proc/vmstat");
 591     dump_file("VMALLOC INFO", "/proc/vmallocinfo");
 592     dump_file("SLAB INFO", "/proc/slabinfo");
 593     dump_file("ZONEINFO", "/proc/zoneinfo");
 594     dump_file("PAGETYPEINFO", "/proc/pagetypeinfo");
 595     dump_file("BUDDYINFO", "/proc/buddyinfo");
 596     dump_file("FRAGMENTATION INFO", "/d/extfrag/unusable_index");
 597
 598     dump_file("KERNEL WAKELOCKS", "/proc/wakelocks");
 599     dump_file("KERNEL WAKE SOURCES", "/d/wakeup_sources");
 600     dump_file("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
 601     dump_file("KERNEL SYNC", "/d/sync");
 602
 603     run_command("PROCESSES AND THREADS", 10, "ps", "-Z", "-t", "-p", "-P", NULL);
 604     run_command("LIBRANK", 10, SU_PATH, "root", "librank", NULL);
 605
 606     run_command("ROUTE", 10, "route", NULL);
 607     run_command("PRINTENV", 10, "printenv", NULL);
 608     run_command("NETSTAT", 10, "netstat", NULL);
 609     run_command("LSMOD", 10, "lsmod", NULL);
 610
 611     do_dmesg();
 612
 613     run_command("LIST OF OPEN FILES", 10, SU_PATH, "root", "lsof", NULL);
 614     for_each_pid(do_showmap, "SMAPS OF ALL PROCESSES");
 615     for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
 616     for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
 617
 618     if (!screenshot_path.empty()) {
 619         MYLOGI("taking late screenshot\n");
 620         take_screenshot(screenshot_path);
 621         MYLOGI("wrote screenshot: %s\n", screenshot_path.c_str());
 622     }
 623
 624     // dump_file("EVENT LOG TAGS", "/etc/event-log-tags");
 625     // calculate timeout
 626     timeout = logcat_timeout("main") + logcat_timeout("system") + logcat_timeout("crash");
 627     if (timeout < 20000) {
 628         timeout = 20000;
 629     }
 630     run_command("SYSTEM LOG", timeout / 1000, "logcat", "-v", "threadtime",
 631                                                         "-v", "printable",
 632                                                         "-d",
 633                                                         "*:v", NULL);
 634     timeout = logcat_timeout("events");
 635     if (timeout < 20000) {
 636         timeout = 20000;
 637     }
 638     run_command("EVENT LOG", timeout / 1000, "logcat", "-b", "events",
 639                                                        "-v", "threadtime",
 640                                                        "-v", "printable",
 641                                                        "-d",
 642                                                        "*:v", NULL);
 643     timeout = logcat_timeout("radio");
 644     if (timeout < 20000) {
 645         timeout = 20000;
 646     }
 647     run_command("RADIO LOG", timeout / 1000, "logcat", "-b", "radio",
 648                                                        "-v", "threadtime",
 649                                                        "-v", "printable",
 650                                                        "-d",
 651                                                        "*:v", NULL);
 652
 653     run_command("LOG STATISTICS", 10, "logcat", "-b", "all", "-S", NULL);
 654
 655     run_command("RAFT LOGS", 600, SU_PATH, "root", "logcompressor", "-r", RAFT_DIR, NULL);
 656
 657     /* show the traces we collected in main(), if that was done */
 658     if (dump_traces_path != NULL) {
 659         dump_file("VM TRACES JUST NOW", dump_traces_path);
 660     }
 661
 662     /* only show ANR traces if they're less than 15 minutes old */
 663     struct stat st;
 664     char anr_traces_path[PATH_MAX];
 665     property_get("dalvik.vm.stack-trace-file", anr_traces_path, "");
 666     if (!anr_traces_path[0]) {
 667         printf("*** NO VM TRACES FILE DEFINED (dalvik.vm.stack-trace-file)\n\n");
 668     } else {
 669       int fd = TEMP_FAILURE_RETRY(open(anr_traces_path,
 670                                        O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK));
 671       if (fd < 0) {
 672           printf("*** NO ANR VM TRACES FILE (%s): %s\n\n", anr_traces_path, strerror(errno));
 673       } else {
 674           dump_file_from_fd("VM TRACES AT LAST ANR", anr_traces_path, fd);
 675       }
 676     }
 677
 678     /* slow traces for slow operations */
 679     if (anr_traces_path[0] != 0) {
 680         int tail = strlen(anr_traces_path)-1;
 681         while (tail > 0 && anr_traces_path[tail] != '/') {
 682             tail--;
 683         }
 684         int i = 0;
 685         while (1) {
 686             sprintf(anr_traces_path+tail+1, "slow%02d.txt", i);
 687             if (stat(anr_traces_path, &st)) {
 688                 // No traces file at this index, done with the files.
 689                 break;
 690             }
 691             dump_file("VM TRACES WHEN SLOW", anr_traces_path);
 692             i++;
 693         }
 694     }
 695
 696     int dumped = 0;
 697     for (size_t i = 0; i < NUM_TOMBSTONES; i++) {
 698         if (tombstone_data[i].fd != -1) {
 699             const char *name = tombstone_data[i].name;
 700             int fd = tombstone_data[i].fd;
 701             dumped = 1;
 702             if (zip_writer) {
 703                 if (!add_zip_entry_from_fd(ZIP_ROOT_DIR + name, fd)) {
 704                     MYLOGE("Unable to add tombstone %s to zip file\n", name);
 705                 }
 706             } else {
 707                 dump_file_from_fd("TOMBSTONE", name, fd);
 708             }
 709             close(fd);
 710             tombstone_data[i].fd = -1;
 711         }
 712     }
 713     if (!dumped) {
 714         printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR);
 715     }
 716
 717     dump_file("NETWORK DEV INFO", "/proc/net/dev");
 718     dump_file("QTAGUID NETWORK INTERFACES INFO", "/proc/net/xt_qtaguid/iface_stat_all");
 719     dump_file("QTAGUID NETWORK INTERFACES INFO (xt)", "/proc/net/xt_qtaguid/iface_stat_fmt");
 720     dump_file("QTAGUID CTRL INFO", "/proc/net/xt_qtaguid/ctrl");
 721     dump_file("QTAGUID STATS INFO", "/proc/net/xt_qtaguid/stats");
 722
 723     if (!stat(PSTORE_LAST_KMSG, &st)) {
 724         /* Also TODO: Make console-ramoops CAP_SYSLOG protected. */
 725         dump_file("LAST KMSG", PSTORE_LAST_KMSG);
 726     } else {
 727         /* TODO: Make last_kmsg CAP_SYSLOG protected. b/5555691 */
 728         dump_file("LAST KMSG", "/proc/last_kmsg");
 729     }
 730
 731     /* kernels must set CONFIG_PSTORE_PMSG, slice up pstore with device tree */
 732     run_command("LAST LOGCAT", 10, "logcat", "-L",
 733                                              "-b", "all",
 734                                              "-v", "threadtime",
 735                                              "-v", "printable",
 736                                              "-d",
 737                                              "*:v", NULL);
 738
 739     /* The following have a tendency to get wedged when wifi drivers/fw goes belly-up. */
 740
 741     run_command("NETWORK INTERFACES", 10, "ip", "link", NULL);
 742
 743     run_command("IPv4 ADDRESSES", 10, "ip", "-4", "addr", "show", NULL);
 744     run_command("IPv6 ADDRESSES", 10, "ip", "-6", "addr", "show", NULL);
 745
 746     run_command("IP RULES", 10, "ip", "rule", "show", NULL);
 747     run_command("IP RULES v6", 10, "ip", "-6", "rule", "show", NULL);
 748
 749     dump_route_tables();
 750
 751     run_command("ARP CACHE", 10, "ip", "-4", "neigh", "show", NULL);
 752     run_command("IPv6 ND CACHE", 10, "ip", "-6", "neigh", "show", NULL);
 753
 754     run_command("IPTABLES", 10, SU_PATH, "root", "iptables", "-L", "-nvx", NULL);
 755     run_command("IP6TABLES", 10, SU_PATH, "root", "ip6tables", "-L", "-nvx", NULL);
 756     run_command("IPTABLE NAT", 10, SU_PATH, "root", "iptables", "-t", "nat", "-L", "-nvx", NULL);
 757     /* no ip6 nat */
 758     run_command("IPTABLE RAW", 10, SU_PATH, "root", "iptables", "-t", "raw", "-L", "-nvx", NULL);
 759     run_command("IP6TABLE RAW", 10, SU_PATH, "root", "ip6tables", "-t", "raw", "-L", "-nvx", NULL);
 760
 761     run_command("WIFI NETWORKS", 20,
 762             SU_PATH, "root", "wpa_cli", "IFNAME=wlan0", "list_networks", NULL);
 763
 764 #ifdef FWDUMP_bcmdhd
 765     run_command("ND OFFLOAD TABLE", 5,
 766             SU_PATH, "root", "wlutil", "nd_hostip", NULL);
 767
 768     run_command("DUMP WIFI INTERNAL COUNTERS (1)", 20,
 769             SU_PATH, "root", "wlutil", "counters", NULL);
 770
 771     run_command("ND OFFLOAD STATUS (1)", 5,
 772             SU_PATH, "root", "wlutil", "nd_status", NULL);
 773
 774 #endif
 775     dump_file("INTERRUPTS (1)", "/proc/interrupts");
 776
 777     run_command("NETWORK DIAGNOSTICS", 10, "dumpsys", "connectivity", "--diag", NULL);
 778
 779 #ifdef FWDUMP_bcmdhd
 780     run_command("DUMP WIFI STATUS", 20,
 781             SU_PATH, "root", "dhdutil", "-i", "wlan0", "dump", NULL);
 782
 783     run_command("DUMP WIFI INTERNAL COUNTERS (2)", 20,
 784             SU_PATH, "root", "wlutil", "counters", NULL);
 785
 786     run_command("ND OFFLOAD STATUS (2)", 5,
 787             SU_PATH, "root", "wlutil", "nd_status", NULL);
 788 #endif
 789     dump_file("INTERRUPTS (2)", "/proc/interrupts");
 790
 791     print_properties();
 792
 793     run_command("VOLD DUMP", 10, "vdc", "dump", NULL);
 794     run_command("SECURE CONTAINERS", 10, "vdc", "asec", "list", NULL);
 795
 796     run_command("FILESYSTEMS & FREE SPACE", 10, "df", NULL);
 797
 798     run_command("LAST RADIO LOG", 10, "parse_radio_log", "/proc/last_radio_log", NULL);
 799
 800     printf("------ BACKLIGHTS ------\n");
 801     printf("LCD brightness=");
 802     dump_file(NULL, "/sys/class/leds/lcd-backlight/brightness");
 803     printf("Button brightness=");
 804     dump_file(NULL, "/sys/class/leds/button-backlight/brightness");
 805     printf("Keyboard brightness=");
 806     dump_file(NULL, "/sys/class/leds/keyboard-backlight/brightness");
 807     printf("ALS mode=");
 808     dump_file(NULL, "/sys/class/leds/lcd-backlight/als");
 809     printf("LCD driver registers:\n");
 810     dump_file(NULL, "/sys/class/leds/lcd-backlight/registers");
 811     printf("\n");
 812
 813     /* Binder state is expensive to look at as it uses a lot of memory. */
 814     dump_file("BINDER FAILED TRANSACTION LOG", "/sys/kernel/debug/binder/failed_transaction_log");
 815     dump_file("BINDER TRANSACTION LOG", "/sys/kernel/debug/binder/transaction_log");
 816     dump_file("BINDER TRANSACTIONS", "/sys/kernel/debug/binder/transactions");
 817     dump_file("BINDER STATS", "/sys/kernel/debug/binder/stats");
 818     dump_file("BINDER STATE", "/sys/kernel/debug/binder/state");
 819
 820     printf("========================================================\n");
 821     printf("== Board\n");
 822     printf("========================================================\n");
 823
 824     dumpstate_board();
 825     printf("\n");
 826
 827     /* Migrate the ril_dumpstate to a dumpstate_board()? */
 828     char ril_dumpstate_timeout[PROPERTY_VALUE_MAX] = {0};
 829     property_get("ril.dumpstate.timeout", ril_dumpstate_timeout, "30");
 830     if (strnlen(ril_dumpstate_timeout, PROPERTY_VALUE_MAX - 1) > 0) {
 831         if (0 == strncmp(build_type, "user", PROPERTY_VALUE_MAX - 1)) {
 832             // su does not exist on user builds, so try running without it.
 833             // This way any implementations of vril-dump that do not require
 834             // root can run on user builds.
 835             run_command("DUMP VENDOR RIL LOGS", atoi(ril_dumpstate_timeout),
 836                     "vril-dump", NULL);
 837         } else {
 838             run_command("DUMP VENDOR RIL LOGS", atoi(ril_dumpstate_timeout),
 839                     SU_PATH, "root", "vril-dump", NULL);
 840         }
 841     }
 842
 843     printf("========================================================\n");
 844     printf("== Android Framework Services\n");
 845     printf("========================================================\n");
 846
 847     /* the full dumpsys is starting to take a long time, so we need
 848        to increase its timeout.  we really need to do the timeouts in
 849        dumpsys itself... */
 850     run_command("DUMPSYS", 60, "dumpsys", NULL);
 851
 852     printf("========================================================\n");
 853     printf("== Checkins\n");
 854     printf("========================================================\n");
 855
 856     run_command("CHECKIN BATTERYSTATS", 30, "dumpsys", "batterystats", "-c", NULL);
 857     run_command("CHECKIN MEMINFO", 30, "dumpsys", "meminfo", "--checkin", NULL);
 858     run_command("CHECKIN NETSTATS", 30, "dumpsys", "netstats", "--checkin", NULL);
 859     run_command("CHECKIN PROCSTATS", 30, "dumpsys", "procstats", "-c", NULL);
 860     run_command("CHECKIN USAGESTATS", 30, "dumpsys", "usagestats", "-c", NULL);
 861     run_command("CHECKIN PACKAGE", 30, "dumpsys", "package", "--checkin", NULL);
 862
 863     printf("========================================================\n");
 864     printf("== Running Application Activities\n");
 865     printf("========================================================\n");
 866
 867     run_command("APP ACTIVITIES", 30, "dumpsys", "activity", "all", NULL);
 868
 869     printf("========================================================\n");
 870     printf("== Running Application Services\n");
 871     printf("========================================================\n");
 872
 873     run_command("APP SERVICES", 30, "dumpsys", "activity", "service", "all", NULL);
 874
 875     printf("========================================================\n");
 876     printf("== Running Application Providers\n");
 877     printf("========================================================\n");
 878
 879     run_command("APP SERVICES", 30, "dumpsys", "activity", "provider", "all", NULL);
 880
 881
 882     printf("========================================================\n");
 883     printf("== Final progress (pid %d): %d/%d (originally %d)\n",
 884             getpid(), progress, weight_total, WEIGHT_TOTAL);
 885     printf("========================================================\n");
 886     printf("== dumpstate: done\n");
 887     printf("========================================================\n");
 888 }
 889
 890 static void usage() {
 891     fprintf(stderr, "usage: dumpstate [-b soundfile] [-e soundfile] [-o file [-d] [-p] [-z]] [-s] [-q] [-B] [-P] [-R] [-V version]\n"
 892             "  -b: play sound file instead of vibrate, at beginning of job\n"
 893             "  -e: play sound file instead of vibrate, at end of job\n"
 894             "  -o: write to file (instead of stdout)\n"
 895             "  -d: append date to filename (requires -o)\n"
 896             "  -p: capture screenshot to filename.png (requires -o)\n"
 897             "  -z: generates zipped file (requires -o)\n"
 898             "  -s: write output to control socket (for init)\n"
 899             "  -q: disable vibrate\n"
 900             "  -B: send broadcast when finished (requires -o)\n"
 901             "  -P: send broadcast when started and update system properties on progress (requires -o and -B)\n"
 902             "  -R: take bugreport in remote mode (requires -o, -z, -d and -B, shouldn't be used with -P)\n"
 903             "  -V: sets the bugreport format version (%s or %s)\n",
 904             VERSION_DEFAULT.c_str(), VERSION_DUMPSYS_SPLIT.c_str());
 905 }
 906
 907 static void sigpipe_handler(int n) {
 908     // don't complain to stderr or stdout
 909     _exit(EXIT_FAILURE);
 910 }
 911
 912 /* adds the temporary report to the existing .zip file, closes the .zip file, and removes the
 913    temporary file.
 914  */
 915 static bool finish_zip_file(const std::string& bugreport_name, const std::string& bugreport_path,
 916         time_t now) {
 917     if (!add_zip_entry(bugreport_name, bugreport_path)) {
 918         MYLOGE("Failed to add text entry to .zip file\n");
 919         return false;
 920     }
 921     if (!add_text_zip_entry("main_entry.txt", bugreport_name)) {
 922         MYLOGE("Failed to add main_entry.txt to .zip file\n");
 923         return false;
 924     }
 925
 926     int32_t err = zip_writer->Finish();
 927     if (err) {
 928         MYLOGE("zip_writer->Finish(): %s\n", ZipWriter::ErrorCodeString(err));
 929         return false;
 930     }
 931
 932     return true;
 933 }
 934
 935 static std::string SHA256_file_hash(std::string filepath) {
 936     ScopedFd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC
 937             | O_NOFOLLOW)));
 938     if (fd.get() == -1) {
 939         MYLOGE("open(%s): %s\n", filepath.c_str(), strerror(errno));
 940         return NULL;
 941     }
 942
 943     SHA256_CTX ctx;
 944     SHA256_init(&ctx);
 945
 946     std::vector<uint8_t> buffer(65536);
 947     while (1) {
 948         ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd.get(), buffer.data(), buffer.size()));
 949         if (bytes_read == 0) {
 950             break;
 951         } else if (bytes_read == -1) {
 952             MYLOGE("read(%s): %s\n", filepath.c_str(), strerror(errno));
 953             return NULL;
 954         }
 955
 956         SHA256_update(&ctx, buffer.data(), bytes_read);
 957     }
 958
 959     uint8_t hash[SHA256_DIGEST_SIZE];
 960     memcpy(hash, SHA256_final(&ctx), SHA256_DIGEST_SIZE);
 961     char hash_buffer[SHA256_DIGEST_SIZE * 2 + 1];
 962     for(size_t i = 0; i < SHA256_DIGEST_SIZE; i++) {
 963         sprintf(hash_buffer + (i * 2), "%02x", hash[i]);
 964     }
 965     hash_buffer[sizeof(hash_buffer) - 1] = 0;
 966     return std::string(hash_buffer);
 967 }
 968
 969 /* switch to non-root user and group */
 970 bool drop_root() {
 971     /* ensure we will keep capabilities when we drop root */
 972     if (prctl(PR_SET_KEEPCAPS, 1) < 0) {
 973         MYLOGE("prctl(PR_SET_KEEPCAPS) failed: %s\n", strerror(errno));
 974         return false;
 975     }
 976
 977     gid_t groups[] = { AID_LOG, AID_SDCARD_R, AID_SDCARD_RW,
 978             AID_MOUNT, AID_INET, AID_NET_BW_STATS, AID_READPROC };
 979     if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
 980         MYLOGE("Unable to setgroups, aborting: %s\n", strerror(errno));
 981         return false;
 982     }
 983     if (setgid(AID_SHELL) != 0) {
 984         MYLOGE("Unable to setgid, aborting: %s\n", strerror(errno));
 985         return false;
 986     }
 987     if (setuid(AID_SHELL) != 0) {
 988         MYLOGE("Unable to setuid, aborting: %s\n", strerror(errno));
 989         return false;
 990     }
 991
 992     struct __user_cap_header_struct capheader;
 993     struct __user_cap_data_struct capdata[2];
 994     memset(&capheader, 0, sizeof(capheader));
 995     memset(&capdata, 0, sizeof(capdata));
 996     capheader.version = _LINUX_CAPABILITY_VERSION_3;
 997     capheader.pid = 0;
 998
 999     capdata[CAP_TO_INDEX(CAP_SYSLOG)].permitted = CAP_TO_MASK(CAP_SYSLOG);
1000     capdata[CAP_TO_INDEX(CAP_SYSLOG)].effective = CAP_TO_MASK(CAP_SYSLOG);
1001     capdata[0].inheritable = 0;
1002     capdata[1].inheritable = 0;
1003
1004     if (capset(&capheader, &capdata[0]) < 0) {
1005         MYLOGE("capset failed: %s\n", strerror(errno));
1006         return false;
1007     }
1008
1009     return true;
1010 }
1011
1012 int main(int argc, char *argv[]) {
1013     struct sigaction sigact;
1014     int do_add_date = 0;
1015     int do_zip_file = 0;
1016     int do_vibrate = 1;
1017     char* use_outfile = 0;
1018     int use_socket = 0;
1019     int do_fb = 0;
1020     int do_broadcast = 0;
1021     int do_early_screenshot = 0;
1022     int is_remote_mode = 0;
1023     std::string version = VERSION_DEFAULT;
1024
1025     now = time(NULL);
1026
1027     if (getuid() != 0) {
1028         // Old versions of the adb client would call the
1029         // dumpstate command directly. Newer clients
1030         // call /system/bin/bugreport instead. If we detect
1031         // we're being called incorrectly, then exec the
1032         // correct program.
1033         return execl("/system/bin/bugreport", "/system/bin/bugreport", NULL);
1034     }
1035
1036     MYLOGI("begin\n");
1037
1038     /* clear SIGPIPE handler */
1039     memset(&sigact, 0, sizeof(sigact));
1040     sigact.sa_handler = sigpipe_handler;
1041     sigaction(SIGPIPE, &sigact, NULL);
1042
1043     /* set as high priority, and protect from OOM killer */
1044     setpriority(PRIO_PROCESS, 0, -20);
1045     FILE *oom_adj = fopen("/proc/self/oom_adj", "we");
1046     if (oom_adj) {
1047         fputs("-17", oom_adj);
1048         fclose(oom_adj);
1049     }
1050
1051     /* parse arguments */
1052     int c;
1053     while ((c = getopt(argc, argv, "dho:svqzpPBRV:")) != -1) {
1054         switch (c) {
1055             case 'd': do_add_date = 1;          break;
1056             case 'z': do_zip_file = 1;          break;
1057             case 'o': use_outfile = optarg;     break;
1058             case 's': use_socket = 1;           break;
1059             case 'v': break;  // compatibility no-op
1060             case 'q': do_vibrate = 0;           break;
1061             case 'p': do_fb = 1;                break;
1062             case 'P': do_update_progress = 1;   break;
1063             case 'R': is_remote_mode = 1;       break;
1064             case 'B': do_broadcast = 1;         break;
1065             case 'V': version = optarg;         break;
1066             case '?': printf("\n");
1067             case 'h':
1068                 usage();
1069                 exit(1);
1070         }
1071     }
1072
1073     if ((do_zip_file || do_add_date || do_update_progress || do_broadcast) && !use_outfile) {
1074         usage();
1075         exit(1);
1076     }
1077
1078     if (do_update_progress && !do_broadcast) {
1079         usage();
1080         exit(1);
1081     }
1082
1083     if (is_remote_mode && (do_update_progress || !do_broadcast || !do_zip_file || !do_add_date)) {
1084         usage();
1085         exit(1);
1086     }
1087
1088     if (version != VERSION_DEFAULT && version != VERSION_DUMPSYS_SPLIT) {
1089         usage();
1090         exit(1);
1091     }
1092
1093     MYLOGI("bugreport format version: %s\n", version.c_str());
1094
1095     do_early_screenshot = do_update_progress;
1096
1097     // If we are going to use a socket, do it as early as possible
1098     // to avoid timeouts from bugreport.
1099     if (use_socket) {
1100         redirect_to_socket(stdout, "dumpstate");
1101     }
1102
1103     /* full path of the directory where the bugreport files will be written */
1104     std::string bugreport_dir;
1105
1106     /* full path of the temporary file containing the bugreport */
1107     std::string tmp_path;
1108
1109     /* full path of the file containing the dumpstate logs*/
1110     std::string log_path;
1111
1112     /* full path of the temporary file containing the screenshot (when requested) */
1113     std::string screenshot_path;
1114
1115     /* base name (without suffix or extensions) of the bugreport files */
1116     std::string base_name;
1117
1118     /* suffix of the bugreport files - it's typically the date (when invoked with -d),
1119      * although it could be changed by the user using a system property */
1120     std::string suffix;
1121
1122     /* pointer to the actual path, be it zip or text */
1123     std::string path;
1124
1125     /* pointer to the zipped file */
1126     std::unique_ptr<FILE, int(*)(FILE*)> zip_file(NULL, fclose);
1127
1128     /* redirect output if needed */
1129     bool is_redirecting = !use_socket && use_outfile;
1130
1131     if (is_redirecting) {
1132         bugreport_dir = dirname(use_outfile);
1133         base_name = basename(use_outfile);
1134         if (do_add_date) {
1135             char date[80];
1136             strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&now));
1137             suffix = date;
1138         } else {
1139             suffix = "undated";
1140         }
1141         if (do_fb) {
1142             // TODO: if dumpstate was an object, the paths could be internal variables and then
1143             // we could have a function to calculate the derived values, such as:
1144             //     screenshot_path = GetPath(".png");
1145             screenshot_path = bugreport_dir + "/" + base_name + "-" + suffix + ".png";
1146         }
1147         tmp_path = bugreport_dir + "/" + base_name + "-" + suffix + ".tmp";
1148         log_path = bugreport_dir + "/dumpstate_log-" + suffix + "-"
1149                 + std::to_string(getpid()) + ".txt";
1150
1151         MYLOGD("Bugreport dir: %s\n"
1152                 "Base name: %s\n"
1153                 "Suffix: %s\n"
1154                 "Log path: %s\n"
1155                 "Temporary path: %s\n"
1156                 "Screenshot path: %s\n",
1157                 bugreport_dir.c_str(), base_name.c_str(), suffix.c_str(),
1158                 log_path.c_str(), tmp_path.c_str(), screenshot_path.c_str());
1159
1160         if (do_zip_file) {
1161             MYLOGD("Creating initial .zip file\n");
1162             path = bugreport_dir + "/" + base_name + "-" + suffix + ".zip";
1163             create_parent_dirs(path.c_str());
1164             zip_file.reset(fopen(path.c_str(), "wb"));
1165             if (!zip_file) {
1166                 MYLOGE("fopen(%s, 'wb'): %s\n", path.c_str(), strerror(errno));
1167                 do_zip_file = 0;
1168             } else {
1169                 zip_writer.reset(new ZipWriter(zip_file.get()));
1170             }
1171             add_text_zip_entry("version.txt", version);
1172         }
1173
1174         if (do_update_progress) {
1175             std::vector<std::string> am_args = {
1176                  "--receiver-permission", "android.permission.DUMP",
1177                  "--es", "android.intent.extra.NAME", suffix,
1178                  "--ei", "android.intent.extra.PID", std::to_string(getpid()),
1179                  "--ei", "android.intent.extra.MAX", std::to_string(WEIGHT_TOTAL),
1180             };
1181             send_broadcast("android.intent.action.BUGREPORT_STARTED", am_args);
1182         }
1183     }
1184
1185     /* read /proc/cmdline before dropping root */
1186     FILE *cmdline = fopen("/proc/cmdline", "re");
1187     if (cmdline) {
1188         fgets(cmdline_buf, sizeof(cmdline_buf), cmdline);
1189         fclose(cmdline);
1190     }
1191
1192     /* open the vibrator before dropping root */
1193     std::unique_ptr<FILE, int(*)(FILE*)> vibrator(NULL, fclose);
1194     if (do_vibrate) {
1195         vibrator.reset(fopen("/sys/class/timed_output/vibrator/enable", "we"));
1196         if (vibrator) {
1197             vibrate(vibrator.get(), 150);
1198         }
1199     }
1200
1201     if (do_fb && do_early_screenshot) {
1202         if (screenshot_path.empty()) {
1203             // should not have happened
1204             MYLOGE("INTERNAL ERROR: skipping early screenshot because path was not set\n");
1205         } else {
1206             MYLOGI("taking early screenshot\n");
1207             take_screenshot(screenshot_path);
1208             MYLOGI("wrote screenshot: %s\n", screenshot_path.c_str());
1209             if (chown(screenshot_path.c_str(), AID_SHELL, AID_SHELL)) {
1210                 MYLOGE("Unable to change ownership of screenshot file %s: %s\n",
1211                         screenshot_path.c_str(), strerror(errno));
1212             }
1213         }
1214     }
1215
1216     if (do_zip_file) {
1217         if (chown(path.c_str(), AID_SHELL, AID_SHELL)) {
1218             MYLOGE("Unable to change ownership of zip file %s: %s\n", path.c_str(), strerror(errno));
1219         }
1220     }
1221
1222     /* collect stack traces from Dalvik and native processes (needs root) */
1223     dump_traces_path = dump_traces();
1224
1225     /* Get the tombstone fds, recovery files, and mount info here while we are running as root. */
1226     get_tombstone_fds(tombstone_data);
1227     add_dir(RECOVERY_DIR, true);
1228     add_mountinfo();
1229
1230     if (!drop_root()) {
1231         return -1;
1232     }
1233
1234     if (is_redirecting) {
1235         redirect_to_file(stderr, const_cast<char*>(log_path.c_str()));
1236         /* TODO: rather than generating a text file now and zipping it later,
1237            it would be more efficient to redirect stdout to the zip entry
1238            directly, but the libziparchive doesn't support that option yet. */
1239         redirect_to_file(stdout, const_cast<char*>(tmp_path.c_str()));
1240     }
1241     // NOTE: there should be no stdout output until now, otherwise it would break the header.
1242     // In particular, DurationReport objects should be created passing 'title, NULL', so their
1243     // duration is logged into MYLOG instead.
1244     print_header(version);
1245
1246     dumpstate(do_early_screenshot ? "": screenshot_path);
1247
1248     /* done */
1249     if (vibrator) {
1250         for (int i = 0; i < 3; i++) {
1251             vibrate(vibrator.get(), 75);
1252             usleep((75 + 50) * 1000);
1253         }
1254     }
1255
1256     /* close output if needed */
1257     if (is_redirecting) {
1258         fclose(stdout);
1259         fclose(stderr);
1260     }
1261
1262     /* rename or zip the (now complete) .tmp file to its final location */
1263     if (use_outfile) {
1264
1265         /* check if user changed the suffix using system properties */
1266         char key[PROPERTY_KEY_MAX];
1267         char value[PROPERTY_VALUE_MAX];
1268         sprintf(key, "dumpstate.%d.name", getpid());
1269         property_get(key, value, "");
1270         bool change_suffix= false;
1271         if (value[0]) {
1272             /* must whitelist which characters are allowed, otherwise it could cross directories */
1273             std::regex valid_regex("^[-_a-zA-Z0-9]+$");
1274             if (std::regex_match(value, valid_regex)) {
1275                 change_suffix = true;
1276             } else {
1277                 MYLOGE("invalid suffix provided by user: %s\n", value);
1278             }
1279         }
1280         if (change_suffix) {
1281             MYLOGI("changing suffix from %s to %s\n", suffix.c_str(), value);
1282             suffix = value;
1283             if (!screenshot_path.empty()) {
1284                 std::string new_screenshot_path =
1285                         bugreport_dir + "/" + base_name + "-" + suffix + ".png";
1286                 if (rename(screenshot_path.c_str(), new_screenshot_path.c_str())) {
1287                     MYLOGE("rename(%s, %s): %s\n", screenshot_path.c_str(),
1288                             new_screenshot_path.c_str(), strerror(errno));
1289                 } else {
1290                     screenshot_path = new_screenshot_path;
1291                 }
1292             }
1293         }
1294
1295         bool do_text_file = true;
1296         if (do_zip_file) {
1297             MYLOGD("Adding text entry to .zip bugreport\n");
1298             if (!finish_zip_file(base_name + "-" + suffix + ".txt", tmp_path, now)) {
1299                 MYLOGE("Failed to finish zip file; sending text bugreport instead\n");
1300                 do_text_file = true;
1301             } else {
1302                 do_text_file = false;
1303             }
1304         }
1305         if (do_text_file) {
1306             MYLOGD("Generating .txt bugreport\n");
1307             path = bugreport_dir + "/" + base_name + "-" + suffix + ".txt";
1308             if (rename(tmp_path.c_str(), path.c_str())) {
1309                 MYLOGE("rename(%s, %s): %s\n", tmp_path.c_str(), path.c_str(), strerror(errno));
1310                 path.clear();
1311             }
1312         }
1313     }
1314
1315     /* tell activity manager we're done */
1316     if (do_broadcast) {
1317         if (!path.empty()) {
1318             MYLOGI("Final bugreport path: %s\n", path.c_str());
1319             std::vector<std::string> am_args = {
1320                  "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
1321                  "--ei", "android.intent.extra.PID", std::to_string(getpid()),
1322                  "--es", "android.intent.extra.BUGREPORT", path,
1323                  "--es", "android.intent.extra.DUMPSTATE_LOG", log_path
1324             };
1325             if (do_fb) {
1326                 am_args.push_back("--es");
1327                 am_args.push_back("android.intent.extra.SCREENSHOT");
1328                 am_args.push_back(screenshot_path);
1329             }
1330             if (is_remote_mode) {
1331                 am_args.push_back("--es");
1332                 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
1333                 am_args.push_back(SHA256_file_hash(path));
1334                 send_broadcast("android.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
1335             } else {
1336                 send_broadcast("android.intent.action.BUGREPORT_FINISHED", am_args);
1337             }
1338         } else {
1339             MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
1340         }
1341     }
1342
1343     MYLOGD("Final progress: %d/%d (originally %d)\n", progress, weight_total, WEIGHT_TOTAL);
1344     MYLOGI("done\n");
1345
1346     return 0;
1347 }