Add some convenient metadata in Android's heap profiler dump.

tools/android/heap_profiler/heap_dump.c

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The client dump tool for libheap_profiler. It attaches to a process (given
 // its pid) and dumps all the libheap_profiler tracking information in JSON.
 // The target process is frozen (SIGSTOP) while dumping, unless the -n opt.
 // is passed (in which case the caller is responsible for un/freezing).
 // The JSON output looks like this:
 // {
@@ skipping 20 matching lines @@
 //       +---------------------> Index of the entry (as for "allocs" xref).
 //                               Indexes are hex and might not be monotonic.
 
 #include <fcntl.h>
 #include <inttypes.h>
 #include <signal.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 #include <sys/stat.h>
 
 #include "tools/android/heap_profiler/heap_profiler.h"
 
 
 static void lseek_abs(int fd, size_t off);
+static void read_proc_cmdline(char* cmdline, int size);
 
 static int pid;
 
 
-static int dump_process_heap(int mem_fd, FILE* fmaps, bool dump_also_allocs) {
+static int dump_process_heap(
+    int mem_fd,
+    FILE* fmaps,
+    bool dump_also_allocs,
+    char* comment) {
   HeapStats stats;
+  time_t tm;
+  char cmdline[512];
+
+  tm = time(NULL);
+  read_proc_cmdline(cmdline, sizeof(cmdline));
 
   // Look for the mmap which contains the HeapStats in the target process vmem.
   // On Linux/Android, the libheap_profiler mmaps explicitly /dev/zero. The
   // region furthermore starts with a magic marker to disambiguate.
   bool stats_mmap_found = false;
   for (;;) {
     char line[1024];
     if (fgets(line, sizeof(line), fmaps) == NULL)
       break;
 
@@ skipping 18 matching lines @@
   }
 
   if (!stats_mmap_found) {
     fprintf(stderr, "Could not find the HeapStats area. "
                     "It looks like libheap_profiler is not loaded.\n");
     return -1;
   }
 
   // Print JSON-formatted output.
   printf("{\n");
+  printf("  \"pid\":             %d,\n", pid);
+  printf("  \"time\":            %ld,\n", tm);
+  printf("  \"comment\":         \"%s\",\n", comment);
+  printf("  \"cmdline\":         \"%s\",\n", cmdline);
+  printf("  \"pagesize\":        %d,\n", getpagesize());
   printf("  \"total_allocated\": %zu,\n", stats.total_alloc_bytes);
   printf("  \"num_allocs\":      %"PRIu32",\n", stats.num_allocs);
   printf("  \"num_stacks\":      %"PRIu32",\n", stats.num_stack_traces);
 
   uint32_t dbg_counted_allocs = 0;
   size_t dbg_counted_total_alloc_bytes = 0;
   bool prepend_trailing_comma = false;  // JSON syntax, I hate you.
   uint32_t i;
 
   // Dump the optional allocation table.
@@ skipping 139 matching lines @@
   char path[64];
   snprintf(path, sizeof(path), "/proc/%d/maps", pid);
   FILE* fmaps = fopen(path, "r");
   if (fmaps == NULL) {
     fprintf(stderr, "Could not open %s.\n", path);
     perror("fopen");
   }
   return fmaps;
 }
 
+static void read_proc_cmdline(char* cmdline, int size) {
+  char path[64];
+  snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
+  int cmdline_fd = open(path, O_RDONLY);
+  if (cmdline_fd < 0) {
+    fprintf(stderr, "Could not open %s.\n", path);
+    perror("open");
+    cmdline[0] = '\0';
+    return;
+  }
+  int length = read(cmdline_fd, cmdline, size);
+  if (length < 0) {
+    fprintf(stderr, "Could not read %s.\n", path);
+    perror("read");
+    length = 0;
+  }
+  close(cmdline_fd);
+  cmdline[length] = '\0';
+}
+
 int main(int argc, char** argv) {
   char c;
   int ret = 0;
   bool should_freeze_process = true;
   bool dump_also_allocs = false;
+  char comment[1024] = { '\0' };
 
-
-  while (((c = getopt(argc, argv, "nx")) & 0x80) == 0) {
+  while (((c = getopt(argc, argv, "nxc:")) & 0x80) == 0) {
    switch (c) {
       case 'n':
         should_freeze_process = false;
         break;
       case 'x':
         dump_also_allocs = true;
         break;
+      case 'c':
+        strlcpy(comment, optarg, sizeof(comment));
+        break;
      }
   }
 
   if (optind >= argc) {
-    printf("Usage: %s [-n] [-x] pid\n", argv[0]);
+    printf("Usage: %s [-n] [-x] [-c comment] pid\n", argv[0]);
     return -1;
   }
 
   pid = atoi(argv[optind]);
 
   if (should_freeze_process && !freeze_process())
     return -1;
 
   // Wait for the process to actually freeze.
   waitpid(pid, NULL, 0);
 
   int mem_fd = open_proc_mem_fd();
   if (mem_fd < 0)
     ret = -1;
 
   FILE* fmaps = open_proc_maps();
   if (fmaps == NULL)
     ret = -1;
 
   if (ret == 0)
-    ret = dump_process_heap(mem_fd, fmaps, dump_also_allocs);
+    ret = dump_process_heap(mem_fd, fmaps, dump_also_allocs, comment);
 
   if (should_freeze_process)
     kill(pid, SIGCONT);
 
   // Cleanup.
   fflush(stdout);
   close(mem_fd);
   fclose(fmaps);
   return ret;
 }