[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

This already exists as RoundUpTo

628

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

633

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

2

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

Added a static_assert.

633

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_common.h

case kModuleArchRISCV64:
       return "riscv64";
     case kModuleArchHexagon:
       return "hexagon";
   }
   CHECK(0 && "Invalid module arch");
   return "";
 }
 
-const uptr kModuleUUIDSize = 16;
+const uptr kModuleUUIDSize = 32;
 const uptr kMaxSegName = 16;
 
 // Represents a binary loaded into virtual memory (e.g. this can be an
 // executable or a shared object).
 class LoadedModule {
  public:
   LoadedModule()
       : full_name_(nullptr),
         base_address_(0),
         max_executable_address_(0),
         arch_(kModuleArchUnknown),
+        uuid_size_(0),
         instrumented_(false) {
     internal_memset(uuid_, 0, kModuleUUIDSize);
     ranges_.clear();
   }
   void set(const char *module_name, uptr base_address);
   void set(const char *module_name, uptr base_address, ModuleArch arch,
            u8 uuid[kModuleUUIDSize], bool instrumented);
+  void setUuid(const char *uuid, uptr size);
   void clear();
   void addAddressRange(uptr beg, uptr end, bool executable, bool writable,
                        const char *name = nullptr);
   bool containsAddress(uptr address) const;
 
   const char *full_name() const { return full_name_; }
   uptr base_address() const { return base_address_; }
   uptr max_executable_address() const { return max_executable_address_; }
   ModuleArch arch() const { return arch_; }
   const u8 *uuid() const { return uuid_; }
+  uptr uuid_size() const { return uuid_size_; }
   bool instrumented() const { return instrumented_; }
 
   struct AddressRange {
     AddressRange *next;
     uptr beg;
     uptr end;
     bool executable;
     bool writable;
public:
 
   const IntrusiveList<AddressRange> &ranges() const { return ranges_; }
 
  private:
   char *full_name_;  // Owned.
   uptr base_address_;
   uptr max_executable_address_;
   ModuleArch arch_;
+  uptr uuid_size_;
   u8 uuid_[kModuleUUIDSize];
   bool instrumented_;
   IntrusiveList<AddressRange> ranges_;
 };
 
 // List of LoadedModules. OS-dependent implementation is responsible for
 // filling this information.
 class ListOfModules {

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

 }
 
 void LoadedModule::set(const char *module_name, uptr base_address,
                        ModuleArch arch, u8 uuid[kModuleUUIDSize],
                        bool instrumented) {
   set(module_name, base_address);
   arch_ = arch;
   internal_memcpy(uuid_, uuid, sizeof(uuid_));
+  uuid_size_ = kModuleUUIDSize;
   instrumented_ = instrumented;
 }
 
+void LoadedModule::setUuid(const char *uuid, uptr size) {
+  if (size > kModuleUUIDSize)
+    size = kModuleUUIDSize;
+  internal_memcpy(uuid_, uuid, size);
+  uuid_size_ = size;
+}
+
 void LoadedModule::clear() {
   InternalFree(full_name_);
   base_address_ = 0;
   max_executable_address_ = 0;
   full_name_ = nullptr;
   arch_ = kModuleArchUnknown;
   internal_memset(uuid_, 0, kModuleUUIDSize);
   instrumented_ = false;

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

 #define dl_iterate_phdr(c, b) xdl_iterate_phdr((c), (b))
 #endif  // !SANITIZER_FREEBSD
 
 struct DlIteratePhdrData {
   InternalMmapVectorNoCtor<LoadedModule> *modules;
   bool first;
 };
 
+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;
+}
+
 static int AddModuleSegments(const char *module_name, dl_phdr_info *info,
                              InternalMmapVectorNoCtor<LoadedModule> *modules) {
   if (module_name[0] == '\0')
     return 0;
   LoadedModule cur_module;
   cur_module.set(module_name, info->dlpi_addr);
   for (int i = 0; i < (int)info->dlpi_phnum; i++) {
     const Elf_Phdr *phdr = &info->dlpi_phdr[i];
     if (phdr->p_type == PT_LOAD) {
       uptr cur_beg = info->dlpi_addr + phdr->p_vaddr;
       uptr cur_end = cur_beg + phdr->p_memsz;
       bool executable = phdr->p_flags & PF_X;
       bool writable = phdr->p_flags & PF_W;
       cur_module.addAddressRange(cur_beg, cur_end, executable,
                                  writable);
+    } else if (phdr->p_type == PT_NOTE) {
+      uptr off = 0;
+      while (off < phdr->p_memsz - sizeof(ElfW(Nhdr))) {
+        auto *nhdr = reinterpret_cast<const ElfW(Nhdr) *>(info->dlpi_addr +
+                                                          phdr->p_vaddr + 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;
+            cur_module.setUuid(value, nhdr->n_descsz);
+            break;
+          }
+        }
+        off += sizeof(*nhdr) + alignUp<4>(nhdr->n_namesz) +
+               alignUp<4>(nhdr->n_descsz);
+      }
     }
   }
   modules->push_back(cur_module);
   return 0;
 }
 
 static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
   DlIteratePhdrData *data = (DlIteratePhdrData *)arg;

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp

if (!internal_strcmp(function, "__libc_thr_curcpu"))
     return "pthread_curcpu_np";
   if (!internal_strcmp(function, "__libc_thr_sigsetmask"))
     return "pthread_sigmask";
 #endif
 
   return function;
 }
 
