Subversion Repositories openrisc_me

/*
 *  RTEMS Malloc Family Implementation
 *
 *
 *  COPYRIGHT (c) 1989-1999.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.OARcorp.com/rtems/license.html.
 *
 *  $Id: malloc.c,v 1.2 2001-09-27 12:01:15 chris Exp $
 */
 
#define __RTEMS_VIOLATE_KERNEL_VISIBILITY__
#include <rtems.h>
#include "libcsupport.h"
#ifdef RTEMS_NEWLIB
#include <sys/reent.h>
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
 
#include <unistd.h>    /* sbrk(2) */
 
rtems_id RTEMS_Malloc_Heap;
size_t RTEMS_Malloc_Sbrk_amount;
 
#ifdef RTEMS_DEBUG
#define MALLOC_STATS
#define MALLOC_DIRTY
#endif
 
#ifdef MALLOC_STATS
#define MSBUMP(f,n)    rtems_malloc_stats.f += (n)
 
struct {
    unsigned32  space_available;             /* current size of malloc area */
    unsigned32  malloc_calls;                /* # calls to malloc */
    unsigned32  free_calls;
    unsigned32  realloc_calls;
    unsigned32  calloc_calls;
    unsigned32  max_depth;		     /* most ever malloc'd at 1 time */
    unsigned64  lifetime_allocated;
    unsigned64  lifetime_freed;
} rtems_malloc_stats;
 
#else			/* No rtems_malloc_stats */
#define MSBUMP(f,n)
#endif
 
void RTEMS_Malloc_Initialize(
  void   *start,
  size_t  length,
  size_t  sbrk_amount
)
{
  rtems_status_code   status;
  void               *starting_address;
  rtems_unsigned32    old_address;
  rtems_unsigned32    u32_address;
 
  /*
   * If the starting address is 0 then we are to attempt to
   * get length worth of memory using sbrk. Make sure we
   * align the address that we get back.
   */
 
  starting_address = start;
  RTEMS_Malloc_Sbrk_amount = sbrk_amount;
 
  if (!starting_address) {
    u32_address = (unsigned int)sbrk(length);
 
    if (u32_address == (rtems_unsigned32) -1) {
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
      /* DOES NOT RETURN!!! */
    }
 
    if (u32_address & (CPU_ALIGNMENT-1)) {
      old_address = u32_address;
      u32_address = (u32_address + CPU_ALIGNMENT) & ~(CPU_ALIGNMENT-1);
 
       /*
	* adjust the length by whatever we aligned by
	*/
 
      length -= u32_address - old_address;
    }
 
    starting_address = (void *)u32_address;
  }
 
  /*
   *  If the BSP is not clearing out the workspace, then it is most likely
   *  not clearing out the initial memory for the heap.  There is no 
   *  standard supporting zeroing out the heap memory.  But much code
   *  with UNIX history seems to assume that memory malloc'ed during
   *  initialization (before any free's) is zero'ed.  This is true most
   *  of the time under UNIX because zero'ing memory when it is first
   *  given to a process eliminates the chance of a process seeing data
   *  left over from another process.  This would be a security violation.
   */
 
  if ( rtems_cpu_configuration_get_do_zero_of_workspace() )
     memset( starting_address, 0, length );
 
  /*
   *  Unfortunately we cannot use assert if this fails because if this
   *  has failed we do not have a heap and if we do not have a heap
   *  STDIO cannot work because there will be no buffers.
   */
 
  status = rtems_region_create(
    rtems_build_name( 'H', 'E', 'A', 'P' ),
    starting_address,
    length,
    CPU_HEAP_ALIGNMENT,
    RTEMS_DEFAULT_ATTRIBUTES,
    &RTEMS_Malloc_Heap
  );
  if ( status != RTEMS_SUCCESSFUL )
    rtems_fatal_error_occurred( status );
 
#ifdef MALLOC_STATS
  /* zero all the stats */
  (void) memset( &rtems_malloc_stats, 0, sizeof(rtems_malloc_stats) );
#endif
 
  MSBUMP(space_available, length);
}
 
#ifdef RTEMS_NEWLIB
void *malloc(
  size_t  size
)
{
  void              *return_this;
  void              *starting_address;
  rtems_unsigned32   the_size;
  rtems_unsigned32   sbrk_amount;
  rtems_status_code  status;
 
  MSBUMP(malloc_calls, 1);
 
  if ( !size )
    return (void *) 0;
 
  /*
   * Try to give a segment in the current region if there is not
   * enough space then try to grow the region using rtems_region_extend().
   * If this fails then return a NULL pointer.
   */
 
  status = rtems_region_get_segment(
    RTEMS_Malloc_Heap,
    size,
    RTEMS_NO_WAIT,
    RTEMS_NO_TIMEOUT,
    &return_this
  );
 
  if ( status != RTEMS_SUCCESSFUL ) {
    /*
     *  Round to the "requested sbrk amount" so hopefully we won't have
     *  to grow again for a while.  This effectively does sbrk() calls
     *  in "page" amounts.
     */
 
    sbrk_amount = RTEMS_Malloc_Sbrk_amount;
 
    if ( sbrk_amount == 0 )
      return (void *) 0;
 
    the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
 
    if (((rtems_unsigned32)starting_address = (void *)sbrk(the_size)) 
            == (rtems_unsigned32) -1)
      return (void *) 0;
 
    status = rtems_region_extend(
      RTEMS_Malloc_Heap,
      starting_address,
      the_size
    );
    if ( status != RTEMS_SUCCESSFUL ) {
      sbrk(-the_size);
      errno = ENOMEM;
      return (void *) 0;
    }
 
    MSBUMP(space_available, the_size);
 
    status = rtems_region_get_segment(
      RTEMS_Malloc_Heap,
       size,
       RTEMS_NO_WAIT,
       RTEMS_NO_TIMEOUT,
       &return_this
    );
    if ( status != RTEMS_SUCCESSFUL ) {
      errno = ENOMEM;
      return (void *) 0;
    }
  }
 
#ifdef MALLOC_STATS
  if (return_this)
  {
      unsigned32 actual_size;
      unsigned32 current_depth;
      status = rtems_region_get_segment_size(
                   RTEMS_Malloc_Heap, return_this, &actual_size);
      MSBUMP(lifetime_allocated, actual_size);
      current_depth = rtems_malloc_stats.lifetime_allocated -
                   rtems_malloc_stats.lifetime_freed;
      if (current_depth > rtems_malloc_stats.max_depth)
          rtems_malloc_stats.max_depth = current_depth;
  }
#endif
 
#ifdef MALLOC_DIRTY
  (void) memset(return_this, 0xCF, size);
#endif
 
  return return_this;
}
 
