gdiobj.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_GDI_HANDLE_TABLE
struct	_BASEOBJECT
struct	_CLIENTOBJ

Macros
#define	GDI_OBJECT_STACK_LEVELS   20

Typedefs
typedef struct _GDI_HANDLE_TABLE	GDI_HANDLE_TABLE
typedef struct _GDI_HANDLE_TABLE *	PGDI_HANDLE_TABLE
typedef PVOID	PGDIOBJ
typedef VOID(NTAPI *	GDICLEANUPPROC) (PVOID ObjectBody)
typedef VOID(NTAPI *	GDIOBJDELETEPROC) (PVOID ObjectBody)
typedef struct _BASEOBJECT	BASEOBJECT
typedef struct _BASEOBJECT *	POBJ
typedef struct _CLIENTOBJ	CLIENTOBJ
typedef struct _CLIENTOBJ *	PCLIENTOBJ

Enumerations
enum	BASEFLAGS { BASEFLAG_LOOKASIDE = 0x80 , BASEFLAG_READY_TO_DIE = 0x1000 }
enum	_GDIOBJLAGS { GDIOBJFLAG_DEFAULT = 0x00 , GDIOBJFLAG_IGNOREPID = 0x01 , GDIOBJFLAG_IGNORELOCK = 0x02 }

Functions
NTSTATUS NTAPI	InitGdiHandleTable (VOID)
BOOL NTAPI	GreIsHandleValid (HGDIOBJ hobj)
BOOL NTAPI	GreDeleteObject (HGDIOBJ hObject)
ULONG NTAPI	GreGetObjectOwner (HGDIOBJ hobj)
BOOL NTAPI	GreSetObjectOwner (HGDIOBJ hobj, ULONG ulOwner)
BOOL NTAPI	GreSetObjectOwnerEx (HGDIOBJ hobj, ULONG ulOwner, ULONG Flags)
INT NTAPI	GreGetObject (IN HGDIOBJ hobj, IN INT cbCount, OUT PVOID pvBuffer)
POBJ NTAPI	GDIOBJ_AllocateObject (UCHAR objt, ULONG cjSize, FLONG fl)
VOID NTAPI	GDIOBJ_vDeleteObject (POBJ pobj)
POBJ NTAPI	GDIOBJ_ReferenceObjectByHandle (HGDIOBJ hobj, UCHAR objt)
VOID NTAPI	GDIOBJ_vReferenceObjectByPointer (POBJ pobj)
VOID NTAPI	GDIOBJ_vDereferenceObject (POBJ pobj)
PGDIOBJ NTAPI	GDIOBJ_LockObject (HGDIOBJ hobj, UCHAR objt)
PGDIOBJ NTAPI	GDIOBJ_TryLockObject (HGDIOBJ hobj, UCHAR objt)
VOID NTAPI	GDIOBJ_vUnlockObject (POBJ pobj)
VOID NTAPI	GDIOBJ_vSetObjectOwner (POBJ pobj, ULONG ulOwner)
BOOL NTAPI	GDIOBJ_bLockMultipleObjects (ULONG ulCount, HGDIOBJ *ahObj, PGDIOBJ *apObj, UCHAR objt)
HGDIOBJ NTAPI	GDIOBJ_hInsertObject (POBJ pobj, ULONG ulOwner)
VOID NTAPI	GDIOBJ_vFreeObject (POBJ pobj)
VOID NTAPI	GDIOBJ_vSetObjectAttr (POBJ pobj, PVOID pvObjAttr)
PVOID NTAPI	GDIOBJ_pvGetObjectAttr (POBJ pobj)
BOOL NTAPI	GDIOBJ_ConvertToStockObj (HGDIOBJ *hObj)
BOOL NTAPI	GDIOBJ_ConvertFromStockObj (HGDIOBJ *phObj)
POBJ NTAPI	GDIOBJ_AllocObjWithHandle (ULONG ObjectType, ULONG cjSize)
PGDIOBJ NTAPI	GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ObjectType)
PVOID NTAPI	GDI_MapHandleTable (PEPROCESS Process)

Variables
static const unsigned	RESERVE_ENTRIES_COUNT = 10
PGDI_HANDLE_TABLE	GdiHandleTable

Macro Definition Documentation

GDI_OBJECT_STACK_LEVELS

#define GDI_OBJECT_STACK_LEVELS   20

Definition at line 8 of file gdiobj.h.

Typedef Documentation

BASEOBJECT

typedef struct _BASEOBJECT BASEOBJECT

CLIENTOBJ

typedef struct _CLIENTOBJ CLIENTOBJ

GDI_HANDLE_TABLE

typedef struct _GDI_HANDLE_TABLE GDI_HANDLE_TABLE

GDICLEANUPPROC

typedef VOID(NTAPI * GDICLEANUPPROC) (PVOID ObjectBody)

Definition at line 33 of file gdiobj.h.

GDIOBJDELETEPROC

typedef VOID(NTAPI * GDIOBJDELETEPROC) (PVOID ObjectBody)

Definition at line 34 of file gdiobj.h.

PCLIENTOBJ

typedef struct _CLIENTOBJ * PCLIENTOBJ

PGDI_HANDLE_TABLE

typedef struct _GDI_HANDLE_TABLE * PGDI_HANDLE_TABLE

PGDIOBJ

typedef PVOID PGDIOBJ

Definition at line 31 of file gdiobj.h.

POBJ

typedef struct _BASEOBJECT * POBJ

Enumeration Type Documentation

_GDIOBJLAGS

enum _GDIOBJLAGS

Enumerator
GDIOBJFLAG_DEFAULT
GDIOBJFLAG_IGNOREPID
GDIOBJFLAG_IGNORELOCK

Definition at line 69 of file gdiobj.h.

{
    GDIOBJFLAG_DEFAULT    = 0x00,
    GDIOBJFLAG_IGNOREPID  = 0x01,
    GDIOBJFLAG_IGNORELOCK = 0x02
};

BASEFLAGS

enum BASEFLAGS

Enumerator
BASEFLAG_LOOKASIDE
BASEFLAG_READY_TO_DIE

Definition at line 56 of file gdiobj.h.

