Skip to content

Commit 693a6c4

Browse files
SenRamakriSenRamakri
committed
Refactor error reporting
1 parent d4fe757 commit 693a6c4

File tree

9 files changed

+385
-526
lines changed

9 files changed

+385
-526
lines changed

‎TESTS/mbed_platform/error_handling/main.cpp

Lines changed: 35 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -33,13 +33,13 @@ void test_error_count_and_reset()
3333
MBED_WARNING(MBED_ERROR_OUT_OF_MEMORY, "Out of memory", i);
3434
}
3535

36-
TEST_ASSERT_EQUAL_INT(count, get_error_count());
36+
TEST_ASSERT_EQUAL_INT(count, mbed_get_error_count());
3737

3838
//clear the errors and error count to 0
3939
mbed_clear_all_errors();
4040

4141
//Now the error count should be 0
42-
TEST_ASSERT_EQUAL_INT(0, get_error_count());
42+
TEST_ASSERT_EQUAL_INT(0, mbed_get_error_count());
4343

4444
}
4545

@@ -54,61 +54,61 @@ void test_error_capturing()
5454
//first clear all errors and start afresh
5555

5656
MBED_WARNING(MBED_ERROR_OUT_OF_RESOURCES, "System type error", 0x1100 );
57-
mbed_error_status_t lastError = get_last_error();
57+
mbed_error_status_t lastError = mbed_get_last_error();
5858
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_SYSTEM, MBED_GET_ERROR_TYPE(lastError));
5959
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
6060
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_OUT_OF_RESOURCES, MBED_GET_ERROR_CODE(lastError));
6161

6262
mbed_error_status_t error = MBED_MAKE_ERROR(MBED_MODULE_DRIVER_SERIAL, MBED_ERROR_CODE_OUT_OF_RESOURCES);
6363
MBED_WARNING(error, "Error Serial", 0xAA );
64-
lastError = get_last_error();
64+
lastError = mbed_get_last_error();
6565
TEST_ASSERT_EQUAL_UINT(error, lastError);
6666

6767
error = MBED_MAKE_CUSTOM_ERROR(MBED_MODULE_APPLICATION, MBED_ERROR_CODE_UNKNOWN);
6868
MBED_WARNING(error, "Custom Error Unknown", 0x1234 );
69-
lastError = get_last_error();
69+
lastError = mbed_get_last_error();
7070
TEST_ASSERT_EQUAL_UINT(error, lastError);
7171

7272
MBED_WARNING(MBED_ERROR_EPERM, "Posix Error Eperm", 0x1234 );
73-
lastError = get_last_error();
73+
lastError = mbed_get_last_error();
7474
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_EPERM, lastError);
7575

7676
error = MBED_MAKE_CUSTOM_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_CREATE_FAILED);
7777
MBED_WARNING(error, "Custom Error Type", error_value);
78-
lastError = get_last_error();
78+
lastError = mbed_get_last_error();
7979
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_CUSTOM, MBED_GET_ERROR_TYPE(lastError));
8080
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_PLATFORM, MBED_GET_ERROR_MODULE(lastError));
8181
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_CREATE_FAILED, MBED_GET_ERROR_CODE(lastError));
82-
mbed_error_status_t status = mbed_get_last_error_log_info( &error_ctx );
82+
mbed_error_status_t status = mbed_get_last_error_info( &error_ctx );
8383
TEST_ASSERT(status == MBED_SUCCESS);
8484
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
8585

8686
error_value = 0xAABBCC;
8787
MBED_WARNING(MBED_ERROR_EACCES, "Posix Error", error_value );
88-
lastError = get_last_error();
88+
lastError = mbed_get_last_error();
8989
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_POSIX, MBED_GET_ERROR_TYPE(lastError));
9090
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
9191
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_EACCES, MBED_GET_ERROR_CODE(lastError));
92-
status = mbed_get_last_error_log_info( &error_ctx );
92+
status = mbed_get_last_error_info( &error_ctx );
9393
TEST_ASSERT(status == MBED_SUCCESS);
9494
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
9595

9696
error_value = 0;
9797
error = MBED_MAKE_ERROR(MBED_MODULE_HAL, MBED_ERROR_CODE_UNKNOWN);
9898
MBED_WARNING(error, "HAL Entity error", error_value );
99-
lastError = get_last_error();
99+
lastError = mbed_get_last_error();
100100
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_SYSTEM, MBED_GET_ERROR_TYPE(lastError));
101101
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_HAL, MBED_GET_ERROR_MODULE(lastError));
102102
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_UNKNOWN, MBED_GET_ERROR_CODE(lastError));
103-
status = mbed_get_last_error_log_info( &error_ctx );
103+
status = mbed_get_last_error_info( &error_ctx );
104104
TEST_ASSERT(status == MBED_SUCCESS);
105105
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
106106

