|
- /*
- ************************************************************************************************************************
- * uC/OS-III
- * The Real-Time Kernel
- *
- * (c) Copyright 2009-2014; Micrium, Inc.; Weston, FL
- * All rights reserved. Protected by international copyright laws.
- *
- * MEMORY PARTITION MANAGEMENT
- *
- * File : OS_MEM.C
- * By : JJL
- * Version : V3.04.04
- *
- * LICENSING TERMS:
- * ---------------
- * uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or
- * for peaceful research. If you plan or intend to use uC/OS-III in a commercial application/
- * product then, you need to contact Micrium to properly license uC/OS-III for its use in your
- * application/product. We provide ALL the source code for your convenience and to help you
- * experience uC/OS-III. The fact that the source is provided does NOT mean that you can use
- * it commercially without paying a licensing fee.
- *
- * Knowledge of the source code may NOT be used to develop a similar product.
- *
- * Please help us continue to provide the embedded community with the finest software available.
- * Your honesty is greatly appreciated.
- *
- * You can find our product's user manual, API reference, release notes and
- * more information at https://doc.micrium.com.
- * You can contact us at www.micrium.com.
- ************************************************************************************************************************
- */
-
- #define MICRIUM_SOURCE
- #include "os.h"
-
- #ifdef VSC_INCLUDE_SOURCE_FILE_NAMES
- const CPU_CHAR *os_mem__c = "$Id: $";
- #endif
-
-
- #if OS_CFG_MEM_EN > 0u
- /*
- ************************************************************************************************************************
- * CREATE A MEMORY PARTITION
- *
- * Description : Create a fixed-sized memory partition that will be managed by uC/OS-III.
- *
- * Arguments : p_mem is a pointer to a memory partition control block which is allocated in user memory space.
- *
- * p_name is a pointer to an ASCII string to provide a name to the memory partition.
- *
- * p_addr is the starting address of the memory partition
- *
- * n_blks is the number of memory blocks to create from the partition.
- *
- * blk_size is the size (in bytes) of each block in the memory partition.
- *
- * p_err is a pointer to a variable containing an error message which will be set by this function to
- * either:
- *
- * OS_ERR_NONE if the memory partition has been created correctly.
- * OS_ERR_ILLEGAL_CREATE_RUN_TIME if you are trying to create the memory partition after you
- * called OSSafetyCriticalStart().
- * OS_ERR_MEM_INVALID_BLKS user specified an invalid number of blocks (must be >= 2)
- * OS_ERR_MEM_INVALID_P_ADDR if you are specifying an invalid address for the memory
- * storage of the partition or, the block does not align on a
- * pointer boundary
- * OS_ERR_MEM_INVALID_SIZE user specified an invalid block size
- * - must be greater than the size of a pointer
- * - must be able to hold an integral number of pointers
- * Returns : none
- ************************************************************************************************************************
- */
-
- void OSMemCreate (OS_MEM *p_mem,
- CPU_CHAR *p_name,
- void *p_addr,
- OS_MEM_QTY n_blks,
- OS_MEM_SIZE blk_size,
- OS_ERR *p_err)
- {
- #if OS_CFG_ARG_CHK_EN > 0u
- CPU_DATA align_msk;
- #endif
- OS_MEM_QTY i;
- OS_MEM_QTY loops;
- CPU_INT08U *p_blk;
- void **p_link;
- CPU_SR_ALLOC();
-
-
-
- #ifdef OS_SAFETY_CRITICAL
- if (p_err == (OS_ERR *)0) {
- OS_SAFETY_CRITICAL_EXCEPTION();
- return;
- }
- #endif
-
- #ifdef OS_SAFETY_CRITICAL_IEC61508
- if (OSSafetyCriticalStartFlag == DEF_TRUE) {
- *p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME;
- return;
- }
- #endif
-
- #if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
- if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* Not allowed to call from an ISR */
- *p_err = OS_ERR_MEM_CREATE_ISR;
- return;
- }
- #endif
-
- #if OS_CFG_ARG_CHK_EN > 0u
- if (p_addr == (void *)0) { /* Must pass a valid address for the memory part. */
- *p_err = OS_ERR_MEM_INVALID_P_ADDR;
- return;
- }
- if (n_blks < (OS_MEM_QTY)2) { /* Must have at least 2 blocks per partition */
- *p_err = OS_ERR_MEM_INVALID_BLKS;
- return;
- }
- if (blk_size < sizeof(void *)) { /* Must contain space for at least a pointer */
- *p_err = OS_ERR_MEM_INVALID_SIZE;
- return;
- }
- align_msk = sizeof(void *) - 1u;
- if (align_msk > 0u) {
- if (((CPU_ADDR)p_addr & align_msk) != 0u){ /* Must be pointer size aligned */
- *p_err = OS_ERR_MEM_INVALID_P_ADDR;
- return;
- }
- if ((blk_size & align_msk) != 0u) { /* Block size must be a multiple address size */
- *p_err = OS_ERR_MEM_INVALID_SIZE;
- return;
- }
- }
- #endif
-
- p_link = (void **)p_addr; /* Create linked list of free memory blocks */
- p_blk = (CPU_INT08U *)p_addr;
- loops = n_blks - 1u;
- for (i = 0u; i < loops; i++) {
- p_blk += blk_size;
- *p_link = (void *)p_blk; /* Save pointer to NEXT block in CURRENT block */
- p_link = (void **)(void *)p_blk; /* Position to NEXT block */
- }
- *p_link = (void *)0; /* Last memory block points to NULL */
-
- OS_CRITICAL_ENTER();
- #if OS_OBJ_TYPE_REQ > 0u
- p_mem->Type = OS_OBJ_TYPE_MEM; /* Set the type of object */
- #endif
- #if OS_CFG_DBG_EN > 0u
- p_mem->NamePtr = p_name; /* Save name of memory partition */
- #else
- (void)&p_name;
- #endif
- p_mem->AddrPtr = p_addr; /* Store start address of memory partition */
- p_mem->FreeListPtr = p_addr; /* Initialize pointer to pool of free blocks */
- p_mem->NbrFree = n_blks; /* Store number of free blocks in MCB */
- p_mem->NbrMax = n_blks;
- p_mem->BlkSize = blk_size; /* Store block size of each memory blocks */
-
- #if OS_CFG_DBG_EN > 0u
- OS_MemDbgListAdd(p_mem);
- #endif
-
- OSMemQty++;
-
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_CREATE(p_mem, p_name); /* Record the event. */
- #endif
-
- OS_CRITICAL_EXIT_NO_SCHED();
- *p_err = OS_ERR_NONE;
- }
-
-
- /*
- ************************************************************************************************************************
- * GET A MEMORY BLOCK
- *
- * Description : Get a memory block from a partition
- *
- * Arguments : p_mem is a pointer to the memory partition control block
- *
- * p_err is a pointer to a variable containing an error message which will be set by this function to
- * either:
- *
- * OS_ERR_NONE if the memory partition has been created correctly.
- * OS_ERR_MEM_INVALID_P_MEM if you passed a NULL pointer for 'p_mem'
- * OS_ERR_MEM_NO_FREE_BLKS if there are no more free memory blocks to allocate to the caller
- *
- * 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 *p_mem,
- OS_ERR *p_err)
- {
- void *p_blk;
- CPU_SR_ALLOC();
-
-
-
- #ifdef OS_SAFETY_CRITICAL
- if (p_err == (OS_ERR *)0) {
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_GET_FAILED(p_mem); /* Record the event. */
- #endif
- OS_SAFETY_CRITICAL_EXCEPTION();
- return ((void *)0);
- }
- #endif
-
- #if OS_CFG_ARG_CHK_EN > 0u
- if (p_mem == (OS_MEM *)0) { /* Must point to a valid memory partition */
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_GET_FAILED(p_mem); /* Record the event. */
- #endif
- *p_err = OS_ERR_MEM_INVALID_P_MEM;
- return ((void *)0);
- }
- #endif
-
- CPU_CRITICAL_ENTER();
- if (p_mem->NbrFree == (OS_MEM_QTY)0) { /* See if there are any free memory blocks */
- CPU_CRITICAL_EXIT();
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_GET_FAILED(p_mem); /* Record the event. */
- #endif
- *p_err = OS_ERR_MEM_NO_FREE_BLKS; /* No, Notify caller of empty memory partition */
- return ((void *)0); /* Return NULL pointer to caller */
- }
- p_blk = p_mem->FreeListPtr; /* Yes, point to next free memory block */
- p_mem->FreeListPtr = *(void **)p_blk; /* Adjust pointer to new free list */
- p_mem->NbrFree--; /* One less memory block in this partition */
- CPU_CRITICAL_EXIT();
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_GET(p_mem); /* Record the event. */
- #endif
- *p_err = OS_ERR_NONE; /* No error */
- return (p_blk); /* Return memory block to caller */
- }
-
-
- /*
- ************************************************************************************************************************
- * RELEASE A MEMORY BLOCK
- *
- * Description : Returns a memory block to a partition
- *
- * Arguments : p_mem is a pointer to the memory partition control block
- *
- * p_blk is a pointer to the memory block being released.
- *
- * p_err is a pointer to a variable that will contain an error code returned by this function.
- *
- * OS_ERR_NONE if the memory block was inserted into the partition
- * OS_ERR_MEM_FULL if you are returning a memory block to an already FULL memory
- * partition (You freed more blocks than you allocated!)
- * OS_ERR_MEM_INVALID_P_BLK if you passed a NULL pointer for the block to release.
- * OS_ERR_MEM_INVALID_P_MEM if you passed a NULL pointer for 'p_mem'
- ************************************************************************************************************************
- */
-
- void OSMemPut (OS_MEM *p_mem,
- void *p_blk,
- OS_ERR *p_err)
- {
- CPU_SR_ALLOC();
-
-
-
- #ifdef OS_SAFETY_CRITICAL
- if (p_err == (OS_ERR *)0) {
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_PUT_FAILED(p_mem); /* Record the event. */
- #endif
- OS_SAFETY_CRITICAL_EXCEPTION();
- return;
- }
- #endif
-
- #if OS_CFG_ARG_CHK_EN > 0u
- if (p_mem == (OS_MEM *)0) { /* Must point to a valid memory partition */
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_PUT_FAILED(p_mem); /* Record the event. */
- #endif
- *p_err = OS_ERR_MEM_INVALID_P_MEM;
- return;
- }
- if (p_blk == (void *)0) { /* Must release a valid block */
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_PUT_FAILED(p_mem); /* Record the event. */
- #endif
- *p_err = OS_ERR_MEM_INVALID_P_BLK;
- return;
- }
- #endif
-
- CPU_CRITICAL_ENTER();
- if (p_mem->NbrFree >= p_mem->NbrMax) { /* Make sure all blocks not already returned */
- CPU_CRITICAL_EXIT();
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_PUT_FAILED(p_mem); /* Record the event. */
- #endif
- *p_err = OS_ERR_MEM_FULL;
- return;
- }
- *(void **)p_blk = p_mem->FreeListPtr; /* Insert released block into free block list */
- p_mem->FreeListPtr = p_blk;
- p_mem->NbrFree++; /* One more memory block in this partition */
- CPU_CRITICAL_EXIT();
- #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))
- TRACE_OS_MEM_PUT(p_mem); /* Record the event. */
- #endif
- *p_err = OS_ERR_NONE; /* Notify caller that memory block was released */
- }
-
-
- /*
- ************************************************************************************************************************
- * ADD MEMORY PARTITION TO DEBUG LIST
- *
- * Description : This function is called by OSMemCreate() to add the memory partition to the debug table.
- *
- * Arguments : p_mem Is a pointer to the memory partition
- *
- * Returns : none
- *
- * Note(s) : This function is INTERNAL to uC/OS-III and your application should not call it.
- ************************************************************************************************************************
- */
-
- #if OS_CFG_DBG_EN > 0u
- void OS_MemDbgListAdd (OS_MEM *p_mem)
- {
- p_mem->DbgPrevPtr = (OS_MEM *)0;
- if (OSMemDbgListPtr == (OS_MEM *)0) {
- p_mem->DbgNextPtr = (OS_MEM *)0;
- } else {
- p_mem->DbgNextPtr = OSMemDbgListPtr;
- OSMemDbgListPtr->DbgPrevPtr = p_mem;
- }
- OSMemDbgListPtr = p_mem;
- }
- #endif
-
-
- /*
- ************************************************************************************************************************
- * INITIALIZE MEMORY PARTITION MANAGER
- *
- * Description : This function is called by uC/OS-III 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-III and your application should not call it.
- ************************************************************************************************************************
- */
-
- void OS_MemInit (OS_ERR *p_err)
- {
- #ifdef OS_SAFETY_CRITICAL
- if (p_err == (OS_ERR *)0) {
- OS_SAFETY_CRITICAL_EXCEPTION();
- return;
- }
- #endif
-
- #if OS_CFG_DBG_EN > 0u
- OSMemDbgListPtr = (OS_MEM *)0;
- #endif
-
- OSMemQty = (OS_OBJ_QTY)0;
- *p_err = OS_ERR_NONE;
- }
- #endif
|
