memlib.c

VXWORKS源代码

/* memLib.c - full-featured memory partition manager */

/* Copyright 1984-1995 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
05x,21feb99,jdi  doc: listed errnos.
05w,01may98,cjtc moved instrumentation point in memPartRealloc to fix problem
                 with reported size of bytesPlusHeaderAlign
05v,17feb98,dvs  added instrumentation points (pr)
05u,11feb97,dbt  Fixed case of memPartRealloc() call with pBlock = NULL (SPR
                 #7012)
05t,18jan96,tam  checked for nbBytes=0 in memPartRealloc() (SPR 5858).
		 reworked the fix for memPartRealloc() (SPR 1407 & 3564).
05s,23jan95,ism  Fixed possible problem with memPartRealloc() from earlier fix
        	 (SPR#3563).  Fixed in-line docs.
05r,23jan95,rhp  doc: explain memPartRealloc() with NULL pointer.
05q,12jan95,rhp  doc: in memLib and memPartOptionsSet man pages, mention
                 VX_UNBREAKABLE override of MEM_*_ERROR_SUSPEND_FLAG (SPR#2499)
05p,29aug94,ism  memBlockSplit() bypasses the problem with the number of free
        	 blocks statistic by incrementing before the memBlockSplit() 
		 call (SPR #3564).
05q,25aug94,ism  realloc() no longer checks for NULL block; instead, this is
		 done at the next level down, in memPartRealloc() (SPR #3563).
05p,05sep93,jcf  calls to logMsg are now indirect for scalability.
05o,23feb93,jdi  documentation: cfree() not ANSI.
05n,10feb93,jdi  fixed spelling of stdlib.
05m,23jan93,jdi  documentation cleanup for 5.1.
05l,13nov92,dnw  added include of smObjLib.h
05k,20oct92,pme  added reference to shared memory manager documentation.
05j,15oct92,pme  fixed valloc documentation.
05i,02oct92,jdi  documentation cleanup.
05h,23aug92,jcf  added _func_{memalign,valloc}
05g,19aug92,smb  fixed SPR #1400, realloc(NULL) now malloc's memory
05f,29jul92,pme  added NULL function pointer check for smObj routines.
05e,29jul92,jcf  moved SUSPEND option to memPartLib.  beefed up package init.
05d,19jul92,pme  added shared memory object support.
05c,19jul92,smb  added some ANSI documentation.
05b,13jul92,rdc  added valloc.
05a,04jul92,jcf  split into memShow/memPartLib/memLib for modularity.
04n,22jun92,rdc  added memalign and memPartAlignedAlloc.
04m,26may92,rrr  the tree shuffle
04l,07apr92,yao  removed macros MEM_ROUND_UP/DOWN, MEM_IS_ROUND.  
04n,25mar92,jmm  Changed way we handle memory pool options for error handling
04m,23mar92,jmm  changed memBlockAllocError to handle MEM_ALLOC_ERROR_RETURN
                 changed memPartAllocError to handle MEM_ALLOC_ERROR_RETURN
		 SPR #1377
04l,16dec91,gae  added includes for ANSI.
04k,25nov91,llk  ansi stuff.  Modified malloc(), calloc(), realloc(), free().
04j,04oct91,rrr  passed through the ansification filter
                  -changed functions to ansi style
		  -changed includes to have absolute path from h/
		  -fixed #else and #endif
		  -changed VOID to void
		  -changed copyright notice
04i,07aug91,ajm  made MIPS MEM_ROUNDUP use 8 byte boundaries for
                   varargs problem.
04h,23may91,jwt  forced 8-byte alignment for SPARC - stack, optimization.
04g,13may91,wmd  added define for TRON rounding.
04f,05apr91,jdi	 documentation -- removed header parens and x-ref numbers;
		 doc review by dnw.
04e,24mar91,del  added I960 rounding and padding to structures.
04d,13feb91,jaa	 documentation cleanup.
04c,05oct90,dnw  made memPartInit() be NOMANUAL.
04b,18jul90,jcf  changed free/memPartFree to return OK if pBlock is NULL.
04a,18jul90,jcf  changed partitions into objects w/ object class.
		 change memPartBlockIsValid () to check validity w/o race.
		 lint & cleanup.
03i,26jun90,jcf  changed partition semaphore to mutex w/ inversion safety.
03h,21nov89,jcf  added memSysPartId which is global variable for system part.
03g,07nov89,shl  added error checking for memPartShow().
		 fixed documentation on memory overhead.
		 fixed memPart{Block,Alloc}Error() to not suspend
		 unbreakable tasks.
		 cosmetics.
03f,15mar88,llk  fixed bug in realloc.  memBlockSplit() wasn't checking to
		   ensure that both resulting blocks were of minimum length.
03e,07nov88,gae  fixed memPartFindMax() return value in bytes not words.
03d,18aug88,gae  documentation.
03c,07jul88,jcf  lint.
03b,22jun88,dnw  fixed bug in realloc.
		 added cfree(), memPartFindMax(), and memFindMax().
		 changed hdr to have ptr to prev block (instead of prev block
		   size and free flag), as per gae suggestion.
03a,20may88,dnw  rewritten - now has following features:
		   - faster allocation
		   - much faster deallocation (no searching)
		   - checks validity of blocks being freed
		   - options to specify how to deal with errors
		   - always allocates on even 4 byte address
		   - VxWorks v4 names
02q,28mar88,gae  added calloc().
02p,22jan88,jcf  made kernel independent.
02o,19feb88,rdc  malloc of 0 bytes in no longer an error.
02n,18nov87,dnw  changed to set S_memLib_INVALID_NBYTES appropriately.
02m,17nov87,ecs  lint.
02l,13nov87,gae  moved FRAGMENT definition here from memLib.h.
		 fixed memFindMax() from returning too large an amount.
02k,05nov87,jlf  documentation
02j,23oct87,rdc  generalized to support private memory partitions.
02i,07apr87,jlf  delinted.
02h,24mar87,jlf  documentation.
02g,30jan87,rdc  fixed bug in memAddToPool - was screwing up allocation stats.
02f,21dec86,dnw  changed to not get include files from default directories.
02e,04sep86,jlf  documentation.
02d,02jul86,rdc  fixed bug in memStat.
02c,19jun86,rdc  spruced up memStat.
02b,18jun86,rdc  de-linted.
02a,14apr86,rdc  completely rewritten to support dynamic allocation.
01i,03mar86,jlf  added malloc and free.  free is a null routine, for now.
01h,20jul85,jlf  Documentation.
01g,08sep84,jlf  Changed to lock out while allocating memory.  added copyright
		 and some comments.
01f,13aug84,ecs  changed S_memLib_NO_MORE_MEMORY to S_memLib_NOT_ENOUGH_MEMORY.
		 added testing for negative nbytes to memAllocate.
		 added setting of status to S_memLib_INVALID_NBYTES.
01e,07aug84,ecs  added setStatus call to memAllocate.
01d,21may84,dnw  changed memInit to specify both start and end of pools.
		 removed memEnd.
		 added LINTLIBRARY and various coercions for lint.
01c,03sep83,dnw  added memInit.
01b,13jul83,dnw  fixed memAlloc to return NULL if insufficient memory available.
01a,24may83,dnw  written
*/