{
    BASEFLAG_LOOKASIDE = 0x80,
 
    /* ReactOS specific: */
    BASEFLAG_READY_TO_DIE = 0x1000
};

Function Documentation

GDI_MapHandleTable()

PVOID NTAPI GDI_MapHandleTable

(

PEPROCESS

Process

)

Definition at line 1565 of file gdiobj.c.

{
    PVOID pvMappedView = NULL;
    NTSTATUS Status;
    LARGE_INTEGER liOffset;
    SIZE_T cjViewSize = sizeof(GDI_HANDLE_TABLE);
 
    liOffset.QuadPart = 0;
 
    ASSERT(gpvGdiHdlTblSection != NULL);
    ASSERT(pProcess != NULL);
 
    Status = MmMapViewOfSection(gpvGdiHdlTblSection,
                                pProcess,
                                &pvMappedView,
                                0,
                                0,
                                &liOffset,
                                &cjViewSize,
                                ViewUnmap,
                                SEC_NO_CHANGE,
                                PAGE_READONLY);
 
    if (!NT_SUCCESS(Status))
        return NULL;
 
    return pvMappedView;
}

Referenced by GdiProcessCreate().

GDIOBJ_AllocateObject()

POBJ NTAPI GDIOBJ_AllocateObject	(	UCHAR	objt,
		ULONG	cjSize,
		FLONG	fl
	)

Definition at line 569 of file gdiobj.c.

{
    POBJ pobj;
 
    if (fl & BASEFLAG_LOOKASIDE)
    {
        /* Allocate the object from a lookaside list */
        pobj = ExAllocateFromPagedLookasideList(&gpaLookasideList[objt & 0x1f]);
    }
    else
    {
        /* Allocate the object from paged pool */
        pobj = ExAllocatePoolWithTag(PagedPool, cjSize, GDIOBJ_POOL_TAG(objt));
    }
 
    if (!pobj) return NULL;
 
    /* Initialize the object */
    RtlZeroMemory(pobj, cjSize);
    pobj->hHmgr = (HGDIOBJ)((ULONG_PTR)objt << 16);
    pobj->cExclusiveLock = 0;
    pobj->ulShareCount = 1;
    pobj->BaseFlags = fl & 0xffff;
    DBG_INITLOG(&pobj->slhLog);
    DBG_LOGEVENT(&pobj->slhLog, EVENT_ALLOCATE, 0);
#if DBG_ENABLE_GDIOBJ_BACKTRACES
    DbgCaptureStackBackTace(pobj->apvBackTrace, 1, GDI_OBJECT_STACK_LEVELS);
#endif /* GDI_DEBUG */
 
    return pobj;
}

Referenced by DC_AllocDcWithHandle(), GDIOBJ_AllocObjWithHandle(), IntSysCreateRectpRgn(), NtGdiCreateClientObj(), PALETTE_AllocPalette(), and REGION_AllocRgnWithHandle().

GDIOBJ_AllocObjWithHandle()

POBJ NTAPI GDIOBJ_AllocObjWithHandle	(	ULONG	ObjectType,
		ULONG	cjSize
	)

Definition at line 1535 of file gdiobj.c.

{
    POBJ pobj;
    FLONG fl = 0;
    UCHAR objt = (ObjectType >> 16) & 0xFF;
 
    if ((objt == GDIObjType_DC_TYPE && cjSize == sizeof(DC)) ||
        (objt == GDIObjType_PAL_TYPE && cjSize == sizeof(PALETTE)) ||
        (objt == GDIObjType_RGN_TYPE && cjSize == sizeof(REGION)) ||
        (objt == GDIObjType_SURF_TYPE && cjSize == sizeof(SURFACE)) ||
        (objt == GDIObjType_PATH_TYPE && cjSize == sizeof(PATH)))
    {
        fl |= BASEFLAG_LOOKASIDE;
    }
 
    pobj = GDIOBJ_AllocateObject(objt, cjSize, fl);
    if (!pobj)
    {
        return NULL;
    }
 
    if (!GDIOBJ_hInsertObject(pobj, GDI_OBJ_HMGR_POWNED))
    {
        GDIOBJ_vFreeObject(pobj);
        return NULL;
    }
    return pobj;
}

Referenced by NtGdiCreateServerMetaFile(), PEN_AllocExtPenWithHandle(), PEN_AllocPenWithHandle(), and SURFACE_AllocSurface().

GDIOBJ_bLockMultipleObjects()

BOOL NTAPI GDIOBJ_bLockMultipleObjects	(	ULONG	ulCount,
		HGDIOBJ *	ahObj,
		PGDIOBJ *	apObj,
		UCHAR	objt
	)

GDIOBJ_ConvertFromStockObj()

BOOL NTAPI GDIOBJ_ConvertFromStockObj

(

HGDIOBJ *

phObj

)

Definition at line 1502 of file gdiobj.c.

{
    PENTRY pentry;
    POBJ pobj;
 
    /* Reference the handle entry */
    pentry = ENTRY_ReferenceEntryByHandle(*phObj, 0);
    if (!pentry)
    {
        DPRINT1("GDIOBJ: Requested handle 0x%p is not valid.\n", *phObj);
        return FALSE;
    }
 
    /* Update the entry */
    pentry->FullUnique &= ~GDI_ENTRY_STOCK_MASK;
    pentry->ObjectOwner.ulObj = PtrToUlong(PsGetCurrentProcessId());
 
    /* Get the pointer to the BASEOBJECT */
    pobj = pentry->einfo.pobj;
 
    /* Calculate the new handle */
    pobj->hHmgr = (HGDIOBJ)((ULONG_PTR)pobj->hHmgr & ~GDI_HANDLE_STOCK_MASK);
 
    /* Return the new handle */
    *phObj = pobj->hHmgr;
 
    /* Dereference the handle */
    GDIOBJ_vDereferenceObject(pobj);
 
    return TRUE;
}

Referenced by NtGdiClearBitmapAttributes(), and NtGdiClearBrushAttributes().

GDIOBJ_ConvertToStockObj()

BOOL NTAPI GDIOBJ_ConvertToStockObj

(

HGDIOBJ *

hObj

)

Definition at line 1468 of file gdiobj.c.

