Fix buffer lock failures (and the #4 most common SA crash @ 0x00354B1C)

Author: Dutchman101

Client/core/DXHook/CProxyDirect3DVertexBuffer.cpp

@@ -14,6 +14,11 @@
 #include "CAdditionalVertexStreamManager.h"
 #include "CVertexStreamBoundingBoxManager.h"
 
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <new>
+
 /////////////////////////////////////////////////////////////
 //
 // CProxyDirect3DVertexBuffer::CProxyDirect3DVertexBuffer
@@ -109,34 +114,50 @@ HRESULT CProxyDirect3DVertexBuffer::Lock(UINT OffsetToLock, UINT SizeToLock, voi
         CVertexStreamBoundingBoxManager::GetSingleton()->OnVertexBufferRangeInvalidated(m_pOriginal, OffsetToLock, SizeToLock);
     }
 
+    ClearFallbackLock();
+
     *ppbData = NULL;
-    HRESULT hr = DoLock(OffsetToLock, SizeToLock, ppbData, Flags);
 
-    // Report problems
-    if (FAILED(hr) || *ppbData == NULL)
+    const UINT clampedSize = ClampLockSize(OffsetToLock, SizeToLock);
+
+    HRESULT hr = DoLock(OffsetToLock, clampedSize, ppbData, Flags);
+    if (SUCCEEDED(hr) && *ppbData != NULL)
+        return hr;
+
+    HRESULT recoveryHr = TryRecoverLock(OffsetToLock, clampedSize, ppbData, Flags, hr);
+    if (SUCCEEDED(recoveryHr) && *ppbData != NULL)
+        return recoveryHr;
+
+    HRESULT finalHr = FAILED(recoveryHr) ? recoveryHr : hr;
+    HRESULT fallbackHr = ActivateFallbackLock(OffsetToLock, clampedSize, ppbData, Flags, finalHr);
+    if (SUCCEEDED(fallbackHr) && *ppbData != NULL)
+        return fallbackHr;
+
+    if (FAILED(fallbackHr))
+        finalHr = fallbackHr;
+
+    struct
     {
-        struct
-        {
-            const char* szText;
-            uint        uiReportId;
-            uint        uiLogEventId;
-        } info;
-        if (hr == D3D_OK)
-            info = {"result NULL", 8621, 621};
-        else if (hr == STATUS_ARRAY_BOUNDS_EXCEEDED)
-            info = {"offset out of range", 8622, 622};
-        else if (hr == STATUS_ACCESS_VIOLATION)
-            info = {"access violation", 8623, 623};
-        else
-            info = {"fail", 8620, 620};
+        const char* szText;
+        uint        uiReportId;
+        uint        uiLogEventId;
+    } info;
+    if (finalHr == D3D_OK)
+        info = {"result NULL", 8621, 621};
+    else if (finalHr == STATUS_ARRAY_BOUNDS_EXCEEDED)
+        info = {"offset out of range", 8622, 622};
+    else if (finalHr == STATUS_ACCESS_VIOLATION)
+        info = {"access violation", 8623, 623};
+    else
+        info = {"fail", 8620, 620};
 
-        SString strMessage("Lock VertexBuffer [%s] hr:%x Length:%x Usage:%x FVF:%x Pool:%x OffsetToLock:%x SizeToLock:%x Flags:%x", info.szText, hr, m_iMemUsed,
-                           m_dwUsage, m_dwFVF, m_pool, OffsetToLock, SizeToLock, Flags);
-        WriteDebugEvent(strMessage);
-        AddReportLog(info.uiReportId, strMessage);
-        CCore::GetSingleton().LogEvent(info.uiLogEventId, "Lock VertexBuffer", "", strMessage);
-    }
-    return hr;
+    SString strMessage("Lock VertexBuffer [%s] hr:%x Length:%x Usage:%x FVF:%x Pool:%x OffsetToLock:%x SizeToLock:%x Flags:%x", info.szText, finalHr, m_iMemUsed,
+                       m_dwUsage, m_dwFVF, m_pool, OffsetToLock, clampedSize, Flags);
+    WriteDebugEvent(strMessage);
+    AddReportLog(info.uiReportId, strMessage);
+    CCore::GetSingleton().LogEvent(info.uiLogEventId, "Lock VertexBuffer", "", strMessage);
+
+    return finalHr;
 }
 
 /////////////////////////////////////////////////////////////
