Ejemplo n.º 1
0
void testLL() {

  int i;
  int storeUs[6] = {5,10,15,7,2,2};

	struct list_head *head = NULL;

	head=create_new_ll();

	printf("Is the list empty? %s\n",is_list_empty(head) ? "Yes" : "No");

  for(i=0; i<6; i++) {
    add_new_node_ll(head,storeUs[i]);
  }
	printf("The number 2 occurs: %d time(s)\n",find_elements_ll(head,2));
  print_out_ll(head);
  remove_node_ll(head,5);
  print_out_ll(head);
  remove_node_ll(head,7);
  print_out_ll(head);
	printf("Total Elements %d\n",total_elements_ll(head));
  remove_node_ll(head,2);
  print_out_ll(head);
	printf("Total Elements %d\n",total_elements_ll(head));
	printf("The number 2 occurs: %d time(s)\n",find_elements_ll(head,2));
	printf("Does the element 10 exist in the list: %s\n", \
					does_element_exist_ll(head,10) ? "Yes!" : "No");
	printf("Does the element 100 exist in the list: %s\n", \
					does_element_exist_ll(head,100) ? "Yes!" : "No");
	printf("Is the list empty? %s\n",is_list_empty(head) ? "Yes" : "No");

	free_ll(head);
}
void
sem_yield(sem_t *sp)
{
    sem *sema = (sem*)sp;
    ucontext_t *curr = NULL, *next = NULL;
    tcb *running = NULL, *tcbnext = NULL;
    struct list_elem *e = NULL;
    int queueflag = -1;

    running = list_entry(list_begin(&q_running), thread_p, elem)->p;
    if (is_list_empty(&q_ready_H) && is_list_empty(&q_ready_L)) {
        printf("Q_ready_H and L are both empty!\n");
        return;
    }

    thread_p *tmp_p = (thread_p *)calloc(1, sizeof(thread_p));
    tmp_p->p = running;
    list_insert_tail(&sema->waiters, &tmp_p->elem);
    curr = &running->context;
    e = list_begin(&q_running);
    tmp_p = list_entry(e, thread_p, elem);
    list_remove(e);
    free(tmp_p);

    if (!is_list_empty(&q_ready_H)) {
        tcbnext = list_entry(list_begin(&q_ready_H), thread_p, elem)->p;
        queueflag = 0;
    }
    else if (!is_list_empty(&q_ready_L)) {
        tcbnext = list_entry(list_begin(&q_ready_L), thread_p, elem)->p;
        queueflag = 1;
    }
    tmp_p = (thread_p *)calloc(1, sizeof(thread_p));
    tmp_p->p = tcbnext;
    list_insert_head(&q_running, &tmp_p->elem);
    next = &tcbnext->context;

    if (queueflag == 0) 
        e = list_begin(&q_ready_H);
    else if (queueflag == 1) 
        e = list_begin(&q_ready_L);
    tmp_p = list_entry(e, thread_p, elem);
    list_remove(e);
    free(tmp_p);
    assert(curr);
    assert(next);
    if (swapcontext(curr, next) == -1) {
        printf("Swapcontext error: %s\n", strerror(errno));   
    }
}
Ejemplo n.º 3
0
uint state_remove( uint state )
{
    STATE_DIS *tmp = state_obj_copy;
    while(!is_list_empty(&(tmp->node)))  
    {
        if ( tmp->state == state )
        {
            list_delete(&(tmp->node));
            tmp->state = 10000;
            tmp->func  = NULL;
            tmp->name  = "";
            return 0;
        }

        tmp = (STATE_DIS *)(&(tmp->node))->next;
    }   
    
    if ( tmp->state == state )
    {
        list_delete(&(tmp->node)); 
        
        tmp->state = 10000;
        tmp->func  = NULL;
        tmp->name  = "";

        return 0;
    }
    printf("State no fund\n");
}
Ejemplo n.º 4
0
uint state_tran( uint state )
{
    STATE_DIS *tmp = state_obj_copy;    

    while( !is_list_empty(&(tmp->node)) )  
    {
        if ( tmp->state == state )
        {
            fsm_obj->func = tmp->func;
            fsm_obj->name     = tmp->name; 
            fsm_obj->state    = state;
            return 0; 
        }

        tmp = (STATE_DIS *)(&(tmp->node))->next;
    }    
    
    if ( tmp->state == state )
    {
            fsm_obj->name     = tmp->name; 
            fsm_obj->state    = state;

            fsm_obj->func = tmp->func; 
            return 0; 
    }
    state_default(fsm_default.state, fsm_default.func, fsm_default.name);
    
    printf("state is no found, and fsm will transfer to default, It is name: %s\n", fsm_obj->name);
}
Ejemplo n.º 5
0
vod_status_t 
write_buffer_queue_flush(write_buffer_queue_t* queue)
{
	buffer_header_t* cur_buffer;
	vod_status_t rc;

	while (!is_list_empty(&queue->buffers))
	{
		cur_buffer = (buffer_header_t*)queue->buffers.next;
		remove_entry_list(&cur_buffer->link);

		if (cur_buffer->cur_pos <= cur_buffer->start_pos)
		{
			continue;
		}

		rc = queue->write_callback(queue->write_context, cur_buffer->start_pos, cur_buffer->cur_pos - cur_buffer->start_pos);
		if (rc != VOD_OK)
		{
			vod_log_debug1(VOD_LOG_DEBUG_LEVEL, queue->request_context->log, 0,
				"write_buffer_queue_flush: write_callback failed %i", rc);
			return rc;
		}

		// no reason to reuse the buffer here
	}

	return VOD_OK;
}
Ejemplo n.º 6
0
/* Rather than use stdlib qsort() (quicksort), implement merge sort based upon 
   wikipedia pseudo code entry.
   https://en.wikipedia.org/wiki/Merge_sort
  
   General idea
   Recursively divide the list into smaller sublists 
   until the sublists are trivially sorted and then
   merge the sublists.
*/
list_t *merge_sort(list_t *pList) {

	list_t *pListLeft;
	list_t *pListRight;
	int i=0;
	node_t *pNode;

	// Base case.  A zero or one element list is sorted by definition
	if (is_list_empty(pList)) {
		return pList;
	}
	if (is_list_singleton(pList)) {
		return pList;
	}

	// The wikipedia entry assumes the number of items in the list
	// is maintained and uses a for loop.  It still requires
	// the list to be iterated.  I'm simply using a while not 
	// empty as I build the sublists. 

	//
	// Create the two sublists
	//
//	int (*pfCompare)(node_t,node_t);
	pListLeft = init_list(pList->pfCompare);
	if (NULL == pListLeft) {
		printf("Failed to init left sublist.\n");
	}
	pListRight = init_list(pList->pfCompare);
	if (NULL == pListRight) {
		printf("Failed to init right sublist.\n");
	}


	// alternatively add each item of the list to the sublists.
	pNode = pList->pFirst;
	while ( NULL != pNode) {
		if (i % 2) {
			if ( append(pListLeft, pNode->pData) ) {
				printf("Failed to append number to left list.\n");
			}	
		} else {
			if ( append(pListRight, pNode->pData) ) {
				printf("Failed to append number to right list.\n");
			}	
		}
		pNode = pNode->pNext;
		i++;
	}

	// Recursively sort both sublists
	pListLeft = merge_sort(pListLeft);
	pListRight = merge_sort(pListRight);

	return ( merge(pListLeft,pListRight) );
	
}
void
list_init(struct list *list)
{
    assert(list);
    list->head.prev = NULL;
    list->head.next = &list->tail;
    list->tail.prev = &list->head;
    list->tail.next = NULL;
    assert(is_list_empty(list));
}
Ejemplo n.º 8
0
/* Note we can't trim distinguished_csn (even during regular trimming)
   because in some cases we would not be able to figure out whether
   a value was distinguished or not at the time of deletion. 

   Example 1:							Example2:
   csn order operation					csn	order	operation
   1    1	 make V  distinguished		1	  1		make V distinguished
   3	3	 delete V 					2	  2		make V non distinguished
   4	2	 make V non-distinguished	3	  4		delete V
										4	  3     make V non distinguished (on another server)

   if the csns up to 2 were triimed, when delete operation is received, the state
   is exactly the same in both examples but in example one delete should not go
   through while in example 2 it should

 */
