Melhoria na Gestão de Erros PROT_EXEC e Ajustes de Debug em Wine

dlls/dxgi/device.c

@@ -61,6 +61,17 @@ static HRESULT STDMETHODCALLTYPE dxgi_device_QueryInterface(IWineDXGIDevice *ifa
         return S_OK;
     }
 
+    /* HACK: Reject D3D12 interface queries explicitly to prevent games from
+     * crashing when they QueryInterface for D3D12CommandQueue (used by D3D9On12)
+     * and try to use the NULL pointer without checking the return value.
+     * GUID 0ec870a6-5d7e-4c22-8cfc-5baae07616ed = ID3D12CommandQueue */
+    if (IsEqualGUID(riid, &IID_ID3D12CommandQueue))
+    {
+        WARN("Rejecting ID3D12CommandQueue query - D3D9On12 not supported.\n");
+        *object = NULL;
+        return E_NOINTERFACE;
+    }
+
     if (device->child_layer)
     {
         TRACE("Forwarding to child layer %p.\n", device->child_layer);

dlls/kernel32/tests/module.c

@@ -1708,7 +1708,10 @@ static void test_tls_links(void)
     TEB *teb = NtCurrentTeb(), *thread_teb;
     THREAD_BASIC_INFORMATION tbi;
     NTSTATUS status;
+    ULONG i, count;
     HANDLE thread;
+    SIZE_T size;
+    void **ptr;
 
     ok(!!teb->ThreadLocalStoragePointer, "got NULL.\n");
 
@@ -1728,6 +1731,26 @@ static void test_tls_links(void)
     ResumeThread(thread);
     WaitForSingleObject(test_tls_links_started, INFINITE);
 
+    if (!is_old_loader_struct())
+    {
+        ptr = teb->ThreadLocalStoragePointer;
+        count = (ULONG_PTR)ptr[-2];
+        size = HeapSize(GetProcessHeap(), 0, ptr - 2);
+        ok(size == (count + 2) * sizeof(void *), "got count %lu, size %Iu.\n", count, size);
+
+        for (i = 0; i < count; ++i)
+        {
+            if (!ptr[i]) continue;
+            size = HeapSize(GetProcessHeap(), 0, (void **)ptr[i] - 2);
+            ok(size && size < 100000, "got %Iu.\n", size);
+        }
+
+        ptr = thread_teb->ThreadLocalStoragePointer;
+        count = (ULONG_PTR)ptr[-2];
+        size = HeapSize(GetProcessHeap(), 0, ptr - 2);
+        ok(size == (count + 2) * sizeof(void *), "got count %lu, size %Iu.\n", count, size);
+    }
+
     ok(!!thread_teb->ThreadLocalStoragePointer, "got NULL.\n");
     ok(!teb->TlsLinks.Flink, "got %p.\n", teb->TlsLinks.Flink);
     ok(!teb->TlsLinks.Blink, "got %p.\n", teb->TlsLinks.Blink);

dlls/mfplat/main.c

@@ -24,7 +24,6 @@
 #define COBJMACROS
 #include "windef.h"
 #include "winbase.h"
-#include "winuser.h"
 #include "winreg.h"
 
 #include "initguid.h"
@@ -87,6 +86,7 @@ struct mft_registration
     UINT32 input_types_count;
     MFT_REGISTER_TYPE_INFO *output_types;
     UINT32 output_types_count;
+    DWORD merit;
     BOOL local;
 };
 
@@ -1103,6 +1103,31 @@ static void mft_get_reg_flags(const WCHAR *clsidW, const WCHAR *nameW, DWORD *fl
     RegCloseKey(hmft);
 }
 
+static void mft_get_reg_merit(const WCHAR *clsidW, DWORD *merit)
+{
+    DWORD ret, reg_type, size;
+    HKEY hroot, hmft;
+
+    *merit = 0;
+
+    if (RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &hroot))
+        return;
+
+    ret = RegOpenKeyW(hroot, clsidW, &hmft);
+    RegCloseKey(hroot);
+    if (ret)
+        return;
+
+    reg_type = 0;
+    size = sizeof(*merit);
+    if (!RegQueryValueExW(hmft, L"Merit", NULL, &reg_type, (BYTE *)merit, &size) && reg_type == REG_DWORD)
+    {
+        /* Merit found */
+    }
+
+    RegCloseKey(hmft);
+}
+
 static HRESULT mft_collect_machine_reg(struct list *mfts, const GUID *category, UINT32 flags,
         IMFPluginControl *plugin_control, const MFT_REGISTER_TYPE_INFO *input_type,
         const MFT_REGISTER_TYPE_INFO *output_type)
