-/*
+/* $Id: global.c,v 1.10 2002/10/28 15:08:32 robd Exp $
+ *
* Win32 Global/Local heap functions (GlobalXXX, LocalXXX).
* These functions included in Win32 for compatibility with 16 bit Windows
* Especially the moveable blocks and handles are oldish.
* used.
*/
+/*
+ * NOTE: Only fixed memory is implemented!!
+ */
+
+#include <ddk/ntddk.h>
+#include <ntdll/rtl.h>
#include <windows.h>
+#define NDEBUG
+#include <kernel32/kernel32.h>
+
+#if 0
#define MAGIC_GLOBAL_USED 0x5342BEEF
#define GLOBAL_LOCK_MAX 0xFF
BYTE Flags;
BYTE LockCount;
} GLOBAL_HANDLE, LOCAL_HANDLE, *PGLOBAL_HANDLE, *PLOCAL_HANDLE;
+#endif
-/*********************************************************************
-* GlobalAlloc -- KERNEL32 *
-*********************************************************************/
-HGLOBAL WINAPI GlobalAlloc(UINT flags, DWORD size)
+/* FUNCTIONS ***************************************************************/
+
+HGLOBAL STDCALL
+GlobalAlloc(UINT uFlags,
+ DWORD dwBytes)
{
+#if 0
PGLOBAL_HANDLE phandle;
- LPVOID palloc;
-
- aprintf("GlobalAlloc( 0x%X, 0x%lX )\n", flags, size );
-
- if((flags & GMEM_MOVEABLE)==0) /* POINTER */
- {
- palloc=HeapAlloc(__ProcessHeap, 0, size);
- return (HGLOBAL) palloc;
- }
+ PVOID palloc;
+#endif
+
+ DPRINT("GlobalAlloc( 0x%X, 0x%lX )\n", uFlags, dwBytes);
+
+ if ((uFlags & GMEM_MOVEABLE)==0) /* POINTER */
+ {
+ if ((uFlags & GMEM_ZEROINIT)==0)
+ return ((HGLOBAL)RtlAllocateHeap(hProcessHeap, 0, dwBytes));
+ else
+ return ((HGLOBAL)RtlAllocateHeap(hProcessHeap, HEAP_ZERO_MEMORY, dwBytes));
+ }
else /* HANDLE */
- {
+ {
+#if 0
HeapLock(__ProcessHeap);
phandle=__HeapAllocFragment(__ProcessHeap, 0, sizeof(GLOBAL_HANDLE));
- if(size)
+ if(dwBytes)
{
palloc=HeapAlloc(__ProcessHeap, 0, size+sizeof(HANDLE));
*(PHANDLE)palloc=(HANDLE) &(phandle->Pointer);
else
phandle->Pointer=NULL;
phandle->Magic=MAGIC_GLOBAL_USED;
- phandle->Flags=flags>>8;
+ phandle->Flags=uFlags>>8;
phandle->LockCount=0;
HeapUnlock(__ProcessHeap);
return (HGLOBAL) &(phandle->Pointer);
- }
+#endif
+ return (HGLOBAL)NULL;
+ }
}
-/*********************************************************************
-* GlobalLock -- KERNEL32 *
-*********************************************************************/
-LPVOID WINAPI GlobalLock(HGLOBAL hmem)
+
+UINT STDCALL
+GlobalCompact(DWORD dwMinFree)
{
- PGLOBAL_HANDLE phandle;
- LPVOID palloc;
+ return RtlCompactHeap(hProcessHeap, 0);
+}
- aprintf("GlobalLock( 0x%lX )\n", (ULONG) hmem );
- if(((ULONG)hmem%8)==0)
- return (LPVOID) hmem;
+VOID STDCALL
+GlobalFix(HGLOBAL hMem)
+{
+ if (hMem != INVALID_HANDLE_VALUE)
+ GlobalLock(hMem);
+}
- HeapLock(__ProcessHeap);
- phandle=(PGLOBAL_HANDLE)(((LPVOID) hmem)-4);
- if(phandle->Magic==MAGIC_GLOBAL_USED)
+
+UINT STDCALL
+GlobalFlags(HGLOBAL hMem)
+{
+#if 0
+ DWORD retval;
+ PGLOBAL_HANDLE phandle;
+#endif
+
+ DPRINT("GlobalFlags( 0x%lX )\n", (ULONG)hMem);
+
+#if 0
+ if(((ULONG)hmem%8)==0)
{
- if(phandle->LockCount<GLOBAL_LOCK_MAX)
- phandle->LockCount++;
- palloc=phandle->Pointer;
+ retval=0;
}
else
{
- dprintf("GlobalLock: invalid handle\n");
- palloc=(LPVOID) hmem;
+ HeapLock(__ProcessHeap);
+ phandle=(PGLOBAL_HANDLE)(((LPVOID) hmem)-4);
+ if(phandle->Magic==MAGIC_GLOBAL_USED)
+ {
+ retval=phandle->LockCount + (phandle->Flags<<8);
+ if(phandle->Pointer==0)
+ retval|= LMEM_DISCARDED;
+ }
+ else
+ {
+ DPRINT("GlobalSize: invalid handle\n");
+ retval=0;
+ }
+ HeapUnlock(__ProcessHeap);
}
- HeapUnlock(__ProcessHeap);
- return palloc;
+ return retval;
+#endif
+
+ return 0;
}
-/*********************************************************************
-* GlobalUnlock -- KERNEL32 *
-*********************************************************************/
-BOOL WINAPI GlobalUnlock(HGLOBAL hmem)
+
+HGLOBAL STDCALL
+GlobalFree(HGLOBAL hMem)
{
- PGLOBAL_HANDLE phandle;
- BOOL locked;
+#if 0
+ PGLOBAL_HANDLE phandle;
+#endif
+
+ DPRINT("GlobalFree( 0x%lX )\n", (ULONG)hMem);
+
+ if (((ULONG)hMem % 4) == 0) /* POINTER */
+ {
+ RtlFreeHeap(hProcessHeap, 0, (PVOID)hMem);
+ }
+ else /* HANDLE */
+ {
+#if 0
+ HeapLock(__ProcessHeap);
+ phandle=(PGLOBAL_HANDLE)(((LPVOID) hMem)-4);
+ if(phandle->Magic==MAGIC_GLOBAL_USED)
+ {
+ HeapLock(__ProcessHeap);
+ if(phandle->LockCount!=0)
+ SetLastError(ERROR_INVALID_HANDLE);
+ if(phandle->Pointer)
+ HeapHeapFree(GetProcessHeap(),0,__ProcessHeap, 0, phandle->Pointer-sizeof(HANDLE));
+ __HeapFreeFragment(__ProcessHeap, 0, phandle);
+ }
+ HeapUnlock(__ProcessHeap);
+#endif
+ hMem = NULL;
+ }
+ return hMem;
+}
+
+
+HGLOBAL STDCALL
+GlobalHandle(LPCVOID pMem)
+{
+ DPRINT("GlobalHandle( 0x%lX )\n", (ULONG)pMem);
+
+#if 0
+ if(((ULONG)pmem%8)==0) /* FIXED */
+ return (HGLOBAL) pmem;
+ else /* MOVEABLE */
+ return (HGLOBAL) *(LPVOID *)(pmem-sizeof(HANDLE));
+#endif
+
+ return (HGLOBAL)pMem;
+}
- aprintf("GlobalUnlock( 0x%lX )\n", (ULONG) hmem );
+LPVOID STDCALL
+GlobalLock(HGLOBAL hMem)
+{
+#if 0
+ PGLOBAL_HANDLE phandle;
+ LPVOID palloc;
+#endif
+
+ DPRINT("GlobalLock( 0x%lX )\n", (ULONG)hMem);
+
+#if 0
if(((ULONG)hmem%8)==0)
- return FALSE;
+ return (LPVOID) hmem;
HeapLock(__ProcessHeap);
phandle=(PGLOBAL_HANDLE)(((LPVOID) hmem)-4);
if(phandle->Magic==MAGIC_GLOBAL_USED)
{
- if((phandle->LockCount<GLOBAL_LOCK_MAX)&&(phandle->LockCount>0))
- phandle->LockCount--;
-
- locked=(phandle->LockCount==0) ? TRUE : FALSE;
+ if(phandle->LockCount<GLOBAL_LOCK_MAX)
+ phandle->LockCount++;
+ palloc=phandle->Pointer;
}
else
{
- dprintf("GlobalUnlock: invalid handle\n");
- locked=FALSE;
+ DPRINT("GlobalLock: invalid handle\n");
+ palloc=(LPVOID) hmem;
}
HeapUnlock(__ProcessHeap);
- return locked;
+ return palloc;
+#else
+ return (LPVOID)hMem;
+#endif
}
-/*********************************************************************
-* GlobalHandle -- KERNEL32 *
-*********************************************************************/
-HGLOBAL WINAPI GlobalHandle(LPCVOID pmem)
-{
- aprintf("GlobalHandle( 0x%lX )\n", (ULONG) pmem );
- if(((ULONG)pmem%8)==0) /* FIXED */
- return (HGLOBAL) pmem;
- else /* MOVEABLE */
- return (HGLOBAL) *(LPVOID *)(pmem-sizeof(HANDLE));
+VOID STDCALL
+GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer)
+{
+ NTSTATUS Status;
+ SYSTEM_PERFORMANCE_INFO Spi;
+ QUOTA_LIMITS Ql;
+ VM_COUNTERS Vmc;
+ PIMAGE_NT_HEADERS ImageNtHeader;
+
+ RtlZeroMemory (lpBuffer, sizeof (MEMORYSTATUS));
+ lpBuffer->dwLength = sizeof (MEMORYSTATUS);
+ Status = NtQuerySystemInformation (
+ SystemPerformanceInformation,
+ & Spi,
+ sizeof Spi,
+ NULL
+ );
+ /* FIXME: perform computations and fill lpBuffer fields */
+ Status = NtQueryInformationProcess (
+ GetCurrentProcess(),
+ ProcessQuotaLimits,
+ & Ql,
+ sizeof Ql,
+ NULL
+ );
+ /* FIXME: perform computations and fill lpBuffer fields */
+ Status = NtQueryInformationProcess (
+ GetCurrentProcess(),
+ ProcessVmCounters,
+ & Vmc,
+ sizeof Vmc,
+ NULL
+ );
+ /* FIXME: perform computations and fill lpBuffer fields */
+ ImageNtHeader = RtlImageNtHeader ((PVOID)NtCurrentPeb()->ImageBaseAddress);
+ /* FIXME: perform computations and fill lpBuffer fields */
}
-/*********************************************************************
-* GlobalReAlloc -- KERNEL32 *
-*********************************************************************/
-HGLOBAL WINAPI GlobalReAlloc(HGLOBAL hmem, DWORD size, UINT flags)
+
+HGLOBAL STDCALL
+GlobalReAlloc(HGLOBAL hMem,
+ DWORD dwBytes,
+ UINT uFlags)
{
+#if 0
LPVOID palloc;
HGLOBAL hnew;
PGLOBAL_HANDLE phandle;
+#endif
- aprintf("GlobalReAlloc( 0x%lX, 0x%lX, 0x%X )\n", (ULONG) hmem, size, flags );
+ DPRINT("GlobalReAlloc( 0x%lX, 0x%lX, 0x%X )\n", (ULONG)hMem, dwBytes, uFlags);
+#if 0
hnew=NULL;
HeapLock(__ProcessHeap);
if(flags & GMEM_MODIFY) /* modify flags */
}
HeapUnlock(__ProcessHeap);
return hnew;
+#else
+ return ((HGLOBAL)RtlReAllocateHeap(hProcessHeap, uFlags, (LPVOID)hMem, dwBytes));
+#endif
}
-/*********************************************************************
-* GlobalFree -- KERNEL32 *
-*********************************************************************/
-HGLOBAL WINAPI GlobalHeapFree(GetProcessHeap(),0,HGLOBAL hmem)
-{
- PGLOBAL_HANDLE phandle;
-
- aprintf("GlobalHeapFree(GetProcessHeap(),0, 0x%lX )\n", (ULONG) hmem );
-
- if(((ULONG)hmem%4)==0) /* POINTER */
- {
- HeapHeapFree(GetProcessHeap(),0,__ProcessHeap, 0, (LPVOID) hmem);
- }
- else /* HANDLE */
- {
- HeapLock(__ProcessHeap);
- phandle=(PGLOBAL_HANDLE)(((LPVOID) hmem)-4);
- if(phandle->Magic==MAGIC_GLOBAL_USED)
- {
- HeapLock(__ProcessHeap);
- if(phandle->LockCount!=0)
- SetLastError(ERROR_INVALID_HANDLE);
- if(phandle->Pointer)
- HeapHeapFree(GetProcessHeap(),0,__ProcessHeap, 0, phandle->Pointer-sizeof(HANDLE));
- __HeapFreeFragment(__ProcessHeap, 0, phandle);
- }
- HeapUnlock(__ProcessHeap);
- }
- return hmem;
-}
-/*********************************************************************
-* GlobalSize -- KERNEL32 *
-*********************************************************************/
-DWORD WINAPI GlobalSize(HGLOBAL hmem)
+DWORD STDCALL
+GlobalSize(HGLOBAL hMem)
{
DWORD retval;
+#if 0
PGLOBAL_HANDLE phandle;
+#endif
- aprintf("GlobalSize( 0x%lX )\n", (ULONG) hmem );
+ DPRINT("GlobalSize( 0x%lX )\n", (ULONG)hMem);
- if(((ULONG)hmem%8)==0)
+ if(((ULONG)hMem % 4) == 0)
{
- retval=HeapSize(__ProcessHeap, 0, hmem);
+ retval = RtlSizeHeap(hProcessHeap, 0, hMem);
}
else
{
+#if 0
HeapLock(__ProcessHeap);
phandle=(PGLOBAL_HANDLE)(((LPVOID) hmem)-4);
if(phandle->Magic==MAGIC_GLOBAL_USED)
}
else
{
- dprintf("GlobalSize: invalid handle\n");
+ DPRINT("GlobalSize: invalid handle\n");
retval=0;
}
HeapUnlock(__ProcessHeap);
+#endif
+ retval = 0;
}
return retval;
}
-/*********************************************************************
-* GlobalWire -- KERNEL32 *
-*********************************************************************/
-LPVOID WINAPI GlobalWire(HGLOBAL hmem)
-{
- return GlobalLock( hmem );
-}
-/*********************************************************************
-* GlobalUnWire -- KERNEL32 *
-*********************************************************************/
-BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
+VOID STDCALL
+GlobalUnfix(HGLOBAL hMem)
{
- return GlobalUnlock( hmem);
+ if (hMem != INVALID_HANDLE_VALUE)
+ GlobalUnlock(hMem);
}
-/*********************************************************************
-* GlobalFix -- KERNEL32 *
-*********************************************************************/
-VOID WINAPI GlobalFix(HGLOBAL hmem)
+
+BOOL STDCALL
+GlobalUnlock(HGLOBAL hMem)
{
- GlobalLock( hmem );
+#if 0
+ PGLOBAL_HANDLE phandle;
+ BOOL locked;
+#endif
+
+ DPRINT("GlobalUnlock( 0x%lX )\n", (ULONG)hMem);
+
+#if 0
+ if(((ULONG)hmem%8)==0)
+ return FALSE;
+
+ HeapLock(__ProcessHeap);
+ phandle=(PGLOBAL_HANDLE)(((LPVOID) hmem)-4);
+ if(phandle->Magic==MAGIC_GLOBAL_USED)
+ {
+ if((phandle->LockCount<GLOBAL_LOCK_MAX)&&(phandle->LockCount>0))
+ phandle->LockCount--;
+
+ locked=(phandle->LockCount==0) ? TRUE : FALSE;
+ }
+ else
+ {
+ DPRINT("GlobalUnlock: invalid handle\n");
+ locked=FALSE;
+ }
+ HeapUnlock(__ProcessHeap);
+ return locked;
+#endif
+
+ return TRUE;
}
-/*********************************************************************
-* GlobalUnfix -- KERNEL32 *
-*********************************************************************/
-VOID WINAPI GlobalUnfix(HGLOBAL hmem)
+
+BOOL STDCALL
+GlobalUnWire(HGLOBAL hMem)
{
- GlobalUnlock( hmem);
+ return GlobalUnlock(hMem);
}
-/*********************************************************************
-* GlobalFlags -- KERNEL32 *
-*********************************************************************/
-UINT WINAPI GlobalFlags(HGLOBAL hmem)
+
+LPVOID STDCALL
+GlobalWire(HGLOBAL hMem)
{
- return LocalFlags( (HLOCAL) hmem);
+ return GlobalLock(hMem);
}
+/* EOF */
projects / reactos.git / blobdiff