@@ -148,22 +169,197 @@ HRESULT CProxyDirect3DVertexBuffer::Lock(UINT OffsetToLock, UINT SizeToLock, voi
 /////////////////////////////////////////////////////////////
 HRESULT CProxyDirect3DVertexBuffer::DoLock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags)
 {
-    // Validate sizes because gta can give invalid values (reason unknown)
-    if (OffsetToLock + SizeToLock > m_iMemUsed)
+    if (OffsetToLock >= m_iMemUsed)
+        return STATUS_ARRAY_BOUNDS_EXCEEDED;
+
+    UINT adjustedSize = ClampLockSize(OffsetToLock, SizeToLock);
+    if (adjustedSize == 0)
+        return STATUS_ARRAY_BOUNDS_EXCEEDED;
+
+    return LockInternal(OffsetToLock, adjustedSize, ppbData, Flags);
+}
+
+HRESULT CProxyDirect3DVertexBuffer::Unlock()
+{
+    if (!m_fallbackLock.active)
+        return m_pOriginal->Unlock();
+
+    HRESULT copyHr = D3D_OK;
+
+    if ((m_fallbackLock.flags & D3DLOCK_READONLY) == 0 && m_fallbackLock.size > 0 && !m_fallbackLock.buffer.empty())
     {
-        if (OffsetToLock > m_iMemUsed)
+        void* pDestination = NULL;
+        copyHr = LockInternal(m_fallbackLock.offset, m_fallbackLock.size, &pDestination, 0);
+        if (SUCCEEDED(copyHr) && pDestination != NULL)
         {
-            return STATUS_ARRAY_BOUNDS_EXCEEDED;
+            std::memcpy(pDestination, m_fallbackLock.buffer.data(), m_fallbackLock.size);
+            HRESULT unlockHr = m_pOriginal->Unlock();
+            if (FAILED(unlockHr))
+            {
+                copyHr = unlockHr;
+                SString strMessage("Unlock VertexBuffer [fallback unlock failed] hr:%x Length:%x Usage:%x FVF:%x Pool:%x Offset:%x Size:%x", unlockHr, m_iMemUsed,
+                                   m_dwUsage, m_dwFVF, m_pool, m_fallbackLock.offset, m_fallbackLock.size);
+                WriteDebugEvent(strMessage);
+                AddReportLog(8627, strMessage);
+                CCore::GetSingleton().LogEvent(627, "Unlock VertexBuffer", "", strMessage);
+            }
+        }
+        else
+        {
+            if (SUCCEEDED(copyHr) && pDestination == NULL)
+                copyHr = D3DERR_INVALIDCALL;
+
+            SString strMessage("Unlock VertexBuffer [fallback copy failed] hr:%x Length:%x Usage:%x FVF:%x Pool:%x Offset:%x Size:%x", copyHr, m_iMemUsed, m_dwUsage,
+                               m_dwFVF, m_pool, m_fallbackLock.offset, m_fallbackLock.size);
+            WriteDebugEvent(strMessage);
+            AddReportLog(8626, strMessage);
+            CCore::GetSingleton().LogEvent(626, "Unlock VertexBuffer", "", strMessage);
         }
-        SizeToLock = m_iMemUsed - OffsetToLock;
     }
 
+    ClearFallbackLock();
+    return D3D_OK;
+}
+
+UINT CProxyDirect3DVertexBuffer::ClampLockSize(UINT OffsetToLock, UINT SizeToLock) const
+{
+    if (OffsetToLock >= m_iMemUsed)
+        return 0;
+
+    const UINT available = static_cast<UINT>(m_iMemUsed - OffsetToLock);
+    if (available == 0)
+        return 0;
+
+    if (SizeToLock == 0)
+        return available;
+
+    return std::min(SizeToLock, available);
+}
+
+HRESULT CProxyDirect3DVertexBuffer::LockInternal(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags)
+{
+    if (ppbData == NULL)
+        return E_INVALIDARG;
+
+    *ppbData = NULL;
+
     __try
     {
         return m_pOriginal->Lock(OffsetToLock, SizeToLock, ppbData, Flags);
     }
     __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
     {
+        *ppbData = NULL;
         return STATUS_ACCESS_VIOLATION;
     }
 }