int value_distinguished_at_delete (Value_State *value, int attr_delete_csn)
{
	if (value->distinguished_csn >= 0 &&
		(is_list_empty (value->non_distinguished_csns) ||
		 min_list_val (value->non_distinguished_csns) > 
		 max_val (value->delete_csn, attr_delete_csn)))
		return 1;
	else
		return 0;
}
Ejemplo n.º 9
0
void calculate_time_slice(RAW_U8 task_prio)
{
	RAW_TASK_OBJ   *task_ptr;
	LIST *head;

	RAW_SR_ALLOC();

	head = &raw_ready_queue.task_ready_list[task_prio];
	 
	RAW_CRITICAL_ENTER();
	
	/*if ready list is empty then just return because nothing is to be caculated*/                       
	if (is_list_empty(head)) {

		RAW_CRITICAL_EXIT();
		return;
	}

	/*Always look at the first task on the ready list*/
	task_ptr = list_entry(head->next, RAW_TASK_OBJ, task_list);

	/*SCHED_FIFO does not has timeslice, just return*/
	if (task_ptr->sched_way == SCHED_FIFO) {
		
		RAW_CRITICAL_EXIT();
		return;
	}

	/*there is only one task on this ready list, so do not need to caculate time slice*/
	/*idle task must satisfy this condition*/
	if (head->next->next == head)  {
		
		RAW_CRITICAL_EXIT();
		return;
		
	}

	if (task_ptr->time_slice) {
		task_ptr->time_slice--;
	}

	/*if current active task has time_slice, just return*/
	if (task_ptr->time_slice) {               
		RAW_CRITICAL_EXIT();
		return;
	}

	/*Move current active task to the end of ready list for the same priority*/
	move_to_ready_list_end(&raw_ready_queue, task_ptr);

	/*restore the task time slice*/ 
	task_ptr->time_slice = task_ptr->time_total;  
	
	RAW_CRITICAL_EXIT();
}
Ejemplo n.º 10
0
RAW_OS_ERROR raw_semaphore_set(RAW_SEMAPHORE *semaphore_ptr,  RAW_U32 sem_count)
{
	LIST *block_list_head;
	
	RAW_SR_ALLOC();

	block_list_head = &semaphore_ptr->common_block_obj.block_list;

	#if (RAW_SEMA_FUNCTION_CHECK > 0)

	if (semaphore_ptr == 0) {

		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
	}

	#endif

	RAW_CRITICAL_ENTER();

	if (semaphore_ptr->common_block_obj.object_type != RAW_SEM_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}
	
	if (semaphore_ptr->count) { 
		
		semaphore_ptr->count = sem_count;                                   
	} 

	else {

		if (is_list_empty(block_list_head)) {

			semaphore_ptr->count = sem_count; 
		}

		else {

			RAW_CRITICAL_EXIT();
			return RAW_SEMAPHORE_TASK_WAITING;
		}

	}

	RAW_CRITICAL_EXIT();

	return RAW_SUCCESS;

}
Ejemplo n.º 11
0
/*
 * Release the lock and delete it from list, and then adjust the
 * priority of task.
 * Set the highest priority between listed below:
 *	(A) The highest priority in all mutexes in which 'tcb' task locks.
 *	(B) The base priority of 'tcb' task.
 */
