libsanitizer/tsan/tsan_external.cpp

   1 //===-- tsan_external.cpp -------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file is a part of ThreadSanitizer (TSan), a race detector.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 #include "tsan_rtl.h"
  13 #include "sanitizer_common/sanitizer_ptrauth.h"
  14
  15 #if !SANITIZER_GO
  16 #  include "tsan_interceptors.h"
  17 #endif
  18
  19 namespace __tsan {
  20
  21 #define CALLERPC ((uptr)__builtin_return_address(0))
  22
  23 struct TagData {
  24   const char *object_type;
  25   const char *header;
  26 };
  27
  28 static TagData registered_tags[kExternalTagMax] = {
  29   {},
  30   {"Swift variable", "Swift access race"},
  31 };
  32 static atomic_uint32_t used_tags{kExternalTagFirstUserAvailable};
  33 static TagData *GetTagData(uptr tag) {
  34   // Invalid/corrupted tag?  Better return NULL and let the caller deal with it.
  35   if (tag >= atomic_load(&used_tags, memory_order_relaxed)) return nullptr;
  36   return &registered_tags[tag];
  37 }
  38
  39 const char *GetObjectTypeFromTag(uptr tag) {
  40   TagData *tag_data = GetTagData(tag);
  41   return tag_data ? tag_data->object_type : nullptr;
  42 }
  43
  44 const char *GetReportHeaderFromTag(uptr tag) {
  45   TagData *tag_data = GetTagData(tag);
  46   return tag_data ? tag_data->header : nullptr;
  47 }
  48
  49 uptr TagFromShadowStackFrame(uptr pc) {
  50   uptr tag_count = atomic_load(&used_tags, memory_order_relaxed);
  51   void *pc_ptr = (void *)pc;
  52   if (pc_ptr < GetTagData(0) || pc_ptr > GetTagData(tag_count - 1))
  53     return 0;
  54   return (TagData *)pc_ptr - GetTagData(0);
  55 }
  56
  57 #if !SANITIZER_GO
  58
  59 // We need to track tags for individual memory accesses, but there is no space
  60 // in the shadow cells for them.  Instead we push/pop them onto the thread
  61 // traces and ignore the extra tag frames when printing reports.
  62 static void PushTag(ThreadState *thr, uptr tag) {
  63   FuncEntry(thr, (uptr)&registered_tags[tag]);
  64 }
  65 static void PopTag(ThreadState *thr) { FuncExit(thr); }
  66
  67 static void ExternalAccess(void *addr, uptr caller_pc, uptr tsan_caller_pc,
  68                            void *tag, AccessType typ) {
  69   CHECK_LT(tag, atomic_load(&used_tags, memory_order_relaxed));
  70   bool in_ignored_lib;
  71   if (caller_pc && libignore()->IsIgnored(caller_pc, &in_ignored_lib))
  72     return;
  73
  74   ThreadState *thr = cur_thread();
  75   if (caller_pc) FuncEntry(thr, caller_pc);
  76   PushTag(thr, (uptr)tag);
  77   MemoryAccess(thr, tsan_caller_pc, (uptr)addr, 1, typ);
  78   PopTag(thr);
  79   if (caller_pc) FuncExit(thr);
  80 }
  81
  82 extern "C" {
  83 SANITIZER_INTERFACE_ATTRIBUTE
  84 void *__tsan_external_register_tag(const char *object_type) {
  85   uptr new_tag = atomic_fetch_add(&used_tags, 1, memory_order_relaxed);
  86   CHECK_LT(new_tag, kExternalTagMax);
  87   GetTagData(new_tag)->object_type = internal_strdup(object_type);
  88   char header[127] = {0};
  89   internal_snprintf(header, sizeof(header), "race on %s", object_type);
  90   GetTagData(new_tag)->header = internal_strdup(header);
  91   return (void *)new_tag;
  92 }
  93
  94 SANITIZER_INTERFACE_ATTRIBUTE
  95 void __tsan_external_register_header(void *tag, const char *header) {
  96   CHECK_GE((uptr)tag, kExternalTagFirstUserAvailable);
  97   CHECK_LT((uptr)tag, kExternalTagMax);
  98   atomic_uintptr_t *header_ptr =
  99       (atomic_uintptr_t *)&GetTagData((uptr)tag)->header;
 100   header = internal_strdup(header);
 101   char *old_header =
 102       (char *)atomic_exchange(header_ptr, (uptr)header, memory_order_seq_cst);
 103   Free(old_header);
 104 }
 105
 106 SANITIZER_INTERFACE_ATTRIBUTE
 107 void __tsan_external_assign_tag(void *addr, void *tag) {
 108   CHECK_LT(tag, atomic_load(&used_tags, memory_order_relaxed));
 109   Allocator *a = allocator();
 110   MBlock *b = nullptr;
 111   if (a->PointerIsMine((void *)addr)) {
 112     void *block_begin = a->GetBlockBegin((void *)addr);
 113     if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin);
 114   }
 115   if (b) {
 116     b->tag = (uptr)tag;
 117   }
 118 }
 119
 120 SANITIZER_INTERFACE_ATTRIBUTE
 121 void __tsan_external_read(void *addr, void *caller_pc, void *tag) {
 122   ExternalAccess(addr, STRIP_PAC_PC(caller_pc), CALLERPC, tag, kAccessRead);
 123 }
 124
 125 SANITIZER_INTERFACE_ATTRIBUTE
 126 void __tsan_external_write(void *addr, void *caller_pc, void *tag) {
 127   ExternalAccess(addr, STRIP_PAC_PC(caller_pc), CALLERPC, tag, kAccessWrite);
 128 }
 129 }  // extern "C"
 130
 131 #endif  // !SANITIZER_GO
 132
 133 }  // namespace __tsan