oldmem.c

一种操作系统源码核

    PARTITION_LIST  *pheader  ;
    oldstatus=FALSE;

    suspend_list=(MEM_WAIT_QUEUE *)(pool_ptr->task_wait_header);
	 //   DoProtect();
    if (suspend_list){
	 	
    do {
	request_size=suspend_list->request_size;
       if ((*size)*(pool_ptr->partition_size) >= request_size){
	  task_ptr=suspend_list->suspended_task;
	  suspend_list->return_pointer=(VOID *)((*free_memory)->partition_address);
	  status=_ResumeTask(task_ptr,MEMORY_SUSPEND);
	  if (status==TRUE) oldstatus=status;
	  i=0;
	  if (type){
		 pheader=*free_memory;		
		 while(request_size>0){
                    i++;
                    request_size-=pool_ptr->partition_size;
		    pheader= pheader->next;
		    (*free_memory)->availables--;
		    pheader->allocated=TRUE;
		   
	    	}
		  
	    	(*free_memory)->allocated_size=i;
	    	pheader->availables=(*free_memory)->availables;
	    	*free_memory=pheader;
	   	pheader=*free_memory+(*free_memory)->availables-1;	
		pheader->availables=(*free_memory)->availables;
          }
          else{
          	 while(request_size>0){
                    i++;
                    request_size-=pool_ptr->partition_size;
                    }	
		  *free_memory=(*free_memory)+i;
	    }	  
	 *size-=i;
	  if (size==0) break;
       }//end if 
      suspend_list=(MEM_WAIT_QUEUE *)(suspend_list->next);
    }while(suspend_list!=(MEM_WAIT_QUEUE *)(pool_ptr->task_wait_header));
	   
   } //end if 
	 
  return (oldstatus);

}
INT8U FreeBuff(VOID *memory)
{
	INT8U status;
	INT8U found;
	UNSIGNED size;
	MEM_MCB *pool_ptr;
	PARTITION_LIST  *allocated_memory,*pheader,*prev_header,*next_header;
     
	UNSIGNED i,j,k;
	  if (memory== NULL ) {                                 /* Not allowed to delete idle pool     */
		  return (ERR_INVALID_POINTER);
	 }
	 #ifdef OPTION_ENABLE_STACK_CHECK
		Check_Stack();
	 #endif
	 #ifdef OPTION_ENABLE_HISTORY
	  MakeHistoryLog(DELETE_TASK,pool_ptr->name,SYSTIME);//在日志中记录操作，时间等信息
	 #endif

	 /**************************************************************************
	 寻找所在的存储池
	 ***************************************************************************/
	 pool_ptr=(MEM_MCB *)CreatedPoolsList;
	 found=FALSE;
	 ProtectStruct(MEMLIST_PROTECT);
	 do {
	    if ((memory>=pool_ptr->start_address) && (memory < (INT8U *)(pool_ptr->start_address)+pool_ptr->pool_size)){
		found=TRUE;
		  break;
		}
		pool_ptr=(MEM_MCB *)(pool_ptr->linknode.next);
	 }while(pool_ptr != (MEM_MCB *)CreatedPoolsList);
	 UnProtectStruct(MEMLIST_PROTECT);
	 if (!found) return (ERR_INVALID_POINTER);
	  /**************************************************************************
	 寻找属于哪个已分配的存储块
	 ***************************************************************************/
	 found=FALSE;
	 allocated_memory=(PARTITION_LIST *)pool_ptr->partition_list_header;
	 do {
	    if (memory==(VOID *)(allocated_memory->partition_address)){
		found=TRUE;
		  break;
		}
	  allocated_memory=(PARTITION_LIST *)(allocated_memory->next);
	 }while(allocated_memory != (PARTITION_LIST *)pool_ptr->partition_list_header);
	  if (!found){
	  	 DoUnProtect(pool_ptr);
	  	 return (ERR_INVALID_POINTER);
	  	}
	    
         size=allocated_memory->allocated_size;
        status= _FreeTask(pool_ptr,&allocated_memory,&size,FALSE);
	 
	if(size==0) {
		 if (status==TRUE) _ControlToSystem();
	        return (SUCCESS);
	 }   
	 pheader=allocated_memory;
	 allocated_memory->allocated_size=size;
	 while (size--){
		pheader->allocated=FALSE;
		pheader=pheader->next;

	   }
	   i=allocated_memory->allocated_size;
	   j=0;
	   k=0;
	 if(allocated_memory != pool_ptr->partition_list_header){
	   if((allocated_memory->previous)->allocated==FALSE){
		prev_header=(PARTITION_LIST *)(allocated_memory->previous);
		j=prev_header->availables;
		prev_header=prev_header-(j-1);
	        Remove_From_RdyList(&(LIST_NODE *)(pool_ptr->available_partition_header),(LIST_NODE *)prev_header);

	  }
	 }
	if(pheader != pool_ptr->partition_list_header){
	     if((pheader->allocated)==FALSE){
	     next_header=pheader;
	     k=next_header->availables;
	     next_header=next_header+k-1;
	     Remove_From_RdyList(&(LIST_NODE *)(pool_ptr->available_partition_header),(LIST_NODE *)next_header);
	    }
	  }
	if(j && k){
		prev_header->availables=i+j+k;
		next_header->availables=i+j+k;
		pheader=prev_header;
	     }
	else if(j){
		prev_header->availables=i+j;
		(allocated_memory+i-1)->availables=i+j;
		pheader=prev_header;

		}
	 else if(k){
		allocated_memory->availables=i+k;
		next_header->availables=i+k;
		pheader=allocated_memory;
	   }
	else{
	     allocated_memory->availables=i;
	    (allocated_memory+i-1)->availables=i;
	     pheader=allocated_memory;
	  }
	size=pheader->availables ;	
	if(size!=i)
	  status= _FreeTask(pool_ptr,&pheader,&size,TRUE);
	 if(size==1)
	     Place_On_RdyList(&(LIST_NODE *)(pool_ptr->available_partition_header),(LIST_NODE *)pheader);
	 else if (size>1)
	    Priority_Place_On_RdyList(&(LIST_NODE *)(pool_ptr->available_partition_header),(LIST_NODE *)pheader);
	      
	 DoUnProtect(pool_ptr);
	 if (status==TRUE) _ControlToSystem();
	   return (SUCCESS);


}
/*
*********************************************************************************************************
*            This function removing a suspension block from a Mem pool.
Functions Called
 Remove_From_List
*********************************************************************************************************
*/
static VOID MemCleanup(VOID *information)
{
     MEM_MCB *pool_ptr;
      TASK_TCB *task_ptr;
    MEM_WAIT_QUEUE *linknode;
     pool_ptr=(MEM_MCB *)information;
      DoUnProtect(pool_ptr);
     DisableInt();
    linknode=pool_ptr->task_wait_header;
	 do{
	    task_ptr=linknode->suspended_task;
	    if (task_ptr==CurrentThread)
	       Remove_From_List(&(LIST_NODE *)(pool_ptr->task_wait_header),(LIST_NODE *)(linknode));
	    linknode=(MEM_WAIT_QUEUE *)(linknode->next) ;
	    if (linknode==NULL) break;
	  }while(linknode!=pool_ptr->task_wait_header);

      EnableInt();
}
#ifdef CPU32
/*
*********************************************************************************************************
*            This function returns the current number of established Mem pools.
Functions Called
[ Check_Stack]
*********************************************************************************************************
*/
UNSIGNED GetTotalMemPools(VOID)
{
	#ifdef OPTION_ENABLE_STACK_CHECK
		CheckStack();
	 #endif
	return(Total_Pools);                             /* Increment the #pools counter           */


}
/*
*********************************************************************************************************
*          This function returns information about the specified Mem pool.
Functions Called
[ Check_Stack]
 System_Protect
 Unprotect
*********************************************************************************************************
*/
INT8U  GetMemPoolInfo(MEM_MCB *pool_ptr,UNSIGNED *avalables,TASK_TCB **first_task)
{
       PARTITION_LIST *pheader; 
       UNSIGNED num;
	 if (pool_ptr == NULL) {                                 /* Not allowed to delete idle task     */
		  return (ERR_INVALID_POOL);
	 }

	 #ifdef OPTION_ENABLE_STACK_CHECK
		CheckStack();
	 #endif
		      DoProtect(pool_ptr);
	 pheader=(PARTITION_LIST *)(pool_ptr->available_partition_header);
	  num=0;
	 do {
	   num+=pheader->availables;
	  pheader=pheader->nextrdy;
	 }while(pheader!= (PARTITION_LIST *)pool_ptr->available_partition_header);
	 
	 *availables=num*(pool_ptr->partition_size);
	 *first_task=(pool_ptr->task_wait_header)->suspended_task;
			 
			DoUnProtect(pool_ptr); 
		      return (SUCCESS);

}
#endif
/*
*********************************************************************************************************
*         This function initializes the data structures  of  Mem pool.

*********************************************************************************************************
*/
VOID MemPoolInit(VOID)
{
   CreatedPoolsList=NULL;
   
}