int DoCloseInterruptHandler (int handle) { struct ISRHandler *isr_handler; struct Process *current; int irq; current = GetCurrentProcess(); if ((isr_handler = GetObject(current, handle, HANDLE_TYPE_ISR)) == NULL) return paramErr; DisablePreemption(); irq = isr_handler->irq; DisableInterrupts(); LIST_REM_ENTRY (&isr_handler_list[irq], isr_handler, isr_handler_entry); irq_handler_cnt[irq] --; if (irq_handler_cnt[irq] == 0) MaskInterrupt(irq); EnableInterrupts(); LIST_ADD_HEAD (&free_isr_handler_list, isr_handler, isr_handler_entry); free_isr_handler_cnt ++; FreeHandle (handle); return 0; }
void HandleSystem::ReleasePrimHandle(unsigned int index) { QHandle *pHandle = &m_Handles[index]; HandleSet set = pHandle->set; if (pHandle->owner && (set != HandleSet_Identity)) { UnlinkHandleFromOwner(pHandle, index); } /* Were we an identity ourself? */ QHandle *pLocal; if (set == HandleSet_Identity) { /* Extra work to do. We need to find everything connected to this identity and release it. */ unsigned int ch_index; #if defined _DEBUG unsigned int old_index = 0; #endif while ((ch_index = pHandle->ch_next) != 0) { pLocal = &m_Handles[ch_index]; #if defined _DEBUG assert(old_index != ch_index); assert(pLocal->set == HandleSet_Used); old_index = ch_index; #endif FreeHandle(pLocal, ch_index); } } pHandle->set = HandleSet_None; m_Types[pHandle->type].opened--; m_Handles[++m_FreeHandles].freeID = index; }
static UCHAR EmsFree(USHORT Handle) { PLIST_ENTRY Entry; PEMS_HANDLE HandleEntry = GetHandleRecord(Handle); if (!ValidateHandle(HandleEntry)) return EMS_STATUS_INVALID_HANDLE; for (Entry = HandleEntry->PageList.Flink; Entry != &HandleEntry->PageList; Entry = Entry->Flink) { PEMS_PAGE PageEntry = (PEMS_PAGE)CONTAINING_RECORD(Entry, EMS_PAGE, Entry); ULONG PageNumber = ARRAY_INDEX(PageEntry, PageTable); /* Free the page */ RtlClearBits(&AllocBitmap, PageNumber, 1); } InitializeListHead(&HandleEntry->PageList); if (Handle != EMS_SYSTEM_HANDLE) FreeHandle(HandleEntry); return EMS_STATUS_SUCCESS; }
HandleError HandleSystem::FreeHandle(Handle_t handle, const HandleSecurity *pSecurity) { unsigned int index; QHandle *pHandle; HandleError err; IdentityToken_t *ident = pSecurity ? pSecurity->pIdentity : NULL; if ((err=GetHandle(handle, ident, &pHandle, &index)) != HandleError_None) { return err; } if (!CheckAccess(pHandle, HandleAccess_Delete, pSecurity)) { return HandleError_Access; } if (pHandle->is_destroying) { /* Someone tried to free this recursively. * We'll just ignore this safely. */ return HandleError_None; } return FreeHandle(pHandle, index); }
static cell AMX_NATIVE_CALL SQL_FreeHandle(AMX *amx, cell *params) { if (!FreeHandle(params[1])) { MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]); return 0; } return 1; }
//public QueryHandler(state, Handle:query, error[], errnum, data[], size) void MysqlThread::Execute() { cell data_addr; if (m_datalen) { data_addr = MF_PrepareCellArray(m_data, m_datalen); } else { static cell tmpdata[1] = {0}; data_addr = MF_PrepareCellArray(tmpdata, 1); } int state = 0; if (!m_qrInfo.connect_success) { state = -2; } else if (!m_qrInfo.query_success) { state = -1; } float diff = gpGlobals->time - m_qrInfo.queue_time; cell c_diff = amx_ftoc(diff); unsigned int hndl = MakeHandle(&m_qrInfo.amxinfo, Handle_Query, NullFunc); if (state != 0) { MF_ExecuteForward(m_fwd, (cell)state, (cell)hndl, m_qrInfo.amxinfo.error, m_qrInfo.amxinfo.info.errorcode, data_addr, m_datalen, c_diff); } else { MF_ExecuteForward(m_fwd, (cell)0, (cell)hndl, "", (cell)0, data_addr, m_datalen, c_diff); } FreeHandle(hndl); if (m_qrInfo.amxinfo.pQuery) { m_qrInfo.amxinfo.pQuery->FreeHandle(); m_qrInfo.amxinfo.pQuery = NULL; } delete [] m_qrInfo.amxinfo.opt_ptr; m_qrInfo.amxinfo.opt_ptr = NULL; }
AtomicResult::~AtomicResult() { if (!m_IsFree) { FreeHandle(); } for (size_t i=0; i<=m_AllocSize; i++) { delete m_Table[i]; } delete [] m_Table; m_Table = NULL; m_IsFree = true; }
void AxisSweep3::RemoveHandle(unsigned short handle) { Handle* pHandle = GetHandle(handle); RemoveOverlappingPairsContainingProxy(pHandle); // compute current limit of edge arrays int limit = m_numHandles * 2; int axis; for (axis = 0;axis<3;axis++) { Edge* pEdges = m_pEdges[axis]; int maxEdge= pHandle->m_maxEdges[axis]; pEdges[maxEdge].m_pos = 0xffff; int minEdge = pHandle->m_minEdges[axis]; pEdges[minEdge].m_pos = 0xffff; } // remove the edges by sorting them up to the end of the list for ( axis = 0; axis < 3; axis++) { Edge* pEdges = m_pEdges[axis]; int max = pHandle->m_maxEdges[axis]; pEdges[max].m_pos = 0xffff; SortMaxUp(axis,max,false); int i = pHandle->m_minEdges[axis]; pEdges[i].m_pos = 0xffff; SortMinUp(axis,i,false); pEdges[limit-1].m_handle = 0; pEdges[limit-1].m_pos = 0xffff; } // free the handle FreeHandle(handle); }
HandleError HandleSystem::FreeHandle(Handle_t handle, const HandleSecurity *pSecurity) { unsigned int index; QHandle *pHandle; HandleError err; IdentityToken_t *ident = pSecurity ? pSecurity->pIdentity : NULL; if ((err=GetHandle(handle, ident, &pHandle, &index)) != HandleError_None) { return err; } if (!CheckAccess(pHandle, HandleAccess_Delete, pSecurity)) { return HandleError_Access; } return FreeHandle(pHandle, index); }
/*! ****************************************************************************** @Function PVRSRVReleaseHandle @Description Release a handle that is no longer needed @Input hHandle - handle from client eType - handle type @Return Error code or PVRSRV_OK ******************************************************************************/ PVRSRV_ERROR PVRSRVReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType) { PVRSRV_ERROR eError; /* PVRSRV_HANDLE_TYPE_NONE is reserved for internal use */ PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE); PVR_ASSERT(gpsHandleFuncs); if (psBase == IMG_NULL) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVReleaseHandle: Missing handle base")); eError = PVRSRV_ERROR_INVALID_PARAMS; goto exit_ReleaseHandle; } eError = FreeHandle(psBase, hHandle, eType, IMG_NULL); exit_ReleaseHandle: return eError; }
ODBCLib::CODBCHandle::~CODBCHandle() { FreeHandle(); }
static PVRSRV_ERROR FreeHandleWrapper(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE hHandle) { return FreeHandle(psBase, hHandle, PVRSRV_HANDLE_TYPE_NONE, IMG_NULL); }
/*! ****************************************************************************** @Function PVRSRVAllocSubHandle @Description Allocate a subhandle @Input phHandle - location for new subhandle pvData - pointer to resource to be associated with the subhandle eType - the type of resource hParent - parent handle @Output phHandle - points to new subhandle @Return Error code or PVRSRV_OK ******************************************************************************/ PVRSRV_ERROR PVRSRVAllocSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_HANDLE hParent) { HANDLE_DATA *psPHandleData = IMG_NULL; HANDLE_DATA *psCHandleData = IMG_NULL; IMG_HANDLE hParentKey; IMG_HANDLE hHandle; PVRSRV_ERROR eError; *phHandle = IMG_NULL; /* PVRSRV_HANDLE_TYPE_NONE is reserved for internal use */ PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE); PVR_ASSERT(gpsHandleFuncs); if (psBase == IMG_NULL) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Missing handle base")); eError = PVRSRV_ERROR_INVALID_PARAMS; goto err; } hParentKey = TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE) ? hParent : IMG_NULL; /* Lookup the parent handle */ eError = GetHandleData(psBase, &psPHandleData, hParent, PVRSRV_HANDLE_TYPE_NONE); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Failed to get parent handle structure")); goto err; } if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI)) { /* See if there is already a handle for this data pointer */ hHandle = FindHandle(psBase, pvData, eType, hParentKey); if (hHandle != IMG_NULL) { eError = GetHandleData(psBase, &psCHandleData, hHandle, eType); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Lookup of existing handle failed")); goto err; } PVR_ASSERT(hParentKey != IMG_NULL && ParentHandle(psCHandleData) == hParent); /* * If the client is willing to share a handle, the * existing handle is marked as shareable, and the * existing handle has the same parent, return the * existing handle. */ if (TEST_FLAG(psCHandleData->eFlag & eFlag, PVRSRV_HANDLE_ALLOC_FLAG_SHARED) && ParentHandle(psCHandleData) == hParent) { psCHandleData->ui32Refs++; *phHandle = hHandle; eError = PVRSRV_OK; goto err; } eError = PVRSRV_ERROR_HANDLE_NOT_SHAREABLE; goto err; } } eError = AllocHandle(psBase, &hHandle, pvData, eType, eFlag, hParentKey); if (eError != PVRSRV_OK) { goto err; } eError = GetHandleData(psBase, &psCHandleData, hHandle, PVRSRV_HANDLE_TYPE_NONE); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Failed to get parent handle structure")); /* If we were able to allocate the handle then there should be no reason why we can't also get it's handle structure. Otherwise something has gone badly wrong. */ PVR_ASSERT(eError == PVRSRV_OK); goto err; } /* * Get the parent handle structure again, in case the handle * structure has moved (depending on the implementation * of AllocHandle). */ eError = GetHandleData(psBase, &psPHandleData, hParent, PVRSRV_HANDLE_TYPE_NONE); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Failed to get parent handle structure")); FreeHandle(psBase, hHandle, eType, IMG_NULL); goto err; } eError = AdoptChild(psBase, psPHandleData, psCHandleData); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Parent handle failed to adopt subhandle")); FreeHandle(psBase, hHandle, eType, IMG_NULL); goto err; } *phHandle = hHandle; eError = PVRSRV_OK; err: return eError; }
_Use_decl_annotations_ int WINAPI WinMain(HINSTANCE instance, HINSTANCE prevInstance, LPSTR commandLine, int commandShow) { UMSpinLock spinLock; UMCriticalSection cs; CRITICAL_SECTION cs2; LARGE_INTEGER freq, start, stop, osCS, myCS; HANDLE threads[64]; UMSpinLockInitialize(&spinLock); UMCriticalSectionInitialize(&cs, _countof(threads)); InitializeCriticalSection(&cs2); for (uint32_t i = 0; i < _countof(threads); ++i) { threads[i] = CreateThread(NULL, 0, ThreadProcSpinLock, &spinLock, 0, NULL); assert(threads[i] != NULL); } WaitForMultipleObjects(_countof(threads), threads, TRUE, INFINITE); uint32_t value = buffer[0]; for (uint32_t i = 0; i < _countof(buffer); ++i) { if (buffer[i] != value) { OutputDebugString(L"\n\nERROR ERROR\n"); assert(false); } } QueryPerformanceFrequency(&freq); QueryPerformanceCounter(&start); for (uint32_t i = 0; i < _countof(threads); ++i) { CloseHandle(threads[i]); threads[i] = CreateThread(NULL, 0, ThreadProcCS, &cs, 0, NULL); assert(threads[i] != NULL); } WaitForMultipleObjects(_countof(threads), threads, TRUE, INFINITE); QueryPerformanceCounter(&stop); myCS.QuadPart = stop.QuadPart - start.QuadPart; value = buffer[0]; for (uint32_t i = 0; i < _countof(buffer); ++i) { if (buffer[i] != value) { OutputDebugString(L"\n\nERROR ERROR\n"); assert(false); } } QueryPerformanceCounter(&start); for (uint32_t i = 0; i < _countof(threads); ++i) { CloseHandle(threads[i]); threads[i] = CreateThread(NULL, 0, ThreadProcOSCS, &cs2, 0, NULL); assert(threads[i] != NULL); } WaitForMultipleObjects(_countof(threads), threads, TRUE, INFINITE); QueryPerformanceCounter(&stop); osCS.QuadPart = stop.QuadPart - start.QuadPart; value = buffer[0]; for (uint32_t i = 0; i < _countof(buffer); ++i) { if (buffer[i] != value) { OutputDebugString(L"\n\nERROR ERROR\n"); assert(false); } } for (uint32_t i = 0; i < _countof(threads); ++i) { CloseHandle(threads[i]); } UMCriticalSectionDestroy(&cs); typedef struct { uint32_t X; float F; } Foo; Foo f; Foo* g; Handle h; char buffer[] = "Hello, World"; wchar_t buffer2[100]; char buffer3[100]; GameObject go1; GameObject go2; AabbNode* root = NULL; go1.Signature = SIGNATURE; go2.Signature = SIGNATURE; AabbNodeStartup(GetGameObjectBounds); go1.Node = AabbNodeInsert(&root, go1.Mins, go1.Maxs, &go1); go2.Node = AabbNodeInsert(&root, go2.Mins, go2.Maxs, &go2); // AabbNodeRemove(&root, root); AabbNodeRemove(&root, go1.Node); AabbNodeRemove(&root, go2.Node); UNREFERENCED_PARAMETER(instance); UNREFERENCED_PARAMETER(prevInstance); UNREFERENCED_PARAMETER(commandLine); UNREFERENCED_PARAMETER(commandShow); f.X = 3; f.F = -234.8f; if (!HandleTableStartup()) { return -1; } h = AllocHandle(&f, 1); if (h == InvalidHandle) { return -2; } g = (Foo*)GetObjectFromHandle(h); if (g == 0) { return -3; } FreeHandle(h); HandleTableShutdown(); if (!ConvertCharToWChar(buffer, buffer2, 100)) { return -3; } if (!ConvertWCharToChar(buffer2, buffer3, 100)) { return -4; } return 0; }
bool HandleSystem::RemoveType(HandleType_t type, IdentityToken_t *ident) { if (type == 0 || type >= HANDLESYS_TYPEARRAY_SIZE) { return false; } QHandleType *pType = &m_Types[type]; if (pType->typeSec.ident && pType->typeSec.ident != ident) { return false; } if (pType->dispatch == NULL) { return false; } /* Remove children if we have to */ if (!(type & HANDLESYS_SUBTYPE_MASK)) { QHandleType *childType; for (unsigned int i=1; i<=HANDLESYS_MAX_SUBTYPES; i++) { childType = &m_Types[type + i]; if (childType->dispatch) { RemoveType(type + i, childType->typeSec.ident); } } /* Link us into the free chain */ m_Types[++m_FreeTypes].freeID = type; } /* Make sure nothing is using this type. */ if (pType->opened) { QHandle *pHandle; for (unsigned int i=1; i<=m_HandleTail; i++) { pHandle = &m_Handles[i]; if (!pHandle->set || pHandle->type != type) { continue; } FreeHandle(pHandle, i); if (pType->opened == 0) { break; } } } /* Invalidate the type now */ pType->dispatch = NULL; /* Remove it from the type cache. */ if (pType->name) m_TypeLookup.remove(pType->name->chars()); return true; }
OdbcHandleBase<HandleType>::~OdbcHandleBase() { FreeHandle(handle_type_, this_handle_, OdbcThrowFlags::None); }