X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Frtos%2Flinux.c;h=84b4c6524d8abfd1e374fcf7001997cb05fc8326;hb=1e07079dee083255eb84fdebdfd4ed4c30e82812;hp=e0f71ef46c83ca60170874d68adbdfe975216522;hpb=a84d237acfa06ed2e40d5db807ff1a1a7d28cd8d;p=fw%2Fopenocd

diff --git a/src/rtos/linux.c b/src/rtos/linux.c
index e0f71ef46..84b4c6524 100644
--- a/src/rtos/linux.c
+++ b/src/rtos/linux.c
@@ -14,9 +14,7 @@
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -40,7 +38,7 @@
 #define MAX_THREADS 200
 /*  specific task  */
 struct linux_os {
-	char *name;
+	const char *name;
 	uint32_t init_task_addr;
 	int thread_count;
 	int threadid_count;
@@ -94,7 +92,7 @@ struct cpu_context {
 	uint32_t PC;
 	uint32_t preempt_count;
 };
-struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
+static struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
 				     uint32_t *info_addr);
 static int insert_into_threadlist(struct target *target, struct threads *t);
 
@@ -107,11 +105,11 @@ static int linux_os_dummy_update(struct rtos *rtos)
 	return 0;
 }
 
-static int linux_compute_virt2phys(struct target *target, uint32_t address)
+static int linux_compute_virt2phys(struct target *target, target_addr_t address)
 {
 	struct linux_os *linux_os = (struct linux_os *)
 		target->rtos->rtos_specific_params;
-	uint32_t pa = 0;
+	target_addr_t pa = 0;
 	int retval = target->type->virt2phys(target, address, &pa);
 	if (retval != ERROR_OK) {
 		LOG_ERROR("Cannot compute linux virt2phys translation");
@@ -140,34 +138,24 @@ static int linux_read_memory(struct target *target,
 		return ERROR_FAIL;
 	}
 #ifdef PHYS
-	target->type->read_phys_memory(target, pa, size, count, buffer);
+	target_read_phys_memory(target, pa, size, count, buffer);
 #endif
-	target->type->read_memory(target, address, size, count, buffer);
+	target_read_memory(target, address, size, count, buffer);
 	return ERROR_OK;
 }
 
-static char *reg_converter(char *buffer, void *reg, int size)
-{
-	int i;
-
-	for (i = 0; i < size; i++)
-		buffer += sprintf(buffer, "%02x", ((uint8_t *) reg)[i]);
-
-	return buffer;
-}
-
-int fill_buffer(struct target *target, uint32_t addr, uint8_t *buffer)
+static int fill_buffer(struct target *target, uint32_t addr, uint8_t *buffer)
 {
 
 	if ((addr & 0xfffffffc) != addr)
-		LOG_INFO("unaligned address %x!!", addr);
+		LOG_INFO("unaligned address %" PRIx32 "!!", addr);
 
 	int retval = linux_read_memory(target, addr, 4, 1, buffer);
 	return retval;
 
 }
 
-uint32_t get_buffer(struct target *target, const uint8_t *buffer)
+static uint32_t get_buffer(struct target *target, const uint8_t *buffer)
 {
 	uint32_t value = 0;
 	const uint8_t *value_ptr = buffer;
@@ -176,15 +164,13 @@ 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, struct rtos_reg **reg_list, int *num_regs)
 {
 	struct target *target = rtos->target;
 	struct linux_os *linux_os = (struct linux_os *)
 		target->rtos->rtos_specific_params;
-	int i = 0;
 	struct current_thread *tmp = linux_os->current_threads;
 	struct current_thread *next;
-	char *hex_string;
 	int found = 0;
 	int retval;
 	/*  check if a current thread is requested  */
@@ -195,140 +181,75 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
 			found = 1;
 		else
 			next = next->next;
-	} while ((found == 0) && (next != tmp) && (next != NULL));
-
-	if (found == 1) {
-		/*  search target to perfom the access  */
-		struct reg **reg_list;
-		int reg_list_size, reg_packet_size = 0;
-		struct target_list *head;
-		head = target->head;
-		found = 0;
-		do {
-			if (head->target->coreid == next->core_id) {
-
-				target = head->target;
-				found = 1;
-			} else
-				head = head->next;
-
-		} while ((head != (struct target_list *)NULL) && (found == 0));
-
-		if (found == 0) {
-			LOG_ERROR
-			(
-				"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);
-
-		if (retval != ERROR_OK)
-			return retval;
-
-		for (i = 0; i < reg_list_size; i++)
-			reg_packet_size += reg_list[i]->size;
-
-		assert(reg_packet_size > 0);
-
-		*hex_reg_list = malloc(DIV_ROUND_UP(reg_packet_size, 8) * 2);
+	} while ((found == 0) && (next != tmp) && (next));
 
-		hex_string = *hex_reg_list;
-
-		for (i = 0; i < reg_list_size; i++) {
-			if (!reg_list[i]->valid)
-				reg_list[i]->type->get(reg_list[i]);
+	if (found == 0) {
+		LOG_ERROR("could not find thread: %" PRIx64, thread_id);
+		return ERROR_FAIL;
+	}
 
-			hex_string = reg_converter(hex_string,
-					reg_list[i]->value,
-					(reg_list[i]->size) / 8);
+	/*  search target to perform the access  */
+	struct reg **gdb_reg_list;
+	struct target_list *head;
+	head = target->head;
+	found = 0;
+	do {
+		if (head->target->coreid == next->core_id) {
+			target = head->target;
+			found = 1;
+			break;
 		}
+		head = head->next;
+	} while (head);
+
+	if (found == 0) {
+		LOG_ERROR
+		(
+			"current thread %" PRIx64 ": no target to perform access of core id %" PRIx32,
+			thread_id,
+			next->core_id);
+		return ERROR_FAIL;
+	}
 
-		free(reg_list);
+	/*LOG_INFO("thread %lx current on core %x",thread_id, target->coreid);*/
+	retval = target_get_gdb_reg_list(target, &gdb_reg_list, num_regs, REG_CLASS_GENERAL);
+	if (retval != ERROR_OK)
+		return retval;
 
-	} else {
-		struct threads *temp = linux_os->thread_list;
-		*hex_reg_list = (char *)calloc(1, 500 * sizeof(char));
-		hex_string = *hex_reg_list;
+	*reg_list = calloc(*num_regs, sizeof(struct rtos_reg));
 
-		for (i = 0; i < 16; i++)
-			hex_string += sprintf(hex_string, "%02x", 0);
+	for (int i = 0; i < *num_regs; ++i) {
+		if (!gdb_reg_list[i]->valid)
+			gdb_reg_list[i]->type->get(gdb_reg_list[i]);
 
-		while ((temp != NULL) &&
-				(temp->threadid != target->rtos->current_threadid))
-			temp = temp->next;
+		(*reg_list)[i].number = gdb_reg_list[i]->number;
+		(*reg_list)[i].size = gdb_reg_list[i]->size;
 
-		if (temp != NULL) {
-			if (temp->context == NULL)
-				temp->context = cpu_context_read(target,
-						temp->
-						base_addr,
-						&temp->
-						thread_info_addr);
-
-			hex_string =
-				reg_converter(hex_string, &temp->context->R4, 4);
-			hex_string =
-				reg_converter(hex_string, &temp->context->R5, 4);
-			hex_string =
-				reg_converter(hex_string, &temp->context->R6, 4);
-			hex_string =
-				reg_converter(hex_string, &temp->context->R7, 4);
-			hex_string =
-				reg_converter(hex_string, &temp->context->R8, 4);
-			hex_string =
-				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);
-			hex_string =
-				reg_converter(hex_string, &temp->context->IP, 4);
-			hex_string =
-				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);
-
-			for (i = 0; i < 100; i++)	/*100 */
-				hex_string += sprintf(hex_string, "%02x", 0);
-
-			uint32_t cpsr = 0x00000000;
-			reg_converter(hex_string, &cpsr, 4);
-		}
+		buf_cpy(gdb_reg_list[i]->value, (*reg_list)[i].value, (*reg_list)[i].size);
 	}
+
 	return ERROR_OK;
 }
 
-static int linux_os_detect(struct target *target)
+static bool linux_os_detect(struct target *target)
 {
 	LOG_INFO("should no be called");
-	return 0;
+	return false;
 }
 
 static int linux_os_smp_init(struct target *target);
 static int linux_os_clean(struct target *target);
 #define INIT_TASK 0
-static char *linux_symbol_list[] = {
+static const char * const linux_symbol_list[] = {
 	"init_task",
 	NULL
 };
 
-static int linux_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
+static int linux_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *)
-		malloc(sizeof(symbol_table_elem_t) * ARRAY_SIZE(linux_symbol_list));
+	*symbol_list = (struct symbol_table_elem *)
+		calloc(ARRAY_SIZE(linux_symbol_list), sizeof(struct symbol_table_elem));
 
 	for (i = 0; i < ARRAY_SIZE(linux_symbol_list); i++)
 		(*symbol_list)[i].symbol_name = linux_symbol_list[i];
@@ -338,7 +259,7 @@ static int linux_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 
 static char *linux_ps_command(struct target *target);
 
-const struct rtos_type Linux_os = {
+const struct rtos_type linux_rtos = {
 	.name = "linux",
 	.detect_rtos = linux_os_detect,
 	.create = linux_os_create,
@@ -350,7 +271,7 @@ const struct rtos_type Linux_os = {
 	.ps_command = linux_ps_command,
 };
 
-static int linux_thread_packet(struct connection *connection, char *packet,
+static int linux_thread_packet(struct connection *connection, char const *packet,
 		int packet_size);
 static void linux_identify_current_threads(struct target *target);
 
@@ -371,7 +292,7 @@ int fill_task_pid(struct target *target, struct threads *t)
 }
 #endif
 
-int fill_task(struct target *target, struct threads *t)
+static int fill_task(struct target *target, struct threads *t)
 {
 	int retval;
 	uint32_t pid_addr = t->base_addr + PID;
@@ -427,7 +348,7 @@ int fill_task(struct target *target, struct threads *t)
 	return retval;
 }
 
-int get_name(struct target *target, struct threads *t)
+static int get_name(struct target *target, struct threads *t)
 {
 	int retval;
 	uint32_t full_name[4];
@@ -473,7 +394,7 @@ int get_name(struct target *target, struct threads *t)
 
 }
 
-int get_current(struct target *target, int create)
+static int get_current(struct target *target, int create)
 {
 	struct target_list *head;
 	head = target->head;
@@ -486,19 +407,19 @@ int get_current(struct target *target, int create)
 	struct current_thread *ctt = linux_os->current_threads;
 
 	/*  invalid current threads content */
-	while (ctt != NULL) {
+	while (ctt) {
 		ctt->threadid = -1;
 		ctt->TS = 0xdeadbeef;
 		ctt = ctt->next;
 	}
 
-	while (head != (struct target_list *)NULL) {
+	while (head) {
 		struct reg **reg_list;
 		int reg_list_size;
 		int retval;
 
 		if (target_get_gdb_reg_list(head->target, &reg_list,
-				&reg_list_size) != ERROR_OK) {
+				&reg_list_size, REG_CLASS_GENERAL) != ERROR_OK) {
 			free(buffer);
 			return ERROR_TARGET_FAILURE;
 		}
@@ -509,8 +430,8 @@ int get_current(struct target *target, int create)
 		buf = reg_list[13]->value;
 		val = get_buffer(target, buf);
 		ti_addr = (val & 0xffffe000);
-		uint32_t TS_addr = ti_addr + 0xc;
-		retval = fill_buffer(target, TS_addr, buffer);
+		uint32_t ts_addr = ti_addr + 0xc;
+		retval = fill_buffer(target, ts_addr, buffer);
 
 		if (retval == ERROR_OK) {
 			uint32_t TS = get_buffer(target, buffer);
@@ -523,16 +444,16 @@ int get_current(struct target *target, int create)
 					linux_os->current_threads;
 				cpu = head->target->coreid;
 
-				while ((ct != NULL) && (ct->core_id != (int32_t) cpu))
+				while ((ct) && (ct->core_id != (int32_t) cpu))
 					ct = ct->next;
 
-				if ((ct != NULL) && (ct->TS == 0xdeadbeef))
+				if ((ct) && (ct->TS == 0xdeadbeef))
 					ct->TS = TS;
 				else
 					LOG_ERROR
 						("error in linux current thread update");
 
-				if (create) {
+				if (create && ct) {
 					struct threads *t;
 					t = calloc(1, sizeof(struct threads));
 					t->base_addr = ct->TS;
@@ -561,7 +482,7 @@ int get_current(struct target *target, int create)
 	return ERROR_OK;
 }
 
-struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
+static struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
 	uint32_t *thread_info_addr_old)
 {
 	struct cpu_context *context = calloc(1, sizeof(struct cpu_context));
@@ -657,7 +578,7 @@ retry:
 	return context;
 }
 
-uint32_t next_task(struct target *target, struct threads *t)
+static uint32_t next_task(struct target *target, struct threads *t)
 {
 	uint8_t *buffer = calloc(1, 4);
 	uint32_t next_addr = t->base_addr + NEXT;
@@ -676,18 +597,18 @@ uint32_t next_task(struct target *target, struct threads *t)
 	return 0;
 }
 
-struct current_thread *add_current_thread(struct current_thread *currents,
+static struct current_thread *add_current_thread(struct current_thread *currents,
 	struct current_thread *ct)
 {
 	ct->next = NULL;
 
-	if (currents == NULL) {
+	if (!currents) {
 		currents = ct;
 		return currents;
 	} else {
 		struct current_thread *temp = currents;
 
-		while (temp->next != NULL)
+		while (temp->next)
 			temp = temp->next;
 
 		temp->next = ct;
@@ -695,37 +616,36 @@ struct current_thread *add_current_thread(struct current_thread *currents,
 	}
 }
 
-struct threads *liste_del_task(struct threads *task_list, struct threads **t,
+static struct threads *liste_del_task(struct threads *task_list, struct threads **t,
 	struct threads *prev)
 {
 	LOG_INFO("del task %" PRId64, (*t)->threadid);
-	prev->next = (*t)->next;
-
-	if (prev == task_list)
-		task_list = prev;
+	if (prev)
+		prev->next = (*t)->next;
+	else
+		task_list = (*t)->next;
 
 	/*  free content of threads */
-	if ((*t)->context)
-		free((*t)->context);
+	free((*t)->context);
 
 	free(*t);
-	*t = prev;
+	*t = prev ? prev : task_list;
 	return task_list;
 }
 
-struct threads *liste_add_task(struct threads *task_list, struct threads *t,
+static struct threads *liste_add_task(struct threads *task_list, struct threads *t,
 	struct threads **last)
 {
 	t->next = NULL;
 
-	if (*last == NULL)
-		if (task_list == NULL) {
+	if (!*last)
+		if (!task_list) {
 			task_list = t;
 			return task_list;
 		} else {
 			struct threads *temp = task_list;
 
-			while (temp->next != NULL)
+			while (temp->next)
 				temp = temp->next;
 
 			temp->next = t;
@@ -747,22 +667,22 @@ static int current_base_addr(struct linux_os *linux_os, uint32_t base_addr)
 	struct current_thread *ct = linux_os->current_threads;
 #ifdef PID_CHECK
 
-	while ((ct != NULL) && (ct->pid != pid))
+	while ((ct) && (ct->pid != pid))
 #else
-	while ((ct != NULL) && (ct->TS != base_addr))
+	while ((ct) && (ct->TS != base_addr))
 #endif
 		ct = ct->next;
 #ifdef PID_CHECK
-	if ((ct != NULL) && (ct->pid == pid))
+	if ((ct) && (ct->pid == pid))
 #else
-	if ((ct != NULL) && (ct->TS == base_addr))
+	if ((ct) && (ct->TS == base_addr))
 #endif
 		return 1;
 
 	return 0;
 }
 
-int linux_get_tasks(struct target *target, int context)
+static int linux_get_tasks(struct target *target, int context)
 {
 	int loop = 0;
 	int retval = 0;
@@ -803,6 +723,7 @@ int linux_get_tasks(struct target *target, int context)
 
 		/*  check that this thread is not one the current threads already
 		 *  created */
+		uint32_t base_addr;
 #ifdef PID_CHECK
 
 		if (!current_pid(linux_os, t->pid)) {
@@ -823,12 +744,13 @@ int linux_get_tasks(struct target *target, int context)
 				t->context =
 					cpu_context_read(target, t->base_addr,
 						&t->thread_info_addr);
+			base_addr = next_task(target, t);
 		} else {
 			/*LOG_INFO("thread %s is a current thread already created",t->name); */
+			base_addr = next_task(target, t);
 			free(t);
 		}
 
-		uint32_t base_addr = next_task(target, t);
 		t = calloc(1, sizeof(struct threads));
 		t->base_addr = base_addr;
 	}
@@ -854,11 +776,10 @@ static int clean_threadlist(struct target *target)
 		target->rtos->rtos_specific_params;
 	struct threads *old, *temp = linux_os->thread_list;
 
-	while (temp != NULL) {
+	while (temp) {
 		old = temp;
 
-		if (temp->context)
-			free(temp->context);
+		free(temp->context);
 
 		temp = temp->next;
 		free(old);
@@ -893,10 +814,10 @@ static int insert_into_threadlist(struct target *target, struct threads *t)
 	t->status = 1;
 	t->next = NULL;
 
-	if (temp == NULL)
+	if (!temp)
 		linux_os->thread_list = t;
 	else {
-		while (temp->next != NULL)
+		while (temp->next)
 			temp = temp->next;
 
 		t->next = NULL;
@@ -914,7 +835,7 @@ static void linux_identify_current_threads(struct target *target)
 	struct current_thread *ct = linux_os->current_threads;
 	struct threads *t = NULL;
 
-	while ((ct != NULL)) {
+	while ((ct)) {
 		if (ct->threadid == -1) {
 
 			/*  un-identified thread */
@@ -934,7 +855,7 @@ error_handling:
 
 			/* search in the list of threads if pid
 			   already present */
-			while ((thread_list != NULL) && (found == 0)) {
+			while ((thread_list) && (found == 0)) {
 #ifdef PID_CHECK
 				if (thread_list->pid == t->pid) {
 #else
@@ -1004,13 +925,11 @@ static int linux_task_update(struct target *target, int context)
 	linux_os->thread_count = 0;
 
 	/*thread_list = thread_list->next; skip init_task*/
-	while (thread_list != NULL) {
+	while (thread_list) {
 		thread_list->status = 0;	/*setting all tasks to dead state*/
 
-		if (thread_list->context) {
-			free(thread_list->context);
-			thread_list->context = NULL;
-		}
+		free(thread_list->context);
+		thread_list->context = NULL;
 
 		thread_list = thread_list->next;
 	}
@@ -1047,7 +966,7 @@ static int linux_task_update(struct target *target, int context)
 
 		thread_list = linux_os->thread_list;
 
-		while (thread_list != NULL) {
+		while (thread_list) {
 #ifdef PID_CHECK
 			if (t->pid == thread_list->pid) {
 #else
@@ -1071,10 +990,8 @@ 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);
+								thread_list->base_addr,
+								&thread_list->thread_info_addr);
 				} else {
 					/*  it is a current thread no need to read context */
 				}
@@ -1115,8 +1032,8 @@ static int linux_task_update(struct target *target, int context)
 	return ERROR_OK;
 }
 
-int linux_gdb_thread_packet(struct target *target,
-	struct connection *connection, char *packet,
+static int linux_gdb_thread_packet(struct target *target,
+	struct connection *connection, char const *packet,
 	int packet_size)
 {
 	int retval;
@@ -1135,25 +1052,25 @@ int linux_gdb_thread_packet(struct target *target,
 	if (retval != ERROR_OK)
 		return ERROR_TARGET_FAILURE;
 
-	char *out_str = (char *)calloc(1, 350 * sizeof(int64_t));
+	char *out_str = calloc(MAX_THREADS * 17 + 10, 1);
 	char *tmp_str = out_str;
 	tmp_str += sprintf(tmp_str, "m");
 	struct threads *temp = linux_os->thread_list;
-	tmp_str += sprintf(tmp_str, "%016" PRIx64, temp->threadid);
-	temp = temp->next;
 
-	while (temp != NULL) {
-		tmp_str += sprintf(tmp_str, ",");
+	while (temp) {
 		tmp_str += sprintf(tmp_str, "%016" PRIx64, temp->threadid);
 		temp = temp->next;
+		if (temp)
+			tmp_str += sprintf(tmp_str, ",");
 	}
 
 	gdb_put_packet(connection, out_str, strlen(out_str));
+	free(out_str);
 	return ERROR_OK;
 }
 
-int linux_gdb_thread_update(struct target *target,
-	struct connection *connection, char *packet,
+static int linux_gdb_thread_update(struct target *target,
+	struct connection *connection, char const *packet,
 	int packet_size)
 {
 	int found = 0;
@@ -1161,7 +1078,7 @@ int linux_gdb_thread_update(struct target *target,
 		target->rtos->rtos_specific_params;
 	struct threads *temp = linux_os->thread_list;
 
-	while (temp != NULL) {
+	while (temp) {
 		if (temp->threadid == linux_os->preupdtate_threadid_count + 1) {
 			/*LOG_INFO("FOUND");*/
 			found = 1;
@@ -1172,7 +1089,7 @@ int linux_gdb_thread_update(struct target *target,
 
 	if (found == 1) {
 		/*LOG_INFO("INTO GDB THREAD UPDATE FOUNDING START TASK");*/
-		char *out_strr = (char *)calloc(1, 350 * sizeof(int64_t));
+		char *out_strr = calloc(MAX_THREADS * 17 + 10, 1);
 		char *tmp_strr = out_strr;
 		tmp_strr += sprintf(tmp_strr, "m");
 		/*LOG_INFO("CHAR MALLOC & M DONE");*/
@@ -1180,7 +1097,7 @@ int linux_gdb_thread_update(struct target *target,
 
 		temp = temp->next;
 
-		while (temp != NULL) {
+		while (temp) {
 			/*LOG_INFO("INTO GDB THREAD UPDATE WHILE");*/
 			tmp_strr += sprintf(tmp_strr, ",");
 			tmp_strr +=
@@ -1199,8 +1116,8 @@ int linux_gdb_thread_update(struct target *target,
 	return ERROR_OK;
 }
 
-int linux_thread_extra_info(struct target *target,
-	struct connection *connection, char *packet,
+static int linux_thread_extra_info(struct target *target,
+	struct connection *connection, char const *packet,
 	int packet_size)
 {
 	int64_t threadid = 0;
@@ -1210,13 +1127,13 @@ int linux_thread_extra_info(struct target *target,
 	/*LOG_INFO("lookup extra info for thread %" SCNx64, threadid);*/
 	struct threads *temp = linux_os->thread_list;
 
-	while (temp != NULL) {
+	while (temp) {
 		if (temp->threadid == threadid) {
 			char *pid = " PID: ";
 			char *pid_current = "*PID: ";
-			char *name = "NAME: ";
+			char *name = "Name: ";
 			int str_size = strlen(pid) + strlen(name);
-			char *tmp_str = (char *)calloc(1, str_size + 50);
+			char *tmp_str = calloc(1, str_size + 50);
 			char *tmp_str_ptr = tmp_str;
 
 			/*  discriminate current task */
@@ -1226,13 +1143,12 @@ int linux_thread_extra_info(struct target *target,
 			else
 				tmp_str_ptr += sprintf(tmp_str_ptr, "%s", pid);
 
-			tmp_str_ptr +=
-				sprintf(tmp_str_ptr, "%d", (int)temp->pid);
-			tmp_str_ptr += sprintf(tmp_str_ptr, "%s", " | ");
+			tmp_str_ptr += sprintf(tmp_str_ptr, "%d, ", (int)temp->pid);
 			sprintf(tmp_str_ptr, "%s", name);
 			sprintf(tmp_str_ptr, "%s", temp->name);
-			char *hex_str = (char *)calloc(1, strlen(tmp_str) * 2 + 1);
-			int pkt_len = hexify(hex_str, tmp_str, 0, strlen(tmp_str) * 2 + 1);
+			char *hex_str = calloc(1, strlen(tmp_str) * 2 + 1);
+			size_t pkt_len = hexify(hex_str, (const uint8_t *)tmp_str,
+				strlen(tmp_str), strlen(tmp_str) * 2 + 1);
 			gdb_put_packet(connection, hex_str, pkt_len);
 			free(hex_str);
 			free(tmp_str);
@@ -1246,8 +1162,8 @@ int linux_thread_extra_info(struct target *target,
 	return ERROR_OK;
 }
 
-int linux_gdb_T_packet(struct connection *connection,
-	struct target *target, char *packet, int packet_size)
+static int linux_gdb_t_packet(struct connection *connection,
+	struct target *target, char const *packet, int packet_size)
 {
 	int64_t threadid;
 	struct linux_os *linux_os = (struct linux_os *)
@@ -1257,9 +1173,9 @@ int linux_gdb_T_packet(struct connection *connection,
 
 	if (linux_os->threads_needs_update == 0) {
 		struct threads *temp = linux_os->thread_list;
-		struct threads *prev = linux_os->thread_list;
+		struct threads *prev = NULL;
 
-		while (temp != NULL) {
+		while (temp) {
 			if (temp->threadid == threadid) {
 				if (temp->status != 0) {
 					gdb_put_packet(connection, "OK", 2);
@@ -1267,9 +1183,8 @@ 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;
@@ -1289,7 +1204,7 @@ int linux_gdb_T_packet(struct connection *connection,
 		retval = linux_task_update(target, 1);
 		struct threads *temp = linux_os->thread_list;
 
-		while (temp != NULL) {
+		while (temp) {
 			if (temp->threadid == threadid) {
 				if (temp->status == 1) {
 					gdb_put_packet(connection, "OK", 2);
@@ -1307,28 +1222,28 @@ int linux_gdb_T_packet(struct connection *connection,
 	return retval;
 }
 
-int linux_gdb_h_packet(struct connection *connection,
-	struct target *target, char *packet, int packet_size)
+static int linux_gdb_h_packet(struct connection *connection,
+	struct target *target, char const *packet, int packet_size)
 {
 	struct linux_os *linux_os = (struct linux_os *)
 		target->rtos->rtos_specific_params;
 	struct current_thread *ct = linux_os->current_threads;
 
 	/* select to display the current thread of the selected target */
-	while ((ct != NULL) && (ct->core_id != target->coreid))
+	while ((ct) && (ct->core_id != target->coreid))
 		ct = ct->next;
 
 	int64_t current_gdb_thread_rq;
 
 	if (linux_os->threads_lookup == 1) {
-		if ((ct != NULL) && (ct->threadid == -1)) {
+		if ((ct) && (ct->threadid == -1)) {
 			ct = linux_os->current_threads;
 
-			while ((ct != NULL) && (ct->threadid == -1))
+			while ((ct) && (ct->threadid == -1))
 				ct = ct->next;
 		}
 
-		if (ct == NULL) {
+		if (!ct) {
 			/*  no current thread can be identified
 			 *  any way with smp  */
 			LOG_INFO("no current thread identified");
@@ -1337,7 +1252,7 @@ int linux_gdb_h_packet(struct connection *connection,
 			struct threads t;
 			ct = linux_os->current_threads;
 
-			while ((ct != NULL) && (ct->threadid == -1)) {
+			while ((ct) && (ct->threadid == -1)) {
 				t.base_addr = ct->TS;
 				get_name(target, &t);
 				LOG_INFO("name of unidentified thread %s",
@@ -1376,7 +1291,7 @@ int linux_gdb_h_packet(struct connection *connection,
 	return ERROR_OK;
 }
 
-static int linux_thread_packet(struct connection *connection, char *packet,
+static int linux_thread_packet(struct connection *connection, char const *packet,
 	int packet_size)
 {
 	int retval = ERROR_OK;
@@ -1388,7 +1303,7 @@ static int linux_thread_packet(struct connection *connection, char *packet,
 	switch (packet[0]) {
 		case 'T':		/* Is thread alive?*/
 
-			linux_gdb_T_packet(connection, target, packet, packet_size);
+			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 )*/
@@ -1400,14 +1315,12 @@ static int linux_thread_packet(struct connection *connection, char *packet,
 			if (strncmp(packet, "qSymbol", 7) == 0) {
 				if (rtos_qsymbol(connection, packet, packet_size) == 1) {
 					linux_compute_virt2phys(target,
-							target->rtos->
-							symbols[INIT_TASK].
-							address);
+							target->rtos->symbols[INIT_TASK].address);
 				}
 
 				break;
 			} else if (strncmp(packet, "qfThreadInfo", 12) == 0) {
-				if (linux_os->thread_list == NULL) {
+				if (!linux_os->thread_list) {
 					retval = linux_gdb_thread_packet(target,
 							connection,
 							packet,
@@ -1442,22 +1355,21 @@ static int linux_thread_packet(struct connection *connection, char *packet,
 			if (linux_os->threads_lookup == 1) {
 				ct = linux_os->current_threads;
 
-				while ((ct != NULL) && (ct->core_id) != target->coreid)
+				while ((ct) && (ct->core_id) != target->coreid)
 					ct = ct->next;
 
-				if ((ct != NULL) && (ct->threadid == -1)) {
+				if ((ct) && (ct->threadid == -1)) {
 					ct = linux_os->current_threads;
 
-					while ((ct != NULL) && (ct->threadid == -1))
+					while ((ct) && (ct->threadid == -1))
 						ct = ct->next;
 				}
 
-				if ((ct != NULL) && (ct->threadid !=
-						 target->rtos->
-						 current_threadid)
+				if ((ct) && (ct->threadid !=
+						 target->rtos->current_threadid)
 				&& (target->rtos->current_threadid != -1))
-					LOG_WARNING("WARNING! current GDB thread do not match" \
-							"current thread running." \
+					LOG_WARNING("WARNING! current GDB thread do not match "
+							"current thread running. "
 							"Switch thread in GDB to threadid %d",
 							(int)ct->threadid);
 
@@ -1484,11 +1396,10 @@ static int linux_os_smp_init(struct target *target)
 	struct current_thread *ct;
 	head = target->head;
 
-	while (head != (struct target_list *)NULL) {
+	while (head) {
 		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;
@@ -1524,7 +1435,7 @@ static int linux_os_create(struct target *target)
 	os_linux->threads_needs_update = 0;
 	os_linux->threadid_count = 1;
 	os_linux->current_threads = NULL;
-	target->rtos->rtos_specific_params = (void *)os_linux;
+	target->rtos->rtos_specific_params = os_linux;
 	ct->core_id = target->coreid;
 	ct->threadid = -1;
 	ct->TS = 0xdeadbeef;
@@ -1566,19 +1477,19 @@ static char *linux_ps_command(struct target *target)
 		tmp += sprintf(tmp, "PID\t\tCPU\t\tASID\t\tNAME\n");
 		tmp += sprintf(tmp, "---\t\t---\t\t----\t\t----\n");
 
-		while (temp != NULL) {
+		while (temp) {
 			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,
+							"%" PRIu32 "\t\t%" PRIu32 "\t\t%" PRIx32 "\t\t%s\n",
+							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,
+							"%" PRIu32 "\t\t%" PRIu32 "\t\t%" PRIx32 "\t\t%s\n",
+							temp->pid, temp->oncpu,
 							temp->asid, temp->name);
 			}