mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

platform/mbed_error.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
188:bcfe06ba3d64 
mbed library release version 165

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 149:156823d33999 1 /* mbed Microcontroller Library
<> 149:156823d33999 2 * Copyright (c) 2006-2013 ARM Limited
AnnaBridge 189:f392fc9709a3 3 * SPDX-License-Identifier: Apache-2.0
<> 149:156823d33999 4 *
<> 149:156823d33999 5 * Licensed under the Apache License, Version 2.0 (the "License");
<> 149:156823d33999 6 * you may not use this file except in compliance with the License.
<> 149:156823d33999 7 * You may obtain a copy of the License at
<> 149:156823d33999 8 *
<> 149:156823d33999 9 * http://www.apache.org/licenses/LICENSE-2.0
<> 149:156823d33999 10 *
<> 149:156823d33999 11 * Unless required by applicable law or agreed to in writing, software
<> 149:156823d33999 12 * distributed under the License is distributed on an "AS IS" BASIS,
<> 149:156823d33999 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<> 149:156823d33999 14 * See the License for the specific language governing permissions and
<> 149:156823d33999 15 * limitations under the License.
<> 149:156823d33999 16 */
<> 149:156823d33999 17 #include <stdlib.h>
<> 149:156823d33999 18 #include <stdarg.h>
Anna Bridge 186:707f6e361f3e 19 #include <string.h>
<> 149:156823d33999 20 #include "device.h"
AnnaBridge 189:f392fc9709a3 21 #include "platform/mbed_crash_data_offsets.h"
AnnaBridge 189:f392fc9709a3 22 #include "platform/mbed_retarget.h"
Anna Bridge 186:707f6e361f3e 23 #include "platform/mbed_critical.h"
<> 149:156823d33999 24 #include "platform/mbed_error.h"
Anna Bridge 186:707f6e361f3e 25 #include "platform/mbed_error_hist.h"
<> 149:156823d33999 26 #include "platform/mbed_interface.h"
AnnaBridge 189:f392fc9709a3 27 #include "platform/mbed_power_mgmt.h"
AnnaBridge 187:0387e8f68319 28 #ifdef MBED_CONF_RTOS_PRESENT
Anna Bridge 186:707f6e361f3e 29 #include "rtx_os.h"
Anna Bridge 186:707f6e361f3e 30 #endif
Anna Bridge 186:707f6e361f3e 31
<> 149:156823d33999 32 #if DEVICE_STDIO_MESSAGES
<> 149:156823d33999 33 #include <stdio.h>
<> 149:156823d33999 34 #endif
AnnaBridge 189:f392fc9709a3 35 #ifndef __STDC_FORMAT_MACROS
AnnaBridge 189:f392fc9709a3 36 #define __STDC_FORMAT_MACROS
AnnaBridge 189:f392fc9709a3 37 #endif
AnnaBridge 189:f392fc9709a3 38 #include <inttypes.h>
Anna Bridge 186:707f6e361f3e 39
AnnaBridge 187:0387e8f68319 40 #ifndef NDEBUG
AnnaBridge 189:f392fc9709a3 41 #define ERROR_REPORT(ctx, error_msg, error_filename, error_line) print_error_report(ctx, error_msg, error_filename, error_line)
AnnaBridge 189:f392fc9709a3 42 static void print_error_report(const mbed_error_ctx *ctx, const char *, const char *error_filename, int error_line);
AnnaBridge 187:0387e8f68319 43 #else
AnnaBridge 189:f392fc9709a3 44 #define ERROR_REPORT(ctx, error_msg, error_filename, error_line) ((void) 0)
AnnaBridge 189:f392fc9709a3 45 #endif
AnnaBridge 189:f392fc9709a3 46
AnnaBridge 189:f392fc9709a3 47 static core_util_atomic_flag error_in_progress = CORE_UTIL_ATOMIC_FLAG_INIT;
AnnaBridge 189:f392fc9709a3 48 static core_util_atomic_flag halt_in_progress = CORE_UTIL_ATOMIC_FLAG_INIT;
AnnaBridge 189:f392fc9709a3 49 static int error_count = 0;
AnnaBridge 189:f392fc9709a3 50 static mbed_error_ctx first_error_ctx = {0};
AnnaBridge 189:f392fc9709a3 51
AnnaBridge 189:f392fc9709a3 52 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
AnnaBridge 189:f392fc9709a3 53 //Global for populating the context in exception handler
AnnaBridge 189:f392fc9709a3 54 static mbed_error_ctx *const report_error_ctx = (mbed_error_ctx *)(ERROR_CONTEXT_LOCATION);
AnnaBridge 189:f392fc9709a3 55 static bool is_reboot_error_valid = false;
AnnaBridge 187:0387e8f68319 56 #endif
Anna Bridge 186:707f6e361f3e 57
Anna Bridge 186:707f6e361f3e 58 static mbed_error_ctx last_error_ctx = {0};
Anna Bridge 186:707f6e361f3e 59 static mbed_error_hook_t error_hook = NULL;
AnnaBridge 187:0387e8f68319 60 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);
Anna Bridge 186:707f6e361f3e 61
AnnaBridge 189:f392fc9709a3 62 //Helper function to calculate CRC
AnnaBridge 189:f392fc9709a3 63 //NOTE: It would have been better to use MbedCRC implementation. But
AnnaBridge 189:f392fc9709a3 64 //MbedCRC uses table based calculation and we dont want to keep that table memory
AnnaBridge 189:f392fc9709a3 65 //used up for this purpose. Also we cannot force bitwise calculation in MbedCRC
AnnaBridge 189:f392fc9709a3 66 //and it also requires a new wrapper to be called from C implementation. Since
AnnaBridge 189:f392fc9709a3 67 //we dont have many uses cases to create a C wrapper for MbedCRC and the data
AnnaBridge 189:f392fc9709a3 68 //we calculate CRC on in this context is very less we will use a local
AnnaBridge 189:f392fc9709a3 69 //implementation here.
AnnaBridge 189:f392fc9709a3 70 static unsigned int compute_crc32(const void *data, int datalen)
AnnaBridge 189:f392fc9709a3 71 {
AnnaBridge 189:f392fc9709a3 72 const unsigned int polynomial = 0x04C11DB7; /* divisor is 32bit */
AnnaBridge 189:f392fc9709a3 73 unsigned int crc = 0; /* CRC value is 32bit */
AnnaBridge 189:f392fc9709a3 74 unsigned char *buf = (unsigned char *)data;//use a temp variable to make code readable and to avoid typecasting issues.
AnnaBridge 189:f392fc9709a3 75
AnnaBridge 189:f392fc9709a3 76 for (; datalen > 0; datalen--) {
AnnaBridge 189:f392fc9709a3 77 unsigned char b = *buf++;
AnnaBridge 189:f392fc9709a3 78 crc ^= (unsigned int)(b << 24); /* move byte into upper 8bit */
AnnaBridge 189:f392fc9709a3 79 for (int i = 0; i < 8; i++) {
AnnaBridge 189:f392fc9709a3 80 /* is MSB 1 */
AnnaBridge 189:f392fc9709a3 81 if ((crc & 0x80000000) != 0) {
AnnaBridge 189:f392fc9709a3 82 crc = (unsigned int)((crc << 1) ^ polynomial);
AnnaBridge 189:f392fc9709a3 83 } else {
AnnaBridge 189:f392fc9709a3 84 crc <<= 1;
AnnaBridge 189:f392fc9709a3 85 }
AnnaBridge 189:f392fc9709a3 86 }
AnnaBridge 189:f392fc9709a3 87 }
AnnaBridge 189:f392fc9709a3 88
AnnaBridge 189:f392fc9709a3 89 return crc;
AnnaBridge 189:f392fc9709a3 90 }
AnnaBridge 189:f392fc9709a3 91
Anna Bridge 186:707f6e361f3e 92 //Helper function to halt the system
AnnaBridge 189:f392fc9709a3 93 static MBED_NORETURN void mbed_halt_system(void)
Anna Bridge 186:707f6e361f3e 94 {
AnnaBridge 189:f392fc9709a3 95 // Prevent recursion if halt is called again during halt attempt - try
AnnaBridge 189:f392fc9709a3 96 // something simple instead.
AnnaBridge 189:f392fc9709a3 97 if (core_util_atomic_flag_test_and_set(&halt_in_progress)) {
AnnaBridge 189:f392fc9709a3 98 core_util_critical_section_enter();
AnnaBridge 189:f392fc9709a3 99 __DSB();
AnnaBridge 187:0387e8f68319 100 for (;;) {
AnnaBridge 189:f392fc9709a3 101 __WFE(); // Not WFI, as don't want to wake for pending interrupts
Anna Bridge 186:707f6e361f3e 102 }
Anna Bridge 186:707f6e361f3e 103 }
AnnaBridge 189:f392fc9709a3 104
AnnaBridge 189:f392fc9709a3 105 //If in ISR context, call mbed_die directly
AnnaBridge 189:f392fc9709a3 106 if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
AnnaBridge 189:f392fc9709a3 107 mbed_die();
AnnaBridge 189:f392fc9709a3 108 }
AnnaBridge 189:f392fc9709a3 109
AnnaBridge 189:f392fc9709a3 110 // In normal context, try orderly exit(1), which eventually calls mbed_die
AnnaBridge 189:f392fc9709a3 111 exit(1);
Anna Bridge 186:707f6e361f3e 112 }
AnnaBridge 167:e84263d55307 113
AnnaBridge 189:f392fc9709a3 114 WEAK MBED_NORETURN void error(const char *format, ...)
AnnaBridge 187:0387e8f68319 115 {
AnnaBridge 189:f392fc9709a3 116 // Prevent recursion if error is called again during store+print attempt
AnnaBridge 189:f392fc9709a3 117 if (!core_util_atomic_flag_test_and_set(&error_in_progress)) {
AnnaBridge 189:f392fc9709a3 118 handle_error(MBED_ERROR_UNKNOWN, 0, NULL, 0, MBED_CALLER_ADDR());
AnnaBridge 189:f392fc9709a3 119 ERROR_REPORT(&last_error_ctx, "Fatal Run-time error", NULL, 0);
AnnaBridge 167:e84263d55307 120
AnnaBridge 189:f392fc9709a3 121 #ifndef NDEBUG
AnnaBridge 189:f392fc9709a3 122 va_list arg;
AnnaBridge 189:f392fc9709a3 123 va_start(arg, format);
AnnaBridge 189:f392fc9709a3 124 mbed_error_vprintf(format, arg);
AnnaBridge 189:f392fc9709a3 125 va_end(arg);
AnnaBridge 189:f392fc9709a3 126 #endif
AnnaBridge 167:e84263d55307 127 }
AnnaBridge 187:0387e8f68319 128
AnnaBridge 189:f392fc9709a3 129 mbed_halt_system();
<> 149:156823d33999 130 }
Anna Bridge 186:707f6e361f3e 131
Anna Bridge 186:707f6e361f3e 132 //Set an error status with the error handling system
AnnaBridge 187:0387e8f68319 133 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)
Anna Bridge 186:707f6e361f3e 134 {
Anna Bridge 186:707f6e361f3e 135 mbed_error_ctx current_error_ctx;
AnnaBridge 187:0387e8f68319 136
Anna Bridge 186:707f6e361f3e 137 //Error status should always be < 0
AnnaBridge 187:0387e8f68319 138 if (error_status >= 0) {
Anna Bridge 186:707f6e361f3e 139 //This is a weird situation, someone called mbed_error with invalid error code.
Anna Bridge 186:707f6e361f3e 140 //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
Anna Bridge 186:707f6e361f3e 141 error_status = MBED_ERROR_INVALID_ARGUMENT;
Anna Bridge 186:707f6e361f3e 142 }
AnnaBridge 187:0387e8f68319 143
Anna Bridge 186:707f6e361f3e 144 //Clear the context capturing buffer
AnnaBridge 188:bcfe06ba3d64 145 memset(&current_error_ctx, 0, sizeof(mbed_error_ctx));
Anna Bridge 186:707f6e361f3e 146 //Capture error information
Anna Bridge 186:707f6e361f3e 147 current_error_ctx.error_status = error_status;
AnnaBridge 187:0387e8f68319 148 current_error_ctx.error_address = (uint32_t)caller;
Anna Bridge 186:707f6e361f3e 149 current_error_ctx.error_value = error_value;
AnnaBridge 187:0387e8f68319 150 #ifdef MBED_CONF_RTOS_PRESENT
Anna Bridge 186:707f6e361f3e 151 //Capture thread info
Anna Bridge 186:707f6e361f3e 152 osRtxThread_t *current_thread = osRtxInfo.thread.run.curr;
Anna Bridge 186:707f6e361f3e 153 current_error_ctx.thread_id = (uint32_t)current_thread;
Anna Bridge 186:707f6e361f3e 154 current_error_ctx.thread_entry_address = (uint32_t)current_thread->thread_addr;
Anna Bridge 186:707f6e361f3e 155 current_error_ctx.thread_stack_size = current_thread->stack_size;
Anna Bridge 186:707f6e361f3e 156 current_error_ctx.thread_stack_mem = (uint32_t)current_thread->stack_mem;
AnnaBridge 189:f392fc9709a3 157 current_error_ctx.thread_current_sp = (uint32_t)&current_error_ctx; // Address local variable to get a stack pointer
Anna Bridge 186:707f6e361f3e 158 #endif //MBED_CONF_RTOS_PRESENT
Anna Bridge 186:707f6e361f3e 159
AnnaBridge 187:0387e8f68319 160 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
Anna Bridge 186:707f6e361f3e 161 //Capture filename/linenumber if provided
Anna Bridge 186:707f6e361f3e 162 //Index for tracking error_filename
AnnaBridge 187:0387e8f68319 163 strncpy(current_error_ctx.error_filename, filename, MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN);
Anna Bridge 186:707f6e361f3e 164 current_error_ctx.error_line_number = line_number;
Anna Bridge 186:707f6e361f3e 165 #endif
AnnaBridge 187:0387e8f68319 166
AnnaBridge 189:f392fc9709a3 167 //Prevent corruption by holding out other callers
AnnaBridge 189:f392fc9709a3 168 core_util_critical_section_enter();
AnnaBridge 189:f392fc9709a3 169
AnnaBridge 189:f392fc9709a3 170 //Increment error count
AnnaBridge 189:f392fc9709a3 171 error_count++;
AnnaBridge 189:f392fc9709a3 172
AnnaBridge 189:f392fc9709a3 173 //Capture the first system error and store it
AnnaBridge 187:0387e8f68319 174 if (error_count == 1) { //first error
Anna Bridge 186:707f6e361f3e 175 memcpy(&first_error_ctx, &current_error_ctx, sizeof(mbed_error_ctx));
Anna Bridge 186:707f6e361f3e 176 }
AnnaBridge 187:0387e8f68319 177
Anna Bridge 186:707f6e361f3e 178 //copy this error to last error
Anna Bridge 186:707f6e361f3e 179 memcpy(&last_error_ctx, &current_error_ctx, sizeof(mbed_error_ctx));
AnnaBridge 187:0387e8f68319 180
AnnaBridge 187:0387e8f68319 181 #if MBED_CONF_PLATFORM_ERROR_HIST_ENABLED
Anna Bridge 186:707f6e361f3e 182 //Log the error with error log
Anna Bridge 186:707f6e361f3e 183 mbed_error_hist_put(&current_error_ctx);
AnnaBridge 187:0387e8f68319 184 #endif
AnnaBridge 187:0387e8f68319 185
Anna Bridge 186:707f6e361f3e 186 //Call the error hook if available
AnnaBridge 187:0387e8f68319 187 if (error_hook != NULL) {
Anna Bridge 186:707f6e361f3e 188 error_hook(&last_error_ctx);
Anna Bridge 186:707f6e361f3e 189 }
AnnaBridge 187:0387e8f68319 190
AnnaBridge 189:f392fc9709a3 191 core_util_critical_section_exit();
AnnaBridge 189:f392fc9709a3 192
AnnaBridge 189:f392fc9709a3 193 return MBED_SUCCESS;
AnnaBridge 189:f392fc9709a3 194 }
AnnaBridge 189:f392fc9709a3 195
AnnaBridge 189:f392fc9709a3 196 WEAK void mbed_error_reboot_callback(mbed_error_ctx *error_context)
AnnaBridge 189:f392fc9709a3 197 {
AnnaBridge 189:f392fc9709a3 198 //Dont do anything here, let application override this if required.
AnnaBridge 189:f392fc9709a3 199 }
AnnaBridge 189:f392fc9709a3 200
AnnaBridge 189:f392fc9709a3 201 //Initialize Error handling system and report any errors detected on rebooted
AnnaBridge 189:f392fc9709a3 202 mbed_error_status_t mbed_error_initialize(void)
AnnaBridge 189:f392fc9709a3 203 {
AnnaBridge 189:f392fc9709a3 204 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
AnnaBridge 189:f392fc9709a3 205 uint32_t crc_val = 0;
AnnaBridge 187:0387e8f68319 206
AnnaBridge 189:f392fc9709a3 207 //Just check if we have valid value for error_status, if error_status is positive(which is not valid), no need to check crc
AnnaBridge 189:f392fc9709a3 208 if (report_error_ctx->error_status < 0) {
AnnaBridge 189:f392fc9709a3 209 crc_val = compute_crc32(report_error_ctx, offsetof(mbed_error_ctx, crc_error_ctx));
AnnaBridge 189:f392fc9709a3 210 //Read report_error_ctx and check if CRC is correct, and with valid status code
AnnaBridge 189:f392fc9709a3 211 if ((report_error_ctx->crc_error_ctx == crc_val) && (report_error_ctx->is_error_processed == 0)) {
AnnaBridge 189:f392fc9709a3 212 is_reboot_error_valid = true;
AnnaBridge 189:f392fc9709a3 213
AnnaBridge 189:f392fc9709a3 214 //Call the mbed_error_reboot_callback, this enables applications to do some handling before we do the handling
AnnaBridge 189:f392fc9709a3 215 mbed_error_reboot_callback(report_error_ctx);
AnnaBridge 189:f392fc9709a3 216
AnnaBridge 189:f392fc9709a3 217 //We let the callback reset the error info, so check if its still valid and do the rest only if its still valid.
AnnaBridge 189:f392fc9709a3 218 if (report_error_ctx->error_reboot_count > 0) {
AnnaBridge 189:f392fc9709a3 219
AnnaBridge 189:f392fc9709a3 220 report_error_ctx->is_error_processed = 1;//Set the flag that we already processed this error
AnnaBridge 189:f392fc9709a3 221 crc_val = compute_crc32(report_error_ctx, offsetof(mbed_error_ctx, crc_error_ctx));
AnnaBridge 189:f392fc9709a3 222 report_error_ctx->crc_error_ctx = crc_val;
AnnaBridge 189:f392fc9709a3 223
AnnaBridge 189:f392fc9709a3 224 //Enforce max-reboot only if auto reboot is enabled
AnnaBridge 189:f392fc9709a3 225 #if MBED_CONF_PLATFORM_FATAL_ERROR_AUTO_REBOOT_ENABLED
AnnaBridge 189:f392fc9709a3 226 if (report_error_ctx->error_reboot_count >= MBED_CONF_PLATFORM_ERROR_REBOOT_MAX) {
AnnaBridge 189:f392fc9709a3 227 mbed_halt_system();
AnnaBridge 189:f392fc9709a3 228 }
AnnaBridge 189:f392fc9709a3 229 #endif
AnnaBridge 189:f392fc9709a3 230 }
AnnaBridge 189:f392fc9709a3 231 }
AnnaBridge 189:f392fc9709a3 232 }
AnnaBridge 189:f392fc9709a3 233 #endif
Anna Bridge 186:707f6e361f3e 234 return MBED_SUCCESS;
Anna Bridge 186:707f6e361f3e 235 }
Anna Bridge 186:707f6e361f3e 236
Anna Bridge 186:707f6e361f3e 237 //Return the first error
AnnaBridge 187:0387e8f68319 238 mbed_error_status_t mbed_get_first_error(void)
Anna Bridge 186:707f6e361f3e 239 {
Anna Bridge 186:707f6e361f3e 240 //return the first error recorded
Anna Bridge 186:707f6e361f3e 241 return first_error_ctx.error_status;
Anna Bridge 186:707f6e361f3e 242 }
Anna Bridge 186:707f6e361f3e 243
Anna Bridge 186:707f6e361f3e 244 //Return the last error
AnnaBridge 187:0387e8f68319 245 mbed_error_status_t mbed_get_last_error(void)
Anna Bridge 186:707f6e361f3e 246 {
Anna Bridge 186:707f6e361f3e 247 //return the last error recorded
Anna Bridge 186:707f6e361f3e 248 return last_error_ctx.error_status;
Anna Bridge 186:707f6e361f3e 249 }
Anna Bridge 186:707f6e361f3e 250
Anna Bridge 186:707f6e361f3e 251 //Gets the current error count
AnnaBridge 187:0387e8f68319 252 int mbed_get_error_count(void)
Anna Bridge 186:707f6e361f3e 253 {
Anna Bridge 186:707f6e361f3e 254 //return the current error count
Anna Bridge 186:707f6e361f3e 255 return error_count;
Anna Bridge 186:707f6e361f3e 256 }
Anna Bridge 186:707f6e361f3e 257
AnnaBridge 189:f392fc9709a3 258 //Sets a non-fatal error
AnnaBridge 187:0387e8f68319 259 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)
Anna Bridge 186:707f6e361f3e 260 {
AnnaBridge 187:0387e8f68319 261 return handle_error(error_status, error_value, filename, line_number, MBED_CALLER_ADDR());
Anna Bridge 186:707f6e361f3e 262 }
Anna Bridge 186:707f6e361f3e 263
AnnaBridge 187:0387e8f68319 264 //Sets a fatal error, this function is marked WEAK to be able to override this for some tests
AnnaBridge 189:f392fc9709a3 265 WEAK MBED_NORETURN 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)
Anna Bridge 186:707f6e361f3e 266 {
AnnaBridge 189:f392fc9709a3 267 // Prevent recursion if error is called again during store+print attempt
AnnaBridge 189:f392fc9709a3 268 if (!core_util_atomic_flag_test_and_set(&error_in_progress)) {
AnnaBridge 189:f392fc9709a3 269 //set the error reported
AnnaBridge 189:f392fc9709a3 270 (void) handle_error(error_status, error_value, filename, line_number, MBED_CALLER_ADDR());
AnnaBridge 189:f392fc9709a3 271
AnnaBridge 189:f392fc9709a3 272 //On fatal errors print the error context/report
AnnaBridge 189:f392fc9709a3 273 ERROR_REPORT(&last_error_ctx, error_msg, filename, line_number);
AnnaBridge 187:0387e8f68319 274 }
AnnaBridge 187:0387e8f68319 275
AnnaBridge 189:f392fc9709a3 276 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
AnnaBridge 189:f392fc9709a3 277 uint32_t crc_val = 0;
AnnaBridge 189:f392fc9709a3 278 crc_val = compute_crc32(report_error_ctx, offsetof(mbed_error_ctx, crc_error_ctx));
AnnaBridge 189:f392fc9709a3 279 //Read report_error_ctx and check if CRC is correct for report_error_ctx
AnnaBridge 189:f392fc9709a3 280 if (report_error_ctx->crc_error_ctx == crc_val) {
AnnaBridge 189:f392fc9709a3 281 uint32_t current_reboot_count = report_error_ctx->error_reboot_count;
AnnaBridge 189:f392fc9709a3 282 last_error_ctx.error_reboot_count = current_reboot_count + 1;
AnnaBridge 189:f392fc9709a3 283 } else {
AnnaBridge 189:f392fc9709a3 284 last_error_ctx.error_reboot_count = 1;
AnnaBridge 189:f392fc9709a3 285 }
AnnaBridge 189:f392fc9709a3 286 last_error_ctx.is_error_processed = 0;//Set the flag that this is a new error
AnnaBridge 189:f392fc9709a3 287 //Update the struct with crc
AnnaBridge 189:f392fc9709a3 288 last_error_ctx.crc_error_ctx = compute_crc32(&last_error_ctx, offsetof(mbed_error_ctx, crc_error_ctx));
AnnaBridge 189:f392fc9709a3 289 //Protect report_error_ctx while we update it
AnnaBridge 189:f392fc9709a3 290 core_util_critical_section_enter();
AnnaBridge 189:f392fc9709a3 291 memcpy(report_error_ctx, &last_error_ctx, sizeof(mbed_error_ctx));
AnnaBridge 189:f392fc9709a3 292 core_util_critical_section_exit();
AnnaBridge 189:f392fc9709a3 293 //We need not call delete_mbed_crc(crc_obj) here as we are going to reset the system anyway, and calling delete while handling a fatal error may cause nested exception
AnnaBridge 189:f392fc9709a3 294 #if MBED_CONF_PLATFORM_FATAL_ERROR_AUTO_REBOOT_ENABLED && (MBED_CONF_PLATFORM_ERROR_REBOOT_MAX > 0)
AnnaBridge 189:f392fc9709a3 295 #ifndef NDEBUG
AnnaBridge 189:f392fc9709a3 296 mbed_error_printf("\n= System will be rebooted due to a fatal error =\n");
AnnaBridge 189:f392fc9709a3 297 if (report_error_ctx->error_reboot_count >= MBED_CONF_PLATFORM_ERROR_REBOOT_MAX) {
AnnaBridge 189:f392fc9709a3 298 //We have rebooted more than enough, hold the system here.
AnnaBridge 189:f392fc9709a3 299 mbed_error_printf("= Reboot count(=%ld) reached maximum, system will halt after rebooting =\n", report_error_ctx->error_reboot_count);
AnnaBridge 189:f392fc9709a3 300 }
AnnaBridge 189:f392fc9709a3 301 #endif
AnnaBridge 189:f392fc9709a3 302 system_reset();//do a system reset to get the system rebooted
AnnaBridge 189:f392fc9709a3 303 #endif
AnnaBridge 189:f392fc9709a3 304 #endif
Anna Bridge 186:707f6e361f3e 305 mbed_halt_system();
Anna Bridge 186:707f6e361f3e 306 }
Anna Bridge 186:707f6e361f3e 307
Anna Bridge 186:707f6e361f3e 308 //Register an application defined callback with error handling
AnnaBridge 187:0387e8f68319 309 mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t error_hook_in)
Anna Bridge 186:707f6e361f3e 310 {
Anna Bridge 186:707f6e361f3e 311 //register the new hook/callback
AnnaBridge 189:f392fc9709a3 312 if (error_hook_in != NULL) {
Anna Bridge 186:707f6e361f3e 313 error_hook = error_hook_in;
Anna Bridge 186:707f6e361f3e 314 return MBED_SUCCESS;
AnnaBridge 187:0387e8f68319 315 }
AnnaBridge 187:0387e8f68319 316
Anna Bridge 186:707f6e361f3e 317 return MBED_ERROR_INVALID_ARGUMENT;
Anna Bridge 186:707f6e361f3e 318 }
Anna Bridge 186:707f6e361f3e 319
AnnaBridge 189:f392fc9709a3 320 //Reset the reboot error context
AnnaBridge 189:f392fc9709a3 321 mbed_error_status_t mbed_reset_reboot_error_info()
AnnaBridge 189:f392fc9709a3 322 {
AnnaBridge 189:f392fc9709a3 323 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
AnnaBridge 189:f392fc9709a3 324 //Protect for thread safety
AnnaBridge 189:f392fc9709a3 325 core_util_critical_section_enter();
AnnaBridge 189:f392fc9709a3 326 memset(report_error_ctx, 0, sizeof(mbed_error_ctx));
AnnaBridge 189:f392fc9709a3 327 core_util_critical_section_exit();
AnnaBridge 189:f392fc9709a3 328 #endif
AnnaBridge 189:f392fc9709a3 329 return MBED_SUCCESS;
AnnaBridge 189:f392fc9709a3 330 }
AnnaBridge 189:f392fc9709a3 331
AnnaBridge 189:f392fc9709a3 332 //Reset the reboot error context
AnnaBridge 189:f392fc9709a3 333 mbed_error_status_t mbed_reset_reboot_count()
AnnaBridge 189:f392fc9709a3 334 {
AnnaBridge 189:f392fc9709a3 335 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
AnnaBridge 189:f392fc9709a3 336 if (is_reboot_error_valid) {
AnnaBridge 189:f392fc9709a3 337 uint32_t crc_val = 0;
AnnaBridge 189:f392fc9709a3 338 core_util_critical_section_enter();
AnnaBridge 189:f392fc9709a3 339 report_error_ctx->error_reboot_count = 0;//Set reboot count to 0
AnnaBridge 189:f392fc9709a3 340 //Update CRC
AnnaBridge 189:f392fc9709a3 341 crc_val = compute_crc32(report_error_ctx, offsetof(mbed_error_ctx, crc_error_ctx));
AnnaBridge 189:f392fc9709a3 342 report_error_ctx->crc_error_ctx = crc_val;
AnnaBridge 189:f392fc9709a3 343 core_util_critical_section_exit();
AnnaBridge 189:f392fc9709a3 344 return MBED_SUCCESS;
AnnaBridge 189:f392fc9709a3 345 }
AnnaBridge 189:f392fc9709a3 346 #endif
AnnaBridge 189:f392fc9709a3 347 return MBED_ERROR_ITEM_NOT_FOUND;
AnnaBridge 189:f392fc9709a3 348 }
AnnaBridge 189:f392fc9709a3 349
AnnaBridge 189:f392fc9709a3 350 //Retrieve the reboot error context
AnnaBridge 189:f392fc9709a3 351 mbed_error_status_t mbed_get_reboot_error_info(mbed_error_ctx *error_info)
AnnaBridge 189:f392fc9709a3 352 {
AnnaBridge 189:f392fc9709a3 353 mbed_error_status_t status = MBED_ERROR_ITEM_NOT_FOUND;
AnnaBridge 189:f392fc9709a3 354 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
AnnaBridge 189:f392fc9709a3 355 if (is_reboot_error_valid) {
AnnaBridge 189:f392fc9709a3 356 if (error_info != NULL) {
AnnaBridge 189:f392fc9709a3 357 memcpy(error_info, report_error_ctx, sizeof(mbed_error_ctx));
AnnaBridge 189:f392fc9709a3 358 status = MBED_SUCCESS;
AnnaBridge 189:f392fc9709a3 359 } else {
AnnaBridge 189:f392fc9709a3 360 status = MBED_ERROR_INVALID_ARGUMENT;
AnnaBridge 189:f392fc9709a3 361 }
AnnaBridge 189:f392fc9709a3 362 }
AnnaBridge 189:f392fc9709a3 363 #endif
AnnaBridge 189:f392fc9709a3 364 return status;
AnnaBridge 189:f392fc9709a3 365 }
AnnaBridge 189:f392fc9709a3 366
AnnaBridge 187:0387e8f68319 367 //Retrieve the first error context from error log
AnnaBridge 187:0387e8f68319 368 mbed_error_status_t mbed_get_first_error_info(mbed_error_ctx *error_info)
Anna Bridge 186:707f6e361f3e 369 {
Anna Bridge 186:707f6e361f3e 370 memcpy(error_info, &first_error_ctx, sizeof(first_error_ctx));
Anna Bridge 186:707f6e361f3e 371 return MBED_SUCCESS;
Anna Bridge 186:707f6e361f3e 372 }
Anna Bridge 186:707f6e361f3e 373
AnnaBridge 187:0387e8f68319 374 //Retrieve the last error context from error log
AnnaBridge 187:0387e8f68319 375 mbed_error_status_t mbed_get_last_error_info(mbed_error_ctx *error_info)
Anna Bridge 186:707f6e361f3e 376 {
Anna Bridge 186:707f6e361f3e 377 memcpy(error_info, &last_error_ctx, sizeof(mbed_error_ctx));
Anna Bridge 186:707f6e361f3e 378 return MBED_SUCCESS;
Anna Bridge 186:707f6e361f3e 379 }
Anna Bridge 186:707f6e361f3e 380
Anna Bridge 186:707f6e361f3e 381 //Makes an mbed_error_status_t value
AnnaBridge 187:0387e8f68319 382 mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t entity, mbed_error_code_t error_code)
Anna Bridge 186:707f6e361f3e 383 {
AnnaBridge 187:0387e8f68319 384 switch (error_type) {
Anna Bridge 186:707f6e361f3e 385 case MBED_ERROR_TYPE_POSIX:
AnnaBridge 187:0387e8f68319 386 if (error_code >= MBED_POSIX_ERROR_BASE && error_code <= MBED_SYSTEM_ERROR_BASE) {
Anna Bridge 186:707f6e361f3e 387 return -error_code;
AnnaBridge 187:0387e8f68319 388 }
Anna Bridge 186:707f6e361f3e 389 break;
AnnaBridge 187:0387e8f68319 390
Anna Bridge 186:707f6e361f3e 391 case MBED_ERROR_TYPE_SYSTEM:
AnnaBridge 187:0387e8f68319 392 if (error_code >= MBED_SYSTEM_ERROR_BASE && error_code <= MBED_CUSTOM_ERROR_BASE) {
Anna Bridge 186:707f6e361f3e 393 return MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, entity, error_code);
AnnaBridge 187:0387e8f68319 394 }
Anna Bridge 186:707f6e361f3e 395 break;
AnnaBridge 187:0387e8f68319 396
Anna Bridge 186:707f6e361f3e 397 case MBED_ERROR_TYPE_CUSTOM:
AnnaBridge 187:0387e8f68319 398 if (error_code >= MBED_CUSTOM_ERROR_BASE) {
Anna Bridge 186:707f6e361f3e 399 return MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, entity, error_code);
AnnaBridge 187:0387e8f68319 400 }
Anna Bridge 186:707f6e361f3e 401 break;
AnnaBridge 187:0387e8f68319 402
Anna Bridge 186:707f6e361f3e 403 default:
Anna Bridge 186:707f6e361f3e 404 break;
Anna Bridge 186:707f6e361f3e 405 }
AnnaBridge 187:0387e8f68319 406
Anna Bridge 186:707f6e361f3e 407 //If we are passed incorrect values return a generic system error
Anna Bridge 186:707f6e361f3e 408 return MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_UNKNOWN);
Anna Bridge 186:707f6e361f3e 409 }
Anna Bridge 186:707f6e361f3e 410
Anna Bridge 186:707f6e361f3e 411 /**
Anna Bridge 186:707f6e361f3e 412 * Clears all the last error, error count and all entries in the error log.
Anna Bridge 186:707f6e361f3e 413 * @return 0 or MBED_SUCCESS on success.
Anna Bridge 186:707f6e361f3e 414 *
Anna Bridge 186:707f6e361f3e 415 */
AnnaBridge 187:0387e8f68319 416 mbed_error_status_t mbed_clear_all_errors(void)
Anna Bridge 186:707f6e361f3e 417 {
Anna Bridge 186:707f6e361f3e 418 mbed_error_status_t status = MBED_SUCCESS;
AnnaBridge 187:0387e8f68319 419
Anna Bridge 186:707f6e361f3e 420 //Make sure we dont multiple clients resetting
Anna Bridge 186:707f6e361f3e 421 core_util_critical_section_enter();
Anna Bridge 186:707f6e361f3e 422 //Clear the error and context capturing buffer
AnnaBridge 188:bcfe06ba3d64 423 memset(&last_error_ctx, 0, sizeof(mbed_error_ctx));
Anna Bridge 186:707f6e361f3e 424 //reset error count to 0
Anna Bridge 186:707f6e361f3e 425 error_count = 0;
AnnaBridge 187:0387e8f68319 426 #if MBED_CONF_PLATFORM_ERROR_HIST_ENABLED
Anna Bridge 186:707f6e361f3e 427 status = mbed_error_hist_reset();
Anna Bridge 186:707f6e361f3e 428 #endif
Anna Bridge 186:707f6e361f3e 429 core_util_critical_section_exit();
AnnaBridge 187:0387e8f68319 430
Anna Bridge 186:707f6e361f3e 431 return status;
Anna Bridge 186:707f6e361f3e 432 }
Anna Bridge 186:707f6e361f3e 433
AnnaBridge 189:f392fc9709a3 434 static const char *name_or_unnamed(const char *name)
AnnaBridge 189:f392fc9709a3 435 {
AnnaBridge 189:f392fc9709a3 436 return name ? name : "<unnamed>";
AnnaBridge 189:f392fc9709a3 437 }
AnnaBridge 189:f392fc9709a3 438
AnnaBridge 187:0387e8f68319 439 #if MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO && defined(MBED_CONF_RTOS_PRESENT)
AnnaBridge 187:0387e8f68319 440 /* Prints info of a thread(using osRtxThread_t struct)*/
AnnaBridge 189:f392fc9709a3 441 static void print_thread(const osRtxThread_t *thread)
AnnaBridge 187:0387e8f68319 442 {
AnnaBridge 189:f392fc9709a3 443 mbed_error_printf("\n%s State: 0x%" PRIX8 " Entry: 0x%08" PRIX32 " Stack Size: 0x%08" PRIX32 " Mem: 0x%08" PRIX32 " SP: 0x%08" PRIX32, name_or_unnamed(thread->name), thread->state, thread->thread_addr, thread->stack_size, (uint32_t)thread->stack_mem, thread->sp);
AnnaBridge 187:0387e8f68319 444 }
AnnaBridge 187:0387e8f68319 445
AnnaBridge 187:0387e8f68319 446 /* Prints thread info from a list */
AnnaBridge 189:f392fc9709a3 447 static void print_threads_info(const osRtxThread_t *threads)
AnnaBridge 187:0387e8f68319 448 {
AnnaBridge 187:0387e8f68319 449 while (threads != NULL) {
AnnaBridge 187:0387e8f68319 450 print_thread(threads);
AnnaBridge 187:0387e8f68319 451 threads = threads->thread_next;
AnnaBridge 187:0387e8f68319 452 }
AnnaBridge 187:0387e8f68319 453 }
AnnaBridge 187:0387e8f68319 454 #endif
AnnaBridge 187:0387e8f68319 455
AnnaBridge 187:0387e8f68319 456 #ifndef NDEBUG
AnnaBridge 189:f392fc9709a3 457 static void print_error_report(const mbed_error_ctx *ctx, const char *error_msg, const char *error_filename, int error_line)
AnnaBridge 187:0387e8f68319 458 {
AnnaBridge 189:f392fc9709a3 459 int error_code = MBED_GET_ERROR_CODE(ctx->error_status);
AnnaBridge 189:f392fc9709a3 460 int error_module = MBED_GET_ERROR_MODULE(ctx->error_status);
AnnaBridge 187:0387e8f68319 461
AnnaBridge 187:0387e8f68319 462 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);
AnnaBridge 187:0387e8f68319 463
AnnaBridge 187:0387e8f68319 464 switch (error_code) {
AnnaBridge 187:0387e8f68319 465 //These are errors reported by kernel handled from mbed_rtx_handlers
AnnaBridge 187:0387e8f68319 466 case MBED_ERROR_CODE_RTOS_EVENT:
AnnaBridge 189:f392fc9709a3 467 mbed_error_printf("Kernel Error: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 187:0387e8f68319 468 break;
AnnaBridge 187:0387e8f68319 469
AnnaBridge 187:0387e8f68319 470 case MBED_ERROR_CODE_RTOS_THREAD_EVENT:
AnnaBridge 189:f392fc9709a3 471 mbed_error_printf("Thread: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 187:0387e8f68319 472 break;
AnnaBridge 187:0387e8f68319 473
AnnaBridge 187:0387e8f68319 474 case MBED_ERROR_CODE_RTOS_MUTEX_EVENT:
AnnaBridge 189:f392fc9709a3 475 mbed_error_printf("Mutex: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 187:0387e8f68319 476 break;
AnnaBridge 187:0387e8f68319 477
AnnaBridge 187:0387e8f68319 478 case MBED_ERROR_CODE_RTOS_SEMAPHORE_EVENT:
AnnaBridge 189:f392fc9709a3 479 mbed_error_printf("Semaphore: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 187:0387e8f68319 480 break;
AnnaBridge 187:0387e8f68319 481
AnnaBridge 187:0387e8f68319 482 case MBED_ERROR_CODE_RTOS_MEMORY_POOL_EVENT:
AnnaBridge 189:f392fc9709a3 483 mbed_error_printf("MemoryPool: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 187:0387e8f68319 484 break;
AnnaBridge 187:0387e8f68319 485
AnnaBridge 187:0387e8f68319 486 case MBED_ERROR_CODE_RTOS_EVENT_FLAGS_EVENT:
AnnaBridge 189:f392fc9709a3 487 mbed_error_printf("EventFlags: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 187:0387e8f68319 488 break;
AnnaBridge 187:0387e8f68319 489
AnnaBridge 187:0387e8f68319 490 case MBED_ERROR_CODE_RTOS_TIMER_EVENT:
AnnaBridge 189:f392fc9709a3 491 mbed_error_printf("Timer: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 187:0387e8f68319 492 break;
AnnaBridge 187:0387e8f68319 493
AnnaBridge 187:0387e8f68319 494 case MBED_ERROR_CODE_RTOS_MESSAGE_QUEUE_EVENT:
AnnaBridge 189:f392fc9709a3 495 mbed_error_printf("MessageQueue: 0x%" PRIX32 ", ", ctx->error_value);
AnnaBridge 189:f392fc9709a3 496 break;
AnnaBridge 189:f392fc9709a3 497
AnnaBridge 189:f392fc9709a3 498 case MBED_ERROR_CODE_ASSERTION_FAILED:
AnnaBridge 189:f392fc9709a3 499 mbed_error_printf("Assertion failed: ");
AnnaBridge 187:0387e8f68319 500 break;
AnnaBridge 187:0387e8f68319 501
AnnaBridge 187:0387e8f68319 502 default:
AnnaBridge 187:0387e8f68319 503 //Nothing to do here, just print the error info down
AnnaBridge 187:0387e8f68319 504 break;
AnnaBridge 187:0387e8f68319 505 }
AnnaBridge 189:f392fc9709a3 506 mbed_error_puts(error_msg);
AnnaBridge 189:f392fc9709a3 507 mbed_error_printf("\nLocation: 0x%" PRIX32, ctx->error_address);
AnnaBridge 187:0387e8f68319 508
AnnaBridge 189:f392fc9709a3 509 /* We print the filename passed in, not any filename in the context. This
AnnaBridge 189:f392fc9709a3 510 * avoids the console print for mbed_error being limited to the presence
AnnaBridge 189:f392fc9709a3 511 * and length of the filename storage. Note that although the MBED_ERROR
AnnaBridge 189:f392fc9709a3 512 * macro compiles out filenames unless platform.error-filename-capture-enabled
AnnaBridge 189:f392fc9709a3 513 * is turned on, MBED_ASSERT always passes filenames, and other direct
AnnaBridge 189:f392fc9709a3 514 * users of mbed_error() may also choose to.
AnnaBridge 189:f392fc9709a3 515 */
AnnaBridge 189:f392fc9709a3 516 if (error_filename) {
AnnaBridge 189:f392fc9709a3 517 mbed_error_puts("\nFile: ");
AnnaBridge 189:f392fc9709a3 518 mbed_error_puts(error_filename);
AnnaBridge 189:f392fc9709a3 519 mbed_error_printf("+%d", error_line);
AnnaBridge 189:f392fc9709a3 520 }
AnnaBridge 189:f392fc9709a3 521
AnnaBridge 189:f392fc9709a3 522 mbed_error_printf("\nError Value: 0x%" PRIX32, ctx->error_value);
AnnaBridge 189:f392fc9709a3 523 #ifdef MBED_CONF_RTOS_PRESENT
AnnaBridge 189:f392fc9709a3 524 mbed_error_printf("\nCurrent Thread: %s Id: 0x%" PRIX32 " Entry: 0x%" PRIX32 " StackSize: 0x%" PRIX32 " StackMem: 0x%" PRIX32 " SP: 0x%" PRIX32 " ",
AnnaBridge 189:f392fc9709a3 525 name_or_unnamed(((osRtxThread_t *)ctx->thread_id)->name),
AnnaBridge 187:0387e8f68319 526 ctx->thread_id, ctx->thread_entry_address, ctx->thread_stack_size, ctx->thread_stack_mem, ctx->thread_current_sp);
AnnaBridge 189:f392fc9709a3 527 #endif
AnnaBridge 187:0387e8f68319 528
AnnaBridge 187:0387e8f68319 529 #if MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO && defined(MBED_CONF_RTOS_PRESENT)
AnnaBridge 187:0387e8f68319 530 mbed_error_printf("\nNext:");
AnnaBridge 187:0387e8f68319 531 print_thread(osRtxInfo.thread.run.next);
AnnaBridge 187:0387e8f68319 532
AnnaBridge 189:f392fc9709a3 533 mbed_error_printf("\nReady:");
AnnaBridge 189:f392fc9709a3 534 print_threads_info(osRtxInfo.thread.ready.thread_list);
AnnaBridge 189:f392fc9709a3 535
AnnaBridge 187:0387e8f68319 536 mbed_error_printf("\nWait:");
AnnaBridge 189:f392fc9709a3 537 print_threads_info(osRtxInfo.thread.wait_list);
AnnaBridge 187:0387e8f68319 538
AnnaBridge 187:0387e8f68319 539 mbed_error_printf("\nDelay:");
AnnaBridge 189:f392fc9709a3 540 print_threads_info(osRtxInfo.thread.delay_list);
AnnaBridge 187:0387e8f68319 541 #endif
AnnaBridge 188:bcfe06ba3d64 542 mbed_error_printf(MBED_CONF_PLATFORM_ERROR_DECODE_HTTP_URL_STR, ctx->error_status);
AnnaBridge 187:0387e8f68319 543 mbed_error_printf("\n-- MbedOS Error Info --\n");
AnnaBridge 187:0387e8f68319 544 }
AnnaBridge 187:0387e8f68319 545 #endif //ifndef NDEBUG
AnnaBridge 187:0387e8f68319 546
AnnaBridge 187:0387e8f68319 547 #if MBED_CONF_PLATFORM_ERROR_HIST_ENABLED
Anna Bridge 186:707f6e361f3e 548 //Retrieve the error context from error log at the specified index
AnnaBridge 187:0387e8f68319 549 mbed_error_status_t mbed_get_error_hist_info(int index, mbed_error_ctx *error_info)
Anna Bridge 186:707f6e361f3e 550 {
Anna Bridge 186:707f6e361f3e 551 return mbed_error_hist_get(index, error_info);
Anna Bridge 186:707f6e361f3e 552 }
Anna Bridge 186:707f6e361f3e 553
Anna Bridge 186:707f6e361f3e 554 //Retrieve the error log count
AnnaBridge 187:0387e8f68319 555 int mbed_get_error_hist_count(void)
Anna Bridge 186:707f6e361f3e 556 {
Anna Bridge 186:707f6e361f3e 557 return mbed_error_hist_get_count();
Anna Bridge 186:707f6e361f3e 558 }
Anna Bridge 186:707f6e361f3e 559
Anna Bridge 186:707f6e361f3e 560 mbed_error_status_t mbed_save_error_hist(const char *path)
Anna Bridge 186:707f6e361f3e 561 {
Anna Bridge 186:707f6e361f3e 562 mbed_error_status_t ret = MBED_SUCCESS;
Anna Bridge 186:707f6e361f3e 563 mbed_error_ctx ctx = {0};
Anna Bridge 186:707f6e361f3e 564 int log_count = mbed_error_hist_get_count();
Anna Bridge 186:707f6e361f3e 565 FILE *error_log_file = NULL;
AnnaBridge 187:0387e8f68319 566
Anna Bridge 186:707f6e361f3e 567 //Ensure path is valid
AnnaBridge 187:0387e8f68319 568 if (path == NULL) {
Anna Bridge 186:707f6e361f3e 569 ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_INVALID_ARGUMENT);
Anna Bridge 186:707f6e361f3e 570 goto exit;
Anna Bridge 186:707f6e361f3e 571 }
AnnaBridge 187:0387e8f68319 572
Anna Bridge 186:707f6e361f3e 573 //Open the file for saving the error log info
AnnaBridge 187:0387e8f68319 574 if ((error_log_file = fopen(path, "w")) == NULL) {
Anna Bridge 186:707f6e361f3e 575 ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED);
Anna Bridge 186:707f6e361f3e 576 goto exit;
Anna Bridge 186:707f6e361f3e 577 }
AnnaBridge 187:0387e8f68319 578
Anna Bridge 186:707f6e361f3e 579 //First store the first and last errors
AnnaBridge 187:0387e8f68319 580 if (fprintf(error_log_file, "\nFirst Error: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n",
AnnaBridge 187:0387e8f68319 581 (unsigned int)first_error_ctx.error_status,
AnnaBridge 187:0387e8f68319 582 (unsigned int)first_error_ctx.thread_id,
AnnaBridge 187:0387e8f68319 583 (unsigned int)first_error_ctx.error_address,
AnnaBridge 187:0387e8f68319 584 (unsigned int)first_error_ctx.error_value) <= 0) {
Anna Bridge 186:707f6e361f3e 585 ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
Anna Bridge 186:707f6e361f3e 586 goto exit;
Anna Bridge 186:707f6e361f3e 587 }
AnnaBridge 187:0387e8f68319 588
AnnaBridge 187:0387e8f68319 589 if (fprintf(error_log_file, "\nLast Error: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n",
AnnaBridge 187:0387e8f68319 590 (unsigned int)last_error_ctx.error_status,
AnnaBridge 187:0387e8f68319 591 (unsigned int)last_error_ctx.thread_id,
AnnaBridge 187:0387e8f68319 592 (unsigned int)last_error_ctx.error_address,
AnnaBridge 187:0387e8f68319 593 (unsigned int)last_error_ctx.error_value) <= 0) {
Anna Bridge 186:707f6e361f3e 594 ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
Anna Bridge 186:707f6e361f3e 595 goto exit;
Anna Bridge 186:707f6e361f3e 596 }
AnnaBridge 187:0387e8f68319 597
Anna Bridge 186:707f6e361f3e 598 //Update with error log info
AnnaBridge 187:0387e8f68319 599 while (--log_count >= 0) {
Anna Bridge 186:707f6e361f3e 600 mbed_error_hist_get(log_count, &ctx);
Anna Bridge 186:707f6e361f3e 601 //first line of file will be error log count
AnnaBridge 187:0387e8f68319 602 if (fprintf(error_log_file, "\n%d: Status:0x%x ThreadId:0x%x Address:0x%x Value:0x%x\n",
AnnaBridge 187:0387e8f68319 603 log_count,
AnnaBridge 187:0387e8f68319 604 (unsigned int)ctx.error_status,
AnnaBridge 187:0387e8f68319 605 (unsigned int)ctx.thread_id,
AnnaBridge 187:0387e8f68319 606 (unsigned int)ctx.error_address,
AnnaBridge 187:0387e8f68319 607 (unsigned int)ctx.error_value) <= 0) {
Anna Bridge 186:707f6e361f3e 608 ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
Anna Bridge 186:707f6e361f3e 609 goto exit;
Anna Bridge 186:707f6e361f3e 610 }
Anna Bridge 186:707f6e361f3e 611 }
AnnaBridge 187:0387e8f68319 612
Anna Bridge 186:707f6e361f3e 613 exit:
Anna Bridge 186:707f6e361f3e 614 fclose(error_log_file);
AnnaBridge 187:0387e8f68319 615
Anna Bridge 186:707f6e361f3e 616 return ret;
Anna Bridge 186:707f6e361f3e 617 }
Anna Bridge 186:707f6e361f3e 618 #endif
Anna Bridge 186:707f6e361f3e 619