/*
DESCRIPTION
This library provides full-featured facilities for managing the allocation
of blocks of memory from ranges of memory called memory partitions.  The
library is an extension of memPartLib and provides enhanced memory management
features, including error handling, aligned allocation, and ANSI allocation
routines.  For more information about the core memory partition management 
facility, see the manual entry for memPartLib.

The system memory partition is created when the kernel is initialized
by kernelInit(), which is called by the root task, usrRoot(), in usrConfig.c.
The ID of the system memory partition is stored in the global variable
`memSysPartId'; its declaration is included in memLib.h.

The memalign() routine is provided for allocating memory aligned to a specified
boundary.

This library includes three ANSI-compatible routines:
calloc() allocates a block of memory for an array;
realloc() changes the size of a specified block of memory; and
cfree() returns to the free memory pool a block of memory that
was previously allocated with calloc().

ERROR OPTIONS
Various debug options can be selected for each partition using
memPartOptionsSet() and memOptionsSet().  Two kinds of errors are 
detected: attempts to allocate more memory
than is available, and bad blocks found when memory is freed.  In both
cases, the error status is returned.  There are four error-handling
options that can be individually selected:

.iP "MEM_ALLOC_ERROR_LOG_FLAG" 8
Log a message when there is an error in allocating memory.
.iP "MEM_ALLOC_ERROR_SUSPEND_FLAG"
Suspend the task when there is an error in allocating memory (unless
the task was spawned with the VX_UNBREAKABLE option, in which case it
cannot be suspended).
.iP "MEM_BLOCK_ERROR_LOG_FLAG"
Log a message when there is an error in freeing memory.
.iP "MEM_BLOCK_ERROR_SUSPEND_FLAG"
Suspend the task when there is an error in freeing memory (unless
the task was spawned with the VX_UNBREAKABLE option, in which case it
cannot be suspended).
.LP

When the following option is specified to check every block freed to the
partition, memPartFree() and free() in memPartLib run consistency checks
of various pointers and values in the header of the block being freed.  If
this flag is not specified, no check will be performed when memory is
freed.

.iP "MEM_BLOCK_CHECK" 8
Check each block freed.
.LP

Setting either of the MEM_BLOCK_ERROR options automatically 
sets MEM_BLOCK_CHECK.

The default options when a partition is created are:

    MEM_ALLOC_ERROR_LOG_FLAG
    MEM_BLOCK_CHECK
    MEM_BLOCK_ERROR_LOG_FLAG
    MEM_BLOCK_ERROR_SUSPEND_FLAG

When setting options for a partition with memPartOptionsSet() or
memOptionsSet(), use the logical OR operator between each specified
option to construct the <options> parameter.  For example:
.CS
    memPartOptionsSet (myPartId, MEM_ALLOC_ERROR_LOG_FLAG |
                                 MEM_BLOCK_CHECK |
                                 MEM_BLOCK_ERROR_LOG_FLAG);
.CE

INCLUDE FILES: memLib.h

SEE ALSO: memPartLib, smMemLib

INTERNAL
This package is initialized by kernelInit() which calls memInit() with a
pointer to a block of memory from which memory will be allocated.

Blocks allocated by malloc() are actually larger than the size requested by
the user.  Each block is prefaced by a header which contains the size and
status of that block and a pointer to the previous block.
The pointer returned to the user points just past this header.
Likewise when a block is freed, the header is found just in front of
the block pointer passed by the user.

The header data is arranged so that the pointer to the previous block
comes first and is therefore adjacent to that previous block.  Thus each
block has 4 bytes of redundant information on either side of it (the 4
bytes of size and status before it in its own header, and the 4-byte
pointer after it in the next header).  This redundant information is
optionally used in free() and realloc() to make a consistency check on
blocks specified by the user.  This mechanism helps to detect two common
errors: (1) bad block pointers passed to free() or realloc() are usually
detected, and (2) trashing up to 4 bytes on either side of the block will
only affect that block and will also be detected by free() or realloc().

There is a minimum block size which malloc() allocates; this is to insure
that there will be enough room for the free list links that must be used
when the block is freed if it cannot be coalesced with an adjacent block.
The malloc() and realloc() routines always allocate memory aligned to the 
boundary defined in the global variable memDefaultAlignment, which is 
initialized to the alignment required for the specific architecture.

The memory partition semaphore is a structure in the partition descriptor
rather than a pointer to a dynamically created semaphore structure.
This is because of the chicken-and-the-egg problem of memLib using semaphores
and semCreate calling malloc.  Instead the structure is simply declared
directly in the partition structure and we call semInit() instead of
semCreate().
*/

