head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.1 netbsd-11-0-RC3:1.1.1.1 netbsd-11-0-RC2:1.1.1.1 netbsd-11-0-RC1:1.1.1.1 gcc-14-3-0:1.1.1.2 perseant-exfatfs-base-20250801:1.1.1.1 netbsd-11:1.1.1.1.0.4 netbsd-11-base:1.1.1.1 gcc-12-5-0:1.1.1.1 perseant-exfatfs-base-20240630:1.1.1.1 gcc-12-4-0:1.1.1.1 perseant-exfatfs:1.1.1.1.0.2 perseant-exfatfs-base:1.1.1.1 gcc-12-3-0:1.1.1.1 FSF:1.1.1; locks; strict; comment @// @; 1.1 date 2023.07.30.05.20.41; author mrg; state Exp; branches 1.1.1.1; next ; commitid tk6nV4mbc9nVEMyE; 1.1.1.1 date 2023.07.30.05.20.41; author mrg; state Exp; branches; next 1.1.1.2; commitid tk6nV4mbc9nVEMyE; 1.1.1.2 date 2025.09.13.23.45.04; author mrg; state Exp; branches; next ; commitid KwhwN4krNWa6XBaG; desc @@ 1.1 log @Initial revision @ text @ #include "hwasan_thread.h" #include "hwasan.h" #include "hwasan_interface_internal.h" #include "hwasan_mapping.h" #include "hwasan_poisoning.h" #include "sanitizer_common/sanitizer_atomic.h" #include "sanitizer_common/sanitizer_file.h" #include "sanitizer_common/sanitizer_placement_new.h" #include "sanitizer_common/sanitizer_tls_get_addr.h" namespace __hwasan { static u32 RandomSeed() { u32 seed; do { if (UNLIKELY(!GetRandom(reinterpret_cast(&seed), sizeof(seed), /*blocking=*/false))) { seed = static_cast( (NanoTime() >> 12) ^ (reinterpret_cast(__builtin_frame_address(0)) >> 4)); } } while (!seed); return seed; } void Thread::InitRandomState() { random_state_ = flags()->random_tags ? RandomSeed() : unique_id_; random_state_inited_ = true; // Push a random number of zeros onto the ring buffer so that the first stack // tag base will be random. for (tag_t i = 0, e = GenerateRandomTag(); i != e; ++i) stack_allocations_->push(0); } void Thread::Init(uptr stack_buffer_start, uptr stack_buffer_size, const InitState *state) { CHECK_EQ(0, unique_id_); // try to catch bad stack reuse CHECK_EQ(0, stack_top_); CHECK_EQ(0, stack_bottom_); static atomic_uint64_t unique_id; unique_id_ = atomic_fetch_add(&unique_id, 1, memory_order_relaxed); if (auto sz = flags()->heap_history_size) heap_allocations_ = HeapAllocationsRingBuffer::New(sz); #if !SANITIZER_FUCHSIA // Do not initialize the stack ring buffer just yet on Fuchsia. Threads will // be initialized before we enter the thread itself, so we will instead call // this later. InitStackRingBuffer(stack_buffer_start, stack_buffer_size); #endif InitStackAndTls(state); } void Thread::InitStackRingBuffer(uptr stack_buffer_start, uptr stack_buffer_size) { HwasanTSDThreadInit(); // Only needed with interceptors. uptr *ThreadLong = GetCurrentThreadLongPtr(); // The following implicitly sets (this) as the current thread. stack_allocations_ = new (ThreadLong) StackAllocationsRingBuffer((void *)stack_buffer_start, stack_buffer_size); // Check that it worked. CHECK_EQ(GetCurrentThread(), this); // ScopedTaggingDisable needs GetCurrentThread to be set up. ScopedTaggingDisabler disabler; if (stack_bottom_) { int local; CHECK(AddrIsInStack((uptr)&local)); CHECK(MemIsApp(stack_bottom_)); CHECK(MemIsApp(stack_top_ - 1)); } if (flags()->verbose_threads) { if (IsMainThread()) { Printf("sizeof(Thread): %zd sizeof(HeapRB): %zd sizeof(StackRB): %zd\n", sizeof(Thread), heap_allocations_->SizeInBytes(), stack_allocations_->size() * sizeof(uptr)); } Print("Creating : "); } } void Thread::ClearShadowForThreadStackAndTLS() { if (stack_top_ != stack_bottom_) TagMemory(stack_bottom_, stack_top_ - stack_bottom_, 0); if (tls_begin_ != tls_end_) TagMemory(tls_begin_, tls_end_ - tls_begin_, 0); } void Thread::Destroy() { if (flags()->verbose_threads) Print("Destroying: "); AllocatorSwallowThreadLocalCache(allocator_cache()); ClearShadowForThreadStackAndTLS(); if (heap_allocations_) heap_allocations_->Delete(); DTLS_Destroy(); // Unregister this as the current thread. // Instrumented code can not run on this thread from this point onwards, but // malloc/free can still be served. Glibc may call free() very late, after all // TSD destructors are done. CHECK_EQ(GetCurrentThread(), this); *GetCurrentThreadLongPtr() = 0; } void Thread::Print(const char *Prefix) { Printf("%sT%zd %p stack: [%p,%p) sz: %zd tls: [%p,%p)\n", Prefix, unique_id_, (void *)this, stack_bottom(), stack_top(), stack_top() - stack_bottom(), tls_begin(), tls_end()); } static u32 xorshift(u32 state) { state ^= state << 13; state ^= state >> 17; state ^= state << 5; return state; } // Generate a (pseudo-)random non-zero tag. tag_t Thread::GenerateRandomTag(uptr num_bits) { DCHECK_GT(num_bits, 0); if (tagging_disabled_) return 0; tag_t tag; const uptr tag_mask = (1ULL << num_bits) - 1; do { if (flags()->random_tags) { if (!random_buffer_) { EnsureRandomStateInited(); random_buffer_ = random_state_ = xorshift(random_state_); } CHECK(random_buffer_); tag = random_buffer_ & tag_mask; random_buffer_ >>= num_bits; } else { EnsureRandomStateInited(); random_state_ += 1; tag = random_state_ & tag_mask; } } while (!tag); return tag; } } // namespace __hwasan @ 1.1.1.1 log @initial import of GCC 12.3.0. major changes in GCC 11 included: - The default mode for C++ is now -std=gnu++17 instead of -std=gnu++14. - When building GCC itself, the host compiler must now support C++11, rather than C++98. - Some short options of the gcov tool have been renamed: -i to -j and -j to -H. - ThreadSanitizer improvements. - Introduce Hardware-assisted AddressSanitizer support. - For targets that produce DWARF debugging information GCC now defaults to DWARF version 5. This can produce up to 25% more compact debug information compared to earlier versions. - Many optimisations. - The existing malloc attribute has been extended so that it can be used to identify allocator/deallocator API pairs. A pair of new -Wmismatched-dealloc and -Wmismatched-new-delete warnings are added. - Other new warnings: -Wsizeof-array-div, enabled by -Wall, warns about divisions of two sizeof operators when the first one is applied to an array and the divisor does not equal the size of the array element. -Wstringop-overread, enabled by default, warns about calls to string functions reading past the end of the arrays passed to them as arguments. -Wtsan, enabled by default, warns about unsupported features in ThreadSanitizer (currently std::atomic_thread_fence). - Enchanced warnings: -Wfree-nonheap-object detects many more instances of calls to deallocation functions with pointers not returned from a dynamic memory allocation function. -Wmaybe-uninitialized diagnoses passing pointers or references to uninitialized memory to functions taking const-qualified arguments. -Wuninitialized detects reads from uninitialized dynamically allocated memory. -Warray-parameter warns about functions with inconsistent array forms. -Wvla-parameter warns about functions with inconsistent VLA forms. - Several new features from the upcoming C2X revision of the ISO C standard are supported with -std=c2x and -std=gnu2x. - Several C++20 features have been implemented. - The C++ front end has experimental support for some of the upcoming C++23 draft. - Several new C++ warnings. - Enhanced Arm, AArch64, x86, and RISC-V CPU support. - The implementation of how program state is tracked within -fanalyzer has been completely rewritten with many enhancements. see https://gcc.gnu.org/gcc-11/changes.html for a full list. major changes in GCC 12 include: - An ABI incompatibility between C and C++ when passing or returning by value certain aggregates containing zero width bit-fields has been discovered on various targets. x86-64, ARM and AArch64 will always ignore them (so there is a C ABI incompatibility between GCC 11 and earlier with GCC 12 or later), PowerPC64 ELFv2 always take them into account (so there is a C++ ABI incompatibility, GCC 4.4 and earlier compatible with GCC 12 or later, incompatible with GCC 4.5 through GCC 11). RISC-V has changed the handling of these already starting with GCC 10. As the ABI requires, MIPS takes them into account handling function return values so there is a C++ ABI incompatibility with GCC 4.5 through 11. - STABS: Support for emitting the STABS debugging format is deprecated and will be removed in the next release. All ports now default to emit DWARF (version 2 or later) debugging info or are obsoleted. - Vectorization is enabled at -O2 which is now equivalent to the original -O2 -ftree-vectorize -fvect-cost-model=very-cheap. - GCC now supports the ShadowCallStack sanitizer. - Support for __builtin_shufflevector compatible with the clang language extension was added. - Support for attribute unavailable was added. - Support for __builtin_dynamic_object_size compatible with the clang language extension was added. - New warnings: -Wbidi-chars warns about potentially misleading UTF-8 bidirectional control characters. -Warray-compare warns about comparisons between two operands of array type. - Some new features from the upcoming C2X revision of the ISO C standard are supported with -std=c2x and -std=gnu2x. - Several C++23 features have been implemented. - Many C++ enhancements across warnings and -f options. see https://gcc.gnu.org/gcc-12/changes.html for a full list. @ text @@ 1.1.1.2 log @initial import of GCC 14.3.0. major changes in GCC 13: - improved sanitizer - zstd debug info compression - LTO improvements - SARIF based diagnostic support - new warnings: -Wxor-used-as-pow, -Wenum-int-mismatch, -Wself-move, -Wdangling-reference - many new -Wanalyzer* specific warnings - enhanced warnings: -Wpessimizing-move, -Wredundant-move - new attributes to mark file descriptors, c++23 "assume" - several C23 features added - several C++23 features added - many new features for Arm, x86, RISC-V major changes in GCC 14: - more strict C99 or newer support - ia64* marked deprecated (but seemingly still in GCC 15.) - several new hardening features - support for "hardbool", which can have user supplied values of true/false - explicit support for stack scrubbing upon function exit - better auto-vectorisation support - added clang-compatible __has_feature and __has_extension - more C23, including -std=c23 - several C++26 features added - better diagnostics in C++ templates - new warnings: -Wnrvo, Welaborated-enum-base - many new features for Arm, x86, RISC-V - possible ABI breaking change for SPARC64 and small structures with arrays of floats. @ text @a7 1 #include "hwasan_thread_list.h" a45 2 if (!IsMainThread()) os_id_ = GetTid(); a56 11 dtls_ = DTLS_Get(); AllocatorThreadStart(allocator_cache()); if (flags()->verbose_threads) { if (IsMainThread()) { Printf("sizeof(Thread): %zd sizeof(HeapRB): %zd sizeof(StackRB): %zd\n", sizeof(Thread), heap_allocations_->SizeInBytes(), stack_allocations_->size() * sizeof(uptr)); } Print("Creating : "); } d78 9 d91 1 a91 3 TagMemory(UntagAddr(stack_bottom_), UntagAddr(stack_top_) - UntagAddr(stack_bottom_), GetTagFromPointer(stack_top_)); d93 1 a93 3 TagMemory(UntagAddr(tls_begin_), UntagAddr(tls_end_) - UntagAddr(tls_begin_), GetTagFromPointer(tls_begin_)); d99 1 a99 1 AllocatorThreadFinish(allocator_cache()); a149 6 void EnsureMainThreadIDIsCorrect() { auto *t = __hwasan::GetCurrentThread(); if (t && (t->IsMainThread())) t->set_os_id(GetTid()); } a150 57 // --- Implementation of LSan-specific functions --- {{{1 namespace __lsan { static __hwasan::HwasanThreadList *GetHwasanThreadListLocked() { auto &tl = __hwasan::hwasanThreadList(); tl.CheckLocked(); return &tl; } static __hwasan::Thread *GetThreadByOsIDLocked(tid_t os_id) { return GetHwasanThreadListLocked()->FindThreadLocked( [os_id](__hwasan::Thread *t) { return t->os_id() == os_id; }); } void LockThreads() { __hwasan::hwasanThreadList().Lock(); __hwasan::hwasanThreadArgRetval().Lock(); } void UnlockThreads() { __hwasan::hwasanThreadArgRetval().Unlock(); __hwasan::hwasanThreadList().Unlock(); } void EnsureMainThreadIDIsCorrect() { __hwasan::EnsureMainThreadIDIsCorrect(); } bool GetThreadRangesLocked(tid_t os_id, uptr *stack_begin, uptr *stack_end, uptr *tls_begin, uptr *tls_end, uptr *cache_begin, uptr *cache_end, DTLS **dtls) { auto *t = GetThreadByOsIDLocked(os_id); if (!t) return false; *stack_begin = t->stack_bottom(); *stack_end = t->stack_top(); *tls_begin = t->tls_begin(); *tls_end = t->tls_end(); // Fixme: is this correct for HWASan. *cache_begin = 0; *cache_end = 0; *dtls = t->dtls(); return true; } void GetAllThreadAllocatorCachesLocked(InternalMmapVector *caches) {} void GetThreadExtraStackRangesLocked(tid_t os_id, InternalMmapVector *ranges) {} void GetThreadExtraStackRangesLocked(InternalMmapVector *ranges) {} void GetAdditionalThreadContextPtrsLocked(InternalMmapVector *ptrs) { __hwasan::hwasanThreadArgRetval().GetAllPtrsLocked(ptrs); } void GetRunningThreadsLocked(InternalMmapVector *threads) {} } // namespace __lsan @