{
    PENTRY pentry;
    POBJ pobj;
 
    /* Reference the handle entry */
    pentry = ENTRY_ReferenceEntryByHandle(*phObj, 0);
    if (!pentry)
    {
        DPRINT1("GDIOBJ: Requested handle 0x%p is not valid.\n", *phObj);
        return FALSE;
    }
 
    /* Update the entry */
    pentry->FullUnique |= GDI_ENTRY_STOCK_MASK;
    pentry->ObjectOwner.ulObj = 0;
 
    /* Get the pointer to the BASEOBJECT */
    pobj = pentry->einfo.pobj;
 
    /* Calculate the new handle */
    pobj->hHmgr = (HGDIOBJ)((ULONG_PTR)pobj->hHmgr | GDI_HANDLE_STOCK_MASK);
 
    /* Return the new handle */
    *phObj = pobj->hHmgr;
 
    /* Dereference the handle */
    GDIOBJ_vDereferenceObject(pobj);
 
    return TRUE;
}

Referenced by CreateStockObjects(), CreateSysColorObjects(), NtGdiSetBitmapAttributes(), and NtGdiSetBrushAttributes().

GDIOBJ_hInsertObject()

HGDIOBJ NTAPI GDIOBJ_hInsertObject	(	POBJ	pobj,
		ULONG	ulOwner
	)

Definition at line 919 of file gdiobj.c.

{
    PENTRY pentry;
    UCHAR objt;
 
    /* Must have no handle and only one reference */
    ASSERT(GDI_HANDLE_GET_INDEX(pobj->hHmgr) == 0);
    ASSERT(pobj->cExclusiveLock == 0);
    ASSERT(pobj->ulShareCount == 1);
 
    /* Get a free handle entry */
    pentry = ENTRY_pentPopFreeEntry();
    if (!pentry)
    {
        DPRINT1("GDIOBJ: Could not get a free entry.\n");
        return NULL;
    }
 
    /* Make the object exclusively locked */
    ExInitializePushLock(&pobj->pushlock);
    KeEnterCriticalRegion();
    ExAcquirePushLockExclusive(&pobj->pushlock);
    pobj->cExclusiveLock = 1;
    pobj->dwThreadId = PtrToUlong(PsGetCurrentThreadId());
    INCREASE_THREAD_LOCK_COUNT(pobj->hHmgr);
 
    /* Get object type from the hHmgr field */
    objt = ((ULONG_PTR)pobj->hHmgr >> 16) & 0xff;
    ASSERT(objt != GDIObjType_DEF_TYPE);
 
    /* Check if current process is requested owner */
    if (ulOwner == GDI_OBJ_HMGR_POWNED)
    {
        /* Increment the process handle count */
        IncrementCurrentProcessGdiHandleCount();
 
        /* Use Process id */
        ulOwner = HandleToUlong(PsGetCurrentProcessId());
    }
 
    /* Insert the object into the handle table */
    pobj->hHmgr = ENTRY_hInsertObject(pentry, pobj, objt, ulOwner);
 
    /* Return the handle */
    DPRINT("GDIOBJ: Created handle: %p\n", pobj->hHmgr);
    DBG_LOGEVENT(&pobj->slhLog, EVENT_CREATE_HANDLE, 0);
    return pobj->hHmgr;
}

Referenced by DC_AllocDcWithHandle(), EngCreatePalette(), GDIOBJ_AllocObjWithHandle(), BASEOBJECT::hInsertObject(), NtGdiCreateClientObj(), PALETTE_AllocPalWithHandle(), and REGION_AllocRgnWithHandle().

GDIOBJ_LockObject()

PGDIOBJ NTAPI GDIOBJ_LockObject	(	HGDIOBJ	hobj,
		UCHAR	objt
	)

Definition at line 833 of file gdiobj.c.

{
    PENTRY pentry;
    POBJ pobj;
    DWORD dwThreadId;
 
    /* Check if the handle type matches */
    ASSERT_EXCLUSIVE_OBJECT_TYPE(objt);
    if ((((ULONG_PTR)hobj >> 16) & 0x1f) != objt)
    {
        DPRINT("Wrong object type: hobj=0x%p, objt=0x%x\n", hobj, objt);
        return NULL;
    }
 
    /* Make sure lock order is correct */
    ASSERT_LOCK_ORDER(objt);
 
    /* Reference the handle entry */
    pentry = ENTRY_ReferenceEntryByHandle(hobj, 0);
    if (!pentry)
    {
        DPRINT("GDIOBJ: Requested handle 0x%p is not valid.\n", hobj);
        return NULL;
    }
 
    /* Get the pointer to the BASEOBJECT */
    pobj = pentry->einfo.pobj;
 
    /* Check if we already own the lock */
    dwThreadId = PtrToUlong(PsGetCurrentThreadId());
    if (pobj->dwThreadId != dwThreadId)
    {
        /* Disable APCs and acquire the push lock */
        KeEnterCriticalRegion();
        ExAcquirePushLockExclusive(&pobj->pushlock);
 
        /* Set us as lock owner */
        ASSERT(pobj->dwThreadId == 0);
        pobj->dwThreadId = dwThreadId;
    }
 
    /* Increase lock count */
    pobj->cExclusiveLock++;
    INCREASE_THREAD_LOCK_COUNT(hobj);
    DBG_LOGEVENT(&pobj->slhLog, EVENT_LOCK, 0);
 
    /* Return the object */
    return pobj;
}

Referenced by DC_LockDc(), GDIOBJ_bLockMultipleObjects(), NtGdiGetServerMetaFileBits(), and REGION_LockRgn().

GDIOBJ_pvGetObjectAttr()

PVOID NTAPI GDIOBJ_pvGetObjectAttr

(

POBJ

pobj

)

Definition at line 1095 of file gdiobj.c.

{
    ULONG ulIndex = GDI_HANDLE_GET_INDEX(pobj->hHmgr);
    return gpentHmgr[ulIndex].pUser;
}

GDIOBJ_ReferenceObjectByHandle()

POBJ NTAPI GDIOBJ_ReferenceObjectByHandle	(	HGDIOBJ	hobj,
		UCHAR	objt
	)

