1 //===-- sanitizer_win.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 shared between AddressSanitizer and ThreadSanitizer 10 // run-time libraries and implements windows-specific functions from 11 // sanitizer_libc.h. 12 //===----------------------------------------------------------------------===// 13 14 #include "sanitizer_platform.h" 15 #if SANITIZER_WINDOWS 16 17 #define WIN32_LEAN_AND_MEAN 18 #define NOGDI 19 #include <windows.h> 20 #include <io.h> 21 #include <psapi.h> 22 #include <stdlib.h> 23 24 #include "sanitizer_common.h" 25 #include "sanitizer_file.h" 26 #include "sanitizer_libc.h" 27 #include "sanitizer_mutex.h" 28 #include "sanitizer_placement_new.h" 29 #include "sanitizer_win_defs.h" 30 31 #if defined(PSAPI_VERSION) && PSAPI_VERSION == 1 32 #pragma comment(lib, "psapi") 33 #endif 34 #if SANITIZER_WIN_TRACE 35 #include <traceloggingprovider.h> 36 // Windows trace logging provider init 37 #pragma comment(lib, "advapi32.lib") 38 TRACELOGGING_DECLARE_PROVIDER(g_asan_provider); 39 // GUID must be the same in utils/AddressSanitizerLoggingProvider.wprp 40 TRACELOGGING_DEFINE_PROVIDER(g_asan_provider, "AddressSanitizerLoggingProvider", 41 (0x6c6c766d, 0x3846, 0x4e6a, 0xa4, 0xfb, 0x5b, 42 0x53, 0x0b, 0xd0, 0xf3, 0xfa)); 43 #else 44 #define TraceLoggingUnregister(x) 45 #endif 46 47 // For WaitOnAddress 48 # pragma comment(lib, "synchronization.lib") 49 50 // A macro to tell the compiler that this part of the code cannot be reached, 51 // if the compiler supports this feature. Since we're using this in 52 // code that is called when terminating the process, the expansion of the 53 // macro should not terminate the process to avoid infinite recursion. 54 #if defined(__clang__) 55 # define BUILTIN_UNREACHABLE() __builtin_unreachable() 56 #elif defined(__GNUC__) && \ 57 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) 58 # define BUILTIN_UNREACHABLE() __builtin_unreachable() 59 #elif defined(_MSC_VER) 60 # define BUILTIN_UNREACHABLE() __assume(0) 61 #else 62 # define BUILTIN_UNREACHABLE() 63 #endif 64 65 namespace __sanitizer { 66 67 #include "sanitizer_syscall_generic.inc" 68 69 // --------------------- sanitizer_common.h 70 uptr GetPageSize() { 71 SYSTEM_INFO si; 72 GetSystemInfo(&si); 73 return si.dwPageSize; 74 } 75 76 uptr GetMmapGranularity() { 77 SYSTEM_INFO si; 78 GetSystemInfo(&si); 79 return si.dwAllocationGranularity; 80 } 81 82 uptr GetMaxUserVirtualAddress() { 83 SYSTEM_INFO si; 84 GetSystemInfo(&si); 85 return (uptr)si.lpMaximumApplicationAddress; 86 } 87 88 uptr GetMaxVirtualAddress() { 89 return GetMaxUserVirtualAddress(); 90 } 91 92 bool FileExists(const char *filename) { 93 return ::GetFileAttributesA(filename) != INVALID_FILE_ATTRIBUTES; 94 } 95 96 bool DirExists(const char *path) { 97 auto attr = ::GetFileAttributesA(path); 98 return (attr != INVALID_FILE_ATTRIBUTES) && (attr & FILE_ATTRIBUTE_DIRECTORY); 99 } 100 101 uptr internal_getpid() { 102 return GetProcessId(GetCurrentProcess()); 103 } 104 105 int internal_dlinfo(void *handle, int request, void *p) { 106 UNIMPLEMENTED(); 107 } 108 109 // In contrast to POSIX, on Windows GetCurrentThreadId() 110 // returns a system-unique identifier. 111 tid_t GetTid() { 112 return GetCurrentThreadId(); 113 } 114 115 uptr GetThreadSelf() { 116 return GetTid(); 117 } 118 119 #if !SANITIZER_GO 120 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top, 121 uptr *stack_bottom) { 122 CHECK(stack_top); 123 CHECK(stack_bottom); 124 MEMORY_BASIC_INFORMATION mbi; 125 CHECK_NE(VirtualQuery(&mbi /* on stack */, &mbi, sizeof(mbi)), 0); 126 // FIXME: is it possible for the stack to not be a single allocation? 127 // Are these values what ASan expects to get (reserved, not committed; 128 // including stack guard page) ? 129 *stack_top = (uptr)mbi.BaseAddress + mbi.RegionSize; 130 *stack_bottom = (uptr)mbi.AllocationBase; 131 } 132 #endif // #if !SANITIZER_GO 133 134 bool ErrorIsOOM(error_t err) { 135 // TODO: This should check which `err`s correspond to OOM. 136 return false; 137 } 138 139 void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) { 140 void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); 141 if (rv == 0) 142 ReportMmapFailureAndDie(size, mem_type, "allocate", 143 GetLastError(), raw_report); 144 return rv; 145 } 146 147 void UnmapOrDie(void *addr, uptr size, bool raw_report) { 148 if (!size || !addr) 149 return; 150 151 MEMORY_BASIC_INFORMATION mbi; 152 CHECK(VirtualQuery(addr, &mbi, sizeof(mbi))); 153 154 // MEM_RELEASE can only be used to unmap whole regions previously mapped with 155 // VirtualAlloc. So we first try MEM_RELEASE since it is better, and if that 156 // fails try MEM_DECOMMIT. 157 if (VirtualFree(addr, 0, MEM_RELEASE) == 0) { 158 if (VirtualFree(addr, size, MEM_DECOMMIT) == 0) { 159 ReportMunmapFailureAndDie(addr, size, GetLastError(), raw_report); 160 } 161 } 162 } 163 164 static void *ReturnNullptrOnOOMOrDie(uptr size, const char *mem_type, 165 const char *mmap_type) { 166 error_t last_error = GetLastError(); 167 if (last_error == ERROR_NOT_ENOUGH_MEMORY) 168 return nullptr; 169 ReportMmapFailureAndDie(size, mem_type, mmap_type, last_error); 170 } 171 172 void *MmapOrDieOnFatalError(uptr size, const char *mem_type) { 173 void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); 174 if (rv == 0) 175 return ReturnNullptrOnOOMOrDie(size, mem_type, "allocate"); 176 return rv; 177 } 178 179 // We want to map a chunk of address space aligned to 'alignment'. 180 void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment, 181 const char *mem_type) { 182 CHECK(IsPowerOfTwo(size)); 183 CHECK(IsPowerOfTwo(alignment)); 184 185 // Windows will align our allocations to at least 64K. 186 alignment = Max(alignment, GetMmapGranularity()); 187 188 uptr mapped_addr = 189 (uptr)VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); 190 if (!mapped_addr) 191 return ReturnNullptrOnOOMOrDie(size, mem_type, "allocate aligned"); 192 193 // If we got it right on the first try, return. Otherwise, unmap it and go to 194 // the slow path. 195 if (IsAligned(mapped_addr, alignment)) 196 return (void*)mapped_addr; 197 if (VirtualFree((void *)mapped_addr, 0, MEM_RELEASE) == 0) 198 ReportMmapFailureAndDie(size, mem_type, "deallocate", GetLastError()); 199 200 // If we didn't get an aligned address, overallocate, find an aligned address, 201 // unmap, and try to allocate at that aligned address. 202 int retries = 0; 203 const int kMaxRetries = 10; 204 for (; retries < kMaxRetries && 205 (mapped_addr == 0 || !IsAligned(mapped_addr, alignment)); 206 retries++) { 207 // Overallocate size + alignment bytes. 208 mapped_addr = 209 (uptr)VirtualAlloc(0, size + alignment, MEM_RESERVE, PAGE_NOACCESS); 210 if (!mapped_addr) 211 return ReturnNullptrOnOOMOrDie(size, mem_type, "allocate aligned"); 212 213 // Find the aligned address. 214 uptr aligned_addr = RoundUpTo(mapped_addr, alignment); 215 216 // Free the overallocation. 217 if (VirtualFree((void *)mapped_addr, 0, MEM_RELEASE) == 0) 218 ReportMmapFailureAndDie(size, mem_type, "deallocate", GetLastError()); 219 220 // Attempt to allocate exactly the number of bytes we need at the aligned 221 // address. This may fail for a number of reasons, in which case we continue 222 // the loop. 223 mapped_addr = (uptr)VirtualAlloc((void *)aligned_addr, size, 224 MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); 225 } 226 227 // Fail if we can't make this work quickly. 228 if (retries == kMaxRetries && mapped_addr == 0) 229 return ReturnNullptrOnOOMOrDie(size, mem_type, "allocate aligned"); 230 231 return (void *)mapped_addr; 232 } 233 234 // ZeroMmapFixedRegion zero's out a region of memory previously returned from a 235 // call to one of the MmapFixed* helpers. On non-windows systems this would be 236 // done with another mmap, but on windows remapping is not an option. 237 // VirtualFree(DECOMMIT)+VirtualAlloc(RECOMMIT) would also be a way to zero the 238 // memory, but we can't do this atomically, so instead we fall back to using 239 // internal_memset. 240 bool ZeroMmapFixedRegion(uptr fixed_addr, uptr size) { 241 internal_memset((void*) fixed_addr, 0, size); 242 return true; 243 } 244 245 bool MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) { 246 // FIXME: is this really "NoReserve"? On Win32 this does not matter much, 247 // but on Win64 it does. 248 (void)name; // unsupported 249 #if !SANITIZER_GO && SANITIZER_WINDOWS64 250 // On asan/Windows64, use MEM_COMMIT would result in error 251 // 1455:ERROR_COMMITMENT_LIMIT. 252 // Asan uses exception handler to commit page on demand. 253 void *p = VirtualAlloc((LPVOID)fixed_addr, size, MEM_RESERVE, PAGE_READWRITE); 254 #else 255 void *p = VirtualAlloc((LPVOID)fixed_addr, size, MEM_RESERVE | MEM_COMMIT, 256 PAGE_READWRITE); 257 #endif 258 if (p == 0) { 259 Report("ERROR: %s failed to " 260 "allocate %p (%zd) bytes at %p (error code: %d)\n", 261 SanitizerToolName, size, size, fixed_addr, GetLastError()); 262 return false; 263 } 264 return true; 265 } 266 267 bool MmapFixedSuperNoReserve(uptr fixed_addr, uptr size, const char *name) { 268 // FIXME: Windows support large pages too. Might be worth checking 269 return MmapFixedNoReserve(fixed_addr, size, name); 270 } 271 272 // Memory space mapped by 'MmapFixedOrDie' must have been reserved by 273 // 'MmapFixedNoAccess'. 274 void *MmapFixedOrDie(uptr fixed_addr, uptr size, const char *name) { 275 void *p = VirtualAlloc((LPVOID)fixed_addr, size, 276 MEM_COMMIT, PAGE_READWRITE); 277 if (p == 0) { 278 char mem_type[30]; 279 internal_snprintf(mem_type, sizeof(mem_type), "memory at address %p", 280 (void *)fixed_addr); 281 ReportMmapFailureAndDie(size, mem_type, "allocate", GetLastError()); 282 } 283 return p; 284 } 285 286 // Uses fixed_addr for now. 287 // Will use offset instead once we've implemented this function for real. 288 uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size, const char *name) { 289 return reinterpret_cast<uptr>(MmapFixedOrDieOnFatalError(fixed_addr, size)); 290 } 291 292 uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr size, 293 const char *name) { 294 return reinterpret_cast<uptr>(MmapFixedOrDie(fixed_addr, size)); 295 } 296 297 void ReservedAddressRange::Unmap(uptr addr, uptr size) { 298 // Only unmap if it covers the entire range. 299 CHECK((addr == reinterpret_cast<uptr>(base_)) && (size == size_)); 300 // We unmap the whole range, just null out the base. 301 base_ = nullptr; 302 size_ = 0; 303 UnmapOrDie(reinterpret_cast<void*>(addr), size); 304 } 305 306 void *MmapFixedOrDieOnFatalError(uptr fixed_addr, uptr size, const char *name) { 307 void *p = VirtualAlloc((LPVOID)fixed_addr, size, 308 MEM_COMMIT, PAGE_READWRITE); 309 if (p == 0) { 310 char mem_type[30]; 311 internal_snprintf(mem_type, sizeof(mem_type), "memory at address %p", 312 (void *)fixed_addr); 313 return ReturnNullptrOnOOMOrDie(size, mem_type, "allocate"); 314 } 315 return p; 316 } 317 318 void *MmapNoReserveOrDie(uptr size, const char *mem_type) { 319 // FIXME: make this really NoReserve? 320 return MmapOrDie(size, mem_type); 321 } 322 323 uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) { 324 base_ = fixed_addr ? MmapFixedNoAccess(fixed_addr, size) : MmapNoAccess(size); 325 size_ = size; 326 name_ = name; 327 (void)os_handle_; // unsupported 328 return reinterpret_cast<uptr>(base_); 329 } 330 331 332 void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) { 333 (void)name; // unsupported 334 void *res = VirtualAlloc((LPVOID)fixed_addr, size, 335 MEM_RESERVE, PAGE_NOACCESS); 336 if (res == 0) 337 Report("WARNING: %s failed to " 338 "mprotect %p (%zd) bytes at %p (error code: %d)\n", 339 SanitizerToolName, size, size, fixed_addr, GetLastError()); 340 return res; 341 } 342 343 void *MmapNoAccess(uptr size) { 344 void *res = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_NOACCESS); 345 if (res == 0) 346 Report("WARNING: %s failed to " 347 "mprotect %p (%zd) bytes (error code: %d)\n", 348 SanitizerToolName, size, size, GetLastError()); 349 return res; 350 } 351 352 bool MprotectNoAccess(uptr addr, uptr size) { 353 DWORD old_protection; 354 return VirtualProtect((LPVOID)addr, size, PAGE_NOACCESS, &old_protection); 355 } 356 357 bool MprotectReadOnly(uptr addr, uptr size) { 358 DWORD old_protection; 359 return VirtualProtect((LPVOID)addr, size, PAGE_READONLY, &old_protection); 360 } 361 362 bool MprotectReadWrite(uptr addr, uptr size) { 363 DWORD old_protection; 364 return VirtualProtect((LPVOID)addr, size, PAGE_READWRITE, &old_protection); 365 } 366 367 void ReleaseMemoryPagesToOS(uptr beg, uptr end) { 368 uptr beg_aligned = RoundDownTo(beg, GetPageSizeCached()), 369 end_aligned = RoundDownTo(end, GetPageSizeCached()); 370 CHECK(beg < end); // make sure the region is sane 371 if (beg_aligned == end_aligned) // make sure we're freeing at least 1 page; 372 return; 373 UnmapOrDie((void *)beg, end_aligned - beg_aligned); 374 } 375 376 void SetShadowRegionHugePageMode(uptr addr, uptr size) { 377 // FIXME: probably similar to ReleaseMemoryToOS. 378 } 379 380 bool DontDumpShadowMemory(uptr addr, uptr length) { 381 // This is almost useless on 32-bits. 382 // FIXME: add madvise-analog when we move to 64-bits. 383 return true; 384 } 385 386 uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale, 387 uptr min_shadow_base_alignment, UNUSED uptr &high_mem_end, 388 uptr granularity) { 389 const uptr alignment = 390 Max<uptr>(granularity << shadow_scale, 1ULL << min_shadow_base_alignment); 391 const uptr left_padding = 392 Max<uptr>(granularity, 1ULL << min_shadow_base_alignment); 393 uptr space_size = shadow_size_bytes + left_padding; 394 uptr shadow_start = FindAvailableMemoryRange(space_size, alignment, 395 granularity, nullptr, nullptr); 396 CHECK_NE((uptr)0, shadow_start); 397 CHECK(IsAligned(shadow_start, alignment)); 398 return shadow_start; 399 } 400 401 uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding, 402 uptr *largest_gap_found, 403 uptr *max_occupied_addr) { 404 uptr address = 0; 405 while (true) { 406 MEMORY_BASIC_INFORMATION info; 407 if (!::VirtualQuery((void*)address, &info, sizeof(info))) 408 return 0; 409 410 if (info.State == MEM_FREE) { 411 uptr shadow_address = RoundUpTo((uptr)info.BaseAddress + left_padding, 412 alignment); 413 if (shadow_address + size < (uptr)info.BaseAddress + info.RegionSize) 414 return shadow_address; 415 } 416 417 // Move to the next region. 418 address = (uptr)info.BaseAddress + info.RegionSize; 419 } 420 return 0; 421 } 422 423 uptr MapDynamicShadowAndAliases(uptr shadow_size, uptr alias_size, 424 uptr num_aliases, uptr ring_buffer_size) { 425 CHECK(false && "HWASan aliasing is unimplemented on Windows"); 426 return 0; 427 } 428 429 bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) { 430 MEMORY_BASIC_INFORMATION mbi; 431 CHECK(VirtualQuery((void *)range_start, &mbi, sizeof(mbi))); 432 return mbi.Protect == PAGE_NOACCESS && 433 (uptr)mbi.BaseAddress + mbi.RegionSize >= range_end; 434 } 435 436 void *MapFileToMemory(const char *file_name, uptr *buff_size) { 437 UNIMPLEMENTED(); 438 } 439 440 void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) { 441 UNIMPLEMENTED(); 442 } 443 444 static const int kMaxEnvNameLength = 128; 445 static const DWORD kMaxEnvValueLength = 32767; 446 447 namespace { 448 449 struct EnvVariable { 450 char name[kMaxEnvNameLength]; 451 char value[kMaxEnvValueLength]; 452 }; 453 454 } // namespace 455 456 static const int kEnvVariables = 5; 457 static EnvVariable env_vars[kEnvVariables]; 458 static int num_env_vars; 459 460 const char *GetEnv(const char *name) { 461 // Note: this implementation caches the values of the environment variables 462 // and limits their quantity. 463 for (int i = 0; i < num_env_vars; i++) { 464 if (0 == internal_strcmp(name, env_vars[i].name)) 465 return env_vars[i].value; 466 } 467 CHECK_LT(num_env_vars, kEnvVariables); 468 DWORD rv = GetEnvironmentVariableA(name, env_vars[num_env_vars].value, 469 kMaxEnvValueLength); 470 if (rv > 0 && rv < kMaxEnvValueLength) { 471 CHECK_LT(internal_strlen(name), kMaxEnvNameLength); 472 internal_strncpy(env_vars[num_env_vars].name, name, kMaxEnvNameLength); 473 num_env_vars++; 474 return env_vars[num_env_vars - 1].value; 475 } 476 return 0; 477 } 478 479 const char *GetPwd() { 480 UNIMPLEMENTED(); 481 } 482 483 u32 GetUid() { 484 UNIMPLEMENTED(); 485 } 486 487 namespace { 488 struct ModuleInfo { 489 const char *filepath; 490 uptr base_address; 491 uptr end_address; 492 }; 493 494 #if !SANITIZER_GO 495 int CompareModulesBase(const void *pl, const void *pr) { 496 const ModuleInfo *l = (const ModuleInfo *)pl, *r = (const ModuleInfo *)pr; 497 if (l->base_address < r->base_address) 498 return -1; 499 return l->base_address > r->base_address; 500 } 501 #endif 502 } // namespace 503 504 #if !SANITIZER_GO 505 void DumpProcessMap() { 506 Report("Dumping process modules:\n"); 507 ListOfModules modules; 508 modules.init(); 509 uptr num_modules = modules.size(); 510 511 InternalMmapVector<ModuleInfo> module_infos(num_modules); 512 for (size_t i = 0; i < num_modules; ++i) { 513 module_infos[i].filepath = modules[i].full_name(); 514 module_infos[i].base_address = modules[i].ranges().front()->beg; 515 module_infos[i].end_address = modules[i].ranges().back()->end; 516 } 517 qsort(module_infos.data(), num_modules, sizeof(ModuleInfo), 518 CompareModulesBase); 519 520 for (size_t i = 0; i < num_modules; ++i) { 521 const ModuleInfo &mi = module_infos[i]; 522 if (mi.end_address != 0) { 523 Printf("\t%p-%p %s\n", mi.base_address, mi.end_address, 524 mi.filepath[0] ? mi.filepath : "[no name]"); 525 } else if (mi.filepath[0]) { 526 Printf("\t??\?-??? %s\n", mi.filepath); 527 } else { 528 Printf("\t???\n"); 529 } 530 } 531 } 532 #endif 533 534 void DisableCoreDumperIfNecessary() { 535 // Do nothing. 536 } 537 538 void ReExec() { 539 UNIMPLEMENTED(); 540 } 541 542 void PlatformPrepareForSandboxing(void *args) {} 543 544 bool StackSizeIsUnlimited() { 545 UNIMPLEMENTED(); 546 } 547 548 void SetStackSizeLimitInBytes(uptr limit) { 549 UNIMPLEMENTED(); 550 } 551 552 bool AddressSpaceIsUnlimited() { 553 UNIMPLEMENTED(); 554 } 555 556 void SetAddressSpaceUnlimited() { 557 UNIMPLEMENTED(); 558 } 559 560 bool IsPathSeparator(const char c) { 561 return c == '\\' || c == '/'; 562 } 563 564 static bool IsAlpha(char c) { 565 c = ToLower(c); 566 return c >= 'a' && c <= 'z'; 567 } 568 569 bool IsAbsolutePath(const char *path) { 570 return path != nullptr && IsAlpha(path[0]) && path[1] == ':' && 571 IsPathSeparator(path[2]); 572 } 573 574 void internal_usleep(u64 useconds) { Sleep(useconds / 1000); } 575 576 u64 NanoTime() { 577 static LARGE_INTEGER frequency = {}; 578 LARGE_INTEGER counter; 579 if (UNLIKELY(frequency.QuadPart == 0)) { 580 QueryPerformanceFrequency(&frequency); 581 CHECK_NE(frequency.QuadPart, 0); 582 } 583 QueryPerformanceCounter(&counter); 584 counter.QuadPart *= 1000ULL * 1000000ULL; 585 counter.QuadPart /= frequency.QuadPart; 586 return counter.QuadPart; 587 } 588 589 u64 MonotonicNanoTime() { return NanoTime(); } 590 591 void Abort() { 592 internal__exit(3); 593 } 594 595 bool CreateDir(const char *pathname) { 596 return CreateDirectoryA(pathname, nullptr) != 0; 597 } 598 599 #if !SANITIZER_GO 600 // Read the file to extract the ImageBase field from the PE header. If ASLR is 601 // disabled and this virtual address is available, the loader will typically 602 // load the image at this address. Therefore, we call it the preferred base. Any 603 // addresses in the DWARF typically assume that the object has been loaded at 604 // this address. 605 static uptr GetPreferredBase(const char *modname, char *buf, size_t buf_size) { 606 fd_t fd = OpenFile(modname, RdOnly, nullptr); 607 if (fd == kInvalidFd) 608 return 0; 609 FileCloser closer(fd); 610 611 // Read just the DOS header. 612 IMAGE_DOS_HEADER dos_header; 613 uptr bytes_read; 614 if (!ReadFromFile(fd, &dos_header, sizeof(dos_header), &bytes_read) || 615 bytes_read != sizeof(dos_header)) 616 return 0; 617 618 // The file should start with the right signature. 619 if (dos_header.e_magic != IMAGE_DOS_SIGNATURE) 620 return 0; 621 622 // The layout at e_lfanew is: 623 // "PE\0\0" 624 // IMAGE_FILE_HEADER 625 // IMAGE_OPTIONAL_HEADER 626 // Seek to e_lfanew and read all that data. 627 if (::SetFilePointer(fd, dos_header.e_lfanew, nullptr, FILE_BEGIN) == 628 INVALID_SET_FILE_POINTER) 629 return 0; 630 if (!ReadFromFile(fd, buf, buf_size, &bytes_read) || bytes_read != buf_size) 631 return 0; 632 633 // Check for "PE\0\0" before the PE header. 634 char *pe_sig = &buf[0]; 635 if (internal_memcmp(pe_sig, "PE\0\0", 4) != 0) 636 return 0; 637 638 // Skip over IMAGE_FILE_HEADER. We could do more validation here if we wanted. 639 IMAGE_OPTIONAL_HEADER *pe_header = 640 (IMAGE_OPTIONAL_HEADER *)(pe_sig + 4 + sizeof(IMAGE_FILE_HEADER)); 641 642 // Check for more magic in the PE header. 643 if (pe_header->Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC) 644 return 0; 645 646 // Finally, return the ImageBase. 647 return (uptr)pe_header->ImageBase; 648 } 649 650 void ListOfModules::init() { 651 clearOrInit(); 652 HANDLE cur_process = GetCurrentProcess(); 653 654 // Query the list of modules. Start by assuming there are no more than 256 655 // modules and retry if that's not sufficient. 656 HMODULE *hmodules = 0; 657 uptr modules_buffer_size = sizeof(HMODULE) * 256; 658 DWORD bytes_required; 659 while (!hmodules) { 660 hmodules = (HMODULE *)MmapOrDie(modules_buffer_size, __FUNCTION__); 661 CHECK(EnumProcessModules(cur_process, hmodules, modules_buffer_size, 662 &bytes_required)); 663 if (bytes_required > modules_buffer_size) { 664 // Either there turned out to be more than 256 hmodules, or new hmodules 665 // could have loaded since the last try. Retry. 666 UnmapOrDie(hmodules, modules_buffer_size); 667 hmodules = 0; 668 modules_buffer_size = bytes_required; 669 } 670 } 671 672 InternalMmapVector<char> buf(4 + sizeof(IMAGE_FILE_HEADER) + 673 sizeof(IMAGE_OPTIONAL_HEADER)); 674 InternalMmapVector<wchar_t> modname_utf16(kMaxPathLength); 675 InternalMmapVector<char> module_name(kMaxPathLength); 676 // |num_modules| is the number of modules actually present, 677 size_t num_modules = bytes_required / sizeof(HMODULE); 678 for (size_t i = 0; i < num_modules; ++i) { 679 HMODULE handle = hmodules[i]; 680 MODULEINFO mi; 681 if (!GetModuleInformation(cur_process, handle, &mi, sizeof(mi))) 682 continue; 683 684 // Get the UTF-16 path and convert to UTF-8. 685 int modname_utf16_len = 686 GetModuleFileNameW(handle, &modname_utf16[0], kMaxPathLength); 687 if (modname_utf16_len == 0) 688 modname_utf16[0] = '\0'; 689 int module_name_len = ::WideCharToMultiByte( 690 CP_UTF8, 0, &modname_utf16[0], modname_utf16_len + 1, &module_name[0], 691 kMaxPathLength, NULL, NULL); 692 module_name[module_name_len] = '\0'; 693 694 uptr base_address = (uptr)mi.lpBaseOfDll; 695 uptr end_address = (uptr)mi.lpBaseOfDll + mi.SizeOfImage; 696 697 // Adjust the base address of the module so that we get a VA instead of an 698 // RVA when computing the module offset. This helps llvm-symbolizer find the 699 // right DWARF CU. In the common case that the image is loaded at it's 700 // preferred address, we will now print normal virtual addresses. 701 uptr preferred_base = 702 GetPreferredBase(&module_name[0], &buf[0], buf.size()); 703 uptr adjusted_base = base_address - preferred_base; 704 705 modules_.push_back(LoadedModule()); 706 LoadedModule &cur_module = modules_.back(); 707 cur_module.set(&module_name[0], adjusted_base); 708 // We add the whole module as one single address range. 709 cur_module.addAddressRange(base_address, end_address, /*executable*/ true, 710 /*writable*/ true); 711 } 712 UnmapOrDie(hmodules, modules_buffer_size); 713 } 714 715 void ListOfModules::fallbackInit() { clear(); } 716 717 // We can't use atexit() directly at __asan_init time as the CRT is not fully 718 // initialized at this point. Place the functions into a vector and use 719 // atexit() as soon as it is ready for use (i.e. after .CRT$XIC initializers). 720 InternalMmapVectorNoCtor<void (*)(void)> atexit_functions; 721 722 static int queueAtexit(void (*function)(void)) { 723 atexit_functions.push_back(function); 724 return 0; 725 } 726 727 // If Atexit() is being called after RunAtexit() has already been run, it needs 728 // to be able to call atexit() directly. Here we use a function ponter to 729 // switch out its behaviour. 730 // An example of where this is needed is the asan_dynamic runtime on MinGW-w64. 731 // On this environment, __asan_init is called during global constructor phase, 732 // way after calling the .CRT$XID initializer. 733 static int (*volatile queueOrCallAtExit)(void (*)(void)) = &queueAtexit; 734 735 int Atexit(void (*function)(void)) { return queueOrCallAtExit(function); } 736 737 static int RunAtexit() { 738 TraceLoggingUnregister(g_asan_provider); 739 queueOrCallAtExit = &atexit; 740 int ret = 0; 741 for (uptr i = 0; i < atexit_functions.size(); ++i) { 742 ret |= atexit(atexit_functions[i]); 743 } 744 return ret; 745 } 746 747 #pragma section(".CRT$XID", long, read) 748 __declspec(allocate(".CRT$XID")) int (*__run_atexit)() = RunAtexit; 749 #endif 750 751 // ------------------ sanitizer_libc.h 752 fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *last_error) { 753 // FIXME: Use the wide variants to handle Unicode filenames. 754 fd_t res; 755 if (mode == RdOnly) { 756 res = CreateFileA(filename, GENERIC_READ, 757 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 758 nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); 759 } else if (mode == WrOnly) { 760 res = CreateFileA(filename, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, 761 FILE_ATTRIBUTE_NORMAL, nullptr); 762 } else { 763 UNIMPLEMENTED(); 764 } 765 CHECK(res != kStdoutFd || kStdoutFd == kInvalidFd); 766 CHECK(res != kStderrFd || kStderrFd == kInvalidFd); 767 if (res == kInvalidFd && last_error) 768 *last_error = GetLastError(); 769 return res; 770 } 771 772 void CloseFile(fd_t fd) { 773 CloseHandle(fd); 774 } 775 776 bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read, 777 error_t *error_p) { 778 CHECK(fd != kInvalidFd); 779 780 // bytes_read can't be passed directly to ReadFile: 781 // uptr is unsigned long long on 64-bit Windows. 782 unsigned long num_read_long; 783 784 bool success = ::ReadFile(fd, buff, buff_size, &num_read_long, nullptr); 785 if (!success && error_p) 786 *error_p = GetLastError(); 787 if (bytes_read) 788 *bytes_read = num_read_long; 789 return success; 790 } 791 792 bool SupportsColoredOutput(fd_t fd) { 793 // FIXME: support colored output. 794 return false; 795 } 796 797 bool WriteToFile(fd_t fd, const void *buff, uptr buff_size, uptr *bytes_written, 798 error_t *error_p) { 799 CHECK(fd != kInvalidFd); 800 801 // Handle null optional parameters. 802 error_t dummy_error; 803 error_p = error_p ? error_p : &dummy_error; 804 uptr dummy_bytes_written; 805 bytes_written = bytes_written ? bytes_written : &dummy_bytes_written; 806 807 // Initialize output parameters in case we fail. 808 *error_p = 0; 809 *bytes_written = 0; 810 811 // Map the conventional Unix fds 1 and 2 to Windows handles. They might be 812 // closed, in which case this will fail. 813 if (fd == kStdoutFd || fd == kStderrFd) { 814 fd = GetStdHandle(fd == kStdoutFd ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE); 815 if (fd == 0) { 816 *error_p = ERROR_INVALID_HANDLE; 817 return false; 818 } 819 } 820 821 DWORD bytes_written_32; 822 if (!WriteFile(fd, buff, buff_size, &bytes_written_32, 0)) { 823 *error_p = GetLastError(); 824 return false; 825 } else { 826 *bytes_written = bytes_written_32; 827 return true; 828 } 829 } 830 831 uptr internal_sched_yield() { 832 Sleep(0); 833 return 0; 834 } 835 836 void internal__exit(int exitcode) { 837 TraceLoggingUnregister(g_asan_provider); 838 // ExitProcess runs some finalizers, so use TerminateProcess to avoid that. 839 // The debugger doesn't stop on TerminateProcess like it does on ExitProcess, 840 // so add our own breakpoint here. 841 if (::IsDebuggerPresent()) 842 __debugbreak(); 843 TerminateProcess(GetCurrentProcess(), exitcode); 844 BUILTIN_UNREACHABLE(); 845 } 846 847 uptr internal_ftruncate(fd_t fd, uptr size) { 848 UNIMPLEMENTED(); 849 } 850 851 uptr GetRSS() { 852 PROCESS_MEMORY_COUNTERS counters; 853 if (!GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) 854 return 0; 855 return counters.WorkingSetSize; 856 } 857 858 void *internal_start_thread(void *(*func)(void *arg), void *arg) { return 0; } 859 void internal_join_thread(void *th) { } 860 861 void FutexWait(atomic_uint32_t *p, u32 cmp) { 862 WaitOnAddress(p, &cmp, sizeof(cmp), INFINITE); 863 } 864 865 void FutexWake(atomic_uint32_t *p, u32 count) { 866 if (count == 1) 867 WakeByAddressSingle(p); 868 else 869 WakeByAddressAll(p); 870 } 871 872 uptr GetTlsSize() { 873 return 0; 874 } 875 876 void InitTlsSize() { 877 } 878 879 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size, 880 uptr *tls_addr, uptr *tls_size) { 881 #if SANITIZER_GO 882 *stk_addr = 0; 883 *stk_size = 0; 884 *tls_addr = 0; 885 *tls_size = 0; 886 #else 887 uptr stack_top, stack_bottom; 888 GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom); 889 *stk_addr = stack_bottom; 890 *stk_size = stack_top - stack_bottom; 891 *tls_addr = 0; 892 *tls_size = 0; 893 #endif 894 } 895 896 void ReportFile::Write(const char *buffer, uptr length) { 897 SpinMutexLock l(mu); 898 ReopenIfNecessary(); 899 if (!WriteToFile(fd, buffer, length)) { 900 // stderr may be closed, but we may be able to print to the debugger 901 // instead. This is the case when launching a program from Visual Studio, 902 // and the following routine should write to its console. 903 OutputDebugStringA(buffer); 904 } 905 } 906 907 void SetAlternateSignalStack() { 908 // FIXME: Decide what to do on Windows. 909 } 910 911 void UnsetAlternateSignalStack() { 912 // FIXME: Decide what to do on Windows. 913 } 914 915 void InstallDeadlySignalHandlers(SignalHandlerType handler) { 916 (void)handler; 917 // FIXME: Decide what to do on Windows. 918 } 919 920 HandleSignalMode GetHandleSignalMode(int signum) { 921 // FIXME: Decide what to do on Windows. 922 return kHandleSignalNo; 923 } 924 925 // Check based on flags if we should handle this exception. 926 bool IsHandledDeadlyException(DWORD exceptionCode) { 927 switch (exceptionCode) { 928 case EXCEPTION_ACCESS_VIOLATION: 929 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: 930 case EXCEPTION_STACK_OVERFLOW: 931 case EXCEPTION_DATATYPE_MISALIGNMENT: 932 case EXCEPTION_IN_PAGE_ERROR: 933 return common_flags()->handle_segv; 934 case EXCEPTION_ILLEGAL_INSTRUCTION: 935 case EXCEPTION_PRIV_INSTRUCTION: 936 case EXCEPTION_BREAKPOINT: 937 return common_flags()->handle_sigill; 938 case EXCEPTION_FLT_DENORMAL_OPERAND: 939 case EXCEPTION_FLT_DIVIDE_BY_ZERO: 940 case EXCEPTION_FLT_INEXACT_RESULT: 941 case EXCEPTION_FLT_INVALID_OPERATION: 942 case EXCEPTION_FLT_OVERFLOW: 943 case EXCEPTION_FLT_STACK_CHECK: 944 case EXCEPTION_FLT_UNDERFLOW: 945 case EXCEPTION_INT_DIVIDE_BY_ZERO: 946 case EXCEPTION_INT_OVERFLOW: 947 return common_flags()->handle_sigfpe; 948 } 949 return false; 950 } 951 952 bool IsAccessibleMemoryRange(uptr beg, uptr size) { 953 SYSTEM_INFO si; 954 GetNativeSystemInfo(&si); 955 uptr page_size = si.dwPageSize; 956 uptr page_mask = ~(page_size - 1); 957 958 for (uptr page = beg & page_mask, end = (beg + size - 1) & page_mask; 959 page <= end;) { 960 MEMORY_BASIC_INFORMATION info; 961 if (VirtualQuery((LPCVOID)page, &info, sizeof(info)) != sizeof(info)) 962 return false; 963 964 if (info.Protect == 0 || info.Protect == PAGE_NOACCESS || 965 info.Protect == PAGE_EXECUTE) 966 return false; 967 968 if (info.RegionSize == 0) 969 return false; 970 971 page += info.RegionSize; 972 } 973 974 return true; 975 } 976 977 bool SignalContext::IsStackOverflow() const { 978 return (DWORD)GetType() == EXCEPTION_STACK_OVERFLOW; 979 } 980 981 void SignalContext::InitPcSpBp() { 982 EXCEPTION_RECORD *exception_record = (EXCEPTION_RECORD *)siginfo; 983 CONTEXT *context_record = (CONTEXT *)context; 984 985 pc = (uptr)exception_record->ExceptionAddress; 986 # if SANITIZER_WINDOWS64 987 # if SANITIZER_ARM64 988 bp = (uptr)context_record->Fp; 989 sp = (uptr)context_record->Sp; 990 # else 991 bp = (uptr)context_record->Rbp; 992 sp = (uptr)context_record->Rsp; 993 # endif 994 # else 995 # if SANITIZER_ARM 996 bp = (uptr)context_record->R11; 997 sp = (uptr)context_record->Sp; 998 # else 999 bp = (uptr)context_record->Ebp; 1000 sp = (uptr)context_record->Esp; 1001 # endif 1002 # endif 1003 } 1004 1005 uptr SignalContext::GetAddress() const { 1006 EXCEPTION_RECORD *exception_record = (EXCEPTION_RECORD *)siginfo; 1007 if (exception_record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION) 1008 return exception_record->ExceptionInformation[1]; 1009 return (uptr)exception_record->ExceptionAddress; 1010 } 1011 1012 bool SignalContext::IsMemoryAccess() const { 1013 return ((EXCEPTION_RECORD *)siginfo)->ExceptionCode == 1014 EXCEPTION_ACCESS_VIOLATION; 1015 } 1016 1017 bool SignalContext::IsTrueFaultingAddress() const { return true; } 1018 1019 SignalContext::WriteFlag SignalContext::GetWriteFlag() const { 1020 EXCEPTION_RECORD *exception_record = (EXCEPTION_RECORD *)siginfo; 1021 1022 // The write flag is only available for access violation exceptions. 1023 if (exception_record->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) 1024 return SignalContext::Unknown; 1025 1026 // The contents of this array are documented at 1027 // https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-exception_record 1028 // The first element indicates read as 0, write as 1, or execute as 8. The 1029 // second element is the faulting address. 1030 switch (exception_record->ExceptionInformation[0]) { 1031 case 0: 1032 return SignalContext::Read; 1033 case 1: 1034 return SignalContext::Write; 1035 case 8: 1036 return SignalContext::Unknown; 1037 } 1038 return SignalContext::Unknown; 1039 } 1040 1041 void SignalContext::DumpAllRegisters(void *context) { 1042 // FIXME: Implement this. 1043 } 1044 1045 int SignalContext::GetType() const { 1046 return static_cast<const EXCEPTION_RECORD *>(siginfo)->ExceptionCode; 1047 } 1048 1049 const char *SignalContext::Describe() const { 1050 unsigned code = GetType(); 1051 // Get the string description of the exception if this is a known deadly 1052 // exception. 1053 switch (code) { 1054 case EXCEPTION_ACCESS_VIOLATION: 1055 return "access-violation"; 1056 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: 1057 return "array-bounds-exceeded"; 1058 case EXCEPTION_STACK_OVERFLOW: 1059 return "stack-overflow"; 1060 case EXCEPTION_DATATYPE_MISALIGNMENT: 1061 return "datatype-misalignment"; 1062 case EXCEPTION_IN_PAGE_ERROR: 1063 return "in-page-error"; 1064 case EXCEPTION_ILLEGAL_INSTRUCTION: 1065 return "illegal-instruction"; 1066 case EXCEPTION_PRIV_INSTRUCTION: 1067 return "priv-instruction"; 1068 case EXCEPTION_BREAKPOINT: 1069 return "breakpoint"; 1070 case EXCEPTION_FLT_DENORMAL_OPERAND: 1071 return "flt-denormal-operand"; 1072 case EXCEPTION_FLT_DIVIDE_BY_ZERO: 1073 return "flt-divide-by-zero"; 1074 case EXCEPTION_FLT_INEXACT_RESULT: 1075 return "flt-inexact-result"; 1076 case EXCEPTION_FLT_INVALID_OPERATION: 1077 return "flt-invalid-operation"; 1078 case EXCEPTION_FLT_OVERFLOW: 1079 return "flt-overflow"; 1080 case EXCEPTION_FLT_STACK_CHECK: 1081 return "flt-stack-check"; 1082 case EXCEPTION_FLT_UNDERFLOW: 1083 return "flt-underflow"; 1084 case EXCEPTION_INT_DIVIDE_BY_ZERO: 1085 return "int-divide-by-zero"; 1086 case EXCEPTION_INT_OVERFLOW: 1087 return "int-overflow"; 1088 } 1089 return "unknown exception"; 1090 } 1091 1092 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) { 1093 if (buf_len == 0) 1094 return 0; 1095 1096 // Get the UTF-16 path and convert to UTF-8. 1097 InternalMmapVector<wchar_t> binname_utf16(kMaxPathLength); 1098 int binname_utf16_len = 1099 GetModuleFileNameW(NULL, &binname_utf16[0], kMaxPathLength); 1100 if (binname_utf16_len == 0) { 1101 buf[0] = '\0'; 1102 return 0; 1103 } 1104 int binary_name_len = 1105 ::WideCharToMultiByte(CP_UTF8, 0, &binname_utf16[0], binname_utf16_len, 1106 buf, buf_len, NULL, NULL); 1107 if ((unsigned)binary_name_len == buf_len) 1108 --binary_name_len; 1109 buf[binary_name_len] = '\0'; 1110 return binary_name_len; 1111 } 1112 1113 uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) { 1114 return ReadBinaryName(buf, buf_len); 1115 } 1116 1117 void CheckVMASize() { 1118 // Do nothing. 1119 } 1120 1121 void InitializePlatformEarly() { 1122 // Do nothing. 1123 } 1124 1125 void CheckASLR() { 1126 // Do nothing 1127 } 1128 1129 void CheckMPROTECT() { 1130 // Do nothing 1131 } 1132 1133 char **GetArgv() { 1134 // FIXME: Actually implement this function. 1135 return 0; 1136 } 1137 1138 char **GetEnviron() { 1139 // FIXME: Actually implement this function. 1140 return 0; 1141 } 1142 1143 pid_t StartSubprocess(const char *program, const char *const argv[], 1144 const char *const envp[], fd_t stdin_fd, fd_t stdout_fd, 1145 fd_t stderr_fd) { 1146 // FIXME: implement on this platform 1147 // Should be implemented based on 1148 // SymbolizerProcess::StarAtSymbolizerSubprocess 1149 // from lib/sanitizer_common/sanitizer_symbolizer_win.cpp. 1150 return -1; 1151 } 1152 1153 bool IsProcessRunning(pid_t pid) { 1154 // FIXME: implement on this platform. 1155 return false; 1156 } 1157 1158 int WaitForProcess(pid_t pid) { return -1; } 1159 1160 // FIXME implement on this platform. 1161 void GetMemoryProfile(fill_profile_f cb, uptr *stats) {} 1162 1163 void CheckNoDeepBind(const char *filename, int flag) { 1164 // Do nothing. 1165 } 1166 1167 // FIXME: implement on this platform. 1168 bool GetRandom(void *buffer, uptr length, bool blocking) { 1169 UNIMPLEMENTED(); 1170 } 1171 1172 u32 GetNumberOfCPUs() { 1173 SYSTEM_INFO sysinfo = {}; 1174 GetNativeSystemInfo(&sysinfo); 1175 return sysinfo.dwNumberOfProcessors; 1176 } 1177 1178 #if SANITIZER_WIN_TRACE 1179 // TODO(mcgov): Rename this project-wide to PlatformLogInit 1180 void AndroidLogInit(void) { 1181 HRESULT hr = TraceLoggingRegister(g_asan_provider); 1182 if (!SUCCEEDED(hr)) 1183 return; 1184 } 1185 1186 void SetAbortMessage(const char *) {} 1187 1188 void LogFullErrorReport(const char *buffer) { 1189 if (common_flags()->log_to_syslog) { 1190 InternalMmapVector<wchar_t> filename; 1191 DWORD filename_length = 0; 1192 do { 1193 filename.resize(filename.size() + 0x100); 1194 filename_length = 1195 GetModuleFileNameW(NULL, filename.begin(), filename.size()); 1196 } while (filename_length >= filename.size()); 1197 TraceLoggingWrite(g_asan_provider, "AsanReportEvent", 1198 TraceLoggingValue(filename.begin(), "ExecutableName"), 1199 TraceLoggingValue(buffer, "AsanReportContents")); 1200 } 1201 } 1202 #endif // SANITIZER_WIN_TRACE 1203 1204 void InitializePlatformCommonFlags(CommonFlags *cf) {} 1205 1206 } // namespace __sanitizer 1207 1208 #endif // _WIN32 1209