-/***************************************************************************
- * *
- * 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"
static bool hwthread_detect_rtos(struct target *target);
static int hwthread_create(struct target *target);
static int hwthread_update_threads(struct rtos *rtos);
+static int hwthread_get_thread_reg(struct rtos *rtos, int64_t thread_id,
+ uint32_t reg_num, struct rtos_reg *rtos_reg);
static int hwthread_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
- struct rtos_reg **reg_list, int *num_regs);
-static int hwthread_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
+ struct rtos_reg **reg_list, int *num_regs);
+static int hwthread_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
static int hwthread_smp_init(struct target *target);
+static int hwthread_set_reg(struct rtos *rtos, uint32_t reg_num, uint8_t *reg_value);
+static int hwthread_read_buffer(struct rtos *rtos, target_addr_t address,
+ uint32_t size, uint8_t *buffer);
+static int hwthread_write_buffer(struct rtos *rtos, target_addr_t address,
+ uint32_t size, const uint8_t *buffer);
#define HW_THREAD_NAME_STR_SIZE (32)
.create = hwthread_create,
.update_threads = hwthread_update_threads,
.get_thread_reg_list = hwthread_get_thread_reg_list,
+ .get_thread_reg = hwthread_get_thread_reg,
.get_symbol_list_to_lookup = hwthread_get_symbol_list_to_lookup,
.smp_init = hwthread_smp_init,
+ .set_reg = hwthread_set_reg,
+ .read_buffer = hwthread_read_buffer,
+ .write_buffer = hwthread_write_buffer,
};
struct hwthread_params {
int64_t current_thread = 0;
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))
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))
return hwthread_update_threads(target->rtos);
}
-static int hwthread_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
- struct rtos_reg **rtos_reg_list, int *num_regs)
+static struct target *hwthread_find_thread(struct target *target, int64_t thread_id)
{
- struct target_list *head;
- struct target *target;
- struct target *curr;
- struct reg **reg_list;
- int retval;
-
- if (rtos == NULL)
- return ERROR_FAIL;
-
- target = rtos->target;
-
/* Find the thread with that thread_id */
+ if (!target)
+ return NULL;
if (target->smp) {
- curr = NULL;
- for (head = target->head; head != NULL; head = head->next) {
- curr = head->target;
-
- if (thread_id == threadid_from_target(curr))
- break;
+ struct target_list *head;
+ foreach_smp_target(head, target->smp_targets) {
+ if (thread_id == threadid_from_target(head->target))
+ return head->target;
}
+ } else if (thread_id == threadid_from_target(target)) {
+ return target;
+ }
+ return NULL;
+}
- if (head == NULL)
- return ERROR_FAIL;
- } else {
- curr = target;
- if (thread_id != threadid_from_target(curr))
- return ERROR_FAIL;
+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)
+ return ERROR_FAIL;
- }
+ struct target *target = rtos->target;
+
+ struct target *curr = hwthread_find_thread(target, thread_id);
+ if (!curr)
+ return ERROR_FAIL;
if (!target_was_examined(curr))
return ERROR_FAIL;
- retval = target_get_gdb_reg_list(curr, ®_list, num_regs,
+ int reg_list_size;
+ struct reg **reg_list;
+ int retval = target_get_gdb_reg_list(curr, ®_list, ®_list_size,
REG_CLASS_GENERAL);
if (retval != ERROR_OK)
return retval;
- *rtos_reg_list = calloc(*num_regs, sizeof(struct rtos_reg));
- if (*rtos_reg_list == NULL) {
+ int j = 0;
+ for (int i = 0; i < reg_list_size; i++) {
+ 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) {
free(reg_list);
return ERROR_FAIL;
}
- for (int i = 0; i < *num_regs; i++) {
- (*rtos_reg_list)[i].number = (*reg_list)[i].number;
- (*rtos_reg_list)[i].size = (*reg_list)[i].size;
- memcpy((*rtos_reg_list)[i].value, (*reg_list)[i].value,
- ((*reg_list)[i].size + 7) / 8);
+ j = 0;
+ for (int i = 0; i < reg_list_size; i++) {
+ 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);
+ j++;
}
-
free(reg_list);
return ERROR_OK;
+}
+
+static int hwthread_get_thread_reg(struct rtos *rtos, int64_t thread_id,
+ uint32_t reg_num, struct rtos_reg *rtos_reg)
+{
+ if (!rtos)
+ return ERROR_FAIL;
+
+ struct target *target = rtos->target;
+
+ struct target *curr = hwthread_find_thread(target, thread_id);
+ if (!curr) {
+ LOG_ERROR("Couldn't find RTOS thread for id %" PRId64 ".", thread_id);
+ return ERROR_FAIL;
+ }
+
+ if (!target_was_examined(curr)) {
+ LOG_ERROR("Target %d hasn't been examined yet.", curr->coreid);
+ return ERROR_FAIL;
+ }
+
+ struct reg *reg = register_get_by_number(curr->reg_cache, reg_num, true);
+ if (!reg) {
+ LOG_ERROR("Couldn't find register %" PRIu32 " in thread %" PRId64 ".", reg_num,
+ thread_id);
+ return ERROR_FAIL;
+ }
+
+ if (reg->type->get(reg) != ERROR_OK)
+ return ERROR_FAIL;
+
+ rtos_reg->number = reg->number;
+ rtos_reg->size = reg->size;
+ unsigned bytes = (reg->size + 7) / 8;
+ assert(bytes <= sizeof(rtos_reg->value));
+ memcpy(rtos_reg->value, reg->value, bytes);
+
+ return ERROR_OK;
+}
+static int hwthread_set_reg(struct rtos *rtos, uint32_t reg_num, uint8_t *reg_value)
+{
+ if (!rtos)
+ return ERROR_FAIL;
+
+ struct target *target = rtos->target;
+
+ struct target *curr = hwthread_find_thread(target, rtos->current_thread);
+ if (!curr)
+ return ERROR_FAIL;
+
+ struct reg *reg = register_get_by_number(curr->reg_cache, reg_num, true);
+ if (!reg)
+ return ERROR_FAIL;
+
+ return reg->type->set(reg, reg_value);
}
-static int hwthread_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
+static int hwthread_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
{
/* return an empty list, we don't have any symbols to look up */
- *symbol_list = calloc(1, sizeof(symbol_table_elem_t));
+ *symbol_list = calloc(1, sizeof(struct symbol_table_elem));
(*symbol_list)[0].symbol_name = NULL;
return 0;
}
static int hwthread_target_for_threadid(struct connection *connection, int64_t thread_id, struct target **p_target)
{
struct target *target = get_target_from_connection(connection);
- struct target_list *head;
- struct target *curr;
-
- if (target->smp) {
- /* Find the thread with that thread_id */
- curr = NULL;
- for (head = target->head; head != NULL; head = head->next) {
- curr = head->target;
-
- if (thread_id == threadid_from_target(curr))
- break;
- }
- if (head == NULL)
- return ERROR_FAIL;
- } else {
- curr = target;
- if (thread_id != threadid_from_target(curr))
- return ERROR_FAIL;
- }
+ struct target *curr = hwthread_find_thread(target, thread_id);
+ if (!curr)
+ return ERROR_FAIL;
*p_target = curr;
target->rtos->gdb_thread_packet = hwthread_thread_packet;
return 0;
}
+
+static int hwthread_read_buffer(struct rtos *rtos, target_addr_t address,
+ uint32_t size, uint8_t *buffer)
+{
+ if (!rtos)
+ return ERROR_FAIL;
+
+ struct target *target = rtos->target;
+
+ struct target *curr = hwthread_find_thread(target, rtos->current_thread);
+ if (!curr)
+ return ERROR_FAIL;
+
+ return target_read_buffer(curr, address, size, buffer);
+}
+
+static int hwthread_write_buffer(struct rtos *rtos, target_addr_t address,
+ uint32_t size, const uint8_t *buffer)
+{
+ if (!rtos)
+ return ERROR_FAIL;
+
+ struct target *target = rtos->target;
+
+ struct target *curr = hwthread_find_thread(target, rtos->current_thread);
+ if (!curr)
+ return ERROR_FAIL;
+
+ return target_write_buffer(curr, address, size, buffer);
+}
projects / fw / openocd / blobdiff