* 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. *
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "target/target.h"
#include "target/target_type.h"
#include "helper/log.h"
+#include "helper/types.h"
#include "rtos.h"
-#include "helper/log.h"
#include "rtos_standard_stackings.h"
#include <target/register.h>
#include "server/gdb_server.h"
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;
}
/*LOG_INFO("thread %lx current on core %x",thread_id,
* target->coreid);*/
retval =
- target_get_gdb_reg_list(target, ®_list, ®_list_size);
+ target_get_gdb_reg_list(target, ®_list, ®_list_size,
+ REG_CLASS_GENERAL);
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);
hex_string = *hex_reg_list;
hex_string += sprintf(hex_string, "%02x", 0);
uint32_t cpsr = 0x00000000;
- hex_string = reg_converter(hex_string, &cpsr, 4);
+ reg_converter(hex_string, &cpsr, 4);
}
}
return ERROR_OK;
{
unsigned int i;
*symbol_list = (symbol_table_elem_t *)
- malloc(sizeof(symbol_table_elem_t) / sizeof(char *));
+ malloc(sizeof(symbol_table_elem_t) * ARRAY_SIZE(linux_symbol_list));
- for (i = 0; i < sizeof(linux_symbol_list) / sizeof(char *); i++)
+ for (i = 0; i < ARRAY_SIZE(linux_symbol_list); i++)
(*symbol_list)[i].symbol_name = linux_symbol_list[i];
return 0;
} else
LOG_ERROR("fill task: unable to read memory");
+ free(buffer);
+
return retval;
}
int retval;
if (target_get_gdb_reg_list(head->target, ®_list,
- ®_list_size) != ERROR_OK)
+ ®_list_size, REG_CLASS_GENERAL) != ERROR_OK) {
+ free(buffer);
return ERROR_TARGET_FAILURE;
+ }
if (!reg_list[13]->valid)
reg_list[13]->type->get(reg_list[13]);
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;
head = head->next;
}
+ free(buffer);
+
return ERROR_OK;
}
(uint8_t *) registers);
if (retval != ERROR_OK) {
+ free(buffer);
LOG_ERROR("cpu_context: unable to read memory\n");
return context;
}
if (*thread_info_addr_old == 0xdeadbeef)
*thread_info_addr_old = thread_info_addr_update;
+ free(buffer);
+
return context;
}
if (retval == ERROR_OK) {
uint32_t val = get_buffer(target, buffer);
val = val - NEXT;
- return val;
free(buffer);
+ return val;
} else
LOG_ERROR("next task: unable to read memory");
+ free(buffer);
+
return 0;
}
struct threads *last = NULL;
t->base_addr = linux_os->init_task_addr;
/* retrieve the thread id , currently running in the different smp core */
- retval = get_current(target, 1);
+ get_current(target, 1);
while (((t->base_addr != linux_os->init_task_addr) &&
(t->base_addr != 0)) || (loop == 0)) {
loop++;
- retval = fill_task(target, t);
+ fill_task(target, t);
retval = get_name(target, t);
if (loop > MAX_THREADS) {
+ free(t);
LOG_INFO("more than %d threads !!", MAX_THREADS);
return ERROR_FAIL;
}
(timeval_ms() - start) / linux_os->threadid_count);
LOG_INFO("threadid count %d", linux_os->threadid_count);
+ free(t);
return ERROR_OK;
}
#ifndef PID_CHECK
error_handling:
free(t);
- LOG_ERROR("unable toread pid");
+ LOG_ERROR("unable to read pid");
return;
#endif
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, ",");
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));
char *tmp_str = (char *)calloc(1, str_size + 50);
char *tmp_str_ptr = tmp_str;
- /* discriminate cuurent task */
+ /* discriminate current task */
if (temp->status == 3)
tmp_str_ptr += sprintf(tmp_str_ptr, "%s",
pid_current);
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, "%s", name);
- tmp_str_ptr += sprintf(tmp_str_ptr, "%s", temp->name);
- char *hex_str =
- (char *)calloc(1, strlen(tmp_str) * 2 + 1);
- str_to_hex(hex_str, tmp_str);
- gdb_put_packet(connection, hex_str, strlen(hex_str));
+ 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);
+ gdb_put_packet(connection, hex_str, pkt_len);
free(hex_str);
free(tmp_str);
return ERROR_OK;
break;
case 'q':
- if ((strstr(packet, "qSymbol"))) {
+ if (strncmp(packet, "qSymbol", 7) == 0) {
if (rtos_qsymbol(connection, packet, packet_size) == 1) {
- gdb_put_packet(connection, "OK", 2);
-
linux_compute_virt2phys(target,
target->rtos->
symbols[INIT_TASK].
}
break;
- } else if (strstr(packet, "qfThreadInfo")) {
+ } else if (strncmp(packet, "qfThreadInfo", 12) == 0) {
if (linux_os->thread_list == NULL) {
retval = linux_gdb_thread_packet(target,
connection,
packet_size);
break;
}
- } else if (strstr(packet, "qsThreadInfo")) {
+ } else if (strncmp(packet, "qsThreadInfo", 12) == 0) {
gdb_put_packet(connection, "l", 1);
break;
- } else if (strstr(packet, "qThreadExtraInfo,")) {
+ } else if (strncmp(packet, "qThreadExtraInfo,", 17) == 0) {
linux_thread_extra_info(target, connection, packet,
packet_size);
break;
}
}
- /* 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;
}
projects / fw / openocd / blobdiff