static void release_mutex(RAW_TASK_OBJ *tcb, RAW_MUTEX *relmtxcb)
{
	RAW_MUTEX	*mtxcb, **prev;
	RAW_U8	newpri, pri;
	RAW_TASK_OBJ *first_block_task;
	LIST *block_list_head;
	
	/* (B) The base priority of task */
	newpri = tcb->bpriority;

	/* (A) The highest priority in mutex which is locked */
	pri = newpri;
	prev = &tcb->mtxlist;
	while ((mtxcb = *prev) != 0) {
		if (mtxcb == relmtxcb) {
			/* Delete self from list and tcb->mtxlist point to next*/
			*prev = mtxcb->mtxlist;
			continue;
		}

		switch (mtxcb->policy) {
		  case RAW_MUTEX_CEILING_POLICY:
			pri = mtxcb->ceiling_prio;
			break;
			
		  case RAW_MUTEX_INHERIT_POLICY:
		  	
		  	block_list_head = &mtxcb->common_block_obj.block_list;
			
			if (!is_list_empty(block_list_head)) {
				first_block_task = raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list); 
				pri = first_block_task->priority;
			}
			
			break;
			
		  default:
			break;
		}
		if (newpri > pri) {
			newpri = pri;
		}

		prev = &mtxcb->mtxlist;
	}

	if ( newpri != tcb->priority ) {
		/* Change priority of lock get task */
		change_internal_task_priority(tcb, newpri);

		TRACE_MUTEX_RELEASE(raw_task_active, tcb, newpri);
	}
	
}
Ejemplo n.º 12
0
/*
 * Delete from free queue
 */