Definition at line 698 of file gdiobj.c.

{
    PENTRY pentry;
    POBJ pobj;
 
    /* Check if the handle type matches */
    ASSERT_SHARED_OBJECT_TYPE(objt);
    if ((((ULONG_PTR)hobj >> 16) & 0x1f) != objt)
    {
        DPRINT("GDIOBJ: Wrong type. handle=%p, type=%x\n", hobj, objt);
        return NULL;
    }
 
    /* Reference the handle entry */
    pentry = ENTRY_ReferenceEntryByHandle(hobj, 0);
    if (!pentry)
    {
        DPRINT("GDIOBJ: Requested handle 0x%p is not valid.\n", hobj);
        return NULL;
    }
 
    /* Get the pointer to the BASEOBJECT */
    pobj = pentry->einfo.pobj;
 
    /* Check if the object is exclusively locked */
    if (pobj->cExclusiveLock != 0)
    {
        DPRINT1("GDIOBJ: Cannot reference object %p with exclusive lock.\n", hobj);
        GDIOBJ_vDereferenceObject(pobj);
        DBG_DUMP_EVENT_LIST(&pobj->slhLog);
        return NULL;
    }
 
    DBG_LOGEVENT(&pobj->slhLog, EVENT_REFERENCE, gpaulRefCount[pentry - gpentHmgr]);
 
    /* All is well, return the object */
    return pobj;
}

Referenced by GDIOBJ_ShareLockObj(), GreGetObject(), and PEN_ShareLockPen().

GDIOBJ_ShareLockObj()

PGDIOBJ NTAPI GDIOBJ_ShareLockObj	(	HGDIOBJ	hObj,
		DWORD	ObjectType
	)

Definition at line 1456 of file gdiobj.c.

{
    if (ExpectedType == GDI_OBJECT_TYPE_DONTCARE)
        ExpectedType = GDI_HANDLE_GET_TYPE(hObj);
    return GDIOBJ_ReferenceObjectByHandle(hObj, (ExpectedType >> 16) & 0x1f);
}

Referenced by BASEOBJECT::LockShared().

GDIOBJ_TryLockObject()

PGDIOBJ NTAPI GDIOBJ_TryLockObject	(	HGDIOBJ	hobj,
		UCHAR	objt
	)

Definition at line 764 of file gdiobj.c.

{
    PENTRY pentry;
    POBJ pobj;
    DWORD dwThreadId;
 
    /* Check if the handle type matches */
    ASSERT_TRYLOCK_OBJECT_TYPE(objt);
    if ((((ULONG_PTR)hobj >> 16) & 0x1f) != objt)
    {
        DPRINT("Wrong object type: hobj=0x%p, objt=0x%x\n", hobj, objt);
        return NULL;
    }
 
    /* Make sure lock order is correct */
    ASSERT_LOCK_ORDER(objt);
 
    /* Reference the handle entry */
    pentry = ENTRY_ReferenceEntryByHandle(hobj, 0);
    if (!pentry)
    {
        DPRINT("GDIOBJ: Requested handle 0x%p is not valid.\n", hobj);
        return NULL;
    }
 
    /* Get the pointer to the BASEOBJECT */
    pobj = pentry->einfo.pobj;
 
    /* Check if we already own the lock */
    dwThreadId = PtrToUlong(PsGetCurrentThreadId());
    if (pobj->dwThreadId != dwThreadId)
    {
        /* Disable APCs and try acquiring the push lock */
        KeEnterCriticalRegion();
        if(!ExTryAcquirePushLockExclusive(&pobj->pushlock))
        {
            ULONG cRefs, ulIndex;
            /* Already owned. Clean up and leave. */
            KeLeaveCriticalRegion();
 
            /* Calculate the index */
            ulIndex = GDI_HANDLE_GET_INDEX(pobj->hHmgr);
 
            /* Decrement reference count */
            ASSERT((gpaulRefCount[ulIndex] & REF_MASK_COUNT) > 0);
            cRefs = InterlockedDecrement((LONG*)&gpaulRefCount[ulIndex]);
            ASSERT(cRefs & REF_MASK_VALID);
 
            return NULL;
        }
 
        /* Set us as lock owner */
        ASSERT(pobj->dwThreadId == 0);
        pobj->dwThreadId = dwThreadId;
    }
 
    /* Increase lock count */
    pobj->cExclusiveLock++;
    INCREASE_THREAD_LOCK_COUNT(hobj);
    DBG_LOGEVENT(&pobj->slhLog, EVENT_LOCK, 0);
 
    /* Return the object */
    return pobj;
}

Referenced by DRIVEROBJ_TryLockObject().

GDIOBJ_vDeleteObject()

VOID NTAPI GDIOBJ_vDeleteObject

(

POBJ

pobj

)

Definition at line 1118 of file gdiobj.c.

{
    ULONG ulIndex;
 
    /* Set the object's delete flag */
    InterlockedOr16((SHORT*)&pobj->BaseFlags, BASEFLAG_READY_TO_DIE);
    DBG_LOGEVENT(&pobj->slhLog, EVENT_DELETE, 0);
 
    /* Get the handle index */
    ulIndex = GDI_HANDLE_GET_INDEX(pobj->hHmgr);
    if (ulIndex)
    {
        /* Reset the handle valid bit */
        InterlockedAnd((LONG*)&gpaulRefCount[ulIndex], ~REF_MASK_VALID);
 
        /* Check if the object is exclusively locked */
        if (pobj->cExclusiveLock != 0)
        {
            /* Reset lock owner and lock count */
            pobj->dwThreadId = 0;
            pobj->cExclusiveLock = 0;
 
            /* Release the pushlock and reenable APCs */
            ExReleasePushLockExclusive(&pobj->pushlock);
            KeLeaveCriticalRegion();
            DECREASE_THREAD_LOCK_COUNT(pobj->hHmgr);
        }
    }
 
    /* Dereference the object (will take care of deletion) */
    GDIOBJ_vDereferenceObject(pobj);
}

Referenced by EngDeleteDriverObj(), EngDeletePalette(), EngDeletePath(), EngDeleteSurface(), GDI_CleanupForProcess(), GreDeleteObject(), IntEngMaskBlt(), IntGdiExtCreatePen(), NtGdiCreateBitmap(), NtGdiCreatePaletteInternal(), NtGdiCreateServerMetaFile(), NtGdiGetPixel(), PATH_Delete(), REGION_AllocRgnWithHandle(), REGION_Delete(), SURFACE_AllocSurface(), and UserDrawIconEx().

GDIOBJ_vDereferenceObject()

VOID NTAPI GDIOBJ_vDereferenceObject

(

POBJ

pobj

)

Definition at line 638 of file gdiobj.c.

{
    ULONG cRefs, ulIndex;
 
    /* Calculate the index */
    ulIndex = GDI_HANDLE_GET_INDEX(pobj->hHmgr);
 
    /* Check if the object has a handle */
    if (ulIndex)
    {
        /* Decrement reference count */
        if ((gpaulRefCount[ulIndex] & REF_MASK_COUNT) == 0)
        {
            DBG_DUMP_EVENT_LIST(&pobj->slhLog);
        }
        ASSERT((gpaulRefCount[ulIndex] & REF_MASK_COUNT) > 0);
        cRefs = InterlockedDecrement((LONG*)&gpaulRefCount[ulIndex]);
        DBG_LOGEVENT(&pobj->slhLog, EVENT_DEREFERENCE, cRefs);
 
        /* Check if we reached 0 and handle bit is not set */
        if ((cRefs & REF_MASK_INUSE) == 0)
        {
            /* Make sure it's ok to delete the object */
            ASSERT(pobj->BaseFlags & BASEFLAG_READY_TO_DIE);
 
            /* Check if the handle was process owned */
            if (gpentHmgr[ulIndex].ObjectOwner.ulObj != GDI_OBJ_HMGR_PUBLIC &&
                gpentHmgr[ulIndex].ObjectOwner.ulObj != GDI_OBJ_HMGR_NONE)
            {
                /* Decrement the process handle count */
                ASSERT(gpentHmgr[ulIndex].ObjectOwner.ulObj ==
                       HandleToUlong(PsGetCurrentProcessId()));
                DecrementCurrentProcessGdiHandleCount();
            }
 
            /* Push entry to the free list */
            ENTRY_vPushFreeEntry(&gpentHmgr[ulIndex]);
 
            /* Free the object */
            GDIOBJ_vFreeObject(pobj);
        }
    }
    else
    {
        /* Decrement the objects reference count */
        ASSERT(pobj->ulShareCount > 0);
        cRefs = InterlockedDecrement((LONG*)&pobj->ulShareCount);
        DBG_LOGEVENT(&pobj->slhLog, EVENT_DEREFERENCE, cRefs);
 
        /* Check if we reached 0 */
        if (cRefs == 0)
        {
            /* Free the object */
            GDIOBJ_vFreeObject(pobj);
        }
    }
}

Referenced by GDIOBJ_ConvertFromStockObj(), GDIOBJ_ConvertToStockObj(), GDIOBJ_ReferenceObjectByHandle(), GDIOBJ_vDeleteObject(), GreDeleteObject(), GreGetObject(), GreIsHandleValid(), GreSetObjectOwnerEx(), NtGdiSetColorSpace(), SURFACE_vSetPalette(), and BASEOBJECT::vUnlock().

GDIOBJ_vFreeObject()

VOID NTAPI GDIOBJ_vFreeObject

(

POBJ

pobj

)

Definition at line 603 of file gdiobj.c.

{
    UCHAR objt;
 
    DBG_CLEANUP_EVENT_LIST(&pobj->slhLog);
 
    /* Get the object type */
    objt = ((ULONG_PTR)pobj->hHmgr >> 16) & 0x1f;
 
    /* Check if we have a delete procedure (for C++ based objects) */
    if (apfnDelete[objt] != NULL)
    {
        /* Invoke the delete procedure */
        apfnDelete[objt](pobj);
    }
    else
    {
        /* Call the cleanup procedure */
        NT_ASSERT(apfnCleanup[objt]);
        apfnCleanup[objt](pobj);
 
        /* Check if the object is allocated from a lookaside list */
        if (pobj->BaseFlags & BASEFLAG_LOOKASIDE)
        {
            ExFreeToPagedLookasideList(&gpaLookasideList[objt], pobj);
        }
        else
        {
            ExFreePoolWithTag(pobj, GDIOBJ_POOL_TAG(objt));
        }
    }
}

Referenced by DC_AllocDcWithHandle(), EngCreatePalette(), GDIOBJ_AllocObjWithHandle(), GDIOBJ_vDereferenceObject(), NtGdiCreateClientObj(), PALETTE_AllocPalWithHandle(), and REGION_AllocRgnWithHandle().

GDIOBJ_vReferenceObjectByPointer()

VOID NTAPI GDIOBJ_vReferenceObjectByPointer

(

POBJ

pobj

)

Definition at line 741 of file gdiobj.c.

{
    ULONG cRefs;
 
    /* Check if the object has a handle */
    if (GDI_HANDLE_GET_INDEX(pobj->hHmgr))
    {
        /* Increase the handle's reference count */
        ULONG ulIndex = GDI_HANDLE_GET_INDEX(pobj->hHmgr);
        ASSERT((gpaulRefCount[ulIndex] & REF_MASK_COUNT) > 0);
        cRefs = InterlockedIncrement((LONG*)&gpaulRefCount[ulIndex]);
    }
    else
    {
        /* Increase the object's reference count */
        cRefs = InterlockedIncrement((LONG*)&pobj->ulShareCount);
    }
 
    DBG_LOGEVENT(&pobj->slhLog, EVENT_REFERENCE, cRefs);
}

Referenced by DC_vCopyState(), DC_vSelectFillBrush(), DC_vSelectLineBrush(), DC_vSelectPalette(), DC_vSelectSurface(), EBRUSHOBJ_vInit(), InitPaletteImpl(), PDEVOBJ_pSurface(), SURFACE_ShareLockByPointer(), and SURFACE_vSetPalette().

GDIOBJ_vSetObjectAttr()

VOID NTAPI GDIOBJ_vSetObjectAttr	(	POBJ	pobj,
		PVOID	pvObjAttr
	)