#include "vxWorks.h"
#include "semLib.h"
#include "dllLib.h"
#include "logLib.h"
#include "taskLib.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "errno.h"
#include "smObjLib.h"
#include "private/memPartLibP.h"
#include "private/vmLibP.h"
#include "private/smMemLibP.h"
#include "private/funcBindP.h"
#include "private/eventP.h"


/* global variables */

int mutexOptionsMemLib = SEM_Q_PRIORITY | 	/* default mutual exclusion */
			 SEM_DELETE_SAFE |	/* options for memory */
			 SEM_INVERSION_SAFE;	/* partition semaphore */

/* shared memory manager function pointers */

FUNCPTR  smMemPartOptionsSetRtn;
FUNCPTR  smMemPartFindMaxRtn;
FUNCPTR  smMemPartReallocRtn;

/* local variables */

LOCAL BOOL  memLibInstalled;		/* TRUE if library has been installed */
LOCAL char *memMsgBlockTooBig =
	"memPartAlloc: block too big - %d in partition %#x.\n";

LOCAL char *memMsgBlockError =
	"%s: invalid block %#x in partition %#x.\n";

/* forward static functions */

static void memSemInit (PART_ID pPart);
static void memPartAllocError (PART_ID pPart, unsigned nBytes);
static void memPartBlockError (PART_ID pPart, char *pBlock, char *label);
static BLOCK_HDR *memBlockSplit (BLOCK_HDR *pHdr, unsigned nWords,
				 unsigned minWords);


/*******************************************************************************
*
* memLibInit - initialize the higher level memory management functions
*
* This routine initializes the higher level memory management functions
* suchas mutex semaphore selection, and error notification.
*
* RETURNS: OK or ERROR.
*
* NOMANUAL
*/

STATUS memLibInit (void)
    {
    if (!memLibInstalled)
	{
	_func_valloc	     	= (FUNCPTR) valloc;
	_func_memalign	     	= (FUNCPTR) memalign;
	memPartBlockErrorRtn  	= (FUNCPTR) memPartBlockError;
	memPartAllocErrorRtn  	= (FUNCPTR) memPartAllocError;
	memPartSemInitRtn     	= (FUNCPTR) memSemInit;
    	memPartOptionsDefault	= MEM_ALLOC_ERROR_LOG_FLAG |
			          MEM_BLOCK_ERROR_LOG_FLAG |
			          MEM_BLOCK_ERROR_SUSPEND_FLAG |