www.pudn.com > uCOS-II.rar > os_mem.c, change:2003-12-20,size:18700b


/* 
********************************************************************************************************* 
*                                                uC/OS-II 
*                                          The Real-Time Kernel 
*                                            MEMORY MANAGEMENT 
* 
*                          (c) Copyright 1992-2003, Jean J. Labrosse, Weston, FL 
*                                           All Rights Reserved 
* 
* File    : OS_MEM.C 
* By      : Jean J. Labrosse 
* Version : V2.76 
********************************************************************************************************* 
*/ 
 
#ifndef  OS_MASTER_FILE 
#include <ucos_ii.h> 
#endif 
 
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0) 
/* 
********************************************************************************************************* 
*                                        CREATE A MEMORY PARTITION 
* 
* Description : Create a fixed-sized memory partition that will be managed by uC/OS-II. 
* 
* Arguments   : addr     is the starting address of the memory partition 
* 
*               nblks    is the number of memory blocks to create from the partition. 
* 
*               blksize  is the size (in bytes) of each block in the memory partition. 
* 
*               err      is a pointer to a variable containing an error message which will be set by 
*                        this function to either: 
* 
*                        OS_NO_ERR            if the memory partition has been created correctly. 
*                        OS_MEM_INVALID_ADDR  you are specifying an invalid address for the memory  
*                                             storage of the partition. 
*                        OS_MEM_INVALID_PART  no free partitions available 
*                        OS_MEM_INVALID_BLKS  user specified an invalid number of blocks (must be >= 2) 
*                        OS_MEM_INVALID_SIZE  user specified an invalid block size 
*                                             (must be greater than the size of a pointer) 
* Returns    : != (OS_MEM *)0  is the partition was created 
*              == (OS_MEM *)0  if the partition was not created because of invalid arguments or, no 
*                              free partition is available. 
********************************************************************************************************* 
*/ 
 
