[sanitizers] include build ids in stacks on linux.

[vitalybuka]

This is in sanitizer_common, so we need a test, TEST(SanitizerStacktracePrinter, ...)

[fmayer]

fix errors on x86

[fmayer]

PTAL. As hwasan_symbolize only matches a prefix of the line. it doesn't need to be changed.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

599 ↗

(On Diff #390536)

This already exists as RoundUpTo

628 ↗

(On Diff #390536)

Technically, kGnuNamesz should be rounded up, too - but it's already 4. Do it anyway, for clarity?

633 ↗

(On Diff #390536)

It would be good to do more checks here - first that the entire nhdr fits in p_memsz, then the name/value data, too.

compiler-rt/test/hwasan/TestCases/build-ids.c

3

Could you use symbolize=0 in %env_hwasan_opts instead?

compiler-rt/test/sanitizer_common/android_commands/android_run.py

16

is this for HWASAN_SYMBOLIZER_PATH?

[fmayer]

address comments.

[fmayer]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

628 ↗

(On Diff #390536)

Added a static_assert.

633 ↗

(On Diff #390536)

We do check that the nhdr fits into p_memsz in the condition of the loop.

Added a check before doing the memcmp and memcpy as an extra precaution.

compiler-rt/test/sanitizer_common/android_commands/android_run.py

16

Yes, it was. But it's now unneeded.

[eugenis]

LGTM

[thakis]

Looks like the new test doesn't pass: http://45.33.8.238/linux/62840/step_10.txt

[fmayer]

Reverted in 06430acc00054f6d2385b631d405226c6deeb6ea.

[fmayer]

fix tests.

on some buildbots __hwasan_store shows up above the frame we assert,
so the frame number is wrong

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp

 //===-- sanitizer_common.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between sanitizers' run-time libraries.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_file.h"
 #include "sanitizer_fuchsia.h"
 
+#if SANITIZER_LINUX
+#  include <dlfcn.h>
+#  include <elf.h>
+#  include <link.h>
+#endif
+
 namespace __sanitizer {
 
 // sanitizer_symbolizer_markup.cpp implements these differently.
 #if !SANITIZER_SYMBOLIZER_MARKUP
 
 static const char *StripFunctionName(const char *function, const char *prefix) {
   if (!function) return nullptr;
   if (!prefix) return function;
if (!internal_strcmp(function, "__libc_thr_curcpu"))
     return "pthread_curcpu_np";
   if (!internal_strcmp(function, "__libc_thr_sigsetmask"))
     return "pthread_sigmask";
 #endif
 
   return function;
 }
 
+#  if SANITIZER_LINUX
+template <uptr Alignment>
+static uptr alignUp(uintptr_t Ptr) {
+  static_assert((Alignment & (Alignment - 1)) == 0,
+                "Alignment is power of two");
+  if ((Ptr & (Alignment - 1)) == 0)
+    return Ptr;
+
+  Ptr += Alignment - (Ptr & (Alignment - 1));
+  return Ptr;
+}
+
+struct BuildId {
+  const char *buf;
+  uptr size;
+};
+
+static BuildId GetBuildIdForAddr(uptr module_base, uptr pc) {
+  auto *ehdr = reinterpret_cast<const ElfW(Ehdr) *>(module_base);
+  if (ehdr->e_ident[EI_MAG0] != ELFMAG0 || ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
+      ehdr->e_ident[EI_MAG2] != ELFMAG2 || ehdr->e_ident[EI_MAG3] != ELFMAG3) {
+    return {nullptr, 0u};
+  }
+  auto *phdr_begin = reinterpret_cast<const ElfW(Phdr) *>(
+      reinterpret_cast<const u8 *>(ehdr) + ehdr->e_phoff);
+
+  for (const auto &phdr :
+       ArrayRef<const ElfW(Phdr)>(phdr_begin, phdr_begin + ehdr->e_phnum)) {
+    if (phdr.p_type != PT_NOTE)
+      continue;
+    uptr off = 0;
+    while (off < phdr.p_memsz) {
+      auto *nhdr = reinterpret_cast<const ElfW(Nhdr) *>(
+          reinterpret_cast<const char *>(ehdr) + phdr.p_offset + off);
+      constexpr auto kGnuNamesz = 4;  // "GNU" with NUL-byte.
+      if (nhdr->n_type == NT_GNU_BUILD_ID && nhdr->n_namesz == kGnuNamesz) {
+        const char *name = reinterpret_cast<const char *>(nhdr) + sizeof(*nhdr);
+        if (internal_memcmp(name, "GNU", 3) == 0) {
+          const char *value =
+              reinterpret_cast<const char *>(nhdr) + sizeof(*nhdr) + kGnuNamesz;
+          return {value, nhdr->n_descsz};
+        }
+      }
+      off += sizeof(*nhdr) + alignUp<4>(nhdr->n_namesz) +
+             alignUp<4>(nhdr->n_descsz);
+    }
+  }
+  return {nullptr, 0u};
+}
+
+#  endif
+
+static void MaybeBuildIdToBuffer(const AddressInfo &info, bool PrefixSpace,
+                                 InternalScopedString *buffer) {
+#  if SANITIZER_LINUX
+  BuildId buildid = GetBuildIdForAddr(info.module_base(), info.address);
+  if (buildid.buf) {
+    if (PrefixSpace)
+      buffer->append(" ");
+    buffer->append("(BuildId: ");
+    for (uptr i = 0; i < buildid.size; ++i) {
+      buffer->append("%x", buildid.buf[i]);
+    }
+    buffer->append(")");
+  }
+#  endif
+}
 static const char kDefaultFormat[] = "    #%n %p %F %L";
 
 void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
                  uptr address, const AddressInfo *info, bool vs_style,
                  const char *strip_path_prefix, const char *strip_func_prefix) {
   // info will be null in the case where symbolization is not needed for the
   // given format. This ensures that the code below will get a hard failure
   // rather than print incorrect information in case RenderNeedsSymbolization
case 'p':
       buffer->append("0x%zx", address);
       break;
     case 'm':
       buffer->append("%s", StripPathPrefix(info->module, strip_path_prefix));
       break;
     case 'o':
       buffer->append("0x%zx", info->module_offset);
       break;
+    case 'b':
+      MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/false, buffer);
+      break;
     case 'f':
       buffer->append("%s", DemangleFunctionName(StripFunctionName(
                                info->function, strip_func_prefix)));
       break;
     case 'q':
       buffer->append("0x%zx", info->function_offset != AddressInfo::kUnknown
                                   ? info->function_offset
                                   : 0x0);
for (const char *p = format; *p != '\0'; p++) {
     case 'L':
       // Source location, or module location.
       if (info->file) {
         RenderSourceLocation(buffer, info->file, info->line, info->column,
                              vs_style, strip_path_prefix);
       } else if (info->module) {
         RenderModuleLocation(buffer, info->module, info->module_offset,
                              info->module_arch, strip_path_prefix);
+
+        MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/true, buffer);
       } else {
         buffer->append("(<unknown module>)");
       }
       break;
     case 'M':
       // Module basename and offset, or PC.
       if (address & kExternalPCBit) {
         // There PCs are not meaningful.
       } else if (info->module) {
         // Always strip the module name for %M.
         RenderModuleLocation(buffer, StripModuleName(info->module),
                              info->module_offset, info->module_arch, "");
+        MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/true, buffer);
       } else {
         buffer->append("(%p)", (void *)address);
       }
       break;
     default:
       Report("Unsupported specifier in stack frame format: %c (%p)!\n", *p,
              (void *)p);
       Die();

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h

struct AddressInfo {
   char *file;
   int line;
   int column;
 
   AddressInfo();
   // Deletes all strings and resets all fields.
   void Clear();
   void FillModuleInfo(const char *mod_name, uptr mod_offset, ModuleArch arch);
+  uptr module_base() const { return address - module_offset; }
 };
 
 // Linked list of symbolized frames (each frame is described by AddressInfo).
 struct SymbolizedStack {
   SymbolizedStack *next;
   AddressInfo info;
   static SymbolizedStack *New(uptr addr);
   // Deletes current, and all subsequent frames in the linked list.

compiler-rt/test/hwasan/TestCases/build-ids.c

+// RUN: %clang_hwasan -Wl,--build-id=0xaba493998257fbdd %s -o %t
+// RUN: HWASAN_SYMBOLIZER_PATH= not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,NOSYM
+// RUN: not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,SYM
+
+#include <stdlib.h>
+
+#include <sanitizer/hwasan_interface.h>
+
+int main(int argc, char **argv) {
+  __hwasan_enable_allocator_tagging();
+  char *buf = (char *)malloc(1);
+  buf[32] = 'x';
+  // CHECK: ERROR: HWAddressSanitizer: tag-mismatch
+  // NOSYM:  #0 0x{{.*}}  {{.*}}build-ids.c{{.*}} (BuildId: aba493998257fbdd)
+  // SYM:  #0 0x{{.*}} in main {{.*}}build-ids.c:[[@LINE-3]]:{{[0-9]+}}
+  return 0;
+}

compiler-rt/test/sanitizer_common/android_commands/android_run.py

 #!/usr/bin/env python
 
 import os, signal, sys, subprocess, tempfile
 from android_common import *
 
 ANDROID_TMPDIR = '/data/local/tmp/Output'
 
 device_binary = host_to_device_path(sys.argv[0])
 
 def build_env():
     args = []
     # Android linker ignores RPATH. Set LD_LIBRARY_PATH to Output dir.
     args.append('LD_LIBRARY_PATH=%s' % (ANDROID_TMPDIR,))
     for (key, value) in list(os.environ.items()):
-        if key in ['ASAN_ACTIVATION_OPTIONS', 'SCUDO_OPTIONS'] or key.endswith('SAN_OPTIONS'):
+        if key in ['ASAN_ACTIVATION_OPTIONS', 'SCUDO_OPTIONS'] or key.endswith('SAN_OPTIONS') \
+           or key.startswith('HWASAN'):
             args.append('%s="%s"' % (key, value.replace('"', '\\"')))
     return ' '.join(args)
 
 is_64bit = str(subprocess.check_output(['file', sys.argv[0] + '.real'])).find('64-bit') != -1
 
 device_env = build_env()
 device_args = ' '.join(sys.argv[1:]) # FIXME: escape?
 device_stdout = device_binary + '.stdout'