oldmem.c

一种操作系统源码核

#include "ebos.h"

/*
*********************************************************************************************************
*                                         Mem Mem implement FILE
*********************************************************************************************************
*/


/*
*********************************************************************************************************
*                                   Creates a Dyn_MEMory Mem pool and then places it on the list of created Mem pools.
Functions Called
 Place_On_List
[HIC_Make_History_Entry]
[ Check_Stack]
 Protect
 Unprotect
*********************************************************************************************************
*/

static INT32U Total_Pools;
static VOID MemCleanup(VOID *information);

INT8U CreateMemPool(MEM_MCB *pool_ptr,VOID *start_address,
	  INT32U pool_size,INT32U partition_size,INT8U suspend_type)
{
	 UNSIGNED i;
	 UNSIGNED pages,start_partition;
	 PARTITION_LIST * pheader;
	 if (pool_ptr==NULL)  return(ERR_INVALID_POOL);
	 if(start_address==NULL) return(ERR_INVALID_MEMORY);
	 if(partition_size==0 ||pool_size==0 ||partition_size>pool_size ) return(ERR_INVALID_SIZE);
	 if (suspend_type!=FIFO && suspend_type!=PRIORITY) return(ERR_INVALID_SUSPEND);
	 if (pool_ptr->type_id==MEM)  return (SUCCESS);
	 #ifdef OPTION_ENABLE_STACK_CHECK
		Check_Stack();
	 #endif
	 #ifdef OPTION_ENABLE_HISTORY
	     MakeHistoryLog(CREATE_pool,pool_ptr->pool_name);//在日志中记录操作，时间等信息
	 #endif
		pages=pool_size/partition_size;

		  pool_ptr->id = IDNumber++ ;


		  start_partition=(pages*sizeof(PARTITION_LIST)) / partition_size;
		  if ((pages*sizeof(PARTITION_LIST )) % partition_size)
		     start_partition++;

		 DoProtect(pool_ptr);
		    pool_ptr->type_id=MEM_POOL;
		  pool_ptr->start_address=start_address;
		  pool_ptr->pool_size=pool_size;

		  pool_ptr->suspend_type=suspend_type;
		  pool_ptr->task_wait_header=NULL;
		  pool_ptr->partition_size=partition_size;
		   pool_ptr->partition_list_header=(PARTITION_LIST *)start_address;
		  pool_ptr->partition_list_header->availables=pages;
		 pool_ptr->available_partition_header=(PARTITION_LIST *)start_address;
		  for(i=0;i<pages;i++)
		  {
		    pheader=(PARTITION_LIST *)((INT8U *)start_address+i*sizeof(PARTITION_LIST));
		    pheader->partition_address=((INT8U *)start_address+(start_partition*partition_size+i*partition_size));
		    pheader->allocated=FALSE;
		    Place_On_List(&(LIST_NODE *)(pool_ptr->partition_list_header),(LIST_NODE *)pheader);
              
		 }
		  pheader->availables=pages;
                pool_ptr->available_partition_header->prevrdy=pool_ptr->available_partition_header;
                pool_ptr->available_partition_header->nextrdy=pool_ptr->available_partition_header;
	         DoUnProtect(pool_ptr);
	         #ifdef CPU32
                    ProtectStruct(MEMLIST_PROTECT);
			Place_On_List(&(LIST_NODE *)(CreatedPoolsList),&(pool_ptr->linknode));
			Total_Pools++;                             /* Increment the #pools counter           */
                    UnProtectStruct(MEMLIST_PROTECT);
                 #endif
			

		  return( SUCCESS);

}
/*
*********************************************************************************************************
*                                   This function deletes a PART_MEMory Mem pool
Functions Called
 Remove_From_List
[Make_History_Entry]
Resume_Task
[Check_Stack]
Control_To_System
Protect
Unprotect
*********************************************************************************************************
*/
 INT8U DeleteMemPool(MEM_MCB *pool_ptr)
 {
   INT8U state,oldstate;

    if (pool_ptr == NULL) {                                 /* Not allowed to delete idle pool     */
	return (ERR_INVALID_POOL);
    }
    #ifdef OPTION_ENABLE_STACK_CHECK
      Check_Stack();
    #endif
     #ifdef OPTION_ENABLE_HISTORY
	   MakeHistoryLog(DELETE_TASK,pool_ptr->name);//在日志中记录操作，时间等信息
     #endif
     oldstate=0;
     DoProtect(pool_ptr); 
      while(pool_ptr->task_wait_header)
      {
         state=_ResumeTask(pool_ptr->task_wait_header->suspended_task,MEMORY_SUSPEND);
	if(state==TRUE) oldstate =state;
	 Remove_From_List(&(LIST_NODE *)(pool_ptr->task_wait_header),(LIST_NODE *)(pool_ptr->task_wait_header));
       } 
       pool_ptr->type_id=INIT;
      DoUnProtect(pool_ptr);
       ProtectStruct(MEMLIST_PROTECT);
       Remove_From_List(&(LIST_NODE *)CreatedPoolsList,&(pool_ptr->linknode));
       Total_Pools--;
       UnProtectStruct(MEMLIST_PROTECT);

  
	//  Set_Current_Protect();

	if(oldstate==TRUE) _ControlToSystem();
	return (SUCCESS);

 }