void *calloc(
  size_t nelem,
  size_t elsize
)
{
  register char *cptr;
  int length;
 
  MSBUMP(calloc_calls, 1);
 
  length = nelem * elsize;
  cptr = malloc( length );
  if ( cptr )
    memset( cptr, '\0', length );
 
  MSBUMP(malloc_calls, -1);   /* subtract off the malloc */
 
  return cptr;
}
 
void *realloc(
  void *ptr,
  size_t size
)
{
  rtems_unsigned32  old_size;
  rtems_status_code status;
  char *new_area;
 
  MSBUMP(realloc_calls, 1);
 
  if ( !ptr )
    return malloc( size );
 
  if ( !size ) {
    free( ptr );
    return (void *) 0;
  }
 
  new_area = malloc( size );
 
  MSBUMP(malloc_calls, -1);   /* subtract off the malloc */
 
  if ( !new_area ) {
    free( ptr );
    return (void *) 0;
  }
 
  status = rtems_region_get_segment_size( RTEMS_Malloc_Heap, ptr, &old_size );
  if ( status != RTEMS_SUCCESSFUL ) {
    errno = EINVAL;
    return (void *) 0;
  }
 
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );
  free( ptr );
 
  return new_area;
 
}
 
void free(
  void *ptr
)
{
  rtems_status_code status;
 
  MSBUMP(free_calls, 1);
 
  if ( !ptr )
    return;
 
#ifdef MALLOC_STATS
  {
      unsigned32        size;
      status = rtems_region_get_segment_size( RTEMS_Malloc_Heap, ptr, &size );
      if ( status == RTEMS_SUCCESSFUL ) {
          MSBUMP(lifetime_freed, size);
      }
  }
#endif
 
  status = rtems_region_return_segment( RTEMS_Malloc_Heap, ptr );
  if ( status != RTEMS_SUCCESSFUL ) {
    errno = EINVAL;
    assert( 0 );
  }
}
/* end if RTEMS_NEWLIB */
#endif
 
#ifdef MALLOC_STATS
/*
 * Dump the malloc statistics
 * May be called via atexit()  (installable by our bsp) or
 * at any time by user
 */
 
void malloc_dump(void)
{
    unsigned32 allocated = rtems_malloc_stats.lifetime_allocated -
                     rtems_malloc_stats.lifetime_freed;
 
    printf("Malloc stats\n");
    printf("  avail:%uk  allocated:%uk (%d%%) "
              "max:%uk (%d%%) lifetime:%Luk freed:%Luk\n",
           (unsigned int) rtems_malloc_stats.space_available / 1024,
           (unsigned int) allocated / 1024,
           /* avoid float! */
           (allocated * 100) / rtems_malloc_stats.space_available,
           (unsigned int) rtems_malloc_stats.max_depth / 1024,
           (rtems_malloc_stats.max_depth * 100) / rtems_malloc_stats.space_available,
           (unsigned64) rtems_malloc_stats.lifetime_allocated / 1024,
           (unsigned64) rtems_malloc_stats.lifetime_freed / 1024);
    printf("  Call counts:   malloc:%d   free:%d   realloc:%d   calloc:%d\n",
           rtems_malloc_stats.malloc_calls,
           rtems_malloc_stats.free_calls,
           rtems_malloc_stats.realloc_calls,
           rtems_malloc_stats.calloc_calls);
}
 
 
void malloc_walk(size_t source, size_t printf_enabled)
{
   register Region_Control *the_region;
   Objects_Locations        location;
 
   the_region = _Region_Get( RTEMS_Malloc_Heap, &location );
   if ( location == OBJECTS_LOCAL )
   {
      _Heap_Walk( &the_region->Memory, source, printf_enabled );
      _Thread_Enable_dispatch();
   }
}
 
#else
 
void malloc_dump(void)
{
   return;
}
 
void malloc_walk(size_t source, size_t printf_enabled)
{
   return;
}
 
#endif
 
/*
 *  "Reentrant" versions of the above routines implemented above.
 */
 
#ifdef RTEMS_NEWLIB
void *_malloc_r(
  struct _reent *ignored,
  size_t  size
)
{
  return malloc( size );
}
 
void *_calloc_r(
  struct _reent *ignored,
  size_t nelem,
  size_t elsize
)
{
  return calloc( nelem, elsize );
}
 
void *_realloc_r(
  struct _reent *ignored,
  void *ptr,
  size_t size
)
{
  return realloc( ptr, size );
}
 
void _free_r(
  struct _reent *ignored,
  void *ptr
)
{
  free( ptr );
}
#endif