-/***************************************************************************
- * *
- * This program is free software; you can redistribute it and/or modify *
- * it under the terms of the GNU General Public License as published by *
- * the Free Software Foundation; either version 2 of the License, or *
- * (at your option) any later version. *
- * *
- * This program is distributed in the hope that it will be useful, *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
- * 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, see <http://www.gnu.org/licenses/>. *
- ***************************************************************************/
+// SPDX-License-Identifier: GPL-2.0-or-later
#ifdef HAVE_CONFIG_H
#include "config.h"
#include "target/target.h"
#include "target/target_type.h"
#include "target/register.h"
+#include <target/smp.h>
#include "rtos.h"
#include "helper/log.h"
#include "helper/types.h"
#define HW_THREAD_NAME_STR_SIZE (32)
-extern int rtos_thread_packet(struct connection *connection, const char *packet, int packet_size);
-
static inline threadid_t threadid_from_target(const struct target *target)
{
return target->coreid + 1;
struct target_list *head;
struct target *target;
int64_t current_thread = 0;
+ int64_t current_threadid = rtos->current_threadid; /* thread selected by GDB */
enum target_debug_reason current_reason = DBG_REASON_UNDEFINED;
- if (rtos == NULL)
+ if (!rtos)
return -1;
target = rtos->target;
/* determine the number of "threads" */
if (target->smp) {
- for (head = target->head; head != NULL; head = head->next) {
+ foreach_smp_target(head, target->smp_targets) {
struct target *curr = head->target;
if (!target_was_examined(curr))
} else
thread_list_size = 1;
+ /* restore the threadid which is currently selected by GDB
+ * because rtos_free_threadlist() wipes out it
+ * (GDB thread id is 1-based indexing) */
+ if (current_threadid <= thread_list_size)
+ rtos->current_threadid = current_threadid;
+ else
+ LOG_WARNING("SMP node change, disconnect GDB from core/thread %" PRId64,
+ current_threadid);
+
/* create space for new thread details */
rtos->thread_details = malloc(sizeof(struct thread_detail) * thread_list_size);
if (target->smp) {
/* loop over all threads */
- for (head = target->head; head != NULL; head = head->next) {
+ foreach_smp_target(head, target->smp_targets) {
struct target *curr = head->target;
if (!target_was_examined(curr))
static struct target *hwthread_find_thread(struct target *target, int64_t thread_id)
{
/* Find the thread with that thread_id */
- if (target == NULL)
+ if (!target)
return NULL;
if (target->smp) {
- for (struct target_list *head = target->head; head != NULL; head = head->next) {
+ struct target_list *head;
+ foreach_smp_target(head, target->smp_targets) {
if (thread_id == threadid_from_target(head->target))
return head->target;
}
static int hwthread_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **rtos_reg_list, int *rtos_reg_list_size)
{
- if (rtos == NULL)
+ if (!rtos)
return ERROR_FAIL;
struct target *target = rtos->target;
struct target *curr = hwthread_find_thread(target, thread_id);
- if (curr == NULL)
+ if (!curr)
return ERROR_FAIL;
if (!target_was_examined(curr))
int j = 0;
for (int i = 0; i < reg_list_size; i++) {
- if (reg_list[i] == NULL || reg_list[i]->exist == false || reg_list[i]->hidden)
+ if (!reg_list[i] || reg_list[i]->exist == false || reg_list[i]->hidden)
continue;
j++;
}
*rtos_reg_list_size = j;
*rtos_reg_list = calloc(*rtos_reg_list_size, sizeof(struct rtos_reg));
- if (*rtos_reg_list == NULL) {
+ if (!*rtos_reg_list) {
free(reg_list);
return ERROR_FAIL;
}
j = 0;
for (int i = 0; i < reg_list_size; i++) {
- if (reg_list[i] == NULL || reg_list[i]->exist == false || reg_list[i]->hidden)
+ if (!reg_list[i] || reg_list[i]->exist == false || reg_list[i]->hidden)
continue;
- (*rtos_reg_list)[j].number = (*reg_list)[i].number;
- (*rtos_reg_list)[j].size = (*reg_list)[i].size;
- memcpy((*rtos_reg_list)[j].value, (*reg_list)[i].value,
- ((*reg_list)[i].size + 7) / 8);
+ if (!reg_list[i]->valid) {
+ retval = reg_list[i]->type->get(reg_list[i]);
+ if (retval != ERROR_OK) {
+ LOG_ERROR("Couldn't get register %s.", reg_list[i]->name);
+ free(reg_list);
+ free(*rtos_reg_list);
+ return retval;
+ }
+ }
+ (*rtos_reg_list)[j].number = reg_list[i]->number;
+ (*rtos_reg_list)[j].size = reg_list[i]->size;
+ memcpy((*rtos_reg_list)[j].value, reg_list[i]->value,
+ DIV_ROUND_UP(reg_list[i]->size, 8));
j++;
}
free(reg_list);
static int hwthread_get_thread_reg(struct rtos *rtos, int64_t thread_id,
uint32_t reg_num, struct rtos_reg *rtos_reg)
{
- if (rtos == NULL)
+ if (!rtos)
return ERROR_FAIL;
struct target *target = rtos->target;
struct target *curr = hwthread_find_thread(target, thread_id);
- if (curr == NULL) {
+ if (!curr) {
LOG_ERROR("Couldn't find RTOS thread for id %" PRId64 ".", thread_id);
return ERROR_FAIL;
}
static int hwthread_set_reg(struct rtos *rtos, uint32_t reg_num, uint8_t *reg_value)
{
- if (rtos == NULL)
+ if (!rtos)
return ERROR_FAIL;
struct target *target = rtos->target;
struct target *curr = hwthread_find_thread(target, rtos->current_thread);
- if (curr == NULL)
+ if (!curr)
return ERROR_FAIL;
struct reg *reg = register_get_by_number(curr->reg_cache, reg_num, true);
struct target *target = get_target_from_connection(connection);
struct target *curr = hwthread_find_thread(target, thread_id);
- if (curr == NULL)
+ if (!curr)
return ERROR_FAIL;
*p_target = curr;