static void uninit() { unregister_generic_syscall(LAUNCH_SPEEDUP_SYSCALLS, 1); recursive_lock_lock(&sLock); // free all sessions from the hashes uint32 cookie = 0; Session *session; while ((session = (Session *)hash_remove_first(sTeamHash, &cookie)) != NULL) { delete session; } cookie = 0; while ((session = (Session *)hash_remove_first(sPrefetchHash, &cookie)) != NULL) { delete session; } // free all sessions from the main prefetch list for (session = sMainPrefetchSessions; session != NULL; ) { sMainPrefetchSessions = session->Next(); delete session; session = sMainPrefetchSessions; } hash_uninit(sTeamHash); hash_uninit(sPrefetchHash); recursive_lock_destroy(&sLock); }
/*! Calls low resource handlers for the given resources. sLowResourceLock must be held. */ static void call_handlers(uint32 lowResources) { if (sLowResourceHandlers.IsEmpty()) return; // Add a marker, so we can drop the lock while calling the handlers and // still iterate safely. low_resource_handler marker; sLowResourceHandlers.Insert(&marker, false); while (low_resource_handler* handler = sLowResourceHandlers.GetNext(&marker)) { // swap with handler sLowResourceHandlers.Swap(&marker, handler); marker.priority = handler->priority; int32 resources = handler->resources & lowResources; if (resources != 0) { recursive_lock_unlock(&sLowResourceLock); handler->function(handler->data, resources, low_resource_state_no_update(resources)); recursive_lock_lock(&sLowResourceLock); } } // remove marker sLowResourceHandlers.Remove(&marker); }
static int lock_tmap(vm_translation_map *map) { TMAP_TRACE("lock_tmap: map %p\n", map); if(recursive_lock_lock(&map->lock) == true) { // we were the first one to grab the lock } return 0; }
/*! Acquires the map's recursive lock, and resets the invalidate pages counter in case it's the first locking recursion. */ bool M68KVMTranslationMap::Lock() { TRACE("%p->M68KVMTranslationMap::Lock()\n", this); recursive_lock_lock(&fLock); if (recursive_lock_get_recursion(&fLock) == 1) { // we were the first one to grab the lock TRACE("clearing invalidated page count\n"); fInvalidPagesCount = 0; } return true; }
int32 low_resource_state(uint32 resources) { recursive_lock_lock(&sLowResourceLock); if (system_time() - sLastMeasurement > 500000) compute_state(); int32 state = low_resource_state_no_update(resources); recursive_lock_unlock(&sLowResourceLock); return state; }
status_t Attribute::_Find(const char* name, int32 index) { Put(); fName = name; // try to find it in the small data region if (fInode->HasExtraAttributes() && recursive_lock_lock(&fInode->SmallDataLock()) == B_OK) { off_t blockNum; fVolume->GetInodeBlock(fInode->ID(), blockNum); if (blockNum != 0) { fBlock.SetTo(blockNum); const uint8* start = fBlock.Block() + fVolume->InodeBlockIndex(fInode->ID()) * fVolume->InodeSize(); const uint8* end = start + fVolume->InodeSize(); int32 count = 0; if (_FindAttributeBody(start + EXT2_INODE_NORMAL_SIZE + fInode->Node().ExtraInodeSize(), end, name, index, &count, &fBodyEntry) == B_OK) return B_OK; index -= count; } recursive_lock_unlock(&fInode->SmallDataLock()); fBlock.Unset(); } // then, search in the attribute directory if (fInode->Node().ExtendedAttributesBlock() != 0) { fBlock.SetTo(fInode->Node().ExtendedAttributesBlock()); if (_FindAttributeBlock(fBlock.Block(), fBlock.Block() + fVolume->BlockSize(), name, index, NULL, &fBlockEntry) == B_OK) return B_OK; fBlock.Unset(); } return B_ENTRY_NOT_FOUND; }
static inline void rld_lock() { recursive_lock_lock(&sLock); }
static void recursive_lock_forward(GenericSharedDeclarations_SharedOf_int32_0_t* value1) { recursive_lock_lock(value1); }