1 //===-- tsan_interface.h ----------------------------------------*- C++ -*-===// 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 // The functions declared in this header will be inserted by the instrumentation 12 // module. 13 // This header can be included by the instrumented program or by TSan tests. 14 //===----------------------------------------------------------------------===// 15 #ifndef TSAN_INTERFACE_H 16 #define TSAN_INTERFACE_H 17 18 #include <sanitizer_common/sanitizer_internal_defs.h> 19 using __sanitizer::uptr; 20 using __sanitizer::tid_t; 21 22 // This header should NOT include any other headers. 23 // All functions in this header are extern "C" and start with __tsan_. 24 25 #ifdef __cplusplus 26 extern "C" { 27 #endif 28 29 #if !SANITIZER_GO 30 31 // This function should be called at the very beginning of the process, 32 // before any instrumented code is executed and before any call to malloc. 33 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_init(); 34 35 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_flush_memory(); 36 37 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1(void *addr); 38 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2(void *addr); 39 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4(void *addr); 40 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8(void *addr); 41 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16(void *addr); 42 43 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1(void *addr); 44 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2(void *addr); 45 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4(void *addr); 46 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8(void *addr); 47 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16(void *addr); 48 49 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read2(const void *addr); 50 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read4(const void *addr); 51 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read8(const void *addr); 52 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read16(const void *addr); 53 54 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write2(void *addr); 55 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write4(void *addr); 56 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write8(void *addr); 57 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write16(void *addr); 58 59 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1_pc(void *addr, void *pc); 60 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2_pc(void *addr, void *pc); 61 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4_pc(void *addr, void *pc); 62 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8_pc(void *addr, void *pc); 63 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16_pc(void *addr, void *pc); 64 65 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1_pc(void *addr, void *pc); 66 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2_pc(void *addr, void *pc); 67 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4_pc(void *addr, void *pc); 68 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8_pc(void *addr, void *pc); 69 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16_pc(void *addr, void *pc); 70 71 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_vptr_read(void **vptr_p); 72 SANITIZER_INTERFACE_ATTRIBUTE 73 void __tsan_vptr_update(void **vptr_p, void *new_val); 74 75 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc); 76 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit(); 77 78 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_begin(); 79 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_end(); 80 81 SANITIZER_INTERFACE_ATTRIBUTE 82 void *__tsan_external_register_tag(const char *object_type); 83 SANITIZER_INTERFACE_ATTRIBUTE 84 void __tsan_external_register_header(void *tag, const char *header); 85 SANITIZER_INTERFACE_ATTRIBUTE 86 void __tsan_external_assign_tag(void *addr, void *tag); 87 SANITIZER_INTERFACE_ATTRIBUTE 88 void __tsan_external_read(void *addr, void *caller_pc, void *tag); 89 SANITIZER_INTERFACE_ATTRIBUTE 90 void __tsan_external_write(void *addr, void *caller_pc, void *tag); 91 92 SANITIZER_INTERFACE_ATTRIBUTE 93 void __tsan_read_range(void *addr, unsigned long size); 94 SANITIZER_INTERFACE_ATTRIBUTE 95 void __tsan_write_range(void *addr, unsigned long size); 96 97 SANITIZER_INTERFACE_ATTRIBUTE 98 void __tsan_read_range_pc(void *addr, unsigned long size, void *pc); // NOLINT 99 SANITIZER_INTERFACE_ATTRIBUTE 100 void __tsan_write_range_pc(void *addr, unsigned long size, void *pc); // NOLINT 101 102 // User may provide function that would be called right when TSan detects 103 // an error. The argument 'report' is an opaque pointer that can be used to 104 // gather additional information using other TSan report API functions. 105 SANITIZER_INTERFACE_ATTRIBUTE 106 void __tsan_on_report(void *report); 107 108 // If TSan is currently reporting a detected issue on the current thread, 109 // returns an opaque pointer to the current report. Otherwise returns NULL. 110 SANITIZER_INTERFACE_ATTRIBUTE 111 void *__tsan_get_current_report(); 112 113 // Returns a report's description (issue type), number of duplicate issues 114 // found, counts of array data (stack traces, memory operations, locations, 115 // mutexes, threads, unique thread IDs) and a stack trace of a sleep() call (if 116 // one was involved in the issue). 117 SANITIZER_INTERFACE_ATTRIBUTE 118 int __tsan_get_report_data(void *report, const char **description, int *count, 119 int *stack_count, int *mop_count, int *loc_count, 120 int *mutex_count, int *thread_count, 121 int *unique_tid_count, void **sleep_trace, 122 uptr trace_size); 123 124 /// Retrieves the "tag" from a report (for external-race report types). External 125 /// races can be associated with a tag which give them more meaning. For example 126 /// tag value '1' means "Swift access race". Tag value '0' indicated a plain 127 /// external race. 128 /// 129 /// \param report opaque pointer to the current report (obtained as argument in 130 /// __tsan_on_report, or from __tsan_get_current_report) 131 /// \param [out] tag points to storage that will be filled with the tag value 132 /// 133 /// \returns non-zero value on success, zero on failure 134 SANITIZER_INTERFACE_ATTRIBUTE 135 int __tsan_get_report_tag(void *report, uptr *tag); 136 137 // Returns information about stack traces included in the report. 138 SANITIZER_INTERFACE_ATTRIBUTE 139 int __tsan_get_report_stack(void *report, uptr idx, void **trace, 140 uptr trace_size); 141 142 // Returns information about memory operations included in the report. 143 SANITIZER_INTERFACE_ATTRIBUTE 144 int __tsan_get_report_mop(void *report, uptr idx, int *tid, void **addr, 145 int *size, int *write, int *atomic, void **trace, 146 uptr trace_size); 147 148 // Returns information about locations included in the report. 149 SANITIZER_INTERFACE_ATTRIBUTE 150 int __tsan_get_report_loc(void *report, uptr idx, const char **type, 151 void **addr, uptr *start, uptr *size, int *tid, 152 int *fd, int *suppressable, void **trace, 153 uptr trace_size); 154 155 SANITIZER_INTERFACE_ATTRIBUTE 156 int __tsan_get_report_loc_object_type(void *report, uptr idx, 157 const char **object_type); 158 159 // Returns information about mutexes included in the report. 160 SANITIZER_INTERFACE_ATTRIBUTE 161 int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr, 162 int *destroyed, void **trace, uptr trace_size); 163 164 // Returns information about threads included in the report. 165 SANITIZER_INTERFACE_ATTRIBUTE 166 int __tsan_get_report_thread(void *report, uptr idx, int *tid, tid_t *os_id, 167 int *running, const char **name, int *parent_tid, 168 void **trace, uptr trace_size); 169 170 // Returns information about unique thread IDs included in the report. 171 SANITIZER_INTERFACE_ATTRIBUTE 172 int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid); 173 174 // Returns the type of the pointer (heap, stack, global, ...) and if possible 175 // also the starting address (e.g. of a heap allocation) and size. 176 SANITIZER_INTERFACE_ATTRIBUTE 177 const char *__tsan_locate_address(uptr addr, char *name, uptr name_size, 178 uptr *region_address, uptr *region_size); 179 180 // Returns the allocation stack for a heap pointer. 181 SANITIZER_INTERFACE_ATTRIBUTE 182 int __tsan_get_alloc_stack(uptr addr, uptr *trace, uptr size, int *thread_id, 183 tid_t *os_id); 184 185 #endif // SANITIZER_GO 186 187 #ifdef __cplusplus 188 } // extern "C" 189 #endif 190 191 namespace __tsan { 192 193 // These should match declarations from public tsan_interface_atomic.h header. 194 typedef unsigned char a8; 195 typedef unsigned short a16; 196 typedef unsigned int a32; 197 typedef unsigned long long a64; 198 #if !SANITIZER_GO && (defined(__SIZEOF_INT128__) \ 199 || (__clang_major__ * 100 + __clang_minor__ >= 302)) && !defined(__mips64) 200 __extension__ typedef __int128 a128; 201 # define __TSAN_HAS_INT128 1 202 #else 203 # define __TSAN_HAS_INT128 0 204 #endif 205 206 // Part of ABI, do not change. 207 // https://github.com/llvm/llvm-project/blob/master/libcxx/include/atomic 208 typedef enum { 209 mo_relaxed, 210 mo_consume, 211 mo_acquire, 212 mo_release, 213 mo_acq_rel, 214 mo_seq_cst 215 } morder; 216 217 struct ThreadState; 218 219 extern "C" { 220 SANITIZER_INTERFACE_ATTRIBUTE 221 a8 __tsan_atomic8_load(const volatile a8 *a, morder mo); 222 SANITIZER_INTERFACE_ATTRIBUTE 223 a16 __tsan_atomic16_load(const volatile a16 *a, morder mo); 224 SANITIZER_INTERFACE_ATTRIBUTE 225 a32 __tsan_atomic32_load(const volatile a32 *a, morder mo); 226 SANITIZER_INTERFACE_ATTRIBUTE 227 a64 __tsan_atomic64_load(const volatile a64 *a, morder mo); 228 #if __TSAN_HAS_INT128 229 SANITIZER_INTERFACE_ATTRIBUTE 230 a128 __tsan_atomic128_load(const volatile a128 *a, morder mo); 231 #endif 232 233 SANITIZER_INTERFACE_ATTRIBUTE 234 void __tsan_atomic8_store(volatile a8 *a, a8 v, morder mo); 235 SANITIZER_INTERFACE_ATTRIBUTE 236 void __tsan_atomic16_store(volatile a16 *a, a16 v, morder mo); 237 SANITIZER_INTERFACE_ATTRIBUTE 238 void __tsan_atomic32_store(volatile a32 *a, a32 v, morder mo); 239 SANITIZER_INTERFACE_ATTRIBUTE 240 void __tsan_atomic64_store(volatile a64 *a, a64 v, morder mo); 241 #if __TSAN_HAS_INT128 242 SANITIZER_INTERFACE_ATTRIBUTE 243 void __tsan_atomic128_store(volatile a128 *a, a128 v, morder mo); 244 #endif 245 246 SANITIZER_INTERFACE_ATTRIBUTE 247 a8 __tsan_atomic8_exchange(volatile a8 *a, a8 v, morder mo); 248 SANITIZER_INTERFACE_ATTRIBUTE 249 a16 __tsan_atomic16_exchange(volatile a16 *a, a16 v, morder mo); 250 SANITIZER_INTERFACE_ATTRIBUTE 251 a32 __tsan_atomic32_exchange(volatile a32 *a, a32 v, morder mo); 252 SANITIZER_INTERFACE_ATTRIBUTE 253 a64 __tsan_atomic64_exchange(volatile a64 *a, a64 v, morder mo); 254 #if __TSAN_HAS_INT128 255 SANITIZER_INTERFACE_ATTRIBUTE 256 a128 __tsan_atomic128_exchange(volatile a128 *a, a128 v, morder mo); 257 #endif 258 259 SANITIZER_INTERFACE_ATTRIBUTE 260 a8 __tsan_atomic8_fetch_add(volatile a8 *a, a8 v, morder mo); 261 SANITIZER_INTERFACE_ATTRIBUTE 262 a16 __tsan_atomic16_fetch_add(volatile a16 *a, a16 v, morder mo); 263 SANITIZER_INTERFACE_ATTRIBUTE 264 a32 __tsan_atomic32_fetch_add(volatile a32 *a, a32 v, morder mo); 265 SANITIZER_INTERFACE_ATTRIBUTE 266 a64 __tsan_atomic64_fetch_add(volatile a64 *a, a64 v, morder mo); 267 #if __TSAN_HAS_INT128 268 SANITIZER_INTERFACE_ATTRIBUTE 269 a128 __tsan_atomic128_fetch_add(volatile a128 *a, a128 v, morder mo); 270 #endif 271 272 SANITIZER_INTERFACE_ATTRIBUTE 273 a8 __tsan_atomic8_fetch_sub(volatile a8 *a, a8 v, morder mo); 274 SANITIZER_INTERFACE_ATTRIBUTE 275 a16 __tsan_atomic16_fetch_sub(volatile a16 *a, a16 v, morder mo); 276 SANITIZER_INTERFACE_ATTRIBUTE 277 a32 __tsan_atomic32_fetch_sub(volatile a32 *a, a32 v, morder mo); 278 SANITIZER_INTERFACE_ATTRIBUTE 279 a64 __tsan_atomic64_fetch_sub(volatile a64 *a, a64 v, morder mo); 280 #if __TSAN_HAS_INT128 281 SANITIZER_INTERFACE_ATTRIBUTE 282 a128 __tsan_atomic128_fetch_sub(volatile a128 *a, a128 v, morder mo); 283 #endif 284 285 SANITIZER_INTERFACE_ATTRIBUTE 286 a8 __tsan_atomic8_fetch_and(volatile a8 *a, a8 v, morder mo); 287 SANITIZER_INTERFACE_ATTRIBUTE 288 a16 __tsan_atomic16_fetch_and(volatile a16 *a, a16 v, morder mo); 289 SANITIZER_INTERFACE_ATTRIBUTE 290 a32 __tsan_atomic32_fetch_and(volatile a32 *a, a32 v, morder mo); 291 SANITIZER_INTERFACE_ATTRIBUTE 292 a64 __tsan_atomic64_fetch_and(volatile a64 *a, a64 v, morder mo); 293 #if __TSAN_HAS_INT128 294 SANITIZER_INTERFACE_ATTRIBUTE 295 a128 __tsan_atomic128_fetch_and(volatile a128 *a, a128 v, morder mo); 296 #endif 297 298 SANITIZER_INTERFACE_ATTRIBUTE 299 a8 __tsan_atomic8_fetch_or(volatile a8 *a, a8 v, morder mo); 300 SANITIZER_INTERFACE_ATTRIBUTE 301 a16 __tsan_atomic16_fetch_or(volatile a16 *a, a16 v, morder mo); 302 SANITIZER_INTERFACE_ATTRIBUTE 303 a32 __tsan_atomic32_fetch_or(volatile a32 *a, a32 v, morder mo); 304 SANITIZER_INTERFACE_ATTRIBUTE 305 a64 __tsan_atomic64_fetch_or(volatile a64 *a, a64 v, morder mo); 306 #if __TSAN_HAS_INT128 307 SANITIZER_INTERFACE_ATTRIBUTE 308 a128 __tsan_atomic128_fetch_or(volatile a128 *a, a128 v, morder mo); 309 #endif 310 311 SANITIZER_INTERFACE_ATTRIBUTE 312 a8 __tsan_atomic8_fetch_xor(volatile a8 *a, a8 v, morder mo); 313 SANITIZER_INTERFACE_ATTRIBUTE 314 a16 __tsan_atomic16_fetch_xor(volatile a16 *a, a16 v, morder mo); 315 SANITIZER_INTERFACE_ATTRIBUTE 316 a32 __tsan_atomic32_fetch_xor(volatile a32 *a, a32 v, morder mo); 317 SANITIZER_INTERFACE_ATTRIBUTE 318 a64 __tsan_atomic64_fetch_xor(volatile a64 *a, a64 v, morder mo); 319 #if __TSAN_HAS_INT128 320 SANITIZER_INTERFACE_ATTRIBUTE 321 a128 __tsan_atomic128_fetch_xor(volatile a128 *a, a128 v, morder mo); 322 #endif 323 324 SANITIZER_INTERFACE_ATTRIBUTE 325 a8 __tsan_atomic8_fetch_nand(volatile a8 *a, a8 v, morder mo); 326 SANITIZER_INTERFACE_ATTRIBUTE 327 a16 __tsan_atomic16_fetch_nand(volatile a16 *a, a16 v, morder mo); 328 SANITIZER_INTERFACE_ATTRIBUTE 329 a32 __tsan_atomic32_fetch_nand(volatile a32 *a, a32 v, morder mo); 330 SANITIZER_INTERFACE_ATTRIBUTE 331 a64 __tsan_atomic64_fetch_nand(volatile a64 *a, a64 v, morder mo); 332 #if __TSAN_HAS_INT128 333 SANITIZER_INTERFACE_ATTRIBUTE 334 a128 __tsan_atomic128_fetch_nand(volatile a128 *a, a128 v, morder mo); 335 #endif 336 337 SANITIZER_INTERFACE_ATTRIBUTE 338 int __tsan_atomic8_compare_exchange_strong(volatile a8 *a, a8 *c, a8 v, 339 morder mo, morder fmo); 340 SANITIZER_INTERFACE_ATTRIBUTE 341 int __tsan_atomic16_compare_exchange_strong(volatile a16 *a, a16 *c, a16 v, 342 morder mo, morder fmo); 343 SANITIZER_INTERFACE_ATTRIBUTE 344 int __tsan_atomic32_compare_exchange_strong(volatile a32 *a, a32 *c, a32 v, 345 morder mo, morder fmo); 346 SANITIZER_INTERFACE_ATTRIBUTE 347 int __tsan_atomic64_compare_exchange_strong(volatile a64 *a, a64 *c, a64 v, 348 morder mo, morder fmo); 349 #if __TSAN_HAS_INT128 350 SANITIZER_INTERFACE_ATTRIBUTE 351 int __tsan_atomic128_compare_exchange_strong(volatile a128 *a, a128 *c, a128 v, 352 morder mo, morder fmo); 353 #endif 354 355 SANITIZER_INTERFACE_ATTRIBUTE 356 int __tsan_atomic8_compare_exchange_weak(volatile a8 *a, a8 *c, a8 v, morder mo, 357 morder fmo); 358 SANITIZER_INTERFACE_ATTRIBUTE 359 int __tsan_atomic16_compare_exchange_weak(volatile a16 *a, a16 *c, a16 v, 360 morder mo, morder fmo); 361 SANITIZER_INTERFACE_ATTRIBUTE 362 int __tsan_atomic32_compare_exchange_weak(volatile a32 *a, a32 *c, a32 v, 363 morder mo, morder fmo); 364 SANITIZER_INTERFACE_ATTRIBUTE 365 int __tsan_atomic64_compare_exchange_weak(volatile a64 *a, a64 *c, a64 v, 366 morder mo, morder fmo); 367 #if __TSAN_HAS_INT128 368 SANITIZER_INTERFACE_ATTRIBUTE 369 int __tsan_atomic128_compare_exchange_weak(volatile a128 *a, a128 *c, a128 v, 370 morder mo, morder fmo); 371 #endif 372 373 SANITIZER_INTERFACE_ATTRIBUTE 374 a8 __tsan_atomic8_compare_exchange_val(volatile a8 *a, a8 c, a8 v, morder mo, 375 morder fmo); 376 SANITIZER_INTERFACE_ATTRIBUTE 377 a16 __tsan_atomic16_compare_exchange_val(volatile a16 *a, a16 c, a16 v, 378 morder mo, morder fmo); 379 SANITIZER_INTERFACE_ATTRIBUTE 380 a32 __tsan_atomic32_compare_exchange_val(volatile a32 *a, a32 c, a32 v, 381 morder mo, morder fmo); 382 SANITIZER_INTERFACE_ATTRIBUTE 383 a64 __tsan_atomic64_compare_exchange_val(volatile a64 *a, a64 c, a64 v, 384 morder mo, morder fmo); 385 #if __TSAN_HAS_INT128 386 SANITIZER_INTERFACE_ATTRIBUTE 387 a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v, 388 morder mo, morder fmo); 389 #endif 390 391 SANITIZER_INTERFACE_ATTRIBUTE 392 void __tsan_atomic_thread_fence(morder mo); 393 SANITIZER_INTERFACE_ATTRIBUTE 394 void __tsan_atomic_signal_fence(morder mo); 395 396 SANITIZER_INTERFACE_ATTRIBUTE 397 void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 398 SANITIZER_INTERFACE_ATTRIBUTE 399 void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 400 SANITIZER_INTERFACE_ATTRIBUTE 401 void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 402 SANITIZER_INTERFACE_ATTRIBUTE 403 void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 404 SANITIZER_INTERFACE_ATTRIBUTE 405 void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 406 SANITIZER_INTERFACE_ATTRIBUTE 407 void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 408 SANITIZER_INTERFACE_ATTRIBUTE 409 void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 410 SANITIZER_INTERFACE_ATTRIBUTE 411 void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 412 SANITIZER_INTERFACE_ATTRIBUTE 413 void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 414 u8 *a); 415 SANITIZER_INTERFACE_ATTRIBUTE 416 void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 417 u8 *a); 418 } // extern "C" 419 420 } // namespace __tsan 421 422 #endif // TSAN_INTERFACE_H 423