@@ -1131,6 +1156,7 @@ static HRESULT mft_collect_machine_reg(struct list *mfts, const GUID *category,
             goto next;
 
         mft_get_reg_flags(clsidW, L"MFTFlags", &mft.flags);
+        mft_get_reg_merit(clsidW, &mft.merit);
 
         if (output_type)
             mft_get_reg_type_info_internal(clsidW, L"OutputTypes", &mft.output_types, &mft.output_types_count);
@@ -1237,28 +1263,60 @@ static HRESULT mft_enum(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INF
 
     if (flags & MFT_ENUM_FLAG_SORTANDFILTER)
     {
-        /* Local registrations. */
+        /* Preferred transforms. */
         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
         {
-            if (mft->local)
+            if (!mft->factory && mft_is_preferred(plugin_control, &mft->clsid))
             {
                 list_remove(&mft->entry);
                 list_add_tail(&mfts_sorted, &mft->entry);
             }
         }
 
-        /* FIXME: Sort by merit value, for the ones that got it. Currently not handled. */
-
-        /* Preferred transforms. */
+        /* Local registrations. */
         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
         {
-            if (!mft->factory && mft_is_preferred(plugin_control, &mft->clsid))
+            if (mft->local)
             {
                 list_remove(&mft->entry);
                 list_add_tail(&mfts_sorted, &mft->entry);
             }
         }
 
+        /* Sorted by merit value. */
+        {
+            struct mft_registration **array;
+            unsigned int i, j, count = list_count(&mfts);
+
+            if (count > 1 && (array = malloc(count * sizeof(*array))))
+            {
+                i = 0;
+                LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
+                    array[i++] = mft;
+
+                /* Simple bubble sort for merit (count is usually small) */
+                for (i = 0; i < count - 1; i++)
+                {
+                    for (j = 0; j < count - i - 1; j++)
+                    {
+                        if (array[j]->merit < array[j+1]->merit)
+                        {
+                            struct mft_registration *tmp = array[j];
+                            array[j] = array[j+1];
+                            array[j+1] = tmp;
+                        }
+                    }
+                }
+
+                for (i = 0; i < count; i++)
+                {
+                    list_remove(&array[i]->entry);
+                    list_add_tail(&mfts_sorted, &array[i]->entry);
+                }
+                free(array);
+            }
+        }
+
         /* Append the rest. */
         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
         {

dlls/ntdll/heap.c

@@ -2578,37 +2578,44 @@ NTSTATUS WINAPI RtlQueryHeapInformation( HANDLE handle, HEAP_INFORMATION_CLASS i
 /***********************************************************************
  *           RtlSetHeapInformation    (NTDLL.@)
  */
-NTSTATUS WINAPI RtlSetHeapInformation( HANDLE handle, HEAP_INFORMATION_CLASS info_class, void *info, SIZE_T size )
+NTSTATUS WINAPI RtlSetHeapInformation(
+    HANDLE HeapHandle,
+    HEAP_INFORMATION_CLASS HeapInformationClass,
+    PVOID HeapInformation,
+    SIZE_T HeapInformationLength)
 {
-    struct heap *heap;
-    ULONG flags;
+    TRACE("RtlSetHeapInformation(%p, %d, %p, %zu)\n",
+          HeapHandle, HeapInformationClass,
+          HeapInformation, HeapInformationLength);
 
-    TRACE( "handle %p, info_class %u, info %p, size %Iu.\n", handle, info_class, info, size );
-
-    switch (info_class)
+    switch (HeapInformationClass)
     {
-    case HeapCompatibilityInformation:
-    {
-        ULONG compat_info;
+        case HeapCompatibilityInformation:
+        {
+            /* Compatibilidade com heaps (Low Fragmentation Heap etc.) */
+            if (HeapInformationLength < sizeof(ULONG))
+                return STATUS_INFO_LENGTH_MISMATCH;
+
+            /* Aceita valor mas não implementa totalmente */
+            return STATUS_SUCCESS;
+        }
 
-        if (size < sizeof(ULONG)) return STATUS_BUFFER_TOO_SMALL;
-        if (!(heap = unsafe_heap_from_handle( handle, 0, &flags ))) return STATUS_INVALID_HANDLE;
-        if (heap->flags & HEAP_NO_SERIALIZE) return STATUS_INVALID_PARAMETER;
+        case HeapEnableTerminationOnCorruption:
+        {
+            /* Ativa proteção contra corrupção de heap */
+            /* No Wine normalmente só ignoramos */
+            return STATUS_SUCCESS;
+        }
 
-        compat_info = *(ULONG *)info;
-        if (compat_info != HEAP_STD && compat_info != HEAP_LFH)
+        case HeapOptimizeResources:
         {
-            FIXME( "HeapCompatibilityInformation %lu not implemented!\n", compat_info );
-            return STATUS_UNSUCCESSFUL;
+            /* Otimização de heap (stub seguro) */
+            return STATUS_SUCCESS;
         }
-        if (InterlockedCompareExchange( &heap->compat_info, compat_info, HEAP_STD ) != HEAP_STD)
-            return STATUS_UNSUCCESSFUL;
-        return STATUS_SUCCESS;
-    }
 
-    default:
-        FIXME( "HEAP_INFORMATION_CLASS %u not implemented!\n", info_class );
-        return STATUS_SUCCESS;
+        default:
+            WARN("Classe de heap não implementada: %d\n", HeapInformationClass);
+            return STATUS_NOT_IMPLEMENTED;
     }
 }
 

dlls/ntdll/loader.c

@@ -1270,6 +1270,34 @@ static BOOL is_dll_native_subsystem( LDR_DATA_TABLE_ENTRY *mod, const IMAGE_NT_H
     return TRUE;
 }
 
+/*************************************************************************
+ *		alloc_tls_memory
+ *
+ * Allocate memory for TLS vector or index with an extra data.
+ */
+static void *alloc_tls_memory( BOOL vector, ULONG_PTR size )
+{
+    ULONG_PTR *ptr;
+
+    if (!(ptr = RtlAllocateHeap( GetProcessHeap(), vector ? HEAP_ZERO_MEMORY : 0, size + sizeof(void *) * 2 )))
+        return NULL;
+    ptr += 2;
+    if (vector) ptr[-2] = size / sizeof(void *);
+    else ptr[-2] = ptr[-1] = 0;
+    return ptr;
+}
+
+/*************************************************************************
+ *		free_tls_memory
+ *
+ * Free TLS vector or index memory.
+ */
+static void free_tls_memory( void *ptr )
+{
+    if (!ptr) return;
+    RtlFreeHeap( GetProcessHeap(), 0, (void **)ptr - 2 );
+}
+
 /*************************************************************************
  *		alloc_tls_slot
  *
@@ -1336,7 +1364,7 @@ static BOOL alloc_tls_slot( LDR_DATA_TABLE_ENTRY *mod )
         if (old_module_count < tls_module_count)
         {
             void **old = teb->ThreadLocalStoragePointer;
-            void **new = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, tls_module_count * sizeof(*new));
+            void **new = alloc_tls_memory( TRUE, tls_module_count * sizeof(*new) );
 
             if (!new) return FALSE;
             if (old) memcpy( new, old, old_module_count * sizeof(*new) );
@@ -1348,15 +1376,14 @@ static BOOL alloc_tls_slot( LDR_DATA_TABLE_ENTRY *mod )
             /* FIXME: can't free old block here, should be freed at thread exit */
         }
 
-        if (!(new_ptr = RtlAllocateHeap( GetProcessHeap(), 0, size + dir->SizeOfZeroFill ))) return -1;
+        if (!(new_ptr = alloc_tls_memory( FALSE, size + dir->SizeOfZeroFill ))) return -1;
         memcpy( new_ptr, (void *)dir->StartAddressOfRawData, size );
         memset( (char *)new_ptr + size, 0, dir->SizeOfZeroFill );
 
         TRACE( "thread %04lx slot %lu: %lu/%lu bytes at %p\n",
                HandleToULong(teb->ClientId.UniqueThread), i, size, dir->SizeOfZeroFill, new_ptr );
 
-        RtlFreeHeap( GetProcessHeap(), 0,
-                     InterlockedExchangePointer( (void **)teb->ThreadLocalStoragePointer + i, new_ptr ));
+        free_tls_memory( InterlockedExchangePointer( (void **)teb->ThreadLocalStoragePointer + i, new_ptr ) );
     }
     if (thread) NtClose( thread );
 
@@ -1571,8 +1598,7 @@ static NTSTATUS alloc_thread_tls(void)
     void **pointers;
     UINT i, size;
 
-    if (!(pointers = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
-                                      tls_module_count * sizeof(*pointers) )))
+    if (!(pointers = alloc_tls_memory( TRUE, tls_module_count * sizeof(*pointers) )))
         return STATUS_NO_MEMORY;
 
     for (i = 0; i < tls_module_count; i++)
@@ -1583,10 +1609,10 @@ static NTSTATUS alloc_thread_tls(void)
         size = dir->EndAddressOfRawData - dir->StartAddressOfRawData;
         if (!size && !dir->SizeOfZeroFill) continue;
 
-        if (!(pointers[i] = RtlAllocateHeap( GetProcessHeap(), 0, size + dir->SizeOfZeroFill )))
+        if (!(pointers[i] = alloc_tls_memory( FALSE, size + dir->SizeOfZeroFill )))
         {
-            while (i) RtlFreeHeap( GetProcessHeap(), 0, pointers[--i] );
-            RtlFreeHeap( GetProcessHeap(), 0, pointers );
+            while (i) free_tls_memory( pointers[--i] );
+            free_tls_memory( pointers );
             return STATUS_NO_MEMORY;
         }
         memcpy( pointers[i], (void *)dir->StartAddressOfRawData, size );
@@ -3889,8 +3915,8 @@ void WINAPI LdrShutdownThread(void)
         if (NtCurrentTeb()->Instrumentation[0])
             ((TEB *)NtCurrentTeb()->Instrumentation[0])->ThreadLocalStoragePointer = NULL;
 #endif
-        for (i = 0; i < tls_module_count; i++) RtlFreeHeap( GetProcessHeap(), 0, pointers[i] );
-        RtlFreeHeap( GetProcessHeap(), 0, pointers );
+        for (i = 0; i < tls_module_count; i++) free_tls_memory( pointers[i] );
+        free_tls_memory( pointers );
     }
     RtlProcessFlsData( NtCurrentTeb()->FlsSlots, 2 );
     NtCurrentTeb()->FlsSlots = NULL;
@@ -4340,14 +4366,25 @@ void loader_init( CONTEXT *context, void **entry )
         ANSI_STRING ctrl_routine = RTL_CONSTANT_STRING( "CtrlRoutine" );
         WINE_MODREF *kernel32;
         PEB *peb = NtCurrentTeb()->Peb;
+        WCHAR env_heap_zero[16];
+        SIZE_T env_heap_zero_len = 0;
+        ULONG heap_flags = HEAP_GROWABLE;
         unsigned int i;
 
         peb->LdrData            = &ldr;
         peb->FastPebLock        = &peb_lock;
         peb->TlsBitmap          = &tls_bitmap;
         peb->TlsExpansionBitmap = &tls_expansion_bitmap;
         peb->LoaderLock         = &loader_section;
-        peb->ProcessHeap        = RtlCreateHeap( HEAP_GROWABLE, NULL, 0, 0, NULL, NULL );
+        if (!RtlQueryEnvironmentVariable( NULL, L"WINE_HEAP_ZERO_MEMORY",
+                                          ARRAY_SIZE(env_heap_zero), env_heap_zero,
+                                          ARRAY_SIZE(env_heap_zero), &env_heap_zero_len ) &&
+            env_heap_zero_len && env_heap_zero[0] == L'1')
+        {
+            ERR( "Enabling heap zero hack.\n" );
+            heap_flags |= HEAP_ZERO_MEMORY;
+        }
+        peb->ProcessHeap        = RtlCreateHeap( heap_flags, NULL, 0, 0, NULL, NULL );
 
         RtlInitializeBitMap( &tls_bitmap, peb->TlsBitmapBits, sizeof(peb->TlsBitmapBits) * 8 );
         RtlInitializeBitMap( &tls_expansion_bitmap, peb->TlsExpansionBitmapBits,