Fix tls_get_addr handling for glibc >=2.25

[thurston]

Summary

This changes the sanitizers' tls_get_addr handling from
a heuristic check of __signal_safe_memalign allocations
(which has only been used in a since deprecated version
of Google's runtime), to using the sanitizers' interface
function to check if it is a malloc allocation (used
since glibc >= 2.25).

This is one of the approaches proposed by Keno in
https://github.com/google/sanitizers/issues/1409#issuecomment-1214244142

This moves the weak annotation of __sanitizer_get_allocated_size/begin from the header to sanitizer_tls_get_addr.cpp, as suggested by Vitaly in D148060.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

23–26

compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp

17

143–147

147

don't use explicit nullptr checks

[thurston]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

23–26

I get a linker error if they're not weak:

$ LIT_FILTER=get_allocated_begin ninja check-sanitizer
...
/usr/bin/ld: projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommon.i386.dir/sanitizer_tls_get_addr.cpp.o: in function `__sanitizer::DTLS_on_tls_get_addr(void*, void*, unsigned int, unsigned int)':
/usr/local/google/home/thurston/llvm-projectB/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp:130: undefined reference to `__sanitizer_get_allocated_begin'
/usr/bin/ld: /usr/local/google/home/thurston/llvm-projectB/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp:133: undefined reference to `__sanitizer_get_allocated_size'
collect2: error: ld returned 1 exit status

[thurston]

Avoid explicit nullptr check, per Vitaly's suggestion

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

23–26

we need to understand why and fix it

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

23–26

Is this for UBSAN case?

[thurston]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

23–26

Is this for UBSAN case?

Yes, and also Nolibc:

Generating Sanitizer-x86_64-Test-Nolibc
...
/usr/bin/ld: libRTSanitizerCommon.test.nolibc.x86_64.a(sanitizer_tls_get_addr.cpp.o): in function `__sanitizer::DTLS_on_tls_get_addr(void*, void*, unsigned long, unsigned long)':
/usr/local/google/home/thurston/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp:129: undefined reference to `__sanitizer_get_allocated_begin'
/usr/bin/ld: /usr/local/google/home/thurston/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp:131: undefined reference to `__sanitizer_get_allocated_size'
clang++: error: linker command failed with exit code 1 (use -v to see invocation)

Linking CXX shared library lib/clang/17/lib/i386-unknown-linux-gnu/libclang_rt.ubsan_standalone.so
...
/usr/bin/ld: projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommon.i386.dir/sanitizer_tls_get_addr.cpp.o: in function `__sanitizer::DTLS_on_tls_get_addr(void*, void*, unsigned int, unsigned int)':
/usr/local/google/home/thurston/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp:129: undefined reference to `__sanitizer_get_allocated_begin'
/usr/bin/ld: /usr/local/google/home/thurston/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp:131: undefined reference to `__sanitizer_get_allocated_size'
collect2: error: ld returned 1 exit status

Linking CXX shared library lib/clang/17/lib/x86_64-unknown-linux-gnu/libclang_rt.ubsan_standalone.so
...

[thurston]

Remove XFAIL from compiler-rt/test/msan/dtls_test.c because it now passes.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

23–26

Is this for UBSAN case?

Yes, and also Nolibc:

sanitizer_tls_get_addr is very glibc specific, it should not be in nolibc

[thurston]

This moves the weak annotation of __sanitizer_get_allocated_size/begin from the header to sanitizer_tls_get_addr.cpp, as suggested by Vitaly in D148060.

[thurston]

Retain const qualifer

[thurston]

Mondos did not show any regressions on google3 TAP targets (other than regular flakiness)

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

 
 #include "sanitizer_internal_defs.h"
 
 using __sanitizer::uptr;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_estimated_allocated_size(uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_get_ownership(const void *p);
-SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const void *
-__sanitizer_get_allocated_begin(const void *p);
+SANITIZER_INTERFACE_ATTRIBUTE const void *__sanitizer_get_allocated_begin(
+    const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr
 __sanitizer_get_allocated_size(const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_current_allocated_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_heap_size();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_free_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_unmapped_bytes();
 
 SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_install_malloc_and_free_hooks(
     void (*malloc_hook)(const void *, uptr),

compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.h

 //===-- sanitizer_tls_get_addr.h --------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Handle the __tls_get_addr call.
 //
 // All this magic is specific to glibc and is required to workaround
 // the lack of interface that would tell us about the Dynamic TLS (DTLS).
 // https://sourceware.org/bugzilla/show_bug.cgi?id=16291
 //
-// The matters get worse because the glibc implementation changed between
-// 2.18 and 2.19:
-// https://groups.google.com/forum/#!topic/address-sanitizer/BfwYD8HMxTM
-//
-// Before 2.19, every DTLS chunk is allocated with __libc_memalign,
+// Before 2.25: every DTLS chunk is allocated with __libc_memalign,
 // which we intercept and thus know where is the DTLS.
-// Since 2.19, DTLS chunks are allocated with __signal_safe_memalign,
-// which is an internal function that wraps a mmap call, neither of which
-// we can intercept. Luckily, __signal_safe_memalign has a simple parseable
-// header which we can use.
+//
+// Since 2.25: DTLS chunks are allocated with malloc. We could co-opt
+// the malloc interceptor to keep track of the last allocation, similar
+// to how we handle __libc_memalign; however, this adds some overhead
+// (since malloc, unlike __libc_memalign, is commonly called), and
+// requires care to avoid false negatives for LeakSanitizer.
+// Instead, we rely on our internal allocators - which keep track of all
+// its allocations - to determine if an address points to a malloc
+// allocation.
+//
+// There exists a since-deprecated version of Google's internal glibc fork
+// that used __signal_safe_memalign. DTLS_on_tls_get_addr relied on a
+// heuristic check (is the allocation 16 bytes from the start of a page
+// boundary?), which was sometimes erroneous:
+//     https://bugs.chromium.org/p/chromium/issues/detail?id=1275223#c15
+// Since that check has no practical use anymore, we have removed it.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_TLS_GET_ADDR_H
 #define SANITIZER_TLS_GET_ADDR_H
 
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"

compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp

 //===-- sanitizer_tls_get_addr.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Handle the __tls_get_addr call.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_tls_get_addr.h"
 
+#include "sanitizer_allocator_interface.h"
 #include "sanitizer_atomic.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_platform_interceptors.h"
 
 namespace __sanitizer {
 #if SANITIZER_INTERCEPT_TLS_GET_ADDR
 
 // The actual parameter that comes to __tls_get_addr
 // is a pointer to a struct with two words in it:
 struct TlsGetAddrParam {
   uptr dso_id;
   uptr offset;
 };
 
-// Glibc starting from 2.19 allocates tls using __signal_safe_memalign,
-// which has such header.
-struct Glibc_2_19_tls_header {
-  uptr size;
-  uptr start;
-};
-
 // This must be static TLS
 __attribute__((tls_model("initial-exec")))
 static __thread DTLS dtls;
 
 // Make sure we properly destroy the DTLS objects:
 // this counter should never get too large.
 static atomic_uintptr_t number_of_live_dtls;
 

 // This is glibc's TLS_DTV_OFFSET:
 // "Dynamic thread vector pointers point 0x800 past the start of each
 // TLS block." (sysdeps/riscv/dl-tls.h)
 static const uptr kDtvOffset = 0x800;
 #else
 static const uptr kDtvOffset = 0;
 #endif
 
+extern "C" {
+SANITIZER_WEAK_ATTRIBUTE
+uptr __sanitizer_get_allocated_size(const void *p);
+
+SANITIZER_WEAK_ATTRIBUTE
+const void *__sanitizer_get_allocated_begin(const void *p);
+}
+
 DTLS::DTV *DTLS_on_tls_get_addr(void *arg_void, void *res,
                                 uptr static_tls_begin, uptr static_tls_end) {
   if (!common_flags()->intercept_tls_get_addr) return 0;
   TlsGetAddrParam *arg = reinterpret_cast<TlsGetAddrParam *>(arg_void);
   uptr dso_id = arg->dso_id;
   DTLS::DTV *dtv = DTLS_Find(dso_id);
   if (!dtv || dtv->beg)
     return 0;
   uptr tls_size = 0;
   uptr tls_beg = reinterpret_cast<uptr>(res) - arg->offset - kDtvOffset;
   VReport(2,
           "__tls_get_addr: %p {0x%zx,0x%zx} => %p; tls_beg: 0x%zx; sp: %p "
           "num_live_dtls %zd\n",
           (void *)arg, arg->dso_id, arg->offset, res, tls_beg, (void *)&tls_beg,
           atomic_load(&number_of_live_dtls, memory_order_relaxed));
   if (dtls.last_memalign_ptr == tls_beg) {
     tls_size = dtls.last_memalign_size;
-    VReport(2, "__tls_get_addr: glibc <=2.18 suspected; tls={0x%zx,0x%zx}\n",
+    VReport(2, "__tls_get_addr: glibc <=2.24 suspected; tls={0x%zx,0x%zx}\n",
             tls_beg, tls_size);
   } else if (tls_beg >= static_tls_begin && tls_beg < static_tls_end) {
     // This is the static TLS block which was initialized / unpoisoned at thread
     // creation.
     VReport(2, "__tls_get_addr: static tls: 0x%zx\n", tls_beg);
     tls_size = 0;
-  } else if ((tls_beg % 4096) == sizeof(Glibc_2_19_tls_header)) {
-    // We may want to check gnu_get_libc_version().
-    Glibc_2_19_tls_header *header = (Glibc_2_19_tls_header *)tls_beg - 1;
-    tls_size = header->size;
-    tls_beg = header->start;
-    VReport(2, "__tls_get_addr: glibc >=2.19 suspected; tls={0x%zx 0x%zx}\n",
+  } else if (const void *start =
+                 __sanitizer_get_allocated_begin((void *)tls_beg)) {
+    tls_beg = (uptr)start;
+    tls_size = __sanitizer_get_allocated_size(start);
+    VReport(2, "__tls_get_addr: glibc >=2.25 suspected; tls={0x%zx,0x%zx}\n",
             tls_beg, tls_size);
   } else {
     VReport(2, "__tls_get_addr: Can't guess glibc version\n");
     // This may happen inside the DTOR of main thread, so just ignore it.
     tls_size = 0;
   }
   dtv->beg = tls_beg;
   dtv->size = tls_size;
   return dtv;
 }
 
 void DTLS_on_libc_memalign(void *ptr, uptr size) {
   if (!common_flags()->intercept_tls_get_addr) return;
   VReport(2, "DTLS_on_libc_memalign: %p 0x%zx\n", ptr, size);

compiler-rt/test/msan/dtls_test.c

 /* RUN: %clang_msan -g %s -o %t
    RUN: %clang_msan -g %s -DBUILD_SO -fPIC -o %t-so.so -shared
    RUN: %run %t 2>&1
 
    Regression test for a bug in msan/glibc integration,
    see https://sourceware.org/bugzilla/show_bug.cgi?id=16291
    and https://github.com/google/sanitizers/issues/547
 
    XFAIL: target={{.*freebsd.*}}
    UNSUPPORTED: target=powerpc{{.*}}
 
    // Reports use-of-uninitialized-value, not analyzed
    XFAIL: target={{.*netbsd.*}}
 
-   // This is known to be broken with glibc-2.27+
-   // https://bugs.llvm.org/show_bug.cgi?id=37804
-   XFAIL: glibc-2.27
-
 */
 
 #ifndef BUILD_SO
 #include <assert.h>
 #include <dlfcn.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>