static void removeFreeQue( LIST  *fq )
{
	if ( !is_list_empty(fq + 1) ) {
		LIST  *nq = (fq + 1)->next;

		list_delete(fq + 1);
		list_insert(nq,nq + 1);
		list_delete(nq);
		list_insert(fq,nq);
	}

	list_delete(fq);
}
Ejemplo n.º 13
0
//Before running run: "ulimit -s unlimited"
int main(int argc, char* argv[]) {
    parse_opts(argc, argv);

    srand(time(NULL)); 
    int tick = 0;
    struct list **chunks_lifetime = (struct list **)malloc(sizeof(struct list*) * max_ticks);// The stack memory has somee restrictions
    for (int i = 0; i < max_ticks; i++) {
        chunks_lifetime[i] = create_list();
    }

    struct memory *mem = create_memory(memory_size);
    printf("Starting\n"); 
    while (1) {
        if (need_trace) {
            printf("Tick %d:\n", tick);
        }
        while (!is_list_empty(chunks_lifetime[tick])) {
            int8_t *ptr = get_and_remove(chunks_lifetime[tick]);
            if (need_trace) {
                printf("   Removing chunk with size %d bytes\n", get_chunk_size(ptr));
            }
            free_chunk(mem, ptr);
        }
        SIZE_TYPE chunk_size = rand_range(min_chunk_size, max_chunk_size) / 4 * 4;
        int8_t *ptr = allocate_chunk(mem, chunk_size);

        if (ptr == NULL) {
            printf("Oops. We have no free memory to allocate %d bytes on tick %d. Exiting\n", chunk_size, tick);
            break;
        }
        int chunk_lifetime = rand_range(min_lifetime, max_lifetime);
        if (tick + chunk_lifetime >= max_ticks) {
            printf("The maximum number of ticks(%d) reached. Exiting\n", max_ticks);
            break;
        }
        
        add_to_list(chunks_lifetime[tick + chunk_lifetime], ptr);
        if (need_trace){
            printf("   Allocating chunk with size %d bytes. Its lifetime is %d ticks\n", chunk_size, chunk_lifetime);
        }
        tick++;
    }

    for (int i = 0; i < max_ticks; i++) {
        free_list(chunks_lifetime[i]);
    }
    free_memory(mem);
    free(chunks_lifetime);
    return 0;
}
void 
sem_signal(sem_t *sp)
{
    while(sem_try_lock(sp) != 0);
    int yield = 0;
    ((sem*)sp)->value++;
    if ( ((sem*)sp)->value <= 0 ) {
        assert(!is_list_empty(&((sem*)sp)->waiters));
        sem_unblock(sp);
        yield = 1;
    }
    sem_unlock(sp);
    if (yield == 1)
        t_yield();
}
Ejemplo n.º 15
0
/*
 * Frees all allocated timers, and timer queues
 */