+
+HRESULT CProxyDirect3DVertexBuffer::TryRecoverLock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags, HRESULT originalHr)
+{
+    HRESULT lastHr = originalHr;
+
+    struct SLockAttempt
+    {
+        DWORD       flags;
+        UINT        offset;
+        UINT        size;
+        bool        adjustPointer;
+    };
+
+    std::array<SLockAttempt, 7> attempts = {
+        SLockAttempt{Flags & ~D3DLOCK_DONOTWAIT, OffsetToLock, SizeToLock, false},
+        SLockAttempt{Flags & ~D3DLOCK_NOOVERWRITE, OffsetToLock, SizeToLock, false},
+        SLockAttempt{Flags & ~D3DLOCK_DISCARD, OffsetToLock, SizeToLock, false},
+        SLockAttempt{Flags & ~(D3DLOCK_DONOTWAIT | D3DLOCK_NOOVERWRITE), OffsetToLock, SizeToLock, false},
+        SLockAttempt{Flags & ~(D3DLOCK_DONOTWAIT | D3DLOCK_NOOVERWRITE | D3DLOCK_NO_DIRTY_UPDATE), OffsetToLock, SizeToLock, false},
+        SLockAttempt{0u, OffsetToLock, SizeToLock, false},
+        SLockAttempt{0u, 0u, static_cast<UINT>(m_iMemUsed), true},
+    };
+
+    for (const SLockAttempt& attempt : attempts)
+    {
+        if (attempt.flags == Flags && attempt.offset == OffsetToLock && attempt.size == SizeToLock)
+            continue;
+
+        if (attempt.size > m_iMemUsed)
+            continue;
+
+        UINT clampedSize = ClampLockSize(attempt.offset, attempt.size);
+        if (clampedSize == 0)
+            continue;
+
+        void* pRecovered = NULL;
+        HRESULT hr = LockInternal(attempt.offset, clampedSize, &pRecovered, attempt.flags);
+        if (SUCCEEDED(hr) && pRecovered != NULL)
+        {
+            if (attempt.adjustPointer)
+            {
+                UINT pointerOffset = 0;
+                if (OffsetToLock > attempt.offset)
+                    pointerOffset = OffsetToLock - attempt.offset;
+                if (pointerOffset >= clampedSize)
+                {
+                    lastHr = hr;
+                    continue;
+                }
+                pRecovered = static_cast<void*>(static_cast<std::uint8_t*>(pRecovered) + pointerOffset);
+            }
+
+            *ppbData = pRecovered;
+
+            SString strMessage("Lock VertexBuffer [retry] hr:%x->%x Length:%x Usage:%x FVF:%x Pool:%x Offset:%x Size:%x Flags:%x->%x", originalHr, hr, m_iMemUsed,
+                               m_dwUsage, m_dwFVF, m_pool, OffsetToLock, SizeToLock, Flags, attempt.flags);
+            WriteDebugEvent(strMessage);
+            AddReportLog(8625, strMessage);
+            CCore::GetSingleton().LogEvent(625, "Lock VertexBuffer", "", strMessage);
+
+            return hr;
+        }
+
+        lastHr = hr;
+    }
+
+    return lastHr;
+}
+
+HRESULT CProxyDirect3DVertexBuffer::ActivateFallbackLock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags, HRESULT originalHr)
+{
+    if (ppbData == NULL)
+        return originalHr;
+
+    UINT clampedSize = ClampLockSize(OffsetToLock, SizeToLock);
+    if (clampedSize == 0)
+        return originalHr;
+
+    try
+    {
+        m_fallbackLock.buffer.resize(clampedSize);
+    }
+    catch (const std::bad_alloc&)
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    m_fallbackLock.active = true;
+    m_fallbackLock.offset = OffsetToLock;
+    m_fallbackLock.size = clampedSize;
+    m_fallbackLock.flags = Flags;
+
+    *ppbData = m_fallbackLock.buffer.data();
+
+    SString strMessage("Lock VertexBuffer [fallback] hr:%x Length:%x Usage:%x FVF:%x Pool:%x OffsetToLock:%x SizeToLock:%x Flags:%x", originalHr, m_iMemUsed,
+                       m_dwUsage, m_dwFVF, m_pool, OffsetToLock, clampedSize, Flags);
+    WriteDebugEvent(strMessage);
+    AddReportLog(8624, strMessage);
+    CCore::GetSingleton().LogEvent(624, "Lock VertexBuffer", "", strMessage);
+
+    return D3D_OK;
+}
+
+void CProxyDirect3DVertexBuffer::ClearFallbackLock()
+{
+    m_fallbackLock.active = false;
+    m_fallbackLock.offset = 0;
+    m_fallbackLock.size = 0;
+    m_fallbackLock.flags = 0;
+}

