Modified for BG96
Fork of mbed-dev by
Diff: platform/mbed_error.c
- Revision:
- 187:0387e8f68319
- Parent:
- 186:707f6e361f3e
--- a/platform/mbed_error.c Fri Jun 22 16:45:37 2018 +0100 +++ b/platform/mbed_error.c Thu Sep 06 13:40:20 2018 +0100 @@ -21,7 +21,7 @@ #include "platform/mbed_error.h" #include "platform/mbed_error_hist.h" #include "platform/mbed_interface.h" -#ifdef MBED_CONF_RTOS_PRESENT +#ifdef MBED_CONF_RTOS_PRESENT #include "rtx_os.h" #endif @@ -33,7 +33,7 @@ #define GET_CURRENT_SP(sp) \ { \ /*If in Handler mode we are always using MSP*/ \ - if( __get_IPSR() != 0U ) { \ + if ( __get_IPSR() != 0U ) { \ sp = __get_MSP(); \ } else { \ /*Look into CONTROL.SPSEL value*/ \ @@ -43,8 +43,13 @@ sp = __get_PSP();/*Read PSP*/ \ } \ } \ - } + } +#ifndef NDEBUG +#define ERROR_REPORT(ctx, error_msg) print_error_report(ctx, error_msg) +#else +#define ERROR_REPORT(ctx, error_msg) ((void) 0) +#endif static uint8_t error_in_progress = 0; static int error_count = 0; @@ -52,15 +57,15 @@ static mbed_error_ctx last_error_ctx = {0}; static mbed_error_hook_t error_hook = NULL; static void print_error_report(mbed_error_ctx *ctx, const char *); -static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsigned int error_value, const char *filename, int line_number); +static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsigned int error_value, const char *filename, int line_number, void *caller); //Helper function to halt the system static void mbed_halt_system(void) { //If not in ISR context exit, otherwise spin on WFI if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) { - for(;;) { - __WFI(); + for (;;) { + __WFI(); } } else { //exit eventually calls mbed_die @@ -68,16 +73,17 @@ } } -WEAK void error(const char* format, ...) { +WEAK void error(const char *format, ...) +{ // Prevent recursion if error is called again if (error_in_progress) { return; } - + //Call handle_error/print_error_report permanently setting error_in_progress flag - handle_error(MBED_ERROR_UNKNOWN, 0, NULL, 0); - print_error_report(&last_error_ctx, "Fatal Run-time error"); + handle_error(MBED_ERROR_UNKNOWN, 0, NULL, 0, MBED_CALLER_ADDR()); + ERROR_REPORT(&last_error_ctx, "Fatal Run-time error"); error_in_progress = 1; #ifndef NDEBUG @@ -90,170 +96,173 @@ } //Set an error status with the error handling system -static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsigned int error_value, const char *filename, int line_number) +static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsigned int error_value, const char *filename, int line_number, void *caller) { mbed_error_ctx current_error_ctx; - + //Error status should always be < 0 - if(error_status >= 0) { + if (error_status >= 0) { //This is a weird situation, someone called mbed_error with invalid error code. //We will still handle the situation but change the error code to ERROR_INVALID_ARGUMENT, atleast the context will have info on who called it error_status = MBED_ERROR_INVALID_ARGUMENT; } - + //Prevent corruption by holding out other callers //and we also need this until we remove the "error" call completely while (error_in_progress == 1); - + //Use critsect here, as we don't want inadvertant modification of this global variable core_util_critical_section_enter(); error_in_progress = 1; core_util_critical_section_exit(); - + //Increment error count error_count++; - + //Clear the context capturing buffer memset(¤t_error_ctx, sizeof(mbed_error_ctx), 0); //Capture error information current_error_ctx.error_status = error_status; - current_error_ctx.error_address = (uint32_t)MBED_CALLER_ADDR(); + current_error_ctx.error_address = (uint32_t)caller; current_error_ctx.error_value = error_value; -#ifdef MBED_CONF_RTOS_PRESENT +#ifdef MBED_CONF_RTOS_PRESENT //Capture thread info osRtxThread_t *current_thread = osRtxInfo.thread.run.curr; current_error_ctx.thread_id = (uint32_t)current_thread; current_error_ctx.thread_entry_address = (uint32_t)current_thread->thread_addr; current_error_ctx.thread_stack_size = current_thread->stack_size; current_error_ctx.thread_stack_mem = (uint32_t)current_thread->stack_mem; -#ifdef TARGET_CORTEX_M +#ifdef TARGET_CORTEX_M GET_CURRENT_SP(current_error_ctx.thread_current_sp); #endif //TARGET_CORTEX_M - + #endif //MBED_CONF_RTOS_PRESENT -#ifdef MBED_CONF_ERROR_FILENAME_CAPTURE_ENABLED +#if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED //Capture filename/linenumber if provided //Index for tracking error_filename - memset(¤t_error_ctx.error_filename, 0, MBED_CONF_MAX_ERROR_FILENAME_LEN); - strncpy(current_error_ctx.error_filename, filename, MBED_CONF_MAX_ERROR_FILENAME_LEN); + memset(¤t_error_ctx.error_filename, 0, MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN); + strncpy(current_error_ctx.error_filename, filename, MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN); current_error_ctx.error_line_number = line_number; #endif - + //Capture the fist system error and store it - if(error_count == 1) { //first error + if (error_count == 1) { //first error memcpy(&first_error_ctx, ¤t_error_ctx, sizeof(mbed_error_ctx)); } - + //copy this error to last error memcpy(&last_error_ctx, ¤t_error_ctx, sizeof(mbed_error_ctx)); - -#ifndef MBED_CONF_ERROR_HIST_DISABLED + +#if MBED_CONF_PLATFORM_ERROR_HIST_ENABLED //Log the error with error log mbed_error_hist_put(¤t_error_ctx); -#endif - +#endif + //Call the error hook if available - if(error_hook != NULL) { + if (error_hook != NULL) { error_hook(&last_error_ctx); } - + error_in_progress = 0; - + return MBED_SUCCESS; } //Return the first error -mbed_error_status_t mbed_get_first_error(void) +mbed_error_status_t mbed_get_first_error(void) { //return the first error recorded return first_error_ctx.error_status; } //Return the last error -mbed_error_status_t mbed_get_last_error(void) +mbed_error_status_t mbed_get_last_error(void) { //return the last error recorded return last_error_ctx.error_status; } //Gets the current error count -int mbed_get_error_count(void) +int mbed_get_error_count(void) { //return the current error count return error_count; } -//Sets a fatal error -mbed_error_status_t mbed_warning(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number) +//Sets a fatal error +mbed_error_status_t mbed_warning(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number) { - return handle_error(error_status, error_value, filename, line_number); + return handle_error(error_status, error_value, filename, line_number, MBED_CALLER_ADDR()); } -//Sets a fatal error -WEAK mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number) +//Sets a fatal error, this function is marked WEAK to be able to override this for some tests +WEAK mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number) { //set the error reported and then halt the system - if( MBED_SUCCESS != handle_error(error_status, error_value, filename, line_number) ) + if (MBED_SUCCESS != handle_error(error_status, error_value, filename, line_number, MBED_CALLER_ADDR())) { return MBED_ERROR_FAILED_OPERATION; - + } + //On fatal errors print the error context/report - print_error_report(&last_error_ctx, error_msg); + ERROR_REPORT(&last_error_ctx, error_msg); mbed_halt_system(); - + return MBED_ERROR_FAILED_OPERATION; } //Register an application defined callback with error handling -mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t error_hook_in) +mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t error_hook_in) { //register the new hook/callback - if( error_hook_in != NULL ) { + if (error_hook_in != NULL) { error_hook = error_hook_in; return MBED_SUCCESS; - } - + } + return MBED_ERROR_INVALID_ARGUMENT; } -//Retrieve the first error context from error log -mbed_error_status_t mbed_get_first_error_info (mbed_error_ctx *error_info) +//Retrieve the first error context from error log +mbed_error_status_t mbed_get_first_error_info(mbed_error_ctx *error_info) { memcpy(error_info, &first_error_ctx, sizeof(first_error_ctx)); return MBED_SUCCESS; } -//Retrieve the last error context from error log -mbed_error_status_t mbed_get_last_error_info (mbed_error_ctx *error_info) +//Retrieve the last error context from error log +mbed_error_status_t mbed_get_last_error_info(mbed_error_ctx *error_info) { memcpy(error_info, &last_error_ctx, sizeof(mbed_error_ctx)); return MBED_SUCCESS; } //Makes an mbed_error_status_t value -mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t entity, mbed_error_code_t error_code) +mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t entity, mbed_error_code_t error_code) { - switch(error_type) - { + switch (error_type) { case MBED_ERROR_TYPE_POSIX: - if(error_code >= MBED_POSIX_ERROR_BASE && error_code <= MBED_SYSTEM_ERROR_BASE) + if (error_code >= MBED_POSIX_ERROR_BASE && error_code <= MBED_SYSTEM_ERROR_BASE) { return -error_code; + } break; - + case MBED_ERROR_TYPE_SYSTEM: - if(error_code >= MBED_SYSTEM_ERROR_BASE && error_code <= MBED_CUSTOM_ERROR_BASE) + if (error_code >= MBED_SYSTEM_ERROR_BASE && error_code <= MBED_CUSTOM_ERROR_BASE) { return MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, entity, error_code); + } break; - + case MBED_ERROR_TYPE_CUSTOM: - if(error_code >= MBED_CUSTOM_ERROR_BASE) + if (error_code >= MBED_CUSTOM_ERROR_BASE) { return MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, entity, error_code); + } break; - + default: break; } - + //If we are passed incorrect values return a generic system error return MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_UNKNOWN); } @@ -263,33 +272,137 @@ * @return 0 or MBED_SUCCESS on success. * */ -mbed_error_status_t mbed_clear_all_errors(void) +mbed_error_status_t mbed_clear_all_errors(void) { mbed_error_status_t status = MBED_SUCCESS; - + //Make sure we dont multiple clients resetting core_util_critical_section_enter(); //Clear the error and context capturing buffer memset(&last_error_ctx, sizeof(mbed_error_ctx), 0); //reset error count to 0 error_count = 0; -#ifndef MBED_CONF_ERROR_HIST_DISABLED +#if MBED_CONF_PLATFORM_ERROR_HIST_ENABLED status = mbed_error_hist_reset(); #endif core_util_critical_section_exit(); - + return status; } -#ifndef MBED_CONF_ERROR_HIST_DISABLED +#if MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO && defined(MBED_CONF_RTOS_PRESENT) +/* Prints info of a thread(using osRtxThread_t struct)*/ +static void print_thread(osRtxThread_t *thread) +{ + mbed_error_printf("\nState: 0x%08X Entry: 0x%08X Stack Size: 0x%08X Mem: 0x%08X SP: 0x%08X", thread->state, thread->thread_addr, thread->stack_size, (uint32_t)thread->stack_mem, thread->sp); +} + +/* Prints thread info from a list */ +static void print_threads_info(osRtxThread_t *threads) +{ + while (threads != NULL) { + print_thread(threads); + threads = threads->thread_next; + } +} +#endif + +#ifndef NDEBUG +static void print_error_report(mbed_error_ctx *ctx, const char *error_msg) +{ + uint32_t error_code = MBED_GET_ERROR_CODE(ctx->error_status); + uint32_t error_module = MBED_GET_ERROR_MODULE(ctx->error_status); + + mbed_error_printf("\n\n++ MbedOS Error Info ++\nError Status: 0x%X Code: %d Module: %d\nError Message: ", ctx->error_status, error_code, error_module); + + switch (error_code) { + //These are errors reported by kernel handled from mbed_rtx_handlers + case MBED_ERROR_CODE_RTOS_EVENT: + mbed_error_printf("Kernel Error: 0x%X, ", ctx->error_value); + break; + + case MBED_ERROR_CODE_RTOS_THREAD_EVENT: + mbed_error_printf("Thread: 0x%X, ", ctx->error_value); + break; + + case MBED_ERROR_CODE_RTOS_MUTEX_EVENT: + mbed_error_printf("Mutex: 0x%X, ", ctx->error_value); + break; + + case MBED_ERROR_CODE_RTOS_SEMAPHORE_EVENT: + mbed_error_printf("Semaphore: 0x%X, ", ctx->error_value); + break; + + case MBED_ERROR_CODE_RTOS_MEMORY_POOL_EVENT: + mbed_error_printf("MemoryPool: 0x%X, ", ctx->error_value); + break; + + case MBED_ERROR_CODE_RTOS_EVENT_FLAGS_EVENT: + mbed_error_printf("EventFlags: 0x%X, ", ctx->error_value); + break; + + case MBED_ERROR_CODE_RTOS_TIMER_EVENT: + mbed_error_printf("Timer: 0x%X, ", ctx->error_value); + break; + + case MBED_ERROR_CODE_RTOS_MESSAGE_QUEUE_EVENT: + mbed_error_printf("MessageQueue: 0x%X, ", ctx->error_value); + break; + + default: + //Nothing to do here, just print the error info down + break; + } + mbed_error_printf(error_msg); + mbed_error_printf("\nLocation: 0x%X", ctx->error_address); + +#if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED && !defined(NDEBUG) + if ((NULL != ctx->error_filename[0]) && (ctx->error_line_number != 0)) { + //for string, we must pass address of a ptr which has the address of the string + mbed_error_printf("\nFile:%s+%d", ctx->error_filename, ctx->error_line_number); + } +#endif + + mbed_error_printf("\nError Value: 0x%X", ctx->error_value); +#ifdef TARGET_CORTEX_M + mbed_error_printf("\nCurrent Thread: Id: 0x%X Entry: 0x%X StackSize: 0x%X StackMem: 0x%X SP: 0x%X ", + ctx->thread_id, ctx->thread_entry_address, ctx->thread_stack_size, ctx->thread_stack_mem, ctx->thread_current_sp); +#else + //For Cortex-A targets we dont have support to capture the current SP + mbed_error_printf("\nCurrent Thread: Id: 0x%X Entry: 0x%X StackSize: 0x%X StackMem: 0x%X ", + ctx->thread_id, ctx->thread_entry_address, ctx->thread_stack_size, ctx->thread_stack_mem); +#endif //TARGET_CORTEX_M + +#if MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO && defined(MBED_CONF_RTOS_PRESENT) + mbed_error_printf("\nNext:"); + print_thread(osRtxInfo.thread.run.next); + + mbed_error_printf("\nWait:"); + osRtxThread_t *threads = (osRtxThread_t *)&osRtxInfo.thread.wait_list; + print_threads_info(threads); + + mbed_error_printf("\nDelay:"); + threads = (osRtxThread_t *)&osRtxInfo.thread.delay_list; + print_threads_info(threads); + + mbed_error_printf("\nIdle:"); + threads = (osRtxThread_t *)&osRtxInfo.thread.idle; + print_threads_info(threads); +#endif + + mbed_error_printf("\n-- MbedOS Error Info --\n"); +} +#endif //ifndef NDEBUG + +#if MBED_CONF_PLATFORM_ERROR_HIST_ENABLED //Retrieve the error context from error log at the specified index -mbed_error_status_t mbed_get_error_hist_info (int index, mbed_error_ctx *error_info) +mbed_error_status_t mbed_get_error_hist_info(int index, mbed_error_ctx *error_info) { return mbed_error_hist_get(index, error_info); } //Retrieve the error log count -int mbed_get_error_hist_count(void) +int mbed_get_error_hist_count(void) { return mbed_error_hist_get_count(); } @@ -300,135 +413,57 @@ mbed_error_ctx ctx = {0}; int log_count = mbed_error_hist_get_count(); FILE *error_log_file = NULL; - + //Ensure path is valid - if(path==NULL) { + if (path == NULL) { ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_INVALID_ARGUMENT); goto exit; } - + //Open the file for saving the error log info - if((error_log_file = fopen( path, "w" ) ) == NULL){ + if ((error_log_file = fopen(path, "w")) == NULL) { ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED); goto exit; } - + //First store the first and last errors - if(fprintf(error_log_file, "\nFirst Error: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n", - (unsigned int)first_error_ctx.error_status, - (unsigned int)first_error_ctx.thread_id, - (unsigned int)first_error_ctx.error_address, - (unsigned int)first_error_ctx.error_value) <= 0) { + if (fprintf(error_log_file, "\nFirst Error: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n", + (unsigned int)first_error_ctx.error_status, + (unsigned int)first_error_ctx.thread_id, + (unsigned int)first_error_ctx.error_address, + (unsigned int)first_error_ctx.error_value) <= 0) { ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED); goto exit; } - - if(fprintf(error_log_file, "\nLast Error: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n", - (unsigned int)last_error_ctx.error_status, - (unsigned int)last_error_ctx.thread_id, - (unsigned int)last_error_ctx.error_address, - (unsigned int)last_error_ctx.error_value) <= 0) { + + if (fprintf(error_log_file, "\nLast Error: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n", + (unsigned int)last_error_ctx.error_status, + (unsigned int)last_error_ctx.thread_id, + (unsigned int)last_error_ctx.error_address, + (unsigned int)last_error_ctx.error_value) <= 0) { ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED); goto exit; } - + //Update with error log info - while(--log_count >= 0) { + while (--log_count >= 0) { mbed_error_hist_get(log_count, &ctx); //first line of file will be error log count - if(fprintf(error_log_file, "\n%d: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n", - log_count, - (unsigned int)ctx.error_status, - (unsigned int)ctx.thread_id, - (unsigned int)ctx.error_address, - (unsigned int)ctx.error_value) <= 0) { + if (fprintf(error_log_file, "\n%d: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n", + log_count, + (unsigned int)ctx.error_status, + (unsigned int)ctx.thread_id, + (unsigned int)ctx.error_address, + (unsigned int)ctx.error_value) <= 0) { ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED); goto exit; } } - + exit: fclose(error_log_file); - + return ret; } - -static void print_error_report(mbed_error_ctx *ctx, const char *error_msg) -{ - uint32_t error_code = MBED_GET_ERROR_CODE(ctx->error_status); - uint32_t error_module = MBED_GET_ERROR_MODULE(ctx->error_status); - - mbed_error_printf("\n\n++ MbedOS Error Info ++\nError Status: 0x%x Code: %d Module: %d\nError Message: ", ctx->error_status, error_code, error_module); - - //Report error info based on error code, some errors require different - //error_vals[1] contains the error code - if(error_code == MBED_ERROR_CODE_HARDFAULT_EXCEPTION || - error_code == MBED_ERROR_CODE_MEMMANAGE_EXCEPTION || - error_code == MBED_ERROR_CODE_BUSFAULT_EXCEPTION || - error_code == MBED_ERROR_CODE_USAGEFAULT_EXCEPTION ) { - mbed_error_printf(error_msg); - mbed_error_printf("\nLocation: 0x%x\n", ctx->error_value); - } else { - switch (error_code) { - //These are errors reported by kernel handled from mbed_rtx_handlers - case MBED_ERROR_CODE_RTOS_EVENT: - mbed_error_printf("Kernel Error: 0x%x, ", ctx->error_value); - break; - - case MBED_ERROR_CODE_RTOS_THREAD_EVENT: - mbed_error_printf("Thread: 0x%x, ", ctx->error_value); - break; - - case MBED_ERROR_CODE_RTOS_MUTEX_EVENT: - mbed_error_printf("Mutex: 0x%x, ", ctx->error_value); - break; - - case MBED_ERROR_CODE_RTOS_SEMAPHORE_EVENT: - mbed_error_printf("Semaphore: 0x%x, ", ctx->error_value); - break; - - case MBED_ERROR_CODE_RTOS_MEMORY_POOL_EVENT: - mbed_error_printf("MemoryPool: 0x%x, ", ctx->error_value); - break; - - case MBED_ERROR_CODE_RTOS_EVENT_FLAGS_EVENT: - mbed_error_printf("EventFlags: 0x%x, ", ctx->error_value); - break; - - case MBED_ERROR_CODE_RTOS_TIMER_EVENT: - mbed_error_printf("Timer: 0x%x, ", ctx->error_value); - break; - - case MBED_ERROR_CODE_RTOS_MESSAGE_QUEUE_EVENT: - mbed_error_printf("MessageQueue: 0x%x, ", ctx->error_value); - break; - - default: - //Nothing to do here, just print the error info down - break; - } - mbed_error_printf(error_msg, NULL); - mbed_error_printf("\nLocation: 0x%x", ctx->error_address); -#if defined(MBED_CONF_ERROR_FILENAME_CAPTURE_ENABLED) && !defined(NDEBUG) - if(NULL != ctx->error_filename) { - //for string, we must pass address of a ptr which has the address of the string - mbed_error_printf("\nFile:%s+%d", ctx->error_filename, ctx->error_line_number); - } -#endif - -#ifdef TARGET_CORTEX_M - mbed_error_printf("\nError Value: 0x%x\nCurrent Thread: Id: 0x%x Entry: 0x%x StackSize: 0x%x StackMem: 0x%x SP: 0x%x ", - ctx->error_value, ctx->thread_id, ctx->thread_entry_address, ctx->thread_stack_size, ctx->thread_stack_mem, ctx->thread_current_sp); -#else - //For Cortex-A targets we dont have support to capture the current SP - mbed_error_printf("\nError Value: 0x%x\nCurrent Thread: Id: 0x%x Entry: 0x%x StackSize: 0x%x StackMem: 0x%x ", - ctx->error_value, ctx->thread_id, ctx->thread_entry_address, ctx->thread_stack_size, ctx->thread_stack_mem); -#endif //TARGET_CORTEX_M - } - - mbed_error_printf("\n-- MbedOS Error Info --\n"); -} - - #endif