void
timer_free_all(void)
{
	while (!is_list_empty(passive_timers)) {
		Any_Type        a = list_pop(passive_timers);
		free(a.vp);
	}
	list_free(passive_timers);
	passive_timers = NULL;

	while (!is_list_empty(active_timers)) {
		Any_Type        a = list_pop(active_timers);
		free(a.vp);
	}
	list_free(active_timers);
	active_timers = NULL;

	while (!is_list_empty(persistent_timers)) {
		Any_Type        a = list_pop(persistent_timers);
		free(a.vp);
	}
	list_free(persistent_timers);
	persistent_timers = NULL;
}
Ejemplo n.º 16
0
RAW_U16 raw_event_delete(RAW_EVENT *event_ptr)
{
	LIST *block_list_head;

	RAW_SR_ALLOC();

	#if (RAW_EVENT_FUNCTION_CHECK > 0)

	if (event_ptr == 0) {
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}

	#endif

	RAW_CRITICAL_ENTER();

	if (event_ptr->common_block_obj.object_type != RAW_EVENT_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		
		return RAW_ERROR_OBJECT_TYPE;
	}

	block_list_head = &event_ptr->common_block_obj.block_list;
	
	event_ptr->common_block_obj.object_type = 0u;
	/*All task blocked on this queue is waken up until list is empty*/
	while (!is_list_empty(block_list_head)) {
		
		delete_pend_obj(list_entry(block_list_head->next, RAW_TASK_OBJ, task_list));	
	}    

	event_ptr->flags = 0u;

	RAW_CRITICAL_EXIT();

	TRACE_EVENT_DELETE(raw_task_active, event_ptr);

	raw_sched();  

	return RAW_SUCCESS;
}
void 
sem_destroy(sem_t **sp)
{
    struct list_elem *e = NULL;
    sem *sema = (sem*)*sp;
    tcb *tcbtmp = NULL;
    struct list *list = &sema->waiters;
    while (!is_list_empty(list)) {
        e = list_begin(list);
        tcbtmp = list_entry(e, tcb, elem);
        list_remove(e);
        free(tcbtmp->context.uc_stack.ss_sp);
        free(tcbtmp);
    }
    sp = NULL;
}
Ejemplo n.º 18
0
static struct cmd_obj *_dequeue_cmd(struct  __queue *queue)
{
	unsigned long irqL;
	struct cmd_obj *obj;

	spin_lock_irqsave(&(queue->lock), irqL);
	if (is_list_empty(&(queue->queue)))
		obj = NULL;
	else {
		obj = LIST_CONTAINOR(get_next(&(queue->queue)),
				     struct cmd_obj, list);
		list_delete(&obj->list);
	}
	spin_unlock_irqrestore(&(queue->lock), irqL);
	return obj;
}
Ejemplo n.º 19
0
RAW_U16 raw_queue_delete(RAW_QUEUE *p_q)
{
	LIST  *block_list_head;
	
	RAW_SR_ALLOC();

	#if (RAW_QUEUE_FUNCTION_CHECK > 0)

	if (p_q == 0) {
		
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif
	
	RAW_CRITICAL_ENTER();

	if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
		
		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}

	block_list_head = &p_q->common_block_obj.block_list;
	
	p_q->common_block_obj.object_type = 0u;
	
	/*All task blocked on this queue is waken up*/
	while (!is_list_empty(block_list_head))  {
		delete_pend_obj(list_entry(block_list_head->next, RAW_TASK_OBJ, task_list));	
	}                             
	
	RAW_CRITICAL_EXIT();

	TRACE_QUEUE_DELETE(raw_task_active, p_q);

	raw_sched(); 
	
	return RAW_SUCCESS;
	
}
Ejemplo n.º 20
0
static struct slab_header *get_new_slab_header(void)
{
	struct slab_header_table *table = &pslab->table;
	struct list_head *free = &table->free_header;
	struct slab_header *header = NULL;
	struct page *pg = table->table_page_current;
	unsigned long base;

	/*
	 * find if there are headers in free list freed
	 * by other slab
	 */
	if (!is_list_empty(free)) {
		header = list_first_entry(free, struct slab_header, header_list);
		list_del(&header->header_list);
		return header;
	}
Ejemplo n.º 21
0
struct	cmd_obj	*_dequeue_cmd(_queue *queue)
{

	struct cmd_obj *obj;
_func_enter_;
	_spinlock(&(queue->lock));

	if (is_list_empty(&(queue->queue)))
		obj = NULL;
	else
	{
		obj = LIST_CONTAINOR(get_next(&(queue->queue)), struct cmd_obj, list);
		list_delete(&obj->list);
	}
	_spinunlock(&(queue->lock));
_func_exit_;	
	return obj;
}
Ejemplo n.º 22
0
RAW_OS_ERROR raw_semaphore_delete(RAW_SEMAPHORE *semaphore_ptr)
{
	LIST *block_list_head;
	
	RAW_SR_ALLOC();

	#if (RAW_SEMA_FUNCTION_CHECK > 0)
	
	if (semaphore_ptr == 0) {
		
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
	}

	#endif
	
	RAW_CRITICAL_ENTER();

	if (semaphore_ptr->common_block_obj.object_type != RAW_SEM_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}

	block_list_head = &semaphore_ptr->common_block_obj.block_list;
	
	semaphore_ptr->common_block_obj.object_type = RAW_OBJ_TYPE_NONE;
	/*All task blocked on this queue is waken up*/
	while (!is_list_empty(block_list_head)) {
		delete_pend_obj(raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list));	
	}                             