107107
MBED_WARNING(MBED_ERROR_MUTEX_LOCK_FAILED, "Mutex lock failed", 0x4455 );
108-
error = get_last_error();
108+
error = mbed_get_last_error();
109109
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_MUTEX_LOCK_FAILED, error);
110110

111-
error = get_first_error();
111+
error = mbed_get_first_error();
112112
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_OUT_OF_RESOURCES, error);
113113

114114
}
@@ -121,7 +121,7 @@ void test_error_context_capture()
121121
mbed_error_ctx error_ctx = {0};
122122

123123
MBED_WARNING(MBED_ERROR_INVALID_ARGUMENT, "System type error", error_value );
124-
mbed_error_status_t status = mbed_get_last_error_log_info( &error_ctx );
124+
mbed_error_status_t status = mbed_get_last_error_info( &error_ctx );
125125
TEST_ASSERT(status == MBED_SUCCESS);
126126
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
127127
TEST_ASSERT_EQUAL_UINT(osThreadGetId(), error_ctx.thread_id);
@@ -136,7 +136,7 @@ void test_error_context_capture()
136136
#endif
137137
}
138138

139-
#ifndef MBED_CONF_ERROR_LOG_DISABLED
139+
#ifndef MBED_CONF_ERROR_HIST_DISABLED
140140
/** Test error logging functionality
141141
*/
142142
void test_error_logging()
@@ -151,15 +151,15 @@ void test_error_logging()
151151
MBED_WARNING(MBED_ERROR_INVALID_SIZE, "Invalid size", 2 );
152152
MBED_WARNING(MBED_ERROR_INVALID_FORMAT, "Invalid format", 3 );
153153

154-
mbed_error_status_t status = mbed_get_error_log_info( 0, &error_ctx );
154+
mbed_error_status_t status = mbed_get_error_hist_info( 0, &error_ctx );
155155
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_ARGUMENT, error_ctx.error_status);
156156
TEST_ASSERT_EQUAL_UINT(1, error_ctx.error_value);
157157

158-
status = mbed_get_error_log_info( 1, &error_ctx );
158+
status = mbed_get_error_hist_info( 1, &error_ctx );
159159
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_SIZE, error_ctx.error_status);
160160
TEST_ASSERT_EQUAL_UINT(2, error_ctx.error_value);
161161

162-
status = mbed_get_error_log_info( 2, &error_ctx );
162+
status = mbed_get_error_hist_info( 2, &error_ctx );
163163
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_FORMAT, error_ctx.error_status);
164164
TEST_ASSERT_EQUAL_UINT(3, error_ctx.error_value);
165165

@@ -175,24 +175,24 @@ void test_error_logging()
175175
MBED_WARNING(MBED_ERROR_UNSUPPORTED, "Not supported", 12 );
176176
MBED_WARNING(MBED_ERROR_ACCESS_DENIED, "Access denied", 13 );
177177

178-
status = mbed_get_error_log_info( 0, &error_ctx );
178+
status = mbed_get_error_hist_info( 0, &error_ctx );
179179
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TIME_OUT, error_ctx.error_status);
180180
TEST_ASSERT_EQUAL_UINT(10, error_ctx.error_value);
181181

182-
status = mbed_get_error_log_info( 1, &error_ctx );
182+
status = mbed_get_error_hist_info( 1, &error_ctx );
183183
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_ALREADY_IN_USE, error_ctx.error_status);
184184
TEST_ASSERT_EQUAL_UINT(11, error_ctx.error_value);
185185

186-
status = mbed_get_error_log_info( 2, &error_ctx );
186+
status = mbed_get_error_hist_info( 2, &error_ctx );
187187
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_UNSUPPORTED, error_ctx.error_status);
188188
TEST_ASSERT_EQUAL_UINT(12, error_ctx.error_value);
189189

190-
status = mbed_get_error_log_info( 3, &error_ctx );
190+
status = mbed_get_error_hist_info( 3, &error_ctx );
191191
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_ACCESS_DENIED, error_ctx.error_status);
192192
TEST_ASSERT_EQUAL_UINT(13, error_ctx.error_value);
193193

194194
//Try an index which is invalid, we should get ERROR_INVALID_ARGUMENT back
195-
status = mbed_get_error_log_info( 99, &error_ctx );
195+
status = mbed_get_error_hist_info( 99, &error_ctx );
196196
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_ARGUMENT, status);
197197

