User pointer read-only memory fix

HoppeMateusz · Compute-Runtime-Automation · commit aa088da8d3ef · 2018-03-28T12:42:31.000+02:00
- do not store fragment in map until hostPointerValidation
is done
- set pointers to nullptr after delete in cleanOsHandles

Change-Id: I0bf99c3215c4b91ce059bb4e94716671c49f1946
diff --git a/runtime/memory_manager/host_ptr_defines.h b/runtime/memory_manager/host_ptr_defines.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -71,7 +71,7 @@ struct AllocationRequirements {
 };
 
 struct FragmentStorage {
-    void *fragmentCpuPointer = nullptr;
+    const void *fragmentCpuPointer = nullptr;
     size_t fragmentSize = 0;
     int refCount = 0;
     OsHandle *osInternalStorage = nullptr;
diff --git a/runtime/memory_manager/host_ptr_manager.cpp b/runtime/memory_manager/host_ptr_manager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -26,7 +26,7 @@
 
 using namespace OCLRT;
 
-std::map<void *, FragmentStorage>::iterator OCLRT::HostPtrManager::findElement(void *ptr) {
+std::map<const void *, FragmentStorage>::iterator OCLRT::HostPtrManager::findElement(const void *ptr) {
     auto nextElement = partialAllocations.lower_bound(ptr);
     auto element = nextElement;
     if (element != partialAllocations.end()) {
@@ -155,7 +155,7 @@ void OCLRT::HostPtrManager::storeFragment(FragmentStorage &fragment) {
         element->second.refCount++;
     } else {
         fragment.refCount++;
-        partialAllocations.insert(std::pair<void *, FragmentStorage>(fragment.fragmentCpuPointer, fragment));
+        partialAllocations.insert(std::pair<const void *, FragmentStorage>(fragment.fragmentCpuPointer, fragment));
     }
 }
 
@@ -171,12 +171,12 @@ void OCLRT::HostPtrManager::storeFragment(AllocationStorageData &storageData) {
 void OCLRT::HostPtrManager::releaseHandleStorage(OsHandleStorage &fragments) {
     for (int i = 0; i < max_fragments_count; i++) {
         if (fragments.fragmentStorageData[i].fragmentSize || fragments.fragmentStorageData[i].cpuPtr) {
-            fragments.fragmentStorageData[i].freeTheFragment = releaseHostPtr(const_cast<void *>(fragments.fragmentStorageData[i].cpuPtr));
+            fragments.fragmentStorageData[i].freeTheFragment = releaseHostPtr(fragments.fragmentStorageData[i].cpuPtr);
         }
     }
 }
 
-bool OCLRT::HostPtrManager::releaseHostPtr(void *ptr) {
+bool OCLRT::HostPtrManager::releaseHostPtr(const void *ptr) {
     std::lock_guard<std::mutex> lock(allocationsMutex);
     bool fragmentReadyToBeReleased = false;
 
@@ -193,7 +193,7 @@ bool OCLRT::HostPtrManager::releaseHostPtr(void *ptr) {
     return fragmentReadyToBeReleased;
 }
 
-FragmentStorage *OCLRT::HostPtrManager::getFragment(void *inputPtr) {
+FragmentStorage *OCLRT::HostPtrManager::getFragment(const void *inputPtr) {
     std::lock_guard<std::mutex> lock(allocationsMutex);
     auto element = findElement(inputPtr);
     if (element != partialAllocations.end()) {
diff --git a/runtime/memory_manager/host_ptr_manager.h b/runtime/memory_manager/host_ptr_manager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -28,7 +28,7 @@
 
 namespace OCLRT {
 
-typedef std::map<void *, FragmentStorage> HostPtrFragmentsContainer;
+typedef std::map<const void *, FragmentStorage> HostPtrFragmentsContainer;
 
 class HostPtrManager {
   public:
@@ -38,14 +38,14 @@ class HostPtrManager {
     void storeFragment(AllocationStorageData &storageData);
 
     void releaseHandleStorage(OsHandleStorage &fragments);
-    bool releaseHostPtr(void *ptr);
+    bool releaseHostPtr(const void *ptr);
 
-    FragmentStorage *getFragment(void *inputPtr);
+    FragmentStorage *getFragment(const void *inputPtr);
     size_t getFragmentCount() { return partialAllocations.size(); }
     FragmentStorage *getFragmentAndCheckForOverlaps(const void *inputPtr, size_t size, OverlapStatus &overlappingStatus);
 
   private:
-    std::map<void *, FragmentStorage>::iterator findElement(void *ptr);
+    std::map<const void *, FragmentStorage>::iterator findElement(const void *ptr);
 
     HostPtrFragmentsContainer partialAllocations;
     std::mutex allocationsMutex;
diff --git a/runtime/os_interface/linux/drm_memory_manager.cpp b/runtime/os_interface/linux/drm_memory_manager.cpp
@@ -471,7 +471,7 @@ uint64_t DrmMemoryManager::getInternalHeapBaseAddress() {
 
 MemoryManager::AllocationStatus DrmMemoryManager::populateOsHandles(OsHandleStorage &handleStorage) {
     BufferObject *allocatedBos[max_fragments_count];
-    size_t numberOfBosAllocated = 0;
+    uint32_t numberOfBosAllocated = 0;
     uint32_t indexesOfAllocatedBos[max_fragments_count];
 
     for (unsigned int i = 0; i < max_fragments_count; i++) {
@@ -492,8 +492,6 @@ MemoryManager::AllocationStatus DrmMemoryManager::populateOsHandles(OsHandleStor
             allocatedBos[numberOfBosAllocated] = handleStorage.fragmentStorageData[i].osHandleStorage->bo;
             indexesOfAllocatedBos[numberOfBosAllocated] = i;
             numberOfBosAllocated++;
-
-            hostPtrManager.storeFragment(handleStorage.fragmentStorageData[i]);
         }
     }
 
@@ -510,8 +508,12 @@ MemoryManager::AllocationStatus DrmMemoryManager::populateOsHandles(OsHandleStor
         }
     }
 
+    for (uint32_t i = 0; i < numberOfBosAllocated; i++) {
+        hostPtrManager.storeFragment(handleStorage.fragmentStorageData[indexesOfAllocatedBos[i]]);
+    }
     return AllocationStatus::Success;
 }
+
 void DrmMemoryManager::cleanOsHandles(OsHandleStorage &handleStorage) {
     for (unsigned int i = 0; i < max_fragments_count; i++) {
         if (handleStorage.fragmentStorageData[i].freeTheFragment) {
@@ -523,7 +525,9 @@ void DrmMemoryManager::cleanOsHandles(OsHandleStorage &handleStorage) {
                 ((void)(refCount));
             }
             delete handleStorage.fragmentStorageData[i].osHandleStorage;
+            handleStorage.fragmentStorageData[i].osHandleStorage = nullptr;
             delete handleStorage.fragmentStorageData[i].residency;
+            handleStorage.fragmentStorageData[i].residency = nullptr;
         }
     }
 }
diff --git a/runtime/os_interface/windows/wddm_memory_manager.cpp b/runtime/os_interface/windows/wddm_memory_manager.cpp
@@ -337,21 +337,30 @@ bool WddmMemoryManager::validateAllocation(WddmAllocation *alloc) {
 }
 
 MemoryManager::AllocationStatus WddmMemoryManager::populateOsHandles(OsHandleStorage &handleStorage) {
+    uint32_t allocatedFragmentIndexes[max_fragments_count];
+    uint32_t allocatedFragmentsCounter = 0;
+
     for (unsigned int i = 0; i < max_fragments_count; i++) {
         // If no fragment is present it means it already exists.
         if (!handleStorage.fragmentStorageData[i].osHandleStorage && handleStorage.fragmentStorageData[i].cpuPtr) {
             handleStorage.fragmentStorageData[i].osHandleStorage = new OsHandle();
             handleStorage.fragmentStorageData[i].residency = new ResidencyData();
 
             handleStorage.fragmentStorageData[i].osHandleStorage->gmm = Gmm::create(handleStorage.fragmentStorageData[i].cpuPtr, handleStorage.fragmentStorageData[i].fragmentSize, false);
-            hostPtrManager.storeFragment(handleStorage.fragmentStorageData[i]);
+            allocatedFragmentIndexes[allocatedFragmentsCounter] = i;
+            allocatedFragmentsCounter++;
         }
     }
     NTSTATUS result = wddm->createAllocationsAndMapGpuVa(handleStorage);
 
     if (result == STATUS_GRAPHICS_NO_VIDEO_MEMORY) {
         return AllocationStatus::InvalidHostPointer;
     }
+
+    for (uint32_t i = 0; i < allocatedFragmentsCounter; i++) {
+        hostPtrManager.storeFragment(handleStorage.fragmentStorageData[allocatedFragmentIndexes[i]]);
+    }
+
     return AllocationStatus::Success;
 }
 
diff --git a/unit_tests/os_interface/linux/drm_memory_manager_tests.cpp b/unit_tests/os_interface/linux/drm_memory_manager_tests.cpp
diff --git a/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp b/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (c) 2017, Intel Corporation`
	`2`	`+ * Copyright (c) 2017 - 2018, Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* Permission is hereby granted, free of charge, to any person obtaining a`
`5`	`5`	`* copy of this software and associated documentation files (the "Software"),`
`@@ -26,7 +26,7 @@`
`26`	`26`
`27`	`27`	`using namespace OCLRT;`
`28`	`28`
`29`		`-std::map<void , FragmentStorage>::iterator OCLRT::HostPtrManager::findElement(void ptr) {`
	`29`	`+std::map<const void , FragmentStorage>::iterator OCLRT::HostPtrManager::findElement(const void ptr) {`
`30`	`30`	`auto nextElement = partialAllocations.lower_bound(ptr);`
`31`	`31`	`auto element = nextElement;`
`32`	`32`	`if (element != partialAllocations.end()) {`
`@@ -155,7 +155,7 @@ void OCLRT::HostPtrManager::storeFragment(FragmentStorage &fragment) {`
`155`	`155`	`element->second.refCount++;`
`156`	`156`	`} else {`
`157`	`157`	`fragment.refCount++;`
`158`		`- partialAllocations.insert(std::pair<void *, FragmentStorage>(fragment.fragmentCpuPointer, fragment));`
	`158`	`+ partialAllocations.insert(std::pair<const void *, FragmentStorage>(fragment.fragmentCpuPointer, fragment));`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
`@@ -171,12 +171,12 @@ void OCLRT::HostPtrManager::storeFragment(AllocationStorageData &storageData) {`
`171`	`171`	`void OCLRT::HostPtrManager::releaseHandleStorage(OsHandleStorage &fragments) {`
`172`	`172`	`for (int i = 0; i < max_fragments_count; i++) {`
`173`	`173`	`if (fragments.fragmentStorageData[i].fragmentSize \|\| fragments.fragmentStorageData[i].cpuPtr) {`
`174`		`- fragments.fragmentStorageData[i].freeTheFragment = releaseHostPtr(const_cast<void *>(fragments.fragmentStorageData[i].cpuPtr));`
	`174`	`+ fragments.fragmentStorageData[i].freeTheFragment = releaseHostPtr(fragments.fragmentStorageData[i].cpuPtr);`
`175`	`175`	`}`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`
`179`		`-bool OCLRT::HostPtrManager::releaseHostPtr(void *ptr) {`
	`179`	`+bool OCLRT::HostPtrManager::releaseHostPtr(const void *ptr) {`
`180`	`180`	`std::lock_guard<std::mutex> lock(allocationsMutex);`
`181`	`181`	`bool fragmentReadyToBeReleased = false;`
`182`	`182`
`@@ -193,7 +193,7 @@ bool OCLRT::HostPtrManager::releaseHostPtr(void *ptr) {`
`193`	`193`	`return fragmentReadyToBeReleased;`
`194`	`194`	`}`
`195`	`195`
`196`		`-FragmentStorage OCLRT::HostPtrManager::getFragment(void inputPtr) {`
	`196`	`+FragmentStorage OCLRT::HostPtrManager::getFragment(const void inputPtr) {`
`197`	`197`	`std::lock_guard<std::mutex> lock(allocationsMutex);`
`198`	`198`	`auto element = findElement(inputPtr);`
`199`	`199`	`if (element != partialAllocations.end()) {`
Original file line number	Diff line number	Diff line change
`@@ -471,7 +471,7 @@ uint64_t DrmMemoryManager::getInternalHeapBaseAddress() {`
`471`	`471`
`472`	`472`	`MemoryManager::AllocationStatus DrmMemoryManager::populateOsHandles(OsHandleStorage &handleStorage) {`
`473`	`473`	`BufferObject *allocatedBos[max_fragments_count];`
`474`		`- size_t numberOfBosAllocated = 0;`
	`474`	`+ uint32_t numberOfBosAllocated = 0;`
`475`	`475`	`uint32_t indexesOfAllocatedBos[max_fragments_count];`
`476`	`476`
`477`	`477`	`for (unsigned int i = 0; i < max_fragments_count; i++) {`
`@@ -492,8 +492,6 @@ MemoryManager::AllocationStatus DrmMemoryManager::populateOsHandles(OsHandleStor`
`492`	`492`	`allocatedBos[numberOfBosAllocated] = handleStorage.fragmentStorageData[i].osHandleStorage->bo;`
`493`	`493`	`indexesOfAllocatedBos[numberOfBosAllocated] = i;`
`494`	`494`	`numberOfBosAllocated++;`
`495`		`-`
`496`		`- hostPtrManager.storeFragment(handleStorage.fragmentStorageData[i]);`
`497`	`495`	`}`
`498`	`496`	`}`
`499`	`497`
`@@ -510,8 +508,12 @@ MemoryManager::AllocationStatus DrmMemoryManager::populateOsHandles(OsHandleStor`
`510`	`508`	`}`
`511`	`509`	`}`
`512`	`510`
	`511`	`+ for (uint32_t i = 0; i < numberOfBosAllocated; i++) {`
	`512`	`+ hostPtrManager.storeFragment(handleStorage.fragmentStorageData[indexesOfAllocatedBos[i]]);`
	`513`	`+ }`
`513`	`514`	`return AllocationStatus::Success;`
`514`	`515`	`}`
	`516`	`+`
`515`	`517`	`void DrmMemoryManager::cleanOsHandles(OsHandleStorage &handleStorage) {`
`516`	`518`	`for (unsigned int i = 0; i < max_fragments_count; i++) {`
`517`	`519`	`if (handleStorage.fragmentStorageData[i].freeTheFragment) {`
`@@ -523,7 +525,9 @@ void DrmMemoryManager::cleanOsHandles(OsHandleStorage &handleStorage) {`
`523`	`525`	`((void)(refCount));`
`524`	`526`	`}`
`525`	`527`	`delete handleStorage.fragmentStorageData[i].osHandleStorage;`
	`528`	`+ handleStorage.fragmentStorageData[i].osHandleStorage = nullptr;`
`526`	`529`	`delete handleStorage.fragmentStorageData[i].residency;`
	`530`	`+ handleStorage.fragmentStorageData[i].residency = nullptr;`
`527`	`531`	`}`
`528`	`532`	`}`
`529`	`533`	`}`
Original file line number	Diff line number	Diff line change
`@@ -337,21 +337,30 @@ bool WddmMemoryManager::validateAllocation(WddmAllocation *alloc) {`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`MemoryManager::AllocationStatus WddmMemoryManager::populateOsHandles(OsHandleStorage &handleStorage) {`
	`340`	`+ uint32_t allocatedFragmentIndexes[max_fragments_count];`
	`341`	`+ uint32_t allocatedFragmentsCounter = 0;`
	`342`	`+`
`340`	`343`	`for (unsigned int i = 0; i < max_fragments_count; i++) {`
`341`	`344`	`// If no fragment is present it means it already exists.`
`342`	`345`	`if (!handleStorage.fragmentStorageData[i].osHandleStorage && handleStorage.fragmentStorageData[i].cpuPtr) {`
`343`	`346`	`handleStorage.fragmentStorageData[i].osHandleStorage = new OsHandle();`
`344`	`347`	`handleStorage.fragmentStorageData[i].residency = new ResidencyData();`
`345`	`348`
`346`	`349`	`handleStorage.fragmentStorageData[i].osHandleStorage->gmm = Gmm::create(handleStorage.fragmentStorageData[i].cpuPtr, handleStorage.fragmentStorageData[i].fragmentSize, false);`
`347`		`- hostPtrManager.storeFragment(handleStorage.fragmentStorageData[i]);`
	`350`	`+ allocatedFragmentIndexes[allocatedFragmentsCounter] = i;`
	`351`	`+ allocatedFragmentsCounter++;`
`348`	`352`	`}`
`349`	`353`	`}`
`350`	`354`	`NTSTATUS result = wddm->createAllocationsAndMapGpuVa(handleStorage);`
`351`	`355`
`352`	`356`	`if (result == STATUS_GRAPHICS_NO_VIDEO_MEMORY) {`
`353`	`357`	`return AllocationStatus::InvalidHostPointer;`
`354`	`358`	`}`
	`359`	`+`
	`360`	`+ for (uint32_t i = 0; i < allocatedFragmentsCounter; i++) {`
	`361`	`+ hostPtrManager.storeFragment(handleStorage.fragmentStorageData[allocatedFragmentIndexes[i]]);`
	`362`	`+ }`
	`363`	`+`
`355`	`364`	`return AllocationStatus::Success;`
`356`	`365`	`}`
`357`	`366`