zcy
/
tinyriscv-openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove target argument from gdb packet handling functions

__archive__
Jie Zhang 2011-08-24 11:23:04 -04:00 committed by Øyvind Harboe
parent 32862ed9f8
commit 8d7ddde5f1
6 changed files with 66 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/rtos/rtos.c
View File

@ -128,8 +128,10 @@ int rtos_create(Jim_GetOptInfo *goi, struct target * target)
int gdb_thread_packet(struct connection *connection, struct target *target, char *packet, int packet_size) int gdb_thread_packet(struct connection *connection, char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
if (strstr(packet, "qP")) if (strstr(packet, "qP"))
{ {
#define TAG_THREADID 1 /* Echo the thread identifier */ #define TAG_THREADID 1 /* Echo the thread identifier */
@ -501,8 +503,10 @@ int gdb_thread_packet(struct connection *connection, struct target *target, char
return GDB_THREAD_PACKET_NOT_CONSUMED; return GDB_THREAD_PACKET_NOT_CONSUMED;
} }
int rtos_get_gdb_reg_list(struct connection *connection, struct target *target, struct reg **reg_list[], int *reg_list_size) int rtos_get_gdb_reg_list(struct connection *connection, struct reg **reg_list[], int *reg_list_size)
{ {
struct target *target = get_target_from_connection(connection);
if ( ( target->rtos != NULL ) && if ( ( target->rtos != NULL ) &&
( current_threadid != -1 ) && ( current_threadid != -1 ) &&
( current_threadid != 0 ) && ( current_threadid != 0 ) &&

4
src/rtos/rtos.h
View File

@ -99,8 +99,8 @@ struct rtos_register_stacking
int rtos_create(Jim_GetOptInfo *goi, 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_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_try_next( struct target * target );
int gdb_thread_packet(struct connection *connection, struct target *target, char *packet, int packet_size); int gdb_thread_packet(struct connection *connection, char *packet, int packet_size);
int rtos_get_gdb_reg_list(struct connection *connection, struct target *target, struct reg **reg_list[], int *reg_list_size); int rtos_get_gdb_reg_list(struct connection *connection, struct reg **reg_list[], int *reg_list_size);
int rtos_update_threads( struct target *target ); int rtos_update_threads( struct target *target );
#endif // RTOS_H #endif // RTOS_H

106
src/server/gdb_server.c
View File

@ -944,8 +944,9 @@ static void gdb_send_error(struct connection *connection, uint8_t the_error)
} }
static int gdb_last_signal_packet(struct connection *connection, static int gdb_last_signal_packet(struct connection *connection,
struct target *target, char* packet, int packet_size) char* packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
char sig_reply[4]; char sig_reply[4];
int signal_var; int signal_var;
@ -1029,8 +1030,9 @@ static void gdb_target_to_reg(struct target *target,
} }
static int gdb_get_registers_packet(struct connection *connection, static int gdb_get_registers_packet(struct connection *connection,
struct target *target, char* packet, int packet_size) char* packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
struct reg **reg_list; struct reg **reg_list;
int reg_list_size; int reg_list_size;
int retval; int retval;
@ -1044,7 +1046,7 @@ static int gdb_get_registers_packet(struct connection *connection,
#endif #endif
if ( ( target->rtos != NULL ) && if ( ( target->rtos != NULL ) &&
( ERROR_FAIL != rtos_get_gdb_reg_list( connection, target, &reg_list, &reg_list_size) ) ) ( ERROR_FAIL != rtos_get_gdb_reg_list( connection, &reg_list, &reg_list_size) ) )
{ {
return ERROR_OK; return ERROR_OK;
} }
@ -1088,8 +1090,9 @@ static int gdb_get_registers_packet(struct connection *connection,
} }
static int gdb_set_registers_packet(struct connection *connection, static int gdb_set_registers_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
int i; int i;
struct reg **reg_list; struct reg **reg_list;
int reg_list_size; int reg_list_size;
@ -1147,8 +1150,9 @@ static int gdb_set_registers_packet(struct connection *connection,
} }
static int gdb_get_register_packet(struct connection *connection, static int gdb_get_register_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
char *reg_packet; char *reg_packet;
int reg_num = strtoul(packet + 1, NULL, 16); int reg_num = strtoul(packet + 1, NULL, 16);
struct reg **reg_list; struct reg **reg_list;
@ -1186,8 +1190,9 @@ static int gdb_get_register_packet(struct connection *connection,
} }
static int gdb_set_register_packet(struct connection *connection, static int gdb_set_register_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
char *separator; char *separator;
uint8_t *bin_buf; uint8_t *bin_buf;
int reg_num = strtoul(packet + 1, &separator, 16); int reg_num = strtoul(packet + 1, &separator, 16);
@ -1249,8 +1254,9 @@ static int gdb_error(struct connection *connection, int retval)
* 8191 bytes by the looks of it. Why 8191 bytes instead of 8192????? * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
*/ */
static int gdb_read_memory_packet(struct connection *connection, static int gdb_read_memory_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
char *separator; char *separator;
uint32_t addr = 0; uint32_t addr = 0;
uint32_t len = 0; uint32_t len = 0;
@ -1324,8 +1330,9 @@ static int gdb_read_memory_packet(struct connection *connection,
} }
static int gdb_write_memory_packet(struct connection *connection, static int gdb_write_memory_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
char *separator; char *separator;
uint32_t addr = 0; uint32_t addr = 0;
uint32_t len = 0; uint32_t len = 0;
@ -1382,8 +1389,9 @@ static int gdb_write_memory_packet(struct connection *connection,
} }
static int gdb_write_memory_binary_packet(struct connection *connection, static int gdb_write_memory_binary_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
char *separator; char *separator;
uint32_t addr = 0; uint32_t addr = 0;
uint32_t len = 0; uint32_t len = 0;
@ -1446,8 +1454,9 @@ static int gdb_write_memory_binary_packet(struct connection *connection,
} }
static int gdb_step_continue_packet(struct connection *connection, static int gdb_step_continue_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
int current = 0; int current = 0;
uint32_t address = 0x0; uint32_t address = 0x0;
int retval = ERROR_OK; int retval = ERROR_OK;
@ -1480,8 +1489,9 @@ static int gdb_step_continue_packet(struct connection *connection,
} }
static int gdb_breakpoint_watchpoint_packet(struct connection *connection, static int gdb_breakpoint_watchpoint_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
int type; int type;
enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */; enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
enum watchpoint_rw wp_type = WPT_READ /* dummy init to avoid warning */; enum watchpoint_rw wp_type = WPT_READ /* dummy init to avoid warning */;
@ -1674,7 +1684,7 @@ static int compare_bank (const void * a, const void * b)
} }
static int gdb_memory_map(struct connection *connection, static int gdb_memory_map(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
/* We get away with only specifying flash here. Regions that are not /* We get away with only specifying flash here. Regions that are not
* specified are treated as if we provided no memory map(if not we * specified are treated as if we provided no memory map(if not we
@ -1683,6 +1693,7 @@ static int gdb_memory_map(struct connection *connection,
* have to regenerate it a couple of times. * have to regenerate it a couple of times.
*/ */
struct target *target = get_target_from_connection(connection);
struct flash_bank *p; struct flash_bank *p;
char *xml = NULL; char *xml = NULL;
int size = 0; int size = 0;
@ -1818,10 +1829,11 @@ static int gdb_memory_map(struct connection *connection,
} }
static int gdb_query_packet(struct connection *connection, static int gdb_query_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct command_context *cmd_ctx = connection->cmd_ctx; struct command_context *cmd_ctx = connection->cmd_ctx;
struct gdb_connection *gdb_connection = connection->priv; struct gdb_connection *gdb_connection = connection->priv;
struct target *target = get_target_from_connection(connection);
if (strstr(packet, "qRcmd,")) if (strstr(packet, "qRcmd,"))
{ {
@ -1919,7 +1931,7 @@ static int gdb_query_packet(struct connection *connection,
} }
else if (strstr(packet, "qXfer:memory-map:read::") else if (strstr(packet, "qXfer:memory-map:read::")
&& (flash_get_bank_count() > 0)) && (flash_get_bank_count() > 0))
return gdb_memory_map(connection, target, packet, packet_size); return gdb_memory_map(connection, packet, packet_size);
else if (strstr(packet, "qXfer:features:read:")) else if (strstr(packet, "qXfer:features:read:"))
{ {
char *xml = NULL; char *xml = NULL;
@ -1972,7 +1984,7 @@ static int gdb_query_packet(struct connection *connection,
} }
static int gdb_v_packet(struct connection *connection, static int gdb_v_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct gdb_connection *gdb_connection = connection->priv; struct gdb_connection *gdb_connection = connection->priv;
struct gdb_service *gdb_service = connection->service->priv; struct gdb_service *gdb_service = connection->service->priv;
@ -2119,7 +2131,7 @@ static int gdb_v_packet(struct connection *connection,
return ERROR_OK; return ERROR_OK;
} }
static int gdb_detach(struct connection *connection, struct target *target) static int gdb_detach(struct connection *connection)
{ {
struct gdb_service *gdb_service = connection->service->priv; struct gdb_service *gdb_service = connection->service->priv;
@ -2207,61 +2219,43 @@ static int gdb_input_inner(struct connection *connection)
switch (packet[0]) switch (packet[0])
{ {
case 'T': // Is thread alive? case 'T': // Is thread alive?
gdb_thread_packet(connection, target, packet, packet_size); gdb_thread_packet(connection, packet, packet_size);
break; break;
case 'H': // Set current thread ( 'c' for step and continue, 'g' for all other operations ) case 'H': // Set current thread ( 'c' for step and continue, 'g' for all other operations )
gdb_thread_packet(connection, target, packet, packet_size); gdb_thread_packet(connection, packet, packet_size);
break; break;
case 'q': case 'q':
case 'Q': case 'Q':
retval = gdb_thread_packet(connection, retval = gdb_thread_packet(connection, packet, packet_size);
target, packet,
packet_size);
if ( retval == GDB_THREAD_PACKET_NOT_CONSUMED ) if ( retval == GDB_THREAD_PACKET_NOT_CONSUMED )
{ {
retval = gdb_query_packet(connection, retval = gdb_query_packet(connection, packet, packet_size);
target, packet,
packet_size);
} }
break; break;
case 'g': case 'g':
retval = gdb_get_registers_packet( retval = gdb_get_registers_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'G': case 'G':
retval = gdb_set_registers_packet( retval = gdb_set_registers_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'p': case 'p':
retval = gdb_get_register_packet( retval = gdb_get_register_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'P': case 'P':
retval = gdb_set_register_packet( retval = gdb_set_register_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'm': case 'm':
retval = gdb_read_memory_packet( retval = gdb_read_memory_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'M': case 'M':
retval = gdb_write_memory_packet( retval = gdb_write_memory_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'z': case 'z':
case 'Z': case 'Z':
retval = gdb_breakpoint_watchpoint_packet(connection, target, packet, packet_size); retval = gdb_breakpoint_watchpoint_packet(connection, packet, packet_size);
break; break;
case '?': case '?':
gdb_last_signal_packet( gdb_last_signal_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'c': case 'c':
case 's': case 's':
@ -2324,7 +2318,7 @@ static int gdb_input_inner(struct connection *connection)
{ {
/* Here we don't want packet processing to stop even if this fails, /* Here we don't want packet processing to stop even if this fails,
* so we use a local variable instead of retval. */ * so we use a local variable instead of retval. */
retval = gdb_step_continue_packet(connection, target, packet, packet_size); retval = gdb_step_continue_packet(connection, packet, packet_size);
if (retval != ERROR_OK) if (retval != ERROR_OK)
{ {
/* we'll never receive a halted condition... issue a false one.. */ /* we'll never receive a halted condition... issue a false one.. */
@ -2335,18 +2329,14 @@ static int gdb_input_inner(struct connection *connection)
} }
break; break;
case 'v': case 'v':
retval = gdb_v_packet( retval = gdb_v_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'D': case 'D':
retval = gdb_detach(connection, target); retval = gdb_detach(connection);
extended_protocol = 0; extended_protocol = 0;
break; break;
case 'X': case 'X':
retval = gdb_write_memory_binary_packet( retval = gdb_write_memory_binary_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
break; break;
@ -2373,18 +2363,14 @@ static int gdb_input_inner(struct connection *connection)
case 'j': case 'j':
/* packet supported only by smp target i.e cortex_a.c*/ /* packet supported only by smp target i.e cortex_a.c*/
/* handle smp packet replying coreid played to gbd */ /* handle smp packet replying coreid played to gbd */
gdb_read_smp_packet( gdb_read_smp_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
case 'J': case 'J':
/* packet supported only by smp target i.e cortex_a.c */ /* packet supported only by smp target i.e cortex_a.c */
/* handle smp packet setting coreid to be played at next /* handle smp packet setting coreid to be played at next
* resume to gdb */ * resume to gdb */
gdb_write_smp_packet( gdb_write_smp_packet(connection, packet, packet_size);
connection, target,
packet, packet_size);
break; break;
default: default:

6
src/server/gdb_server.h
View File

@ -40,6 +40,12 @@ int gdb_register_commands(struct command_context *command_context);
int gdb_put_packet(struct connection *connection, char *buffer, int len); int gdb_put_packet(struct connection *connection, char *buffer, int len);
static inline struct target *get_target_from_connection(struct connection *connection)
{
struct gdb_service *gdb_service = connection->service->priv;
return gdb_service->target;
}
#define ERROR_GDB_BUFFER_TOO_SMALL (-800) #define ERROR_GDB_BUFFER_TOO_SMALL (-800)
#define ERROR_GDB_TIMEOUT (-801) #define ERROR_GDB_TIMEOUT (-801)

6
src/target/smp.c
View File

@ -59,8 +59,9 @@ static const char DIGITS[16] = "0123456789abcdef";
/* packet j :smp status request */ /* packet j :smp status request */
int gdb_read_smp_packet(struct connection *connection, int gdb_read_smp_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
uint32_t len = sizeof(int32_t); uint32_t len = sizeof(int32_t);
uint8_t *buffer; uint8_t *buffer;
char *hex_buffer; char *hex_buffer;
@ -91,8 +92,9 @@ int gdb_read_smp_packet(struct connection *connection,
/* J : smp set request */ /* J : smp set request */
int gdb_write_smp_packet(struct connection *connection, int gdb_write_smp_packet(struct connection *connection,
struct target *target, char *packet, int packet_size) char *packet, int packet_size)
{ {
struct target *target = get_target_from_connection(connection);
char *separator; char *separator;
int coreid = 0; int coreid = 0;
int retval = ERROR_OK; int retval = ERROR_OK;

4
src/target/smp.h
View File

@ -19,7 +19,7 @@
***************************************************************************/ ***************************************************************************/
#include "server/server.h" #include "server/server.h"
int gdb_read_smp_packet(struct connection *connection, int gdb_read_smp_packet(struct connection *connection,
struct target *target, char *packet, int packet_size); char *packet, int packet_size);
int gdb_write_smp_packet(struct connection *connection, int gdb_write_smp_packet(struct connection *connection,
struct target *target, char *packet, int packet_size); char *packet, int packet_size);