Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-04 00:05:44 +00:00
Code Issues Projects Releases Packages Wiki Activity

Bye, bye, GDIOBJ header! You've served us well, but now the time has come for you to make room for BASEOBJECT.

Browse source 
Also bye, bye, HandleTable parameter. You've never done any reasonable job, so no one will be missing you.

svn path=/trunk/; revision=32497
This commit is contained in:
Timo Kreuzer 2008-02-26 23:09:20 +00:00
parent 314611d68d
commit c11d265144
24 changed files with 203 additions and 233 deletions
Download patch file Download diff file Expand all files Collapse all files

4
reactos/subsystems/win32/win32k/eng/palette.c
View file

@ -68,7 +68,7 @@ EngCreatePalette(ULONG Mode, ULONG NumColors, ULONG *Colors,
Palette = PALETTE_AllocPalette(Mode, NumColors, Colors, Red, Green, Blue); Palette = PALETTE_AllocPalette(Mode, NumColors, Colors, Red, Green, Blue);
if (Palette != NULL) if (Palette != NULL)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, Palette, NULL); GDIOBJ_SetOwnership(Palette, NULL);
} }
return Palette; return Palette;
@ -80,7 +80,7 @@ EngCreatePalette(ULONG Mode, ULONG NumColors, ULONG *Colors,
BOOL STDCALL BOOL STDCALL
EngDeletePalette(IN HPALETTE Palette) EngDeletePalette(IN HPALETTE Palette)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, Palette, PsGetCurrentProcess()); GDIOBJ_SetOwnership(Palette, PsGetCurrentProcess());
return PALETTE_FreePalette(Palette); return PALETTE_FreePalette(Palette);
} }

10
reactos/subsystems/win32/win32k/eng/surface.c
View file

@ -379,7 +379,7 @@ EngCreateBitmap(IN SIZEL Size,
if ( !NewBitmap ) if ( !NewBitmap )
return 0; return 0;
GDIOBJ_SetOwnership(GdiHandleTable, NewBitmap, NULL); GDIOBJ_SetOwnership(NewBitmap, NULL);
return NewBitmap; return NewBitmap;
} }
@ -400,7 +400,7 @@ EngCreateDeviceSurface(IN DHSURF dhsurf,
if (NewSurface == NULL) if (NewSurface == NULL)
return 0; return 0;
GDIOBJ_SetOwnership(GdiHandleTable, NewSurface, NULL); GDIOBJ_SetOwnership(NewSurface, NULL);
BitmapObj = BITMAPOBJ_LockBitmap(NewSurface); BitmapObj = BITMAPOBJ_LockBitmap(NewSurface);
if (! BITMAPOBJ_InitBitsLock(BitmapObj)) if (! BITMAPOBJ_InitBitsLock(BitmapObj))
@ -512,7 +512,7 @@ EngModifySurface(
BOOL STDCALL BOOL STDCALL
EngDeleteSurface(IN HSURF Surface) EngDeleteSurface(IN HSURF Surface)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, Surface, PsGetCurrentProcess()); GDIOBJ_SetOwnership(Surface, PsGetCurrentProcess());
BITMAPOBJ_FreeBitmap(Surface); BITMAPOBJ_FreeBitmap(Surface);
return TRUE; return TRUE;
} }
@ -550,7 +550,7 @@ NtGdiEngLockSurface(IN HSURF Surface)
SURFOBJ * STDCALL SURFOBJ * STDCALL
EngLockSurface(IN HSURF Surface) EngLockSurface(IN HSURF Surface)
{ {
BITMAPOBJ *bmp = GDIOBJ_ShareLockObj(GdiHandleTable, Surface, GDI_OBJECT_TYPE_BITMAP); BITMAPOBJ *bmp = GDIOBJ_ShareLockObj(Surface, GDI_OBJECT_TYPE_BITMAP);
if (bmp != NULL) if (bmp != NULL)
return &bmp->SurfObj; return &bmp->SurfObj;
@ -577,7 +577,7 @@ EngUnlockSurface(IN SURFOBJ *Surface)
if (Surface != NULL) if (Surface != NULL)
{ {
BITMAPOBJ *bmp = CONTAINING_RECORD(Surface, BITMAPOBJ, SurfObj); BITMAPOBJ *bmp = CONTAINING_RECORD(Surface, BITMAPOBJ, SurfObj);
GDIOBJ_UnlockObjByPtr(GdiHandleTable, bmp); GDIOBJ_ShareUnlockObjByPtr((POBJ)bmp);
} }
} }

8
reactos/subsystems/win32/win32k/include/bitmaps.h
View file

@ -27,14 +27,14 @@ typedef struct _BITMAPOBJ
/* Internal interface */ /* Internal interface */
#define BITMAPOBJ_AllocBitmap() \ #define BITMAPOBJ_AllocBitmap() \
((HBITMAP) GDIOBJ_AllocObj (GdiHandleTable, GDI_OBJECT_TYPE_BITMAP)) ((HBITMAP) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BITMAP))
#define BITMAPOBJ_FreeBitmap(hBMObj) \ #define BITMAPOBJ_FreeBitmap(hBMObj) \
GDIOBJ_FreeObj(GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP)
/* NOTE: Use shared locks! */ /* NOTE: Use shared locks! */
#define BITMAPOBJ_LockBitmap(hBMObj) \ #define BITMAPOBJ_LockBitmap(hBMObj) \
((PBITMAPOBJ) GDIOBJ_ShareLockObj (GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP)) ((PBITMAPOBJ) GDIOBJ_ShareLockObj ((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP))
#define BITMAPOBJ_UnlockBitmap(pBMObj) \ #define BITMAPOBJ_UnlockBitmap(pBMObj) \
GDIOBJ_UnlockObjByPtr (GdiHandleTable, pBMObj) GDIOBJ_ShareUnlockObjByPtr ((POBJ)pBMObj)
BOOL INTERNAL_CALL BITMAP_Cleanup(PVOID ObjectBody); BOOL INTERNAL_CALL BITMAP_Cleanup(PVOID ObjectBody);

8
reactos/subsystems/win32/win32k/include/brush.h
View file

@ -72,10 +72,10 @@ typedef struct
#define GDIBRUSH_IS_MASKING 0x8000 /* Pattern bitmap is used as transparent mask (?) */ #define GDIBRUSH_IS_MASKING 0x8000 /* Pattern bitmap is used as transparent mask (?) */
#define GDIBRUSH_CACHED_IS_SOLID 0x80000000 #define GDIBRUSH_CACHED_IS_SOLID 0x80000000
#define BRUSHOBJ_AllocBrush() ((HBRUSH) GDIOBJ_AllocObj (GdiHandleTable, GDI_OBJECT_TYPE_BRUSH)) #define BRUSHOBJ_AllocBrush() ((HBRUSH) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BRUSH))
#define BRUSHOBJ_FreeBrush(hBrush) GDIOBJ_FreeObj(GdiHandleTable, (HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH) #define BRUSHOBJ_FreeBrush(hBrush) GDIOBJ_FreeObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)
#define BRUSHOBJ_LockBrush(hBrush) ((PGDIBRUSHOBJ)GDIOBJ_LockObj(GdiHandleTable, (HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)) #define BRUSHOBJ_LockBrush(hBrush) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH))
#define BRUSHOBJ_UnlockBrush(pBrush) GDIOBJ_UnlockObjByPtr(GdiHandleTable, pBrush) #define BRUSHOBJ_UnlockBrush(pBrush) GDIOBJ_UnlockObjByPtr((POBJ)pBrush)
INT FASTCALL BRUSH_GetObject (PGDIBRUSHOBJ GdiObject, INT Count, LPLOGBRUSH Buffer); INT FASTCALL BRUSH_GetObject (PGDIBRUSHOBJ GdiObject, INT Count, LPLOGBRUSH Buffer);
BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody); BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody);

4
reactos/subsystems/win32/win32k/include/dc.h
View file