198198
}
@@ -202,7 +202,6 @@ void test_error_logging()
202202
//Error logger threads
203203
void err_thread_func(mbed_error_status_t *error_status)
204204
{
205-
//printf("\nError Status = 0x%08X\n",*error_status);
206205
MBED_WARNING(*error_status, "Error from Multi-Threaded error logging test", *error_status );
207206
}
208207

@@ -228,15 +227,14 @@ void test_error_logging_multithread()
228227
errThread[i]->join();
229228
}
230229

231-
i = mbed_get_error_log_count()-1;
232-
//printf("\nError log count = %d\n", i+1);
230+
i = mbed_get_error_hist_count()-1;
231+
233232
for(;i>=0;--i) {
234-
mbed_error_status_t status = mbed_get_error_log_info( i, &error_ctx );
233+
mbed_error_status_t status = mbed_get_error_hist_info( i, &error_ctx );
235234
if(status != MBED_SUCCESS) {
236235
TEST_FAIL();
237236
}
238237

239-
//printf("\nError Status[%d] = 0x%08X Value = 0x%08X\n", i, (unsigned int)error_ctx.error_status, (unsigned int)error_ctx.error_value);
240238
TEST_ASSERT_EQUAL_UINT((unsigned int)error_ctx.error_value, (unsigned int)error_ctx.error_status);
241239
}
242240
}
@@ -307,47 +305,41 @@ void test_save_error_log()
307305

308306
error = MBED_TEST_FILESYSTEM::format(&fd);
309307
if(error < 0) {
310-
printf("Failed formatting");
311-
TEST_FAIL();
308+
TEST_FAIL_MESSAGE("Failed formatting");
312309
}
313310

314311
error = fs.mount(&fd);
315312
if(error < 0) {
316-
printf("Failed mounting fs");
317-
TEST_FAIL();
313+
TEST_FAIL_MESSAGE("Failed mounting fs");
318314
}
319315

320-
if(MBED_SUCCESS != mbed_save_error_log("/fs/errors.log")) {
321-
printf("Failed saving error log");
322-
TEST_FAIL();
316+
if(MBED_SUCCESS != mbed_save_error_hist("/fs/errors.log")) {
317+
TEST_FAIL_MESSAGE("Failed saving error log");
323318
}
324319

325320
FILE *error_file = fopen("/fs/errors.log", "r");
326321
if(error_file == NULL) {
327-
printf("Unable to find error log in fs");
328-
TEST_FAIL();
322+
TEST_FAIL_MESSAGE("Unable to find error log in fs");
329323
}
330324

331325
char buff[64] = {0};
332326
while (!feof(error_file)){
333327
int size = fread(&buff[0], 1, 15, error_file);
334328
fwrite(&buff[0], 1, size, stdout);
335329
}
336-
printf("\r\n");
337330
fclose(error_file);
338331

339332
error = fs.unmount();
340333
if(error < 0) {
341-
printf("Failed unmounting fs");
342-
TEST_FAIL();
334+
TEST_FAIL_MESSAGE("Failed unmounting fs");
343335
}
344336
}
345337

346338
#endif
347339

348340
utest::v1::status_t test_setup(const size_t number_of_cases)
349341
{
350-
GREENTEA_SETUP(300, "default_auto");
342+
GREENTEA_SETUP(120, "default_auto");
351343
return utest::v1::verbose_test_setup_handler(number_of_cases);
352344
}
353345

@@ -356,7 +348,7 @@ Case cases[] = {
356348
Case("Test error encoding, value capture, first and last errors", test_error_capturing),
357349
Case("Test error context capture", test_error_context_capture),
358350
Case("Test error hook", test_error_hook),
359-
#ifndef MBED_CONF_ERROR_LOG_DISABLED
351+
#ifndef MBED_CONF_ERROR_HIST_DISABLED
360352
Case("Test error logging", test_error_logging),
361353
Case("Test error handling multi-threaded", test_error_logging_multithread),
362354
#ifdef MBED_TEST_SIM_BLOCKDEVICE

‎features/FEATURE_LWIP/lwip-interface/lwip-sys/arch/lwip_sys_arch.c

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -123,15 +123,15 @@ u32_t sys_now(void) {
123123
*---------------------------------------------------------------------------*/
124124
err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
125125
if (queue_sz > MB_SIZE)
126-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INVALID_SIZE), "sys_mbox_new size error\n", queue_sz);
126+
error("sys_mbox_new size error\n");
127127

128128
memset(mbox, 0, sizeof(*mbox));
129129

