Subversion Repositories or1k

/*

 *  Stack Overflow Check User Extension Set

 *

 *  NOTE:  This extension set automatically determines at

 *         initialization time whether the stack for this

 *         CPU grows up or down and installs the correct

 *         extension routines for that direction.

 *

 *  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: check.c,v 1.2 2001-09-27 12:01:46 chris Exp $

 *

 */

#include <rtems.h>

/*

 * HACK

 * the stack dump information should be printed by a "fatal" extension.

 * Fatal extensions only get called via rtems_fatal_error_occurred()

 * and not when rtems_shutdown_executive() is called.

 * I hope/think this is changing so that fatal extensions are renamed

 * to "shutdown" extensions.

 * When that happens, this #define should be deleted and all the code

 * it marks.

 */

#define DONT_USE_FATAL_EXTENSION

#include <assert.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <rtems/stackchk.h>

#include "internal.h"

/*

 *  This variable contains the name of the task which "blew" the stack.

 *  It is NULL if the system is all right.

 */

Thread_Control *Stack_check_Blown_task;

/*

 *  The extension table for the stack checker.

 */

rtems_extensions_table Stack_check_Extension_table = {

  Stack_check_Create_extension,     /* rtems_task_create  */

  0,                                /* rtems_task_start   */

  0,                                /* rtems_task_restart */

  0,                                /* rtems_task_delete  */

  Stack_check_Switch_extension,     /* task_switch  */

  Stack_check_Begin_extension,      /* task_begin   */

  0,                                /* task_exitted */

#ifdef DONT_USE_FATAL_EXTENSION

  0,                                /* fatal        */

#else

  Stack_check_Fatal_extension,      /* fatal        */

#endif

};

/*

 *  The "magic pattern" used to mark the end of the stack.

 */

Stack_check_Control Stack_check_Pattern;

/*

 *  Where the pattern goes in the stack area is dependent upon

 *  whether the stack grow to the high or low area of the memory.

 *

 */

#if ( CPU_STACK_GROWS_UP == TRUE )

#define Stack_check_Get_pattern_area( _the_stack ) \

  ((Stack_check_Control *) ((char *)(_the_stack)->area + \

       (_the_stack)->size - sizeof( Stack_check_Control ) ))

#define Stack_check_Calculate_used( _low, _size, _high_water ) \

    ((char *)(_high_water) - (char *)(_low))

#define Stack_check_usable_stack_start(_the_stack) \

    ((_the_stack)->area)

#else

#define Stack_check_Get_pattern_area( _the_stack ) \

  ((Stack_check_Control *) ((char *)(_the_stack)->area + HEAP_OVERHEAD))

#define Stack_check_Calculate_used( _low, _size, _high_water) \

    ( ((char *)(_low) + (_size)) - (char *)(_high_water) )

#define Stack_check_usable_stack_start(_the_stack) \

    ((char *)(_the_stack)->area + sizeof(Stack_check_Control))

#endif

#define Stack_check_usable_stack_size(_the_stack) \

    ((_the_stack)->size - sizeof(Stack_check_Control))

/*

 * Do we have an interrupt stack?

 * XXX it would sure be nice if the interrupt stack were also

 *     stored in a "stack" structure!

 */

Stack_Control stack_check_interrupt_stack;

/*

 * Prototypes necessary for forward references

 */

void Stack_check_Dump_usage( void );

/*

 * Fill an entire stack area with BYTE_PATTERN.

 * This will be used by a Fatal extension to check for

 * amount of actual stack used

 */

void

stack_check_dope_stack(Stack_Control *stack)

{

    memset(stack->area, BYTE_PATTERN, stack->size);

}

/*PAGE

 *

 *  Stack_check_Initialize

 */

unsigned32 stack_check_initialized = 0;

void Stack_check_Initialize( void )

{

#if 0

  rtems_status_code    status;

  Objects_Id           id_ignored;

#endif

  unsigned32          *p;

#if 0

  unsigned32           i;

  unsigned32           class_index;

  Thread_Control      *the_thread;

  Objects_Information *information;

#endif

  if (stack_check_initialized)

      return;

  /*

   * Dope the pattern and fill areas

   */

  for ( p = Stack_check_Pattern.pattern;

        p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];

        p += 4

      )

  {

      p[0] = 0xFEEDF00D;          /* FEED FOOD to BAD DOG */

      p[1] = 0x0BAD0D06;

      p[2] = 0xDEADF00D;          /* DEAD FOOD GOOD DOG */

      p[3] = 0x600D0D06;

  };