@ -150,9 +150,9 @@ typedef struct
/* Internal functions *********************************************************/ /* Internal functions *********************************************************/
#define DC_LockDc(hDC) \ #define DC_LockDc(hDC) \
((PDC) GDIOBJ_LockObj (GdiHandleTable, (HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC)) ((PDC) GDIOBJ_LockObj ((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC))
#define DC_UnlockDc(pDC) \ #define DC_UnlockDc(pDC) \
GDIOBJ_UnlockObjByPtr (GdiHandleTable, pDC) GDIOBJ_UnlockObjByPtr ((POBJ)pDC)
NTSTATUS FASTCALL InitDcImpl(VOID); NTSTATUS FASTCALL InitDcImpl(VOID);
PGDIDEVICE FASTCALL IntEnumHDev(VOID); PGDIDEVICE FASTCALL IntEnumHDev(VOID);

48
reactos/subsystems/win32/win32k/include/gdiobj.h
View file

@ -35,26 +35,8 @@ typedef PVOID PGDIOBJ;
typedef BOOL (INTERNAL_CALL *GDICLEANUPPROC)(PVOID ObjectBody); typedef BOOL (INTERNAL_CALL *GDICLEANUPPROC)(PVOID ObjectBody);
/*! /* Every GDI Object must have this standard type of header.
* GDI object header. This is a part of any GDI object. ROS specific header! * It's for thread locking. */
*/
typedef struct _GDIOBJHDR
{
PETHREAD LockingThread; /* only assigned if a thread is holding the lock! */
ULONG Locks;
#ifdef GDI_DEBUG
const char* createdfile;
int createdline;
const char* lockfile;
int lockline;
#endif
} GDIOBJHDR, *PGDIOBJHDR;
//
// Every GDI Object must have this standard type of header.
// It's for thread locking.
// This header is standalone, used only in gdiobj.c.
//
typedef struct _BASEOBJECT typedef struct _BASEOBJECT
{ {
HGDIOBJ hHmgr; HGDIOBJ hHmgr;
@ -64,23 +46,23 @@ typedef struct _BASEOBJECT
PW32THREAD Tid; PW32THREAD Tid;
} BASEOBJECT, *POBJ; } BASEOBJECT, *POBJ;
BOOL INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ ObjectHandle); BOOL INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle);
void INTERNAL_CALL GDIOBJ_SetOwnership(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ ObjectHandle, PEPROCESS Owner); VOID INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner);
void INTERNAL_CALL GDIOBJ_CopyOwnership(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ CopyFrom, HGDIOBJ CopyTo); VOID INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo);
BOOL INTERNAL_CALL GDIOBJ_ConvertToStockObj(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ *hObj); BOOL INTERNAL_CALL GDIOBJ_ConvertToStockObj(HGDIOBJ *hObj);
VOID INTERNAL_CALL GDIOBJ_UnlockObjByPtr(PGDI_HANDLE_TABLE HandleTable, PGDIOBJ Object); VOID INTERNAL_CALL GDIOBJ_UnlockObjByPtr(POBJ Object);
VOID INTERNAL_CALL GDIOBJ_ShareUnlockObjByPtr(POBJ Object);
BOOL INTERNAL_CALL GDIOBJ_ValidateHandle(HGDIOBJ hObj, ULONG ObjectType);
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObj(ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObj (HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_LockObj (HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ObjectType);
PVOID INTERNAL_CALL GDI_MapHandleTable(PSECTION_OBJECT SectionObject, PEPROCESS Process);
#define GDIOBJ_GetObjectType(Handle) \ #define GDIOBJ_GetObjectType(Handle) \
GDI_HANDLE_GET_TYPE(Handle) GDI_HANDLE_GET_TYPE(Handle)
BOOL INTERNAL_CALL GDIOBJ_ValidateHandle(HGDIOBJ hObj, ULONG ObjectType);
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObj(PGDI_HANDLE_TABLE HandleTable, ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_LockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ObjectType);
PVOID INTERNAL_CALL GDI_MapHandleTable(PSECTION_OBJECT SectionObject, PEPROCESS Process);
#define GDIOBJFLAG_DEFAULT (0x0) #define GDIOBJFLAG_DEFAULT (0x0)
#define GDIOBJFLAG_IGNOREPID (0x1) #define GDIOBJFLAG_IGNOREPID (0x1)
#define GDIOBJFLAG_IGNORELOCK (0x2) #define GDIOBJFLAG_IGNORELOCK (0x2)

6
reactos/subsystems/win32/win32k/include/palette.h
View file

@ -64,9 +64,9 @@ HPALETTE FASTCALL PALETTE_AllocPalette(ULONG Mode,
ULONG Blue); ULONG Blue);
HPALETTE FASTCALL PALETTE_AllocPaletteIndexedRGB(ULONG NumColors, HPALETTE FASTCALL PALETTE_AllocPaletteIndexedRGB(ULONG NumColors,
CONST RGBQUAD *Colors); CONST RGBQUAD *Colors);
#define PALETTE_FreePalette(hPalette) GDIOBJ_FreeObj(GdiHandleTable, (HGDIOBJ)hPalette, GDI_OBJECT_TYPE_PALETTE) #define PALETTE_FreePalette(hPalette) GDIOBJ_FreeObj((HGDIOBJ)hPalette, GDI_OBJECT_TYPE_PALETTE)
#define PALETTE_LockPalette(hPalette) ((PPALGDI)GDIOBJ_LockObj(GdiHandleTable, (HGDIOBJ)hPalette, GDI_OBJECT_TYPE_PALETTE)) #define PALETTE_LockPalette(hPalette) ((PPALGDI)GDIOBJ_LockObj((HGDIOBJ)hPalette, GDI_OBJECT_TYPE_PALETTE))
#define PALETTE_UnlockPalette(pPalette) GDIOBJ_UnlockObjByPtr(GdiHandleTable, pPalette) #define PALETTE_UnlockPalette(pPalette) GDIOBJ_UnlockObjByPtr((POBJ)pPalette)
BOOL INTERNAL_CALL PALETTE_Cleanup(PVOID ObjectBody); BOOL INTERNAL_CALL PALETTE_Cleanup(PVOID ObjectBody);
HPALETTE FASTCALL PALETTE_Init (VOID); HPALETTE FASTCALL PALETTE_Init (VOID);

14
reactos/subsystems/win32/win32k/include/pen.h
View file

@ -6,13 +6,13 @@
/* Internal interface */ /* Internal interface */
#define PENOBJ_AllocPen() ((HPEN)GDIOBJ_AllocObj(GdiHandleTable, GDI_OBJECT_TYPE_PEN)) #define PENOBJ_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDI_OBJECT_TYPE_PEN))
#define PENOBJ_FreePen(hBMObj) GDIOBJ_FreeObj(GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN) #define PENOBJ_FreePen(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN)
#define PENOBJ_LockPen(hBMObj) ((PGDIBRUSHOBJ)GDIOBJ_LockObj(GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN)) #define PENOBJ_LockPen(hBMObj) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN))
#define PENOBJ_AllocExtPen() ((HPEN)GDIOBJ_AllocObj(GdiHandleTable, GDI_OBJECT_TYPE_EXTPEN)) #define PENOBJ_AllocExtPen() ((HPEN)GDIOBJ_AllocObj(GDI_OBJECT_TYPE_EXTPEN))
#define PENOBJ_FreeExtPen(hBMObj) GDIOBJ_FreeObj(GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN) #define PENOBJ_FreeExtPen(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN)
#define PENOBJ_LockExtPen(hBMObj) ((PGDIBRUSHOBJ)GDIOBJ_LockObj(GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN)) #define PENOBJ_LockExtPen(hBMObj) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN))
#define PENOBJ_UnlockPen(pPenObj) GDIOBJ_UnlockObjByPtr(GdiHandleTable, pPenObj) #define PENOBJ_UnlockPen(pPenObj) GDIOBJ_UnlockObjByPtr((POBJ)pPenObj)
INT STDCALL PEN_GetObject(PGDIBRUSHOBJ hPen, INT Count, PLOGPEN Buffer); INT STDCALL PEN_GetObject(PGDIBRUSHOBJ hPen, INT Count, PLOGPEN Buffer);

6
reactos/subsystems/win32/win32k/include/region.h
View file

@ -21,9 +21,9 @@ typedef struct _ROSRGNDATA
/* Functions ******************************************************************/ /* Functions ******************************************************************/
#define RGNDATA_FreeRgn(hRgn) GDIOBJ_FreeObj(GdiHandleTable, (HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION) #define RGNDATA_FreeRgn(hRgn) GDIOBJ_FreeObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION)
#define RGNDATA_LockRgn(hRgn) ((PROSRGNDATA)GDIOBJ_LockObj(GdiHandleTable, (HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION)) #define RGNDATA_LockRgn(hRgn) ((PROSRGNDATA)GDIOBJ_LockObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION))
#define RGNDATA_UnlockRgn(pRgn) GDIOBJ_UnlockObjByPtr(GdiHandleTable, pRgn) #define RGNDATA_UnlockRgn(pRgn) GDIOBJ_UnlockObjByPtr((POBJ)pRgn)
HRGN FASTCALL RGNDATA_AllocRgn(INT n); HRGN FASTCALL RGNDATA_AllocRgn(INT n);
BOOL INTERNAL_CALL RGNDATA_Cleanup(PVOID ObjectBody); BOOL INTERNAL_CALL RGNDATA_Cleanup(PVOID ObjectBody);

8
reactos/subsystems/win32/win32k/include/text.h
View file

@ -69,10 +69,10 @@ typedef struct
/* Internal interface */ /* Internal interface */
#define TEXTOBJ_AllocText() \ #define TEXTOBJ_AllocText() \
((HFONT) GDIOBJ_AllocObj (GdiHandleTable, GDI_OBJECT_TYPE_FONT)) ((HFONT) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_FONT))
#define TEXTOBJ_FreeText(hBMObj) GDIOBJ_FreeObj(GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT) #define TEXTOBJ_FreeText(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT)
#define TEXTOBJ_LockText(hBMObj) ((PTEXTOBJ) GDIOBJ_LockObj (GdiHandleTable, (HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT)) #define TEXTOBJ_LockText(hBMObj) ((PTEXTOBJ) GDIOBJ_LockObj ((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT))
#define TEXTOBJ_UnlockText(pBMObj) GDIOBJ_UnlockObjByPtr (GdiHandleTable, pBMObj) #define TEXTOBJ_UnlockText(pBMObj) GDIOBJ_UnlockObjByPtr ((POBJ)pBMObj)
NTSTATUS FASTCALL TextIntRealizeFont(HFONT FontHandle); NTSTATUS FASTCALL TextIntRealizeFont(HFONT FontHandle);
NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont); NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont);

4
reactos/subsystems/win32/win32k/main/dllmain.c
View file