+static void MaybeBuildIdToBuffer(const AddressInfo &info, bool PrefixSpace,
+                                 InternalScopedString *buffer) {
+  if (info.uuid_size) {
+    if (PrefixSpace)
+      buffer->append(" ");
+    buffer->append("(BuildId: ");
+    for (uptr i = 0; i < info.uuid_size; ++i) {
+      buffer->append("%02x", info.uuid[i]);
+    }
+    buffer->append(")");
+  }
+}
+
 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 {
   // Owns all the string members. Storage for them is
   // (de)allocated using sanitizer internal allocator.
   uptr address;
 
   char *module;
   uptr module_offset;
   ModuleArch module_arch;
+  u8 uuid[kModuleUUIDSize];
+  uptr uuid_size;
 
   static const uptr kUnknown = ~(uptr)0;
   char *function;
   uptr function_offset;
 
   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);
+  void FillModuleInfo(const LoadedModule &mod);
+  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/lib/sanitizer_common/sanitizer_symbolizer.cpp

 //===-- sanitizer_symbolizer.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 AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_allocator_internal.h"
-#include "sanitizer_platform.h"
+#include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_platform.h"
 #include "sanitizer_symbolizer_internal.h"
 
 namespace __sanitizer {
 
 AddressInfo::AddressInfo() {
   internal_memset(this, 0, sizeof(AddressInfo));
   function_offset = kUnknown;
 }
 
 void AddressInfo::Clear() {
   InternalFree(module);
   InternalFree(function);
   InternalFree(file);
   internal_memset(this, 0, sizeof(AddressInfo));
   function_offset = kUnknown;
+  uuid_size = 0;
 }
 
 void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset,
                                  ModuleArch mod_arch) {
   module = internal_strdup(mod_name);
   module_offset = mod_offset;
   module_arch = mod_arch;
+  uuid_size = 0;
+}
+
+void AddressInfo::FillModuleInfo(const LoadedModule &mod) {
+  module = internal_strdup(mod.full_name());
+  module_offset = address - mod.base_address();
+  module_arch = mod.arch();
+  if (mod.uuid_size())
+    internal_memcpy(uuid, mod.uuid(), mod.uuid_size());
+  uuid_size = mod.uuid_size();
 }
 
 SymbolizedStack::SymbolizedStack() : next(nullptr), info() {}
 
 SymbolizedStack *SymbolizedStack::New(uptr addr) {
   void *mem = InternalAlloc(sizeof(SymbolizedStack));
   SymbolizedStack *res = new(mem) SymbolizedStack();
   res->info.address = addr;

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp

const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
   (*result)[prefix_len] = '\0';
   const char *prefix_end = str + prefix_len;
   if (*prefix_end != '\0') prefix_end += internal_strlen(delimiter);
   return prefix_end;
 }
 
 SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
   Lock l(&mu_);
-  const char *module_name = nullptr;
-  uptr module_offset;
-  ModuleArch arch;
   SymbolizedStack *res = SymbolizedStack::New(addr);
-  if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset,
-                                         &arch))
+  auto *mod = FindModuleForAddress(addr);
+  if (!mod)
     return res;
   // Always fill data about module name and offset.
-  res->info.FillModuleInfo(module_name, module_offset, arch);
+  res->info.FillModuleInfo(*mod);
   for (auto &tool : tools_) {
     SymbolizerScope sym_scope(this);
     if (tool.SymbolizePC(addr, res)) {
       return res;
     }
   }
   return res;
 }

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp

TEST(SanitizerStacktracePrinter, RenderFrame) {
   EXPECT_NE(nullptr, internal_strstr(str.data(), "(module+0x"));
   EXPECT_NE(nullptr, internal_strstr(str.data(), "200"));
   str.clear();
 
   RenderFrame(&str, "%L", frame_no, info.address, &info, false);
   EXPECT_STREQ("(/path/to/module+0x200)", str.data());
   str.clear();
 
+  RenderFrame(&str, "%b", frame_no, info.address, &info, false);
+  EXPECT_STREQ("", str.data());
+  str.clear();
+
+  info.uuid_size = 2;
+  info.uuid[0] = 0x55;
+  info.uuid[1] = 0x66;
+
+  RenderFrame(&str, "%M", frame_no, info.address, &info, false);
+  EXPECT_NE(nullptr, internal_strstr(str.data(), "(module+0x"));
+  EXPECT_NE(nullptr, internal_strstr(str.data(), "200"));
+  EXPECT_NE(nullptr, internal_strstr(str.data(), "BuildId: 5566"));
+  str.clear();
+
+  RenderFrame(&str, "%L", frame_no, info.address, &info, false);
+  EXPECT_STREQ("(/path/to/module+0x200) (BuildId: 5566)", str.data());
+  str.clear();
+
+  RenderFrame(&str, "%b", frame_no, info.address, &info, false);
+  EXPECT_STREQ("(BuildId: 5566)", str.data());
+  str.clear();
+
   info.function = internal_strdup("my_function");
   RenderFrame(&str, "%F", frame_no, info.address, &info, false);
   EXPECT_STREQ("in my_function", str.data());
   str.clear();
 
   info.function_offset = 0x100;
   RenderFrame(&str, "%F %S", frame_no, info.address, &info, false);
   EXPECT_STREQ("in my_function+0x100 <null>", str.data());

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'