/*
*********************************************************************************************************
*            This function allocates a PART_MEMory Mem from the specified PART_MEMory Mem pool.
Functions Called
 Place_On_List
 Priority_Place_On_List
[HIC_Make_History_Entry]
 Suspend_Task
 Priority
[ Check_Stack]
 CurrentThread
 System_Protect
 Unprotect
*********************************************************************************************************
*/
INT8U AllocBuff(MEM_MCB *pool_ptr,VOID **return_pointer,UNSIGNED size,INT32S suspend)
{
	  UNSIGNED i;
	 MEM_WAIT_QUEUE *suspend_list;
	 PARTITION_LIST *pheader;
	 MEM_WAIT_QUEUE task_suspend;
	if (pool_ptr == NULL) {                                 /* Not allowed to delete idle pool     */
		return (ERR_INVALID_POOL);
	 }
	  if (return_pointer == NULL) {                                 /* Not allowed to delete idle pool     */
		return (ERR_INVALID_POINTER);
	 }
	 if (size<0){
		return (ERR_INVALID_SIZE);
	 }
	   if (pool_ptr->type_id!=MEM) return(ERR_INVALID_POOL);
	  #ifdef OPTION_ENABLE_STACK_CHECK
		Check_Stack();
	  #endif
	  #ifdef OPTION_ENABLE_HISTORY
		 MakeHistoryLog(DELETE_TASK,pool_ptr->name);//在日志中记录操作，时间等信息
	  #endif
	      i=0;
         
	      DoProtect(pool_ptr);
	      if((pool_ptr->available_partition_header->availables)*(pool_ptr->partition_size)>=size){
	      
		*return_pointer=(VOID *)(((PARTITION_LIST *)(pool_ptr->available_partition_header))->partition_address);

		  pheader=pool_ptr->available_partition_header;
		   while(i*(pool_ptr->partition_size)<size){
		     pheader->allocated=TRUE;
		     i++;
		     (pool_ptr->available_partition_header->availables)--;
		     pheader= pheader->next;
		   }
		    (pool_ptr->available_partition_header)->allocated_size=i;
		    i= pool_ptr->available_partition_header->availables;
		    Remove_From_RdyList(&(LIST_NODE *)(pool_ptr->available_partition_header),(LIST_NODE *)(pool_ptr->available_partition_header));

		    pheader->availables=i;
                   if(i>1)
		   Priority_Place_On_RdyList(&(LIST_NODE *)(pool_ptr->available_partition_header),(LIST_NODE *)pheader);
		  
		    pheader=pheader+(pheader->availables-1);
		    pheader->availables=i;
		  DoUnProtect(pool_ptr);
		  return (SUCCESS);
	      }
	      else if(suspend!=NO_SUSPEND){
		 if(((TASK_TCB *)CurrentThread)->type_id !=TASK) {
		 	DoUnProtect(pool_ptr);
		 	return(ERR_INVALID_SUSPEND);
		  	}
		
		 // task_suspend.partiton_pool=pool_ptr;
		   task_suspend.request_size=size;
		  task_suspend.suspended_task=(TASK_TCB *)CurrentThread;
		  task_suspend.return_pointer=NULL;
		 
		  if(pool_ptr->suspend_type==FIFO)
			 Place_On_List(&(LIST_NODE *)(pool_ptr->task_wait_header),(LIST_NODE *)&(task_suspend));
		  else{
			 task_suspend.priority=GetPriority(CurrentThread);
			 Priority_Place_On_List(&(LIST_NODE *)(pool_ptr->task_wait_header),(LIST_NODE *)&(task_suspend));
		     }
		  DoUnProtect(pool_ptr);
		 // System_Protect()
		  _SuspendTask(CurrentThread,MEMORY_SUSPEND,MemCleanup,pool_ptr,suspend);

		 // DoUnProtect();
		  if(pool_ptr->type_id==0) {
		   	
		   return(ERR_POOL_DELETED);
		  }
		  if (task_suspend.return_pointer==NULL){
		     
		      return(ERR_TIMEOUT);
		    }
			   *return_pointer=task_suspend.return_pointer;
			    DoProtect(pool_ptr);	
			    Remove_From_List(&(LIST_NODE *)(pool_ptr->task_wait_header),(LIST_NODE *)&(task_suspend));
			  
			 DoUnProtect(pool_ptr);

		 return (SUCCESS);
	  }
	else if(suspend==NO_SUSPEND) 
	   return(ERR_NO_MEMORY);

}



/*
*********************************************************************************************************
*            This function deallocates a previously allocated Mem.
Functions Called
 Remove_From_List
[HIC_Make_History_Entry]
 Resume_Task
[ Check_Stack]
 Control_To_System
 System_Protect
 Unprotect
*********************************************************************************************************
*/
INT8U _FreeTask(MEM_MCB *pool_ptr,PARTITION_LIST **free_memory,UNSIGNED *size,INT8U type)
{      
    INT8U status,oldstatus;
    TASK_TCB *task_ptr;
    MEM_WAIT_QUEUE *suspend_list;
    INT32S request_size;	
    UNSIGNED i;