@ -28,7 +28,7 @@
#include <debug.h> #include <debug.h>
PGDI_HANDLE_TABLE INTERNAL_CALL GDIOBJ_iAllocHandleTable(OUT PSECTION_OBJECT *SectionObject); PGDI_HANDLE_TABLE INTERNAL_CALL GDIOBJ_iAllocHandleTable(OUT PSECTION_OBJECT *SectionObject);
BOOL INTERNAL_CALL GDI_CleanupForProcess (PGDI_HANDLE_TABLE HandleTable, struct _EPROCESS *Process); BOOL INTERNAL_CALL GDI_CleanupForProcess (struct _EPROCESS *Process);
/* FIXME */ /* FIXME */
PGDI_HANDLE_TABLE GdiHandleTable = NULL; PGDI_HANDLE_TABLE GdiHandleTable = NULL;
PSECTION_OBJECT GdiTableSection = NULL; PSECTION_OBJECT GdiTableSection = NULL;
@ -136,7 +136,7 @@ Win32kProcessCallback(struct _EPROCESS *Process,
/* no process windows should exist at this point, or the function will assert! */ /* no process windows should exist at this point, or the function will assert! */
DestroyProcessClasses(Win32Process); DestroyProcessClasses(Win32Process);
GDI_CleanupForProcess(GdiHandleTable, Process); GDI_CleanupForProcess(Process);
co_IntGraphicsCheck(FALSE); co_IntGraphicsCheck(FALSE);

12
reactos/subsystems/win32/win32k/ntuser/cursoricon.c
View file

@ -490,13 +490,13 @@ IntDestroyCurIconObject(PWINSTATION_OBJECT WinSta, PCURICON_OBJECT CurIcon, BOOL
/* delete bitmaps */ /* delete bitmaps */
if(bmpMask) if(bmpMask)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, bmpMask, PsGetCurrentProcess()); GDIOBJ_SetOwnership(bmpMask, PsGetCurrentProcess());
NtGdiDeleteObject(bmpMask); NtGdiDeleteObject(bmpMask);
CurIcon->IconInfo.hbmMask = NULL; CurIcon->IconInfo.hbmMask = NULL;
} }
if(bmpColor) if(bmpColor)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, bmpColor, PsGetCurrentProcess()); GDIOBJ_SetOwnership(bmpColor, PsGetCurrentProcess());
NtGdiDeleteObject(bmpColor); NtGdiDeleteObject(bmpColor);
CurIcon->IconInfo.hbmColor = NULL; CurIcon->IconInfo.hbmColor = NULL;
} }
@ -597,7 +597,7 @@ NtUserCreateCursorIconHandle(PICONINFO IconInfo OPTIONAL, BOOL Indirect)
CurIcon->Size.cx = bmp->SurfObj.sizlBitmap.cx; CurIcon->Size.cx = bmp->SurfObj.sizlBitmap.cx;
CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy; CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy;
BITMAPOBJ_UnlockBitmap(bmp); BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(GdiHandleTable, CurIcon->IconInfo.hbmColor, NULL); GDIOBJ_SetOwnership(CurIcon->IconInfo.hbmColor, NULL);
} }
if(CurIcon->IconInfo.hbmMask && if(CurIcon->IconInfo.hbmMask &&
(bmp = BITMAPOBJ_LockBitmap(CurIcon->IconInfo.hbmMask))) (bmp = BITMAPOBJ_LockBitmap(CurIcon->IconInfo.hbmMask)))
@ -608,7 +608,7 @@ NtUserCreateCursorIconHandle(PICONINFO IconInfo OPTIONAL, BOOL Indirect)
CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy / 2; CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy / 2;
} }
BITMAPOBJ_UnlockBitmap(bmp); BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(GdiHandleTable, CurIcon->IconInfo.hbmMask, NULL); GDIOBJ_SetOwnership(CurIcon->IconInfo.hbmMask, NULL);
} }
} }
else else
@ -1186,7 +1186,7 @@ NtUserSetCursorContents(
CurIcon->Size.cx = bmp->SurfObj.sizlBitmap.cx; CurIcon->Size.cx = bmp->SurfObj.sizlBitmap.cx;
CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy; CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy;
BITMAPOBJ_UnlockBitmap(bmp); BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(GdiHandleTable, CurIcon->IconInfo.hbmColor, NULL); GDIOBJ_SetOwnership(CurIcon->IconInfo.hbmColor, NULL);
} }
else else
{ {
@ -1198,7 +1198,7 @@ NtUserSetCursorContents(
CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy / 2; CurIcon->Size.cy = bmp->SurfObj.sizlBitmap.cy / 2;
BITMAPOBJ_UnlockBitmap(bmp); BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(GdiHandleTable, CurIcon->IconInfo.hbmMask, NULL); GDIOBJ_SetOwnership(CurIcon->IconInfo.hbmMask, NULL);
} }
Ret = TRUE; Ret = TRUE;

2
reactos/subsystems/win32/win32k/ntuser/misc.c
View file

@ -1277,7 +1277,7 @@ IntSystemParametersInfo(
BITMAPOBJ_UnlockBitmap(bmp); BITMAPOBJ_UnlockBitmap(bmp);
/* change the bitmap's ownership */ /* change the bitmap's ownership */
GDIOBJ_SetOwnership(GdiHandleTable, hNewBitmap, NULL); GDIOBJ_SetOwnership(hNewBitmap, NULL);
} }
hOldBitmap = (HBITMAP)InterlockedExchange((LONG*)&WinStaObject->hbmWallpaper, (LONG)hNewBitmap); hOldBitmap = (HBITMAP)InterlockedExchange((LONG*)&WinStaObject->hbmWallpaper, (LONG)hNewBitmap);
if(hOldBitmap != NULL) if(hOldBitmap != NULL)

14
reactos/subsystems/win32/win32k/ntuser/painting.c
View file

@ -211,7 +211,7 @@ IntGetNCUpdateRgn(PWINDOW_OBJECT Window, BOOL Validate)
if (NtGdiCombineRgn(Window->UpdateRegion, Window->UpdateRegion, if (NtGdiCombineRgn(Window->UpdateRegion, Window->UpdateRegion,
hRgnWindow, RGN_AND) == NULLREGION) hRgnWindow, RGN_AND) == NULLREGION)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, Window->UpdateRegion, PsGetCurrentProcess()); GDIOBJ_SetOwnership(Window->UpdateRegion, PsGetCurrentProcess());
NtGdiDeleteObject(Window->UpdateRegion); NtGdiDeleteObject(Window->UpdateRegion);
Window->UpdateRegion = NULL; Window->UpdateRegion = NULL;
if (!(Window->Flags & WINDOWOBJECT_NEED_INTERNALPAINT)) if (!(Window->Flags & WINDOWOBJECT_NEED_INTERNALPAINT))
@ -272,7 +272,7 @@ co_IntPaintWindows(PWINDOW_OBJECT Window, ULONG Flags, BOOL Recurse)
if ((HANDLE) 1 != TempRegion && NULL != TempRegion) if ((HANDLE) 1 != TempRegion && NULL != TempRegion)
{ {
/* NOTE: The region can already be deleted! */ /* NOTE: The region can already be deleted! */
GDIOBJ_FreeObj(GdiHandleTable, TempRegion, GDI_OBJECT_TYPE_REGION | GDI_OBJECT_TYPE_SILENT); GDIOBJ_FreeObj(TempRegion, GDI_OBJECT_TYPE_REGION | GDI_OBJECT_TYPE_SILENT);
} }
} }
@ -398,13 +398,13 @@ IntInvalidateWindows(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags)
if (Window->UpdateRegion == NULL) if (Window->UpdateRegion == NULL)
{ {
Window->UpdateRegion = NtGdiCreateRectRgn(0, 0, 0, 0); Window->UpdateRegion = NtGdiCreateRectRgn(0, 0, 0, 0);
GDIOBJ_SetOwnership(GdiHandleTable, Window->UpdateRegion, NULL); GDIOBJ_SetOwnership(Window->UpdateRegion, NULL);
} }
if (NtGdiCombineRgn(Window->UpdateRegion, Window->UpdateRegion, if (NtGdiCombineRgn(Window->UpdateRegion, Window->UpdateRegion,
hRgn, RGN_OR) == NULLREGION) hRgn, RGN_OR) == NULLREGION)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, Window->UpdateRegion, PsGetCurrentProcess()); GDIOBJ_SetOwnership(Window->UpdateRegion, PsGetCurrentProcess());
NtGdiDeleteObject(Window->UpdateRegion); NtGdiDeleteObject(Window->UpdateRegion);
Window->UpdateRegion = NULL; Window->UpdateRegion = NULL;
} }
@ -424,7 +424,7 @@ IntInvalidateWindows(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags)
if (NtGdiCombineRgn(Window->UpdateRegion, Window->UpdateRegion, if (NtGdiCombineRgn(Window->UpdateRegion, Window->UpdateRegion,
hRgn, RGN_DIFF) == NULLREGION) hRgn, RGN_DIFF) == NULLREGION)
{ {
GDIOBJ_SetOwnership(GdiHandleTable, Window->UpdateRegion, PsGetCurrentProcess()); GDIOBJ_SetOwnership(Window->UpdateRegion, PsGetCurrentProcess());
NtGdiDeleteObject(Window->UpdateRegion); NtGdiDeleteObject(Window->UpdateRegion);
Window->UpdateRegion = NULL; Window->UpdateRegion = NULL;
} }
@ -801,7 +801,7 @@ NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* UnsafePs)
if (hRgn != (HANDLE)1 && hRgn != NULL) if (hRgn != (HANDLE)1 && hRgn != NULL)
{ {
/* NOTE: The region can already by deleted! */ /* NOTE: The region can already by deleted! */
GDIOBJ_FreeObj(GdiHandleTable, hRgn, GDI_OBJECT_TYPE_REGION | GDI_OBJECT_TYPE_SILENT); GDIOBJ_FreeObj(hRgn, GDI_OBJECT_TYPE_REGION | GDI_OBJECT_TYPE_SILENT);
} }
} }
@ -833,7 +833,7 @@ NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* UnsafePs)
{ {
IntGetClientRect(Window, &Ps.rcPaint); IntGetClientRect(Window, &Ps.rcPaint);
} }
GDIOBJ_SetOwnership(GdiHandleTable, Window->UpdateRegion, PsGetCurrentProcess()); GDIOBJ_SetOwnership(Window->UpdateRegion, PsGetCurrentProcess());
/* The region is part of the dc now and belongs to the process! */ /* The region is part of the dc now and belongs to the process! */
Window->UpdateRegion = NULL; Window->UpdateRegion = NULL;
} }

2
reactos/subsystems/win32/win32k/ntuser/windc.c
View file

@ -590,7 +590,7 @@ DceFreeDCE(PDCE pdce, BOOLEAN Force)
SetDCHook(pdce->hDC, NULL, 0L); SetDCHook(pdce->hDC, NULL, 0L);
#endif #endif
if (Force && !GDIOBJ_OwnedByCurrentProcess(GdiHandleTable, pdce->hDC)) if (Force && !GDIOBJ_OwnedByCurrentProcess(pdce->hDC))
{ {
DPRINT1("Change ownership for DCE!\n"); DPRINT1("Change ownership for DCE!\n");

12
reactos/subsystems/win32/win32k/objects/bitmaps.c
View file

@ -634,7 +634,7 @@ BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
return 0; return 0;
} }
Bitmap = GDIOBJ_LockObj(GdiHandleTable, hBitmap, GDI_OBJECT_TYPE_BITMAP); Bitmap = GDIOBJ_LockObj(hBitmap, GDI_OBJECT_TYPE_BITMAP);
if (Bitmap == NULL) if (Bitmap == NULL)
{ {
return 0; return 0;
@ -657,14 +657,14 @@ BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
{ {
PBYTE buf; PBYTE buf;
resBitmap = GDIOBJ_LockObj(GdiHandleTable, res, GDI_OBJECT_TYPE_BITMAP); resBitmap = GDIOBJ_LockObj(res, GDI_OBJECT_TYPE_BITMAP);
if (resBitmap) if (resBitmap)
{ {
buf = ExAllocatePoolWithTag (PagedPool, bm.bmWidthBytes * abs(bm.bmHeight), TAG_BITMAP); buf = ExAllocatePoolWithTag (PagedPool, bm.bmWidthBytes * abs(bm.bmHeight), TAG_BITMAP);
if (buf == NULL) if (buf == NULL)
{ {
GDIOBJ_UnlockObjByPtr(GdiHandleTable, resBitmap); GDIOBJ_UnlockObjByPtr((POBJ)resBitmap);
GDIOBJ_UnlockObjByPtr(GdiHandleTable, Bitmap); GDIOBJ_UnlockObjByPtr((POBJ)Bitmap);
NtGdiDeleteObject(res); NtGdiDeleteObject(res);
return 0; return 0;
} }
@ -672,7 +672,7 @@ BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
IntSetBitmapBits (resBitmap, bm.bmWidthBytes * abs(bm.bmHeight), buf); IntSetBitmapBits (resBitmap, bm.bmWidthBytes * abs(bm.bmHeight), buf);
ExFreePool (buf); ExFreePool (buf);
resBitmap->flFlags = Bitmap->flFlags; resBitmap->flFlags = Bitmap->flFlags;
GDIOBJ_UnlockObjByPtr(GdiHandleTable, resBitmap); GDIOBJ_UnlockObjByPtr((POBJ)resBitmap);
} }
else else
{ {
@ -681,7 +681,7 @@ BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
} }
} }
GDIOBJ_UnlockObjByPtr(GdiHandleTable, Bitmap); GDIOBJ_UnlockObjByPtr((POBJ)Bitmap);
return res; return res;
} }

