Revert "fix: set ReadOnly flag when creating allocation with existing system ...

This reverts commit bddb24124d.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>

shared/source/os_interface/windows/CMakeLists.txt

@@ -97,6 +97,7 @@ set(NEO_CORE_OS_INTERFACE_WDDM
     ${CMAKE_CURRENT_SOURCE_DIR}/wddm/set_gmm_input_args_${DRIVER_MODEL}.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/wddm/max_mem_alloc_size_${DRIVER_MODEL}.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/wddm/helper_${DRIVER_MODEL}.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/wddm/is_readonly_memory_${DRIVER_MODEL}.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/wddm/skip_resource_cleanup_${DRIVER_MODEL}.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}map_tile_instanced_allocation_${DRIVER_MODEL}.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/wddm/wddm.cpp

shared/source/os_interface/windows/wddm/is_readonly_memory_drm_or_wddm.cpp

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/os_interface/windows/wddm/wddm.h"
+
+namespace NEO {
+bool Wddm::isReadOnlyMemory(const void *ptr) {
+    return false;
+}
+} // namespace NEO

shared/source/os_interface/windows/wddm/is_readonly_memory_wddm.cpp

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/os_interface/windows/sys_calls.h"
+#include "shared/source/os_interface/windows/wddm/wddm.h"
+
+namespace NEO {
+
+bool Wddm::isReadOnlyMemory(const void *ptr) {
+    if (ptr) {
+        MEMORY_BASIC_INFORMATION info;
+        SysCalls::virtualQuery(ptr, &info, sizeof(info));
+        return info.Protect & PAGE_READONLY;
+    }
+    return false;
+}
+} // namespace NEO

shared/source/os_interface/windows/wddm/wddm.cpp