Client/core/DXHook/CProxyDirect3DVertexBuffer.h

@@ -12,6 +12,8 @@
 #pragma once
 
 #include <d3d9.h>
+#include <vector>
+#include <cstdint>
 #include "CProxyDirect3DDevice9.h"  // Include full definition for SResourceMemory
 
 DEFINE_GUID(CProxyDirect3DVertexBuffer_GUID, 0x128A025E, 0x0100, 0x04F1, 0x40, 0x60, 0x53, 0x19, 0x44, 0x56, 0x59, 0x42);
@@ -39,7 +41,7 @@ class CProxyDirect3DVertexBuffer : public IDirect3DVertexBuffer9
 
     /*** IDirect3DVertexBuffer9 methods ***/
     HRESULT __stdcall Lock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags);
-    HRESULT __stdcall Unlock() { return m_pOriginal->Unlock(); }
+    HRESULT __stdcall Unlock();
     HRESULT __stdcall GetDesc(D3DVERTEXBUFFER_DESC* pDesc) { return m_pOriginal->GetDesc(pDesc); }
 
     // CProxyDirect3DVertexBuffer
@@ -49,11 +51,28 @@ class CProxyDirect3DVertexBuffer : public IDirect3DVertexBuffer9
     IDirect3DVertexBuffer9* GetOriginal() { return m_pOriginal; }
     HRESULT                 DoLock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags);
 
+private:
+    struct SFallbackLock
+    {
+        bool                          active = false;
+        UINT                          offset = 0;
+        UINT                          size = 0;
+        DWORD                         flags = 0;
+        std::vector<std::uint8_t>     buffer;
+    };
+
+    UINT     ClampLockSize(UINT OffsetToLock, UINT SizeToLock) const;
+    HRESULT  LockInternal(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags);
+    HRESULT  TryRecoverLock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags, HRESULT originalHr);
+    HRESULT  ActivateFallbackLock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags, HRESULT originalHr);
+    void     ClearFallbackLock();
+
 protected:
     IDirect3DVertexBuffer9*                 m_pOriginal;
     uint                                    m_iMemUsed;
     DWORD                                   m_dwUsage;
     DWORD                                   m_dwFVF;
     D3DPOOL                                 m_pool;
     CProxyDirect3DDevice9::SResourceMemory& m_stats;
+    SFallbackLock                           m_fallbackLock;
 };