#if 0

  status = rtems_extension_create(

    rtems_build_name( 'S', 'T', 'C', 'K' ),

    &Stack_check_Extension_table,

    &id_ignored

  );

  assert ( status == RTEMS_SUCCESSFUL );

#endif

  Stack_check_Blown_task = 0;

  /*

   * If installed by a task, that task will not get setup properly

   * since it missed out on the create hook.  This will cause a

   * failure on first switch out of that task.

   * So pretend here that we actually ran create and begin extensions.

   */

  /* XXX

   *

   *  Technically this has not been done for any task created before this

   *  happened.  So just run through them and fix the situation.

   */

#if 0

  if (_Thread_Executing)

  {

      Stack_check_Create_extension(_Thread_Executing, _Thread_Executing);

  }

#endif

#if 0

  for ( class_index = OBJECTS_CLASSES_FIRST ;

        class_index <= OBJECTS_CLASSES_LAST ;

        class_index++ ) {

    information = _Objects_Information_table[ class_index ];

    if ( information && information->is_thread ) {

      for ( i=1 ; i <= information->maximum ; i++ ) {

        the_thread = (Thread_Control *)information->local_table[ i ];

        Stack_check_Create_extension( the_thread, the_thread );

      }

    }

  }

#endif

  /*

   * If appropriate, setup the interrupt stack for high water testing

   * also.

   */

  if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high)

  {

      stack_check_interrupt_stack.area = _CPU_Interrupt_stack_low;

      stack_check_interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -

                                              (char *) _CPU_Interrupt_stack_low;

      stack_check_dope_stack(&stack_check_interrupt_stack);

  }

#ifdef DONT_USE_FATAL_EXTENSION

#ifdef RTEMS_DEBUG

    /*

     * this would normally be called by a fatal extension

     * handler, but we don't run fatal extensions unless

     * we fatal error.

     */

  atexit(Stack_check_Dump_usage);

#endif

#endif

  stack_check_initialized = 1;

}

/*PAGE

 *

 *  Stack_check_Create_extension

 */

boolean Stack_check_Create_extension(

  Thread_Control *running,

  Thread_Control *the_thread

)

{

    if (!stack_check_initialized)

      Stack_check_Initialize();

    if (the_thread /* XXX && (the_thread != _Thread_Executing) */ )

        stack_check_dope_stack(&the_thread->Start.Initial_stack);

    return TRUE;

}

/*PAGE

 *

 *  Stack_check_Begin_extension

 */

void Stack_check_Begin_extension(

  Thread_Control *the_thread

)

{

  Stack_check_Control  *the_pattern;

  if (!stack_check_initialized)

    Stack_check_Initialize();

  if ( the_thread->Object.id == 0 )        /* skip system tasks */

    return;

  the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);

  *the_pattern = Stack_check_Pattern;

}

/*PAGE

 *

 *  Stack_check_report_blown_task

 *  Report a blown stack.  Needs to be a separate routine

 *  so that interrupt handlers can use this too.

 *

 *  Caller must have set the Stack_check_Blown_task.

 *

 *  NOTE: The system is in a questionable state... we may not get

 *        the following message out.

 */

void Stack_check_report_blown_task(void)

{

    Stack_Control *stack;

    Thread_Control *running;

    running = Stack_check_Blown_task;

    stack = &running->Start.Initial_stack;

    fprintf(

        stderr,

        "BLOWN STACK!!! Offending task(%p): id=0x%08x; name=0x%08x",

        running,

        running->Object.id,

        *(unsigned32 *)running->Object.name

    );

    fflush(stderr);

    if (rtems_configuration_get_user_multiprocessing_table())

        fprintf(

          stderr,

          "; node=%d\n",

          rtems_configuration_get_user_multiprocessing_table()->node

       );

    else

        fprintf(stderr, "\n");

    fflush(stderr);

    fprintf(

        stderr,

        "  stack covers range 0x%08x - 0x%08x (%d bytes)\n",

        (unsigned32) stack->area,

        (unsigned32) stack->area + stack->size - 1,

        (unsigned32) stack->size);

    fflush(stderr);

    fprintf(

        stderr,

        "  Damaged pattern begins at 0x%08x and is %d bytes long\n",

        (unsigned32) Stack_check_Get_pattern_area(stack), PATTERN_SIZE_BYTES);

    fflush(stderr);

    rtems_fatal_error_occurred( (unsigned32) "STACK BLOWN" );

}

/*PAGE

 *

 *  Stack_check_Switch_extension

 */

void Stack_check_Switch_extension(

  Thread_Control *running,

  Thread_Control *heir

)