Definition at line 1103 of file gdiobj.c.

{
    ULONG ulIndex;
 
    ASSERT(pobj->hHmgr);
 
    /* Get the handle index */
    ulIndex = GDI_HANDLE_GET_INDEX(pobj->hHmgr);
 
    /* Set pointer to the usermode attribute */
    gpentHmgr[ulIndex].pUser = pvObjAttr;
}

Referenced by DC_bAllocDcAttr(), DC_vFreeDcAttr(), IntGdiSetRegionOwner(), REGION_bAllocRgnAttr(), and BASEOBJECT::vSetObjectAttr().

GDIOBJ_vSetObjectOwner()

VOID NTAPI GDIOBJ_vSetObjectOwner	(	POBJ	pobj,
		ULONG	ulOwner
	)

Definition at line 972 of file gdiobj.c.

{
    PENTRY pentry;
    ULONG ulOldOwner;
 
    /* This is a ugly HACK, needed to fix IntGdiSetDCOwnerEx */
    if (GDI_HANDLE_IS_STOCKOBJ(pobj->hHmgr))
    {
        DPRINT("Trying to set ownership of stock object %p to %lx\n", pobj->hHmgr, ulNewOwner);
        return;
    }
 
    /* Get the handle entry */
    NT_ASSERT(GDI_HANDLE_GET_INDEX(pobj->hHmgr));
    pentry = &gpentHmgr[GDI_HANDLE_GET_INDEX(pobj->hHmgr)];
 
    /* Check if the new owner is the same as the old one */
    ulOldOwner = pentry->ObjectOwner.ulObj;
    if (ulOldOwner == ulNewOwner)
    {
        /* Nothing to do */
        return;
    }
 
    /* Is the current process requested? */
    if (ulNewOwner == GDI_OBJ_HMGR_POWNED)
    {
        /* Use process id */
        ulNewOwner = HandleToUlong(PsGetCurrentProcessId());
    }
 
    // HACK
    if (ulNewOwner == GDI_OBJ_HMGR_NONE)
        ulNewOwner = GDI_OBJ_HMGR_PUBLIC;
 
    /* Was the object process owned? */
    if ((ulOldOwner != GDI_OBJ_HMGR_PUBLIC) &&
        (ulOldOwner != GDI_OBJ_HMGR_NONE))
    {
        /* Decrement the previous owners handle count */
        DecrementGdiHandleCount(ulOldOwner);
    }
 
    /* Is the new owner a process? */
    if ((ulNewOwner != GDI_OBJ_HMGR_PUBLIC) &&
        (ulNewOwner != GDI_OBJ_HMGR_NONE))
    {
        /* Increment the new owners handle count */
        IncrementGdiHandleCount(ulNewOwner);
    }
    else
    {
        /* Make sure we don't leak user mode memory */
        NT_ASSERT(pentry->pUser == NULL);
    }
 
    /* Set new owner */
    pentry->ObjectOwner.ulObj = ulNewOwner;
    DBG_LOGEVENT(&pobj->slhLog, EVENT_SET_OWNER, 0);
}

Referenced by DC_vSetOwner(), EngCreateBitmap(), EngCreateDeviceBitmap(), EngCreateDeviceSurface(), GreSetObjectOwnerEx(), NtGdiCreateServerMetaFile(), and NtGdiSaveDC().

GDIOBJ_vUnlockObject()

VOID NTAPI GDIOBJ_vUnlockObject

(

POBJ

pobj

)

Definition at line 887 of file gdiobj.c.

{
    ULONG cRefs, ulIndex;
    ASSERT(pobj->cExclusiveLock > 0);
 
    /* Decrease lock count */
    pobj->cExclusiveLock--;
    DECREASE_THREAD_LOCK_COUNT(pobj->hHmgr);
    DBG_LOGEVENT(&pobj->slhLog, EVENT_UNLOCK, 0);
 
    /* Check if this was the last lock */
    if (pobj->cExclusiveLock == 0)
    {
        /* Reset lock owner */
        pobj->dwThreadId = 0;
 
        /* Release the pushlock and reenable APCs */
        ExReleasePushLockExclusive(&pobj->pushlock);
        KeLeaveCriticalRegion();
    }
 
    /* Calculate the index */
    ulIndex = GDI_HANDLE_GET_INDEX(pobj->hHmgr);
 
    /* Decrement reference count */
    ASSERT((gpaulRefCount[ulIndex] & REF_MASK_COUNT) > 0);
    cRefs = InterlockedDecrement((LONG*)&gpaulRefCount[ulIndex]);
    ASSERT(cRefs & REF_MASK_VALID);
}

Referenced by DC_UnlockDc(), GDIOBJ_bLockMultipleObjects(), GreStretchBltMask(), NtGdiAlphaBlend(), NtGdiCreateClientObj(), NtGdiCreateServerMetaFile(), NtGdiGetServerMetaFileBits(), NtGdiTransparentBlt(), PATH_CreatePath(), REGION_UnlockRgn(), and BASEOBJECT::vUnlock().

GreDeleteObject()

BOOL NTAPI GreDeleteObject

(

HGDIOBJ

hObject

)

Definition at line 1165 of file gdiobj.c.

{
    PENTRY pentry;
 
    /* Check for stock objects */
    if (GDI_HANDLE_IS_STOCKOBJ(hobj))
    {
        DPRINT1("GreDeleteObject: Cannot delete stock object %p.\n", hobj);
        return FALSE;
    }
 
    /* Reference the handle entry */
    pentry = ENTRY_ReferenceEntryByHandle(hobj, 0);
    if (!pentry)
    {
        DPRINT1("GreDeleteObject: Trying to delete invalid object %p\n", hobj);
        return FALSE;
    }
 
    /* Check for public owner */
    if (pentry->ObjectOwner.ulObj == GDI_OBJ_HMGR_PUBLIC)
    {
        DPRINT1("GreDeleteObject: Trying to delete global object %p\n", hobj);
        GDIOBJ_vDereferenceObject(pentry->einfo.pobj);
        return FALSE;
    }
 
    /* Delete the object */
    GDIOBJ_vDeleteObject(pentry->einfo.pobj);
    return TRUE;
}

