示例#1
0
文件: select.c 项目: berkus/acess2
void VFS_int_Select_RemThread(tVFS_SelectList *List, tThread *Thread)
{
	 int	i;
	tVFS_SelectListEnt	*block, *prev = NULL;
	
	ENTER("pList pThread", List, Thread);
	
	// Lock to avoid concurrency issues
	Mutex_Acquire(&List->Lock);
	
	block = &List->FirstEnt;
	
	// Look for the thread
	do
	{
		for( i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
		{
			if( block->Threads[i] == Thread )
			{
				block->Threads[i] = NULL;
				
				// Check if this block is empty
				if( block != &List->FirstEnt )
				{
					for( i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
						if( block->Threads[i] )
							break;
					// If empty, free it
					if( i == NUM_THREADS_PER_ALLOC ) {
						LOG("Deleting block");
						prev->Next = block->Next;
						free(block);
					}
					//TODO: If not empty, check if it can be merged downwards
				}
				
				Mutex_Release(&List->Lock);
				LEAVE('-');
				return ;
			}
		}
		
		prev = block;
		block = block->Next;
	} while(block);
	
	// Not on list, is this an error?
	
	Mutex_Release(&List->Lock);
	
	LOG("Not on list");
	LEAVE('-');
}
示例#2
0
//---------------------------------------------------------------------------
static void Mutex_Profiling()
{
    K_USHORT i;
    Mutex_t stMutex;
    
    for (i = 0; i < 10; i++)
    {
        ProfileTimer_Start( &stMutexInitTimer );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        Mutex_Init( &stMutex );
        ProfileTimer_Stop( &stMutexInitTimer );
    }
    
    for (i = 0; i < 100; i++)
    {
        ProfileTimer_Start( &stMutexClaimTimer );
        Mutex_Claim( &stMutex );
        ProfileTimer_Stop( &stMutexClaimTimer );

        ProfileTimer_Start( &stMutexReleaseTimer );
        Mutex_Release( &stMutex );
        ProfileTimer_Stop( &stMutexReleaseTimer );
    }
}
示例#3
0
/**
 * \brief Signal all threads on a list
 */
void VFS_int_Select_SignalAll(tVFS_SelectList *List)
{
	 int	i;
	tVFS_SelectListEnt	*block;
	
	if( !List )	return ;
	
	ENTER("pList", List);
	
	// Lock to avoid concurrency issues
	Mutex_Acquire(&List->Lock);
	
	block = &List->FirstEnt;
	
	// Look for the thread
	do
	{
		for( i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
		{
			if( block->Threads[i]  )
			{
				LOG("block(%p)->Threads[%i] = %p", block, i, block->Threads[i]);
				Threads_PostEvent( block->Threads[i], THREAD_EVENT_VFS );
			}
		}
		
		block = block->Next;
	} while(block);
	
	Mutex_Release(&List->Lock);
	
	LEAVE('-');
}
int Mutex_Cleanup(PVOID pVoid)
{
	if(!pVoid)
		return ERROR_INVALID_ARGUMENT;

	return Mutex_Release(pVoid);
}
示例#5
0
文件: main.c 项目: moslevin/Mark3C
//---------------------------------------------------------------------------
void App1Main(void *unused_)
{
    while(1)
    {
        // Claim the mutex.  This will prevent any other thread from claiming
        // this lock simulatenously.  As a result, the other thread has to
        // wait until we're done before it can do its work.  You will notice
        // that the Start/Done prints for the thread will come as a pair (i.e.
        // you won't see "Thread2: Start" then "Thread1: Start").

		Mutex_Claim( &stMyMutex );
        
		// Start our work (incrementing a counter).  Notice that the Start and
        // Done prints wind up as a pair when simuated with flAVR.

        KernelAware_Print("Thread1: Start\n");
        ulCounter++;
        while (ulCounter <= 10000)
        {
            ulCounter++;
        }
        ulCounter = 0;
        KernelAware_Print("Thread1: Done\n");

        // Release the lock, allowing the other thread to do its thing.
        Mutex_Release( &stMyMutex );
    }
}
示例#6
0
void
MT_AddTask(Task * pt, gboolean lock)
{
    if (lock) {
        Mutex_Lock(td.queueLock, "add task");
    }
    if (td.addedTasks == 0)
        td.result = 0;          /* Reset result for new tasks */
    td.addedTasks++;
    td.tasks = g_list_append(td.tasks, pt);
    if (g_list_length(td.tasks) == 1) { /* New tasks */
        SetManualEvent(td.activity);
    }
    if (lock) {
        multi_debug("add task: release");
        Mutex_Release(td.queueLock);
    }
}
示例#7
0
static Task *
MT_GetTask(void)
{
    Task *task = NULL;

    Mutex_Lock(td.queueLock, "get task");

    if (g_list_length(td.tasks) > 0) {
        task = (Task *) g_list_first(td.tasks)->data;
        td.tasks = g_list_delete_link(td.tasks, g_list_first(td.tasks));
        if (g_list_length(td.tasks) == 0) {
            ResetManualEvent(td.activity);
        }
    }

    multi_debug("get task: release");
    Mutex_Release(td.queueLock);

    return task;
}
示例#8
0
/**
 * \fn void Ext2_CloseFile(tVFS_Node *Node)
 * \brief Close a file (Remove it from the cache)
 */
void Ext2_CloseFile(tVFS_Node *Node)
{
	tExt2_Disk	*disk = Node->ImplPtr;
	ENTER("pNode", Node);

	if( Mutex_Acquire(&Node->Lock) != 0 )
	{
		LEAVE('-');
		return ;
	}

	if( Node->Flags & VFS_FFLAG_DIRTY )
	{
		// Commit changes
		Ext2_int_WritebackNode(disk, Node);
		Node->Flags &= ~VFS_FFLAG_DIRTY;
	}

	int was_not_referenced = (Node->ImplInt == 0);
	tVFS_ACL	*acls = Node->ACLs;
	if( Inode_UncacheNode(disk->CacheID, Node->Inode) == 1 )
	{
		if( was_not_referenced )
		{
			LOG("Removng inode");
			// Remove inode
			Log_Warning("Ext2", "TODO: Remove inode when not referenced (%x)", (Uint32)Node->Inode);
		}
		if( acls != &gVFS_ACL_EveryoneRW ) {
			free(acls);
		}
		LOG("Node cleaned");
	}
	else {
		LOG("Still referenced, releasing lock");
		Mutex_Release(&Node->Lock);
	}
	LEAVE('-');
	return ;
}
示例#9
0
void
mt_add_tasks(unsigned int num_tasks, AsyncFun pFun, void *taskData, gpointer linked)
{
    unsigned int i;
    {
#ifdef DEBUG_MULTITHREADED
        char buf[20];
        sprintf(buf, "add %u tasks", num_tasks);
        Mutex_Lock(td.queueLock, buf);
#else
        Mutex_Lock(td.queueLock, NULL);
#endif
    }
    for (i = 0; i < num_tasks; i++) {
        Task *pt = (Task *) malloc(sizeof(Task));
        pt->fun = pFun;
        pt->data = taskData;
        pt->pLinkedTask = linked;
        MT_AddTask(pt, FALSE);
    }
    multi_debug("add many release: lock");
    Mutex_Release(td.queueLock);
}
示例#10
0
/**
 * \return Boolean failure
 */
int VFS_int_Select_AddThread(tVFS_SelectList *List, tThread *Thread, int MaxAllowed)
{
	 int	i, count = 0;
	tVFS_SelectListEnt	*block, *prev;
	
	ENTER("pList pThread iMaxAllowed", List, Thread, MaxAllowed);
	
	// Lock to avoid concurrency issues
	Mutex_Acquire(&List->Lock);
	
	block = &List->FirstEnt;
	
	// Look for free space
	do
	{
		for( i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
		{
			if( block->Threads[i] == NULL )
			{
				block->Threads[i] = Thread;
				Mutex_Release(&List->Lock);
				LEAVE('i', 0);
				return 0;
			}
			count ++;
			if( MaxAllowed && count >= MaxAllowed ) {
				Mutex_Release(&List->Lock);
				LEAVE('i', 1);
				return 1;
			}
		}
		
		prev = block;
		block = block->Next;
	} while(block);
	
	LOG("New block");
	
	// Create new block
	block = malloc( sizeof(tVFS_SelectListEnt) );
	if( !block ) {
		Log_Warning("VFS", "VFS_int_Select_AddThread: malloc() failed");
		Mutex_Release(&List->Lock);
		return -1;
	}
	block->Next = NULL;
	block->Threads[0] = Thread;
	for( i = 1; i < NUM_THREADS_PER_ALLOC; i ++ )
	{
		block->Threads[i] = NULL;
	}
	
	// Add to list
	prev->Next = block;
	
	// Release
	Mutex_Release(&List->Lock);
	
	LEAVE('i', 0);
	return 0;
}
示例#11
0
extern void
MT_Release(void)
{
    Mutex_Release(td.multiLock);
}
示例#12
0
void IPStack_Buffer_UnlockBuffer(tIPStackBuffer *Buffer)
{
	ASSERT(Buffer);
	Mutex_Release(&Buffer->lBufferLock);
}