1 //===-- asan_posix.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 AddressSanitizer, an address sanity checker.
10 //
11 // Posix-specific details.
12 //===----------------------------------------------------------------------===//
13 
14 #include "sanitizer_common/sanitizer_platform.h"
15 #if SANITIZER_POSIX
16 
17 #  include <pthread.h>
18 #  include <signal.h>
19 #  include <stdlib.h>
20 #  include <sys/resource.h>
21 #  include <sys/time.h>
22 #  include <unistd.h>
23 
24 #  include "asan_interceptors.h"
25 #  include "asan_internal.h"
26 #  include "asan_mapping.h"
27 #  include "asan_poisoning.h"
28 #  include "asan_report.h"
29 #  include "asan_stack.h"
30 #  include "lsan/lsan_common.h"
31 #  include "sanitizer_common/sanitizer_libc.h"
32 #  include "sanitizer_common/sanitizer_posix.h"
33 #  include "sanitizer_common/sanitizer_procmaps.h"
34 
35 namespace __asan {
36 
37 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
38   StartReportDeadlySignal();
39   SignalContext sig(siginfo, context);
40   ReportDeadlySignal(sig);
41 }
42 
43 bool PlatformUnpoisonStacks() {
44   stack_t signal_stack;
45   CHECK_EQ(0, sigaltstack(nullptr, &signal_stack));
46   uptr sigalt_bottom = (uptr)signal_stack.ss_sp;
47   uptr sigalt_top = (uptr)((char *)signal_stack.ss_sp + signal_stack.ss_size);
48   // If we're executing on the signal alternate stack AND the Linux flag
49   // SS_AUTODISARM was used, then we cannot get the signal alternate stack
50   // bounds from sigaltstack -- sigaltstack's output looks just as if no
51   // alternate stack has ever been set up.
52   // We're always unpoisoning the signal alternate stack to support jumping
53   // between the default stack and signal alternate stack.
54   if (signal_stack.ss_flags != SS_DISABLE)
55     UnpoisonStack(sigalt_bottom, sigalt_top, "sigalt");
56 
57   if (signal_stack.ss_flags != SS_ONSTACK)
58     return false;
59 
60   // Since we're on the signal alternate stack, we cannot find the DEFAULT
61   // stack bottom using a local variable.
62   uptr default_bottom, tls_addr, tls_size, stack_size;
63   GetThreadStackAndTls(/*main=*/false, &default_bottom, &stack_size, &tls_addr,
64                        &tls_size);
65   UnpoisonStack(default_bottom, default_bottom + stack_size, "default");
66   return true;
67 }
68 
69 // ---------------------- TSD ---------------- {{{1
70 
71 #if SANITIZER_NETBSD && !ASAN_DYNAMIC
72 // Thread Static Data cannot be used in early static ASan init on NetBSD.
73 // Reuse the Asan TSD API for compatibility with existing code
74 // with an alternative implementation.
75 
76 static void (*tsd_destructor)(void *tsd) = nullptr;
77 
78 struct tsd_key {
79   tsd_key() : key(nullptr) {}
80   ~tsd_key() {
81     CHECK(tsd_destructor);
82     if (key)
83       (*tsd_destructor)(key);
84   }
85   void *key;
86 };
87 
88 static thread_local struct tsd_key key;
89 
90 void AsanTSDInit(void (*destructor)(void *tsd)) {
91   CHECK(!tsd_destructor);
92   tsd_destructor = destructor;
93 }
94 
95 void *AsanTSDGet() {
96   CHECK(tsd_destructor);
97   return key.key;
98 }
99 
100 void AsanTSDSet(void *tsd) {
101   CHECK(tsd_destructor);
102   CHECK(tsd);
103   CHECK(!key.key);
104   key.key = tsd;
105 }
106 
107 void PlatformTSDDtor(void *tsd) {
108   CHECK(tsd_destructor);
109   CHECK_EQ(key.key, tsd);
110   key.key = nullptr;
111   // Make sure that signal handler can not see a stale current thread pointer.
112   atomic_signal_fence(memory_order_seq_cst);
113   AsanThread::TSDDtor(tsd);
114 }
115 #else
116 static pthread_key_t tsd_key;
117 static bool tsd_key_inited = false;
118 void AsanTSDInit(void (*destructor)(void *tsd)) {
119   CHECK(!tsd_key_inited);
120   tsd_key_inited = true;
121   CHECK_EQ(0, pthread_key_create(&tsd_key, destructor));
122 }
123 
124 void *AsanTSDGet() {
125   CHECK(tsd_key_inited);
126   return pthread_getspecific(tsd_key);
127 }
128 
129 void AsanTSDSet(void *tsd) {
130   CHECK(tsd_key_inited);
131   pthread_setspecific(tsd_key, tsd);
132 }
133 
134 void PlatformTSDDtor(void *tsd) {
135   AsanThreadContext *context = (AsanThreadContext *)tsd;
136   if (context->destructor_iterations > 1) {
137     context->destructor_iterations--;
138     CHECK_EQ(0, pthread_setspecific(tsd_key, tsd));
139     return;
140   }
141   AsanThread::TSDDtor(tsd);
142 }
143 #endif
144 
145 void InstallAtExitCheckLeaks() {
146   if (CAN_SANITIZE_LEAKS) {
147     if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit) {
148       if (flags()->halt_on_error)
149         Atexit(__lsan::DoLeakCheck);
150       else
151         Atexit(__lsan::DoRecoverableLeakCheckVoid);
152     }
153   }
154 }
155 
156 }  // namespace __asan
157 
158 #endif  // SANITIZER_POSIX
159