OS_MEM  *OSMemCreate (void *addr, INT32U nblks, INT32U blksize, INT8U *err) 
{ 
    OS_MEM    *pmem; 
    INT8U     *pblk; 
    void     **plink; 
    INT32U     i; 
#if OS_CRITICAL_METHOD == 3                           /* Allocate storage for CPU status register      */ 
    OS_CPU_SR  cpu_sr; 
 
 
 
    cpu_sr = 0;                                       /* Prevent compiler warning                       */ 
#endif     
#if OS_ARG_CHK_EN > 0 
    if (addr == (void *)0) {                          /* Must pass a valid address for the memory part. */ 
        *err = OS_MEM_INVALID_ADDR; 
        return ((OS_MEM *)0); 
    } 
    if (nblks < 2) {                                  /* Must have at least 2 blocks per partition      */ 
        *err = OS_MEM_INVALID_BLKS; 
        return ((OS_MEM *)0); 
    } 
    if (blksize < sizeof(void *)) {                   /* Must contain space for at least a pointer      */ 
        *err = OS_MEM_INVALID_SIZE; 
        return ((OS_MEM *)0); 
    } 
#endif 
    OS_ENTER_CRITICAL(); 
    pmem = OSMemFreeList;                             /* Get next free memory partition                */ 
    if (OSMemFreeList != (OS_MEM *)0) {               /* See if pool of free partitions was empty      */ 
        OSMemFreeList = (OS_MEM *)OSMemFreeList->OSMemFreeList; 
    } 
    OS_EXIT_CRITICAL(); 
    if (pmem == (OS_MEM *)0) {                        /* See if we have a memory partition             */ 
        *err = OS_MEM_INVALID_PART; 
        return ((OS_MEM *)0); 
    } 
    plink = (void **)addr;                            /* Create linked list of free memory blocks      */ 
    pblk  = (INT8U *)((INT32U)addr + blksize); 
    for (i = 0; i < (nblks - 1); i++) { 
       *plink = (void *)pblk;                         /* Save pointer to NEXT block in CURRENT block   */ 
        plink = (void **)pblk;                        /* Position to  NEXT      block                  */ 
        pblk  = (INT8U *)((INT32U)pblk + blksize);    /* Point to the FOLLOWING block                  */ 
    } 
    *plink              = (void *)0;                  /* Last memory block points to NULL              */ 
    pmem->OSMemAddr     = addr;                       /* Store start address of memory partition       */ 
    pmem->OSMemFreeList = addr;                       /* Initialize pointer to pool of free blocks     */ 
    pmem->OSMemNFree    = nblks;                      /* Store number of free blocks in MCB            */ 
    pmem->OSMemNBlks    = nblks; 
    pmem->OSMemBlkSize  = blksize;                    /* Store block size of each memory blocks        */ 
    *err                = OS_NO_ERR; 
    return (pmem); 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                          GET A MEMORY BLOCK 
* 
* Description : Get a memory block from a partition 
* 
* Arguments   : pmem    is a pointer to the memory partition control block 
* 
*               err     is a pointer to a variable containing an error message which will be set by this 
*                       function to either: 
* 
*                       OS_NO_ERR           if the memory partition has been created correctly. 
*                       OS_MEM_NO_FREE_BLKS if there are no more free memory blocks to allocate to caller 
*                       OS_MEM_INVALID_PMEM if you passed a NULL pointer for 'pmem' 
* 
* Returns     : A pointer to a memory block if no error is detected 
*               A pointer to NULL if an error is detected 
********************************************************************************************************* 
*/ 
 
void  *OSMemGet (OS_MEM *pmem, INT8U *err) 
{ 
    void      *pblk; 
#if OS_CRITICAL_METHOD == 3                           /* Allocate storage for CPU status register      */ 
    OS_CPU_SR  cpu_sr; 
 
 
 
    cpu_sr = 0;                                       /* Prevent compiler warning                       */ 
#endif     
#if OS_ARG_CHK_EN > 0 
    if (pmem == (OS_MEM *)0) {                        /* Must point to a valid memory partition         */ 
        *err = OS_MEM_INVALID_PMEM; 
        return ((OS_MEM *)0); 
    } 
#endif 
    OS_ENTER_CRITICAL(); 
    if (pmem->OSMemNFree > 0) {                       /* See if there are any free memory blocks       */ 
        pblk                = pmem->OSMemFreeList;    /* Yes, point to next free memory block          */ 
        pmem->OSMemFreeList = *(void **)pblk;         /*      Adjust pointer to new free list          */ 
        pmem->OSMemNFree--;                           /*      One less memory block in this partition  */ 
        OS_EXIT_CRITICAL(); 
        *err = OS_NO_ERR;                             /*      No error                                 */ 
        return (pblk);                                /*      Return memory block to caller            */ 
    } 
    OS_EXIT_CRITICAL(); 
    *err = OS_MEM_NO_FREE_BLKS;                       /* No,  Notify caller of empty memory partition  */ 
    return ((void *)0);                               /*      Return NULL pointer to caller            */ 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                   GET THE NAME OF A MEMORY PARTITION 
* 
* Description: This function is used to obtain the name assigned to a memory partition. 
* 
* Arguments  : pmem      is a pointer to the memory partition 
* 
*              pname     is a pointer to an ASCII string that will receive the name of the memory partition. 
* 
*              err       is a pointer to an error code that can contain one of the following values: 
* 
*                        OS_NO_ERR                  if the name was copied to 'pname' 
*                        OS_MEM_INVALID_PMEM        if you passed a NULL pointer for 'pmem' 
*                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname' 
* 
* Returns    : The length of the string or 0 if 'pmem' is a NULL pointer. 
********************************************************************************************************* 
*/ 
 
#if OS_MEM_NAME_SIZE > 1 
INT8U  OSMemNameGet (OS_MEM *pmem, char *pname, INT8U *err) 
{ 
    INT8U      len; 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
 
 
 
    cpu_sr = 0;                                  /* Prevent compiler warning                           */ 
#endif     
    OS_ENTER_CRITICAL(); 
#if OS_ARG_CHK_EN > 0 
    if (pmem == (OS_MEM *)0) {                   /* Is 'pmem' a NULL pointer?                          */ 
        OS_EXIT_CRITICAL();                      /* Yes                                                */ 
        *err = OS_MEM_INVALID_PMEM; 
        return (0); 
    } 
    if (pname == (char *)0) {                    /* Is 'pname' a NULL pointer?                         */ 
        OS_EXIT_CRITICAL();                      /* Yes                                                */ 
        *err = OS_ERR_PNAME_NULL; 
        return (0); 
    } 
#endif 
    len  = OS_StrCopy(pname, pmem->OSMemName);   /* Copy name from OS_MEM                              */ 
    OS_EXIT_CRITICAL(); 
    *err = OS_NO_ERR; 
    return (len); 
} 
#endif 
 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                 ASSIGN A NAME TO A MEMORY PARTITION 
* 
* Description: This function assigns a name to a memory partition. 
* 
* Arguments  : pmem      is a pointer to the memory partition 
* 
*              pname     is a pointer to an ASCII string that contains the name of the memory partition. 
* 
*              err       is a pointer to an error code that can contain one of the following values: 
* 
*                        OS_NO_ERR                  if the name was copied to 'pname' 
*                        OS_MEM_INVALID_PMEM        if you passed a NULL pointer for 'pmem' 
*                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname' 
*						 OS_MEM_NAME_TOO_LONG       if the name doesn't fit in the storage area 
* 
* Returns    : None 
********************************************************************************************************* 
*/ 
 
#if OS_MEM_NAME_SIZE > 1 
void  OSMemNameSet (OS_MEM *pmem, char *pname, INT8U *err) 
{ 
    INT8U      len; 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
 
 
 
    cpu_sr = 0;                                  /* Prevent compiler warning                           */ 
#endif     
    OS_ENTER_CRITICAL(); 
#if OS_ARG_CHK_EN > 0 
    if (pmem == (OS_MEM *)0) {                   /* Is 'pmem' a NULL pointer?                          */ 
        OS_EXIT_CRITICAL();                      /* Yes                                                */ 
        *err = OS_MEM_INVALID_PMEM; 
        return; 
    } 
    if (pname == (char *)0) {                    /* Is 'pname' a NULL pointer?                         */ 
        OS_EXIT_CRITICAL();                      /* Yes                                                */ 
        *err = OS_ERR_PNAME_NULL; 
        return; 
    } 
#endif 
    len = OS_StrLen(pname);                      /* Can we fit the string in the storage area?         */ 
    if (len > (OS_MEM_NAME_SIZE - 1)) {          /* No                                                 */ 
        OS_EXIT_CRITICAL(); 
        *err = OS_MEM_NAME_TOO_LONG; 
        return; 
    }  
    (void)OS_StrCopy(pmem->OSMemName, pname);    /* Yes, copy name to the memory partition header      */ 
    OS_EXIT_CRITICAL(); 
    *err = OS_NO_ERR; 
} 
#endif 
 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                         RELEASE A MEMORY BLOCK 
* 
* Description : Returns a memory block to a partition 
* 
* Arguments   : pmem    is a pointer to the memory partition control block 
* 
*               pblk    is a pointer to the memory block being released. 
* 
* Returns     : OS_NO_ERR            if the memory block was inserted into the partition 
*               OS_MEM_FULL          if you are returning a memory block to an already FULL memory  
*                                    partition (You freed more blocks than you allocated!) 
*               OS_MEM_INVALID_PMEM  if you passed a NULL pointer for 'pmem' 
*               OS_MEM_INVALID_PBLK  if you passed a NULL pointer for the block to release. 
********************************************************************************************************* 
*/ 
 
INT8U  OSMemPut (OS_MEM *pmem, void *pblk) 
{ 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
     
     
 
    cpu_sr = 0;                                  /* Prevent compiler warning                           */ 
#endif     
#if OS_ARG_CHK_EN > 0 
    if (pmem == (OS_MEM *)0) {                   /* Must point to a valid memory partition             */ 
        return (OS_MEM_INVALID_PMEM); 
    } 
    if (pblk == (void *)0) {                     /* Must release a valid block                         */ 
        return (OS_MEM_INVALID_PBLK); 
    } 
#endif 
    OS_ENTER_CRITICAL(); 
    if (pmem->OSMemNFree >= pmem->OSMemNBlks) {  /* Make sure all blocks not already returned          */ 
        OS_EXIT_CRITICAL(); 
        return (OS_MEM_FULL); 
    } 
    *(void **)pblk      = pmem->OSMemFreeList;   /* Insert released block into free block list         */ 
    pmem->OSMemFreeList = pblk; 
    pmem->OSMemNFree++;                          /* One more memory block in this partition            */ 
    OS_EXIT_CRITICAL(); 
    return (OS_NO_ERR);                          /* Notify caller that memory block was released       */ 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                          QUERY MEMORY PARTITION 
* 
* Description : This function is used to determine the number of free memory blocks and the number of 
*               used memory blocks from a memory partition. 
* 
* Arguments   : pmem        is a pointer to the memory partition control block 
* 
*               p_mem_data  is a pointer to a structure that will contain information about the memory 
*                           partition. 
* 
* Returns     : OS_NO_ERR            If no errors were found. 
*               OS_MEM_INVALID_PMEM  if you passed a NULL pointer for 'pmem' 
*               OS_MEM_INVALID_PDATA if you passed a NULL pointer to the data recipient. 
********************************************************************************************************* 
*/ 
 
#if OS_MEM_QUERY_EN > 0 
INT8U  OSMemQuery (OS_MEM *pmem, OS_MEM_DATA *p_mem_data) 
{ 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
     
     
 
    cpu_sr = 0;                                  /* Prevent compiler warning                           */ 
#endif     
#if OS_ARG_CHK_EN > 0 
    if (pmem == (OS_MEM *)0) {                   /* Must point to a valid memory partition             */ 
        return (OS_MEM_INVALID_PMEM); 
    } 
    if (p_mem_data == (OS_MEM_DATA *)0) {        /* Must release a valid storage area for the data     */ 
        return (OS_MEM_INVALID_PDATA); 
    } 
#endif 
    OS_ENTER_CRITICAL(); 
    p_mem_data->OSAddr     = pmem->OSMemAddr; 
    p_mem_data->OSFreeList = pmem->OSMemFreeList; 
    p_mem_data->OSBlkSize  = pmem->OSMemBlkSize; 
    p_mem_data->OSNBlks    = pmem->OSMemNBlks; 
    p_mem_data->OSNFree    = pmem->OSMemNFree; 
    OS_EXIT_CRITICAL(); 
    p_mem_data->OSNUsed    = p_mem_data->OSNBlks - p_mem_data->OSNFree; 
    return (OS_NO_ERR); 
} 
#endif                                           /* OS_MEM_QUERY_EN                                    */ 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                    INITIALIZE MEMORY PARTITION MANAGER 
* 
* Description : This function is called by uC/OS-II to initialize the memory partition manager.  Your 
*               application MUST NOT call this function. 
* 
* Arguments   : none 
* 
* Returns     : none 
* 
* Note(s)    : This function is INTERNAL to uC/OS-II and your application should not call it. 
********************************************************************************************************* 
*/ 
 
void  OS_MemInit (void) 
{ 
#if OS_MAX_MEM_PART == 1 
    OSMemFreeList = (OS_MEM *)&OSMemTbl[0];             /* Point to beginning of free list             */ 
    OS_MemClr((INT8U *)&OSMemTbl[0], sizeof(OSMemTbl)); /* Clear the memory partition table            */ 
#endif 
 
#if OS_MAX_MEM_PART >= 2 
    OS_MEM  *pmem; 
    INT16U   i; 
 
 
    OS_MemClr((INT8U *)&OSMemTbl[0], sizeof(OSMemTbl)); /* Clear the memory partition table            */ 
    pmem = (OS_MEM *)&OSMemTbl[0];                      /* Point to memory control block (MCB)         */ 
    for (i = 0; i < (OS_MAX_MEM_PART - 1); i++) {       /* Init. list of free memory partitions        */ 
        pmem->OSMemFreeList = (void *)&OSMemTbl[i+1];   /* Chain list of free partitions               */ 
#if OS_MEM_NAME_SIZE > 1 
        pmem->OSMemName[0]  = '?';                      /* Unknown name                                */ 
        pmem->OSMemName[1]  = OS_ASCII_NUL; 
#endif 
        pmem++; 
    } 
    pmem->OSMemFreeList = (void *)0;                    /* Initialize last node                        */ 
#if OS_MEM_NAME_SIZE > 1 
    pmem->OSMemName[0]  = '?';                          /* Unknown name                                */ 
    pmem->OSMemName[1]  = OS_ASCII_NUL; 
#endif 
 
    OSMemFreeList       = (OS_MEM *)&OSMemTbl[0];       /* Point to beginning of free list             */ 
#endif 
} 
#endif                                                  /* OS_MEM_EN                                   */