]> git.proxmox.com Git - rustc.git/blob - src/compiler-rt/lib/tsan/go/tsan_go.cc
New upstream version 1.19.0+dfsg3
[rustc.git] / src / compiler-rt / lib / tsan / go / tsan_go.cc
1 //===-- tsan_go.cc --------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // ThreadSanitizer runtime for Go language.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "tsan_rtl.h"
15 #include "tsan_symbolize.h"
16 #include "sanitizer_common/sanitizer_common.h"
17 #include <stdlib.h>
18
19 namespace __tsan {
20
21 void InitializeInterceptors() {
22 }
23
24 void InitializeDynamicAnnotations() {
25 }
26
27 bool IsExpectedReport(uptr addr, uptr size) {
28 return false;
29 }
30
31 void *internal_alloc(MBlockType typ, uptr sz) {
32 return InternalAlloc(sz);
33 }
34
35 void internal_free(void *p) {
36 InternalFree(p);
37 }
38
39 // Callback into Go.
40 static void (*go_runtime_cb)(uptr cmd, void *ctx);
41
42 enum {
43 CallbackGetProc = 0,
44 CallbackSymbolizeCode = 1,
45 CallbackSymbolizeData = 2,
46 };
47
48 struct SymbolizeCodeContext {
49 uptr pc;
50 char *func;
51 char *file;
52 uptr line;
53 uptr off;
54 uptr res;
55 };
56
57 SymbolizedStack *SymbolizeCode(uptr addr) {
58 SymbolizedStack *s = SymbolizedStack::New(addr);
59 SymbolizeCodeContext cbctx;
60 internal_memset(&cbctx, 0, sizeof(cbctx));
61 cbctx.pc = addr;
62 go_runtime_cb(CallbackSymbolizeCode, &cbctx);
63 if (cbctx.res) {
64 AddressInfo &info = s->info;
65 info.module_offset = cbctx.off;
66 info.function = internal_strdup(cbctx.func ? cbctx.func : "??");
67 info.file = internal_strdup(cbctx.file ? cbctx.file : "-");
68 info.line = cbctx.line;
69 info.column = 0;
70 }
71 return s;
72 }
73
74 struct SymbolizeDataContext {
75 uptr addr;
76 uptr heap;
77 uptr start;
78 uptr size;
79 char *name;
80 char *file;
81 uptr line;
82 uptr res;
83 };
84
85 ReportLocation *SymbolizeData(uptr addr) {
86 SymbolizeDataContext cbctx;
87 internal_memset(&cbctx, 0, sizeof(cbctx));
88 cbctx.addr = addr;
89 go_runtime_cb(CallbackSymbolizeData, &cbctx);
90 if (!cbctx.res)
91 return 0;
92 if (cbctx.heap) {
93 MBlock *b = ctx->metamap.GetBlock(cbctx.start);
94 if (!b)
95 return 0;
96 ReportLocation *loc = ReportLocation::New(ReportLocationHeap);
97 loc->heap_chunk_start = cbctx.start;
98 loc->heap_chunk_size = b->siz;
99 loc->tid = b->tid;
100 loc->stack = SymbolizeStackId(b->stk);
101 return loc;
102 } else {
103 ReportLocation *loc = ReportLocation::New(ReportLocationGlobal);
104 loc->global.name = internal_strdup(cbctx.name ? cbctx.name : "??");
105 loc->global.file = internal_strdup(cbctx.file ? cbctx.file : "??");
106 loc->global.line = cbctx.line;
107 loc->global.start = cbctx.start;
108 loc->global.size = cbctx.size;
109 return loc;
110 }
111 }
112
113 static ThreadState *main_thr;
114 static bool inited;
115
116 static Processor* get_cur_proc() {
117 if (UNLIKELY(!inited)) {
118 // Running Initialize().
119 // We have not yet returned the Processor to Go, so we cannot ask it back.
120 // Currently, Initialize() does not use the Processor, so return nullptr.
121 return nullptr;
122 }
123 Processor *proc;
124 go_runtime_cb(CallbackGetProc, &proc);
125 return proc;
126 }
127
128 Processor *ThreadState::proc() {
129 return get_cur_proc();
130 }
131
132 extern "C" {
133
134 static ThreadState *AllocGoroutine() {
135 ThreadState *thr = (ThreadState*)internal_alloc(MBlockThreadContex,
136 sizeof(ThreadState));
137 internal_memset(thr, 0, sizeof(*thr));
138 return thr;
139 }
140
141 void __tsan_init(ThreadState **thrp, Processor **procp,
142 void (*cb)(uptr cmd, void *cb)) {
143 go_runtime_cb = cb;
144 ThreadState *thr = AllocGoroutine();
145 main_thr = *thrp = thr;
146 Initialize(thr);
147 *procp = thr->proc1;
148 inited = true;
149 }
150
151 void __tsan_fini() {
152 // FIXME: Not necessary thread 0.
153 ThreadState *thr = main_thr;
154 int res = Finalize(thr);
155 exit(res);
156 }
157
158 void __tsan_map_shadow(uptr addr, uptr size) {
159 MapShadow(addr, size);
160 }
161
162 void __tsan_read(ThreadState *thr, void *addr, void *pc) {
163 MemoryRead(thr, (uptr)pc, (uptr)addr, kSizeLog1);
164 }
165
166 void __tsan_read_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
167 if (callpc != 0)
168 FuncEntry(thr, callpc);
169 MemoryRead(thr, (uptr)pc, (uptr)addr, kSizeLog1);
170 if (callpc != 0)
171 FuncExit(thr);
172 }
173
174 void __tsan_write(ThreadState *thr, void *addr, void *pc) {
175 MemoryWrite(thr, (uptr)pc, (uptr)addr, kSizeLog1);
176 }
177
178 void __tsan_write_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
179 if (callpc != 0)
180 FuncEntry(thr, callpc);
181 MemoryWrite(thr, (uptr)pc, (uptr)addr, kSizeLog1);
182 if (callpc != 0)
183 FuncExit(thr);
184 }
185
186 void __tsan_read_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
187 MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, false);
188 }
189
190 void __tsan_write_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
191 MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, true);
192 }
193
194 void __tsan_func_enter(ThreadState *thr, void *pc) {
195 FuncEntry(thr, (uptr)pc);
196 }
197
198 void __tsan_func_exit(ThreadState *thr) {
199 FuncExit(thr);
200 }
201
202 void __tsan_malloc(ThreadState *thr, uptr pc, uptr p, uptr sz) {
203 CHECK(inited);
204 if (thr && pc)
205 ctx->metamap.AllocBlock(thr, pc, p, sz);
206 MemoryResetRange(0, 0, (uptr)p, sz);
207 }
208
209 void __tsan_free(uptr p, uptr sz) {
210 ctx->metamap.FreeRange(get_cur_proc(), p, sz);
211 }
212
213 void __tsan_go_start(ThreadState *parent, ThreadState **pthr, void *pc) {
214 ThreadState *thr = AllocGoroutine();
215 *pthr = thr;
216 int goid = ThreadCreate(parent, (uptr)pc, 0, true);
217 ThreadStart(thr, goid, 0);
218 }
219
220 void __tsan_go_end(ThreadState *thr) {
221 ThreadFinish(thr);
222 internal_free(thr);
223 }
224
225 void __tsan_proc_create(Processor **pproc) {
226 *pproc = ProcCreate();
227 }
228
229 void __tsan_proc_destroy(Processor *proc) {
230 ProcDestroy(proc);
231 }
232
233 void __tsan_acquire(ThreadState *thr, void *addr) {
234 Acquire(thr, 0, (uptr)addr);
235 }
236
237 void __tsan_release(ThreadState *thr, void *addr) {
238 ReleaseStore(thr, 0, (uptr)addr);
239 }
240
241 void __tsan_release_merge(ThreadState *thr, void *addr) {
242 Release(thr, 0, (uptr)addr);
243 }
244
245 void __tsan_finalizer_goroutine(ThreadState *thr) {
246 AcquireGlobal(thr, 0);
247 }
248
249 void __tsan_mutex_before_lock(ThreadState *thr, uptr addr, uptr write) {
250 }
251
252 void __tsan_mutex_after_lock(ThreadState *thr, uptr addr, uptr write) {
253 if (write)
254 MutexLock(thr, 0, addr);
255 else
256 MutexReadLock(thr, 0, addr);
257 }
258
259 void __tsan_mutex_before_unlock(ThreadState *thr, uptr addr, uptr write) {
260 if (write)
261 MutexUnlock(thr, 0, addr);
262 else
263 MutexReadUnlock(thr, 0, addr);
264 }
265
266 void __tsan_go_ignore_sync_begin(ThreadState *thr) {
267 ThreadIgnoreSyncBegin(thr, 0);
268 }
269
270 void __tsan_go_ignore_sync_end(ThreadState *thr) {
271 ThreadIgnoreSyncEnd(thr, 0);
272 }
273
274 void __tsan_report_count(u64 *pn) {
275 Lock lock(&ctx->report_mtx);
276 *pn = ctx->nreported;
277 }
278
279 } // extern "C"
280 } // namespace __tsan
281
282 namespace __sanitizer {
283
284 void SymbolizerPrepareForSandboxing() {
285 // Nothing to do here for Go.
286 }
287
288 } // namespace __sanitizer