130130
mbox->attr.cb_mem = &mbox->data;
131131
mbox->attr.cb_size = sizeof(mbox->data);
132132
mbox->id = osEventFlagsNew(&mbox->attr);
133133
if (mbox->id == NULL)
134-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_mbox_new create error\n", mbox->id);
134+
error("sys_mbox_new create error\n");
135135

136136
osEventFlagsSet(mbox->id, SYS_MBOX_POST_EVENT);
137137

@@ -150,7 +150,7 @@ err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
150150
*---------------------------------------------------------------------------*/
151151
void sys_mbox_free(sys_mbox_t *mbox) {
152152
if (mbox->post_idx != mbox->fetch_idx)
153-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FREE_FAILED), "sys_mbox_free error\n", mbox->post_idx);
153+
error("sys_mbox_free error\n");
154154
}
155155

156156
/*---------------------------------------------------------------------------*
@@ -309,7 +309,7 @@ err_t sys_sem_new(sys_sem_t *sem, u8_t count) {
309309
sem->attr.cb_size = sizeof(sem->data);
310310
sem->id = osSemaphoreNew(UINT16_MAX, count, &sem->attr);
311311
if (sem->id == NULL)
312-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_sem_new create error\n", sem->id);
312+
error("sys_sem_new create error\n");
313313

314314
return ERR_OK;
315315
}
@@ -388,14 +388,14 @@ err_t sys_mutex_new(sys_mutex_t *mutex) {
388388
* @param mutex the mutex to lock */
389389
void sys_mutex_lock(sys_mutex_t *mutex) {
390390
if (osMutexAcquire(mutex->id, osWaitForever) != osOK)
391-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_mutex_lock error\n", mutex->id);
391+
error("sys_mutex_lock error\n");
392392
}
393393

394394
/** Unlock a mutex
395395
* @param mutex the mutex to unlock */
396396
void sys_mutex_unlock(sys_mutex_t *mutex) {
397397
if (osMutexRelease(mutex->id) != osOK)
398-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_UNLOCK_FAILED), "sys_mutex_unlock error\n", mutex->id);
398+
error("sys_mutex_unlock error\n");
399399
}
400400

401401
/** Delete a mutex
@@ -418,7 +418,7 @@ void sys_init(void) {
418418
lwip_sys_mutex_attr.cb_size = sizeof(lwip_sys_mutex_data);
419419
lwip_sys_mutex = osMutexNew(&lwip_sys_mutex_attr);
420420
if (lwip_sys_mutex == NULL)
421-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INITIALIZATION_FAILED), "sys_init error\n", lwip_sys_mutex);
421+
error("sys_init error\n");
422422
}
423423

424424
/*---------------------------------------------------------------------------*
@@ -452,7 +452,7 @@ u32_t sys_jiffies(void) {
452452
*---------------------------------------------------------------------------*/
453453
sys_prot_t sys_arch_protect(void) {
454454
if (osMutexAcquire(lwip_sys_mutex, osWaitForever) != osOK)
455-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_protect error\n", lwip_sys_mutex);
455+
error("sys_arch_protect error\n");
456456
return (sys_prot_t) 1;
457457
}
458458

@@ -469,7 +469,7 @@ sys_prot_t sys_arch_protect(void) {
469469
*---------------------------------------------------------------------------*/
470470
void sys_arch_unprotect(sys_prot_t p) {
471471
if (osMutexRelease(lwip_sys_mutex) != osOK)
472-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_unprotect error\n", lwip_sys_mutex);
472+
error("sys_arch_unprotect error\n");
473473
}
474474

475475
u32_t sys_now(void) {
@@ -508,7 +508,7 @@ sys_thread_t sys_thread_new(const char *pcName,
508508
LWIP_DEBUGF(SYS_DEBUG, ("New Thread: %s\n", pcName));
509509

510510
if (thread_pool_index >= SYS_THREAD_POOL_N)
511-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new number error\n", thread_pool_index);
511+
error("sys_thread_new number error\n");
512512
sys_thread_t t = (sys_thread_t)&thread_pool[thread_pool_index];
513513
thread_pool_index++;
514514

@@ -520,11 +520,11 @@ sys_thread_t sys_thread_new(const char *pcName,
520520
t->attr.stack_size = stacksize;
521521
t->attr.stack_mem = malloc(stacksize);
522522
if (t->attr.stack_mem == NULL) {
523-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_OUT_OF_MEMORY), "Error allocating the stack memory", t);
523+
error("Error allocating the stack memory");
524524
}
525525
t->id = osThreadNew((osThreadFunc_t)thread, arg, &t->attr);
526526
if (t->id == NULL)
527-
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new create error\n", t->id);
527+
error("sys_thread_new create error\n");
528528

529529
return t;
530530
}

0 commit comments

Comments
 (0)