8
reactos/subsystems/win32/win32k/objects/brush.c
View file

@ -42,7 +42,7 @@ BRUSH_Cleanup(PVOID ObjectBody)
if(pBrush->flAttrs & (GDIBRUSH_IS_HATCH | GDIBRUSH_IS_BITMAP)) if(pBrush->flAttrs & (GDIBRUSH_IS_HATCH | GDIBRUSH_IS_BITMAP))
{ {
ASSERT(pBrush->hbmPattern); ASSERT(pBrush->hbmPattern);
GDIOBJ_SetOwnership(GdiHandleTable, pBrush->hbmPattern, PsGetCurrentProcess()); GDIOBJ_SetOwnership(pBrush->hbmPattern, PsGetCurrentProcess());
NtGdiDeleteObject(pBrush->hbmPattern); NtGdiDeleteObject(pBrush->hbmPattern);
} }
@ -366,7 +366,7 @@ IntGdiCreateDIBBrush(
BrushObject->hbmPattern = hPattern; BrushObject->hbmPattern = hPattern;
/* FIXME: Fill in the rest of fields!!! */ /* FIXME: Fill in the rest of fields!!! */
GDIOBJ_SetOwnership(GdiHandleTable, hPattern, NULL); GDIOBJ_SetOwnership(hPattern, NULL);
BRUSHOBJ_UnlockBrush(BrushObject); BRUSHOBJ_UnlockBrush(BrushObject);
@ -409,7 +409,7 @@ IntGdiCreateHatchBrush(
BrushObject->hbmPattern = hPattern; BrushObject->hbmPattern = hPattern;
BrushObject->BrushAttr.lbColor = Color & 0xFFFFFF; BrushObject->BrushAttr.lbColor = Color & 0xFFFFFF;
GDIOBJ_SetOwnership(GdiHandleTable, hPattern, NULL); GDIOBJ_SetOwnership(hPattern, NULL);
BRUSHOBJ_UnlockBrush(BrushObject); BRUSHOBJ_UnlockBrush(BrushObject);
@ -446,7 +446,7 @@ IntGdiCreatePatternBrush(
BrushObject->hbmPattern = hPattern; BrushObject->hbmPattern = hPattern;
/* FIXME: Fill in the rest of fields!!! */ /* FIXME: Fill in the rest of fields!!! */
GDIOBJ_SetOwnership(GdiHandleTable, hPattern, NULL); GDIOBJ_SetOwnership(hPattern, NULL);
BRUSHOBJ_UnlockBrush(BrushObject); BRUSHOBJ_UnlockBrush(BrushObject);

2
reactos/subsystems/win32/win32k/objects/cliprgn.c
View file

@ -81,7 +81,7 @@ IntGdiSelectVisRgn(HDC hdc, HRGN hrgn)
if (dc->w.hVisRgn == NULL) if (dc->w.hVisRgn == NULL)
{ {
dc->w.hVisRgn = NtGdiCreateRectRgn(0, 0, 0, 0); dc->w.hVisRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
GDIOBJ_CopyOwnership(GdiHandleTable, hdc, dc->w.hVisRgn); GDIOBJ_CopyOwnership(hdc, dc->w.hVisRgn);
} }
retval = NtGdiCombineRgn(dc->w.hVisRgn, hrgn, 0, RGN_COPY); retval = NtGdiCombineRgn(dc->w.hVisRgn, hrgn, 0, RGN_COPY);

8
reactos/subsystems/win32/win32k/objects/color.c
View file

@ -706,7 +706,7 @@ BOOL STDCALL
NtGdiUnrealizeObject(HGDIOBJ hgdiobj) NtGdiUnrealizeObject(HGDIOBJ hgdiobj)
{ {
GDIOBJHDR * ptr; POBJ pObject;
DWORD objectType; DWORD objectType;
BOOL Ret = FALSE; BOOL Ret = FALSE;
@ -714,8 +714,8 @@ NtGdiUnrealizeObject(HGDIOBJ hgdiobj)
if(!hgdiobj) if(!hgdiobj)
return Ret; return Ret;
ptr = GDIOBJ_LockObj(GdiHandleTable, hgdiobj, GDI_OBJECT_TYPE_DONTCARE); pObject = GDIOBJ_LockObj(hgdiobj, GDI_OBJECT_TYPE_DONTCARE);
if (ptr == 0) if (pObject == NULL)
{ {
SetLastWin32Error(ERROR_INVALID_HANDLE); SetLastWin32Error(ERROR_INVALID_HANDLE);
return Ret; return Ret;
@ -740,7 +740,7 @@ NtGdiUnrealizeObject(HGDIOBJ hgdiobj)
break; break;
} }
GDIOBJ_UnlockObjByPtr(GdiHandleTable, ptr); GDIOBJ_UnlockObjByPtr(pObject);
return Ret; return Ret;
} }

18
reactos/subsystems/win32/win32k/objects/dc.c
View file

@ -1019,7 +1019,7 @@ NtGdiDeleteObjectApp(HANDLE DCHandle)
if(IsObjectDead((HGDIOBJ)DCHandle)) return TRUE; if(IsObjectDead((HGDIOBJ)DCHandle)) return TRUE;
if (!GDIOBJ_OwnedByCurrentProcess(GdiHandleTable, DCHandle)) if (!GDIOBJ_OwnedByCurrentProcess(DCHandle))
{ {
SetLastWin32Error(ERROR_INVALID_HANDLE); SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
@ -1669,7 +1669,7 @@ IntGdiGetObject(IN HANDLE Handle,
INT Result = 0; INT Result = 0;
DWORD dwObjectType; DWORD dwObjectType;
pGdiObject = GDIOBJ_LockObj(GdiHandleTable, Handle, GDI_OBJECT_TYPE_DONTCARE); pGdiObject = GDIOBJ_LockObj(Handle, GDI_OBJECT_TYPE_DONTCARE);
if (!pGdiObject) if (!pGdiObject)
{ {
SetLastWin32Error(ERROR_INVALID_HANDLE); SetLastWin32Error(ERROR_INVALID_HANDLE);
@ -1711,7 +1711,7 @@ IntGdiGetObject(IN HANDLE Handle,
break; break;
} }
GDIOBJ_UnlockObjByPtr(GdiHandleTable, pGdiObject); GDIOBJ_UnlockObjByPtr(pGdiObject);
return Result; return Result;
} }
@ -2375,7 +2375,7 @@ DC_AllocDC(PUNICODE_STRING Driver)
RtlCopyMemory(Buf, Driver->Buffer, Driver->MaximumLength); RtlCopyMemory(Buf, Driver->Buffer, Driver->MaximumLength);
} }
hDC = (HDC) GDIOBJ_AllocObj(GdiHandleTable, GDI_OBJECT_TYPE_DC); hDC = (HDC) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DC);
if (hDC == NULL) if (hDC == NULL)
{ {
if(Buf) if(Buf)
@ -2546,7 +2546,7 @@ DC_FreeDC(HDC DCToFree)
DC_FreeDcAttr(DCToFree); DC_FreeDcAttr(DCToFree);
if(!IsObjectDead( DCToFree )) if(!IsObjectDead( DCToFree ))
{ {
if (!GDIOBJ_FreeObj(GdiHandleTable, DCToFree, GDI_OBJECT_TYPE_DC)) if (!GDIOBJ_FreeObj(DCToFree, GDI_OBJECT_TYPE_DC))
{ {
DPRINT1("DC_FreeDC failed\n"); DPRINT1("DC_FreeDC failed\n");
} }
@ -2629,21 +2629,21 @@ DC_SetOwnership(HDC hDC, PEPROCESS Owner)
{ {
PDC DC; PDC DC;
GDIOBJ_SetOwnership(GdiHandleTable, hDC, Owner); GDIOBJ_SetOwnership(hDC, Owner);
DC = DC_LockDc(hDC); DC = DC_LockDc(hDC);
if (NULL != DC) if (NULL != DC)
{ {
if (NULL != DC->w.hClipRgn) if (NULL != DC->w.hClipRgn)
{ {
GDIOBJ_CopyOwnership(GdiHandleTable, hDC, DC->w.hClipRgn); GDIOBJ_CopyOwnership(hDC, DC->w.hClipRgn);
} }
if (NULL != DC->w.hVisRgn) if (NULL != DC->w.hVisRgn)
{ {
GDIOBJ_CopyOwnership(GdiHandleTable, hDC, DC->w.hVisRgn); GDIOBJ_CopyOwnership(hDC, DC->w.hVisRgn);
} }
if (NULL != DC->w.hGCClipRgn) if (NULL != DC->w.hGCClipRgn)
{ {
GDIOBJ_CopyOwnership(GdiHandleTable, hDC, DC->w.hGCClipRgn); GDIOBJ_CopyOwnership(hDC, DC->w.hGCClipRgn);
} }
DC_UnlockDc(DC); DC_UnlockDc(DC);
} }

210
reactos/subsystems/win32/win32k/objects/gdiobj.c
View file

@ -166,7 +166,7 @@ GDIOBJ_iAllocHandleTable(OUT PSECTION_OBJECT *SectionObject)
if (ObjTypeInfo[ObjType].bUseLookaside) if (ObjTypeInfo[ObjType].bUseLookaside)
{ {
ExInitializePagedLookasideList(HandleTable->LookasideLists + ObjType, NULL, NULL, 0, ExInitializePagedLookasideList(HandleTable->LookasideLists + ObjType, NULL, NULL, 0,
ObjTypeInfo[ObjType].ulBodySize + sizeof(GDIOBJHDR), ObjTypeInfo[ObjType].Tag, 0); ObjTypeInfo[ObjType].ulBodySize, ObjTypeInfo[ObjType].Tag, 0);
} }
} }
@ -179,10 +179,9 @@ GDIOBJ_iAllocHandleTable(OUT PSECTION_OBJECT *SectionObject)
} }
static __inline PPAGED_LOOKASIDE_LIST static __inline PPAGED_LOOKASIDE_LIST
FindLookasideList(PGDI_HANDLE_TABLE HandleTable, FindLookasideList(ULONG TypeIndex)
ULONG TypeIndex)
{ {
return HandleTable->LookasideLists + TypeIndex; return GdiHandleTable->LookasideLists + TypeIndex;
} }
static __inline BOOL static __inline BOOL
@ -338,7 +337,7 @@ LockErrorDebugOutput(HGDIOBJ hObj, PGDI_TABLE_ENTRY Entry, LPSTR Function)
ULONG ULONG
FASTCALL FASTCALL
InterlockedPopFreeEntry(PGDI_HANDLE_TABLE HandleTable) InterlockedPopFreeEntry()
{ {
ULONG idxFirstFree, idxNextFree, idxPrev; ULONG idxFirstFree, idxNextFree, idxPrev;
PGDI_TABLE_ENTRY pFreeEntry; PGDI_TABLE_ENTRY pFreeEntry;
@ -347,24 +346,24 @@ InterlockedPopFreeEntry(PGDI_HANDLE_TABLE HandleTable)
do do
{ {
idxFirstFree = HandleTable->FirstFree; idxFirstFree = GdiHandleTable->FirstFree;
if (idxFirstFree) if (idxFirstFree)
{ {
pFreeEntry = HandleTable->Entries + idxFirstFree; pFreeEntry = GdiHandleTable->Entries + idxFirstFree;
ASSERT(((ULONG)pFreeEntry->KernelData & ~GDI_HANDLE_INDEX_MASK) == 0); ASSERT(((ULONG)pFreeEntry->KernelData & ~GDI_HANDLE_INDEX_MASK) == 0);
idxNextFree = (ULONG)pFreeEntry->KernelData; idxNextFree = (ULONG)pFreeEntry->KernelData;
idxPrev = (ULONG)_InterlockedCompareExchange((LONG*)&HandleTable->FirstFree, idxNextFree, idxFirstFree); idxPrev = (ULONG)_InterlockedCompareExchange((LONG*)&GdiHandleTable->FirstFree, idxNextFree, idxFirstFree);
} }
else else
{ {
idxFirstFree = HandleTable->FirstUnused; idxFirstFree = GdiHandleTable->FirstUnused;
idxNextFree = idxFirstFree + 1; idxNextFree = idxFirstFree + 1;
if (idxNextFree >= GDI_HANDLE_COUNT) if (idxNextFree >= GDI_HANDLE_COUNT)
{ {
DPRINT1("No more gdi handles left!\n"); DPRINT1("No more gdi handles left!\n");
return 0; return 0;
} }
idxPrev = (ULONG)_InterlockedCompareExchange((LONG*)&HandleTable->FirstUnused, idxNextFree, idxFirstFree); idxPrev = (ULONG)_InterlockedCompareExchange((LONG*)&GdiHandleTable->FirstUnused, idxNextFree, idxFirstFree);
} }
} }
while (idxPrev != idxFirstFree); while (idxPrev != idxFirstFree);
@ -376,24 +375,24 @@ InterlockedPopFreeEntry(PGDI_HANDLE_TABLE HandleTable)
The entry must be unlocked and the base type field must be 0 */ The entry must be unlocked and the base type field must be 0 */
VOID VOID
FASTCALL FASTCALL
InterlockedPushFreeEntry(PGDI_HANDLE_TABLE HandleTable, ULONG idxToFree) InterlockedPushFreeEntry(ULONG idxToFree)
{ {
ULONG idxFirstFree, idxPrev; ULONG idxFirstFree, idxPrev;
PGDI_TABLE_ENTRY pFreeEntry; PGDI_TABLE_ENTRY pFreeEntry;
DPRINT("Enter InterlockedPushFreeEntry\n"); DPRINT("Enter InterlockedPushFreeEntry\n");
pFreeEntry = HandleTable->Entries + idxToFree; pFreeEntry = GdiHandleTable->Entries + idxToFree;
ASSERT((pFreeEntry->Type & GDI_ENTRY_BASETYPE_MASK) == 0); ASSERT((pFreeEntry->Type & GDI_ENTRY_BASETYPE_MASK) == 0);
ASSERT(pFreeEntry->ProcessId == 0); ASSERT(pFreeEntry->ProcessId == 0);
pFreeEntry->UserData = NULL; pFreeEntry->UserData = NULL;
do do
{ {
idxFirstFree = HandleTable->FirstFree; idxFirstFree = GdiHandleTable->FirstFree;
pFreeEntry->KernelData = (PVOID)idxFirstFree; pFreeEntry->KernelData = (PVOID)idxFirstFree;
idxPrev = (ULONG)_InterlockedCompareExchange((LONG*)&HandleTable->FirstFree, idxToFree, idxFirstFree); idxPrev = (ULONG)_InterlockedCompareExchange((LONG*)&GdiHandleTable->FirstFree, idxToFree, idxFirstFree);
} }
while (idxPrev != idxFirstFree); while (idxPrev != idxFirstFree);
} }
@ -427,10 +426,10 @@ GDIOBJ_ValidateHandle(HGDIOBJ hObj, ULONG ObjectType)
* \todo return the object pointer and lock it by default. * \todo return the object pointer and lock it by default.
*/ */
HGDIOBJ INTERNAL_CALL HGDIOBJ INTERNAL_CALL
GDIOBJ_AllocObj(PGDI_HANDLE_TABLE HandleTable, ULONG ObjectType) GDIOBJ_AllocObj(ULONG ObjectType)
{ {
PW32PROCESS W32Process; PW32PROCESS W32Process;
PGDIOBJHDR newObject = NULL; POBJ newObject = NULL;
PPAGED_LOOKASIDE_LIST LookasideList = NULL; PPAGED_LOOKASIDE_LIST LookasideList = NULL;
HANDLE CurrentProcessId, LockedProcessId; HANDLE CurrentProcessId, LockedProcessId;
ULONG TypeIndex; ULONG TypeIndex;
@ -449,7 +448,7 @@ GDIOBJ_AllocObj(PGDI_HANDLE_TABLE HandleTable, ULONG ObjectType)
TypeIndex = GDI_OBJECT_GET_TYPE_INDEX(ObjectType); TypeIndex = GDI_OBJECT_GET_TYPE_INDEX(ObjectType);
if (ObjTypeInfo[TypeIndex].bUseLookaside) if (ObjTypeInfo[TypeIndex].bUseLookaside)
{ {
LookasideList = FindLookasideList(HandleTable, TypeIndex); LookasideList = FindLookasideList(TypeIndex);
if(LookasideList != NULL) if(LookasideList != NULL)
{ {
newObject = ExAllocateFromPagedLookasideList(LookasideList); newObject = ExAllocateFromPagedLookasideList(LookasideList);
@ -458,37 +457,31 @@ GDIOBJ_AllocObj(PGDI_HANDLE_TABLE HandleTable, ULONG ObjectType)
else else
{ {
newObject = ExAllocatePoolWithTag(PagedPool, newObject = ExAllocatePoolWithTag(PagedPool,
ObjTypeInfo[TypeIndex].ulBodySize + sizeof(GDIOBJHDR), ObjTypeInfo[TypeIndex].ulBodySize,
ObjTypeInfo[TypeIndex].Tag); ObjTypeInfo[TypeIndex].Tag);
} }
if(newObject != NULL) if(newObject != NULL)
{ {
UINT Index; UINT Index;
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
PGDIOBJ ObjectBody;
LONG TypeInfo; LONG TypeInfo;
CurrentProcessId = PsGetCurrentProcessId(); CurrentProcessId = PsGetCurrentProcessId();
LockedProcessId = (HANDLE)((ULONG_PTR)CurrentProcessId | 0x1); LockedProcessId = (HANDLE)((ULONG_PTR)CurrentProcessId | 0x1);
newObject->LockingThread = NULL; RtlZeroMemory(newObject, GetObjectSize(TypeIndex));
newObject->Locks = 0;
ObjectBody = GDIHdrToBdy(newObject);
RtlZeroMemory(ObjectBody, GetObjectSize(TypeIndex));
/* On Windows the higher 16 bit of the type field don't contain the /* On Windows the higher 16 bit of the type field don't contain the
full type from the handle, but the base type. full type from the handle, but the base type.
(type = BRSUH, PEN, EXTPEN, basetype = BRUSH) */ (type = BRSUH, PEN, EXTPEN, basetype = BRUSH) */
TypeInfo = (ObjectType & GDI_HANDLE_BASETYPE_MASK) | (ObjectType >> GDI_ENTRY_UPPER_SHIFT); TypeInfo = (ObjectType & GDI_HANDLE_BASETYPE_MASK) | (ObjectType >> GDI_ENTRY_UPPER_SHIFT);
Index = InterlockedPopFreeEntry(HandleTable); Index = InterlockedPopFreeEntry();
if (Index != 0) if (Index != 0)
{ {
HANDLE PrevProcId; HANDLE PrevProcId;
Entry = &HandleTable->Entries[Index]; Entry = &GdiHandleTable->Entries[Index];
LockHandle: LockHandle:
PrevProcId = _InterlockedCompareExchangePointer((PVOID*)&Entry->ProcessId, LockedProcessId, 0); PrevProcId = _InterlockedCompareExchangePointer((PVOID*)&Entry->ProcessId, LockedProcessId, 0);
@ -496,7 +489,7 @@ LockHandle:
{ {
HGDIOBJ Handle; HGDIOBJ Handle;
Entry->KernelData = ObjectBody; Entry->KernelData = newObject;
/* copy the reuse-counter */ /* copy the reuse-counter */
TypeInfo |= Entry->Type & GDI_ENTRY_REUSE_MASK; TypeInfo |= Entry->Type & GDI_ENTRY_REUSE_MASK;
@ -518,7 +511,7 @@ LockHandle:
} }
Handle = (HGDIOBJ)((Index & 0xFFFF) | (TypeInfo << GDI_ENTRY_UPPER_SHIFT)); Handle = (HGDIOBJ)((Index & 0xFFFF) | (TypeInfo << GDI_ENTRY_UPPER_SHIFT));
DPRINT("GDIOBJ_AllocObj: 0x%x ob: 0x%x\n", Handle, ObjectBody); DPRINT("GDIOBJ_AllocObj: 0x%x ob: 0x%x\n", Handle, newObject);
return Handle; return Handle;
} }
else else
@ -548,7 +541,7 @@ LockHandle:
} }
DPRINT1("Failed to insert gdi object into the handle table, no handles left!\n"); DPRINT1("Failed to insert gdi object into the handle table, no handles left!\n");
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
IntDumpHandleTable(HandleTable); IntDumpHandleTable(GdiHandleTable);
#endif /* GDI_DEBUG */ #endif /* GDI_DEBUG */
} }
else else
@ -569,7 +562,7 @@ LockHandle:
* to the calling process. * to the calling process.
*/ */
BOOL INTERNAL_CALL BOOL INTERNAL_CALL
GDIOBJ_FreeObj(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ExpectedType) GDIOBJ_FreeObj(HGDIOBJ hObj, DWORD ExpectedType)
{ {
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
PPAGED_LOOKASIDE_LIST LookasideList; PPAGED_LOOKASIDE_LIST LookasideList;
@ -615,7 +608,7 @@ GDIOBJ_FreeObj(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ExpectedType)
return FALSE; return FALSE;
} }
Entry = GDI_HANDLE_GET_ENTRY(HandleTable, hObj); Entry = GDI_HANDLE_GET_ENTRY(GdiHandleTable, hObj);
LockHandle: LockHandle:
/* lock the object, we must not delete global objects, so don't exchange the locking /* lock the object, we must not delete global objects, so don't exchange the locking
@ -627,11 +620,11 @@ LockHandle:
((Entry->Type << GDI_ENTRY_UPPER_SHIFT) == HandleUpper) && ((Entry->Type << GDI_ENTRY_UPPER_SHIFT) == HandleUpper) &&
((Entry->Type & GDI_ENTRY_BASETYPE_MASK) == (HandleUpper & GDI_ENTRY_BASETYPE_MASK)) ) ((Entry->Type & GDI_ENTRY_BASETYPE_MASK) == (HandleUpper & GDI_ENTRY_BASETYPE_MASK)) )
{ {
PGDIOBJHDR GdiHdr; POBJ Object;
GdiHdr = GDIBdyToHdr(Entry->KernelData); Object = Entry->KernelData;
if(GdiHdr->Locks == 0) if(Object->cExclusiveLock == 0)
{ {
BOOL Ret; BOOL Ret;
PW32PROCESS W32Process = PsGetCurrentProcessWin32Process(); PW32PROCESS W32Process = PsGetCurrentProcessWin32Process();
@ -643,7 +636,7 @@ LockHandle:
(void)_InterlockedExchangePointer((PVOID*)&Entry->ProcessId, NULL); (void)_InterlockedExchangePointer((PVOID*)&Entry->ProcessId, NULL);
/* push this entry to the free list */ /* push this entry to the free list */
InterlockedPushFreeEntry(HandleTable, GDI_ENTRY_TO_INDEX(HandleTable, Entry)); InterlockedPushFreeEntry(GDI_ENTRY_TO_INDEX(GdiHandleTable, Entry));
if(W32Process != NULL) if(W32Process != NULL)
{ {
@ -652,20 +645,20 @@ LockHandle:
/* call the cleanup routine. */ /* call the cleanup routine. */
TypeIndex = GDI_OBJECT_GET_TYPE_INDEX(HandleType); TypeIndex = GDI_OBJECT_GET_TYPE_INDEX(HandleType);
Ret = RunCleanupCallback(GDIHdrToBdy(GdiHdr), TypeIndex); Ret = RunCleanupCallback(Object, TypeIndex);
/* Now it's time to free the memory */ /* Now it's time to free the memory */
if (ObjTypeInfo[TypeIndex].bUseLookaside) if (ObjTypeInfo[TypeIndex].bUseLookaside)
{ {
LookasideList = FindLookasideList(HandleTable, TypeIndex); LookasideList = FindLookasideList(TypeIndex);
if(LookasideList != NULL) if(LookasideList != NULL)
{ {
ExFreeToPagedLookasideList(LookasideList, GdiHdr); ExFreeToPagedLookasideList(LookasideList, Object);
} }
} }
else else
{ {
ExFreePool(GdiHdr); ExFreePool(Object);
} }
return Ret; return Ret;
@ -675,7 +668,7 @@ LockHandle:
/* /*
* The object is currently locked, so freeing is forbidden! * The object is currently locked, so freeing is forbidden!
*/ */
DPRINT1("GdiHdr->Locks: %d\n", GdiHdr->Locks); DPRINT1("Object->cExclusiveLock = %d\n", Object->cExclusiveLock);
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
// DPRINT1("Locked from:\n"); // DPRINT1("Locked from:\n");
// KeRosDumpStackFrames(GDIHandleLocker[GDI_HANDLE_GET_INDEX(hObj)], GDI_STACK_LEVELS); // KeRosDumpStackFrames(GDIHandleLocker[GDI_HANDLE_GET_INDEX(hObj)], GDI_STACK_LEVELS);
@ -758,7 +751,7 @@ NtGdiDeleteObject(HGDIOBJ hObject)
if(!IsObjectDead(hObject)) if(!IsObjectDead(hObject))
{ {
return NULL != hObject return NULL != hObject
? GDIOBJ_FreeObj(GdiHandleTable, hObject, GDI_OBJECT_TYPE_DONTCARE) : FALSE; ? GDIOBJ_FreeObj(hObject, GDI_OBJECT_TYPE_DONTCARE) : FALSE;
} }
else else
{ {
@ -772,7 +765,7 @@ NtGdiDeleteObject(HGDIOBJ hObject)
* \param Process - PID of the process that will be destroyed. * \param Process - PID of the process that will be destroyed.
*/ */
BOOL INTERNAL_CALL BOOL INTERNAL_CALL
GDI_CleanupForProcess (PGDI_HANDLE_TABLE HandleTable, struct _EPROCESS *Process) GDI_CleanupForProcess (struct _EPROCESS *Process)
{ {
PGDI_TABLE_ENTRY Entry, End; PGDI_TABLE_ENTRY Entry, End;
PEPROCESS CurrentProcess; PEPROCESS CurrentProcess;
@ -795,8 +788,8 @@ GDI_CleanupForProcess (PGDI_HANDLE_TABLE HandleTable, struct _EPROCESS *Process)
we should delete it directly here! */ we should delete it directly here! */
ProcId = Process->UniqueProcessId; ProcId = Process->UniqueProcessId;
End = &HandleTable->Entries[GDI_HANDLE_COUNT]; End = &GdiHandleTable->Entries[GDI_HANDLE_COUNT];
for(Entry = &HandleTable->Entries[RESERVE_ENTRIES_COUNT]; for(Entry = &GdiHandleTable->Entries[RESERVE_ENTRIES_COUNT];
Entry != End; Entry != End;
Entry++, Index++) Entry++, Index++)
{ {
@ -811,7 +804,7 @@ GDI_CleanupForProcess (PGDI_HANDLE_TABLE HandleTable, struct _EPROCESS *Process)
simply ignore this fact here. */ simply ignore this fact here. */
ObjectHandle = (HGDIOBJ)(Index | (Entry->Type << GDI_ENTRY_UPPER_SHIFT)); ObjectHandle = (HGDIOBJ)(Index | (Entry->Type << GDI_ENTRY_UPPER_SHIFT));
if(GDIOBJ_FreeObj(HandleTable, ObjectHandle, GDI_OBJECT_TYPE_DONTCARE) && if(GDIOBJ_FreeObj(ObjectHandle, GDI_OBJECT_TYPE_DONTCARE) &&
W32Process->GDIObjects == 0) W32Process->GDIObjects == 0)
{ {
/* there are no more gdi handles for this process, bail */ /* there are no more gdi handles for this process, bail */
@ -842,12 +835,12 @@ GDI_CleanupForProcess (PGDI_HANDLE_TABLE HandleTable, struct _EPROCESS *Process)
* \todo Get rid of the ExpectedType parameter! * \todo Get rid of the ExpectedType parameter!
*/ */
PGDIOBJ INTERNAL_CALL PGDIOBJ INTERNAL_CALL
GDIOBJ_LockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ExpectedType) GDIOBJ_LockObj (HGDIOBJ hObj, DWORD ExpectedType)
{ {
ULONG HandleIndex; ULONG HandleIndex;
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
HANDLE ProcessId, HandleProcessId, LockedProcessId, PrevProcId; HANDLE ProcessId, HandleProcessId, LockedProcessId, PrevProcId;
PGDIOBJ Object = NULL; POBJ Object = NULL;
ULONG HandleType, HandleUpper; ULONG HandleType, HandleUpper;
HandleIndex = GDI_HANDLE_GET_INDEX(hObj); HandleIndex = GDI_HANDLE_GET_INDEX(hObj);
@ -858,7 +851,7 @@ GDIOBJ_LockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ExpectedType)
if (HandleIndex >= GDI_HANDLE_COUNT) if (HandleIndex >= GDI_HANDLE_COUNT)
return NULL; return NULL;
Entry = &HandleTable->Entries[HandleIndex]; Entry = &GdiHandleTable->Entries[HandleIndex];
/* Check if we have the requested type */ /* Check if we have the requested type */
if ( (ExpectedType != GDI_OBJECT_TYPE_DONTCARE && if ( (ExpectedType != GDI_OBJECT_TYPE_DONTCARE &&
@ -921,32 +914,29 @@ GDIOBJ_LockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ExpectedType)
if ( (Entry->KernelData != NULL) && if ( (Entry->KernelData != NULL) &&
((Entry->Type << GDI_ENTRY_UPPER_SHIFT) == HandleUpper) ) ((Entry->Type << GDI_ENTRY_UPPER_SHIFT) == HandleUpper) )
{ {
PGDIOBJHDR GdiHdr = GDIBdyToHdr(Entry->KernelData); PW32THREAD Thread = PsGetCurrentThreadWin32Thread();
PETHREAD Thread = PsGetCurrentThread(); Object = Entry->KernelData;
if (GdiHdr->Locks == 0) if (Object->cExclusiveLock == 0)
{ {
GdiHdr->LockingThread = Thread; Object->Tid = Thread;
GdiHdr->Locks = 1; Object->cExclusiveLock = 1;
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
CaptureStackBackTace((PVOID*)GDIHandleLocker[GDI_HANDLE_GET_INDEX(hObj)], GDI_STACK_LEVELS); CaptureStackBackTace((PVOID*)GDIHandleLocker[GDI_HANDLE_GET_INDEX(hObj)], GDI_STACK_LEVELS);
#endif #endif
} }
else else
{ {
_InterlockedIncrement((PLONG)&GdiHdr->Locks); if (Object->Tid != Thread)
if (GdiHdr->LockingThread != Thread)
{ {
_InterlockedDecrement((PLONG)&GdiHdr->Locks);
/* Unlock the handle table entry. */ /* Unlock the handle table entry. */
(void)_InterlockedExchangePointer((PVOID*)&Entry->ProcessId, PrevProcId); (void)_InterlockedExchangePointer((PVOID*)&Entry->ProcessId, PrevProcId);
DelayExecution(); DelayExecution();
continue; continue;
} }
_InterlockedIncrement((PLONG)&Object->cExclusiveLock);
} }
Object = Entry->KernelData;
} }
else else
{ {
@ -991,12 +981,12 @@ GDIOBJ_LockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ExpectedType)
* \todo Get rid of the ExpectedType parameter! * \todo Get rid of the ExpectedType parameter!
*/ */
PGDIOBJ INTERNAL_CALL PGDIOBJ INTERNAL_CALL
GDIOBJ_ShareLockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD ExpectedType) GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ExpectedType)
{ {
ULONG HandleIndex; ULONG HandleIndex;
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
HANDLE ProcessId, HandleProcessId, LockedProcessId, PrevProcId; HANDLE ProcessId, HandleProcessId, LockedProcessId, PrevProcId;
PGDIOBJ Object = NULL; POBJ Object = NULL;
ULONG_PTR HandleType, HandleUpper; ULONG_PTR HandleType, HandleUpper;
HandleIndex = GDI_HANDLE_GET_INDEX(hObj); HandleIndex = GDI_HANDLE_GET_INDEX(hObj);
@ -1017,7 +1007,7 @@ GDIOBJ_ShareLockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD Expected
return NULL; return NULL;
} }
Entry = &HandleTable->Entries[HandleIndex]; Entry = &GdiHandleTable->Entries[HandleIndex];
ProcessId = (HANDLE)((ULONG_PTR)PsGetCurrentProcessId() & ~1); ProcessId = (HANDLE)((ULONG_PTR)PsGetCurrentProcessId() & ~1);
HandleProcessId = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~1); HandleProcessId = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~1);
@ -1059,18 +1049,17 @@ GDIOBJ_ShareLockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD Expected
if ( (Entry->KernelData != NULL) && if ( (Entry->KernelData != NULL) &&
(HandleUpper == (Entry->Type << GDI_ENTRY_UPPER_SHIFT)) ) (HandleUpper == (Entry->Type << GDI_ENTRY_UPPER_SHIFT)) )
{ {
PGDIOBJHDR GdiHdr = GDIBdyToHdr(Entry->KernelData); Object = (POBJ)Entry->KernelData;
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
if (_InterlockedIncrement((PLONG)&GdiHdr->Locks) == 1) if (_InterlockedIncrement((PLONG)&Object->ulShareCount) == 1)
{ {
memset(GDIHandleLocker[HandleIndex], 0x00, GDI_STACK_LEVELS * sizeof(ULONG)); memset(GDIHandleLocker[HandleIndex], 0x00, GDI_STACK_LEVELS * sizeof(ULONG));
RtlCaptureStackBackTrace(1, GDI_STACK_LEVELS, (PVOID*)GDIHandleLocker[HandleIndex], NULL); RtlCaptureStackBackTrace(1, GDI_STACK_LEVELS, (PVOID*)GDIHandleLocker[HandleIndex], NULL);
} }
#else #else
_InterlockedIncrement((PLONG)&GdiHdr->Locks); _InterlockedIncrement(Object->ulShareCount);
#endif #endif
Object = Entry->KernelData;
} }
else else
{ {
@ -1110,23 +1099,25 @@ GDIOBJ_ShareLockObj (PGDI_HANDLE_TABLE HandleTable, HGDIOBJ hObj, DWORD Expected
* \param Object Object pointer (as returned by GDIOBJ_LockObj). * \param Object Object pointer (as returned by GDIOBJ_LockObj).
*/ */
VOID INTERNAL_CALL VOID INTERNAL_CALL
GDIOBJ_UnlockObjByPtr(PGDI_HANDLE_TABLE HandleTable, PGDIOBJ Object) GDIOBJ_UnlockObjByPtr(POBJ Object)
{ {
PGDIOBJHDR GdiHdr = GDIBdyToHdr(Object); if (_InterlockedDecrement((PLONG)&Object->cExclusiveLock) < 0)
#ifdef GDI_DEBUG
if (_InterlockedDecrement((PLONG)&GdiHdr->Locks) == 0)
{ {
memset(GDIHandleLocker[GDI_HANDLE_GET_INDEX(Object)], 0x00, GDI_STACK_LEVELS * sizeof(ULONG));
RtlCaptureStackBackTrace(1, GDI_STACK_LEVELS, (PVOID*)GDIHandleLocker[GDI_HANDLE_GET_INDEX(Object)], NULL);
}
#else
if (_InterlockedDecrement((PLONG)&GdiHdr->Locks) < 0)
DPRINT1("Trying to unlock non-existant object\n"); DPRINT1("Trying to unlock non-existant object\n");
#endif }
}
VOID INTERNAL_CALL
GDIOBJ_ShareUnlockObjByPtr(POBJ Object)
{
if (_InterlockedDecrement((PLONG)&Object->ulShareCount) < 0)
{
DPRINT1("Trying to unlock non-existant object\n");
}
} }
BOOL INTERNAL_CALL BOOL INTERNAL_CALL
GDIOBJ_OwnedByCurrentProcess(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ ObjectHandle) GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle)
{ {
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
HANDLE ProcessId; HANDLE ProcessId;
@ -1138,7 +1129,7 @@ GDIOBJ_OwnedByCurrentProcess(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ ObjectHandle
{ {
ProcessId = PsGetCurrentProcessId(); ProcessId = PsGetCurrentProcessId();
Entry = GDI_HANDLE_GET_ENTRY(HandleTable, ObjectHandle); Entry = GDI_HANDLE_GET_ENTRY(GdiHandleTable, ObjectHandle);
Ret = Entry->KernelData != NULL && Ret = Entry->KernelData != NULL &&
(Entry->Type & ~GDI_ENTRY_REUSE_MASK) != 0 && (Entry->Type & ~GDI_ENTRY_REUSE_MASK) != 0 &&
(HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1) == ProcessId; (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1) == ProcessId;
@ -1150,7 +1141,7 @@ GDIOBJ_OwnedByCurrentProcess(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ ObjectHandle
} }
BOOL INTERNAL_CALL BOOL INTERNAL_CALL
GDIOBJ_ConvertToStockObj(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ *phObj) GDIOBJ_ConvertToStockObj(HGDIOBJ *phObj)
{ {
/* /*
* FIXME !!!!! THIS FUNCTION NEEDS TO BE FIXED - IT IS NOT SAFE WHEN OTHER THREADS * FIXME !!!!! THIS FUNCTION NEEDS TO BE FIXED - IT IS NOT SAFE WHEN OTHER THREADS
@ -1158,7 +1149,7 @@ GDIOBJ_ConvertToStockObj(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ *phObj)
*/ */
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
HANDLE ProcessId, LockedProcessId, PrevProcId; HANDLE ProcessId, LockedProcessId, PrevProcId;
PETHREAD Thread; PW32THREAD Thread;
HGDIOBJ hObj; HGDIOBJ hObj;
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
ULONG Attempts = 0; ULONG Attempts = 0;
@ -1169,14 +1160,14 @@ GDIOBJ_ConvertToStockObj(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ *phObj)
DPRINT("GDIOBJ_ConvertToStockObj: hObj: 0x%08x\n", hObj); DPRINT("GDIOBJ_ConvertToStockObj: hObj: 0x%08x\n", hObj);
Thread = PsGetCurrentThread(); Thread = PsGetCurrentThreadWin32Thread();
if(!GDI_HANDLE_IS_STOCKOBJ(hObj)) if(!GDI_HANDLE_IS_STOCKOBJ(hObj))
{ {
ProcessId = PsGetCurrentProcessId(); ProcessId = PsGetCurrentProcessId();
LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1); LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1);
Entry = GDI_HANDLE_GET_ENTRY(HandleTable, hObj); Entry = GDI_HANDLE_GET_ENTRY(GdiHandleTable, hObj);
LockHandle: LockHandle:
/* lock the object, we must not convert stock objects, so don't check!!! */ /* lock the object, we must not convert stock objects, so don't check!!! */
@ -1203,17 +1194,17 @@ LockHandle:
PrevType = _InterlockedCompareExchange(&Entry->Type, NewType, OldType); PrevType = _InterlockedCompareExchange(&Entry->Type, NewType, OldType);
if(PrevType == OldType && Entry->KernelData != NULL) if(PrevType == OldType && Entry->KernelData != NULL)
{ {
PETHREAD PrevThread; PW32THREAD PrevThread;
PGDIOBJHDR GdiHdr; POBJ Object;
/* We successfully set the stock object flag. /* We successfully set the stock object flag.
KernelData should never be NULL here!!! */ KernelData should never be NULL here!!! */
ASSERT(Entry->KernelData); ASSERT(Entry->KernelData);
GdiHdr = GDIBdyToHdr(Entry->KernelData); Object = Entry->KernelData;
PrevThread = GdiHdr->LockingThread; PrevThread = Object->Tid;
if(GdiHdr->Locks == 0 || PrevThread == Thread) if(Object->cExclusiveLock == 0 || PrevThread == Thread)
{ {
/* dereference the process' object counter */ /* dereference the process' object counter */
if(PrevProcId != GDI_GLOBAL_PROCESS) if(PrevProcId != GDI_GLOBAL_PROCESS)
@ -1248,12 +1239,9 @@ LockHandle:
{ {
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
if(++Attempts > 20) if(++Attempts > 20)
{
if(GdiHdr->lockfile != NULL)
{ {
DPRINT1("[%d]Locked by 0x%x (we're 0x%x)\n", Attempts, PrevThread, Thread); DPRINT1("[%d]Locked by 0x%x (we're 0x%x)\n", Attempts, PrevThread, Thread);
} }
}
#endif #endif
/* WTF?! The object is already locked by a different thread! /* WTF?! The object is already locked by a different thread!
Release the lock, wait a bit and try again! Release the lock, wait a bit and try again!
@ -1294,39 +1282,39 @@ LockHandle:
} }
void INTERNAL_CALL void INTERNAL_CALL
GDIOBJ_SetOwnership(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ ObjectHandle, PEPROCESS NewOwner) GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS NewOwner)
{ {
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
HANDLE ProcessId, LockedProcessId, PrevProcId; HANDLE ProcessId, LockedProcessId, PrevProcId;
PETHREAD Thread; PW32THREAD Thread;
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
ULONG Attempts = 0; ULONG Attempts = 0;
#endif #endif
DPRINT("GDIOBJ_SetOwnership: hObj: 0x%x, NewProcess: 0x%x\n", ObjectHandle, (NewOwner ? PsGetProcessId(NewOwner) : 0)); DPRINT("GDIOBJ_SetOwnership: hObj: 0x%x, NewProcess: 0x%x\n", ObjectHandle, (NewOwner ? PsGetProcessId(NewOwner) : 0));
Thread = PsGetCurrentThread(); Thread = PsGetCurrentThreadWin32Thread();
if(!GDI_HANDLE_IS_STOCKOBJ(ObjectHandle)) if(!GDI_HANDLE_IS_STOCKOBJ(ObjectHandle))
{ {
ProcessId = PsGetCurrentProcessId(); ProcessId = PsGetCurrentProcessId();
LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1); LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1);
Entry = GDI_HANDLE_GET_ENTRY(HandleTable, ObjectHandle); Entry = GDI_HANDLE_GET_ENTRY(GdiHandleTable, ObjectHandle);
LockHandle: LockHandle:
/* lock the object, we must not convert stock objects, so don't check!!! */ /* lock the object, we must not convert stock objects, so don't check!!! */
PrevProcId = _InterlockedCompareExchangePointer((PVOID*)&Entry->ProcessId, ProcessId, LockedProcessId); PrevProcId = _InterlockedCompareExchangePointer((PVOID*)&Entry->ProcessId, ProcessId, LockedProcessId);
if(PrevProcId == ProcessId) if(PrevProcId == ProcessId)
{ {
PETHREAD PrevThread; PW32THREAD PrevThread;
if((Entry->Type & ~GDI_ENTRY_REUSE_MASK) != 0 && Entry->KernelData != NULL) if((Entry->Type & ~GDI_ENTRY_REUSE_MASK) != 0 && Entry->KernelData != NULL)
{ {
PGDIOBJHDR GdiHdr = GDIBdyToHdr(Entry->KernelData); POBJ Object = Entry->KernelData;
PrevThread = GdiHdr->LockingThread; PrevThread = Object->Tid;
if(GdiHdr->Locks == 0 || PrevThread == Thread) if(Object->cExclusiveLock == 0 || PrevThread == Thread)
{ {
PEPROCESS OldProcess; PEPROCESS OldProcess;
PW32PROCESS W32Process; PW32PROCESS W32Process;
@ -1427,10 +1415,10 @@ LockHandle:
} }
void INTERNAL_CALL void INTERNAL_CALL
GDIOBJ_CopyOwnership(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ CopyFrom, HGDIOBJ CopyTo) GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo)
{ {
PGDI_TABLE_ENTRY FromEntry; PGDI_TABLE_ENTRY FromEntry;
PETHREAD Thread; PW32THREAD Thread;
HANDLE FromProcessId, FromLockedProcessId, FromPrevProcId; HANDLE FromProcessId, FromLockedProcessId, FromPrevProcId;
#ifdef GDI_DEBUG #ifdef GDI_DEBUG
ULONG Attempts = 0; ULONG Attempts = 0;
@ -1438,11 +1426,11 @@ GDIOBJ_CopyOwnership(PGDI_HANDLE_TABLE HandleTable, HGDIOBJ CopyFrom, HGDIOBJ Co
DPRINT("GDIOBJ_CopyOwnership: from: 0x%x, to: 0x%x\n", CopyFrom, CopyTo); DPRINT("GDIOBJ_CopyOwnership: from: 0x%x, to: 0x%x\n", CopyFrom, CopyTo);
Thread = PsGetCurrentThread(); Thread = PsGetCurrentThreadWin32Thread();
if(!GDI_HANDLE_IS_STOCKOBJ(CopyFrom) && !GDI_HANDLE_IS_STOCKOBJ(CopyTo)) if(!GDI_HANDLE_IS_STOCKOBJ(CopyFrom) && !GDI_HANDLE_IS_STOCKOBJ(CopyTo))
{ {
FromEntry = GDI_HANDLE_GET_ENTRY(HandleTable, CopyFrom); FromEntry = GDI_HANDLE_GET_ENTRY(GdiHandleTable, CopyFrom);
FromProcessId = (HANDLE)((ULONG_PTR)FromEntry->ProcessId & ~0x1); FromProcessId = (HANDLE)((ULONG_PTR)FromEntry->ProcessId & ~0x1);
FromLockedProcessId = (HANDLE)((ULONG_PTR)FromProcessId | 0x1); FromLockedProcessId = (HANDLE)((ULONG_PTR)FromProcessId | 0x1);
@ -1452,17 +1440,17 @@ LockHandleFrom:
FromPrevProcId = _InterlockedCompareExchangePointer((PVOID*)&FromEntry->ProcessId, FromProcessId, FromLockedProcessId); FromPrevProcId = _InterlockedCompareExchangePointer((PVOID*)&FromEntry->ProcessId, FromProcessId, FromLockedProcessId);
if(FromPrevProcId == FromProcessId) if(FromPrevProcId == FromProcessId)
{ {
PETHREAD PrevThread; PW32THREAD PrevThread;
PGDIOBJHDR GdiHdr; POBJ Object;
if((FromEntry->Type & ~GDI_ENTRY_REUSE_MASK) != 0 && FromEntry->KernelData != NULL) if((FromEntry->Type & ~GDI_ENTRY_REUSE_MASK) != 0 && FromEntry->KernelData != NULL)
{ {
GdiHdr = GDIBdyToHdr(FromEntry->KernelData); Object = FromEntry->KernelData;
/* save the pointer to the calling thread so we know it was this thread /* save the pointer to the calling thread so we know it was this thread
that locked the object */ that locked the object */
PrevThread = GdiHdr->LockingThread; PrevThread = Object->Tid;
if(GdiHdr->Locks == 0 || PrevThread == Thread) if(Object->cExclusiveLock == 0 || PrevThread == Thread)
{ {
/* now let's change the ownership of the target object */ /* now let's change the ownership of the target object */
@ -1472,14 +1460,14 @@ LockHandleFrom:
/* FIXME */ /* FIXME */
if(NT_SUCCESS(PsLookupProcessByProcessId((HANDLE)((ULONG_PTR)FromPrevProcId & ~0x1), &ProcessTo))) if(NT_SUCCESS(PsLookupProcessByProcessId((HANDLE)((ULONG_PTR)FromPrevProcId & ~0x1), &ProcessTo)))
{ {
GDIOBJ_SetOwnership(HandleTable, CopyTo, ProcessTo); GDIOBJ_SetOwnership(CopyTo, ProcessTo);
ObDereferenceObject(ProcessTo); ObDereferenceObject(ProcessTo);
} }
} }
else else
{ {
/* mark the object as global */ /* mark the object as global */
GDIOBJ_SetOwnership(HandleTable, CopyTo, NULL); GDIOBJ_SetOwnership(CopyTo, NULL);
} }
(void)_InterlockedExchangePointer((PVOID*)&FromEntry->ProcessId, FromPrevProcId); (void)_InterlockedExchangePointer((PVOID*)&FromEntry->ProcessId, FromPrevProcId);
@ -1580,7 +1568,7 @@ NtGdiCreateClientObj(
// //
INT Index; INT Index;
PGDI_TABLE_ENTRY Entry; PGDI_TABLE_ENTRY Entry;
HANDLE handle = GDIOBJ_AllocObj(GdiHandleTable, GDI_OBJECT_TYPE_CLIOBJ); HANDLE handle = GDIOBJ_AllocObj(GDI_OBJECT_TYPE_CLIOBJ);
// Need to change handle type based on ulType. // Need to change handle type based on ulType.
Index = GDI_HANDLE_GET_INDEX((HGDIOBJ)handle); Index = GDI_HANDLE_GET_INDEX((HGDIOBJ)handle);
Entry = &GdiHandleTable->Entries[Index]; Entry = &GdiHandleTable->Entries[Index];
@ -1600,7 +1588,7 @@ NtGdiDeleteClientObj(
IN HANDLE h IN HANDLE h
) )
{ {
return GDIOBJ_FreeObj(GdiHandleTable, h, GDI_OBJECT_TYPE_CLIOBJ); return GDIOBJ_FreeObj(h, GDI_OBJECT_TYPE_CLIOBJ);
} }
/* EOF */ /* EOF */

4
reactos/subsystems/win32/win32k/objects/palobj.c
View file

@ -63,7 +63,7 @@ PALETTE_AllocPalette(ULONG Mode,
HPALETTE NewPalette; HPALETTE NewPalette;
PPALGDI PalGDI; PPALGDI PalGDI;
NewPalette = (HPALETTE) GDIOBJ_AllocObj(GdiHandleTable, GDI_OBJECT_TYPE_PALETTE); NewPalette = (HPALETTE) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_PALETTE);
if (NULL == NewPalette) if (NULL == NewPalette)
{ {
return NULL; return NULL;
@ -112,7 +112,7 @@ PALETTE_AllocPaletteIndexedRGB(ULONG NumColors,
PPALGDI PalGDI; PPALGDI PalGDI;
unsigned i; unsigned i;
NewPalette = (HPALETTE) GDIOBJ_AllocObj(GdiHandleTable, GDI_OBJECT_TYPE_PALETTE); NewPalette = (HPALETTE) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_PALETTE);
if (NULL == NewPalette) if (NULL == NewPalette)
{ {
return NULL; return NULL;

2
reactos/subsystems/win32/win32k/objects/region.c
View file

@ -2088,7 +2088,7 @@ RGNDATA_AllocRgn(INT n)
HRGN hReg; HRGN hReg;
PROSRGNDATA pReg; PROSRGNDATA pReg;
if ((hReg = (HRGN) GDIOBJ_AllocObj(GdiHandleTable, GDI_OBJECT_TYPE_REGION))) if ((hReg = (HRGN) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_REGION)))
{ {
if (NULL != (pReg = RGNDATA_LockRgn(hReg))) if (NULL != (pReg = RGNDATA_LockRgn(hReg)))
{ {

6
reactos/subsystems/win32/win32k/objects/stockobj.c
View file

@ -149,7 +149,7 @@ CreateStockObjects(void)
{ {
if (NULL != StockObjects[Object]) if (NULL != StockObjects[Object])
{ {
GDIOBJ_ConvertToStockObj(GdiHandleTable, &StockObjects[Object]); GDIOBJ_ConvertToStockObj(&StockObjects[Object]);
} }
} }
@ -284,7 +284,7 @@ CreateSysColorObjects(VOID)
SysColorBrushes[i] = IntGdiCreateSolidBrush(SysColors[i]); SysColorBrushes[i] = IntGdiCreateSolidBrush(SysColors[i]);
if(SysColorBrushes[i] != NULL) if(SysColorBrushes[i] != NULL)
{ {
GDIOBJ_ConvertToStockObj(GdiHandleTable, (HGDIOBJ*)&SysColorBrushes[i]); GDIOBJ_ConvertToStockObj((HGDIOBJ*)&SysColorBrushes[i]);
} }
} }
} }
@ -301,7 +301,7 @@ CreateSysColorObjects(VOID)
SysColorPens[i] = IntGdiExtCreatePen(Pen.lopnStyle, Pen.lopnWidth.x, BS_SOLID, Pen.lopnColor, 0, 0, 0, NULL, 0, TRUE, NULL); SysColorPens[i] = IntGdiExtCreatePen(Pen.lopnStyle, Pen.lopnWidth.x, BS_SOLID, Pen.lopnColor, 0, 0, 0, NULL, 0, TRUE, NULL);
if(SysColorPens[i] != NULL) if(SysColorPens[i] != NULL)
{ {
GDIOBJ_ConvertToStockObj(GdiHandleTable, (HGDIOBJ*)&SysColorPens[i]); GDIOBJ_ConvertToStockObj((HGDIOBJ*)&SysColorPens[i]);
} }
} }
} }