Merge pull request #1638 from zhaomaosu/asan-shadow-scale-4

[DeviceSanitizer] Change ASan shadow scale from 3 to 4

Author: kbenzie

source/loader/layers/sanitizer/asan_interceptor.cpp

@@ -23,15 +23,16 @@ namespace ur_sanitizer_layer {
 namespace {
 
 uptr MemToShadow_CPU(uptr USM_SHADOW_BASE, uptr UPtr) {
-    return USM_SHADOW_BASE + (UPtr >> 3);
+    return USM_SHADOW_BASE + (UPtr >> ASAN_SHADOW_SCALE);
 }
 
 uptr MemToShadow_PVC(uptr USM_SHADOW_BASE, uptr UPtr) {
     if (UPtr & 0xFF00000000000000ULL) { // Device USM
-        return USM_SHADOW_BASE + 0x200000000000ULL +
-               ((UPtr & 0xFFFFFFFFFFFFULL) >> 3);
+        return USM_SHADOW_BASE + 0x80000000000ULL +
+               ((UPtr & 0xFFFFFFFFFFFFULL) >> ASAN_SHADOW_SCALE);
     } else { // Only consider 47bit VA
-        return USM_SHADOW_BASE + ((UPtr & 0x7FFFFFFFFFFFULL) >> 3);
+        return USM_SHADOW_BASE +
+               ((UPtr & 0x7FFFFFFFFFFFULL) >> ASAN_SHADOW_SCALE);
     }
 }
 

source/loader/layers/sanitizer/asan_libdevice.hpp

@@ -79,7 +79,7 @@ struct LaunchInfo {
     LocalArgsInfo *LocalArgs = nullptr; // ordered by ArgIndex
 };
 
-constexpr unsigned ASAN_SHADOW_SCALE = 3;
+constexpr unsigned ASAN_SHADOW_SCALE = 4;
 constexpr unsigned ASAN_SHADOW_GRANULARITY = 1ULL << ASAN_SHADOW_SCALE;
 
 // These magic values are written to shadow for better error

source/loader/layers/sanitizer/asan_shadow_setup.cpp

@@ -17,67 +17,44 @@ namespace ur_sanitizer_layer {
 
 namespace cpu {
 
-// Based on "compiler-rt/lib/asan/asan_mapping.h"
-// Typical shadow mapping on Linux/x86_64 with SHADOW_OFFSET == 0x00007fff8000:
-constexpr uptr LOW_SHADOW_BEGIN = 0x00007fff8000ULL;
-constexpr uptr LOW_SHADOW_END = 0x00008fff6fffULL;
-constexpr uptr SHADOW_GAP_BEGIN = 0x00008fff7000ULL;
-constexpr uptr SHADOW_GAP_END = 0x02008fff6fffULL;
-constexpr uptr HIGH_SHADOW_BEGIN = 0x02008fff7000ULL;
-constexpr uptr HIGH_SHADOW_END = 0x10007fff7fffULL;
-constexpr uptr LOW_SHADOW_SIZE = LOW_SHADOW_END - LOW_SHADOW_BEGIN;
-constexpr uptr SHADOW_GAP_SIZE = SHADOW_GAP_END - SHADOW_GAP_BEGIN;
-constexpr uptr HIGH_SHADOW_SIZE = HIGH_SHADOW_END - HIGH_SHADOW_BEGIN;
-
-bool IsShadowMemInited;
+constexpr size_t SHADOW_SIZE = 0x80000000000ULL;
+uptr SHADOW_BEGIN;
+uptr SHADOW_END;
+
+bool IsShadowMemInited = false;
 
 ur_result_t SetupShadowMemory(uptr &ShadowBegin, uptr &ShadowEnd) {
     static ur_result_t Result = []() {
-        if (!MmapFixedNoReserve(LOW_SHADOW_BEGIN, LOW_SHADOW_SIZE)) {
-            return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        }
-        if (!MmapFixedNoReserve(HIGH_SHADOW_BEGIN, HIGH_SHADOW_SIZE)) {
-            return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        }
-        if (!MmapFixedNoAccess(SHADOW_GAP_BEGIN, SHADOW_GAP_SIZE)) {
+        SHADOW_BEGIN = MmapNoReserve(0, SHADOW_SIZE);
+        if (SHADOW_BEGIN == 0) {
             return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         }
+        SHADOW_END = SHADOW_BEGIN + SHADOW_SIZE;
         IsShadowMemInited = true;
         return UR_RESULT_SUCCESS;
     }();
-    ShadowBegin = LOW_SHADOW_BEGIN;
-    ShadowEnd = HIGH_SHADOW_END;
+    ShadowBegin = SHADOW_BEGIN;
+    ShadowEnd = SHADOW_END;
     return Result;
 }
 
 ur_result_t DestroyShadowMemory() {
-    static ur_result_t Result = []() {
-        if (!IsShadowMemInited) {
-            return UR_RESULT_SUCCESS;
-        }
-        if (!Munmap(LOW_SHADOW_BEGIN, LOW_SHADOW_SIZE)) {
-            return UR_RESULT_ERROR_UNKNOWN;
-        }
-        if (!Munmap(HIGH_SHADOW_BEGIN, HIGH_SHADOW_SIZE)) {
-            return UR_RESULT_ERROR_UNKNOWN;
-        }
-        if (!Munmap(SHADOW_GAP_BEGIN, SHADOW_GAP_SIZE)) {
-            return UR_RESULT_ERROR_UNKNOWN;
-        }
+    if (!IsShadowMemInited) {
         return UR_RESULT_SUCCESS;
-    }();
-    return Result;
+    }
+    if (!Munmap(SHADOW_BEGIN, SHADOW_SIZE)) {
+        return UR_RESULT_ERROR_UNKNOWN;
+    }
+    return UR_RESULT_SUCCESS;
 }
 
 } // namespace cpu
 
 namespace pvc {
 
-/// SHADOW MEMORY MAPPING (PVC, with CPU 47bit)
-///   Host/Shared USM : 0x0              ~ 0x0fff_ffff_ffff
-///   ?               : 0x1000_0000_0000 ~ 0x1fff_ffff_ffff
-///   Device USM      : 0x2000_0000_0000 ~ 0x3fff_ffff_ffff
-constexpr size_t SHADOW_SIZE = 1ULL << 46;
+///   Host/Shared USM : 0x0              ~ 0x07ff_ffff_ffff
+///   Device USM      : 0x0800_0000_0000 ~ 0x17ff_ffff_ffff
+constexpr size_t SHADOW_SIZE = 0x180000000000ULL;
 
 uptr LOW_SHADOW_BEGIN;
 uptr HIGH_SHADOW_END;

source/loader/layers/sanitizer/common.hpp

@@ -140,8 +140,7 @@ enum class DeviceType : uint64_t { UNKNOWN = 0, CPU, GPU_PVC, GPU_DG2 };
 
 bool IsInASanContext();
 
-bool MmapFixedNoReserve(uptr Addr, uptr Size);
-bool MmapFixedNoAccess(uptr Addr, uptr Size);
+uptr MmapNoReserve(uptr Addr, uptr Size);
 bool Munmap(uptr Addr, uptr Size);
 
 void *GetMemFunctionPointer(const char *);

source/loader/layers/sanitizer/linux/sanitizer_utils.cpp

@@ -27,20 +27,12 @@ namespace ur_sanitizer_layer {
 
 bool IsInASanContext() { return (void *)__asan_init != nullptr; }
 
-bool MmapFixedNoReserve(uptr Addr, uptr Size) {
+uptr MmapNoReserve(uptr Addr, uptr Size) {
     Size = RoundUpTo(Size, EXEC_PAGESIZE);
     Addr = RoundDownTo(Addr, EXEC_PAGESIZE);
-    void *P =
-        mmap((void *)Addr, Size, PROT_READ | PROT_WRITE,
-             MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE | MAP_ANONYMOUS, -1, 0);
-    return Addr == (uptr)P;
-}
-
-bool MmapFixedNoAccess(uptr Addr, uptr Size) {
-    void *P =
-        mmap((void *)Addr, Size, PROT_NONE,
-             MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE | MAP_ANONYMOUS, -1, 0);
-    return Addr == (uptr)P;
+    void *P = mmap((void *)Addr, Size, PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_NORESERVE | MAP_ANONYMOUS, -1, 0);
+    return (uptr)P;
 }
 
 bool Munmap(uptr Addr, uptr Size) { return munmap((void *)Addr, Size) == 0; }