	RAW_CRITICAL_EXIT();

	TRACE_SEMAPHORE_DELETE(raw_task_active, semaphore_ptr);
	
	raw_sched(); 
	
	return RAW_SUCCESS;
}
Ejemplo n.º 23
0
vod_status_t
write_buffer_queue_send(write_buffer_queue_t* queue, off_t max_offset)
{
	buffer_header_t* cur_buffer;
	vod_status_t rc;

	while (!is_list_empty(&queue->buffers))
	{
		cur_buffer = (buffer_header_t*)queue->buffers.next;
		if (cur_buffer->cur_pos <= cur_buffer->start_pos)
		{
			break;
		}

		if (cur_buffer->end_offset > max_offset)
		{
			break;
		}

		remove_entry_list(&cur_buffer->link);
		if (cur_buffer == queue->cur_write_buffer)
		{
			queue->cur_write_buffer = NULL;
		}

		rc = queue->write_callback(queue->write_context, cur_buffer->start_pos, cur_buffer->cur_pos - cur_buffer->start_pos);
		if (rc != VOD_OK)
		{
			vod_log_debug1(VOD_LOG_DEBUG_LEVEL, queue->request_context->log, 0,
				"write_buffer_queue_send: write_callback failed %i", rc);
			return rc;
		}

		if (!queue->reuse_buffers)
		{
			cur_buffer->start_pos = NULL;
		}
		cur_buffer->cur_pos = cur_buffer->start_pos;
		insert_tail_list(&queue->buffers, &cur_buffer->link);
	}

	return VOD_OK;
}
Ejemplo n.º 24
0
RAW_OS_ERROR raw_mutex_delete(RAW_MUTEX *mutex_ptr)
{
	LIST *block_list_head;
	
	RAW_SR_ALLOC();

	#if (RAW_MUTEX_FUNCTION_CHECK > 0)

	if (mutex_ptr == 0) {
		return RAW_NULL_OBJECT;
	}
	
	#endif
	
	RAW_CRITICAL_ENTER();

	if (mutex_ptr->common_block_obj.object_type != RAW_MUTEX_OBJ_TYPE) {
		
		RAW_CRITICAL_EXIT();  
		return RAW_ERROR_OBJECT_TYPE;
	}

	block_list_head = &mutex_ptr->common_block_obj.block_list;
	
	mutex_ptr->common_block_obj.object_type = RAW_OBJ_TYPE_NONE;

	if (mutex_ptr->mtxtsk) {
		release_mutex(mutex_ptr->mtxtsk, mutex_ptr);
	}
	
	/*All task blocked on this mutex is waken up*/
	while (!is_list_empty(block_list_head)) {
		delete_pend_obj(raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list));	
	}              

	RAW_CRITICAL_EXIT();

	TRACE_MUTEX_DELETE(raw_task_active, mutex_ptr);
		
	raw_sched(); 
	
	return RAW_SUCCESS;
}
Ejemplo n.º 25
0
void raw_task_free_mutex(RAW_TASK_OBJ *tcb)
{
	RAW_MUTEX	*mtxcb, *next_mtxcb;
	RAW_TASK_OBJ	*next_tcb;
	LIST 				*block_list_head;
	
	next_mtxcb = tcb->mtxlist;
	while ((mtxcb = next_mtxcb) != 0) {
		next_mtxcb = mtxcb->mtxlist;

		block_list_head = &mtxcb->common_block_obj.block_list;
		
		if (!is_list_empty(block_list_head)) {
			
			next_tcb = raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list);

			/* Wake wait task */
			raw_wake_object(next_tcb);

			/* Change mutex get task */
			mtxcb->mtxtsk = next_tcb;
			mtxcb->mtxlist = next_tcb->mtxlist;
			next_tcb->mtxlist = mtxcb;

			if (mtxcb->policy == RAW_MUTEX_CEILING_POLICY) {
				if (next_tcb->priority > mtxcb->ceiling_prio) {
					/* Raise the priority for the task
					   that got lock to the highest
					   priority limit */
					change_internal_task_priority(next_tcb, mtxcb->ceiling_prio);
				}
			}
		} 

		else {
			/* No wait task */
			mtxcb->mtxtsk = 0;
		}
		
	}
	
}
Ejemplo n.º 26
0
/*

Must use critical section to protect alloc_ioreq and free_ioreq,
due to the irq level possibilities of the callers.
This is to guarantee the atomic context of the service.

*/
struct io_req *alloc_ioreq(struct io_queue *pio_q)
{
	_irqL	irqL;
	_list	*phead = &pio_q->free_ioreqs;
	struct io_req *preq = NULL;

_func_enter_;

	_enter_critical(&pio_q->lock, &irqL);

	if (is_list_empty(phead) == _FALSE)
	{
		preq = LIST_CONTAINOR(get_next(phead), struct io_req, list);
		list_delete(&preq->list);

		//_memset((u8 *)preq, 0, sizeof(struct io_req));//!!!

		_init_listhead(&preq->list);	
		_init_sema(&preq->sema, 0);

	}
Ejemplo n.º 27
0
/*
0	struct	list_head	free_txirp_mgt;
1	struct	list_head	free_txirp_small;
2	struct	list_head	free_txirp_medium;
3	struct	list_head	free_txirp_large;
*/
struct txirp *alloc_txirp(_adapter *padapter)
{
	_irqL flags;
	struct txirp *irp = NULL;
	struct mib_info *pmibinfo = &(padapter->_sys_mib);
	_list *head = &(pmibinfo->free_txirp_mgt);

	_enter_critical(&(pmibinfo->free_txirp_mgt_lock), &flags);

	if(is_list_empty(head)==_TRUE)
		goto ret;

	irp = LIST_CONTAINOR(head->next, struct txirp, list);
	list_delete(head->next);

	memset( (u8*)irp->txbuf_phyaddr, 0, TXMGTBUF_SZ);
	irp->tx_len = 0;
ret:
	_exit_critical(&(pmibinfo->free_txirp_mgt_lock), &flags);

	return irp;
}
Ejemplo n.º 28
0
/*
 * Schedules a timer into the active_timer list.  Usually the timer is 
 * requisitioned from the passive_timer list to avoid making extra calls
 * to malloc, but will allocate memory for a new counter if there are no
 * inactive timers available
 */
struct Timer   *
timer_schedule(void (*timeout) (struct Timer * t, Any_Type arg),
	       Any_Type subject, Time delay)
{
	struct Timer   *t;

	if (!is_list_empty(passive_timers)) {
		Any_Type        a = list_pop(passive_timers);
		t = (struct Timer *) a.vp;
	} else if ((t = malloc(sizeof(struct Timer))) == NULL)
		return NULL;

	memset(t, 0, sizeof(struct Timer));
	t->timeout_callback = timeout;
	t->has_expired = false;
	t->timer_subject = subject;
	t->time_started = timer_now();
	t->timeout_delay = delay;

	if (delay > 0)
	{
		Any_Type temp;
		temp.vp = (void *)t;
		list_push(active_timers, temp);
	}
	else
	{
		Any_Type temp;
		temp.vp = (void *)t;
		list_push(persistent_timers, temp);
	}

	if (DBG > 2)
		fprintf(stderr,
			"timer_schedule: t=%p, delay=%gs, subject=%lx\n", t,
			delay, subject.l);

	return t;
}
Ejemplo n.º 29
0
struct evt_obj* dequeue_evt(_queue *queue)
{
	_irqL irqL;
	struct	evt_obj	*pevtobj;

_func_enter_;

	_enter_critical_ex(&queue->lock, &irqL);

	if (is_list_empty(&(queue->queue)))
		pevtobj = NULL;
	else
	{
		pevtobj = LIST_CONTAINOR(get_next(&(queue->queue)), struct evt_obj, list);
		list_delete(&pevtobj->list);
	}

	_exit_critical_ex(&queue->lock, &irqL);

_func_exit_;

	return pevtobj;
}
Ejemplo n.º 30
0
void free_arch(ARCH arch)
{
	/* free text, data, bss sections */
	for (int i = 0; i < 4 ; i++) {
		free((arch->sections[i]).name);
		free((arch->sections[i]).data);
	}

	/* free symbol table */
	free(arch->symbols);

	/* free breakpoints list */
	if (!is_list_empty(arch->breakpoints))
		free_list(arch->breakpoints);
	
	free(arch->symbols_names);

	/* free instructions array*/
	free_desc_array();

	/* last but not least */
	free(arch);
}