Read Chrome build ID and store it in leak reports

components/metrics/leak_detector/gnu_build_id_reader.cc

Index: components/metrics/leak_detector/gnu_build_id_reader.cc
diff --git a/components/metrics/leak_detector/gnu_build_id_reader.cc b/components/metrics/leak_detector/gnu_build_id_reader.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4625c27888bdb6886a760355dd96c1a646ec32ad
--- /dev/null
+++ b/components/metrics/leak_detector/gnu_build_id_reader.cc
@@ -0,0 +1,108 @@
+// Copyright 2016 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.
+
+#include "components/metrics/leak_detector/gnu_build_id_reader.h"
+
+#include <libelf.h>
+#include <string.h>
+
+#if defined(OS_CHROMEOS)
+#include <link.h>  // for dl_iterate_phdr
+#else
+#error "Getting binary mapping info is not supported on this platform."
+#endif  // defined(OS_CHROMEOS)
+
+namespace metrics {
+namespace leak_detector {
+
+namespace {
+
+// Given a pointer and an offset, add the offset to the pointer and round it up
+// to the next uint32_t.
+const void* AlignPtrAndOffsetToUint32(const void* ptr, intptr_t offset) {
+  uintptr_t addr = reinterpret_cast<uintptr_t>(ptr) + offset;
+  uintptr_t aligned_addr =
+      (addr + sizeof(uint32_t) - 1) & ~(sizeof(uint32_t) - 1);
+  return reinterpret_cast<const void*>(aligned_addr);
+}
+
+// Searches for the ELF note containing the build ID within the data range
+// specified by [start, end). Returns the build ID in |*result|. If the build ID
+// is not found, |*result| will be unchanged.
+void GetBuildIdFromNotes(const void* start,
+                         const void* end,
+                         std::vector<uint8_t>* result) {
+  using NoteHeaderPtr = const Elf32_Nhdr*;
+  NoteHeaderPtr note = reinterpret_cast<NoteHeaderPtr>(start);
+
+  while (note < end) {
+    NoteHeaderPtr name_ptr = &note[1];
+    if (name_ptr > end) {
+      return;
+    }
+    // |desc_ptr| points the to the actual build ID data.
+    const uint8_t* desc_ptr = reinterpret_cast<const uint8_t*>(
+        AlignPtrAndOffsetToUint32(name_ptr, note->n_namesz));
+    if (note->n_type == NT_GNU_BUILD_ID &&

[Will Harris, 2016/07/18 22:03:53]

where is this build id set in the binary?

[Simon Que, 2016/07/19 00:29:34]

What do you mean? It's set by the build process.

[Will Harris, 2016/07/19 00:33:42]

that's what I mean. Where is this set? Is this a standard ELF thing or is there
some custom step in our build process setting this?

[Simon Que, 2016/07/19 00:36:36]

AFAICT it is set as part of the standard build process. When I build it using
the CrOS simplechrome workflow, the build ID is a random-looking 20-byte hash
that changes each time. I don't think there's a custom value being passed in.

+        note->n_namesz == sizeof(ELF_NOTE_GNU) &&
+        memcmp((const char*)name_ptr, ELF_NOTE_GNU, sizeof(ELF_NOTE_GNU)) ==
+            0) {
+      result->assign(desc_ptr, desc_ptr + note->n_descsz);
+    }
+    NoteHeaderPtr next_ptr = reinterpret_cast<NoteHeaderPtr>(
+        AlignPtrAndOffsetToUint32(desc_ptr, note->n_descsz));
+    note = next_ptr;
+  }
+}
+
+// Callback for dl_iterate_phdr(). Finds the notes section and looks for the
+// build ID in there. Returns the build ID in |data|, which should point to a
+// std::vector<uint8_t>.
+int FindNotesAndGetBuildID(struct dl_phdr_info* info,
+                           size_t /* size */,
+                           void* data) {
+  uintptr_t mapping_addr = reinterpret_cast<uintptr_t>(info->dlpi_addr);
+  const ElfW(Ehdr)* file_header =
+      reinterpret_cast<const ElfW(Ehdr)*>(mapping_addr);
+
+  // Make sure that a valid |mapping_addr| was read.
+  if (!file_header || file_header->e_phentsize != sizeof(ElfW(Phdr))) {
+    return 1;
+  }
+
+  for (int i = 0; i < info->dlpi_phnum; i++) {
+    // Find the ELF segment header for the NOTES section.
+    for (int i = 0; i < info->dlpi_phnum; ++i) {
+      const ElfW(Phdr)& segment_header = info->dlpi_phdr[i];
+      if (segment_header.p_type == PT_NOTE) {
+        // Elf64_Nhdr is the same as Elf32_Nhdr so we can use either here.
+        const void* note = reinterpret_cast<const void*>(
+            mapping_addr + segment_header.p_offset);
+        const void* note_end = reinterpret_cast<const void*>(
+            mapping_addr + segment_header.p_offset + segment_header.p_memsz);
+        std::vector<uint8_t>* result =
+            reinterpret_cast<std::vector<uint8_t>*>(data);
+        GetBuildIdFromNotes(note, note_end, result);
+      }
+    }
+  }
+  return 1;
+}
+
+}  // namespace
+
+GNUBuildIDReader::GNUBuildIDReader() {
+  ReadBuildID();
+}
+
+GNUBuildIDReader::~GNUBuildIDReader() {}
+
+void GNUBuildIDReader::ReadBuildID() {
+#if defined(OS_CHROMEOS)
+  dl_iterate_phdr(FindNotesAndGetBuildID, &build_id_);
+#endif  // defined(OS_CHROMEOS)
+}
+
+}  // namespace leak_detector
+}  // namespace metrics