@@ -665,7 +665,6 @@ NTSTATUS Wddm::createAllocation(const void *alignedCpuPtr, const Gmm *gmm, D3DKM
     createAllocation.Flags.CreateShared = outSharedHandle ? TRUE : FALSE;
     createAllocation.Flags.NtSecuritySharing = outSharedHandle ? TRUE : FALSE;
     createAllocation.Flags.CreateResource = outSharedHandle ? TRUE : FALSE;
-    createAllocation.Flags.ReadOnly = alignedCpuPtr != nullptr ? TRUE : FALSE;
     createAllocation.pAllocationInfo2 = &allocationInfo;
     createAllocation.hDevice = device;
 
@@ -678,6 +677,12 @@ NTSTATUS Wddm::createAllocation(const void *alignedCpuPtr, const Gmm *gmm, D3DKM
     }
 
     status = getGdi()->createAllocation2(&createAllocation);
+    if (status != STATUS_SUCCESS) {
+        if (isReadOnlyMemory(alignedCpuPtr)) {
+            createAllocation.Flags.ReadOnly = true;
+            status = getGdi()->createAllocation2(&createAllocation);
+        }
+    }
     if (status != STATUS_SUCCESS) {
         DEBUG_BREAK_IF(true);
         return status;
@@ -772,13 +777,19 @@ NTSTATUS Wddm::createAllocationsAndMapGpuVa(OsHandleStorage &osHandles) {
     createAllocation.Flags.CreateShared = FALSE;
     createAllocation.Flags.RestrictSharedAccess = FALSE;
     createAllocation.Flags.CreateResource = FALSE;
-    createAllocation.Flags.ReadOnly = allocationInfo[0].pSystemMem != nullptr ? TRUE : FALSE;
     createAllocation.pAllocationInfo2 = allocationInfo;
     createAllocation.hDevice = device;
 
     while (status == STATUS_UNSUCCESSFUL) {
         status = getGdi()->createAllocation2(&createAllocation);
 
+        if (status != STATUS_SUCCESS) {
+            if (isReadOnlyMemory(allocationInfo[0].pSystemMem)) {
+                createAllocation.Flags.ReadOnly = true;
+                status = getGdi()->createAllocation2(&createAllocation);
+            }
+        }
+
         if (status != STATUS_SUCCESS) {
             PRINT_DEBUG_STRING(debugManager.flags.PrintDebugMessages.get(), stderr, "%s status: %d", __FUNCTION__, status);
             DEBUG_BREAK_IF(status != STATUS_GRAPHICS_NO_VIDEO_MEMORY);

shared/source/os_interface/windows/wddm/wddm.h

@@ -257,6 +257,7 @@ class Wddm : public DriverModel {
     void setNewResourceBoundToPageTable();
     void setProcessPowerThrottling();
     void setThreadPriority();
+    bool isReadOnlyMemory(const void *ptr);
 
     GMM_GFX_PARTITIONING gfxPartition{};
     ADAPTER_BDF adapterBDF{};

shared/test/common/mock_gdi/mock_gdi.cpp

@@ -156,19 +156,20 @@ inline void *getStaticStorage(uint32_t slot) {
     return ptrOffset(baseAddress, slot * singleStorageSize);
 }
 
-static D3DKMT_CREATEALLOCATIONFLAGS createAllocationFlags{};
-static bool captureCreateAllocationFlags = false;
+static bool createAllocation2FailOnReadOnlyAllocation = false;
+static bool createAllocation2ReadOnlyFlagWasPassed = false;
 static uint32_t createAllocation2NumCalled = 0;
 
-void setCapturingCreateAllocationFlags() {
-    captureCreateAllocationFlags = true;
+void setCreateAllocation2ReadOnlyFailConfig(bool fail) {
+    createAllocation2FailOnReadOnlyAllocation = fail;
+    createAllocation2ReadOnlyFlagWasPassed = false;
     createAllocation2NumCalled = 0;
 }
 
-void getCapturedCreateAllocationFlags(D3DKMT_CREATEALLOCATIONFLAGS &capturedCreateAllocationFlags, uint32_t &numCalled) {
-    capturedCreateAllocationFlags = createAllocationFlags;
+void getCreateAllocation2ReadOnlyFailConfig(bool &readOnlyFlagWasPassed, uint32_t &numCalled) {
+    readOnlyFlagWasPassed = createAllocation2ReadOnlyFlagWasPassed;
     numCalled = createAllocation2NumCalled;
-    captureCreateAllocationFlags = false;
+    setCreateAllocation2ReadOnlyFailConfig(false);
 }
 
 NTSTATUS __stdcall mockD3DKMTCreateAllocation2(IN OUT D3DKMT_CREATEALLOCATION *allocation) {
@@ -186,10 +187,14 @@ NTSTATUS __stdcall mockD3DKMTCreateAllocation2(IN OUT D3DKMT_CREATEALLOCATION *a
         return STATUS_INVALID_PARAMETER;
     }
 
-    if (captureCreateAllocationFlags) {
-        createAllocationFlags = pallocation.Flags;
+    if (createAllocation2FailOnReadOnlyAllocation) {
         createAllocation2NumCalled++;
-        return STATUS_SUCCESS;
+        if (pallocation.Flags.ReadOnly) {
+            createAllocation2ReadOnlyFlagWasPassed = true;
+            return STATUS_SUCCESS;
+        } else {
+            return STATUS_GRAPHICS_NO_VIDEO_MEMORY;
+        }
     }
 
     numOfAllocations = allocation->NumAllocations;

shared/test/common/mock_gdi/mock_gdi.h

@@ -109,5 +109,5 @@ void setAdapterBDF(ADAPTER_BDF &adapterBDF);
 void setMockDeviceExecutionState(D3DKMT_DEVICEEXECUTION_STATE newState);
 void setMockGetDeviceStateReturnValue(NTSTATUS newReturnValue, bool execution);
 void initGfxPartition();
-void setCapturingCreateAllocationFlags();
-void getCapturedCreateAllocationFlags(D3DKMT_CREATEALLOCATIONFLAGS &capturedCreateAllocationFlags, uint32_t &numCalled);
+void setCreateAllocation2ReadOnlyFailConfig(bool fail);
+void getCreateAllocation2ReadOnlyFailConfig(bool &readOnlyFlagWasPassed, uint32_t &numCalled);

shared/test/common/mock_gdi/mock_os_library.cpp

@@ -253,11 +253,11 @@ void *MockOsLibrary::getProcAddress(const std::string &procName) {
     if (procName == "D3DKMTUnregisterTrimNotification") {
         return reinterpret_cast<void *>(mockD3DKMTUnregisterTrimNotification);
     }
-    if (procName == "setCapturingCreateAllocationFlags") {
-        return reinterpret_cast<void *>(setCapturingCreateAllocationFlags);
+    if (procName == "getCreateAllocation2ReadOnlyFailConfig") {
+        return reinterpret_cast<void *>(getCreateAllocation2ReadOnlyFailConfig);
     }
-    if (procName == "getCapturedCreateAllocationFlags") {
-        return reinterpret_cast<void *>(getCapturedCreateAllocationFlags);
+    if (procName == "setCreateAllocation2ReadOnlyFailConfig") {
+        return reinterpret_cast<void *>(setCreateAllocation2ReadOnlyFailConfig);
     }
     return nullptr;
 }

shared/test/common/mocks/mock_wddm.h

@@ -53,6 +53,7 @@ class WddmMock : public Wddm {
     using Wddm::gfxWorkaroundTable;
     using Wddm::gmmMemory;
     using Wddm::hwDeviceId;
+    using Wddm::isReadOnlyMemory;
     using Wddm::mapGpuVirtualAddress;
     using Wddm::minAddress;
     using Wddm::pagingFenceAddress;

shared/test/common/os_interface/windows/gdi_dll_fixture.h

@@ -61,8 +61,8 @@ struct GdiDllFixture {
             reinterpret_cast<decltype(&setAdapterBDF)>(mockGdiDll->getProcAddress("setAdapterBDF"));
         setMockDeviceExecutionStateFcn = reinterpret_cast<decltype(&setMockDeviceExecutionState)>(mockGdiDll->getProcAddress("setMockDeviceExecutionState"));
         setMockGetDeviceStateReturnValueFcn = reinterpret_cast<decltype(&setMockGetDeviceStateReturnValue)>(mockGdiDll->getProcAddress("setMockGetDeviceStateReturnValue"));
-        getCapturedCreateAllocationFlagsFcn = reinterpret_cast<decltype(&getCapturedCreateAllocationFlags)>(mockGdiDll->getProcAddress("getCapturedCreateAllocationFlags"));
-        setCapturingCreateAllocationFlagsFcn = reinterpret_cast<decltype(&setCapturingCreateAllocationFlags)>(mockGdiDll->getProcAddress("setCapturingCreateAllocationFlags"));
+        getCreateAllocation2ReadOnlyFailConfigFcn = reinterpret_cast<decltype(&getCreateAllocation2ReadOnlyFailConfig)>(mockGdiDll->getProcAddress("getCreateAllocation2ReadOnlyFailConfig"));
+        setCreateAllocation2ReadOnlyFailConfigFcn = reinterpret_cast<decltype(&setCreateAllocation2ReadOnlyFailConfig)>(mockGdiDll->getProcAddress("setCreateAllocation2ReadOnlyFailConfig"));
         setMockLastDestroyedResHandleFcn((D3DKMT_HANDLE)0);
         *getDestroySynchronizationObjectDataFcn() = {};
         *getCreateSynchronizationObject2FailCallFcn() = false;
@@ -111,6 +111,6 @@ struct GdiDllFixture {
     decltype(&setAdapterBDF) setAdapterBDFFcn = nullptr;
     decltype(&setMockDeviceExecutionState) setMockDeviceExecutionStateFcn = nullptr;
     decltype(&setMockGetDeviceStateReturnValue) setMockGetDeviceStateReturnValueFcn = nullptr;
-    decltype(&setCapturingCreateAllocationFlags) setCapturingCreateAllocationFlagsFcn = nullptr;
-    decltype(&getCapturedCreateAllocationFlags) getCapturedCreateAllocationFlagsFcn = nullptr;
+    decltype(&getCreateAllocation2ReadOnlyFailConfig) getCreateAllocation2ReadOnlyFailConfigFcn = nullptr;
+    decltype(&setCreateAllocation2ReadOnlyFailConfig) setCreateAllocation2ReadOnlyFailConfigFcn = nullptr;
 };

shared/test/unit_test/os_interface/wddm_linux/configure_device_address_space_drm_or_wddm_test.cpp

@@ -65,6 +65,7 @@ struct MockWddmLinux : NEO::Wddm {
     using Wddm::gfxPartition;
     using Wddm::gfxPlatform;
     using Wddm::gmmMemory;
+    using Wddm::isReadOnlyMemory;
 };
 
 struct MockGmmMemoryWddmLinux : NEO::GmmMemory {
@@ -795,6 +796,16 @@ TEST_F(WddmLinuxTest, whenCheckedIfResourcesCleanupCanBeSkippedAndDeviceIsLostTh
     EXPECT_EQ(1, gdiMockConfig.getDeviceStateClb.callCount);
 }
 
+TEST_F(WddmLinuxTest, whenIsReadOnlyMemoryCalledThenCorrectValueReturned) {
+    EXPECT_FALSE(wddm->isReadOnlyMemory(nullptr));
+
+    static int mem[10];
+    EXPECT_FALSE(wddm->isReadOnlyMemory(mem));
+
+    static const int constMem[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    EXPECT_FALSE(wddm->isReadOnlyMemory(constMem));
+}
+
 class MockOsTimeLinux : public NEO::OSTimeLinux {
   public:
     MockOsTimeLinux(NEO::OSInterface &osInterface, std::unique_ptr<NEO::DeviceTime> deviceTime) : NEO::OSTimeLinux(osInterface, std::move(deviceTime)) {}

shared/test/unit_test/os_interface/windows/wddm_tests.cpp

@@ -1000,53 +1000,4 @@ TEST_F(WddmTests, whenInitializeFailureThenInitOsInterfaceWddmFails) {
 
     EXPECT_FALSE(rootDeviceEnvironment->initOsInterface(std::move(hwDeviceId), 0u));
 }
-
-TEST_F(WddmTests, givenHostMemoryPassedToCreateAllocationThenAllocationCreatedWithReadOnlyFlagPassed) {
-    wddm->init();
-    setCapturingCreateAllocationFlagsFcn();
-
-    static const int constMem[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-
-    D3DKMT_HANDLE handle, resHandle;
-    GmmRequirements gmmRequirements{};
-    Gmm gmm(executionEnvironment->rootDeviceEnvironments[0]->getGmmHelper(), constMem, 10, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, {}, gmmRequirements);
-
-    EXPECT_EQ(STATUS_SUCCESS, wddm->createAllocation(constMem, &gmm, handle, resHandle, nullptr));
-    D3DKMT_CREATEALLOCATIONFLAGS createAllocationFlags{};
-    uint32_t createAllocation2NumCalled = 0;
-    getCapturedCreateAllocationFlagsFcn(createAllocationFlags, createAllocation2NumCalled);
-    EXPECT_TRUE(createAllocationFlags.ReadOnly);
-    EXPECT_EQ(1u, createAllocation2NumCalled);
-}
-
-TEST_F(WddmTests, givenHostMemoryPassedToCreateAllocationsAndMapGpuVaThenAllocationCreatedWithReadOnlyFlagPassed) {
-    wddm->init();
-    wddm->callBaseMapGpuVa = false;
-    setCapturingCreateAllocationFlagsFcn();
-
-    static const int constMem[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-
-    GmmRequirements gmmRequirements{};
-    Gmm gmm(executionEnvironment->rootDeviceEnvironments[0]->getGmmHelper(), constMem, 10, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, {}, gmmRequirements);
-
-    OsHandleStorage handleStorage;
-    OsHandleWin osHandle;
-    auto maxOsContextCount = 1u;
-    ResidencyData residency(maxOsContextCount);
-
-    handleStorage.fragmentCount = 1;
-    handleStorage.fragmentStorageData[0].cpuPtr = constMem;
-    handleStorage.fragmentStorageData[0].fragmentSize = 10;
-    handleStorage.fragmentStorageData[0].freeTheFragment = false;
-    handleStorage.fragmentStorageData[0].osHandleStorage = &osHandle;
-    handleStorage.fragmentStorageData[0].residency = &residency;
-    osHandle.gmm = &gmm;
-
-    EXPECT_EQ(STATUS_SUCCESS, wddm->createAllocationsAndMapGpuVa(handleStorage));
-    D3DKMT_CREATEALLOCATIONFLAGS createAllocationFlags{};
-    uint32_t createAllocation2NumCalled = 0;
-    getCapturedCreateAllocationFlagsFcn(createAllocationFlags, createAllocation2NumCalled);
-    EXPECT_TRUE(createAllocationFlags.ReadOnly);
-    EXPECT_EQ(1u, createAllocation2NumCalled);
-}
 } // namespace NEO

shared/test/unit_test/os_interface/windows/wddm_windows_tests.cpp

@@ -405,3 +405,66 @@ TEST_F(WddmTestWithMockGdiDll, givenSetThreadPriorityStateEnabledWhenInitWddmThe
     EXPECT_EQ(1u, SysCalls::setThreadPriorityCalled);
     EXPECT_EQ(SysCalls::ThreadPriority::AboveNormal, SysCalls::setThreadPriorityLastValue);
 }
+
+TEST_F(WddmTestWithMockGdiDll, whenIsReadOnlyMemoryCalledThenCorrectValueReturned) {
+    EXPECT_FALSE(wddm->isReadOnlyMemory(nullptr));
+
+    static int mem[10];
+    SysCalls::virtualQueryMemoryBasicInformation.Protect = PAGE_READWRITE;
+    EXPECT_FALSE(wddm->isReadOnlyMemory(mem));
+
+    static const int constMem[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    SysCalls::virtualQueryMemoryBasicInformation.Protect = PAGE_READONLY;
+    EXPECT_TRUE(wddm->isReadOnlyMemory(constMem));
+}
+
+TEST_F(WddmTestWithMockGdiDll, givenReadOnlyHostMemoryPassedToCreateAllocationThenAllocationCreatedWithRetryAndReadOnlyFlagPassed) {
+    wddm->init();
+    setCreateAllocation2ReadOnlyFailConfigFcn(true);
+
+    static const int constMem[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    SysCalls::virtualQueryMemoryBasicInformation.Protect = PAGE_READONLY;
+
+    D3DKMT_HANDLE handle, resHandle;
+    GmmRequirements gmmRequirements{};
+    Gmm gmm(executionEnvironment->rootDeviceEnvironments[0]->getGmmHelper(), constMem, 10, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, {}, gmmRequirements);
+
+    EXPECT_EQ(STATUS_SUCCESS, wddm->createAllocation(constMem, &gmm, handle, resHandle, nullptr));
+    bool readOnlyFlagWasPassed = false;
+    uint32_t createAllocation2NumCalled = 0;
+    getCreateAllocation2ReadOnlyFailConfigFcn(readOnlyFlagWasPassed, createAllocation2NumCalled);
+    EXPECT_TRUE(readOnlyFlagWasPassed);
+    EXPECT_EQ(2u, createAllocation2NumCalled);
+}
+
+TEST_F(WddmTestWithMockGdiDll, givenReadOnlyHostMemoryPassedToCreateAllocationsAndMapGpuVaThenAllocationCreatedWithRetryAndReadOnlyFlagPassed) {
+    wddm->init();
+    wddm->callBaseMapGpuVa = false;
+    setCreateAllocation2ReadOnlyFailConfigFcn(true);
+
+    static const int constMem[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    SysCalls::virtualQueryMemoryBasicInformation.Protect = PAGE_READONLY;
+
+    GmmRequirements gmmRequirements{};
+    Gmm gmm(executionEnvironment->rootDeviceEnvironments[0]->getGmmHelper(), constMem, 10, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, {}, gmmRequirements);
+
+    OsHandleStorage handleStorage;
+    OsHandleWin osHandle;
+    auto maxOsContextCount = 1u;
+    ResidencyData residency(maxOsContextCount);
+
+    handleStorage.fragmentCount = 1;
+    handleStorage.fragmentStorageData[0].cpuPtr = constMem;
+    handleStorage.fragmentStorageData[0].fragmentSize = 10;
+    handleStorage.fragmentStorageData[0].freeTheFragment = false;
+    handleStorage.fragmentStorageData[0].osHandleStorage = &osHandle;
+    handleStorage.fragmentStorageData[0].residency = &residency;
+    osHandle.gmm = &gmm;
+
+    EXPECT_EQ(STATUS_SUCCESS, wddm->createAllocationsAndMapGpuVa(handleStorage));
+    bool readOnlyFlagWasPassed = false;
+    uint32_t createAllocation2NumCalled = 0;
+    getCreateAllocation2ReadOnlyFailConfigFcn(readOnlyFlagWasPassed, createAllocation2NumCalled);
+    EXPECT_TRUE(readOnlyFlagWasPassed);
+    EXPECT_EQ(2u, createAllocation2NumCalled);
+}