NTSTATUS UnhookDriverObject(PDRIVER_HOOK_RECORD DriverRecord)
{
KIRQL irql;
PHASH_ITEM h = NULL;
NTSTATUS status = STATUS_UNSUCCESSFUL;
DEBUG_ENTER_FUNCTION("DriverRecord=0x%p", DriverRecord);
KeAcquireSpinLock(&_driverTableLock, &irql);
h = HashTableDelete(_driverTable, DriverRecord->DriverObject);
if (h != NULL) {
KeReleaseSpinLock(&_driverTableLock, irql);
if (DriverRecord->MonitoringEnabled) {
_UnhookDriverObject(DriverRecord);
DriverRecord->MonitoringEnabled = FALSE;
}
KeAcquireSpinLock(&DriverRecord->SelectedDevicesLock, &irql);
HashTableClear(DriverRecord->SelectedDevices, TRUE);
KeReleaseSpinLock(&DriverRecord->SelectedDevicesLock, irql);
_InvalidateDriverHookRecord(DriverRecord);
DriverHookRecordDereference(DriverRecord);
status = STATUS_SUCCESS;
} else {
KeReleaseSpinLock(&_driverTableLock, irql);
status = STATUS_NOT_FOUND;
ASSERT(FALSE);
}
DEBUG_EXIT_FUNCTION("0x%x", status);
return status;
}
NTSTATUS HandleTableHandleClose(PCHANDLE_TABLE HandleTable, HANDLE Handle)
{
KIRQL irql;
PHASH_ITEM hashItem = NULL;
PCHANDLE_TABLE_MAPPING mapping = NULL;
NTSTATUS status = STATUS_UNSUCCESSFUL;
DEBUG_ENTER_FUNCTION("HandleTable=0x%p; Handle=0x%p", HandleTable, Handle);
_HandleTableLockExclusive(HandleTable, &irql);
hashItem = HashTableDelete(HandleTable->HashTable, Handle);
if (hashItem != NULL) {
PVOID object = NULL;
HANDLE handleValue = NULL;
PCHANDLE_TABLE handleTable = NULL;
mapping = CONTAINING_RECORD(hashItem, CHANDLE_TABLE_MAPPING, HashItem);
object = mapping->Object;
handleValue = mapping->HandleValue;
HandleTable = mapping->HandleTable;
_HandleTableUnlock(HandleTable, irql);
HeapMemoryFree(mapping);
HandleTable->HandleDeleteProcedure(handleTable, object, handleValue);
} else {
_HandleTableUnlock(HandleTable, irql);
status = STATUS_INVALID_HANDLE;
}
DEBUG_EXIT_FUNCTION("0x%x", status);
return status;
}
static VOID _InvalidateDeviceHookRecord(PDEVICE_HOOK_RECORD DeviceRecord)
{
KIRQL irql;
DEBUG_ENTER_FUNCTION("DeviceRecord=0x%p", DeviceRecord);
KeAcquireSpinLock(&_deviceValidationTableLock, &irql);
HashTableDelete(_deviceValidationTable, DeviceRecord);
KeReleaseSpinLock(&_deviceValidationTableLock, irql);
DEBUG_EXIT_FUNCTION_VOID();
return;
}
static VOID _InvalidateDriverHookRecord(PDRIVER_HOOK_RECORD DriverRecord)
{
KIRQL irql;
DEBUG_ENTER_FUNCTION("DriverRecord=0x%p", DriverRecord);
KeAcquireSpinLock(&_driverValidationTableLock, &irql);
ASSERT(HashTableGet(_driverValidationTable, DriverRecord) != NULL);
HashTableDelete(_driverValidationTable, DriverRecord);
KeReleaseSpinLock(&_driverValidationTableLock, irql);
DEBUG_EXIT_FUNCTION_VOID();
return;
}
VOID
ProtectAddObject(IN PVOID Object,
IN BOOLEAN Remove)
{
KIRQL oldIrql;
KeAcquireSpinLock(&ProtectObjectLock, &oldIrql);
if(Remove) {
HashTableDelete(&ProtectObject, (ULONG)Object);
}
else {
HashTableMark(&ProtectObject, (ULONG)Object);
}
KeReleaseSpinLock(&ProtectObjectLock, oldIrql);
}
/***********************************************************************************
Function Name : DestroyUSEShaderVariant
Inputs : gc, psUSEVariant
Outputs : -
Returns : -
Description : Destroys the given variant, removing it from the list and freeing
all of its memory.
Limitations : The variant MUST belong to a shader.
************************************************************************************/
static IMG_VOID DestroyUSEShaderVariant(GLES1Context *gc, GLES1ShaderVariant *psUSEVariant)
{
GLES1PDSCodeVariant *psPDSVariant, *psPDSVariantNext;
GLES1PDSVertexCodeVariant *psPDSVertexVariant, *psPDSVertexVariantNext;
GLES1ShaderVariant *psList;
IMG_UINT32 ui32DummyItem;
/* Remove this variant from the list attached to its shader */
psList = psUSEVariant->psShader->psShaderVariant;
if(psList == psUSEVariant)
{
/* The element was in the head of the list */
psUSEVariant->psShader->psShaderVariant = psList->psNext;
}
else
{
/* The element was in the body of the list */
while(psList)
{
if(psList->psNext == psUSEVariant)
{
psList->psNext = psUSEVariant->psNext;
break;
}
psList = psList->psNext;
}
/* Check that the psUSEVariant was found */
GLES1_ASSERT(psList);
}
/* Remove the variant from the KRM list */
KRM_RemoveResourceFromAllLists(&gc->psSharedState->sUSEShaderVariantKRM, &psUSEVariant->sResource);
/* destroy PDS vertex variants, if present */
psPDSVertexVariant = psUSEVariant->psPDSVertexCodeVariant;
while(psPDSVertexVariant)
{
psPDSVertexVariantNext = psPDSVertexVariant->psNext;
if(psPDSVertexVariant->psCodeBlock)
UCH_CodeHeapFree(psPDSVertexVariant->psCodeBlock);
GLES1Free(gc, psPDSVertexVariant);
psPDSVertexVariant = psPDSVertexVariantNext;
}
UCH_CodeHeapFree(psUSEVariant->psCodeBlock);
psPDSVariant = psUSEVariant->psPDSVariant;
while(psPDSVariant)
{
psPDSVariantNext = psPDSVariant->psNext;
if(!HashTableDelete(gc, &gc->sProgram.sPDSFragmentVariantHashTable, psPDSVariant->tHashValue,
psPDSVariant->pui32HashCompare, psPDSVariant->ui32HashCompareSizeInDWords,
&ui32DummyItem))
{
PVR_DPF((PVR_DBG_ERROR,"PDS Variant not found in hash table"));
}
psPDSVariant = psPDSVariantNext;
}
GLES1Free(gc, psUSEVariant);
}