Referenced by BITMAP_CopyBitmap(), co_IntDrawCaret(), co_IntPaintWindows(), co_UserExcludeUpdateRgn(), co_UserFreeWindow(), co_UserGetUpdateRgn(), co_WinPosSetWindowPos(), CreateBrushInternal(), DC_vRestoreDC(), DceDeleteClipRgn(), DceFreeDCE(), DefWndDoSizeMove(), DIB_CreateDIBSection(), DrawTextExWorker(), ForceNCPaintErase(), FreeCurIconObject(), GdiFlushUserBatch(), GreGetDIBitsInternal(), IntBeginPaint(), IntCreateDIBitmap(), IntDefWindowProc(), IntDestroyMonitorObject(), IntEndDesktopGraphics(), IntForceMinimizeWindow(), IntFreeElementData(), IntGdiCreateMaskFromRLE(), IntGdiDeleteColorSpace(), IntGdiDeleteDC(), IntGetNCUpdateRgn(), IntInvalidateWindows(), IntPaintDesktop(), IntSetDIBits(), IntUpdateLayeredWindowI(), MENU_DrawPopupGlyph(), MenuInit(), NC_HandleNCActivate(), NtGdiDeleteClientObj(), NtGdiDeleteObjectApp(), NtGdiExtCreateRegion(), NtGdiFrameRgn(), NtGdiStretchDIBitsInternal(), PaintSuspendedWindow(), REGION_XorRegion(), SelectWindowRgn(), SnapWindow(), SpiSetWallpaper(), TEXT_DrawUnderscore(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), UITOOLS95_DrawFrameMenu(), UITOOLS95_DrawFrameScroll(), UserDrawCaptionText(), UserGetDCEx(), UserUpdateMonitorSize(), and BRUSH::~BRUSH().

GreGetObject()

INT NTAPI GreGetObject	(	IN HGDIOBJ	hobj,
		IN INT	cbCount,
		OUT PVOID	pvBuffer
	)

Definition at line 1277 of file gdiobj.c.

{
    PVOID pvObj;
    UCHAR objt;
    INT iResult = 0;
 
    /* Verify object type */
    objt = ((ULONG_PTR)hobj >> 16) & 0x1f;
    if (objt != GDIObjType_BRUSH_TYPE &&
        objt != GDIObjType_SURF_TYPE &&
        objt != GDIObjType_LFONT_TYPE &&
        objt != GDIObjType_PAL_TYPE)
    {
        DPRINT1("GreGetObject: Invalid object type\n");
        return 0;
    }
 
    pvObj = GDIOBJ_ReferenceObjectByHandle(hobj, objt);
    if (!pvObj)
    {
        DPRINT("GreGetObject: Could not lock object\n");
        return 0;
    }
 
    switch (GDI_HANDLE_GET_TYPE(hobj))
    {
        case GDILoObjType_LO_PEN_TYPE:
        case GDILoObjType_LO_EXTPEN_TYPE:
            iResult = PEN_GetObject(pvObj, cbCount, pvBuffer);
            break;
 
        case GDILoObjType_LO_BRUSH_TYPE:
            iResult = BRUSH_GetObject(pvObj, cbCount, pvBuffer);
            break;
 
        case GDILoObjType_LO_BITMAP_TYPE:
            iResult = BITMAP_GetObject(pvObj, cbCount, pvBuffer);
            break;
 
        case GDILoObjType_LO_FONT_TYPE:
            iResult = FontGetObject(pvObj, cbCount, pvBuffer);
            break;
 
        case GDILoObjType_LO_PALETTE_TYPE:
            iResult = PALETTE_GetObject(pvObj, cbCount, pvBuffer);
            break;
 
        default:
            DPRINT1("GDI object type of 0x%p not implemented\n", hobj);
            break;
    }
 
    GDIOBJ_vDereferenceObject(pvObj);
    return iResult;
}

Referenced by IntTMWFixUp(), IntUpdateLayeredWindowI(), MENU_DrawBitmapItem(), MENU_GetBitmapItemSize(), NtGdiExtGetObjectW(), and PATH_WidenPathEx().

GreGetObjectOwner()

ULONG NTAPI GreGetObjectOwner

(

HGDIOBJ

hobj

)

Definition at line 1199 of file gdiobj.c.

{
    ULONG ulIndex, ulOwner;
 
    if (hobj == NULL)
    {
        DPRINT("GreGetObjectOwner: invalid NULL handle\n");
        return GDI_OBJ_HMGR_RESTRICTED;
    }
 
    /* Get the handle index */
    ulIndex = GDI_HANDLE_GET_INDEX(hobj);
 
    /* Check if the handle is valid */
    if (ulIndex >= GDI_HANDLE_COUNT ||
        gpentHmgr[ulIndex].Objt == GDIObjType_DEF_TYPE ||
        ((ULONG_PTR)hobj >> 16) != gpentHmgr[ulIndex].FullUnique)
    {
        DPRINT1("GreGetObjectOwner: invalid handle 0x%p.\n", hobj);
        return GDI_OBJ_HMGR_RESTRICTED;
    }
 
    /* Get the object owner */
    ulOwner = gpentHmgr[ulIndex].ObjectOwner.ulObj;
 
    if (ulOwner == HandleToUlong(PsGetCurrentProcessId()))
        return GDI_OBJ_HMGR_POWNED;
 
    if (ulOwner == GDI_OBJ_HMGR_PUBLIC)
        return GDI_OBJ_HMGR_PUBLIC;
 
    return GDI_OBJ_HMGR_RESTRICTED;
}

Referenced by DceFreeDCE(), GreSetBitmapOwner(), NtGdiDeleteObjectApp(), REGION_UnlockRgn(), and REGION_vSyncRegion().

GreIsHandleValid()

BOOL NTAPI GreIsHandleValid

(

HGDIOBJ

hobj

)

Definition at line 1153 of file gdiobj.c.

{
    PENTRY pentry;
 
    pentry = ENTRY_ReferenceEntryByHandle(hobj, 0);
    if (!pentry) return FALSE;
    GDIOBJ_vDereferenceObject(pentry->einfo.pobj);
    return TRUE;
}

