/******************************Module*Header*******************************\ * Module Name: hmgr.h * * This file contains all the prototypes for the handle mangager. * * Added nifty header: 29-Jun-1991 16:31:46 * Author: Patrick Haluptzok patrickh * * Copyright (c) 1990-1999 Microsoft Corporation \**************************************************************************/ //#include "hmgshare.h" // <-fulltype-> // <---full unique---> // +-+------+-+--+-----+----------------+ // |u|unique|s|al|type | index | // +-+------+-+--+-----+----------------+ // ^ ^ ^^ // +user | || // | || // | ++alternate type for client (pen, metafile, dibsection) // | // +stock object // // USER - bit(s) reserved for USER, not used for comparing identical handles // // TYPE - types used by GRE // ALTTYPE - extra type bits used by client // STOCK - bit indicating stockobject // FULLTYPE - all bits related to type that are per object (includes STOCK bit) // // UNIQUE - bits that are incremented for each instance of the handle // FULLUNIQUE - bits used for comparing identical handles. This includes FULLTYPE // // INDEX - index into server side handle table // // The handle index points into a big array of entries. This index is // broken down into 'page' and 'entry' fields. // This is to prevent having to have the entire handle table created at // once. If all the handles in a page are in use and no free handles are // available, a new page is faulted in for use. // all the commented defines below live in ntgdistr.h. #define LOTYPE_BITS (TYPE_BITS + ALTTYPE_BITS) #define FULLTYPE_BITS (TYPE_BITS + ALTTYPE_BITS + STOCK_BITS) #define FULLUNIQUE_BITS (TYPE_BITS + ALTTYPE_BITS + STOCK_BITS + UNIQUE_BITS) #define NONINDEX_BITS (32 - INDEX_BITS) #define INDEX_SHIFT 0 #define UNIQUE_SHIFT (STOCK_SHIFT + STOCK_BITS) #define LOTYPE_SHIFT (TYPE_SHIFT) #define FULLTYPE_SHIFT (TYPE_SHIFT) #define FULLUNIQUE_SHIFT (TYPE_SHIFT) //MASKS contain the bits of the handle used for the paricular field #define NONINDEX_MASK(shift,cbits) ( ((1 << (cbits)) - 1) << (shift) ) #define INDEX_MASK ((1 << INDEX_BITS) - 1) #define TYPE_MASK (NONINDEX_MASK(TYPE_SHIFT, TYPE_BITS)) #define ALTTYPE_MASK (NONINDEX_MASK(ALTTYPE_SHIFT, ALTTYPE_BITS)) #define STOCK_MASK (NONINDEX_MASK(STOCK_SHIFT, STOCK_BITS)) #define UNIQUE_MASK (NONINDEX_MASK(UNIQUE_SHIFT, UNIQUE_BITS)) #define LOTYPE_MASK (NONINDEX_MASK(LOTYPE_SHIFT, LOTYPE_BITS)) #define FULLTYPE_MASK (NONINDEX_MASK(FULLTYPE_SHIFT, FULLTYPE_BITS)) // NOTE that UNIQUE_INCREMENT is based on the uniqueness beeing a short, not a full handle #define UNIQUE_INCREMENT (1 << (UNIQUE_SHIFT - INDEX_BITS)) #define MODIFY_HMGR_TYPE(h,t) ((HANDLE)((ULONG_PTR)(h) | (t))) #define HmgIfromH(h) (ULONG)((ULONG_PTR)(h) & INDEX_MASK) #define HmgUfromH(h) ((USHORT) (((ULONG_PTR)(h) & FULLUNIQUE_MASK) >> TYPE_SHIFT)) #define HmgObjtype(h) ((OBJTYPE)(((ULONG_PTR)(h) & TYPE_MASK) >> TYPE_SHIFT)) #define HmgStockObj(hobj) ((ULONG_PTR)(hobj) & STOCK_MASK) // given a usUnique and a type, modify it to contain a new type #define USUNIQUE(u,t) (USHORT)((u & (UNIQUE_MASK >> INDEX_BITS)) | \ (t << (TYPE_SHIFT - INDEX_BITS))) // // WOW has a dependency on the index portion of returned 32-bit GDI // handles being greater than (COLOR_ENDCOLORS >> 2) // (COLOR_ENDCOLORS is defined in winuserp.h). // // This dependency allows WOW to distinguish between a 16-bit HBRUSH // and a COLOR_* constant. // // Therefore, we will will reserve the first few entries of the handle // table, disallowing the use of any index less than HMGR_HANDLE_BASE. // // hideyukn, 1997.Oct.27 // #define HMGR_HANDLE_BASE 0x000a ULONG FASTCALL HmgQueryLock(HOBJ hobj); BOOL FASTCALL HmgSetLock(HOBJ hobj, ULONG cLock); ULONG FASTCALL HmgQueryAltLock(HOBJ hobj); BOOL HmgCreate(); HOBJ HmgAlloc(ULONGSIZE_T,OBJTYPE,USHORT); POBJ HmgReplace(HOBJ,POBJ,FLONG,LONG,OBJTYPE); VOID HmgFree(HOBJ); POBJ FASTCALL HmgLock(HOBJ,OBJTYPE); POBJ FASTCALL HmgLockAllOwners(HOBJ,OBJTYPE); POBJ FASTCALL HmgShareLock(HOBJ,OBJTYPE); POBJ FASTCALL HmgShareCheckLock(HOBJ,OBJTYPE); POBJ FASTCALL HmgShareLockIgnoreStockBit(HOBJ,OBJTYPE); POBJ FASTCALL HmgShareCheckLockIgnoreStockBit(HOBJ,OBJTYPE); BOOL HmgSetOwner(HOBJ,W32PID,OBJTYPE); BOOL HmgSwapHandleContents(HOBJ,ULONG,HOBJ,ULONG,OBJTYPE); BOOL HmgSwapLockedHandleContents(HOBJ,ULONG,HOBJ,ULONG,OBJTYPE); POBJ FASTCALL HmgReferenceCheckLock(HOBJ h,OBJTYPE ot, BOOL bDebugPrint); HOBJ FASTCALL HmgNextOwned(HOBJ,W32PID); POBJ FASTCALL HmgSafeNextObjt(HOBJ hobj, OBJTYPE objt); BOOL HmgValidHandle(HOBJ, OBJTYPE); HOBJ FASTCALL HmgSafeNextOwned(HOBJ,W32PID); BOOL FASTCALL HmgMarkUndeletable(HOBJ,OBJTYPE); BOOL FASTCALL HmgMarkDeletable(HOBJ,OBJTYPE); HOBJ HmgInsertObject(PVOID,FLONG,OBJTYPE); PVOID HmgRemoveObject(HOBJ,LONG,LONG,BOOL,OBJTYPE); OBJTYPE * HmgSetNULLType(HOBJ,LONG,LONG,OBJTYPE); HOBJ HmgModifyHandleType(HOBJ h); BOOL HmgLockAndModifyHandleType(HOBJ h); PVOID HmgAllocateSecureUserMemory(); PDC_ATTR HmgAllocateDcAttr(); POBJECTATTR HmgAllocateObjectAttr(); VOID HmgFreeDcAttr(PDC_ATTR); VOID HmgFreeObjectAttr(POBJECTATTR); BOOL bPEBCacheHandle(HANDLE,HANDLECACHETYPE,POBJECTATTR,PENTRY); BOOL bLoadProcessHandleQuota(); HOBJ HmgIncUniqueness(HOBJ hobj, OBJTYPE objt); VOID FASTCALL HmgIncrementShareReferenceCount(POBJ); ULONG FASTCALL HmgDecrementShareReferenceCount(POBJ); VOID HmgShareUnlock(POBJ pobj); BOOL FASTCALL HmgInterlockedCompareAndSwap(PULONG,ULONG,ULONG); PVOID HmgForceRemoveObject(HOBJ hobj,BOOL bIgnoreUndeletable, OBJTYPE objt); BOOL HmgIncProcessHandleCount(W32PID,OBJTYPE); VOID HmgDecProcessHandleCount(W32PID); #define HMGR_ALLOC_LOCK 0x0001 #define HMGR_ALLOC_ALT_LOCK 0x0002 #define HMGR_NO_ZERO_INIT 0x0004 #define HMGR_MAKE_PUBLIC 0x0008 #define MAXIMUM_POOL_ALLOC (PAGE_SIZE * 10000) // Global Handle Manager data. extern HSEMAPHORE ghsemHmgr; extern ENTRY *gpentHmgr; extern HOBJ ghFreeHmgr; extern ULONG gcMaxHmgr; extern PLARGE_INTEGER gpLockShortDelay; extern ULONG gCacheHandleEntries[GDI_CACHED_HADNLE_TYPES]; extern LONG gProcessHandleQuota; // DirectDraw Handle Manager data: externed here for debugger extensions extern ULONG gcSizeDdHmgr; extern ENTRY *gpentDdHmgr; extern HOBJ ghFreeDdHmgr; extern ULONG gcMaxDdHmgr; // // SAMEHANDLE and DIFFHANDLE have moved to wingdip.h so other server-side // components can safely compare engine handles. They validate all but USER bits // #define SAMEINDEX(H,K) (((((ULONG_PTR) (H)) ^ ((ULONG_PTR) (K))) & INDEX_MASK) == 0) /*********************************MACRO************************************\ * INC_EXCLUSIVE_REF_CNT - increment object's exclusive reference count * DEC_EXCLUSIVE_REF_CNT - decrement object's exclusive reference count * * Note that the InterlockedIncrement/Decrement treats the cExclusiveLock * as a ULONG. cExclusiveLock is declared as a USHORT and the increment * overlaps with the BASEOBJECT::BaseFlags. If the BaseFlags were ever changed, * this code may have to be changed to use an InterlockedCompareExchange loop. * See BASEOBJECT declaration. * * * Arguments: * * pObj - pointer to object * * Return Value: * * None * \**************************************************************************/ #define INC_EXCLUSIVE_REF_CNT(pObj) InterlockedIncrement((LONG *)& (((POBJ) pObj)->cExclusiveLock)) #define DEC_EXCLUSIVE_REF_CNT(pObj) InterlockedDecrement((LONG *)& (((POBJ) pObj)->cExclusiveLock)) /********************************MACRO*************************************\ * INC_SHARE_REF_CNT - do an interlocked increment of the * shared reference count of the given object. * * DEC_SHARE_REF_CNT - do an interlocked decrement of the * shared reference count of the given object. * * Arguments: * * pObj - pointer to OBJECT * * Return Value: * * HmgIncrementShareReferenceCount : None * HmgDecrementShareReferenceCount : Original shared reference count * \**************************************************************************/ #define PENTRY_FROM_POBJ(pObj) \ (&gpentHmgr[(UINT)HmgIfromH(((POBJ)(pObj))->hHmgr)]) #define INC_SHARE_REF_CNT(pObj) \ HmgIncrementShareReferenceCount((POBJ) (pObj)) #define DEC_SHARE_REF_CNT(pObj) \ HmgDecrementShareReferenceCount((POBJ) (pObj)) /*********************************MACRO************************************\ * * DEC_SHARE_REF_CNT_LAZY0 - Interlocked decrement the shared reference * count of the given object. If the original count was 1, and the * object's TO_BE_DELETED flag is set, then call the object deletion * routine * * Arguments: * * pObj - pointer to object * * Return Value: * * None * \**************************************************************************/ #define DEC_SHARE_REF_CNT_LAZY0(pObj) \ { \ PBRUSHATTR pBrushattr = ((PBRUSH)pObj)->pBrushattr(); \ \ if (1 == (DEC_SHARE_REF_CNT(pObj) & 0xffff)) \ { \ if ((pBrushattr->AttrFlags) & ATTR_TO_BE_DELETED) \ { \ bDeleteBrush ((HBRUSH) pObj->hHmgr,FALSE); \ } \ } \ } /*********************************MACRO************************************\ * * DEC_SHARE_REF_CNT_LAZY_DEL_LOGFONT * count of the given object. If the original count was 1, and the * object's TO_BE_DELETED flag is set, then call the object deletion * routine * * Arguments: * * pObj - pointer to object * * Return Value: * * None * \**************************************************************************/ #define DEC_SHARE_REF_CNT_LAZY_DEL_LOGFONT(pObj) \ { \ if (1 == (DEC_SHARE_REF_CNT(pObj) & 0xffff)) \ { \ if (PENTRY_FROM_POBJ(pObj)->Flags & HMGR_ENTRY_LAZY_DEL) \ { \ bDeleteFont ((HLFONT) pObj->hHmgr,FALSE); \ } \ } \ } #define DEC_SHARE_REF_CNT_LAZY_DEL_COLORSPACE(pObj) \ { \ DEC_SHARE_REF_CNT(pObj); \ }