FreeCalypso > hg > freecalypso-sw
view gsm-fw/nucleus/erc.c @ 317:06ee56829697
GPF: frame.c compiles
author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
---|---|
date | Fri, 11 Apr 2014 05:37:27 +0000 |
parents | afceeeb2cba1 |
children |
line wrap: on
line source
/*************************************************************************/ /* */ /* Copyright Mentor Graphics Corporation 2002 */ /* All Rights Reserved. */ /* */ /* THIS WORK CONTAINS TRADE SECRET AND PROPRIETARY INFORMATION WHICH IS */ /* THE PROPERTY OF MENTOR GRAPHICS CORPORATION OR ITS LICENSORS AND IS */ /* SUBJECT TO LICENSE TERMS. */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* FILE NAME VERSION */ /* */ /* erc.c Nucleus PLUS 1.14 */ /* */ /* COMPONENT */ /* */ /* ER - Error Management */ /* */ /* DESCRIPTION */ /* */ /* This file contains the core routines for the Error management */ /* component. */ /* */ /* DATA STRUCTURES */ /* */ /* None */ /* */ /* FUNCTIONS */ /* */ /* ERC_System_Error System error function */ /* ERC_Assert System assertion routine */ /* */ /* DEPENDENCIES */ /* */ /* tc_defs.h Thread control definitions */ /* er_extr.h Error handling functions */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Modified copyright notice, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* 04-17-1996 updated to version 1.2 */ /* 03-24-1998 Released version 1.3. */ /* 11-24-1998 Added ERC_Assert routine. */ /* 03-26-1999 Released 1.11m (new release */ /* numbering scheme) */ /* 04-07-1999 Release 1.11mA */ /* 04-17-2002 Released version 1.13m */ /* 11-07-2002 Released version 1.14 */ /*************************************************************************/ #define NU_SOURCE_FILE #ifdef NU_ERROR_STRING #include <stdio.h> /* Standard I/O functions */ #endif #include "tc_defs.h" /* Thread control constants */ #include "er_extr.h" /* Error handling functions */ #ifdef NU_DEBUG_MEMORY #include "er_defs.h" /* Error management structures */ #include "dm_extr.h" /* Memory management */ #include "ncl\inc\string.h" /* memcmp & memcpy functions */ #include "ncl\inc\nu_ncl.h" /* memcmp & memcpy functions */ extern NU_MEMORY_POOL NU_DEBUG_POOL; extern const UINT8 ERD_MemoryAllocationHead[]; extern const UINT8 ERD_MemoryAllocationFoot[]; extern ER_DEBUG_ALLOCATION *ERD_RecentAllocation; extern UINT32 ERD_AllocationCount; extern UINT32 ERD_AllocationSequenceCounter; extern UINT32 ERD_TotalMemoryAllocated; extern UINT32 ERD_TotalMemoryAllocations; extern UINT32 ERD_MaxTotalMemoryAllocated; extern UINT32 ERD_MaxTotalMemoryAllocations; #endif /* NU_DEBUG_MEMORY */ /* Define external inner-component global data references. */ extern INT ERD_Error_Code; #ifdef NU_ERROR_STRING extern CHAR ERD_Error_String[]; #endif #ifdef NU_DEBUG extern UNSIGNED ERD_Assert_Count; #endif /* Define direct access to a thread component variable. */ extern VOID *TCD_Current_Thread; /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* ERC_System_Error */ /* */ /* DESCRIPTION */ /* */ /* This function processes system errors detected by various */ /* system components. Typically an error of this type is */ /* considered fatal. */ /* */ /* CALLED BY */ /* */ /* Various Components */ /* */ /* CALLS */ /* */ /* None */ /* */ /* INPUTS */ /* */ /* error_code Code of detected system error*/ /* */ /* OUTPUTS */ /* */ /* None */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* */ /*************************************************************************/ VOID ERC_System_Error(INT error_code) { #ifdef NU_ERROR_STRING INT i; CHAR *pointer; CHAR name[NU_MAX_NAME+1]; #endif NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); /* First place the error code into the global variable. */ ERD_Error_Code = error_code; #ifdef NU_ERROR_STRING /* Build string that corresponds to the error. */ switch(error_code) { case NU_ERROR_CREATING_TIMER_HISR: /* Build string that indicates an error occurred creating the timer HISR. */ sprintf(ERD_Error_String,"%s\n", "Error Creating Timer HISR"); break; case NU_ERROR_CREATING_TIMER_TASK: /* Build string that indicates an error occurred creating the timer Task. */ sprintf(ERD_Error_String,"%s\n", "Error Creating Timer Task"); break; case NU_STACK_OVERFLOW: /* Build string that indicates a stack overflow occurred. */ name[NU_MAX_NAME] = (CHAR) 0; pointer = (((TC_TCB *) TCD_Current_Thread) -> tc_name); for (i = 0; i < NU_MAX_NAME; i++) name[i] = *pointer++; sprintf(ERD_Error_String,"%s %s\n", "Stack Overflow in task/HISR: ", name); break; case NU_UNHANDLED_INTERRUPT: /* Build string that indicates an error occurred because of an unhandled interrupt. */ sprintf(ERD_Error_String,"%s\n", "Unhandled interrupt error"); break; } #endif /* This function cannot return, since the error is fatal. */ while(1) { } /* No need to return to user mode because of the infinite loop. */ /* Returning to user mode will cause warnings with some compilers. */ } #ifdef NU_DEBUG_MEMORY /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* ERC_Memory_To_Debug */ /* */ /* DESCRIPTION */ /* */ /* This function returns a pointer to the ER_DEBUG_ALLOCATION that */ /* contains the memory allocation specified by the caller (target). */ /* */ /* CALLED BY */ /* */ /* ERC_Deallocate_Memory */ /* */ /* CALLS */ /* */ /* memcmp (CLIB_memcmp) */ /* ERC_System_Error */ /* */ /* INPUTS */ /* */ /* target memory allocation to find */ /* */ /* OUTPUTS */ /* */ /* ER_DEBUG_ALLOCATION ER_DEBUG_ALLOCATION that contains*/ /* target. */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /*************************************************************************/ static ER_DEBUG_ALLOCATION *ERC_Memory_To_Debug(VOID *target) { INT dataOffset; ER_DEBUG_ALLOCATION *walk; ER_DEBUG_ALLOCATION *to_find; dataOffset = (INT)(((ER_DEBUG_ALLOCATION *)0)->data); to_find = (ER_DEBUG_ALLOCATION *)(((UNSIGNED_CHAR *)target) - dataOffset); /* Invalid pointer, report no match found */ if((target == NULL) && (to_find == NULL)) return(NULL); for (walk = ERD_RecentAllocation; ((walk != to_find) && (walk != NULL)); walk = walk->prev); /* if no match was found */ if (walk != NULL) { /* Has the "HEAD" or "FOOT" been disturbed by a rouge pointer? */ if (memcmp((void *)ERD_MemoryAllocationHead,(void *)walk->head,4) != 0) ERC_System_Error(NU_MEMORY_CORRUPT); if (memcmp((void *)ERD_MemoryAllocationFoot,(void *)&(walk->data[walk->size]),4) != 0) ERC_System_Error(NU_MEMORY_CORRUPT); } return(walk); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* ERC_Remove_Debug_Allocation */ /* */ /* DESCRIPTION */ /* */ /* This function removes an ER_DEBUG_ALLOCATION from the linked list*/ /* */ /* CALLED BY */ /* */ /* ERC_Deallocate_Memory */ /* */ /* CALLS */ /* */ /* none */ /* */ /* INPUTS */ /* */ /* target ER_DEBUG_ALLOCATION to remove */ /* */ /* OUTPUTS */ /* */ /* STATUS status of the operation */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /*************************************************************************/ static STATUS ERC_Remove_Debug_Allocation(ER_DEBUG_ALLOCATION *target) { ER_DEBUG_ALLOCATION *walk; if (target == NULL) return(NU_INVALID_POINTER); /* If the list is empty nothing can be removed! */ if (ERD_RecentAllocation == NULL) return(NU_EMPTY_DEBUG_ALLOCATION_LIST); /* If there is only one item on the list. */ if (ERD_RecentAllocation->prev == NULL) { /* If the only item on the list is the one to be removed...*/ if (ERD_RecentAllocation == target) { ERD_RecentAllocation = NULL; return(NU_SUCCESS); } else return(NU_INVALID_DEBUG_ALLOCATION); } if (ERD_RecentAllocation == target) { ERD_RecentAllocation->prev = target->prev; return(NU_SUCCESS); } /* Walk the entire list until walk->prev is the target. */ walk = ERD_RecentAllocation; while (NU_TRUE) { if (walk->prev == target) break; if (walk->prev == NULL) break; walk = walk->prev; } /* target is last item on the list */ if (walk->prev == target) { walk->prev = target->prev; return(NU_SUCCESS); } return(NU_INVALID_DEBUG_ALLOCATION); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* ERC_Append_Debug_Allocation */ /* */ /* DESCRIPTION */ /* */ /* This function appends an ER_DEBUG_ALLOCATION to the linked list. */ /* */ /* CALLED BY */ /* */ /* ERC_Allocate_Memory */ /* */ /* CALLS */ /* */ /* none */ /* */ /* INPUTS */ /* */ /* new_guy ER_DEBUG_ALLOCATION to append */ /* */ /* OUTPUTS */ /* */ /* STATUS status of the operation */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /*************************************************************************/ static STATUS ERC_Append_Debug_Allocation(ER_DEBUG_ALLOCATION *new_guy) { /* Either this is the first ER_DEBUG_ALLOCATION ever to be appended or this is the first on a list that shrank to 0 element. */ if (ERD_AllocationCount == 0) { ERD_RecentAllocation = new_guy; ERD_RecentAllocation->prev = NULL; } else { new_guy->prev = ERD_RecentAllocation; ERD_RecentAllocation = new_guy; } return(NU_SUCCESS); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* ERC_Allocate_Memory */ /* */ /* DESCRIPTION */ /* */ /* This function tracks additional information regarding the memory */ /* allocation */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* ERC_Append_Debug_Allocation */ /* DMCE_Allocate_Memory */ /* memcpy */ /* */ /* INPUTS */ /* */ /* pool_ptr Memory pool pointer */ /* return_pointer Pointer to the destination */ /* memory pointer */ /* size Number of bytes requested */ /* suspend Suspension option if full */ /* */ /* OUTPUTS */ /* */ /* NU_SUCCESS If service is successful */ /* NU_NO_MEMORY Memory not available */ /* NU_TIMEOUT If timeout on service */ /* NU_POOL_DELETED If memory pool deleted */ /* during suspension */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /*************************************************************************/ STATUS ERC_Allocate_Memory(NU_MEMORY_POOL *pool_ptr, VOID **ptr, UNSIGNED size, UNSIGNED suspend, unsigned long line, const char* file) { ER_DEBUG_ALLOCATION **debug_ptr; STATUS status = NU_SUCCESS; /* If the allocation is not from the pool specified in the NU_DEBUG_POOL macro then allocate memory normally (no meta-data) */ if(&NU_DEBUG_POOL != pool_ptr) return(DMCE_Allocate_Memory(pool_ptr, ptr, size, suspend)); /* This call allocates memory for a structure that will contain the users data and the meta-data used to find memory problems */ status = DMCE_Allocate_Memory(pool_ptr, ptr, (sizeof(ER_DEBUG_ALLOCATION) + size + 4), suspend); if (status != NU_SUCCESS) return status; /* From here out, debug_ptr is used because it is typed. In the end ptr will be set to point to debug_ptr->data, where the user will put the data. */ debug_ptr = (ER_DEBUG_ALLOCATION **)ptr; /* Record file and line where the application made the allocation */ (*debug_ptr)->line = line; (*debug_ptr)->file = file; /* Set "HEAD" and "FOOT" boundary markers */ memcpy((*debug_ptr)->head,ERD_MemoryAllocationHead,4); memcpy(&((*debug_ptr)->data[size]),ERD_MemoryAllocationFoot,4); /* Record the size */ (*debug_ptr)->size = size; /* This links debug_ptr to a linked list that holds all the ER_DEBUG_ALLOCATION structures. */ ERC_Append_Debug_Allocation((*debug_ptr)); (*debug_ptr)->AllocSequenceCounter = ERD_AllocationSequenceCounter++; ERD_TotalMemoryAllocated += size; ERD_TotalMemoryAllocations++; ERD_AllocationCount++; if (ERD_MaxTotalMemoryAllocated < ERD_TotalMemoryAllocated) ERD_MaxTotalMemoryAllocated = ERD_TotalMemoryAllocated; if (ERD_MaxTotalMemoryAllocations < ERD_TotalMemoryAllocations) ERD_MaxTotalMemoryAllocations = ERD_TotalMemoryAllocations; /* Return pointer to the data field of debug allocation by reference */ (*ptr) = (*debug_ptr)->data; return(status); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* ERC_Deallocate_Memory */ /* */ /* DESCRIPTION */ /* */ /* This function tracks additional information regarding the memory */ /* deallocation. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* ERC_Memory_To_Debug */ /* ERC_Remove_Debug_Allocation */ /* DMCE_Deallocate_Memory */ /* */ /* INPUTS */ /* */ /* ptr Pointer to dynamic memory */ /* */ /* OUTPUTS */ /* */ /* NU_SUCCESS */ /* NU_INVALID_POINTER Returned when ptr is null or */ /* when there is no */ /* corresponding */ /* ER_DEBUG_ALLOCATION */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /*************************************************************************/ STATUS ERC_Deallocate_Memory(VOID *ptr) { ER_DEBUG_ALLOCATION *target; STATUS status; if (ptr == NULL) return(NU_INVALID_POINTER); /* Find the NU_DEBUG_ALLOCATION ptr refers to. After this call, (&(target->data) == ptr) or (target == NULL). */ target = ERC_Memory_To_Debug(ptr); /* Remove target from the linked list of ER_DEBUG_ALLOCATIONs */ status = ERC_Remove_Debug_Allocation(target); if ((status != 0) || (target == NULL)) return(NU_INVALID_POINTER); /* Maintain status variables */ ERD_TotalMemoryAllocated -= target->size; ERD_TotalMemoryAllocations--; ERD_AllocationCount--; return(DMCE_Deallocate_Memory(target)); } #endif /* NU_DEBUG_MEMORY */ /************************************************************************** This routine should appear last in this file and must *NOT* use the NU_ASSERT macro. **************************************************************************/ #ifdef NU_ASSERT /* Don't use NU_ASSERT past this point */ #undef NU_ASSERT #define NU_ASSERT(ignore) ((void) 0) #endif #ifdef NU_ASSERT2 #undef NU_ASSERT2 #define NU_ASSERT2(ignore) ((void) 0) #endif /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* ERC_Assert */ /* */ /* DESCRIPTION */ /* */ /* This public routine is called when an assertion made by the */ /* NU_ASSERT (or NU_ASSERT2) macro fails. By default, this routine */ /* simply counts the number of failed assertions. A breakpoint can */ /* be set in the routine to observe failed assertions, or the */ /* routine can be customized to perform some action, such as */ /* printing the failed assertion as a message, etc. */ /* */ /* CALLED BY */ /* */ /* NU_ASSERT macro */ /* NU_ASSERT2 macro */ /* */ /* CALLS */ /* */ /* None */ /* */ /* INPUTS */ /* */ /* test Pointer to string of failed assertion test */ /* name File name of file containing failed assertion */ /* line Location of failed assertion in above file */ /* */ /* OUTPUTS */ /* */ /* None */ /* */ /* HISTORY */ /* */ /* NAME DATE REMARKS */ /* */ /* Todd C. Larsen 09-01-1998 Created initial revision */ /* */ /*************************************************************************/ #ifdef NU_DEBUG void ERC_Assert(CHAR *test, CHAR *name, UNSIGNED line) { NU_SUPERV_USER_VARIABLES #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_ASSERT_ID, (UNSIGNED) test, (UNSIGNED) name, line); #endif /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); /* Set breakpoint here to catch failed assertions. */ ERD_Assert_Count += 1; /* Return to user mode */ NU_USER_MODE(); } #endif /* NU_DEBUG */