Referenced by co_IntPaintWindows(), co_UserFreeWindow(), DceFreeDCE(), DceResetActiveDCEs(), GetControlColor(), IntBeginPaint(), IntGdiDeleteDC(), NC_HandleNCActivate(), NtGdiEqualRgn(), NtGdiFlushUserBatch(), NtUserSetWindowRgn(), PaintSuspendedWindow(), UserGetDCEx(), and BRUSH::~BRUSH().

GreSetObjectOwner()

BOOL NTAPI GreSetObjectOwner	(	HGDIOBJ	hobj,
		ULONG	ulOwner
	)

Definition at line 1268 of file gdiobj.c.

{
    return GreSetObjectOwnerEx(hobj, ulOwner, 0);
}

Referenced by _Success_(), DC_vRestoreDC(), DC_vSetOwner(), FreeCurIconObject(), GreSetBitmapOwner(), IntDdePostMessageHook(), IntDestroyMenu(), IntDestroyMonitorObject(), IntFreeElementData(), IntGdiSetRegionOwner(), IntSynthesizeBitmap(), MenuInit(), SpiSetWallpaper(), UserSetClipboardData(), and UserUpdateMonitorSize().

GreSetObjectOwnerEx()

BOOL NTAPI GreSetObjectOwnerEx	(	HGDIOBJ	hobj,
		ULONG	ulOwner,
		ULONG	Flags
	)

Definition at line 1235 of file gdiobj.c.

{
    PENTRY pentry;
 
    /* Check for stock objects */
    if (GDI_HANDLE_IS_STOCKOBJ(hobj))
    {
        DPRINT("GreSetObjectOwner: Got stock object %p\n", hobj);
        return FALSE;
    }
 
    /* Reference the handle entry */
    pentry = ENTRY_ReferenceEntryByHandle(hobj, Flags);
    if (!pentry)
    {
        DPRINT("GreSetObjectOwner: Invalid handle 0x%p.\n", hobj);
        return FALSE;
    }
 
    /* Call internal function */
    GDIOBJ_vSetObjectOwner(pentry->einfo.pobj, ulOwner);
 
    /* Dereference the object */
    GDIOBJ_vDereferenceObject(pentry->einfo.pobj);
 
    return TRUE;
}

Referenced by GreSetObjectOwner(), and NtUserConsoleControl().

InitGdiHandleTable()

NTSTATUS NTAPI InitGdiHandleTable

(

VOID

)

Definition at line 259 of file gdiobj.c.

{
    NTSTATUS status;
    LARGE_INTEGER liSize;
    PVOID pvSection;
    SIZE_T cjViewSize = 0;
 
    /* Create a section for the shared handle table */
    liSize.QuadPart = sizeof(GDI_HANDLE_TABLE); // GDI_HANDLE_COUNT * sizeof(ENTRY);
    status = MmCreateSection(&gpvGdiHdlTblSection,
                             SECTION_ALL_ACCESS,
                             NULL,
                             &liSize,
                             PAGE_READWRITE,
                             SEC_COMMIT | 0x1,
                             NULL,
                             NULL);
    if (!NT_SUCCESS(status))
    {
        DPRINT1("INITGDI: Could not allocate a GDI handle table.\n");
        return status;
    }
 
    /* Map the section in session space */
    status = MmMapViewInSessionSpace(gpvGdiHdlTblSection,
                                     (PVOID*)&gpentHmgr,
                                     &cjViewSize);
    if (!NT_SUCCESS(status))
    {
        DPRINT1("INITGDI: Failed to map handle table section\n");
        ObDereferenceObject(gpvGdiHdlTblSection);
        return status;
    }
 
    /* Allocate memory for the reference counter table */
    gpaulRefCount = EngAllocSectionMem(&pvSection,
                                     FL_ZERO_MEMORY,
                                     GDI_HANDLE_COUNT * sizeof(ULONG),
                                     'frHG');
    if (!gpaulRefCount)
    {
        DPRINT1("INITGDI: Failed to allocate reference table.\n");
        ObDereferenceObject(gpvGdiHdlTblSection);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    gulFirstFree = 0;
    gulFirstUnused = RESERVE_ENTRIES_COUNT;
 
    GdiHandleTable = (PVOID)gpentHmgr;
 
    /* Initialize the lookaside lists */
    gpaLookasideList = ExAllocatePoolWithTag(NonPagedPool,
                           GDIObjTypeTotal * sizeof(PAGED_LOOKASIDE_LIST),
                           TAG_GDIHNDTBLE);
    if(!gpaLookasideList)
        return STATUS_NO_MEMORY;
 
    InitLookasideList(GDIObjType_DC_TYPE, sizeof(DC));
    InitLookasideList(GDIObjType_RGN_TYPE, sizeof(REGION));
    InitLookasideList(GDIObjType_SURF_TYPE, sizeof(SURFACE));
    InitLookasideList(GDIObjType_CLIENTOBJ_TYPE, sizeof(CLIENTOBJ));
    InitLookasideList(GDIObjType_PATH_TYPE, sizeof(PATH));
    InitLookasideList(GDIObjType_PAL_TYPE, sizeof(PALETTE));
    InitLookasideList(GDIObjType_ICMLCS_TYPE, sizeof(COLORSPACE));
    InitLookasideList(GDIObjType_LFONT_TYPE, sizeof(TEXTOBJ));
    InitLookasideList(GDIObjType_BRUSH_TYPE, sizeof(BRUSH));
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

Variable Documentation

GdiHandleTable

PGDI_HANDLE_TABLE GdiHandleTable

extern

Definition at line 26 of file gdihv.c.

Referenced by _tWinMain(), GdiFixUpHandle(), GdiGetHandleUserData(), GdiQueryTable(), GdiValidateHandle(), GetHandleUserData(), InitGdiHandleTable(), IsHandleValid(), and WinMain().

RESERVE_ENTRIES_COUNT

const unsigned RESERVE_ENTRIES_COUNT = 10

static

Definition at line 11 of file gdiobj.h.

Referenced by GDI_CleanupForProcess(), InitGdiHandleTable(), and KdbCommand_Gdi_dumpht().