{

  if ( running->Object.id == 0 )        /* skip system tasks */

    return;

  if (0 != memcmp( (void *) Stack_check_Get_pattern_area( &running->Start.Initial_stack)->pattern,

                  (void *) Stack_check_Pattern.pattern,

                  PATTERN_SIZE_BYTES))

  {

      Stack_check_Blown_task = running;

      Stack_check_report_blown_task();

  }

}

void *Stack_check_find_high_water_mark(

  const void *s,

  size_t n

)

{

  const unsigned32 *base, *ebase;

  unsigned32 length;

  base = s;

  length = n/4;

#if ( CPU_STACK_GROWS_UP == TRUE )

  /*

   * start at higher memory and find first word that does not

   * match pattern

   */

  base += length - 1;

  for (ebase = s; base > ebase; base--)

      if (*base != U32_PATTERN)

          return (void *) base;

#else

  /*

   * start at lower memory and find first word that does not

   * match pattern

   */

  base += PATTERN_SIZE_WORDS;

  for (ebase = base + length; base < ebase; base++)

      if (*base != U32_PATTERN)

          return (void *) base;

#endif

  return (void *)0;

}

/*PAGE

 *

 *  Stack_check_Dump_threads_usage

 *  Try to print out how much stack was actually used by the task.

 *

 */

void Stack_check_Dump_threads_usage(

  Thread_Control *the_thread

)

{

  unsigned32      size, used;

  void           *low;

  void           *high_water_mark;

  Stack_Control  *stack;

  unsigned32      u32_name;

  char            name[5];

  if ( !the_thread )

    return;

  /*

   * XXX HACK to get to interrupt stack

   */

  if (the_thread == (Thread_Control *) -1)

  {

      if (stack_check_interrupt_stack.area)

      {

          stack = &stack_check_interrupt_stack;

          the_thread = 0;

      }

      else

          return;

  }

  else

      stack = &the_thread->Start.Initial_stack;

  low  = Stack_check_usable_stack_start(stack);

  size = Stack_check_usable_stack_size(stack);

  high_water_mark = Stack_check_find_high_water_mark(low, size);

  if ( high_water_mark )

    used = Stack_check_Calculate_used( low, size, high_water_mark );

  else

    used = 0;

  if ( the_thread )

    u32_name = *(unsigned32 *)the_thread->Object.name;

  else

    u32_name = rtems_build_name('I', 'N', 'T', 'R');

  name[ 0 ] = (u32_name >> 24) & 0xff;

  name[ 1 ] = (u32_name >> 16) & 0xff;

  name[ 2 ] = (u32_name >>  8) & 0xff;

  name[ 3 ] = (u32_name >>  0) & 0xff;

  name[ 4 ] = '\0';

  printf( "0x%08x  %4s  0x%08x  0x%08x   %8d   %8d\n",

          the_thread ? the_thread->Object.id : ~0,

          name,

          (unsigned32) stack->area,

          (unsigned32) stack->area + (unsigned32) stack->size - 1,

          size,

          used

  );

}

/*PAGE

 *

 *  Stack_check_Fatal_extension

 */

void Stack_check_Fatal_extension(

    Internal_errors_Source  source,

    boolean                 is_internal,

    unsigned32              status

)

{

#ifndef DONT_USE_FATAL_EXTENSION

    if (status == 0)

        Stack_check_Dump_usage();

#endif

}

/*PAGE

 *

 *  Stack_check_Dump_usage

 */

void Stack_check_Dump_usage( void )

{

  unsigned32           i;

  unsigned32           class_index;

  Thread_Control      *the_thread;

  unsigned32           hit_running = 0;

  Objects_Information *information;

  if (stack_check_initialized == 0)

      return;

  printf("Stack usage by thread\n");

  printf(

    "    ID      NAME       LOW        HIGH     AVAILABLE      USED\n"

  );

  for ( class_index = OBJECTS_CLASSES_FIRST ;

        class_index <= OBJECTS_CLASSES_LAST ;

        class_index++ ) {

    information = _Objects_Information_table[ class_index ];

    if ( information && information->is_thread ) {

      for ( i=1 ; i <= information->maximum ; i++ ) {

        the_thread = (Thread_Control *)information->local_table[ i ];

        Stack_check_Dump_threads_usage( the_thread );

        if ( the_thread == _Thread_Executing )

          hit_running = 1;

      }

    }

  }

  if ( !hit_running )

    Stack_check_Dump_threads_usage( _Thread_Executing );

  /* dump interrupt stack info if any */

  Stack_check_Dump_threads_usage((Thread_Control *) -1);

}