build: cleanup src/rtos directory

Change-Id: I24bc62d12409dbfc20a0a986acf6b3f2c913e36d
Signed-off-by: Spencer Oliver <spen@spen-soft.co.uk>
Reviewed-on: http://openocd.zylin.com/416
Tested-by: jenkins

10 files changed, 1119 insertions, 1349 deletions

diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c
index eeab134..c7b4643 100644
--- a/src/rtos/FreeRTOS.c
+++ b/src/rtos/FreeRTOS.c
@@ -18,7 +18,6 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -31,370 +30,346 @@
 #include "helper/log.h"
 #include "rtos_standard_stackings.h"
 
-#define FreeRTOS_STRUCT( int_type, ptr_type, list_prev_offset )
-
-
-struct FreeRTOS_params
-{
-	const char *                         target_name;
-	const unsigned char                  thread_count_width;
-	const unsigned char                  pointer_width;
-	const unsigned char                  list_next_offset;
-	const unsigned char                  list_width;
-	const unsigned char                  list_elem_next_offset;
-	const unsigned char                  list_elem_content_offset;
-	const unsigned char                  thread_stack_offset;
-	const unsigned char                  thread_name_offset;
-	const struct rtos_register_stacking* stacking_info;
+#define FreeRTOS_STRUCT(int_type, ptr_type, list_prev_offset)
+
+struct FreeRTOS_params {
+	const char *target_name;
+	const unsigned char thread_count_width;
+	const unsigned char pointer_width;
+	const unsigned char list_next_offset;
+	const unsigned char list_width;
+	const unsigned char list_elem_next_offset;
+	const unsigned char list_elem_content_offset;
+	const unsigned char thread_stack_offset;
+	const unsigned char thread_name_offset;
+	const struct rtos_register_stacking *stacking_info;
 };
 
-
-
-
-const struct FreeRTOS_params FreeRTOS_params_list[] =
-{
-		{ "cortex_m3",                      // target_name
-          4,                                // thread_count_width;
-          4,                                // pointer_width;
-          16,                               // list_next_offset;
-          20,                               // list_width;
-          8,                                // list_elem_next_offset;
-          12,                               // list_elem_content_offset
-          0,                                // thread_stack_offset;
-          52,                               // thread_name_offset;
-          &rtos_standard_Cortex_M3_stacking, // stacking_info
-		}
-
+const struct FreeRTOS_params FreeRTOS_params_list[] = {
+	{
+	"cortex_m3",			/* target_name */
+	4,						/* thread_count_width; */
+	4,						/* pointer_width; */
+	16,						/* list_next_offset; */
+	20,						/* list_width; */
+	8,						/* list_elem_next_offset; */
+	12,						/* list_elem_content_offset */
+	0,						/* thread_stack_offset; */
+	52,						/* thread_name_offset; */
+	&rtos_standard_Cortex_M3_stacking,	/* stacking_info */
+	}
 };
 
-
 #define FREERTOS_NUM_PARAMS ((int)(sizeof(FreeRTOS_params_list)/sizeof(struct FreeRTOS_params)))
 
-static int FreeRTOS_detect_rtos( struct target* target );
-static int FreeRTOS_create( struct target* target );
-static int FreeRTOS_update_threads( struct rtos *rtos );
-static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
-static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
-
-
+static int FreeRTOS_detect_rtos(struct target *target);
+static int FreeRTOS_create(struct target *target);
+static int FreeRTOS_update_threads(struct rtos *rtos);
+static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list);
+static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
 
+struct rtos_type FreeRTOS_rtos = {
+	.name = "FreeRTOS",
 
-struct rtos_type FreeRTOS_rtos =
-{
-	.name                       = "FreeRTOS",
-
-	.detect_rtos                = FreeRTOS_detect_rtos,
-	.create                     = FreeRTOS_create,
-	.update_threads            = FreeRTOS_update_threads,
-	.get_thread_reg_list        = FreeRTOS_get_thread_reg_list,
-	.get_symbol_list_to_lookup  = FreeRTOS_get_symbol_list_to_lookup,
+	.detect_rtos = FreeRTOS_detect_rtos,
+	.create = FreeRTOS_create,
+	.update_threads = FreeRTOS_update_threads,
+	.get_thread_reg_list = FreeRTOS_get_thread_reg_list,
+	.get_symbol_list_to_lookup = FreeRTOS_get_symbol_list_to_lookup,
 };
 
-enum FreeRTOS_symbol_values
-{
-	FreeRTOS_VAL_pxCurrentTCB              = 0,
-	FreeRTOS_VAL_pxReadyTasksLists         = 1,
-	FreeRTOS_VAL_xDelayedTaskList1         = 2,
-	FreeRTOS_VAL_xDelayedTaskList2         = 3,
-	FreeRTOS_VAL_pxDelayedTaskList         = 4,
+enum FreeRTOS_symbol_values {
+	FreeRTOS_VAL_pxCurrentTCB = 0,
+	FreeRTOS_VAL_pxReadyTasksLists = 1,
+	FreeRTOS_VAL_xDelayedTaskList1 = 2,
+	FreeRTOS_VAL_xDelayedTaskList2 = 3,
+	FreeRTOS_VAL_pxDelayedTaskList = 4,
 	FreeRTOS_VAL_pxOverflowDelayedTaskList = 5,
-	FreeRTOS_VAL_xPendingReadyList         = 6,
-	FreeRTOS_VAL_xTasksWaitingTermination  = 7,
-	FreeRTOS_VAL_xSuspendedTaskList        = 8,
-	FreeRTOS_VAL_uxCurrentNumberOfTasks    = 9,
-	FreeRTOS_VAL_uxTopUsedPriority         = 10,
+	FreeRTOS_VAL_xPendingReadyList = 6,
+	FreeRTOS_VAL_xTasksWaitingTermination = 7,
+	FreeRTOS_VAL_xSuspendedTaskList = 8,
+	FreeRTOS_VAL_uxCurrentNumberOfTasks = 9,
+	FreeRTOS_VAL_uxTopUsedPriority = 10,
 };
 
-static char* FreeRTOS_symbol_list[] =
-{
-		"pxCurrentTCB",
-		"pxReadyTasksLists",
-		"xDelayedTaskList1",
-		"xDelayedTaskList2",
-		"pxDelayedTaskList",
-		"pxOverflowDelayedTaskList",
-		"xPendingReadyList",
-		"xTasksWaitingTermination",
-		"xSuspendedTaskList",
-		"uxCurrentNumberOfTasks",
-		"uxTopUsedPriority",
-		NULL
+static char *FreeRTOS_symbol_list[] = {
+	"pxCurrentTCB",
+	"pxReadyTasksLists",
+	"xDelayedTaskList1",
+	"xDelayedTaskList2",
+	"pxDelayedTaskList",
+	"pxOverflowDelayedTaskList",
+	"xPendingReadyList",
+	"xTasksWaitingTermination",
+	"xSuspendedTaskList",
+	"uxCurrentNumberOfTasks",
+	"uxTopUsedPriority",
+	NULL
 };
 
-#define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char*))
+#define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char *))
 
-// TODO:
-// this is not safe for little endian yet
-// may be problems reading if sizes are not 32 bit long integers.
-// test mallocs for failure
+/* TODO: */
+/* this is not safe for little endian yet */
+/* may be problems reading if sizes are not 32 bit long integers. */
+/* test mallocs for failure */
 
-static int FreeRTOS_update_threads( struct rtos *rtos )
+static int FreeRTOS_update_threads(struct rtos *rtos)
 {
 	int i = 0;
 	int retval;
 	int tasks_found = 0;
-	const struct FreeRTOS_params* param;
+	const struct FreeRTOS_params *param;
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -1;
-	}
 
-	param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
+	param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
 
-	if ( rtos->symbols == NULL )
-	{
+	if (rtos->symbols == NULL) {
 		LOG_OUTPUT("No symbols for FreeRTOS\r\n");
 		return -3;
 	}
 
-	if ( rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0 )
-	{
+	if (rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0) {
 		LOG_OUTPUT("Don't have the number of threads in FreeRTOS \r\n");
 		return -2;
 	}
 
 	int thread_list_size = 0;
-	retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address, param->thread_count_width, (uint8_t *)&thread_list_size);
+	retval = target_read_buffer(rtos->target,
+			rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
+			param->thread_count_width,
+			(uint8_t *)&thread_list_size);
 
-	if ( retval != ERROR_OK )
-	{
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Could not read FreeRTOS thread count from target\r\n");
 		return retval;
 	}
 
-
-	// wipe out previous thread details if any
-	if ( rtos->thread_details != NULL )
-	{
+	/* wipe out previous thread details if any */
+	if (rtos->thread_details != NULL) {
 		int j;
-		for( j = 0; j < rtos->thread_count; j++ )
-		{
-			if ( rtos->thread_details[j].display_str != NULL )
-			{
-				free( rtos->thread_details[j].display_str );
+		for (j = 0; j < rtos->thread_count; j++) {
+			if (rtos->thread_details[j].display_str != NULL) {
+				free(rtos->thread_details[j].display_str);
 				rtos->thread_details[j].display_str = NULL;
 			}
-			if ( rtos->thread_details[j].thread_name_str != NULL )
-			{
-				free( rtos->thread_details[j].thread_name_str );
+			if (rtos->thread_details[j].thread_name_str != NULL) {
+				free(rtos->thread_details[j].thread_name_str);
 				rtos->thread_details[j].thread_name_str = NULL;
 			}
-			if ( rtos->thread_details[j].extra_info_str != NULL )
-			{
-				free( rtos->thread_details[j].extra_info_str );
+			if (rtos->thread_details[j].extra_info_str != NULL) {
+				free(rtos->thread_details[j].extra_info_str);
 				rtos->thread_details[j].extra_info_str = NULL;
 			}
 		}
-		free( rtos->thread_details );
+		free(rtos->thread_details);
 		rtos->thread_details = NULL;
 	}
 
-
-	// read the current thread
-	retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address, param->pointer_width, (uint8_t *)&rtos->current_thread );
-	if ( retval != ERROR_OK )
-	{
+	/* read the current thread */
+	retval = target_read_buffer(rtos->target,
+			rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
+			param->pointer_width,
+			(uint8_t *)&rtos->current_thread);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Error reading current thread in FreeRTOS thread list\r\n");
 		return retval;
 	}
 
-	if ( ( thread_list_size  == 0 ) || ( rtos->current_thread == 0 ) )
-	{
-		// Either : No RTOS threads - there is always at least the current execution though
-		// OR     : No current thread - all threads suspended - show the current execution of idling
+	if ((thread_list_size  == 0) || (rtos->current_thread == 0)) {
+		/* Either : No RTOS threads - there is always at least the current execution though */
+		/* OR     : No current thread - all threads suspended - show the current execution
+		 * of idling */
 		char tmp_str[] = "Current Execution";
 		thread_list_size++;
 		tasks_found++;
-		rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
+		rtos->thread_details = (struct thread_detail *) malloc(
+				sizeof(struct thread_detail) * thread_list_size);
 		rtos->thread_details->threadid = 1;
 		rtos->thread_details->exists = true;
 		rtos->thread_details->display_str = NULL;
 		rtos->thread_details->extra_info_str = NULL;
-		rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
-		strcpy( rtos->thread_details->thread_name_str, tmp_str );
-
+		rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+		strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
-		if ( thread_list_size == 1 )
-		{
+		if (thread_list_size == 1) {
 			rtos->thread_count = 1;
 			return ERROR_OK;
 		}
+	} else {
+		/* create space for new thread details */
+		rtos->thread_details = (struct thread_detail *) malloc(
+				sizeof(struct thread_detail) * thread_list_size);
 	}
-	else
-	{
-		// create space for new thread details
-		rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
-	}
-
 
-	// Find out how many lists are needed to be read from pxReadyTasksLists,
+	/* Find out how many lists are needed to be read from pxReadyTasksLists, */
 	int64_t max_used_priority = 0;
-	retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address, param->pointer_width, (uint8_t *)&max_used_priority );
+	retval = target_read_buffer(rtos->target,
+			rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
+			param->pointer_width,
+			(uint8_t *)&max_used_priority);
 	if (retval != ERROR_OK)
-	  return retval;
+		return retval;
 
-	symbol_address_t* list_of_lists = (symbol_address_t *)malloc( sizeof( symbol_address_t ) * ( max_used_priority+1 + 5 ) );
+	symbol_address_t *list_of_lists =
+		(symbol_address_t *)malloc(sizeof(symbol_address_t) *
+			(max_used_priority+1 + 5));
 
 	int num_lists;
-	for( num_lists = 0; num_lists <= max_used_priority; num_lists++ )
-	{
-		list_of_lists[num_lists] =  rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address + num_lists * param->list_width;
-	}
-
-	list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xDelayedTaskList1].address;
-	list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xDelayedTaskList2].address;
-	list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xPendingReadyList].address;
-	list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xSuspendedTaskList].address;
-	list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
-
-
-	for( i = 0; i < num_lists; i++ )
-	{
-		if ( list_of_lists[i] == 0 )
-		{
+	for (num_lists = 0; num_lists <= max_used_priority; num_lists++)
+		list_of_lists[num_lists] = rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address +
+			num_lists * param->list_width;
+
+	list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList1].address;
+	list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList2].address;
+	list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xPendingReadyList].address;
+	list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xSuspendedTaskList].address;
+	list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
+
+	for (i = 0; i < num_lists; i++) {
+		if (list_of_lists[i] == 0)
 			continue;
-		}
 
-		// Read the number of threads in this list
+		/* Read the number of threads in this list */
 		int64_t list_thread_count = 0;
-		retval = target_read_buffer( rtos->target, list_of_lists[i], param->thread_count_width, (uint8_t *)&list_thread_count);
-		if ( retval != ERROR_OK )
-		{
+		retval = target_read_buffer(rtos->target,
+				list_of_lists[i],
+				param->thread_count_width,
+				(uint8_t *)&list_thread_count);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading number of threads in FreeRTOS thread list\r\n");
 			return retval;
 		}
 
-		if ( list_thread_count == 0 )
-		{
+		if (list_thread_count == 0)
 			continue;
-		}
 
-		// Read the location of first list item
+		/* Read the location of first list item */
 		uint64_t prev_list_elem_ptr = -1;
 		uint64_t list_elem_ptr = 0;
-		retval = target_read_buffer( rtos->target, list_of_lists[i] + param->list_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
-		if ( retval != ERROR_OK )
-		{
-			LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
+		retval = target_read_buffer(rtos->target,
+				list_of_lists[i] + param->list_next_offset,
+				param->pointer_width,
+				(uint8_t *)&list_elem_ptr);
+		if (retval != ERROR_OK) {
+			LOG_OUTPUT(
+				"Error reading first thread item location in FreeRTOS thread list\r\n");
 			return retval;
 		}
 
-
-		while ( (list_thread_count > 0) && ( list_elem_ptr != 0) && ( list_elem_ptr != prev_list_elem_ptr ) && ( tasks_found < thread_list_size ) )
-		{
-			// Get the location of the thread structure.
+		while ((list_thread_count > 0) && (list_elem_ptr != 0) &&
+				(list_elem_ptr != prev_list_elem_ptr) &&
+				(tasks_found < thread_list_size)) {
+			/* Get the location of the thread structure. */
 			rtos->thread_details[tasks_found].threadid = 0;
-			retval = target_read_buffer( rtos->target, list_elem_ptr + param->list_elem_content_offset, param->pointer_width, (uint8_t *)&(rtos->thread_details[tasks_found].threadid));
-			if ( retval != ERROR_OK )
-			{
-				LOG_OUTPUT("Error reading thread list item object in FreeRTOS thread list\r\n");
+			retval = target_read_buffer(rtos->target,
+					list_elem_ptr + param->list_elem_content_offset,
+					param->pointer_width,
+					(uint8_t *)&(rtos->thread_details[tasks_found].threadid));
+			if (retval != ERROR_OK) {
+				LOG_OUTPUT(
+					"Error reading thread list item object in FreeRTOS thread list\r\n");
 				return retval;
 			}
 
-
-			// get thread name
+			/* get thread name */
 
 			#define FREERTOS_THREAD_NAME_STR_SIZE (200)
 			char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
 
-			// Read the thread name
-			retval = target_read_buffer( rtos->target, rtos->thread_details[tasks_found].threadid + param->thread_name_offset, FREERTOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
-			if ( retval != ERROR_OK )
-			{
-				LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
+			/* Read the thread name */
+			retval = target_read_buffer(rtos->target,
+					rtos->thread_details[tasks_found].threadid + param->thread_name_offset,
+					FREERTOS_THREAD_NAME_STR_SIZE,
+					(uint8_t *)&tmp_str);
+			if (retval != ERROR_OK) {
+				LOG_OUTPUT(
+					"Error reading first thread item location in FreeRTOS thread list\r\n");
 				return retval;
 			}
 			tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 
-			if ( tmp_str[0] == '\x00' )
-			{
-				strcpy(tmp_str,"No Name");
-			}
+			if (tmp_str[0] == '\x00')
+				strcpy(tmp_str, "No Name");
 
-			rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
-			strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
+			rtos->thread_details[tasks_found].thread_name_str =
+				(char *)malloc(strlen(tmp_str)+1);
+			strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 			rtos->thread_details[tasks_found].display_str = NULL;
 			rtos->thread_details[tasks_found].exists = true;
 
-			if ( rtos->thread_details[tasks_found].threadid == rtos->current_thread )
-			{
+			if (rtos->thread_details[tasks_found].threadid == rtos->current_thread) {
 				char running_str[] = "Running";
-				rtos->thread_details[tasks_found].extra_info_str = (char*) malloc( sizeof(running_str) );
-				strcpy( rtos->thread_details[tasks_found].extra_info_str, running_str );
-			}
-			else
-			{
+				rtos->thread_details[tasks_found].extra_info_str = (char *) malloc(
+						sizeof(running_str));
+				strcpy(rtos->thread_details[tasks_found].extra_info_str,
+					running_str);
+			} else
 				rtos->thread_details[tasks_found].extra_info_str = NULL;
-			}
-
 
 			tasks_found++;
 			list_thread_count--;
 
 			prev_list_elem_ptr = list_elem_ptr;
 			list_elem_ptr = 0;
-			retval = target_read_buffer( rtos->target, prev_list_elem_ptr + param->list_elem_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
-			if ( retval != ERROR_OK )
-			{
-				LOG_OUTPUT("Error reading next thread item location in FreeRTOS thread list\r\n");
+			retval = target_read_buffer(rtos->target,
+					prev_list_elem_ptr + param->list_elem_next_offset,
+					param->pointer_width,
+					(uint8_t *)&list_elem_ptr);
+			if (retval != ERROR_OK) {
+				LOG_OUTPUT(
+					"Error reading next thread item location in FreeRTOS thread list\r\n");
 				return retval;
 			}
 		}
-
-
 	}
-	free( list_of_lists );
+	free(list_of_lists);
 	rtos->thread_count = tasks_found;
 	return 0;
 }
 
-static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
+static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list)
 {
 	int retval;
-	const struct FreeRTOS_params* param;
+	const struct FreeRTOS_params *param;
 	int64_t stack_ptr = 0;
 
-
 	*hex_reg_list = NULL;
-	if ( rtos == NULL )
-	{
+	if (rtos == NULL)
 		return -1;
-	}
 
-	if ( thread_id == 0 )
-	{
+	if (thread_id == 0)
 		return -2;
-	}
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -1;
-	}
 
-	param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
+	param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
 
-	// Read the stack pointer
-	retval = target_read_buffer( rtos->target, thread_id + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
-	if ( retval != ERROR_OK )
-	{
+	/* Read the stack pointer */
+	retval = target_read_buffer(rtos->target,
+			thread_id + param->thread_stack_offset,
+			param->pointer_width,
+			(uint8_t *)&stack_ptr);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
 		return retval;
 	}
 
-	return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
+	return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, hex_reg_list);
 
 }
 
-static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
+static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * FREERTOS_NUM_SYMBOLS );
+	*symbol_list = (symbol_table_elem_t *) malloc(
+			sizeof(symbol_table_elem_t) * FREERTOS_NUM_SYMBOLS);
 
-	for( i = 0; i < FREERTOS_NUM_SYMBOLS; i++ )
-	{
+	for (i = 0; i < FREERTOS_NUM_SYMBOLS; i++)
 		(*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i];
-	}
 
 	return 0;
 }
@@ -406,81 +381,68 @@ static int FreeRTOS_set_current_thread(struct rtos *rtos, threadid_t thread_id)
 	return 0;
 }
 
-
-
-static int FreeRTOS_get_thread_ascii_info( struct rtos*   rtos, threadid_t   thread_id, char ** info )
+static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_id, char **info)
 {
 	int retval;
-	const struct FreeRTOS_params* param;
+	const struct FreeRTOS_params *param;
 
-	if ( rtos == NULL )
-	{
+	if (rtos == NULL)
 		return -1;
-	}
 
-	if ( thread_id == 0 )
-	{
+	if (thread_id == 0)
 		return -2;
-	}
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -3;
-	}
 
-	param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
+	param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
 
 #define FREERTOS_THREAD_NAME_STR_SIZE (200)
 	char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
 
-	// Read the thread name
-	retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, FREERTOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
-	if ( retval != ERROR_OK )
-	{
+	/* Read the thread name */
+	retval = target_read_buffer(rtos->target,
+			thread_id + param->thread_name_offset,
+			FREERTOS_THREAD_NAME_STR_SIZE,
+			(uint8_t *)&tmp_str);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
 		return retval;
 	}
 	tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 
-	if ( tmp_str[0] == '\x00' )
-	{
-		strcpy(tmp_str,"No Name");
-	}
+	if (tmp_str[0] == '\x00')
+		strcpy(tmp_str, "No Name");
 
-	*info = (char*)malloc( strlen(tmp_str)+1 );
-	strcpy( *info, tmp_str );
+	*info = (char *)malloc(strlen(tmp_str)+1);
+	strcpy(*info, tmp_str);
 	return 0;
 }
 
 #endif
 
-static int FreeRTOS_detect_rtos( struct target* target )
+static int FreeRTOS_detect_rtos(struct target *target)
 {
-	if ( ( target->rtos->symbols != NULL ) &&
-		 ( target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0 ) )
-	{
-		// looks like FreeRTOS
+	if ((target->rtos->symbols != NULL) &&
+			(target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0)) {
+		/* looks like FreeRTOS */
 		return 1;
 	}
 	return 0;
-	return 0;
 }
 
-
-static int FreeRTOS_create( struct target* target )
+static int FreeRTOS_create(struct target *target)
 {
 	int i = 0;
-	while ( ( i < FREERTOS_NUM_PARAMS ) && ( 0 != strcmp( FreeRTOS_params_list[i].target_name, target->type->name ) ) )
-	{
+	while ((i < FREERTOS_NUM_PARAMS) &&
+			(0 != strcmp(FreeRTOS_params_list[i].target_name, target->type->name))) {
 		i++;
 	}
-	if ( i >= FREERTOS_NUM_PARAMS )
-	{
+	if (i >= FREERTOS_NUM_PARAMS) {
 		LOG_OUTPUT("Could not find target in FreeRTOS compatibility list\r\n");
 		return -1;
 	}
 
-	target->rtos->rtos_specific_params = (void*) &FreeRTOS_params_list[i];
+	target->rtos->rtos_specific_params = (void *) &FreeRTOS_params_list[i];
 	return 0;
 }
-
diff --git a/src/rtos/ThreadX.c b/src/rtos/ThreadX.c
index 1ce47a2..a9e313b 100644
--- a/src/rtos/ThreadX.c
+++ b/src/rtos/ThreadX.c
@@ -30,312 +30,275 @@
 #include "helper/log.h"
 #include "rtos_standard_stackings.h"
 
+static int ThreadX_detect_rtos(struct target *target);
+static int ThreadX_create(struct target *target);
+static int ThreadX_update_threads(struct rtos *rtos);
+static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list);
+static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
 
-static int ThreadX_detect_rtos( struct target* target );
-static int ThreadX_create( struct target* target );
-static int ThreadX_update_threads( struct rtos* rtos);
-static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
-static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
-
-
-
-struct ThreadX_thread_state
-{
+struct ThreadX_thread_state {
 	int value;
-	char * desc;
+	char *desc;
 };
 
-
-struct ThreadX_thread_state ThreadX_thread_states[] =
-{
-    { 0,  "Ready" },
-    { 1,  "Completed" },
-    { 2,  "Terminated" },
-    { 3,  "Suspended" },
-    { 4,  "Sleeping" },
-    { 5,  "Waiting - Queue" },
-    { 6,  "Waiting - Semaphore" },
-    { 7,  "Waiting - Event flag" },
-    { 8,  "Waiting - Memory" },
-    { 9,  "Waiting - Memory" },
-    { 10, "Waiting - I/O" },
-    { 11, "Waiting - Filesystem" },
-    { 12, "Waiting - Network" },
-    { 13, "Waiting - Mutex" },
+struct ThreadX_thread_state ThreadX_thread_states[] = {
+	{ 0,  "Ready" },
+	{ 1,  "Completed" },
+	{ 2,  "Terminated" },
+	{ 3,  "Suspended" },
+	{ 4,  "Sleeping" },
+	{ 5,  "Waiting - Queue" },
+	{ 6,  "Waiting - Semaphore" },
+	{ 7,  "Waiting - Event flag" },
+	{ 8,  "Waiting - Memory" },
+	{ 9,  "Waiting - Memory" },
+	{ 10, "Waiting - I/O" },
+	{ 11, "Waiting - Filesystem" },
+	{ 12, "Waiting - Network" },
+	{ 13, "Waiting - Mutex" },
 };
 
-
 #define THREADX_NUM_STATES (sizeof(ThreadX_thread_states)/sizeof(struct ThreadX_thread_state))
 
-
-struct ThreadX_params
-{
-	char *                               target_name;
-	unsigned char                        pointer_width;
-	unsigned char                        thread_stack_offset;
-	unsigned char                        thread_name_offset;
-	unsigned char                        thread_state_offset;
-	unsigned char                        thread_next_offset;
-	const struct rtos_register_stacking* stacking_info;
+struct ThreadX_params {
+	char *target_name;
+	unsigned char pointer_width;
+	unsigned char thread_stack_offset;
+	unsigned char thread_name_offset;
+	unsigned char thread_state_offset;
+	unsigned char thread_next_offset;
+	const struct rtos_register_stacking *stacking_info;
 };
 
-const struct ThreadX_params ThreadX_params_list[] =
-{
-		{ "cortex_m3",                       // target_name
-          4,                                 // pointer_width;
-          8,                                 // thread_stack_offset;
-          40,                                // thread_name_offset;
-          48,                                // thread_state_offset;
-          136,                               // thread_next_offset
-          &rtos_standard_Cortex_M3_stacking, // stacking_info
-		}
-
+const struct ThreadX_params ThreadX_params_list[] = {
+	{
+	"cortex_m3",				/* target_name */
+	4,							/* pointer_width; */
+	8,							/* thread_stack_offset; */
+	40,							/* thread_name_offset; */
+	48,							/* thread_state_offset; */
+	136,						/* thread_next_offset */
+	&rtos_standard_Cortex_M3_stacking,	/* stacking_info */
+	}
 };
 
 #define THREADX_NUM_PARAMS ((int)(sizeof(ThreadX_params_list)/sizeof(struct ThreadX_params)))
 
-enum ThreadX_symbol_values
-{
-	ThreadX_VAL_tx_thread_current_ptr     = 0,
-	ThreadX_VAL_tx_thread_created_ptr     = 1,
-	ThreadX_VAL_tx_thread_created_count   = 2,
+enum ThreadX_symbol_values {
+	ThreadX_VAL_tx_thread_current_ptr = 0,
+	ThreadX_VAL_tx_thread_created_ptr = 1,
+	ThreadX_VAL_tx_thread_created_count = 2,
 };
 
-static char* ThreadX_symbol_list[] =
-{
-		"_tx_thread_current_ptr",
-		"_tx_thread_created_ptr",
-		"_tx_thread_created_count",
-		NULL
+static char *ThreadX_symbol_list[] = {
+	"_tx_thread_current_ptr",
+	"_tx_thread_created_ptr",
+	"_tx_thread_created_count",
+	NULL
 };
 
+#define THREADX_NUM_SYMBOLS (sizeof(ThreadX_symbol_list)/sizeof(char *))
 
+const struct rtos_type ThreadX_rtos = {
+	.name = "ThreadX",
 
-#define THREADX_NUM_SYMBOLS (sizeof(ThreadX_symbol_list)/sizeof(char*))
-
-
-const struct rtos_type ThreadX_rtos =
-{
-	.name                      = "ThreadX",
-
-	.detect_rtos               = ThreadX_detect_rtos,
-	.create                    = ThreadX_create,
-	.update_threads            = ThreadX_update_threads,
-	.get_thread_reg_list       = ThreadX_get_thread_reg_list,
+	.detect_rtos = ThreadX_detect_rtos,
+	.create = ThreadX_create,
+	.update_threads = ThreadX_update_threads,
+	.get_thread_reg_list = ThreadX_get_thread_reg_list,
 	.get_symbol_list_to_lookup = ThreadX_get_symbol_list_to_lookup,
 
 };
 
-static int ThreadX_update_threads( struct rtos* rtos)
+static int ThreadX_update_threads(struct rtos *rtos)
 {
 	int retval;
 	int tasks_found = 0;
 	int thread_list_size = 0;
-	const struct ThreadX_params* param;
+	const struct ThreadX_params *param;
 
-	if ( rtos == NULL )
-	{
+	if (rtos == NULL)
 		return -1;
-	}
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -3;
-	}
 
-	param = (const struct ThreadX_params*) rtos->rtos_specific_params;
+	param = (const struct ThreadX_params *) rtos->rtos_specific_params;
 
-	if ( rtos->symbols == NULL )
-	{
+	if (rtos->symbols == NULL) {
 		LOG_OUTPUT("No symbols for ThreadX\r\n");
 		return -4;
 	}
 
-	if ( rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0 )
-	{
+	if (rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0) {
 		LOG_OUTPUT("Don't have the number of threads in ThreadX \r\n");
 		return -2;
 	}
 
+	/* read the number of threads */
+	retval = target_read_buffer(rtos->target,
+			rtos->symbols[ThreadX_VAL_tx_thread_created_count].address,
+			4,
+			(uint8_t *)&thread_list_size);
 
-
-
-
-	// read the number of threads
-	retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_created_count].address, 4, (uint8_t *)&thread_list_size);
-
-	if ( retval != ERROR_OK )
-	{
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Could not read ThreadX thread count from target\r\n");
 		return retval;
 	}
 
-
-	// wipe out previous thread details if any
-	if ( rtos->thread_details != NULL )
-	{
+	/* wipe out previous thread details if any */
+	if (rtos->thread_details != NULL) {
 		int j;
-		for( j = 0; j < rtos->thread_count; j++ )
-		{
-			if ( rtos->thread_details[j].display_str != NULL )
-			{
-				free( rtos->thread_details[j].display_str );
+		for (j = 0; j < rtos->thread_count; j++) {
+			if (rtos->thread_details[j].display_str != NULL) {
+				free(rtos->thread_details[j].display_str);
 				rtos->thread_details[j].display_str = NULL;
 			}
-			if ( rtos->thread_details[j].thread_name_str != NULL )
-			{
-				free( rtos->thread_details[j].thread_name_str );
+			if (rtos->thread_details[j].thread_name_str != NULL) {
+				free(rtos->thread_details[j].thread_name_str);
 				rtos->thread_details[j].thread_name_str = NULL;
 			}
-			if ( rtos->thread_details[j].extra_info_str != NULL )
-			{
-				free( rtos->thread_details[j].extra_info_str );
+			if (rtos->thread_details[j].extra_info_str != NULL) {
+				free(rtos->thread_details[j].extra_info_str);
 				rtos->thread_details[j].extra_info_str = NULL;
 			}
 		}
-		free( rtos->thread_details );
+		free(rtos->thread_details);
 		rtos->thread_details = NULL;
 	}
 
+	/* read the current thread id */
+	retval = target_read_buffer(rtos->target,
+			rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address,
+			4,
+			(uint8_t *)&rtos->current_thread);
 
-	// read the current thread id
-	retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address, 4, (uint8_t *)&rtos->current_thread);
-
-	if ( retval != ERROR_OK )
-	{
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Could not read ThreadX current thread from target\r\n");
 		return retval;
 	}
 
-	if ( ( thread_list_size  == 0 ) || ( rtos->current_thread == 0 ) )
-	{
-		// Either : No RTOS threads - there is always at least the current execution though
-		// OR     : No current thread - all threads suspended - show the current execution of idling
+	if ((thread_list_size  == 0) || (rtos->current_thread == 0)) {
+		/* Either : No RTOS threads - there is always at least the current execution though */
+		/* OR     : No current thread - all threads suspended - show the current execution
+		 * of idling */
 		char tmp_str[] = "Current Execution";
 		thread_list_size++;
 		tasks_found++;
-		rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
+		rtos->thread_details = (struct thread_detail *) malloc(
+				sizeof(struct thread_detail) * thread_list_size);
 		rtos->thread_details->threadid = 1;
 		rtos->thread_details->exists = true;
 		rtos->thread_details->display_str = NULL;
 		rtos->thread_details->extra_info_str = NULL;
-		rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
-		strcpy( rtos->thread_details->thread_name_str, tmp_str );
-
+		rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+		strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
-		if ( thread_list_size == 0 )
-		{
+		if (thread_list_size == 0) {
 			rtos->thread_count = 1;
 			return ERROR_OK;
 		}
+	} else {
+		/* create space for new thread details */
+		rtos->thread_details = (struct thread_detail *) malloc(
+				sizeof(struct thread_detail) * thread_list_size);
 	}
-	else
-	{
-		// create space for new thread details
-		rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
-	}
-
 
-
-	// Read the pointer to the first thread
+	/* Read the pointer to the first thread */
 	int64_t thread_ptr = 0;
-	retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address, param->pointer_width, (uint8_t *)&thread_ptr);
-	if ( retval != ERROR_OK )
-	{
+	retval = target_read_buffer(rtos->target,
+			rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address,
+			param->pointer_width,
+			(uint8_t *)&thread_ptr);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Could not read ThreadX thread location from target\r\n");
 		return retval;
 	}
 
-
-	// loop over all threads
+	/* loop over all threads */
 	int64_t prev_thread_ptr = 0;
-	while ( ( thread_ptr != prev_thread_ptr ) && ( tasks_found < thread_list_size ) )
-	{
+	while ((thread_ptr != prev_thread_ptr) && (tasks_found < thread_list_size)) {
 
 		#define THREADX_THREAD_NAME_STR_SIZE (200)
-	    char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
+		char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
 		unsigned int i = 0;
 		int64_t name_ptr = 0;
 
-		// Save the thread pointer
+		/* Save the thread pointer */
 		rtos->thread_details[tasks_found].threadid = thread_ptr;
 
-
-		// read the name pointer
-		retval = target_read_buffer( rtos->target, thread_ptr + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr);
-		if ( retval != ERROR_OK )
-		{
+		/* read the name pointer */
+		retval = target_read_buffer(rtos->target,
+				thread_ptr + param->thread_name_offset,
+				param->pointer_width,
+				(uint8_t *)&name_ptr);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n");
 			return retval;
 		}
 
-		// Read the thread name
-		retval = target_read_buffer( rtos->target, name_ptr, THREADX_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
-		if ( retval != ERROR_OK )
-		{
+		/* Read the thread name */
+		retval =
+			target_read_buffer(rtos->target,
+				name_ptr,
+				THREADX_THREAD_NAME_STR_SIZE,
+				(uint8_t *)&tmp_str);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading thread name from ThreadX target\r\n");
 			return retval;
 		}
 		tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
 
-		if ( tmp_str[0] == '\x00' )
-		{
-			strcpy(tmp_str,"No Name");
-		}
-
-
-		rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
-		strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
-
+		if (tmp_str[0] == '\x00')
+			strcpy(tmp_str, "No Name");
 
+		rtos->thread_details[tasks_found].thread_name_str =
+			(char *)malloc(strlen(tmp_str)+1);
+		strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 
-		// Read the thread status
+		/* Read the thread status */
 		int64_t thread_status = 0;
-		retval = target_read_buffer( rtos->target, thread_ptr + param->thread_state_offset, 4, (uint8_t *)&thread_status);
-		if ( retval != ERROR_OK )
-		{
+		retval = target_read_buffer(rtos->target,
+				thread_ptr + param->thread_state_offset,
+				4,
+				(uint8_t *)&thread_status);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading thread state from ThreadX target\r\n");
 			return retval;
 		}
 
-		for( i = 0; (i < THREADX_NUM_STATES) && (ThreadX_thread_states[i].value!=thread_status); i++ )
-		{
+		for (i = 0; (i < THREADX_NUM_STATES) &&
+				(ThreadX_thread_states[i].value != thread_status); i++) {
+			/* empty */
 		}
 
-
-		char * state_desc;
+		char *state_desc;
 		if  (i < THREADX_NUM_STATES)
-		{
 			state_desc = ThreadX_thread_states[i].desc;
-		}
 		else
-		{
 			state_desc = "Unknown state";
-		}
 
-		rtos->thread_details[tasks_found].extra_info_str = (char*)malloc( strlen(state_desc)+1 );
-		strcpy( rtos->thread_details[tasks_found].extra_info_str, state_desc );
+		rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
+					state_desc)+1);
+		strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
 
 		rtos->thread_details[tasks_found].exists = true;
 
 		rtos->thread_details[tasks_found].display_str = NULL;
 
-
-
-
-
 		tasks_found++;
 		prev_thread_ptr = thread_ptr;
 
-		// Get the location of the next thread structure.
+		/* Get the location of the next thread structure. */
 		thread_ptr = 0;
-		retval = target_read_buffer( rtos->target, prev_thread_ptr + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_ptr );
-		if ( retval != ERROR_OK )
-		{
+		retval = target_read_buffer(rtos->target,
+				prev_thread_ptr + param->thread_next_offset,
+				param->pointer_width,
+				(uint8_t *) &thread_ptr);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading next thread pointer in ThreadX thread list\r\n");
 			return retval;
 		}
-
 	}
 
 	rtos->thread_count = tasks_found;
@@ -343,71 +306,60 @@ static int ThreadX_update_threads( struct rtos* rtos)
 	return 0;
 }
 
-static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
+static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list)
 {
-
 	int retval;
-	const struct ThreadX_params* param;
+	const struct ThreadX_params *param;
 
 	*hex_reg_list = NULL;
 
-	if ( rtos == NULL )
-	{
+	if (rtos == NULL)
 		return -1;
-	}
 
-	if ( thread_id == 0 )
-	{
+	if (thread_id == 0)
 		return -2;
-	}
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -3;
-	}
 
-	param = (const struct ThreadX_params*) rtos->rtos_specific_params;
+	param = (const struct ThreadX_params *) rtos->rtos_specific_params;
 
-	// Read the stack pointer
+	/* Read the stack pointer */
 	int64_t stack_ptr = 0;
-	retval = target_read_buffer( rtos->target, thread_id + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
-	if ( retval != ERROR_OK )
-	{
+	retval = target_read_buffer(rtos->target,
+			thread_id + param->thread_stack_offset,
+			param->pointer_width,
+			(uint8_t *)&stack_ptr);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Error reading stack frame from ThreadX thread\r\n");
 		return retval;
 	}
 
-	return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
+	return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, hex_reg_list);
 }
 
-
-
-static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
+static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * THREADX_NUM_SYMBOLS );
+	*symbol_list = (symbol_table_elem_t *) malloc(
+			sizeof(symbol_table_elem_t) * THREADX_NUM_SYMBOLS);
 
-	for( i = 0; i < THREADX_NUM_SYMBOLS; i++ )
-	{
+	for (i = 0; i < THREADX_NUM_SYMBOLS; i++)
 		(*symbol_list)[i].symbol_name = ThreadX_symbol_list[i];
-	}
 
 	return 0;
 }
 
-static int ThreadX_detect_rtos( struct target* target )
+static int ThreadX_detect_rtos(struct target *target)
 {
-	if ( ( target->rtos->symbols != NULL ) &&
-		 ( target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0 ) )
-	{
-		// looks like ThreadX
+	if ((target->rtos->symbols != NULL) &&
+			(target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0)) {
+		/* looks like ThreadX */
 		return 1;
 	}
 	return 0;
 }
 
-
-
 #if 0
 
 static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id)
@@ -415,9 +367,9 @@ static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id)
 	return 0;
 }
 
-
-
-static int ThreadX_get_thread_detail( struct rtos*   rtos, threadid_t   thread_id, struct thread_detail* detail )
+static int ThreadX_get_thread_detail(struct rtos *rtos,
+	threadid_t thread_id,
+	struct thread_detail *detail)
 {
 	unsigned int i = 0;
 	int retval;
@@ -425,27 +377,20 @@ static int ThreadX_get_thread_detail( struct rtos*   rtos, threadid_t   thread_i
 #define THREADX_THREAD_NAME_STR_SIZE (200)
 	char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
 
-	const struct ThreadX_params* param;
+	const struct ThreadX_params *param;
 
-	if ( rtos == NULL )
-	{
+	if (rtos == NULL)
 		return -1;
-	}
 
-	if ( thread_id == 0 )
-	{
+	if (thread_id == 0)
 		return -2;
-	}
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -3;
-	}
 
-	param = (const struct ThreadX_params*) rtos->rtos_specific_params;
+	param = (const struct ThreadX_params *) rtos->rtos_specific_params;
 
-	if ( rtos->symbols == NULL )
-	{
+	if (rtos->symbols == NULL) {
 		LOG_OUTPUT("No symbols for ThreadX\r\n");
 		return -3;
 	}
@@ -453,83 +398,79 @@ static int ThreadX_get_thread_detail( struct rtos*   rtos, threadid_t   thread_i
 	detail->threadid = thread_id;
 
 	int64_t name_ptr = 0;
-	// read the name pointer
-	retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr);
-	if ( retval != ERROR_OK )
-	{
+	/* read the name pointer */
+	retval = target_read_buffer(rtos->target,
+			thread_id + param->thread_name_offset,
+			param->pointer_width,
+			(uint8_t *)&name_ptr);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n");
 		return retval;
 	}
 
-	// Read the thread name
-	retval = target_read_buffer( rtos->target, name_ptr, THREADX_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
-	if ( retval != ERROR_OK )
-	{
+	/* Read the thread name */
+	retval = target_read_buffer(rtos->target,
+			name_ptr,
+			THREADX_THREAD_NAME_STR_SIZE,
+			(uint8_t *)&tmp_str);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Error reading thread name from ThreadX target\r\n");
 		return retval;
 	}
 	tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
 
-	if ( tmp_str[0] == '\x00' )
-	{
-		strcpy(tmp_str,"No Name");
-	}
-
-	detail->thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
+	if (tmp_str[0] == '\x00')
+		strcpy(tmp_str, "No Name");
 
+	detail->thread_name_str = (char *)malloc(strlen(tmp_str)+1);
 
-	// Read the thread status
+	/* Read the thread status */
 	int64_t thread_status = 0;
-	retval = target_read_buffer( rtos->target, thread_id + param->thread_state_offset, 4, (uint8_t *)&thread_status);
-	if ( retval != ERROR_OK )
-	{
+	retval =
+		target_read_buffer(rtos->target,
+			thread_id + param->thread_state_offset,
+			4,
+			(uint8_t *)&thread_status);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Error reading thread state from ThreadX target\r\n");
 		return retval;
 	}
 
-	for( i = 0; (i < THREADX_NUM_STATES) && (ThreadX_thread_states[i].value!=thread_status); i++ )
-	{
+	for (i = 0; (i < THREADX_NUM_STATES) &&
+			(ThreadX_thread_states[i].value != thread_status); i++) {
+		/* empty */
 	}
 
-
-	char * state_desc;
+	char *state_desc;
 	if  (i < THREADX_NUM_STATES)
-	{
 		state_desc = ThreadX_thread_states[i].desc;
-	}
 	else
-	{
 		state_desc = "Unknown state";
-	}
 
-	detail->extra_info_str = (char*)malloc( strlen(state_desc)+1 );
+	detail->extra_info_str = (char *)malloc(strlen(state_desc)+1);
 
 	detail->exists = true;
 
 	detail->display_str = NULL;
 
-
-
-
 	return 0;
 }
 
 #endif
 
-static int ThreadX_create( struct target* target )
+static int ThreadX_create(struct target *target)
 {
 	int i = 0;
-	while ( ( i < THREADX_NUM_PARAMS ) && ( 0 != strcmp( ThreadX_params_list[i].target_name, target->type->name ) ) )
-	{
+	while ((i < THREADX_NUM_PARAMS) &&
+			(0 != strcmp(ThreadX_params_list[i].target_name, target->type->name))) {
 		i++;
 	}
-	if ( i >= THREADX_NUM_PARAMS )
-	{
+	if (i >= THREADX_NUM_PARAMS) {
 		LOG_OUTPUT("Could not find target in ThreadX compatibility list\r\n");
 		return -1;
 	}
 
-	target->rtos->rtos_specific_params = (void*) &ThreadX_params_list[i];
+	target->rtos->rtos_specific_params = (void *) &ThreadX_params_list[i];
 	target->rtos->current_thread = 0;
 	target->rtos->thread_details = NULL;
 	return 0;
diff --git a/src/rtos/eCos.c b/src/rtos/eCos.c
index cd04d9d..5c18916 100644
--- a/src/rtos/eCos.c
+++ b/src/rtos/eCos.c
@@ -28,206 +28,189 @@
 #include "helper/log.h"
 #include "rtos_ecos_stackings.h"
 
-static int eCos_detect_rtos( struct target* target );
-static int eCos_create( struct target* target );
-static int eCos_update_threads( struct rtos* rtos);
-static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
-static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
+static int eCos_detect_rtos(struct target *target);
+static int eCos_create(struct target *target);
+static int eCos_update_threads(struct rtos *rtos);
+static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list);
+static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
 
-struct eCos_thread_state
-{
+struct eCos_thread_state {
 	int value;
-	char * desc;
+	char *desc;
 };
 
-
-struct eCos_thread_state eCos_thread_states[] =
-{
-    { 0,  "Ready" },
-    { 1,  "Sleeping" },
-    { 2,  "Countsleep" },
-    { 4,  "Suspended" },
-    { 8,  "Creating" },
-    { 16,  "Exited" }
+struct eCos_thread_state eCos_thread_states[] = {
+	{ 0, "Ready" },
+	{ 1, "Sleeping" },
+	{ 2, "Countsleep" },
+	{ 4, "Suspended" },
+	{ 8, "Creating" },
+	{ 16, "Exited" }
 };
 
 #define ECOS_NUM_STATES (sizeof(eCos_thread_states)/sizeof(struct eCos_thread_state))
 
-struct eCos_params
-{
-	char *                               target_name;
-	unsigned char                        pointer_width;
-	unsigned char                        thread_stack_offset;
-	unsigned char                        thread_name_offset;
-	unsigned char                        thread_state_offset;
-	unsigned char                        thread_next_offset;
-	unsigned char                        thread_uniqueid_offset;
-	const struct rtos_register_stacking* stacking_info;
+struct eCos_params {
+	char *target_name;
+	unsigned char pointer_width;
+	unsigned char thread_stack_offset;
+	unsigned char thread_name_offset;
+	unsigned char thread_state_offset;
+	unsigned char thread_next_offset;
+	unsigned char thread_uniqueid_offset;
+	const struct rtos_register_stacking *stacking_info;
 };
 
-const struct eCos_params eCos_params_list[] =
-{
-	{ "cortex_m3",                       // target_name
-          4,                                 // pointer_width;
-          0x0c,                              // thread_stack_offset;
-          0x9c,                              // thread_name_offset;
-          0x3c,                              // thread_state_offset;
-          0xa0,                              // thread_next_offset
-          0x4c,                              // thread_uniqueid_offset
-          &rtos_eCos_Cortex_M3_stacking      // stacking_info
+const struct eCos_params eCos_params_list[] = {
+	{
+	"cortex_m3",			/* target_name */
+	4,						/* pointer_width; */
+	0x0c,					/* thread_stack_offset; */
+	0x9c,					/* thread_name_offset; */
+	0x3c,					/* thread_state_offset; */
+	0xa0,					/* thread_next_offset */
+	0x4c,					/* thread_uniqueid_offset */
+	&rtos_eCos_Cortex_M3_stacking	/* stacking_info */
 	}
-
 };
 
 #define ECOS_NUM_PARAMS ((int)(sizeof(eCos_params_list)/sizeof(struct eCos_params)))
 
-enum eCos_symbol_values
-{
-	eCos_VAL_thread_list     	= 0,
-	eCos_VAL_current_thread_ptr	= 1
+enum eCos_symbol_values {
+	eCos_VAL_thread_list = 0,
+	eCos_VAL_current_thread_ptr = 1
 };
 
-static char* eCos_symbol_list[] =
-{
-		"Cyg_Thread::thread_list",
-		"Cyg_Scheduler_Base::current_thread",
-		NULL
+static char *eCos_symbol_list[] = {
+	"Cyg_Thread::thread_list",
+	"Cyg_Scheduler_Base::current_thread",
+	NULL
 };
 
+#define ECOS_NUM_SYMBOLS (sizeof(eCos_symbol_list)/sizeof(char *))
 
+const struct rtos_type eCos_rtos = {
+	.name = "eCos",
 
-#define ECOS_NUM_SYMBOLS (sizeof(eCos_symbol_list)/sizeof(char*))
-
-
-const struct rtos_type eCos_rtos =
-{
-	.name                      = "eCos",
-
-	.detect_rtos               = eCos_detect_rtos,
-	.create                    = eCos_create,
-	.update_threads            = eCos_update_threads,
-	.get_thread_reg_list       = eCos_get_thread_reg_list,
+	.detect_rtos = eCos_detect_rtos,
+	.create = eCos_create,
+	.update_threads = eCos_update_threads,
+	.get_thread_reg_list = eCos_get_thread_reg_list,
 	.get_symbol_list_to_lookup = eCos_get_symbol_list_to_lookup,
 
 };
 
-static int eCos_update_threads( struct rtos* rtos)
+static int eCos_update_threads(struct rtos *rtos)
 {
 	int retval;
 	int tasks_found = 0;
 	int thread_list_size = 0;
-	const struct eCos_params* param;
+	const struct eCos_params *param;
 
-	if ( rtos == NULL )
-	{
+	if (rtos == NULL)
 		return -1;
-	}
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -3;
-	}
 
-	param = (const struct eCos_params*) rtos->rtos_specific_params;
+	param = (const struct eCos_params *) rtos->rtos_specific_params;
 
-	if ( rtos->symbols == NULL )
-	{
+	if (rtos->symbols == NULL) {
 		LOG_OUTPUT("No symbols for eCos\r\n");
 		return -4;
 	}
 
-	if ( rtos->symbols[eCos_VAL_thread_list].address == 0 )
-	{
+	if (rtos->symbols[eCos_VAL_thread_list].address == 0) {
 		LOG_OUTPUT("Don't have the thread list head\r\n");
 		return -2;
 	}
 
-
-	// wipe out previous thread details if any
-	if ( rtos->thread_details != NULL )
-	{
+	/* wipe out previous thread details if any */
+	if (rtos->thread_details != NULL) {
 		int j;
-		for( j = 0; j < rtos->thread_count; j++ )
-		{
-			if ( rtos->thread_details[j].display_str != NULL )
-			{
-				free( rtos->thread_details[j].display_str );
+		for (j = 0; j < rtos->thread_count; j++) {
+			if (rtos->thread_details[j].display_str != NULL) {
+				free(rtos->thread_details[j].display_str);
 				rtos->thread_details[j].display_str = NULL;
 			}
-			if ( rtos->thread_details[j].thread_name_str != NULL )
-			{
-				free( rtos->thread_details[j].thread_name_str );
+			if (rtos->thread_details[j].thread_name_str != NULL) {
+				free(rtos->thread_details[j].thread_name_str);
 				rtos->thread_details[j].thread_name_str = NULL;
 			}
-			if ( rtos->thread_details[j].extra_info_str != NULL )
-			{
-				free( rtos->thread_details[j].extra_info_str );
+			if (rtos->thread_details[j].extra_info_str != NULL) {
+				free(rtos->thread_details[j].extra_info_str);
 				rtos->thread_details[j].extra_info_str = NULL;
 			}
 		}
-		free( rtos->thread_details );
+		free(rtos->thread_details);
 		rtos->thread_details = NULL;
 	}
 
-
-	// determine the number of current threads
+	/* determine the number of current threads */
 	uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address;
 	uint32_t thread_index;
-	target_read_buffer( rtos->target, thread_list_head, param->pointer_width, (uint8_t *) &thread_index );
+	target_read_buffer(rtos->target,
+		thread_list_head,
+		param->pointer_width,
+		(uint8_t *) &thread_index);
 	uint32_t first_thread = thread_index;
-	do
-	{
+	do {
 		thread_list_size++;
-		retval = target_read_buffer( rtos->target, thread_index + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
+		retval = target_read_buffer(rtos->target,
+				thread_index + param->thread_next_offset,
+				param->pointer_width,
+				(uint8_t *) &thread_index);
 		if (retval != ERROR_OK)
 			return retval;
-	} while( thread_index!=first_thread );
+	} while (thread_index != first_thread);
 
-	// read the current thread id
+	/* read the current thread id */
 	uint32_t current_thread_addr;
-	retval = target_read_buffer( rtos->target, rtos->symbols[eCos_VAL_current_thread_ptr].address, 4, (uint8_t *)&current_thread_addr);
+	retval = target_read_buffer(rtos->target,
+			rtos->symbols[eCos_VAL_current_thread_ptr].address,
+			4,
+			(uint8_t *)&current_thread_addr);
 	if (retval != ERROR_OK)
 		return retval;
 	rtos->current_thread = 0;
-	retval = target_read_buffer( rtos->target, current_thread_addr + param->thread_uniqueid_offset, 2, (uint8_t *)&rtos->current_thread);
-	if ( retval != ERROR_OK )
-	{
+	retval = target_read_buffer(rtos->target,
+			current_thread_addr + param->thread_uniqueid_offset,
+			2,
+			(uint8_t *)&rtos->current_thread);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Could not read eCos current thread from target\r\n");
 		return retval;
 	}
 
-	if ( ( thread_list_size  == 0 ) || ( rtos->current_thread == 0 ) )
-	{
-		// Either : No RTOS threads - there is always at least the current execution though
-		// OR     : No current thread - all threads suspended - show the current execution of idling
+	if ((thread_list_size  == 0) || (rtos->current_thread == 0)) {
+		/* Either : No RTOS threads - there is always at least the current execution though */
+		/* OR     : No current thread - all threads suspended - show the current execution
+		 * of idling */
 		char tmp_str[] = "Current Execution";
 		thread_list_size++;
 		tasks_found++;
-		rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
+		rtos->thread_details = (struct thread_detail *) malloc(
+				sizeof(struct thread_detail) * thread_list_size);
 		rtos->thread_details->threadid = 1;
 		rtos->thread_details->exists = true;
 		rtos->thread_details->display_str = NULL;
 		rtos->thread_details->extra_info_str = NULL;
-		rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
-		strcpy( rtos->thread_details->thread_name_str, tmp_str );
-
+		rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+		strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
-		if ( thread_list_size == 0 )
-		{
+		if (thread_list_size == 0) {
 			rtos->thread_count = 1;
 			return ERROR_OK;
 		}
-	}
-	else
-	{
-		// create space for new thread details
-		rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
+	} else {
+		/* create space for new thread details */
+		rtos->thread_details = (struct thread_detail *) malloc(
+				sizeof(struct thread_detail) * thread_list_size);
 	}
 
-	// loop over all threads
+	/* loop over all threads */
 	thread_index = first_thread;
-	do
-	{
+	do {
 
 		#define ECOS_THREAD_NAME_STR_SIZE (200)
 		char tmp_str[ECOS_THREAD_NAME_STR_SIZE];
@@ -235,196 +218,198 @@ static int eCos_update_threads( struct rtos* rtos)
 		uint32_t name_ptr = 0;
 		uint32_t prev_thread_ptr;
 
-		// Save the thread pointer
+		/* Save the thread pointer */
 		uint16_t thread_id;
-		retval = target_read_buffer( rtos->target, thread_index + param->thread_uniqueid_offset, 2, (uint8_t *)&thread_id);
-		if ( retval != ERROR_OK )
-		{
+		retval = target_read_buffer(rtos->target,
+				thread_index + param->thread_uniqueid_offset,
+				2,
+				(uint8_t *)&thread_id);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Could not read eCos thread id from target\r\n");
 			return retval;
 		}
 		rtos->thread_details[tasks_found].threadid = thread_id;
 
-		// read the name pointer
-		retval = target_read_buffer( rtos->target, thread_index + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr);
-		if ( retval != ERROR_OK )
-		{
+		/* read the name pointer */
+		retval = target_read_buffer(rtos->target,
+				thread_index + param->thread_name_offset,
+				param->pointer_width,
+				(uint8_t *)&name_ptr);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Could not read eCos thread name pointer from target\r\n");
 			return retval;
 		}
 
-		// Read the thread name
-		retval = target_read_buffer( rtos->target, name_ptr, ECOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
-		if ( retval != ERROR_OK )
-		{
+		/* Read the thread name */
+		retval =
+			target_read_buffer(rtos->target,
+				name_ptr,
+				ECOS_THREAD_NAME_STR_SIZE,
+				(uint8_t *)&tmp_str);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading thread name from eCos target\r\n");
 			return retval;
 		}
 		tmp_str[ECOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 
-		if ( tmp_str[0] == '\x00' )
-		{
-			strcpy(tmp_str,"No Name");
-		}
+		if (tmp_str[0] == '\x00')
+			strcpy(tmp_str, "No Name");
 
-		rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
-		strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
+		rtos->thread_details[tasks_found].thread_name_str =
+			(char *)malloc(strlen(tmp_str)+1);
+		strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 
-		// Read the thread status
+		/* Read the thread status */
 		int64_t thread_status = 0;
-		retval = target_read_buffer( rtos->target, thread_index + param->thread_state_offset, 4, (uint8_t *)&thread_status);
-		if ( retval != ERROR_OK )
-		{
+		retval = target_read_buffer(rtos->target,
+				thread_index + param->thread_state_offset,
+				4,
+				(uint8_t *)&thread_status);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading thread state from eCos target\r\n");
 			return retval;
 		}
 
-		for( i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value!=thread_status); i++ )
-		{
+		for (i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value != thread_status); i++) {
+			/*
+			 * empty
+			 */
 		}
 
-		char * state_desc;
+		char *state_desc;
 		if  (i < ECOS_NUM_STATES)
-		{
 			state_desc = eCos_thread_states[i].desc;
-		}
 		else
-		{
 			state_desc = "Unknown state";
-		}
 
-		rtos->thread_details[tasks_found].extra_info_str = (char*)malloc( strlen(state_desc)+1 );
-		strcpy( rtos->thread_details[tasks_found].extra_info_str, state_desc );
+		rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
+					state_desc)+1);
+		strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
 
 		rtos->thread_details[tasks_found].exists = true;
 
 		rtos->thread_details[tasks_found].display_str = NULL;
 
-
 		tasks_found++;
 		prev_thread_ptr = thread_index;
 
-		// Get the location of the next thread structure.
+		/* Get the location of the next thread structure. */
 		thread_index = rtos->symbols[eCos_VAL_thread_list].address;
-		retval = target_read_buffer( rtos->target, prev_thread_ptr + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
-		if ( retval != ERROR_OK )
-		{
+		retval = target_read_buffer(rtos->target,
+				prev_thread_ptr + param->thread_next_offset,
+				param->pointer_width,
+				(uint8_t *) &thread_index);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading next thread pointer in eCos thread list\r\n");
 			return retval;
 		}
-	}
-	while( thread_index!=first_thread );
+	} while (thread_index != first_thread);
 
 	rtos->thread_count = tasks_found;
 	return 0;
 }
 
-static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
+static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list)
 {
-
 	int retval;
-	const struct eCos_params* param;
+	const struct eCos_params *param;
 
 	*hex_reg_list = NULL;
 
-	if ( rtos == NULL )
-	{
+	if (rtos == NULL)
 		return -1;
-	}
 
-	if ( thread_id == 0 )
-	{
+	if (thread_id == 0)
 		return -2;
-	}
 
-	if (rtos->rtos_specific_params == NULL )
-	{
+	if (rtos->rtos_specific_params == NULL)
 		return -3;
-	}
-
-	param = (const struct eCos_params*) rtos->rtos_specific_params;
 
+	param = (const struct eCos_params *) rtos->rtos_specific_params;
 
-	// Find the thread with that thread id
-	uint16_t id=0;
+	/* Find the thread with that thread id */
+	uint16_t id = 0;
 	uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address;
 	uint32_t thread_index;
-	target_read_buffer( rtos->target, thread_list_head, param->pointer_width, (uint8_t *) &thread_index );
-	bool done=false;
-	while(!done)
-	{
-		retval = target_read_buffer( rtos->target, thread_index + param->thread_uniqueid_offset, 2, (uint8_t*)&id);
-		if ( retval != ERROR_OK )
-		{
+	target_read_buffer(rtos->target, thread_list_head, param->pointer_width,
+			(uint8_t *)&thread_index);
+	bool done = false;
+	while (!done) {
+		retval = target_read_buffer(rtos->target,
+				thread_index + param->thread_uniqueid_offset,
+				2,
+				(uint8_t *)&id);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading unique id from eCos thread\r\n");
 			return retval;
 		}
 
-		if( id==thread_id )
-		{
-			done=true;
+		if (id == thread_id) {
+			done = true;
 			break;
 		}
-		target_read_buffer( rtos->target, thread_index + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
+		target_read_buffer(rtos->target,
+			thread_index + param->thread_next_offset,
+			param->pointer_width,
+			(uint8_t *) &thread_index);
 	}
 
-	if(done)
-	{
-		// Read the stack pointer
+	if (done) {
+		/* Read the stack pointer */
 		int64_t stack_ptr = 0;
-		retval = target_read_buffer( rtos->target, thread_index + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
-		if ( retval != ERROR_OK )
-		{
+		retval = target_read_buffer(rtos->target,
+				thread_index + param->thread_stack_offset,
+				param->pointer_width,
+				(uint8_t *)&stack_ptr);
+		if (retval != ERROR_OK) {
 			LOG_OUTPUT("Error reading stack frame from eCos thread\r\n");
 			return retval;
 		}
 
-		return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
+		return rtos_generic_stack_read(rtos->target,
+			param->stacking_info,
+			stack_ptr,
+			hex_reg_list);
 	}
 
 	return -1;
 }
 
-
-
-static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
+static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * ECOS_NUM_SYMBOLS );
+	*symbol_list = (symbol_table_elem_t *) malloc(
+			sizeof(symbol_table_elem_t) * ECOS_NUM_SYMBOLS);
 
-	for( i = 0; i < ECOS_NUM_SYMBOLS; i++ )
-	{
+	for (i = 0; i < ECOS_NUM_SYMBOLS; i++)
 		(*symbol_list)[i].symbol_name = eCos_symbol_list[i];
-	}
 
 	return 0;
 }
 
-static int eCos_detect_rtos( struct target* target )
+static int eCos_detect_rtos(struct target *target)
 {
-	if ( ( target->rtos->symbols != NULL ) &&
-		 ( target->rtos->symbols[eCos_VAL_thread_list].address != 0 ) )
-	{
-		// looks like eCos
+	if ((target->rtos->symbols != NULL) &&
+			(target->rtos->symbols[eCos_VAL_thread_list].address != 0)) {
+		/* looks like eCos */
 		return 1;
 	}
 	return 0;
 }
 
-static int eCos_create( struct target* target )
+static int eCos_create(struct target *target)
 {
 	int i = 0;
-	while ( ( i < ECOS_NUM_PARAMS ) && ( 0 != strcmp( eCos_params_list[i].target_name, target->type->name ) ) )
-	{
+	while ((i < ECOS_NUM_PARAMS) &&
+		(0 != strcmp(eCos_params_list[i].target_name, target->type->name))) {
 		i++;
 	}
-	if ( i >= ECOS_NUM_PARAMS )
-	{
+	if (i >= ECOS_NUM_PARAMS) {
 		LOG_OUTPUT("Could not find target in eCos compatibility list\r\n");
 		return -1;
 	}
 
-	target->rtos->rtos_specific_params = (void*) &eCos_params_list[i];
+	target->rtos->rtos_specific_params = (void *) &eCos_params_list[i];
 	target->rtos->current_thread = 0;
 	target->rtos->thread_details = NULL;
 	return 0;
diff --git a/src/rtos/linux.c b/src/rtos/linux.c
index 2ea3312..e249ff4 100644
--- a/src/rtos/linux.c
+++ b/src/rtos/linux.c
@@ -102,15 +102,15 @@ static int linux_os_create(struct target *target);
 
 static int linux_os_dummy_update(struct rtos *rtos)
 {
-	/*  update is done only when thread request come */
-	/*  too many thread to do it on each stop */
+	/*  update is done only when thread request come
+	 *  too many thread to do it on each stop */
 	return 0;
 }
 
 static int linux_compute_virt2phys(struct target *target, uint32_t address)
 {
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	uint32_t pa = 0;
 	int retval = target->type->virt2phys(target, address, &pa);
 	if (retval != ERROR_OK) {
@@ -127,12 +127,12 @@ static int linux_compute_virt2phys(struct target *target, uint32_t address)
 }
 
 static int linux_read_memory(struct target *target,
-			     uint32_t address, uint32_t size, uint32_t count,
-			     uint8_t *buffer)
+	uint32_t address, uint32_t size, uint32_t count,
+	uint8_t *buffer)
 {
 #ifdef PHYS
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	uint32_t pa = (address & linux_os->phys_mask) + linux_os->phys_base;
 #endif
 	if (address < 0xc000000) {
@@ -156,7 +156,7 @@ static char *reg_converter(char *buffer, void *reg, int size)
 	return buffer;
 }
 
-int fill_buffer(struct target *target, uint32_t addr, uint8_t * buffer)
+int fill_buffer(struct target *target, uint32_t addr, uint8_t *buffer)
 {
 
 	if ((addr & 0xfffffffc) != addr)
@@ -176,11 +176,11 @@ uint32_t get_buffer(struct target *target, const uint8_t *buffer)
 }
 
 static int linux_os_thread_reg_list(struct rtos *rtos,
-				    int64_t thread_id, char **hex_reg_list)
+	int64_t thread_id, char **hex_reg_list)
 {
 	struct target *target = rtos->target;
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	int i = 0;
 	struct current_thread *tmp = linux_os->current_threads;
 	struct current_thread *next;
@@ -216,15 +216,17 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
 
 		if (found == 0) {
 			LOG_ERROR
-			    ("current thread %" PRIx64": no target to perform access of core id %x",
-			     thread_id, next->core_id);
+			(
+				"current thread %" PRIx64 ": no target to perform access of core id %x",
+				thread_id,
+				next->core_id);
 			return ERROR_FAIL;
 		}
 
 		/*LOG_INFO("thread %lx current on core %x",thread_id,
 		 * target->coreid);*/
 		retval =
-		    target_get_gdb_reg_list(target, &reg_list, &reg_list_size);
+			target_get_gdb_reg_list(target, &reg_list, &reg_list_size);
 
 		if (retval != ERROR_OK)
 			return retval;
@@ -241,8 +243,8 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
 				reg_list[i]->type->get(reg_list[i]);
 
 			hex_string = reg_converter(hex_string,
-						   reg_list[i]->value,
-						   (reg_list[i]->size) / 8);
+					reg_list[i]->value,
+					(reg_list[i]->size) / 8);
 		}
 
 		free(reg_list);
@@ -256,49 +258,48 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
 			hex_string += sprintf(hex_string, "%02x", 0);
 
 		while ((temp != NULL) &&
-		       (temp->threadid != target->rtos->current_threadid))
+				(temp->threadid != target->rtos->current_threadid))
 			temp = temp->next;
 
 		if (temp != NULL) {
 			if (temp->context == NULL)
 				temp->context = cpu_context_read(target,
-								 temp->
-								 base_addr,
-								 &temp->
-								 thread_info_addr);
+						temp->
+						base_addr,
+						&temp->
+						thread_info_addr);
 
 			hex_string =
-			    reg_converter(hex_string, &temp->context->R4, 4);
+				reg_converter(hex_string, &temp->context->R4, 4);
 			hex_string =
-			    reg_converter(hex_string, &temp->context->R5, 4);
+				reg_converter(hex_string, &temp->context->R5, 4);
 			hex_string =
-			    reg_converter(hex_string, &temp->context->R6, 4);
+				reg_converter(hex_string, &temp->context->R6, 4);
 			hex_string =
-			    reg_converter(hex_string, &temp->context->R7, 4);
+				reg_converter(hex_string, &temp->context->R7, 4);
 			hex_string =
-			    reg_converter(hex_string, &temp->context->R8, 4);
+				reg_converter(hex_string, &temp->context->R8, 4);
 			hex_string =
-			    reg_converter(hex_string, &temp->context->R9, 4);
+				reg_converter(hex_string, &temp->context->R9, 4);
 
 			for (i = 0; i < 4; i++)	/*R10 = 0x0 */
 				hex_string += sprintf(hex_string, "%02x", 0);
 
 			hex_string =
-			    reg_converter(hex_string, &temp->context->FP, 4);
+				reg_converter(hex_string, &temp->context->FP, 4);
 			hex_string =
-			    reg_converter(hex_string, &temp->context->IP, 4);
+				reg_converter(hex_string, &temp->context->IP, 4);
 			hex_string =
-			    reg_converter(hex_string, &temp->context->SP, 4);
+				reg_converter(hex_string, &temp->context->SP, 4);
 
 			for (i = 0; i < 4; i++)
 				hex_string += sprintf(hex_string, "%02x", 0);
 
 			hex_string =
-			    reg_converter(hex_string, &temp->context->PC, 4);
+				reg_converter(hex_string, &temp->context->PC, 4);
 
-			for (i = 0; i < 100; i++) {	/*100 */
+			for (i = 0; i < 100; i++)	/*100 */
 				hex_string += sprintf(hex_string, "%02x", 0);
-			}
 
 			uint32_t cpsr = 0x00000000;
 			hex_string = reg_converter(hex_string, &cpsr, 4);
@@ -325,7 +326,7 @@ static int linux_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
 	*symbol_list = (symbol_table_elem_t *)
-	    malloc(sizeof(symbol_table_elem_t) / sizeof(char *));
+		malloc(sizeof(symbol_table_elem_t) / sizeof(char *));
 
 	for (i = 0; i < sizeof(linux_symbol_list) / sizeof(char *); i++)
 		(*symbol_list)[i].symbol_name = linux_symbol_list[i];
@@ -348,7 +349,7 @@ const struct rtos_type Linux_os = {
 };
 
 static int linux_thread_packet(struct connection *connection, char *packet,
-			       int packet_size);
+		int packet_size);
 static void linux_identify_current_threads(struct target *target);
 
 #ifdef PID_CHECK
@@ -370,7 +371,6 @@ int fill_task_pid(struct target *target, struct threads *t)
 
 int fill_task(struct target *target, struct threads *t)
 {
-
 	int retval;
 	uint32_t pid_addr = t->base_addr + PID;
 	uint32_t mem_addr = t->base_addr + MEM;
@@ -414,10 +414,9 @@ int fill_task(struct target *target, struct threads *t)
 				t->asid = val;
 			} else
 				LOG_ERROR
-				    ("fill task: unable to read memory -- ASID");
-		} else {
+					("fill task: unable to read memory -- ASID");
+		} else
 			t->asid = 0;
-		}
 	} else
 		LOG_ERROR("fill task: unable to read memory");
 
@@ -442,26 +441,26 @@ int get_name(struct target *target, struct threads *t)
 	}
 
 	uint32_t raw_name = target_buffer_get_u32(target,
-						  (const uint8_t *)
-						  &full_name[0]);
+			(const uint8_t *)
+			&full_name[0]);
 	t->name[3] = raw_name >> 24;
 	t->name[2] = raw_name >> 16;
 	t->name[1] = raw_name >> 8;
 	t->name[0] = raw_name;
 	raw_name =
-	    target_buffer_get_u32(target, (const uint8_t *)&full_name[1]);
+		target_buffer_get_u32(target, (const uint8_t *)&full_name[1]);
 	t->name[7] = raw_name >> 24;
 	t->name[6] = raw_name >> 16;
 	t->name[5] = raw_name >> 8;
 	t->name[4] = raw_name;
 	raw_name =
-	    target_buffer_get_u32(target, (const uint8_t *)&full_name[2]);
+		target_buffer_get_u32(target, (const uint8_t *)&full_name[2]);
 	t->name[11] = raw_name >> 24;
 	t->name[10] = raw_name >> 16;
 	t->name[9] = raw_name >> 8;
 	t->name[8] = raw_name;
 	raw_name =
-	    target_buffer_get_u32(target, (const uint8_t *)&full_name[3]);
+		target_buffer_get_u32(target, (const uint8_t *)&full_name[3]);
 	t->name[15] = raw_name >> 24;
 	t->name[14] = raw_name >> 16;
 	t->name[13] = raw_name >> 8;
@@ -479,7 +478,7 @@ int get_current(struct target *target, int create)
 	uint32_t ti_addr;
 	uint8_t *buffer = calloc(1, 4);
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	struct current_thread *ctt = linux_os->current_threads;
 
 	/*  invalid current threads content */
@@ -495,8 +494,7 @@ int get_current(struct target *target, int create)
 		int retval;
 
 		if (target_get_gdb_reg_list(head->target, &reg_list,
-						      &reg_list_size) !=
-		    ERROR_OK)
+				&reg_list_size) != ERROR_OK)
 			return ERROR_TARGET_FAILURE;
 
 		if (!reg_list[13]->valid)
@@ -516,19 +514,17 @@ int get_current(struct target *target, int create)
 			if (retval == ERROR_OK) {
 				/*uint32_t cpu = get_buffer(target, buffer);*/
 				struct current_thread *ct =
-				    linux_os->current_threads;
+					linux_os->current_threads;
 				cpu = head->target->coreid;
 
-				while ((ct != NULL)
-				       && (ct->core_id != (int32_t) cpu)) {
+				while ((ct != NULL) && (ct->core_id != (int32_t) cpu))
 					ct = ct->next;
-				}
 
 				if ((ct != NULL) && (ct->TS == 0xdeadbeef))
 					ct->TS = TS;
 				else
 					LOG_ERROR
-					    ("error in linux current thread update");
+						("error in linux current thread update");
 
 				if (create) {
 					struct threads *t;
@@ -558,7 +554,7 @@ int get_current(struct target *target, int create)
 }
 
 struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
-				     uint32_t *thread_info_addr_old)
+	uint32_t *thread_info_addr_old)
 {
 	struct cpu_context *context = calloc(1, sizeof(struct cpu_context));
 	uint32_t preempt_count_addr = 0;
@@ -600,11 +596,11 @@ retry:
 	else {
 		if (*thread_info_addr_old != 0xdeadbeef) {
 			LOG_ERROR
-			    ("cpu_context: cannot read at thread_info_addr");
+				("cpu_context: cannot read at thread_info_addr");
 
 			if (*thread_info_addr_old < LINUX_USER_KERNEL_BORDER)
 				LOG_INFO
-				    ("cpu_context : thread_info_addr in userspace!!!");
+					("cpu_context : thread_info_addr in userspace!!!");
 
 			*thread_info_addr_old = 0xdeadbeef;
 			goto retry;
@@ -616,7 +612,7 @@ retry:
 	thread_info_addr += CPU_CONT;
 
 	retval = linux_read_memory(target, thread_info_addr, 4, 10,
-				   (uint8_t *) registers);
+			(uint8_t *) registers);
 
 	if (retval != ERROR_OK) {
 		LOG_ERROR("cpu_context: unable to read memory\n");
@@ -624,25 +620,25 @@ retry:
 	}
 
 	context->R4 =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[0]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[0]);
 	context->R5 =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[1]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[1]);
 	context->R6 =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[2]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[2]);
 	context->R7 =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[3]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[3]);
 	context->R8 =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[4]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[4]);
 	context->R9 =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[5]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[5]);
 	context->IP =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[6]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[6]);
 	context->FP =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[7]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[7]);
 	context->SP =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[8]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[8]);
 	context->PC =
-	    target_buffer_get_u32(target, (const uint8_t *)&registers[9]);
+		target_buffer_get_u32(target, (const uint8_t *)&registers[9]);
 
 	if (*thread_info_addr_old == 0xdeadbeef)
 		*thread_info_addr_old = thread_info_addr_update;
@@ -668,7 +664,7 @@ uint32_t next_task(struct target *target, struct threads *t)
 }
 
 struct current_thread *add_current_thread(struct current_thread *currents,
-					  struct current_thread *ct)
+	struct current_thread *ct)
 {
 	ct->next = NULL;
 
@@ -687,7 +683,7 @@ struct current_thread *add_current_thread(struct current_thread *currents,
 }
 
 struct threads *liste_del_task(struct threads *task_list, struct threads **t,
-			       struct threads *prev)
+	struct threads *prev)
 {
 	LOG_INFO("del task %" PRId64, (*t)->threadid);
 	prev->next = (*t)->next;
@@ -705,7 +701,7 @@ struct threads *liste_del_task(struct threads *task_list, struct threads **t,
 }
 
 struct threads *liste_add_task(struct threads *task_list, struct threads *t,
-			       struct threads **last)
+	struct threads **last)
 {
 	t->next = NULL;
 
@@ -723,10 +719,10 @@ struct threads *liste_add_task(struct threads *task_list, struct threads *t,
 			*last = t;
 			return task_list;
 		} else {
-			(*last)->next = t;
-			*last = t;
-			return task_list;
-		}
+		(*last)->next = t;
+		*last = t;
+		return task_list;
+	}
 }
 
 #ifdef PID_CHECK
@@ -758,7 +754,7 @@ int linux_get_tasks(struct target *target, int context)
 	int loop = 0;
 	int retval = 0;
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	linux_os->thread_list = NULL;
 	linux_os->thread_count = 0;
 
@@ -776,9 +772,7 @@ int linux_get_tasks(struct target *target, int context)
 	retval = get_current(target, 1);
 
 	while (((t->base_addr != linux_os->init_task_addr) &&
-		(t->base_addr != 0))
-	       || (loop == 0)
-	    ) {
+		(t->base_addr != 0)) || (loop == 0)) {
 		loop++;
 		retval = fill_task(target, t);
 		retval = get_name(target, t);
@@ -806,15 +800,15 @@ int linux_get_tasks(struct target *target, int context)
 			linux_os->threadid_count++;
 
 			linux_os->thread_list =
-			    liste_add_task(linux_os->thread_list, t, &last);
+				liste_add_task(linux_os->thread_list, t, &last);
 			/* no interest to fill the context if it is a current thread. */
 			linux_os->thread_count++;
 			t->thread_info_addr = 0xdeadbeef;
 
 			if (context)
 				t->context =
-				    cpu_context_read(target, t->base_addr,
-						     &t->thread_info_addr);
+					cpu_context_read(target, t->base_addr,
+						&t->thread_info_addr);
 		} else {
 			/*LOG_INFO("thread %s is a current thread already created",t->name); */
 			free(t);
@@ -830,9 +824,9 @@ int linux_get_tasks(struct target *target, int context)
 	linux_os->preupdtate_threadid_count = linux_os->threadid_count - 1;
 	/*  check that all current threads have been identified  */
 
-	LOG_INFO("complete time %" PRId64", thread mean %" PRId64"\n",
-		 (timeval_ms() - start),
-		 (timeval_ms() - start) / linux_os->threadid_count);
+	LOG_INFO("complete time %" PRId64 ", thread mean %" PRId64 "\n",
+		(timeval_ms() - start),
+		(timeval_ms() - start) / linux_os->threadid_count);
 
 	LOG_INFO("threadid count %d", linux_os->threadid_count);
 
@@ -842,7 +836,7 @@ int linux_get_tasks(struct target *target, int context)
 static int clean_threadlist(struct target *target)
 {
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	struct threads *old, *temp = linux_os->thread_list;
 
 	while (temp != NULL) {
@@ -860,9 +854,8 @@ static int clean_threadlist(struct target *target)
 
 static int linux_os_clean(struct target *target)
 {
-
 	struct linux_os *os_linux = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	clean_threadlist(target);
 	os_linux->init_task_addr = 0xdeadbeef;
 	os_linux->name = "linux";
@@ -901,7 +894,7 @@ static int insert_into_threadlist(struct target *target, struct threads *t)
 static void linux_identify_current_threads(struct target *target)
 {
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	struct threads *thread_list = linux_os->thread_list;
 	struct current_thread *ct = linux_os->current_threads;
 	struct threads *t = NULL;
@@ -930,66 +923,66 @@ error_handling:
 #ifdef PID_CHECK
 				if (thread_list->pid == t->pid) {
 #else
-					if (thread_list->base_addr == t->base_addr) {
+				if (thread_list->base_addr == t->base_addr) {
 #endif
-						free(t);
-						t = thread_list;
-						found = 1;
-					}
-					thread_list = thread_list->next;
+					free(t);
+					t = thread_list;
+					found = 1;
 				}
+				thread_list = thread_list->next;
+			}
 
-				if (!found) {
-					/*  it is a new thread */
-					if (fill_task(target, t) != ERROR_OK)
-						goto error_handling;
+			if (!found) {
+				/*  it is a new thread */
+				if (fill_task(target, t) != ERROR_OK)
+					goto error_handling;
 
-					get_name(target, t);
-					insert_into_threadlist(target, t);
-					t->thread_info_addr = 0xdeadbeef;
-				}
+				get_name(target, t);
+				insert_into_threadlist(target, t);
+				t->thread_info_addr = 0xdeadbeef;
+			}
 
-				t->status = 3;
-				ct->threadid = t->threadid;
+			t->status = 3;
+			ct->threadid = t->threadid;
 #ifdef PID_CHECK
-				ct->pid = t->pid;
+			ct->pid = t->pid;
 #endif
-				linux_os->thread_count++;
+			linux_os->thread_count++;
 #if 0
-				if (found == 0)
-					LOG_INFO("current thread core %x identified %s",
-							ct->core_id, t->name);
-				else
-					LOG_INFO("current thread core %x, reused %s",
-							ct->core_id, t->name);
+			if (found == 0)
+				LOG_INFO("current thread core %x identified %s",
+					ct->core_id, t->name);
+			else
+				LOG_INFO("current thread core %x, reused %s",
+					ct->core_id, t->name);
 #endif
-			}
+		}
 #if 0
-			else {
-				struct threads tmp;
-				tmp.base_addr = ct->TS;
-				get_name(target, &tmp);
-				LOG_INFO("current thread core %x , already identified %s !!!",
-						ct->core_id, tmp.name);
-			}
-#endif
-			ct = ct->next;
+		else {
+			struct threads tmp;
+			tmp.base_addr = ct->TS;
+			get_name(target, &tmp);
+			LOG_INFO("current thread core %x , already identified %s !!!",
+				ct->core_id, tmp.name);
 		}
+#endif
+		ct = ct->next;
+	}
 
-		return;
+	return;
 #ifndef PID_CHECK
 error_handling:
-		free(t);
-		LOG_ERROR("unable toread pid");
-		return;
+	free(t);
+	LOG_ERROR("unable toread pid");
+	return;
 
 #endif
-	}
+}
 
 static int linux_task_update(struct target *target, int context)
 {
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	struct threads *thread_list = linux_os->thread_list;
 	int retval;
 	int loop = 0;
@@ -1005,7 +998,6 @@ static int linux_task_update(struct target *target, int context)
 		}
 
 		thread_list = thread_list->next;
-
 	}
 
 	int found = 0;
@@ -1019,7 +1011,7 @@ static int linux_task_update(struct target *target, int context)
 	uint32_t previous = 0xdeadbeef;
 	t->base_addr = linux_os->init_task_addr;
 	retval = get_current(target, 0);
-    /*check that all current threads have been identified  */
+	/*check that all current threads have been identified  */
 	linux_identify_current_threads(target);
 
 	while (((t->base_addr != linux_os->init_task_addr) &&
@@ -1042,20 +1034,14 @@ static int linux_task_update(struct target *target, int context)
 
 		while (thread_list != NULL) {
 #ifdef PID_CHECK
-
 			if (t->pid == thread_list->pid) {
 #else
 			if (t->base_addr == thread_list->base_addr) {
 #endif
-
 				if (!thread_list->status) {
 #ifdef PID_CHECK
-
-					if (t->base_addr !=
-					    thread_list->base_addr) {
-						LOG_INFO
-						    ("thread base_addr has changed !!");
-					}
+					if (t->base_addr != thread_list->base_addr)
+						LOG_INFO("thread base_addr has changed !!");
 #endif
 					/*  this is not a current thread  */
 					thread_list->base_addr = t->base_addr;
@@ -1069,11 +1055,11 @@ static int linux_task_update(struct target *target, int context)
 					*/
 					if (context)
 						thread_list->context =
-						    cpu_context_read(target,
-								     thread_list->
-								     base_addr,
-								     &thread_list->
-								     thread_info_addr);
+							cpu_context_read(target,
+								thread_list->
+								base_addr,
+								&thread_list->
+								thread_info_addr);
 				} else {
 					/*  it is a current thread no need to read context */
 				}
@@ -1096,8 +1082,8 @@ static int linux_task_update(struct target *target, int context)
 
 			if (context)
 				t->context =
-				    cpu_context_read(target, t->base_addr,
-						     &t->thread_info_addr);
+					cpu_context_read(target, t->base_addr,
+						&t->thread_info_addr);
 
 			base_addr = next_task(target, t);
 			t = calloc(1, sizeof(struct threads));
@@ -1105,24 +1091,22 @@ static int linux_task_update(struct target *target, int context)
 			linux_os->thread_count++;
 		} else
 			t->base_addr = next_task(target, t);
-
 	}
 
-	LOG_INFO("update thread done %" PRId64", mean%" PRId64"\n",
-		 (timeval_ms() - start), (timeval_ms() - start) / loop);
+	LOG_INFO("update thread done %" PRId64 ", mean%" PRId64 "\n",
+		(timeval_ms() - start), (timeval_ms() - start) / loop);
 	free(t);
 	linux_os->threads_needs_update = 0;
 	return ERROR_OK;
 }
 
 int linux_gdb_thread_packet(struct target *target,
-			    struct connection *connection, char *packet,
-			    int packet_size)
+	struct connection *connection, char *packet,
+	int packet_size)
 {
-
 	int retval;
 	struct linux_os *linux_os =
-	    (struct linux_os *)target->rtos->rtos_specific_params;
+		(struct linux_os *)target->rtos->rtos_specific_params;
 
 	if (linux_os->init_task_addr == 0xdeadbeef) {
 		/* it has not been initialized */
@@ -1154,12 +1138,12 @@ int linux_gdb_thread_packet(struct target *target,
 }
 
 int linux_gdb_thread_update(struct target *target,
-			    struct connection *connection, char *packet,
-			    int packet_size)
+	struct connection *connection, char *packet,
+	int packet_size)
 {
 	int found = 0;
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	struct threads *temp = linux_os->thread_list;
 
 	while (temp != NULL) {
@@ -1185,14 +1169,14 @@ int linux_gdb_thread_update(struct target *target,
 			/*LOG_INFO("INTO GDB THREAD UPDATE WHILE");*/
 			tmp_strr += sprintf(tmp_strr, ",");
 			tmp_strr +=
-			    sprintf(tmp_strr, "%016" PRIx64, temp->threadid);
+				sprintf(tmp_strr, "%016" PRIx64, temp->threadid);
 			temp = temp->next;
 		}
 
 		/*tmp_str[0] = 0;*/
 		gdb_put_packet(connection, out_strr, strlen(out_strr));
 		linux_os->preupdtate_threadid_count =
-		    linux_os->threadid_count - 1;
+			linux_os->threadid_count - 1;
 		free(out_strr);
 	} else
 		gdb_put_packet(connection, "l", 1);
@@ -1201,12 +1185,12 @@ int linux_gdb_thread_update(struct target *target,
 }
 
 int linux_thread_extra_info(struct target *target,
-			    struct connection *connection, char *packet,
-			    int packet_size)
+	struct connection *connection, char *packet,
+	int packet_size)
 {
 	int64_t threadid = 0;
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid);
 	/*LOG_INFO("lookup extra info for thread %" SCNx64, threadid);*/
 	struct threads *temp = linux_os->thread_list;
@@ -1223,17 +1207,17 @@ int linux_thread_extra_info(struct target *target,
 			/*  discriminate cuurent task */
 			if (temp->status == 3)
 				tmp_str_ptr += sprintf(tmp_str_ptr, "%s",
-						       pid_current);
+						pid_current);
 			else
 				tmp_str_ptr += sprintf(tmp_str_ptr, "%s", pid);
 
 			tmp_str_ptr +=
-			    sprintf(tmp_str_ptr, "%d", (int)temp->pid);
+				sprintf(tmp_str_ptr, "%d", (int)temp->pid);
 			tmp_str_ptr += sprintf(tmp_str_ptr, "%s", " | ");
 			tmp_str_ptr += sprintf(tmp_str_ptr, "%s", name);
 			tmp_str_ptr += sprintf(tmp_str_ptr, "%s", temp->name);
 			char *hex_str =
-			    (char *)calloc(1, strlen(tmp_str) * 2 + 1);
+				(char *)calloc(1, strlen(tmp_str) * 2 + 1);
 			str_to_hex(hex_str, tmp_str);
 			gdb_put_packet(connection, hex_str, strlen(hex_str));
 			free(hex_str);
@@ -1249,11 +1233,11 @@ int linux_thread_extra_info(struct target *target,
 }
 
 int linux_gdb_T_packet(struct connection *connection,
-		       struct target *target, char *packet, int packet_size)
+	struct target *target, char *packet, int packet_size)
 {
 	int64_t threadid;
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	int retval = ERROR_OK;
 	sscanf(packet, "T%" SCNx64, &threadid);
 
@@ -1269,9 +1253,9 @@ int linux_gdb_T_packet(struct connection *connection,
 				} else {
 					/* delete item in the list   */
 					linux_os->thread_list =
-					    liste_del_task(linux_os->
-							   thread_list, &temp,
-							   prev);
+						liste_del_task(linux_os->
+							thread_list, &temp,
+							prev);
 					linux_os->thread_count--;
 					gdb_put_packet(connection, "E01", 3);
 					return ERROR_OK;
@@ -1310,10 +1294,10 @@ int linux_gdb_T_packet(struct connection *connection,
 }
 
 int linux_gdb_h_packet(struct connection *connection,
-		       struct target *target, char *packet, int packet_size)
+	struct target *target, char *packet, int packet_size)
 {
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	struct current_thread *ct = linux_os->current_threads;
 
 	/* select to display the current thread of the selected target */
@@ -1331,8 +1315,8 @@ int linux_gdb_h_packet(struct connection *connection,
 		}
 
 		if (ct == NULL) {
-			/*  no current thread can be identified */
-			/*  any way with smp  */
+			/*  no current thread can be identified
+			 *  any way with smp  */
 			LOG_INFO("no current thread identified");
 			/* attempt to display the name of the 2 threads identified with
 			 * get_current */
@@ -1343,7 +1327,7 @@ int linux_gdb_h_packet(struct connection *connection,
 				t.base_addr = ct->TS;
 				get_name(target, &t);
 				LOG_INFO("name of unidentified thread %s",
-					 t.name);
+					t.name);
 				ct = ct->next;
 			}
 
@@ -1359,14 +1343,14 @@ int linux_gdb_h_packet(struct connection *connection,
 				gdb_put_packet(connection, "OK", 2);
 			} else {
 				target->rtos->current_threadid =
-				    current_gdb_thread_rq;
+					current_gdb_thread_rq;
 				gdb_put_packet(connection, "OK", 2);
 			}
 		} else if (packet[1] == 'c') {
 			sscanf(packet, "Hc%16" SCNx64, &current_gdb_thread_rq);
 
 			if ((current_gdb_thread_rq == 0) ||
-			    (current_gdb_thread_rq == ct->threadid)) {
+					(current_gdb_thread_rq == ct->threadid)) {
 				target->rtos->current_threadid = ct->threadid;
 				gdb_put_packet(connection, "OK", 2);
 			} else
@@ -1379,7 +1363,7 @@ int linux_gdb_h_packet(struct connection *connection,
 }
 
 static int linux_thread_packet(struct connection *connection, char *packet,
-			       int packet_size)
+	int packet_size)
 {
 	int retval = ERROR_OK;
 	struct current_thread *ct;
@@ -1388,92 +1372,89 @@ static int linux_thread_packet(struct connection *connection, char *packet,
 		target->rtos->rtos_specific_params;
 
 	switch (packet[0]) {
-	case 'T':		/* Is thread alive?*/
-
-		linux_gdb_T_packet(connection, target, packet, packet_size);
-		break;
-	case 'H':		/* Set current thread */
-		/*  ( 'c' for step and continue, 'g' for all other operations )*/
-		/*LOG_INFO(" H packet received '%s'", packet);*/
-		linux_gdb_h_packet(connection, target, packet, packet_size);
-		break;
-	case 'q':
-
-		if ((strstr(packet, "qSymbol"))) {
-			if (rtos_qsymbol(connection, packet, packet_size) == 1) {
-				gdb_put_packet(connection, "OK", 2);
-
-				linux_compute_virt2phys(target,
-						target->rtos->
-						symbols[INIT_TASK].
-						address);
-			}
+		case 'T':		/* Is thread alive?*/
 
+			linux_gdb_T_packet(connection, target, packet, packet_size);
 			break;
-		} else if (strstr(packet, "qfThreadInfo")) {
-			if (linux_os->thread_list == NULL) {
-				retval = linux_gdb_thread_packet(target,
-						connection,
-						packet,
+		case 'H':		/* Set current thread */
+			/*  ( 'c' for step and continue, 'g' for all other operations )*/
+			/*LOG_INFO(" H packet received '%s'", packet);*/
+			linux_gdb_h_packet(connection, target, packet, packet_size);
+			break;
+		case 'q':
+
+			if ((strstr(packet, "qSymbol"))) {
+				if (rtos_qsymbol(connection, packet, packet_size) == 1) {
+					gdb_put_packet(connection, "OK", 2);
+
+					linux_compute_virt2phys(target,
+							target->rtos->
+							symbols[INIT_TASK].
+							address);
+				}
+
+				break;
+			} else if (strstr(packet, "qfThreadInfo")) {
+				if (linux_os->thread_list == NULL) {
+					retval = linux_gdb_thread_packet(target,
+							connection,
+							packet,
+							packet_size);
+					break;
+				} else {
+					retval = linux_gdb_thread_update(target,
+							connection,
+							packet,
+							packet_size);
+					break;
+				}
+			} else if (strstr(packet, "qsThreadInfo")) {
+				gdb_put_packet(connection, "l", 1);
+				break;
+			} else if (strstr(packet, "qThreadExtraInfo,")) {
+				linux_thread_extra_info(target, connection, packet,
 						packet_size);
 				break;
 			} else {
-				retval = linux_gdb_thread_update(target,
-						connection,
-						packet,
-						packet_size);
+				retval = GDB_THREAD_PACKET_NOT_CONSUMED;
 				break;
 			}
-		} else if (strstr(packet, "qsThreadInfo")) {
-			gdb_put_packet(connection, "l", 1);
-			break;
-		} else if (strstr(packet, "qThreadExtraInfo,")) {
-			linux_thread_extra_info(target, connection, packet,
-					packet_size);
-			break;
-		} else {
+
+		case 'Q':
+			/* previously response was : thread not found
+			 * gdb_put_packet(connection, "E01", 3); */
 			retval = GDB_THREAD_PACKET_NOT_CONSUMED;
 			break;
-		}
-
-	case 'Q':
-		/* previously response was : thread not found
-		 * gdb_put_packet(connection, "E01", 3); */
-		retval = GDB_THREAD_PACKET_NOT_CONSUMED;
-		break;
-	case 'c':
-	case 's':{
-		if (linux_os->threads_lookup == 1) {
-			ct = linux_os->current_threads;
-
-			while ((ct != NULL)
-					&& (ct->core_id) != target->coreid) {
-				ct = ct->next;
-			}
-
-			if ((ct != NULL) && (ct->threadid == -1)) {
+		case 'c':
+		case 's': {
+			if (linux_os->threads_lookup == 1) {
 				ct = linux_os->current_threads;
 
-				while ((ct != NULL)
-						&& (ct->threadid == -1)) {
+				while ((ct != NULL) && (ct->core_id) != target->coreid)
 					ct = ct->next;
-				}
-			}
 
-			if ((ct != NULL) && (ct->threadid !=
-						target->rtos->
-						current_threadid)
-					&& (target->rtos->current_threadid != -1))
-				LOG_WARNING("WARNING! current GDB thread do not match"\
-						"current thread running."\
-						"Switch thread in GDB to threadid %d", (int)ct->threadid);
+				if ((ct != NULL) && (ct->threadid == -1)) {
+					ct = linux_os->current_threads;
+
+					while ((ct != NULL) && (ct->threadid == -1))
+						ct = ct->next;
+				}
 
-			LOG_INFO("threads_needs_update = 1");
-			linux_os->threads_needs_update = 1;
+				if ((ct != NULL) && (ct->threadid !=
+						 target->rtos->
+						 current_threadid)
+				&& (target->rtos->current_threadid != -1))
+					LOG_WARNING("WARNING! current GDB thread do not match" \
+							"current thread running." \
+							"Switch thread in GDB to threadid %d",
+							(int)ct->threadid);
+
+				LOG_INFO("threads_needs_update = 1");
+				linux_os->threads_needs_update = 1;
+			}
 		}
-	}
 
-		/* if a packet handler returned an error, exit input loop */
+			/* if a packet handler returned an error, exit input loop */
 		if (retval != ERROR_OK)
 			return retval;
 	}
@@ -1487,15 +1468,15 @@ static int linux_os_smp_init(struct target *target)
 	/* keep only target->rtos */
 	struct rtos *rtos = target->rtos;
 	struct linux_os *os_linux =
-	    (struct linux_os *)rtos->rtos_specific_params;
+		(struct linux_os *)rtos->rtos_specific_params;
 	struct current_thread *ct;
 	head = target->head;
 
 	while (head != (struct target_list *)NULL) {
 		if (head->target->rtos != rtos) {
 			struct linux_os *smp_os_linux =
-			    (struct linux_os *)head->target->rtos->
-			    rtos_specific_params;
+				(struct linux_os *)head->target->rtos->
+				rtos_specific_params;
 			/*  remap smp target on rtos  */
 			free(head->target->rtos);
 			head->target->rtos = rtos;
@@ -1505,7 +1486,7 @@ static int linux_os_smp_init(struct target *target)
 			ct->TS = 0xdeadbeef;
 			ct->core_id = head->target->coreid;
 			os_linux->current_threads =
-			    add_current_thread(os_linux->current_threads, ct);
+				add_current_thread(os_linux->current_threads, ct);
 			os_linux->nr_cpus++;
 			free(smp_os_linux);
 		}
@@ -1536,7 +1517,7 @@ static int linux_os_create(struct target *target)
 	ct->threadid = -1;
 	ct->TS = 0xdeadbeef;
 	os_linux->current_threads =
-	    add_current_thread(os_linux->current_threads, ct);
+		add_current_thread(os_linux->current_threads, ct);
 	/*  overload rtos thread default handler */
 	target->rtos->gdb_thread_packet = linux_thread_packet;
 	/*  initialize a default virt 2 phys translation */
@@ -1548,13 +1529,13 @@ static int linux_os_create(struct target *target)
 static char *linux_ps_command(struct target *target)
 {
 	struct linux_os *linux_os = (struct linux_os *)
-	    target->rtos->rtos_specific_params;
+		target->rtos->rtos_specific_params;
 	int retval = ERROR_OK;
 	char *display;
 
-	if (linux_os->threads_lookup == 0) {
+	if (linux_os->threads_lookup == 0)
 		retval = linux_get_tasks(target, 1);
-	} else {
+	else {
 		if (linux_os->threads_needs_update != 0)
 			retval = linux_task_update(target, 0);
 	}
@@ -1563,7 +1544,7 @@ static char *linux_ps_command(struct target *target)
 		struct threads *temp = linux_os->thread_list;
 		char *tmp;
 		LOG_INFO("allocation for %d threads line",
-			 linux_os->thread_count);
+			linux_os->thread_count);
 		display = calloc((linux_os->thread_count + 2) * 80, 1);
 
 		if (!display)
@@ -1577,16 +1558,16 @@ static char *linux_ps_command(struct target *target)
 			if (temp->status) {
 				if (temp->context)
 					tmp +=
-					    sprintf(tmp,
-						    "%d\t\t%d\t\t%x\t\t%s\n",
-						    (int)temp->pid, temp->oncpu,
-						    temp->asid, temp->name);
+						sprintf(tmp,
+							"%d\t\t%d\t\t%x\t\t%s\n",
+							(int)temp->pid, temp->oncpu,
+							temp->asid, temp->name);
 				else
 					tmp +=
-					    sprintf(tmp,
-						    "%d\t\t%d\t\t%x\t\t%s\n",
-						    (int)temp->pid, temp->oncpu,
-						    temp->asid, temp->name);
+						sprintf(tmp,
+							"%d\t\t%d\t\t%x\t\t%s\n",
+							(int)temp->pid, temp->oncpu,
+							temp->asid, temp->name);
 			}
 
 			temp = temp->next;
diff --git a/src/rtos/rtos.c b/src/rtos/rtos.c
index 3deeb68..07e44ea 100644
--- a/src/rtos/rtos.c
+++ b/src/rtos/rtos.c
@@ -22,16 +22,12 @@
 #include "config.h"
 #endif
 
-
 #include "rtos.h"
 #include "target/target.h"
 #include "helper/log.h"
 #include "server/gdb_server.h"
 
-
-
-static void hex_to_str( char* dst, char * hex_src );
-
+static void hex_to_str(char *dst, char *hex_src);
 
 /* RTOSs */
 extern struct rtos_type FreeRTOS_rtos;
@@ -39,8 +35,7 @@ extern struct rtos_type ThreadX_rtos;
 extern struct rtos_type eCos_rtos;
 extern struct rtos_type Linux_os;
 
-static struct rtos_type *rtos_types[] =
-{
+static struct rtos_type *rtos_types[] = {
 	&ThreadX_rtos,
 	&FreeRTOS_rtos,
 	&eCos_rtos,
@@ -57,69 +52,66 @@ int rtos_smp_init(struct target *target)
 	return ERROR_TARGET_INIT_FAILED;
 }
 
-
-int rtos_create(Jim_GetOptInfo *goi, struct target * target)
+int rtos_create(Jim_GetOptInfo *goi, struct target *target)
 {
 	int x;
 	char *cp;
-	if (! goi->isconfigure) {
+	if (!goi->isconfigure) {
 		if (goi->argc != 0) {
 			if (goi->argc != 0) {
 				Jim_WrongNumArgs(goi->interp,
-						goi->argc, goi->argv,
-						"NO PARAMS");
+					goi->argc, goi->argv,
+					"NO PARAMS");
 				return JIM_ERR;
 			}
 
 			Jim_SetResultString(goi->interp,
-					target_type_name(target), -1);
+				target_type_name(target), -1);
 		}
 	}
 
-	if (target->rtos) {
+	if (target->rtos)
 		free((void *)(target->rtos));
-	}
-//			e = Jim_GetOpt_String(goi, &cp, NULL);
-//			target->rtos = strdup(cp);
+						/*			e = Jim_GetOpt_String(goi,
+						 * &cp, NULL); */
+/*			target->rtos = strdup(cp); */
 
 	Jim_GetOpt_String(goi, &cp, NULL);
 	/* now does target type exist */
 
-	if ( 0 == strcmp( cp, "auto") )
-	{
-		// auto detection of RTOS
+	if (0 == strcmp(cp, "auto")) {
+		/* auto detection of RTOS */
 		target->rtos_auto_detect = true;
 		x = 0;
-	}
-	else
-	{
+	} else {
 
-		for (x = 0 ; rtos_types[x] ; x++) {
+		for (x = 0; rtos_types[x]; x++) {
 			if (0 == strcmp(cp, rtos_types[x]->name)) {
 				/* found */
 				break;
 			}
 		}
 		if (rtos_types[x] == NULL) {
-			Jim_SetResultFormatted(goi->interp, "Unknown rtos type %s, try one of ", cp);
-			for (x = 0 ; rtos_types[x] ; x++) {
+			Jim_SetResultFormatted(goi->interp, "Unknown rtos type %s, try one of ",
+				cp);
+			for (x = 0; rtos_types[x]; x++) {
 				if (rtos_types[x + 1]) {
 					Jim_AppendStrings(goi->interp,
-									   Jim_GetResult(goi->interp),
-									   rtos_types[x]->name,
-									   ", ", NULL);
+						Jim_GetResult(goi->interp),
+						rtos_types[x]->name,
+						", ", NULL);
 				} else {
 					Jim_AppendStrings(goi->interp,
-									   Jim_GetResult(goi->interp),
-									   " or ",
-									   rtos_types[x]->name,NULL);
+						Jim_GetResult(goi->interp),
+						" or ",
+						rtos_types[x]->name, NULL);
 				}
 			}
 			return JIM_ERR;
 		}
 	}
 	/* Create it */
-	target->rtos = calloc(1,sizeof(struct rtos));
+	target->rtos = calloc(1, sizeof(struct rtos));
 	target->rtos->type = rtos_types[x];
 	target->rtos->current_threadid = -1;
 	target->rtos->current_thread = 0;
@@ -128,10 +120,8 @@ int rtos_create(Jim_GetOptInfo *goi, struct target * target)
 	/* put default thread handler in linux usecase it is overloaded*/
 	target->rtos->gdb_thread_packet = rtos_thread_packet;
 
-	if ( 0 != strcmp( cp, "auto") )
-	{
-		target->rtos->type->create( target );
-	}
+	if (0 != strcmp(cp, "auto"))
+		target->rtos->type->create(target);
 
 	return JIM_OK;
 }
@@ -140,7 +130,8 @@ int gdb_thread_packet(struct connection *connection, char *packet, int packet_si
 {
 	struct target *target = get_target_from_connection(connection);
 	if (target->rtos == NULL)
-		return rtos_thread_packet(connection, packet, packet_size); /* thread not found*/
+		return rtos_thread_packet(connection, packet, packet_size);	/* thread not
+										 *found*/
 	return target->rtos->gdb_thread_packet(connection, packet, packet_size);
 }
 /* return -1 if no rtos defined, 0 if rtos and symbol to be asked, 1 if all
@@ -171,8 +162,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
 
 			hex_to_str(name_str, hex_name_str);
 			symbol_num = 0;
-			while ((target->rtos->symbols[symbol_num].symbol_name != NULL)
-					&& (0 != strcmp(target->rtos->symbols[symbol_num].symbol_name, name_str)))
+			while ((target->rtos->symbols[symbol_num].symbol_name != NULL) &&
+					(0 != strcmp(target->rtos->symbols[symbol_num].symbol_name, name_str)))
 				symbol_num++;
 
 			if (target->rtos->symbols[symbol_num].symbol_name == NULL) {
@@ -194,7 +185,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
 					(1 == target->rtos->type->detect_rtos(target))) {
 				/* Found correct RTOS or not autodetecting */
 				if (target->rtos_auto_detect == true)
-					LOG_OUTPUT("Auto-detected RTOS: %s\r\n", target->rtos->type->name);
+					LOG_OUTPUT("Auto-detected RTOS: %s\r\n",
+						target->rtos->type->name);
 				symbols_done = 1;
 			} else {
 				/* Auto detecting RTOS and currently not found */
@@ -203,7 +195,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
 					symbols_done = 1;
 				else {
 					next_symbol_num = 0;
-					target->rtos->type->get_symbol_list_to_lookup(&target->rtos->symbols);
+					target->rtos->type->get_symbol_list_to_lookup(
+						&target->rtos->symbols);
 				}
 			}
 		}
@@ -225,82 +218,63 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
 	return -1;
 }
 
-
 int rtos_thread_packet(struct connection *connection, char *packet, int packet_size)
 {
 	struct target *target = get_target_from_connection(connection);
 
-	if (strstr(packet, "qThreadExtraInfo,"))
-	{
-		if ((target->rtos != NULL) && (target->rtos->thread_details != NULL) && (target->rtos->thread_count != 0))
-		{
+	if (strstr(packet, "qThreadExtraInfo,")) {
+		if ((target->rtos != NULL) && (target->rtos->thread_details != NULL) &&
+				(target->rtos->thread_count != 0)) {
 			threadid_t threadid = 0;
 			int found = -1;
-			sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid );
+			sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid);
 
-			if ((target->rtos != NULL) && (target->rtos->thread_details
-					!= NULL)) {
+			if ((target->rtos != NULL) && (target->rtos->thread_details != NULL)) {
 				int thread_num;
-				for (thread_num = 0; thread_num
-						< target->rtos->thread_count; thread_num++) {
-					if (target->rtos->thread_details[thread_num].threadid
-							== threadid) {
-						if (target->rtos->thread_details[thread_num].exists) {
+				for (thread_num = 0; thread_num < target->rtos->thread_count; thread_num++) {
+					if (target->rtos->thread_details[thread_num].threadid == threadid) {
+						if (target->rtos->thread_details[thread_num].exists)
 							found = thread_num;
-						}
 					}
 				}
 			}
 			if (found == -1) {
-				gdb_put_packet(connection, "E01", 3); // thread not found
+				gdb_put_packet(connection, "E01", 3);	/* thread not found */
 				return ERROR_OK;
 			}
 
-			struct thread_detail* detail = &target->rtos->thread_details[found];
+			struct thread_detail *detail = &target->rtos->thread_details[found];
 
 			int str_size = 0;
-			if ( detail->display_str != NULL )
-			{
+			if (detail->display_str != NULL)
 				str_size += strlen(detail->display_str);
-			}
-			if ( detail->thread_name_str != NULL )
-			{
+			if (detail->thread_name_str != NULL)
 				str_size += strlen(detail->thread_name_str);
-			}
-			if ( detail->extra_info_str != NULL )
-			{
+			if (detail->extra_info_str != NULL)
 				str_size += strlen(detail->extra_info_str);
-			}
 
-			char * tmp_str = (char*) malloc( str_size + 7 );
-			char*  tmp_str_ptr = tmp_str;
+			char *tmp_str = (char *) malloc(str_size + 7);
+			char *tmp_str_ptr = tmp_str;
 
-			if ( detail->display_str != NULL )
-			{
-				tmp_str_ptr += sprintf( tmp_str_ptr, "%s", detail->display_str );
-			}
-			if ( detail->thread_name_str != NULL )
-			{
-				if ( tmp_str_ptr != tmp_str )
-				{
-					tmp_str_ptr += sprintf( tmp_str_ptr, " : " );
-				}
-				tmp_str_ptr += sprintf( tmp_str_ptr, "%s", detail->thread_name_str );
+			if (detail->display_str != NULL)
+				tmp_str_ptr += sprintf(tmp_str_ptr, "%s", detail->display_str);
+			if (detail->thread_name_str != NULL) {
+				if (tmp_str_ptr != tmp_str)
+					tmp_str_ptr += sprintf(tmp_str_ptr, " : ");
+				tmp_str_ptr += sprintf(tmp_str_ptr, "%s", detail->thread_name_str);
 			}
-			if ( detail->extra_info_str != NULL )
-			{
-				if ( tmp_str_ptr != tmp_str )
-				{
-					tmp_str_ptr += sprintf( tmp_str_ptr, " : " );
-				}
-				tmp_str_ptr += sprintf( tmp_str_ptr, " : %s", detail->extra_info_str );
+			if (detail->extra_info_str != NULL) {
+				if (tmp_str_ptr != tmp_str)
+					tmp_str_ptr += sprintf(tmp_str_ptr, " : ");
+				tmp_str_ptr +=
+					sprintf(tmp_str_ptr, " : %s", detail->extra_info_str);
 			}
 
 			assert(strlen(tmp_str) ==
 				(size_t) (tmp_str_ptr - tmp_str));
 
-			char * hex_str = (char*) malloc( strlen(tmp_str)*2 +1 );
-			str_to_hex( hex_str, tmp_str );
+			char *hex_str = (char *) malloc(strlen(tmp_str)*2 + 1);
+			str_to_hex(hex_str, tmp_str);
 
 			gdb_put_packet(connection, hex_str, strlen(hex_str));
 			free(hex_str);
@@ -310,11 +284,8 @@ int rtos_thread_packet(struct connection *connection, char *packet, int packet_s
 		}
 		gdb_put_packet(connection, "", 0);
 		return ERROR_OK;
-	}
-	else if (strstr(packet, "qSymbol"))
-	{
-		if (rtos_qsymbol(connection, packet, packet_size) == 1)
-		{
+	} else if (strstr(packet, "qSymbol")) {
+		if (rtos_qsymbol(connection, packet, packet_size) == 1) {
 			target->rtos_auto_detect = false;
 			target->rtos->type->create(target);
 			target->rtos->type->update_threads(target->rtos);
@@ -322,91 +293,64 @@ int rtos_thread_packet(struct connection *connection, char *packet, int packet_s
 			gdb_put_packet(connection, "OK", 2);
 		}
 		return ERROR_OK;
-	}
-	else if (strstr(packet, "qfThreadInfo"))
-	{
+	} else if (strstr(packet, "qfThreadInfo")) {
 		int i;
-		if ( ( target->rtos != NULL ) && ( target->rtos->thread_count != 0 ) )
-		{
+		if ((target->rtos != NULL) && (target->rtos->thread_count != 0)) {
 
-			char* out_str = (char*) malloc(17 * target->rtos->thread_count + 5);
-			char* tmp_str = out_str;
+			char *out_str = (char *) malloc(17 * target->rtos->thread_count + 5);
+			char *tmp_str = out_str;
 			tmp_str += sprintf(tmp_str, "m");
 			for (i = 0; i < target->rtos->thread_count; i++) {
-				if (i != 0) {
+				if (i != 0)
 					tmp_str += sprintf(tmp_str, ",");
-				}
 				tmp_str += sprintf(tmp_str, "%016" PRIx64,
 						target->rtos->thread_details[i].threadid);
 			}
 			tmp_str[0] = 0;
 			gdb_put_packet(connection, out_str, strlen(out_str));
-		}
-		else
-		{
+		} else
 			gdb_put_packet(connection, "", 0);
-		}
 
 		return ERROR_OK;
-	}
-	else if (strstr(packet, "qsThreadInfo"))
-	{
+	} else if (strstr(packet, "qsThreadInfo")) {
 		gdb_put_packet(connection, "l", 1);
 		return ERROR_OK;
-	}
-	else if (strstr(packet, "qAttached"))
-	{
+	} else if (strstr(packet, "qAttached")) {
 		gdb_put_packet(connection, "1", 1);
 		return ERROR_OK;
-	}
-	else if (strstr(packet, "qOffsets"))
-	{
+	} else if (strstr(packet, "qOffsets")) {
 		char offsets[] = "Text=0;Data=0;Bss=0";
 		gdb_put_packet(connection, offsets, sizeof(offsets)-1);
 		return ERROR_OK;
-	}
-	else if (strstr(packet, "qC"))
-	{
-		if( target->rtos!=NULL )
-		{
+	} else if (strstr(packet, "qC")) {
+		if (target->rtos != NULL) {
 			char buffer[15];
 			int size;
 			size = snprintf(buffer, 15, "QC%08X", (int)target->rtos->current_thread);
 			gdb_put_packet(connection, buffer, size);
-		}
-		else
-		{
+		} else
 			gdb_put_packet(connection, "QC0", 3);
-		}
 		return ERROR_OK;
-	}
-	else if ( packet[0] == 'T' ) // Is thread alive?
-	{
+	} else if (packet[0] == 'T') {	/* Is thread alive? */
 		threadid_t threadid;
 		int found = -1;
 		sscanf(packet, "T%" SCNx64, &threadid);
-		if ((target->rtos != NULL) && (target->rtos->thread_details
-				!= NULL)) {
+		if ((target->rtos != NULL) && (target->rtos->thread_details != NULL)) {
 			int thread_num;
-			for (thread_num = 0; thread_num
-					< target->rtos->thread_count; thread_num++) {
-				if (target->rtos->thread_details[thread_num].threadid
-						== threadid) {
-					if (target->rtos->thread_details[thread_num].exists) {
+			for (thread_num = 0; thread_num < target->rtos->thread_count; thread_num++) {
+				if (target->rtos->thread_details[thread_num].threadid == threadid) {
+					if (target->rtos->thread_details[thread_num].exists)
 						found = thread_num;
-					}
 				}
 			}
 		}
-		if (found != -1) {
-			gdb_put_packet(connection, "OK", 2); // thread alive
-		} else {
-			gdb_put_packet(connection, "E01", 3); // thread not found
-		}
+		if (found != -1)
+			gdb_put_packet(connection, "OK", 2);	/* thread alive */
+		else
+			gdb_put_packet(connection, "E01", 3);	/* thread not found */
 		return ERROR_OK;
-	}
-	else if ( packet[0] == 'H') // Set current thread ( 'c' for step and continue, 'g' for all other operations )
-	{
+	} else if (packet[0] == 'H') {	/* Set current thread ( 'c' for step and continue, 'g' for
+					 * all other operations ) */
 		if ((packet[1] == 'g') && (target->rtos != NULL))
 			sscanf(packet, "Hg%16" SCNx64, &target->rtos->current_threadid);
 		gdb_put_packet(connection, "OK", 2);
@@ -420,17 +364,16 @@ int rtos_get_gdb_reg_list(struct connection *connection)
 {
 	struct target *target = get_target_from_connection(connection);
 	int64_t current_threadid = target->rtos->current_threadid;
-	if ((target->rtos != NULL) &&
-		 (current_threadid != -1) &&
-		 (current_threadid != 0) &&
-		 ((current_threadid != target->rtos->current_thread) ||
-		 (target->smp))) /* in smp several current thread are possible */
-	{
-		char * hex_reg_list;
-		target->rtos->type->get_thread_reg_list( target->rtos, current_threadid, &hex_reg_list );
-
-		if ( hex_reg_list != NULL )
-		{
+	if ((target->rtos != NULL) && (current_threadid != -1) &&
+			(current_threadid != 0) &&
+			((current_threadid != target->rtos->current_thread) ||
+			(target->smp))) {	/* in smp several current thread are possible */
+		char *hex_reg_list;
+		target->rtos->type->get_thread_reg_list(target->rtos,
+			current_threadid,
+			&hex_reg_list);
+
+		if (hex_reg_list != NULL) {
 			gdb_put_packet(connection, hex_reg_list, strlen(hex_reg_list));
 			free(hex_reg_list);
 			return ERROR_OK;
@@ -439,103 +382,84 @@ int rtos_get_gdb_reg_list(struct connection *connection)
 	return ERROR_FAIL;
 }
 
-
-
-int rtos_generic_stack_read( struct target * target, const struct rtos_register_stacking* stacking, int64_t stack_ptr, char ** hex_reg_list )
+int rtos_generic_stack_read(struct target *target,
+	const struct rtos_register_stacking *stacking,
+	int64_t stack_ptr,
+	char **hex_reg_list)
 {
 	int list_size = 0;
-	char * tmp_str_ptr;
+	char *tmp_str_ptr;
 	int64_t new_stack_ptr;
 	int i;
 	int retval;
 
-	if ( stack_ptr == 0)
-	{
+	if (stack_ptr == 0) {
 		LOG_OUTPUT("Error: null stack pointer in thread\r\n");
 		return -5;
 	}
-	// Read the stack
-	uint8_t * stack_data = (uint8_t*) malloc( stacking->stack_registers_size );
+	/* Read the stack */
+	uint8_t *stack_data = (uint8_t *) malloc(stacking->stack_registers_size);
 	uint32_t address = stack_ptr;
 
-	if ( stacking->stack_growth_direction == 1 )
-	{
-		address -=  stacking->stack_registers_size;
-	}
-	retval = target_read_buffer( target, address, stacking->stack_registers_size, stack_data);
-	if ( retval != ERROR_OK )
-	{
+	if (stacking->stack_growth_direction == 1)
+		address -= stacking->stack_registers_size;
+	retval = target_read_buffer(target, address, stacking->stack_registers_size, stack_data);
+	if (retval != ERROR_OK) {
 		LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
 		return retval;
 	}
-/*
-	LOG_OUTPUT("Stack Data :");
-	for(i = 0; i < stacking->stack_registers_size; i++ )
-	{
-		LOG_OUTPUT("%02X",stack_data[i]);
-	}
-	LOG_OUTPUT("\r\n");
-*/
-	for( i = 0; i < stacking->num_output_registers; i++ )
-	{
+#if 0
+		LOG_OUTPUT("Stack Data :");
+		for (i = 0; i < stacking->stack_registers_size; i++)
+			LOG_OUTPUT("%02X", stack_data[i]);
+		LOG_OUTPUT("\r\n");
+#endif
+	for (i = 0; i < stacking->num_output_registers; i++)
 		list_size += stacking->register_offsets[i].width_bits/8;
-	}
-	*hex_reg_list = (char*)malloc( list_size*2 +1 );
+	*hex_reg_list = (char *)malloc(list_size*2 + 1);
 	tmp_str_ptr = *hex_reg_list;
-	new_stack_ptr = stack_ptr - stacking->stack_growth_direction * stacking->stack_registers_size;
+	new_stack_ptr = stack_ptr - stacking->stack_growth_direction *
+		stacking->stack_registers_size;
 	if (stacking->stack_alignment != 0) {
 		/* Align new stack pointer to x byte boundary */
 		new_stack_ptr =
 			(new_stack_ptr & (~((int64_t) stacking->stack_alignment - 1))) +
 			((stacking->stack_growth_direction == -1) ? stacking->stack_alignment : 0);
 	}
-	for( i = 0; i < stacking->num_output_registers; i++ )
-	{
+	for (i = 0; i < stacking->num_output_registers; i++) {
 		int j;
-		for ( j = 0; j < stacking->register_offsets[i].width_bits/8; j++ )
-		{
-			if ( stacking->register_offsets[i].offset == -1 )
-			{
-				tmp_str_ptr += sprintf( tmp_str_ptr, "%02x", 0 );
-			}
-			else if ( stacking->register_offsets[i].offset == -2 )
-			{
-				tmp_str_ptr += sprintf( tmp_str_ptr, "%02x", ((uint8_t*)&new_stack_ptr)[j] );
-			}
+		for (j = 0; j < stacking->register_offsets[i].width_bits/8; j++) {
+			if (stacking->register_offsets[i].offset == -1)
+				tmp_str_ptr += sprintf(tmp_str_ptr, "%02x", 0);
+			else if (stacking->register_offsets[i].offset == -2)
+				tmp_str_ptr += sprintf(tmp_str_ptr, "%02x",
+						((uint8_t *)&new_stack_ptr)[j]);
 			else
-			{
-				tmp_str_ptr += sprintf( tmp_str_ptr,"%02x", stack_data[ stacking->register_offsets[i].offset + j ] );
-			}
+				tmp_str_ptr += sprintf(tmp_str_ptr, "%02x",
+						stack_data[stacking->register_offsets[i].offset + j]);
 		}
 	}
-//	LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list);
+/*	LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list); */
 	return ERROR_OK;
 }
 
-int rtos_try_next( struct target * target )
+int rtos_try_next(struct target *target)
 {
 	int x;
 
-	if ( target->rtos == NULL )
-	{
+	if (target->rtos == NULL)
 		return -1;
-	}
 
-	for (x = 0 ; rtos_types[x] ; x++) {
-		if (target->rtos->type == rtos_types[x] ) {
+	for (x = 0; rtos_types[x]; x++) {
+		if (target->rtos->type == rtos_types[x]) {
 			/* found */
-			if ( rtos_types[x+1] != NULL )
-			{
+			if (rtos_types[x+1] != NULL) {
 				target->rtos->type = rtos_types[x+1];
-				if ( target->rtos->symbols != NULL )
-				{
-					free( target->rtos->symbols );
-				}
+				if (target->rtos->symbols != NULL)
+					free(target->rtos->symbols);
 				return 1;
-			}
-			else
-			{
-				// No more rtos types
+			} else {
+				/* No more rtos types */
 				return 0;
 			}
 
@@ -545,24 +469,23 @@ int rtos_try_next( struct target * target )
 
 }
 
-static void hex_to_str( char* dst, char * hex_src )
+static void hex_to_str(char *dst, char *hex_src)
 {
 	int src_pos = 0;
 	int dst_pos = 0;
 
-	while ( hex_src[src_pos] != '\x00' )
-	{
+	while (hex_src[src_pos] != '\x00') {
 		char hex_char = hex_src[src_pos];
-		char hex_digit_val = (hex_char>='a')?hex_char-'a'+10:(hex_char>='A')?hex_char-'A'+10:hex_char-'0';
-		if ( 0 == (src_pos & 0x01) )
-		{
+		char hex_digit_val =
+			(hex_char >=
+			 'a') ? hex_char-'a'+
+			10 : (hex_char >= 'A') ? hex_char-'A'+10 : hex_char-'0';
+		if (0 == (src_pos & 0x01)) {
 			dst[dst_pos] = hex_digit_val;
 			dst[dst_pos+1] = 0;
-		}
-		else
-		{
-			((unsigned char*)dst)[dst_pos] <<= 4;
-			((unsigned char*)dst)[dst_pos] += hex_digit_val;
+		} else {
+			((unsigned char *)dst)[dst_pos] <<= 4;
+			((unsigned char *)dst)[dst_pos] += hex_digit_val;
 			dst_pos++;
 		}
 		src_pos++;
@@ -572,21 +495,16 @@ static void hex_to_str( char* dst, char * hex_src )
 
 int str_to_hex(char *hex_dst, char *src)
 {
-	char * posptr = hex_dst;
+	char *posptr = hex_dst;
 	unsigned i;
-	for( i = 0; i < strlen(src); i++)
-	{
-		posptr += sprintf( posptr, "%02x", (unsigned char)src[i] );
-	}
-	return (posptr-hex_dst);
+	for (i = 0; i < strlen(src); i++)
+		posptr += sprintf(posptr, "%02x", (unsigned char)src[i]);
+	return posptr - hex_dst;
 }
 
-
-int rtos_update_threads( struct target* target )
+int rtos_update_threads(struct target *target)
 {
 	if ((target->rtos != NULL) && (target->rtos->type != NULL))
-	{
 		target->rtos->type->update_threads(target->rtos);
-	}
 	return ERROR_OK;
 }
diff --git a/src/rtos/rtos.h b/src/rtos/rtos.h
index 80ba0e2..a93daee 100644
--- a/src/rtos/rtos.h
+++ b/src/rtos/rtos.h
@@ -21,7 +21,6 @@
 #ifndef RTOS_H
 #define RTOS_H
 
-
 #include "server/server.h"
 #include <helper/types.h>
 #include <jim-nvp.h>
@@ -34,83 +33,75 @@ struct reg;
 /**
  * Table should be terminated by an element with NULL in symbol_name
  */
-typedef struct symbol_table_elem_struct
-{
-	char * symbol_name;
+typedef struct symbol_table_elem_struct {
+	char *symbol_name;
 	symbol_address_t address;
 
 } symbol_table_elem_t;
 
-struct thread_detail
-{
+struct thread_detail {
 	threadid_t threadid;
 	bool exists;
-	char * display_str;
-	char * thread_name_str;
-	char * extra_info_str;
+	char *display_str;
+	char *thread_name_str;
+	char *extra_info_str;
 };
 
-struct rtos
-{
+struct rtos {
 	const struct rtos_type *type;
 
-
-	symbol_table_elem_t * symbols;
+	symbol_table_elem_t *symbols;
 	struct target *target;
 	/*  add a context variable instead of global variable */
 	int64_t current_threadid;
 	threadid_t current_thread;
-	struct thread_detail* thread_details;
+	struct thread_detail *thread_details;
 	int thread_count;
 	int (*gdb_thread_packet)(struct connection *connection, char *packet, int packet_size);
-	void * rtos_specific_params;
-
-
+	void *rtos_specific_params;
 };
 
-
-
-struct rtos_type
-{
-	char * name;
-	int (*detect_rtos)                 ( struct target* target );
-	int (*create)                      ( struct target* target );
+struct rtos_type {
+	char *name;
+	int (*detect_rtos)(struct target *target);
+	int (*create)(struct target *target);
 	int (*smp_init)(struct target *target);
-	int (*update_threads)              ( struct rtos*   rtos );
-	int (*get_thread_reg_list)         ( struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
-	int (*get_symbol_list_to_lookup)   (symbol_table_elem_t * symbol_list[] );
+	int (*update_threads)(struct rtos *rtos);
+	int (*get_thread_reg_list)(struct rtos *rtos, int64_t thread_id, char **hex_reg_list);
+	int (*get_symbol_list_to_lookup)(symbol_table_elem_t *symbol_list[]);
 	int (*clean)(struct target *target);
 	char * (*ps_command)(struct target *target);
 };
 
-
-struct stack_register_offset
-{
-	signed short   offset;       // offset in bytes from stack head, or -1 to indicate register is not stacked, or -2 to indicate this is the stack pointer register
+struct stack_register_offset {
+	signed short offset;		/* offset in bytes from stack head, or -1 to indicate
+					 * register is not stacked, or -2 to indicate this is the
+					 * stack pointer register */
 	unsigned short width_bits;
-
 };
 
-struct rtos_register_stacking
-{
-	unsigned char                       stack_registers_size;
-	signed   char                       stack_growth_direction;
-	unsigned char                       num_output_registers;
-	unsigned char                       stack_alignment;
-	const struct stack_register_offset* register_offsets;
+struct rtos_register_stacking {
+	unsigned char stack_registers_size;
+	signed char stack_growth_direction;
+	unsigned char num_output_registers;
+	unsigned char stack_alignment;
+	const struct stack_register_offset *register_offsets;
 };
 
 #define GDB_THREAD_PACKET_NOT_CONSUMED (-40)
 
-int rtos_create(Jim_GetOptInfo *goi, struct target * target);
-int rtos_generic_stack_read( struct target * target, const struct rtos_register_stacking* stacking, int64_t stack_ptr, char ** hex_reg_list );
-int rtos_try_next( struct target * target );
+int rtos_create(Jim_GetOptInfo *goi, struct target *target);
+int rtos_generic_stack_read(struct target *target,
+		const struct rtos_register_stacking *stacking,
+		int64_t stack_ptr,
+		char **hex_reg_list);
+int rtos_try_next(struct target *target);
 int gdb_thread_packet(struct connection *connection, char *packet, int packet_size);
 int rtos_get_gdb_reg_list(struct connection *connection);
-int rtos_update_threads( struct target *target );
+int rtos_update_threads(struct target *target);
 int rtos_smp_init(struct target *target);
 /*  function for handling symbol access */
 int rtos_qsymbol(struct connection *connection, char *packet, int packet_size);
 int str_to_hex(char *hex_dst, char *src);
 
-#endif // RTOS_H
+#endif	/* RTOS_H */
diff --git a/src/rtos/rtos_ecos_stackings.c b/src/rtos/rtos_ecos_stackings.c
index 995c113..4f9c405 100644
--- a/src/rtos/rtos_ecos_stackings.c
+++ b/src/rtos/rtos_ecos_stackings.c
@@ -23,42 +23,38 @@
 #include "rtos.h"
 
 static const struct stack_register_offset rtos_eCos_Cortex_M3_stack_offsets[] = {
-	{ 0x0c, 32 },       /* r0   */
-	{ 0x10, 32 },       /* r1   */
-	{ 0x14, 32 },       /* r2   */
-	{ 0x18, 32 },       /* r3   */
-	{ 0x1c, 32 },       /* r4   */
-	{ 0x20, 32 },       /* r5   */
-	{ 0x24, 32 },       /* r6   */
-	{ 0x28, 32 },       /* r7   */
-	{ 0x2c, 32 },       /* r8   */
-	{ 0x30, 32 },       /* r9   */
-	{ 0x34, 32 },       /* r10  */
-	{ 0x38, 32 },       /* r11  */
-	{ 0x3c, 32 },       /* r12  */
-	{ -2,   32 },       /* sp   */
-	{ -1,   32 },       /* lr   */
-	{ 0x40, 32 },       /* pc   */
-	{ -1,   96 },       /* FPA1 */
-	{ -1,   96 },       /* FPA2 */
-	{ -1,   96 },       /* FPA3 */
-	{ -1,   96 },       /* FPA4 */
-	{ -1,   96 },       /* FPA5 */
-	{ -1,   96 },       /* FPA6 */
-	{ -1,   96 },       /* FPA7 */
-	{ -1,   96 },       /* FPA8 */
-	{ -1,   32 },       /* FPS  */
-	{ -1,   32 },       /* xPSR */
+	{ 0x0c, 32 },		/* r0   */
+	{ 0x10, 32 },		/* r1   */
+	{ 0x14, 32 },		/* r2   */
+	{ 0x18, 32 },		/* r3   */
+	{ 0x1c, 32 },		/* r4   */
+	{ 0x20, 32 },		/* r5   */
+	{ 0x24, 32 },		/* r6   */
+	{ 0x28, 32 },		/* r7   */
+	{ 0x2c, 32 },		/* r8   */
+	{ 0x30, 32 },		/* r9   */
+	{ 0x34, 32 },		/* r10  */
+	{ 0x38, 32 },		/* r11  */
+	{ 0x3c, 32 },		/* r12  */
+	{ -2,   32 },		/* sp   */
+	{ -1,   32 },		/* lr   */
+	{ 0x40, 32 },		/* pc   */
+	{ -1,   96 },		/* FPA1 */
+	{ -1,   96 },		/* FPA2 */
+	{ -1,   96 },		/* FPA3 */
+	{ -1,   96 },		/* FPA4 */
+	{ -1,   96 },		/* FPA5 */
+	{ -1,   96 },		/* FPA6 */
+	{ -1,   96 },		/* FPA7 */
+	{ -1,   96 },		/* FPA8 */
+	{ -1,   32 },		/* FPS  */
+	{ -1,   32 },		/* xPSR */
 };
 
-
-const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking =
-{
-	0x44,                                 /* stack_registers_size */
-	-1,                                   /* stack_growth_direction */
-	26,                                   /* num_output_registers */
-	8,                                    /* stack_alignment */
-	rtos_eCos_Cortex_M3_stack_offsets     /* register_offsets */
+const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking = {
+	0x44,					/* stack_registers_size */
+	-1,					/* stack_growth_direction */
+	26,					/* num_output_registers */
+	8,					/* stack_alignment */
+	rtos_eCos_Cortex_M3_stack_offsets	/* register_offsets */
 };
-
-
diff --git a/src/rtos/rtos_ecos_stackings.h b/src/rtos/rtos_ecos_stackings.h
index 82f0855..034251c 100644
--- a/src/rtos/rtos_ecos_stackings.h
+++ b/src/rtos/rtos_ecos_stackings.h
@@ -27,4 +27,4 @@
 
 extern const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking;
 
-#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_
+#endif	/* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */
diff --git a/src/rtos/rtos_standard_stackings.c b/src/rtos/rtos_standard_stackings.c
index 278d3ef..30d9cd9 100644
--- a/src/rtos/rtos_standard_stackings.c
+++ b/src/rtos/rtos_standard_stackings.c
@@ -25,42 +25,38 @@
 #include "rtos.h"
 
 static const struct stack_register_offset rtos_standard_Cortex_M3_stack_offsets[] = {
-	{ 0x20, 32 },       /* r0   */
-	{ 0x24, 32 },       /* r1   */
-	{ 0x28, 32 },       /* r2   */
-	{ 0x2c, 32 },       /* r3   */
-	{ 0x00, 32 },       /* r4   */
-	{ 0x04, 32 },       /* r5   */
-	{ 0x08, 32 },       /* r6   */
-	{ 0x0c, 32 },       /* r7   */
-	{ 0x10, 32 },       /* r8   */
-	{ 0x14, 32 },       /* r9   */
-	{ 0x18, 32 },       /* r10  */
-	{ 0x1c, 32 },       /* r11  */
-	{ 0x30, 32 },       /* r12  */
-	{ -2,   32 },       /* sp   */
-	{ 0x34, 32 },       /* lr   */
-	{ 0x38, 32 },       /* pc   */
-	{ -1,   96 },       /* FPA1 */
-	{ -1,   96 },       /* FPA2 */
-	{ -1,   96 },       /* FPA3 */
-	{ -1,   96 },       /* FPA4 */
-	{ -1,   96 },       /* FPA5 */
-	{ -1,   96 },       /* FPA6 */
-	{ -1,   96 },       /* FPA7 */
-	{ -1,   96 },       /* FPA8 */
-	{ -1,   32 },       /* FPS  */
-	{ 0x3c, 32 },       /* xPSR */
+	{ 0x20, 32 },		/* r0   */
+	{ 0x24, 32 },		/* r1   */
+	{ 0x28, 32 },		/* r2   */
+	{ 0x2c, 32 },		/* r3   */
+	{ 0x00, 32 },		/* r4   */
+	{ 0x04, 32 },		/* r5   */
+	{ 0x08, 32 },		/* r6   */
+	{ 0x0c, 32 },		/* r7   */
+	{ 0x10, 32 },		/* r8   */
+	{ 0x14, 32 },		/* r9   */
+	{ 0x18, 32 },		/* r10  */
+	{ 0x1c, 32 },		/* r11  */
+	{ 0x30, 32 },		/* r12  */
+	{ -2,   32 },		/* sp   */
+	{ 0x34, 32 },		/* lr   */
+	{ 0x38, 32 },		/* pc   */
+	{ -1,   96 },		/* FPA1 */
+	{ -1,   96 },		/* FPA2 */
+	{ -1,   96 },		/* FPA3 */
+	{ -1,   96 },		/* FPA4 */
+	{ -1,   96 },		/* FPA5 */
+	{ -1,   96 },		/* FPA6 */
+	{ -1,   96 },		/* FPA7 */
+	{ -1,   96 },		/* FPA8 */
+	{ -1,   32 },		/* FPS  */
+	{ 0x3c, 32 },		/* xPSR */
 };
 
-
-const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking =
-{
-	0x40,                                 /* stack_registers_size */
-	-1,                                   /* stack_growth_direction */
-	26,                                   /* num_output_registers */
-	8,                                    /* stack_alignment */
-	rtos_standard_Cortex_M3_stack_offsets /* register_offsets */
+const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking = {
+	0x40,					/* stack_registers_size */
+	-1,					/* stack_growth_direction */
+	26,					/* num_output_registers */
+	8,					/* stack_alignment */
+	rtos_standard_Cortex_M3_stack_offsets	/* register_offsets */
 };
-
-
diff --git a/src/rtos/rtos_standard_stackings.h b/src/rtos/rtos_standard_stackings.h
index 1e8568c..9f26b8e 100644
--- a/src/rtos/rtos_standard_stackings.h
+++ b/src/rtos/rtos_standard_stackings.h
@@ -29,4 +29,4 @@
 
 extern const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking;
 
-#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_
+#endif	/* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */