1//===-- asan_errors.h -------------------------------------------*- C++ -*-===// 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// This file is a part of AddressSanitizer, an address sanity checker. 11// 12// ASan-private header for error structures. 13//===----------------------------------------------------------------------===// 14#ifndef ASAN_ERRORS_H 15#define ASAN_ERRORS_H 16 17#include "asan_descriptions.h" 18#include "asan_scariness_score.h" 19#include "sanitizer_common/sanitizer_common.h" 20 21namespace __asan { 22 23// (*) VS2013 does not implement unrestricted unions, so we need a trivial 24// default constructor explicitly defined for each particular error. 25 26// None of the error classes own the stack traces mentioned in them. 27 28struct ErrorBase { 29 ScarinessScoreBase scariness; 30 u32 tid; 31 32 ErrorBase() = default; // (*) 33 explicit ErrorBase(u32 tid_) : tid(tid_) {} 34 ErrorBase(u32 tid_, int initial_score, const char *reason) : tid(tid_) { 35 scariness.Clear(); 36 scariness.Scare(initial_score, reason); 37 } 38}; 39 40struct ErrorDeadlySignal : ErrorBase { 41 SignalContext signal; 42 43 ErrorDeadlySignal() = default; // (*) 44 ErrorDeadlySignal(u32 tid, const SignalContext &sig) 45 : ErrorBase(tid), 46 signal(sig) { 47 scariness.Clear(); 48 if (signal.IsStackOverflow()) { 49 scariness.Scare(10, "stack-overflow"); 50 } else if (!signal.is_memory_access) { 51 scariness.Scare(10, "signal"); 52 } else if (signal.addr < GetPageSizeCached()) { 53 scariness.Scare(10, "null-deref"); 54 } else if (signal.addr == signal.pc) { 55 scariness.Scare(60, "wild-jump"); 56 } else if (signal.write_flag == SignalContext::WRITE) { 57 scariness.Scare(30, "wild-addr-write"); 58 } else if (signal.write_flag == SignalContext::READ) { 59 scariness.Scare(20, "wild-addr-read"); 60 } else { 61 scariness.Scare(25, "wild-addr"); 62 } 63 } 64 void Print(); 65}; 66 67struct ErrorDoubleFree : ErrorBase { 68 const BufferedStackTrace *second_free_stack; 69 HeapAddressDescription addr_description; 70 71 ErrorDoubleFree() = default; // (*) 72 ErrorDoubleFree(u32 tid, BufferedStackTrace *stack, uptr addr) 73 : ErrorBase(tid, 42, "double-free"), 74 second_free_stack(stack) { 75 CHECK_GT(second_free_stack->size, 0); 76 GetHeapAddressInformation(addr, 1, &addr_description); 77 } 78 void Print(); 79}; 80 81struct ErrorNewDeleteTypeMismatch : ErrorBase { 82 const BufferedStackTrace *free_stack; 83 HeapAddressDescription addr_description; 84 uptr delete_size; 85 uptr delete_alignment; 86 87 ErrorNewDeleteTypeMismatch() = default; // (*) 88 ErrorNewDeleteTypeMismatch(u32 tid, BufferedStackTrace *stack, uptr addr, 89 uptr delete_size_, uptr delete_alignment_) 90 : ErrorBase(tid, 10, "new-delete-type-mismatch"), 91 free_stack(stack), 92 delete_size(delete_size_), 93 delete_alignment(delete_alignment_) { 94 GetHeapAddressInformation(addr, 1, &addr_description); 95 } 96 void Print(); 97}; 98 99struct ErrorFreeNotMalloced : ErrorBase { 100 const BufferedStackTrace *free_stack; 101 AddressDescription addr_description; 102 103 ErrorFreeNotMalloced() = default; // (*) 104 ErrorFreeNotMalloced(u32 tid, BufferedStackTrace *stack, uptr addr) 105 : ErrorBase(tid, 40, "bad-free"), 106 free_stack(stack), 107 addr_description(addr, /*shouldLockThreadRegistry=*/false) {} 108 void Print(); 109}; 110 111struct ErrorAllocTypeMismatch : ErrorBase { 112 const BufferedStackTrace *dealloc_stack; 113 AllocType alloc_type, dealloc_type; 114 AddressDescription addr_description; 115 116 ErrorAllocTypeMismatch() = default; // (*) 117 ErrorAllocTypeMismatch(u32 tid, BufferedStackTrace *stack, uptr addr, 118 AllocType alloc_type_, AllocType dealloc_type_) 119 : ErrorBase(tid, 10, "alloc-dealloc-mismatch"), 120 dealloc_stack(stack), 121 alloc_type(alloc_type_), 122 dealloc_type(dealloc_type_), 123 addr_description(addr, 1, false) {} 124 void Print(); 125}; 126 127struct ErrorMallocUsableSizeNotOwned : ErrorBase { 128 const BufferedStackTrace *stack; 129 AddressDescription addr_description; 130 131 ErrorMallocUsableSizeNotOwned() = default; // (*) 132 ErrorMallocUsableSizeNotOwned(u32 tid, BufferedStackTrace *stack_, uptr addr) 133 : ErrorBase(tid, 10, "bad-malloc_usable_size"), 134 stack(stack_), 135 addr_description(addr, /*shouldLockThreadRegistry=*/false) {} 136 void Print(); 137}; 138 139struct ErrorSanitizerGetAllocatedSizeNotOwned : ErrorBase { 140 const BufferedStackTrace *stack; 141 AddressDescription addr_description; 142 143 ErrorSanitizerGetAllocatedSizeNotOwned() = default; // (*) 144 ErrorSanitizerGetAllocatedSizeNotOwned(u32 tid, BufferedStackTrace *stack_, 145 uptr addr) 146 : ErrorBase(tid, 10, "bad-__sanitizer_get_allocated_size"), 147 stack(stack_), 148 addr_description(addr, /*shouldLockThreadRegistry=*/false) {} 149 void Print(); 150}; 151 152struct ErrorCallocOverflow : ErrorBase { 153 const BufferedStackTrace *stack; 154 uptr count; 155 uptr size; 156 157 ErrorCallocOverflow() = default; // (*) 158 ErrorCallocOverflow(u32 tid, BufferedStackTrace *stack_, uptr count_, 159 uptr size_) 160 : ErrorBase(tid, 10, "calloc-overflow"), 161 stack(stack_), 162 count(count_), 163 size(size_) {} 164 void Print(); 165}; 166 167struct ErrorPvallocOverflow : ErrorBase { 168 const BufferedStackTrace *stack; 169 uptr size; 170 171 ErrorPvallocOverflow() = default; // (*) 172 ErrorPvallocOverflow(u32 tid, BufferedStackTrace *stack_, uptr size_) 173 : ErrorBase(tid, 10, "pvalloc-overflow"), 174 stack(stack_), 175 size(size_) {} 176 void Print(); 177}; 178 179struct ErrorInvalidAllocationAlignment : ErrorBase { 180 const BufferedStackTrace *stack; 181 uptr alignment; 182 183 ErrorInvalidAllocationAlignment() = default; // (*) 184 ErrorInvalidAllocationAlignment(u32 tid, BufferedStackTrace *stack_, 185 uptr alignment_) 186 : ErrorBase(tid, 10, "invalid-allocation-alignment"), 187 stack(stack_), 188 alignment(alignment_) {} 189 void Print(); 190}; 191 192struct ErrorInvalidAlignedAllocAlignment : ErrorBase { 193 const BufferedStackTrace *stack; 194 uptr size; 195 uptr alignment; 196 197 ErrorInvalidAlignedAllocAlignment() = default; // (*) 198 ErrorInvalidAlignedAllocAlignment(u32 tid, BufferedStackTrace *stack_, 199 uptr size_, uptr alignment_) 200 : ErrorBase(tid, 10, "invalid-aligned-alloc-alignment"), 201 stack(stack_), 202 size(size_), 203 alignment(alignment_) {} 204 void Print(); 205}; 206 207struct ErrorInvalidPosixMemalignAlignment : ErrorBase { 208 const BufferedStackTrace *stack; 209 uptr alignment; 210 211 ErrorInvalidPosixMemalignAlignment() = default; // (*) 212 ErrorInvalidPosixMemalignAlignment(u32 tid, BufferedStackTrace *stack_, 213 uptr alignment_) 214 : ErrorBase(tid, 10, "invalid-posix-memalign-alignment"), 215 stack(stack_), 216 alignment(alignment_) {} 217 void Print(); 218}; 219 220struct ErrorAllocationSizeTooBig : ErrorBase { 221 const BufferedStackTrace *stack; 222 uptr user_size; 223 uptr total_size; 224 uptr max_size; 225 226 ErrorAllocationSizeTooBig() = default; // (*) 227 ErrorAllocationSizeTooBig(u32 tid, BufferedStackTrace *stack_, 228 uptr user_size_, uptr total_size_, uptr max_size_) 229 : ErrorBase(tid, 10, "allocation-size-too-big"), 230 stack(stack_), 231 user_size(user_size_), 232 total_size(total_size_), 233 max_size(max_size_) {} 234 void Print(); 235}; 236 237struct ErrorRssLimitExceeded : ErrorBase { 238 const BufferedStackTrace *stack; 239 240 ErrorRssLimitExceeded() = default; // (*) 241 ErrorRssLimitExceeded(u32 tid, BufferedStackTrace *stack_) 242 : ErrorBase(tid, 10, "rss-limit-exceeded"), 243 stack(stack_) {} 244 void Print(); 245}; 246 247struct ErrorOutOfMemory : ErrorBase { 248 const BufferedStackTrace *stack; 249 uptr requested_size; 250 251 ErrorOutOfMemory() = default; // (*) 252 ErrorOutOfMemory(u32 tid, BufferedStackTrace *stack_, uptr requested_size_) 253 : ErrorBase(tid, 10, "out-of-memory"), 254 stack(stack_), 255 requested_size(requested_size_) {} 256 void Print(); 257}; 258 259struct ErrorStringFunctionMemoryRangesOverlap : ErrorBase { 260 const BufferedStackTrace *stack; 261 uptr length1, length2; 262 AddressDescription addr1_description; 263 AddressDescription addr2_description; 264 const char *function; 265 266 ErrorStringFunctionMemoryRangesOverlap() = default; // (*) 267 ErrorStringFunctionMemoryRangesOverlap(u32 tid, BufferedStackTrace *stack_, 268 uptr addr1, uptr length1_, uptr addr2, 269 uptr length2_, const char *function_) 270 : ErrorBase(tid), 271 stack(stack_), 272 length1(length1_), 273 length2(length2_), 274 addr1_description(addr1, length1, /*shouldLockThreadRegistry=*/false), 275 addr2_description(addr2, length2, /*shouldLockThreadRegistry=*/false), 276 function(function_) { 277 char bug_type[100]; 278 internal_snprintf(bug_type, sizeof(bug_type), "%s-param-overlap", function); 279 scariness.Clear(); 280 scariness.Scare(10, bug_type); 281 } 282 void Print(); 283}; 284 285struct ErrorStringFunctionSizeOverflow : ErrorBase { 286 const BufferedStackTrace *stack; 287 AddressDescription addr_description; 288 uptr size; 289 290 ErrorStringFunctionSizeOverflow() = default; // (*) 291 ErrorStringFunctionSizeOverflow(u32 tid, BufferedStackTrace *stack_, 292 uptr addr, uptr size_) 293 : ErrorBase(tid, 10, "negative-size-param"), 294 stack(stack_), 295 addr_description(addr, /*shouldLockThreadRegistry=*/false), 296 size(size_) {} 297 void Print(); 298}; 299 300struct ErrorBadParamsToAnnotateContiguousContainer : ErrorBase { 301 const BufferedStackTrace *stack; 302 uptr beg, end, old_mid, new_mid; 303 304 ErrorBadParamsToAnnotateContiguousContainer() = default; // (*) 305 // PS4: Do we want an AddressDescription for beg? 306 ErrorBadParamsToAnnotateContiguousContainer(u32 tid, 307 BufferedStackTrace *stack_, 308 uptr beg_, uptr end_, 309 uptr old_mid_, uptr new_mid_) 310 : ErrorBase(tid, 10, "bad-__sanitizer_annotate_contiguous_container"), 311 stack(stack_), 312 beg(beg_), 313 end(end_), 314 old_mid(old_mid_), 315 new_mid(new_mid_) {} 316 void Print(); 317}; 318 319struct ErrorODRViolation : ErrorBase { 320 __asan_global global1, global2; 321 u32 stack_id1, stack_id2; 322 323 ErrorODRViolation() = default; // (*) 324 ErrorODRViolation(u32 tid, const __asan_global *g1, u32 stack_id1_, 325 const __asan_global *g2, u32 stack_id2_) 326 : ErrorBase(tid, 10, "odr-violation"), 327 global1(*g1), 328 global2(*g2), 329 stack_id1(stack_id1_), 330 stack_id2(stack_id2_) {} 331 void Print(); 332}; 333 334struct ErrorInvalidPointerPair : ErrorBase { 335 uptr pc, bp, sp; 336 AddressDescription addr1_description; 337 AddressDescription addr2_description; 338 339 ErrorInvalidPointerPair() = default; // (*) 340 ErrorInvalidPointerPair(u32 tid, uptr pc_, uptr bp_, uptr sp_, uptr p1, 341 uptr p2) 342 : ErrorBase(tid, 10, "invalid-pointer-pair"), 343 pc(pc_), 344 bp(bp_), 345 sp(sp_), 346 addr1_description(p1, 1, /*shouldLockThreadRegistry=*/false), 347 addr2_description(p2, 1, /*shouldLockThreadRegistry=*/false) {} 348 void Print(); 349}; 350 351struct ErrorGeneric : ErrorBase { 352 AddressDescription addr_description; 353 uptr pc, bp, sp; 354 uptr access_size; 355 const char *bug_descr; 356 bool is_write; 357 u8 shadow_val; 358 359 ErrorGeneric() = default; // (*) 360 ErrorGeneric(u32 tid, uptr addr, uptr pc_, uptr bp_, uptr sp_, bool is_write_, 361 uptr access_size_); 362 void Print(); 363}; 364 365// clang-format off 366#define ASAN_FOR_EACH_ERROR_KIND(macro) \ 367 macro(DeadlySignal) \ 368 macro(DoubleFree) \ 369 macro(NewDeleteTypeMismatch) \ 370 macro(FreeNotMalloced) \ 371 macro(AllocTypeMismatch) \ 372 macro(MallocUsableSizeNotOwned) \ 373 macro(SanitizerGetAllocatedSizeNotOwned) \ 374 macro(CallocOverflow) \ 375 macro(PvallocOverflow) \ 376 macro(InvalidAllocationAlignment) \ 377 macro(InvalidAlignedAllocAlignment) \ 378 macro(InvalidPosixMemalignAlignment) \ 379 macro(AllocationSizeTooBig) \ 380 macro(RssLimitExceeded) \ 381 macro(OutOfMemory) \ 382 macro(StringFunctionMemoryRangesOverlap) \ 383 macro(StringFunctionSizeOverflow) \ 384 macro(BadParamsToAnnotateContiguousContainer) \ 385 macro(ODRViolation) \ 386 macro(InvalidPointerPair) \ 387 macro(Generic) 388// clang-format on 389 390#define ASAN_DEFINE_ERROR_KIND(name) kErrorKind##name, 391#define ASAN_ERROR_DESCRIPTION_MEMBER(name) Error##name name; 392#define ASAN_ERROR_DESCRIPTION_CONSTRUCTOR(name) \ 393 ErrorDescription(Error##name const &e) : kind(kErrorKind##name), name(e) {} 394#define ASAN_ERROR_DESCRIPTION_PRINT(name) \ 395 case kErrorKind##name: \ 396 return name.Print(); 397 398enum ErrorKind { 399 kErrorKindInvalid = 0, 400 ASAN_FOR_EACH_ERROR_KIND(ASAN_DEFINE_ERROR_KIND) 401}; 402 403struct ErrorDescription { 404 ErrorKind kind; 405 // We're using a tagged union because it allows us to have a trivially 406 // copiable type and use the same structures as the public interface. 407 // 408 // We can add a wrapper around it to make it "more c++-like", but that would 409 // add a lot of code and the benefit wouldn't be that big. 410 union { 411 ErrorBase Base; 412 ASAN_FOR_EACH_ERROR_KIND(ASAN_ERROR_DESCRIPTION_MEMBER) 413 }; 414 415 ErrorDescription() { internal_memset(this, 0, sizeof(*this)); } 416 explicit ErrorDescription(LinkerInitialized) {} 417 ASAN_FOR_EACH_ERROR_KIND(ASAN_ERROR_DESCRIPTION_CONSTRUCTOR) 418 419 bool IsValid() { return kind != kErrorKindInvalid; } 420 void Print() { 421 switch (kind) { 422 ASAN_FOR_EACH_ERROR_KIND(ASAN_ERROR_DESCRIPTION_PRINT) 423 case kErrorKindInvalid: 424 CHECK(0); 425 } 426 CHECK(0); 427 } 428}; 429 430#undef ASAN_FOR_EACH_ERROR_KIND 431#undef ASAN_DEFINE_ERROR_KIND 432#undef ASAN_ERROR_DESCRIPTION_MEMBER 433#undef ASAN_ERROR_DESCRIPTION_CONSTRUCTOR 434#undef ASAN_ERROR_DESCRIPTION_PRINT 435 436} // namespace __asan 437 438#endif // ASAN_ERRORS_H 439