URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [libmisc/] [stackchk/] [check.c] - Rev 173
Compare with Previous | Blame | View Log
/* * 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); }