gdbstub: Add infrastructure to parse cmd packets
PATCH v3 1/20 gdbstub: Add infrastructure to parse cmd packets
From: Jon Doron <[email protected]>
--- gdbstub.c | 215 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 215 insertions(+)
gdbstub.c +215 -0
@@ -1268,6 +1268,221 @@ out:return res; } +typedef union GdbCmdVariant { +const char *data; +uint8_t opcode; +unsigned long val_ul; +unsigned long long val_ull; +struct { +GDBThreadIdKind kind; +uint32_t pid; +uint32_t tid; + } thread_id; +}GdbCmdVariant ; + +static const char *cmd_next_param (const char *param,const char delimiter) +{ +const char *delim; +static char all_delimiters[] =",;:=" ; +static char no_delimiter[] ="\0" ; +char curr_delimiters[2 ] = {0 }; +const char *delimiters; + +if (delimiter =='?' ) { + delimiters = all_delimiters; + }else if (delimiter =='0' ) { + delimiters = no_delimiter; + }else if (delimiter =='.' && *param) { +return param +1 ; + }else { + curr_delimiters[0 ] = delimiter; + delimiters = curr_delimiters; + } + +while (*param) { + delim = delimiters; +while (*delim) { +if (*param == *delim) { +return param +1 ; + } + delim++; + } + param++; + } + +return param; +} + +static int cmd_parse_params (const char *data,const char *schema, +GdbCmdVariant *params,int *num_params) +{ +int curr_param; +const char *curr_schema, *curr_data; + + *num_params =0 ; + +if (!schema) { +return 0 ; + } + + curr_schema = schema; + curr_param =0 ; + curr_data = data; +while (curr_schema[0 ] && curr_schema[1 ] && *curr_data) { +switch (curr_schema[0 ]) { +case 'l' : +if (qemu_strtoul (curr_data, &curr_data,16 , + ¶ms[curr_param].val_ul)) { +return -EINVAL ; + } + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'L' : +if (qemu_strtou64 (curr_data, &curr_data,16 , + (uint64_t *)¶ms[curr_param].val_ull)) { +return -EINVAL ; + } + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 's' : + params[curr_param].data = curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'o' : + params[curr_param].opcode = *(uint8_t *)curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 't' : + params[curr_param].thread_id.kind = +read_thread_id (curr_data, &curr_data, + ¶ms[curr_param].thread_id.pid, + ¶ms[curr_param].thread_id.tid); + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'x' : + params[curr_param].data = curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case '?' : + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +default : +return -EINVAL ; + } + curr_schema +=2 ; + } + + *num_params = curr_param; +return 0 ; +} + +typedef struct GdbCmdContext { +GDBState *s; +GdbCmdVariant *params; +int num_params; +uint8_t mem_buf[MAX_PACKET_LENGTH ]; +char str_buf[MAX_PACKET_LENGTH +1 ]; +}GdbCmdContext ; + +typedef void (*GdbCmdHandler )(GdbCmdContext *gdb_ctx,void *user_ctx); + +/* +* cmd_startswith -> cmd is compared using startswith +* cmd_full_match -> cmd is compared using strcmp +* +* +* schema definitions: +* Each schema parameter entry consists of 2 chars, +* the first char represents the parameter type handling +* the second char represents the delimiter for the next parameter +* +* Currently supported schema types: +* 'l' -> unsigned long (stored in .val_ul) +* 'L' -> unsigned long long (stored in .val_ull) +* 's' -> string (stored in .data) +* 'o' -> single char (stored in .opcode) +* 't' -> thread id (stored in .thread_id) +* 'x' -> xml (stored in .data), must have a ':' delimiter +* '?' -> skip according to delimiter +* +* Currently supported delimiters: +* '?' -> Stop at any delimiter (",;:=\0") +* '0' -> Stop at "\0" +* '.' -> Skip 1 char unless reached "\0" +* Any other value is treated as the delimiter value itself +*/ +typedef struct GdbCmdParseEntry { +GdbCmdHandler handler; +const char *cmd; +union { +int flags; +struct { +int cmd_startswith:1 ; +int cmd_full_match:1 ; + }; + }; +const char *schema; +}GdbCmdParseEntry ; + +static inline int startswith (const char *string,const char *pattern) +{ +return !strncmp (string, pattern,strlen (pattern)); +} + +__attribute__((unused))static int process_string_cmd ( +GDBState *s,void *user_ctx,const char *data, +GdbCmdParseEntry *cmds,int num_cmds); + +static int process_string_cmd (GDBState *s,void *user_ctx,const char *data, +GdbCmdParseEntry *cmds,int num_cmds) +{ +int i, schema_len, max_num_params; +GdbCmdContext gdb_ctx; + +if (!cmds) { +return -1 ; + } + +for (i =0 ; i < num_cmds; i++) { +if (!cmds[i].handler || !cmds[i].cmd || + (cmds[i].cmd_startswith && !startswith (data, cmds[i].cmd)) || + (cmds[i].cmd_full_match &&strcmp (data, cmds[i].cmd))) { +continue ; + } + + max_num_params =0 ; +if (cmds[i].schema) { + schema_len =strlen (cmds[i].schema); +if (schema_len %2 ) { +return -2 ; + } + + max_num_params = schema_len /2 ; + } + + gdb_ctx.params = + (GdbCmdVariant *)alloca (sizeof (*gdb_ctx.params) * max_num_params); +memset (gdb_ctx.params,0 ,sizeof (*gdb_ctx.params) * max_num_params); + +if (cmd_parse_params (&data[strlen (cmds[i].cmd)], cmds[i].schema, + gdb_ctx.params, &gdb_ctx.num_params)) { +return -1 ; + } + + gdb_ctx.s = s; + cmds[i].handler (&gdb_ctx, user_ctx); +return 0 ; + } + +return -1 ; +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
Signature · 1 line
2.20.1
PATCH v3 2/20 gdbstub: Implement deatch (D pkt) with new infra
From: Jon Doron <[email protected]>
--- gdbstub.c | 82 +++++++++++++++++++++++++++++-------------------------- 1 file changed, 43 insertions(+), 39 deletions(-)
gdbstub.c +43 -39
@@ -1435,10 +1435,6 @@ static inline int startswith(const char *string, const char *pattern)return !strncmp (string, pattern,strlen (pattern)); } -__attribute__((unused))static int process_string_cmd ( -GDBState *s,void *user_ctx,const char *data, -GdbCmdParseEntry *cmds,int num_cmds); -static int process_string_cmd (GDBState *s,void *user_ctx,const char *data,GdbCmdParseEntry *cmds,int num_cmds) {
@@ -1483,6 +1479,41 @@ static int process_string_cmd(GDBState *s, void *user_ctx, const char *data,return -1 ; } +static void handle_detach (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +GDBProcess *process; +GDBState *s = gdb_ctx->s; +uint32_t pid =1 ; + +if (s->multiprocess) { +if (!gdb_ctx->num_params) { +put_packet (s,"E22" ); +return ; + } + + pid = gdb_ctx->params[0 ].val_ul; + } + + process =gdb_get_process (s, pid); +gdb_process_breakpoint_remove_all (s, process); + process->attached = false; + +if (pid ==gdb_get_cpu_pid (s, s->c_cpu)) { + s->c_cpu =gdb_first_attached_cpu (s); + } + +if (pid ==gdb_get_cpu_pid (s, s->g_cpu)) { + s->g_cpu =gdb_first_attached_cpu (s); + } + +if (!s->c_cpu) { +/* No more process attached */ + gdb_syscall_mode =GDB_SYS_DISABLED ; +gdb_continue (s); + } +put_packet (s,"OK" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1597,42 +1628,15 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)error_report ("QEMU: Terminated via GDBstub" );exit (0 );case 'D' : -/* Detach packet */ - pid =1 ; - -if (s->multiprocess) { -unsigned long lpid; -if (*p !=';' ) { -put_packet (s,"E22" ); -break ; - } - -if (qemu_strtoul (p +1 , &p,16 , &lpid)) { -put_packet (s,"E22" ); -break ; - } - - pid = lpid; - } - - process =gdb_get_process (s, pid); -gdb_process_breakpoint_remove_all (s, process); - process->attached = false; - -if (pid ==gdb_get_cpu_pid (s, s->c_cpu)) { - s->c_cpu =gdb_first_attached_cpu (s); - } - -if (pid ==gdb_get_cpu_pid (s, s->g_cpu)) { - s->g_cpu =gdb_first_attached_cpu (s); - } - -if (s->c_cpu ==NULL ) { -/* No more process attached */ - gdb_syscall_mode =GDB_SYS_DISABLED ; -gdb_continue (s); + { +static GdbCmdParseEntry deatch_cmd_desc = { + .handler = handle_detach, + .cmd ="D" , + .cmd_startswith =1 , + .schema ="?.l0" + }; +process_string_cmd (s,NULL , line_buf, &deatch_cmd_desc,1 ); } -put_packet (s,"OK" );break ;case 's' :if (*p !='\0' ) {
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v3 02/20] gdbstub: Implement deatch (D pkt) with new infra
gdbstub.c static int gdb_handle_packet(GDBState *s, const char *line_buf) · line 1632
Quoted 2 lines · On 4/24/19 7:26 AM, [email protected] wrote:
gdbstub.c +2
-0+ { +static GdbCmdParseEntry deatch_cmd_desc = {
static const. s/deatch/detach/.
That'll require changes to patch 1, since process_string_cmd doesn't take a const GdbCmdParseEntry pointer.
gdbstub.c static int gdb_handle_packet(GDBState *s, const char *line_buf) · line 1638
Quoted 6 lines
gdbstub.c +6
-0+ .handler = handle_detach, + .cmd = "D", + .cmd_startswith = 1, + .schema = "?.l0" + }; +process_string_cmd (s,NULL , line_buf, &deatch_cmd_desc,1 );
process_string_cmd returns errors, which you make no attempt to handle here. Should the errors returns in fact be asserts?
r~
Re: [Qemu-devel] [PATCH v3 02/20] gdbstub: Implement deatch (D pkt) with new infra
In reply to [email protected]Quoted 3 lines · [email protected] writes:
From: Jon Doron <[email protected]>
Signed-otff-by Jon Doron <[email protected]>
mini typo...
(btw you can either create a editor shortcut for adding s-o-b tags or use --signoff while re-basing)
Otherwise:
Quoted 102 lines
--- gdbstub.c | 82 +++++++++++++++++++++++++++++-------------------------- 1 file changed, 43 insertions(+), 39 deletions(-)gdbstub.c +38
-38@@ -1435,10 +1435,6 @@ static inline int startswith(const char *string, const char *pattern)return !strncmp (string, pattern,strlen (pattern)); } -__attribute__((unused))static int process_string_cmd ( -GDBState *s,void *user_ctx,const char *data, -GdbCmdParseEntry *cmds,int num_cmds); -static int process_string_cmd (GDBState *s,void *user_ctx,const char *data,GdbCmdParseEntry *cmds,int num_cmds) {@@ -1483,6 +1479,41 @@ static int process_string_cmd(GDBState *s, void *user_ctx, const char *data,return -1 ; } +static void handle_detach (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +GDBProcess *process; +GDBState *s = gdb_ctx->s; +uint32_t pid =1 ; + +if (s->multiprocess) { +if (!gdb_ctx->num_params) { +put_packet (s,"E22" ); +return ; + } + + pid = gdb_ctx->params[0 ].val_ul; + } + + process =gdb_get_process (s, pid); +gdb_process_breakpoint_remove_all (s, process); + process->attached = false; + +if (pid ==gdb_get_cpu_pid (s, s->c_cpu)) { + s->c_cpu =gdb_first_attached_cpu (s); + } + +if (pid ==gdb_get_cpu_pid (s, s->g_cpu)) { + s->g_cpu =gdb_first_attached_cpu (s); + } + +if (!s->c_cpu) { +/* No more process attached */ + gdb_syscall_mode =GDB_SYS_DISABLED ; +gdb_continue (s); + } +put_packet (s,"OK" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;@@ -1597,42 +1628,15 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)error_report ("QEMU: Terminated via GDBstub" );exit (0 );case 'D' : -/* Detach packet */ - pid =1 ; - -if (s->multiprocess) { -unsigned long lpid; -if (*p !=';' ) { -put_packet (s,"E22" ); -break ; - } - -if (qemu_strtoul (p +1 , &p,16 , &lpid)) { -put_packet (s,"E22" ); -break ; - } - - pid = lpid; - } - - process =gdb_get_process (s, pid); -gdb_process_breakpoint_remove_all (s, process); - process->attached = false; - -if (pid ==gdb_get_cpu_pid (s, s->c_cpu)) { - s->c_cpu =gdb_first_attached_cpu (s); - } - -if (pid ==gdb_get_cpu_pid (s, s->g_cpu)) { - s->g_cpu =gdb_first_attached_cpu (s); - } - -if (s->c_cpu ==NULL ) { -/* No more process attached */ - gdb_syscall_mode =GDB_SYS_DISABLED ; -gdb_continue (s); + { +static GdbCmdParseEntry deatch_cmd_desc = { + .handler = handle_detach,
gdbstub.c static int gdb_handle_packet(GDBState *s, const char *line_buf) · line 1642
Quoted 10 lines
gdbstub.c +5
-1+ .cmd = "D", + .cmd_startswith = 1, + .schema = "?.l0" + }; +process_string_cmd (s,NULL , line_buf, &deatch_cmd_desc,1 ); } -put_packet (s,"OK" );break ;case 's' :if (*p !='\0' ) {
--
Alex Bennée
PATCH v3 3/20 gdbstub: Implement thread_alive (T pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 43 ++++++++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 11 deletions(-)
gdbstub.c +32 -11
@@ -1514,6 +1514,30 @@ static void handle_detach(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (s,"OK" ); } +static void handle_thread_alive (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +CPUState *cpu; + +if (!gdb_ctx->num_params) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +if (gdb_ctx->params[0 ].thread_id.kind ==GDB_READ_THREAD_ERR ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + + cpu =gdb_get_cpu (gdb_ctx->s, gdb_ctx->params[0 ].thread_id.pid, + gdb_ctx->params[0 ].thread_id.tid); +if (!cpu) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +put_packet (gdb_ctx->s,"OK" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1813,17 +1837,14 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'T' : - thread_kind =read_thread_id (p, &p, &pid, &tid); -if (thread_kind ==GDB_READ_THREAD_ERR ) { -put_packet (s,"E22" ); -break ; - } - cpu =gdb_get_cpu (s, pid, tid); - -if (cpu !=NULL ) { -put_packet (s,"OK" ); - }else { -put_packet (s,"E22" ); + { +static GdbCmdParseEntry thread_alive_cmd_desc = { + .handler = handle_thread_alive, + .cmd ="T" , + .cmd_startswith =1 , + .schema ="t0" + }; +process_string_cmd (s,NULL , line_buf, &thread_alive_cmd_desc,1 ); }break ;case 'q' :
Signature · 1 line
2.20.1
PATCH v3 4/20 gdbstub: Implement continue (c pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-)
gdbstub.c +19 -6
@@ -1538,6 +1538,16 @@ static void handle_thread_alive(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"OK" ); } +static void handle_continue (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (gdb_ctx->num_params) { +gdb_set_cpu_pc (gdb_ctx->s, gdb_ctx->params[0 ].val_ull); + } + + gdb_ctx->s->signal =0 ; +gdb_continue (gdb_ctx->s); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1573,13 +1583,16 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)gdb_breakpoint_remove_all ();break ;case 'c' : -if (*p !='\0' ) { - addr =strtoull (p, (char **)&p,16 ); -gdb_set_cpu_pc (s, addr); + { +static GdbCmdParseEntry continue_cmd_desc = { + .handler = handle_continue, + .cmd ="c" , + .cmd_startswith =1 , + .schema ="L0" + }; +process_string_cmd (s,NULL , line_buf, &continue_cmd_desc,1 ); } - s->signal =0 ; -gdb_continue (s); -return RS_IDLE ; +break ;case 'C' : s->signal =gdb_signal_to_target (strtoul (p, (char **)&p,16 ));if (s->signal ==-1 )
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v3 04/20] gdbstub: Implement continue (c pkt) with new infra
Quoted 3 lines · [email protected] writes:
From: Jon Doron <[email protected]>
Signed-off-by Jon Doron <[email protected]>
Quoted 38 lines
--- gdbstub.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-)gdbstub.c +16
-3@@ -1538,6 +1538,16 @@ static void handle_thread_alive(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"OK" ); } +static void handle_continue (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (gdb_ctx->num_params) { +gdb_set_cpu_pc (gdb_ctx->s, gdb_ctx->params[0 ].val_ull); + } + + gdb_ctx->s->signal =0 ; +gdb_continue (gdb_ctx->s); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;@@ -1573,13 +1583,16 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)gdb_breakpoint_remove_all ();break ;case 'c' : -if (*p !='\0' ) { - addr =strtoull (p, (char **)&p,16 ); -gdb_set_cpu_pc (s, addr); + { +static GdbCmdParseEntry continue_cmd_desc = { + .handler = handle_continue, + .cmd ="c" , + .cmd_startswith =1 , + .schema ="L0"
gdbstub.c static int gdb_handle_packet(GDBState *s, const char *line_buf) · line 1598
Quoted 10 lines
gdbstub.c +3
-3+ }; +process_string_cmd (s,NULL , line_buf, &continue_cmd_desc,1 ); } - s->signal =0 ; -gdb_continue (s); -return RS_IDLE ; +break ;case 'C' : s->signal =gdb_signal_to_target (strtoul (p, (char **)&p,16 ));if (s->signal ==-1 )
--
Alex Bennée
PATCH v3 5/20 gdbstub: Implement continue with signal (C pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-)
gdbstub.c +25 -5
@@ -1548,6 +1548,21 @@ static void handle_continue(GdbCmdContext *gdb_ctx, void *user_ctx)gdb_continue (gdb_ctx->s); } +static void handle_cont_with_sig (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +unsigned long signal =0 ; + +if (gdb_ctx->num_params) { + signal = gdb_ctx->params[0 ].val_ul; + } + + gdb_ctx->s->signal =gdb_signal_to_target (signal); +if (gdb_ctx->s->signal ==-1 ) { + gdb_ctx->s->signal =0 ; + } +gdb_continue (gdb_ctx->s); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1594,11 +1609,16 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'C' : - s->signal =gdb_signal_to_target (strtoul (p, (char **)&p,16 )); -if (s->signal ==-1 ) - s->signal =0 ; -gdb_continue (s); -return RS_IDLE ; + { +static GdbCmdParseEntry cont_with_sig_cmd_desc = { + .handler = handle_cont_with_sig, + .cmd ="C" , + .cmd_startswith =1 , + .schema ="l0" + }; +process_string_cmd (s,NULL , line_buf, &cont_with_sig_cmd_desc,1 ); + } +break ;case 'v' :if (strncmp (p,"Cont" ,4 ) ==0 ) { p +=4 ;
Signature · 1 line
2.20.1
PATCH v3 6/20 gdbstub: Implement set_thread (H pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 79 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 49 insertions(+), 30 deletions(-)
gdbstub.c +49 -30
@@ -1563,6 +1563,47 @@ static void handle_cont_with_sig(GdbCmdContext *gdb_ctx, void *user_ctx)gdb_continue (gdb_ctx->s); } +static void handle_set_thread (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +CPUState *cpu; + +if (gdb_ctx->num_params <2 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +if (gdb_ctx->params[1 ].thread_id.kind ==GDB_READ_THREAD_ERR ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +if (gdb_ctx->params[1 ].thread_id.kind !=GDB_ONE_THREAD ) { +put_packet (gdb_ctx->s,"OK" ); +return ; + } + + cpu =gdb_get_cpu (gdb_ctx->s, gdb_ctx->params[1 ].thread_id.pid, + gdb_ctx->params[1 ].thread_id.tid); +if (!cpu) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +switch (gdb_ctx->params[0 ].opcode) { +case 'c' : + gdb_ctx->s->c_cpu = cpu; +put_packet (gdb_ctx->s,"OK" ); +break ; +case 'g' : + gdb_ctx->s->g_cpu = cpu; +put_packet (gdb_ctx->s,"OK" ); +break ; +default : +put_packet (gdb_ctx->s,"E22" ); +break ; + } +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1576,7 +1617,6 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)char thread_id[16 ];uint8_t *registers;target_ulong addr, len; -GDBThreadIdKind thread_kind;trace_gdbstub_io_command (line_buf);
@@ -1838,35 +1878,14 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)put_packet (s,"E22" );break ;case 'H' : - type = *p++; - - thread_kind =read_thread_id (p, &p, &pid, &tid); -if (thread_kind ==GDB_READ_THREAD_ERR ) { -put_packet (s,"E22" ); -break ; - } - -if (thread_kind !=GDB_ONE_THREAD ) { -put_packet (s,"OK" ); -break ; - } - cpu =gdb_get_cpu (s, pid, tid); -if (cpu ==NULL ) { -put_packet (s,"E22" ); -break ; - } -switch (type) { -case 'c' : - s->c_cpu = cpu; -put_packet (s,"OK" ); -break ; -case 'g' : - s->g_cpu = cpu; -put_packet (s,"OK" ); -break ; -default : -put_packet (s,"E22" ); -break ; + { +static GdbCmdParseEntry set_thread_cmd_desc = { + .handler = handle_set_thread, + .cmd ="H" , + .cmd_startswith =1 , + .schema ="o.t0" + }; +process_string_cmd (s,NULL , line_buf, &set_thread_cmd_desc,1 ); }break ;case 'T' :
Signature · 1 line
2.20.1
PATCH v3 7/20 gdbstub: Implement insert breakpoint (Z pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
gdbstub.c +33 -0
@@ -1604,6 +1604,29 @@ static void handle_set_thread(GdbCmdContext *gdb_ctx, void *user_ctx) } } +static void handle_insert_bp (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +int res; + +if (gdb_ctx->num_params <3 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + + res =gdb_breakpoint_insert (gdb_ctx->params[1 ].val_ull, + gdb_ctx->params[2 ].val_ull, + gdb_ctx->params[0 ].val_ul); +if (res >=0 ) { +put_packet (gdb_ctx->s,"OK" ); +return ; + }else if (res == -ENOSYS ) { +put_packet (gdb_ctx->s,"" ); +return ; + } + +put_packet (gdb_ctx->s,"E22" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1858,6 +1881,16 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)put_packet (s,"OK" );break ;case 'Z' : + { +static GdbCmdParseEntry insert_bp_cmd_desc = { + .handler = handle_insert_bp, + .cmd ="Z" , + .cmd_startswith =1 , + .schema ="l?L?L0" + }; +process_string_cmd (s,NULL , line_buf, &insert_bp_cmd_desc,1 ); + } +break ;case 'z' : type =strtoul (p, (char **)&p,16 );if (*p ==',' )
Signature · 1 line
2.20.1
PATCH v3 8/20 gdbstub: Implement remove breakpoint (z pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 49 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 32 insertions(+), 17 deletions(-)
gdbstub.c +32 -17
@@ -1627,6 +1627,29 @@ static void handle_insert_bp(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"E22" ); } +static void handle_remove_bp (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +int res; + +if (gdb_ctx->num_params <3 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + + res =gdb_breakpoint_remove (gdb_ctx->params[1 ].val_ull, + gdb_ctx->params[2 ].val_ull, + gdb_ctx->params[0 ].val_ul); +if (res >=0 ) { +put_packet (gdb_ctx->s,"OK" ); +return ; + }else if (res == -ENOSYS ) { +put_packet (gdb_ctx->s,"" ); +return ; + } + +put_packet (gdb_ctx->s,"E22" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1892,23 +1915,15 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'z' : - type =strtoul (p, (char **)&p,16 ); -if (*p ==',' ) - p++; - addr =strtoull (p, (char **)&p,16 ); -if (*p ==',' ) - p++; - len =strtoull (p, (char **)&p,16 ); -if (ch =='Z' ) - res =gdb_breakpoint_insert (addr, len, type); -else - res =gdb_breakpoint_remove (addr, len, type); -if (res >=0 ) -put_packet (s,"OK" ); -else if (res == -ENOSYS ) -put_packet (s,"" ); -else -put_packet (s,"E22" ); + { +static GdbCmdParseEntry remove_bp_cmd_desc = { + .handler = handle_remove_bp, + .cmd ="z" , + .cmd_startswith =1 , + .schema ="l?L?L0" + }; +process_string_cmd (s,NULL , line_buf, &remove_bp_cmd_desc,1 ); + }break ;case 'H' : {
Signature · 1 line
2.20.1
PATCH v3 9/20 gdbstub: Implement set register (P pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 39 ++++++++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 9 deletions(-)
gdbstub.c +30 -9
@@ -1650,6 +1650,27 @@ static void handle_remove_bp(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"E22" ); } +static void handle_set_reg (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +int reg_size; + +if (!gdb_has_xml) { +put_packet (gdb_ctx->s,"" ); +return ; + } + +if (gdb_ctx->num_params <2 ) { +put_packet (gdb_ctx->s,"" ); +return ; + } + + reg_size =strlen (gdb_ctx->params[1 ].data) /2 ; +hextomem (gdb_ctx->mem_buf, gdb_ctx->params[1 ].data, reg_size); +gdb_write_register (gdb_ctx->s->g_cpu, gdb_ctx->mem_buf, + gdb_ctx->params[0 ].val_ull); +put_packet (gdb_ctx->s,"OK" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1893,15 +1914,15 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'P' : -if (!gdb_has_xml) - goto unknown_command; - addr =strtoull (p, (char **)&p,16 ); -if (*p =='=' ) - p++; - reg_size =strlen (p) /2 ; -hextomem (mem_buf, p, reg_size); -gdb_write_register (s->g_cpu, mem_buf, addr); -put_packet (s,"OK" ); + { +static GdbCmdParseEntry set_reg_cmd_desc = { + .handler = handle_set_reg, + .cmd ="P" , + .cmd_startswith =1 , + .schema ="L?s0" + }; +process_string_cmd (s,NULL , line_buf, &set_reg_cmd_desc,1 ); + }break ;case 'Z' : {
Signature · 1 line
2.20.1
PATCH v3 10/20 gdbstub: Implement get register (p pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 50 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 38 insertions(+), 12 deletions(-)
gdbstub.c +38 -12
@@ -1671,6 +1671,36 @@ static void handle_set_reg(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"OK" ); } +static void handle_get_reg (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +int reg_size; + +/* +* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable. +* This works, but can be very slow. Anything new enough to +* understand XML also knows how to use this properly. +*/ +if (!gdb_has_xml) { +put_packet (gdb_ctx->s,"" ); +return ; + } + +if (!gdb_ctx->num_params) { +put_packet (gdb_ctx->s,"E14" ); +return ; + } + + reg_size =gdb_read_register (gdb_ctx->s->g_cpu, gdb_ctx->mem_buf, + gdb_ctx->params[0 ].val_ull); +if (!reg_size) { +put_packet (gdb_ctx->s,"E14" ); +return ; + } + +memtohex (gdb_ctx->str_buf, gdb_ctx->mem_buf, reg_size); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1899,18 +1929,14 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'p' : -/* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable. -This works, but can be very slow. Anything new enough to -understand XML also knows how to use this properly. */ -if (!gdb_has_xml) - goto unknown_command; - addr =strtoull (p, (char **)&p,16 ); - reg_size =gdb_read_register (s->g_cpu, mem_buf, addr); -if (reg_size) { -memtohex (buf, mem_buf, reg_size); -put_packet (s, buf); - }else { -put_packet (s,"E14" ); + { +static GdbCmdParseEntry get_reg_cmd_desc = { + .handler = handle_get_reg, + .cmd ="p" , + .cmd_startswith =1 , + .schema ="L0" + }; +process_string_cmd (s,NULL , line_buf, &get_reg_cmd_desc,1 ); }break ;case 'P' :
Signature · 1 line
2.20.1
PATCH v3 11/20 gdbstub: Implement write memory (M pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 51 +++++++++++++++++++++++++++++++++------------------ 1 file changed, 33 insertions(+), 18 deletions(-)
gdbstub.c +33 -18
@@ -1701,6 +1701,31 @@ static void handle_get_reg(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s, gdb_ctx->str_buf); } +static void handle_write_mem (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (gdb_ctx->num_params <3 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +/* hextomem() reads 2*len bytes */ +if (gdb_ctx->params[1 ].val_ull >strlen (gdb_ctx->params[2 ].data) /2 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +hextomem (gdb_ctx->mem_buf, gdb_ctx->params[2 ].data, + gdb_ctx->params[1 ].val_ull); +if (target_memory_rw_debug (gdb_ctx->s->g_cpu, gdb_ctx->params[0 ].val_ull, + gdb_ctx->mem_buf, + gdb_ctx->params[1 ].val_ull, true)) { +put_packet (gdb_ctx->s,"E14" ); +return ; + } + +put_packet (gdb_ctx->s,"OK" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1908,24 +1933,14 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'M' : - addr =strtoull (p, (char **)&p,16 ); -if (*p ==',' ) - p++; - len =strtoull (p, (char **)&p,16 ); -if (*p ==':' ) - p++; - -/* hextomem() reads 2*len bytes */ -if (len >strlen (p) /2 ) { -put_packet (s,"E22" ); -break ; - } -hextomem (mem_buf, p, len); -if (target_memory_rw_debug (s->g_cpu, addr, mem_buf, len, - true) !=0 ) { -put_packet (s,"E14" ); - }else { -put_packet (s,"OK" ); + { +static GdbCmdParseEntry write_mem_cmd_desc = { + .handler = handle_write_mem, + .cmd ="M" , + .cmd_startswith =1 , + .schema ="L,L:s0" + }; +process_string_cmd (s,NULL , line_buf, &write_mem_cmd_desc,1 ); }break ;case 'p' :
Signature · 1 line
2.20.1
PATCH v3 12/20 gdbstub: Implement read memory (m pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 48 ++++++++++++++++++++++++++++++++---------------- 1 file changed, 32 insertions(+), 16 deletions(-)
gdbstub.c +32 -16
@@ -1726,6 +1726,30 @@ static void handle_write_mem(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"OK" ); } +static void handle_read_mem (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (gdb_ctx->num_params <2 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +/* memtohex() doubles the required space */ +if (gdb_ctx->params[1 ].val_ull >MAX_PACKET_LENGTH /2 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + +if (target_memory_rw_debug (gdb_ctx->s->g_cpu, gdb_ctx->params[0 ].val_ull, + gdb_ctx->mem_buf, + gdb_ctx->params[1 ].val_ull, false)) { +put_packet (gdb_ctx->s,"E14" ); +return ; + } + +memtohex (gdb_ctx->str_buf, gdb_ctx->mem_buf, gdb_ctx->params[1 ].val_ull); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1914,22 +1938,14 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)put_packet (s,"OK" );break ;case 'm' : - addr =strtoull (p, (char **)&p,16 ); -if (*p ==',' ) - p++; - len =strtoull (p,NULL ,16 ); - -/* memtohex() doubles the required space */ -if (len >MAX_PACKET_LENGTH /2 ) { -put_packet (s,"E22" ); -break ; - } - -if (target_memory_rw_debug (s->g_cpu, addr, mem_buf, len, false) !=0 ) { -put_packet (s,"E14" ); - }else { -memtohex (buf, mem_buf, len); -put_packet (s, buf); + { +static GdbCmdParseEntry read_mem_cmd_desc = { + .handler = handle_read_mem, + .cmd ="m" , + .cmd_startswith =1 , + .schema ="L,L0" + }; +process_string_cmd (s,NULL , line_buf, &read_mem_cmd_desc,1 ); }break ;case 'M' :
Signature · 1 line
2.20.1
PATCH v3 13/20 gdbstub: Implement write all registers (G pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 41 +++++++++++++++++++++++++++++++---------- 1 file changed, 31 insertions(+), 10 deletions(-)
gdbstub.c +31 -10
@@ -1750,6 +1750,29 @@ static void handle_read_mem(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s, gdb_ctx->str_buf); } +static void handle_write_all_regs (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +target_ulong addr, len; +uint8_t *registers; +int reg_size; + +if (!gdb_ctx->num_params) { +return ; + } + +cpu_synchronize_state (gdb_ctx->s->g_cpu); + registers = gdb_ctx->mem_buf; + len =strlen (gdb_ctx->params[0 ].data) /2 ; +hextomem (registers, gdb_ctx->params[0 ].data, len); +for (addr =0 ; addr < gdb_ctx->s->g_cpu->gdb_num_g_regs && len >0 ; + addr++) { + reg_size =gdb_write_register (gdb_ctx->s->g_cpu, registers, addr); + len -= reg_size; + registers += reg_size; + } +put_packet (gdb_ctx->s,"OK" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1761,7 +1784,6 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)uint8_t mem_buf[MAX_PACKET_LENGTH ];char buf[sizeof (mem_buf) +1 /* trailing NUL */ ];char thread_id[16 ]; -uint8_t *registers;target_ulong addr, len;trace_gdbstub_io_command (line_buf);
@@ -1926,16 +1948,15 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)put_packet (s, buf);break ;case 'G' : -cpu_synchronize_state (s->g_cpu); - registers = mem_buf; - len =strlen (p) /2 ; -hextomem ((uint8_t *)registers, p, len); -for (addr =0 ; addr < s->g_cpu->gdb_num_g_regs && len >0 ; addr++) { - reg_size =gdb_write_register (s->g_cpu, registers, addr); - len -= reg_size; - registers += reg_size; + { +static GdbCmdParseEntry write_all_regs_cmd_desc = { + .handler = handle_write_all_regs, + .cmd ="G" , + .cmd_startswith =1 , + .schema ="s0" + }; +process_string_cmd (s,NULL , line_buf, &write_all_regs_cmd_desc,1 ); } -put_packet (s,"OK" );break ;case 'm' : {
Signature · 1 line
2.20.1
PATCH v3 14/20 gdbstub: Implement read all registers (g pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-)
gdbstub.c +23 -8
@@ -1773,6 +1773,21 @@ static void handle_write_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"OK" ); } +static void handle_read_all_regs (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +target_ulong addr, len; + +cpu_synchronize_state (gdb_ctx->s->g_cpu); + len =0 ; +for (addr =0 ; addr < gdb_ctx->s->g_cpu->gdb_num_g_regs; addr++) { + len +=gdb_read_register (gdb_ctx->s->g_cpu, gdb_ctx->mem_buf + len, + addr); + } + +memtohex (gdb_ctx->str_buf, gdb_ctx->mem_buf, len); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1780,7 +1795,7 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)CPUClass *cc;const char *p;uint32_t pid, tid; -int ch, reg_size, type, res; +int ch, type, res;uint8_t mem_buf[MAX_PACKET_LENGTH ];char buf[sizeof (mem_buf) +1 /* trailing NUL */ ];char thread_id[16 ];
@@ -1938,14 +1953,14 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'g' : -cpu_synchronize_state (s->g_cpu); - len =0 ; -for (addr =0 ; addr < s->g_cpu->gdb_num_g_regs; addr++) { - reg_size =gdb_read_register (s->g_cpu, mem_buf + len, addr); - len += reg_size; + { +static GdbCmdParseEntry read_all_regs_cmd_desc = { + .handler = handle_read_all_regs, + .cmd ="g" , + .cmd_startswith =1 + }; +process_string_cmd (s,NULL , line_buf, &read_all_regs_cmd_desc,1 ); } -memtohex (buf, mem_buf, len); -put_packet (s, buf);break ;case 'G' : {
Signature · 1 line
2.20.1
PATCH v3 15/20 gdbstub: Implement file io (F pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 62 +++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 40 insertions(+), 22 deletions(-)
gdbstub.c +40 -22
@@ -1788,6 +1788,39 @@ static void handle_read_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s, gdb_ctx->str_buf); } +static void handle_file_io (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +int num_syscall_params; +GdbCmdVariant syscall_params[3 ] = {}; + +if (!gdb_ctx->num_params) { +return ; + } + +if (cmd_parse_params (gdb_ctx->params[0 ].data,"L,L,o0" , syscall_params, + &num_syscall_params)) { +return ; + } + +if (!num_syscall_params) { +return ; + } + +if (gdb_ctx->s->current_syscall_cb) { + gdb_ctx->s->current_syscall_cb (gdb_ctx->s->c_cpu, + (target_ulong )syscall_params[0 ].val_ull, + (target_ulong )syscall_params[1 ].val_ull); + gdb_ctx->s->current_syscall_cb =NULL ; + } + +if (syscall_params[2 ].opcode == (uint8_t )'C' ) { +put_packet (gdb_ctx->s,"T02" ); +return ; + } + +gdb_continue (gdb_ctx->s); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1928,28 +1961,13 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)return RS_IDLE ;case 'F' : { -target_ulong ret; -target_ulong err; - - ret =strtoull (p, (char **)&p,16 ); -if (*p ==',' ) { - p++; - err =strtoull (p, (char **)&p,16 ); - }else { - err =0 ; - } -if (*p ==',' ) - p++; - type = *p; -if (s->current_syscall_cb) { - s->current_syscall_cb (s->c_cpu, ret, err); - s->current_syscall_cb =NULL ; - } -if (type =='C' ) { -put_packet (s,"T02" ); - }else { -gdb_continue (s); - } +static GdbCmdParseEntry file_io_cmd_desc = { + .handler = handle_file_io, + .cmd ="F" , + .cmd_startswith =1 , + .schema ="s0" + }; +process_string_cmd (s,NULL , line_buf, &file_io_cmd_desc,1 ); }break ;case 'g' :
Signature · 1 line
2.20.1
PATCH v3 16/20 gdbstub: Implement step (s pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-)
gdbstub.c +19 -6
@@ -1821,6 +1821,16 @@ static void handle_file_io(GdbCmdContext *gdb_ctx, void *user_ctx)gdb_continue (gdb_ctx->s); } +static void handle_step (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (gdb_ctx->num_params) { +gdb_set_cpu_pc (gdb_ctx->s, (target_ulong )gdb_ctx->params[0 ].val_ull); + } + +cpu_single_step (gdb_ctx->s->c_cpu, sstep_flags); +gdb_continue (gdb_ctx->s); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1952,13 +1962,16 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 's' : -if (*p !='\0' ) { - addr =strtoull (p, (char **)&p,16 ); -gdb_set_cpu_pc (s, addr); + { +static GdbCmdParseEntry step_cmd_desc = { + .handler = handle_step, + .cmd ="s" , + .cmd_startswith =1 , + .schema ="L0" + }; +process_string_cmd (s,NULL , line_buf, &step_cmd_desc,1 ); } -cpu_single_step (s->c_cpu, sstep_flags); -gdb_continue (s); -return RS_IDLE ; +break ;case 'F' : {static GdbCmdParseEntry file_io_cmd_desc = {
Signature · 1 line
2.20.1
PATCH v3 17/20 gdbstub: Implement v commands with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 170 +++++++++++++++++++++++++++++++++++------------------- 1 file changed, 110 insertions(+), 60 deletions(-)
gdbstub.c +110 -60
@@ -1831,6 +1831,106 @@ static void handle_step(GdbCmdContext *gdb_ctx, void *user_ctx)gdb_continue (gdb_ctx->s); } +static void handle_v_cont_query (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +put_packet (gdb_ctx->s,"vCont;c;C;s;S" ); +} + +static void handle_v_cont (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +int res; + +if (!gdb_ctx->num_params) { +return ; + } + + res =gdb_handle_vcont (gdb_ctx->s, gdb_ctx->params[0 ].data); +if ((res == -EINVAL ) || (res == -ERANGE )) { +put_packet (gdb_ctx->s,"E22" ); + }else if (res) { +put_packet (gdb_ctx->s,"\0" ); + } +} + +static void handle_v_attach (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +GDBProcess *process; +CPUState *cpu; +char thread_id[16 ]; + +strcpy (gdb_ctx->str_buf,"E22" ); +if (!gdb_ctx->num_params) { + goto cleanup; + } + + process =gdb_get_process (gdb_ctx->s, gdb_ctx->params[0 ].val_ul); +if (!process) { + goto cleanup; + } + + cpu =get_first_cpu_in_process (gdb_ctx->s, process); +if (!cpu) { + goto cleanup; + } + + process->attached = true; + gdb_ctx->s->g_cpu = cpu; + gdb_ctx->s->c_cpu = cpu; + +gdb_fmt_thread_id (gdb_ctx->s, cpu, thread_id,sizeof (thread_id)); +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),"T%02xthread:%s;" , +GDB_SIGNAL_TRAP , thread_id); +cleanup: +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} + +static void handle_v_kill (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +/* Kill the target */ +put_packet (gdb_ctx->s,"OK" ); +error_report ("QEMU: Terminated via GDBstub" ); +exit (0 ); +} + +static GdbCmdParseEntry gdb_v_commands_table[] = { +/* Order is important if has same prefix */ + { + .handler = handle_v_cont_query, + .cmd ="Cont?" , + .cmd_startswith =1 + }, + { + .handler = handle_v_cont, + .cmd ="Cont" , + .cmd_startswith =1 , + .schema ="s0" + }, + { + .handler = handle_v_attach, + .cmd ="Attach;" , + .cmd_startswith =1 , + .schema ="l0" + }, + { + .handler = handle_v_kill, + .cmd ="Kill;" , + .cmd_startswith =1 + }, +}; + +static void handle_v_commands (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (!gdb_ctx->num_params) { +return ; + } + +if (process_string_cmd (gdb_ctx->s,NULL , gdb_ctx->params[0 ].data, + gdb_v_commands_table, +ARRAY_SIZE (gdb_v_commands_table))) { +put_packet (gdb_ctx->s,"" ); + } +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -1838,7 +1938,7 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)CPUClass *cc;const char *p;uint32_t pid, tid; -int ch, type, res; +int ch, type;uint8_t mem_buf[MAX_PACKET_LENGTH ];char buf[sizeof (mem_buf) +1 /* trailing NUL */ ];char thread_id[16 ];
@@ -1886,66 +1986,16 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'v' : -if (strncmp (p,"Cont" ,4 ) ==0 ) { - p +=4 ; -if (*p =='?' ) { -put_packet (s,"vCont;c;C;s;S" ); -break ; - } - - res =gdb_handle_vcont (s, p); - -if (res) { -if ((res == -EINVAL ) || (res == -ERANGE )) { -put_packet (s,"E22" ); -break ; - } - goto unknown_command; - } -break ; - }else if (strncmp (p,"Attach;" ,7 ) ==0 ) { -unsigned long pid; - - p +=7 ; - -if (qemu_strtoul (p, &p,16 , &pid)) { -put_packet (s,"E22" ); -break ; - } - - process =gdb_get_process (s, pid); - -if (process ==NULL ) { -put_packet (s,"E22" ); -break ; - } - - cpu =get_first_cpu_in_process (s, process); - -if (cpu ==NULL ) { -/* Refuse to attach an empty process */ -put_packet (s,"E22" ); -break ; - } - - process->attached = true; - - s->g_cpu = cpu; - s->c_cpu = cpu; - -snprintf (buf,sizeof (buf),"T%02xthread:%s;" ,GDB_SIGNAL_TRAP , -gdb_fmt_thread_id (s, cpu, thread_id,sizeof (thread_id))); - -put_packet (s, buf); -break ; - }else if (strncmp (p,"Kill;" ,5 ) ==0 ) { -/* Kill the target */ -put_packet (s,"OK" ); -error_report ("QEMU: Terminated via GDBstub" ); -exit (0 ); - }else { - goto unknown_command; + { +static GdbCmdParseEntry v_cmd_desc = { + .handler = handle_v_commands, + .cmd ="v" , + .cmd_startswith =1 , + .schema ="s0" + }; +process_string_cmd (s,NULL , line_buf, &v_cmd_desc,1 ); } +break ;case 'k' :/* Kill the target */ error_report ("QEMU: Terminated via GDBstub" );
Signature · 1 line
2.20.1
PATCH v3 18/20 gdbstub: Implement generic query (q pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 335 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 335 insertions(+)
gdbstub.c +335 -0
@@ -1931,6 +1931,331 @@ static void handle_v_commands(GdbCmdContext *gdb_ctx, void *user_ctx) } } +static void handle_query_qemu_sstepbits (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf), +"ENABLE=%x,NOIRQ=%x,NOTIMER=%x" ,SSTEP_ENABLE , +SSTEP_NOIRQ ,SSTEP_NOTIMER ); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} + +static void handle_set_qemu_sstep (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (!gdb_ctx->num_params) { +return ; + } + + sstep_flags = gdb_ctx->params[0 ].val_ul; +put_packet (gdb_ctx->s,"OK" ); +} + +static void handle_query_qemu_sstep (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),"0x%x" , sstep_flags); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} + +static void handle_query_curr_tid (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +CPUState *cpu; +GDBProcess *process; +char thread_id[16 ]; + +/* +* "Current thread" remains vague in the spec, so always return +* the first thread of the current process (gdb returns the +* first thread). +*/ + process =gdb_get_cpu_process (gdb_ctx->s, gdb_ctx->s->g_cpu); + cpu =get_first_cpu_in_process (gdb_ctx->s, process); +gdb_fmt_thread_id (gdb_ctx->s, cpu, thread_id,sizeof (thread_id)); +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),"QC%s" , thread_id); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} + +static void handle_query_threads (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +char thread_id[16 ]; + +if (!gdb_ctx->s->query_cpu) { +put_packet (gdb_ctx->s,"l" ); +return ; + } + +gdb_fmt_thread_id (gdb_ctx->s, gdb_ctx->s->query_cpu, thread_id, +sizeof (thread_id)); +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),"m%s" , thread_id); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); + gdb_ctx->s->query_cpu = +gdb_next_attached_cpu (gdb_ctx->s, gdb_ctx->s->query_cpu); +} + +static void handle_query_first_threads (GdbCmdContext *gdb_ctx,void *user_ctx) +{ + gdb_ctx->s->query_cpu =gdb_first_attached_cpu (gdb_ctx->s); +handle_query_threads (gdb_ctx, user_ctx); +} + +static void handle_query_thread_extra (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +CPUState *cpu; +int len; + +if (!gdb_ctx->num_params || + gdb_ctx->params[0 ].thread_id.kind ==GDB_READ_THREAD_ERR ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + + cpu =gdb_get_cpu (gdb_ctx->s, gdb_ctx->params[0 ].thread_id.pid, + gdb_ctx->params[0 ].thread_id.tid); +if (!cpu) { +return ; + } + +cpu_synchronize_state (cpu); + +if (gdb_ctx->s->multiprocess && (gdb_ctx->s->process_num >1 )) { +/* Print the CPU model and name in multiprocess mode */ +ObjectClass *oc =object_get_class (OBJECT (cpu)); +const char *cpu_model =object_class_get_name (oc); +char *cpu_name =object_get_canonical_path_component (OBJECT (cpu)); + len =snprintf ((char *)gdb_ctx->mem_buf,sizeof (gdb_ctx->str_buf) /2 , +"%s %s [%s]" , cpu_model, cpu_name, + cpu->halted ?"halted " :"running" ); +g_free (cpu_name); + }else { +/* memtohex() doubles the required space */ + len =snprintf ((char *)gdb_ctx->mem_buf,sizeof (gdb_ctx->str_buf) /2 , +"CPU#%d [%s]" , cpu->cpu_index, + cpu->halted ?"halted " :"running" ); + } +trace_gdbstub_op_extra_info ((char *)gdb_ctx->mem_buf); +memtohex (gdb_ctx->str_buf, gdb_ctx->mem_buf, len); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} + +#ifdef CONFIG_USER_ONLY +static void handle_query_offsets (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +TaskState *ts; + + ts = gdb_ctx->s->c_cpu->opaque; +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf), +"Text=" TARGET_ABI_FMT_lx";Data=" TARGET_ABI_FMT_lx +";Bss=" TARGET_ABI_FMT_lx, + ts->info->code_offset, + ts->info->data_offset, + ts->info->data_offset); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} +#else +static void handle_query_rcmd (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +int len; + +if (!gdb_ctx->num_params) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + + len =strlen (gdb_ctx->params[0 ].data); +if (len %2 ) { +put_packet (gdb_ctx->s,"E01" ); +return ; + } + + len = len /2 ; +hextomem (gdb_ctx->mem_buf, gdb_ctx->params[0 ].data, len); + gdb_ctx->mem_buf[len++] =0 ; +qemu_chr_be_write (gdb_ctx->s->mon_chr, gdb_ctx->mem_buf, len); +put_packet (gdb_ctx->s,"OK" ); + +} +#endif + +static void handle_query_supported (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +CPUClass *cc; + +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),"PacketSize=%x" , +MAX_PACKET_LENGTH ); + cc =CPU_GET_CLASS (first_cpu); +if (cc->gdb_core_xml_file) { +pstrcat (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf), +";qXfer:features:read+" ); + } + +if (gdb_ctx->num_params && +strstr (gdb_ctx->params[0 ].data,"multiprocess+" )) { + gdb_ctx->s->multiprocess = true; + } + +pstrcat (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),";multiprocess+" ); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +} + +static void handle_query_xfer_features (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +GDBProcess *process; +CPUClass *cc; +unsigned long len, total_len, addr; +const char *xml; +const char *p; + +if (gdb_ctx->num_params <3 ) { +put_packet (gdb_ctx->s,"E22" ); +return ; + } + + process =gdb_get_cpu_process (gdb_ctx->s, gdb_ctx->s->g_cpu); + cc =CPU_GET_CLASS (gdb_ctx->s->g_cpu); +if (!cc->gdb_core_xml_file) { +put_packet (gdb_ctx->s,"" ); +return ; + } + + gdb_has_xml = true; + p = gdb_ctx->params[0 ].data; + xml =get_feature_xml (gdb_ctx->s, p, &p, process); +if (!xml) { +put_packet (gdb_ctx->s,"E00" ); +return ; + } + + addr = gdb_ctx->params[1 ].val_ul; + len = gdb_ctx->params[2 ].val_ul; + total_len =strlen (xml); +if (addr > total_len) { +put_packet (gdb_ctx->s,"E00" ); +return ; + } + +if (len > (MAX_PACKET_LENGTH -5 ) /2 ) { + len = (MAX_PACKET_LENGTH -5 ) /2 ; + } + +if (len < total_len - addr) { + gdb_ctx->str_buf[0 ] ='m' ; + len =memtox (gdb_ctx->str_buf +1 , xml + addr, len); + }else { + gdb_ctx->str_buf[0 ] ='l' ; + len =memtox (gdb_ctx->str_buf +1 , xml + addr, total_len - addr); + } + +put_packet_binary (gdb_ctx->s, gdb_ctx->str_buf, len +1 , true); +} + +static void handle_query_attached (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +put_packet (gdb_ctx->s,GDB_ATTACHED ); +} + +static GdbCmdParseEntry gdb_gen_query_set_common_table[] = { +/* Order is important if has same prefix */ + { + .handler = handle_query_qemu_sstepbits, + .cmd ="qemu.sstepbits" , + .cmd_full_match =1 + }, + { + .handler = handle_query_qemu_sstep, + .cmd ="qemu.sstep" , + .cmd_full_match =1 , + }, + { + .handler = handle_set_qemu_sstep, + .cmd ="qemu.sstep=" , + .cmd_startswith =1 , + .schema ="l0" + }, +}; + +static GdbCmdParseEntry gdb_gen_query_table[] = { + { + .handler = handle_query_curr_tid, + .cmd ="C" , + .cmd_full_match =1 + }, + { + .handler = handle_query_threads, + .cmd ="sThreadInfo" , + .cmd_full_match =1 + }, + { + .handler = handle_query_first_threads, + .cmd ="fThreadInfo" , + .cmd_full_match =1 + }, + { + .handler = handle_query_thread_extra, + .cmd ="ThreadExtraInfo," , + .cmd_startswith =1 , + .schema ="t0" + }, +#ifdef CONFIG_USER_ONLY + { + .handler = handle_query_offsets, + .cmd ="Offsets" , + .cmd_full_match =1 + }, +#else + { + .handler = handle_query_rcmd, + .cmd ="Rcmd," , + .cmd_startswith =1 , + .schema ="s0" + }, +#endif + { + .handler = handle_query_supported, + .cmd ="Supported:" , + .cmd_startswith =1 , + .schema ="s0" + }, + { + .handler = handle_query_supported, + .cmd ="Supported" , + .cmd_full_match =1 , + .schema ="s0" + }, + { + .handler = handle_query_xfer_features, + .cmd ="Xfer:features:read:" , + .cmd_startswith =1 , + .schema ="x:l,l0" + }, + { + .handler = handle_query_attached, + .cmd ="Attached:" , + .cmd_startswith =1 + }, + { + .handler = handle_query_attached, + .cmd ="Attached" , + .cmd_full_match =1 + }, +}; + +static void handle_gen_query (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (!gdb_ctx->num_params) { +return ; + } + +if (!process_string_cmd (gdb_ctx->s,NULL , gdb_ctx->params[0 ].data, + gdb_gen_query_set_common_table, +ARRAY_SIZE (gdb_gen_query_set_common_table))) { +return ; + } + +if (process_string_cmd (gdb_ctx->s,NULL , gdb_ctx->params[0 ].data, + gdb_gen_query_table, +ARRAY_SIZE (gdb_gen_query_table))) { +put_packet (gdb_ctx->s,"" ); + } +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) {CPUState *cpu;
@@ -2143,6 +2468,16 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'q' : + { +static GdbCmdParseEntry gen_query_cmd_desc = { + .handler = handle_gen_query, + .cmd ="q" , + .cmd_startswith =1 , + .schema ="s0" + }; +process_string_cmd (s,NULL , line_buf, &gen_query_cmd_desc,1 ); + } +break ;case 'Q' :/* parse any 'q' packets here */ if (!strcmp (p,"qemu.sstepbits" )) {
Signature · 1 line
2.20.1
PATCH v3 19/20 gdbstub: Implement generic set (Q pkt) with new infra
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 213 +++++++----------------------------------------------- 1 file changed, 25 insertions(+), 188 deletions(-)
gdbstub.c +25 -188
@@ -1130,14 +1130,6 @@ static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,return GDB_ONE_THREAD ; } -static int is_query_packet (const char *p,const char *query,char separator) -{ -unsigned int query_len =strlen (query); - -return strncmp (p, query, query_len) ==0 && - (p[query_len] =='\0' || p[query_len] == separator); -} -/** * gdb_handle_vcont - Parses and handles a vCont packet. * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
@@ -2256,18 +2248,28 @@ static void handle_gen_query(GdbCmdContext *gdb_ctx, void *user_ctx) } } +static void handle_gen_set (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +if (!gdb_ctx->num_params) { +return ; + } + +if (!process_string_cmd (gdb_ctx->s,NULL , gdb_ctx->params[0 ].data, + gdb_gen_query_set_common_table, +ARRAY_SIZE (gdb_gen_query_set_common_table))) { +return ; + } + +put_packet (gdb_ctx->s,"" ); +} +static int gdb_handle_packet (GDBState *s,const char *line_buf) { -CPUState *cpu; -GDBProcess *process; -CPUClass *cc;const char *p; -uint32_t pid, tid; -int ch, type; +int ch;uint8_t mem_buf[MAX_PACKET_LENGTH ];char buf[sizeof (mem_buf) +1 /* trailing NUL */ ];char thread_id[16 ]; -target_ulong addr, len;trace_gdbstub_io_command (line_buf);
@@ -2479,182 +2481,17 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf) }break ;case 'Q' : -/* parse any 'q' packets here */ -if (!strcmp (p,"qemu.sstepbits" )) { -/* Query Breakpoint bit definitions */ -snprintf (buf,sizeof (buf),"ENABLE=%x,NOIRQ=%x,NOTIMER=%x" , -SSTEP_ENABLE , -SSTEP_NOIRQ , -SSTEP_NOTIMER ); -put_packet (s, buf); -break ; - }else if (is_query_packet (p,"qemu.sstep" ,'=' )) { -/* Display or change the sstep_flags */ - p +=10 ; -if (*p !='=' ) { -/* Display current setting */ -snprintf (buf,sizeof (buf),"0x%x" , sstep_flags); -put_packet (s, buf); -break ; - } - p++; - type =strtoul (p, (char **)&p,16 ); - sstep_flags = type; -put_packet (s,"OK" ); -break ; - }else if (strcmp (p,"C" ) ==0 ) { -/* -* "Current thread" remains vague in the spec, so always return -* the first thread of the current process (gdb returns the -* first thread). -*/ - cpu =get_first_cpu_in_process (s,gdb_get_cpu_process (s, s->g_cpu)); -snprintf (buf,sizeof (buf),"QC%s" , -gdb_fmt_thread_id (s, cpu, thread_id,sizeof (thread_id))); -put_packet (s, buf); -break ; - }else if (strcmp (p,"fThreadInfo" ) ==0 ) { - s->query_cpu =gdb_first_attached_cpu (s); - goto report_cpuinfo; - }else if (strcmp (p,"sThreadInfo" ) ==0 ) { - report_cpuinfo: -if (s->query_cpu) { -snprintf (buf,sizeof (buf),"m%s" , -gdb_fmt_thread_id (s, s->query_cpu, - thread_id,sizeof (thread_id))); -put_packet (s, buf); - s->query_cpu =gdb_next_attached_cpu (s, s->query_cpu); - }else -put_packet (s,"l" ); -break ; - }else if (strncmp (p,"ThreadExtraInfo," ,16 ) ==0 ) { -if (read_thread_id (p +16 , &p, &pid, &tid) ==GDB_READ_THREAD_ERR ) { -put_packet (s,"E22" ); -break ; - } - cpu =gdb_get_cpu (s, pid, tid); -if (cpu !=NULL ) { -cpu_synchronize_state (cpu); - -if (s->multiprocess && (s->process_num >1 )) { -/* Print the CPU model and name in multiprocess mode */ -ObjectClass *oc =object_get_class (OBJECT (cpu)); -const char *cpu_model =object_class_get_name (oc); -char *cpu_name = -object_get_canonical_path_component (OBJECT (cpu)); - len =snprintf ((char *)mem_buf,sizeof (buf) /2 , -"%s %s [%s]" , cpu_model, cpu_name, - cpu->halted ?"halted " :"running" ); -g_free (cpu_name); - }else { -/* memtohex() doubles the required space */ - len =snprintf ((char *)mem_buf,sizeof (buf) /2 , -"CPU#%d [%s]" , cpu->cpu_index, - cpu->halted ?"halted " :"running" ); - } -trace_gdbstub_op_extra_info ((char *)mem_buf); -memtohex (buf, mem_buf, len); -put_packet (s, buf); - } -break ; - } -#ifdef CONFIG_USER_ONLY - else if (strcmp(p, "Offsets") == 0) { - TaskState *ts = s->c_cpu->opaque; - -snprintf (buf,sizeof (buf), -"Text=" TARGET_ABI_FMT_lx";Data=" TARGET_ABI_FMT_lx -";Bss=" TARGET_ABI_FMT_lx, - ts->info->code_offset, - ts->info->data_offset, - ts->info->data_offset); -put_packet (s, buf); -break ; - } -#else /* !CONFIG_USER_ONLY */ - else if (strncmp(p, "Rcmd,", 5) == 0) { - int len = strlen(p + 5); - - if ((len % 2) != 0) { - put_packet(s, "E01"); - break; - } - len = len / 2; - hextomem(mem_buf, p + 5, len); - mem_buf[len++] = 0; - qemu_chr_be_write(s->mon_chr, mem_buf, len); - put_packet(s, "OK"); - break; - } -#endif /* !CONFIG_USER_ONLY */ - if (is_query_packet(p, "Supported", ':')) { -snprintf (buf,sizeof (buf),"PacketSize=%x" ,MAX_PACKET_LENGTH ); - cc =CPU_GET_CLASS (first_cpu); -if (cc->gdb_core_xml_file !=NULL ) { -pstrcat (buf,sizeof (buf),";qXfer:features:read+" ); - } - -if (strstr (p,"multiprocess+" )) { - s->multiprocess = true; - } -pstrcat (buf,sizeof (buf),";multiprocess+" ); - -put_packet (s, buf); -break ; - } -if (strncmp (p,"Xfer:features:read:" ,19 ) ==0 ) { -const char *xml; -target_ulong total_len; - - process =gdb_get_cpu_process (s, s->g_cpu); - cc =CPU_GET_CLASS (s->g_cpu); -if (cc->gdb_core_xml_file ==NULL ) { - goto unknown_command; - } - - gdb_has_xml = true; - p +=19 ; - xml =get_feature_xml (s, p, &p, process); -if (!xml) { -snprintf (buf,sizeof (buf),"E00" ); -put_packet (s, buf); -break ; - } - -if (*p ==':' ) - p++; - addr =strtoul (p, (char **)&p,16 ); -if (*p ==',' ) - p++; - len =strtoul (p, (char **)&p,16 ); - - total_len =strlen (xml); -if (addr > total_len) { -snprintf (buf,sizeof (buf),"E00" ); -put_packet (s, buf); -break ; - } -if (len > (MAX_PACKET_LENGTH -5 ) /2 ) - len = (MAX_PACKET_LENGTH -5 ) /2 ; -if (len < total_len - addr) { - buf[0 ] ='m' ; - len =memtox (buf +1 , xml + addr, len); - }else { - buf[0 ] ='l' ; - len =memtox (buf +1 , xml + addr, total_len - addr); - } -put_packet_binary (s, buf, len +1 , true); -break ; - } -if (is_query_packet (p,"Attached" ,':' )) { -put_packet (s,GDB_ATTACHED ); -break ; + { +static GdbCmdParseEntry gen_set_cmd_desc = { + .handler = handle_gen_set, + .cmd ="Q" , + .cmd_startswith =1 , + .schema ="s0" + }; +process_string_cmd (s,NULL , line_buf, &gen_set_cmd_desc,1 ); } -/* Unrecognised 'q' command. */ - goto unknown_command; - +break ;default : - unknown_command:/* put empty packet */ buf[0 ] ='\0' ;put_packet (s, buf);
Signature · 1 line
2.20.1
PATCH v3 20/20 gdbstub: Refactor parse handle packet to work with a static array
In reply to [email protected]From: Jon Doron <[email protected]>
--- gdbstub.c | 386 ++++++++++++++++++++++-------------------------------- 1 file changed, 158 insertions(+), 228 deletions(-)
gdbstub.c +158 -228
@@ -2263,240 +2263,170 @@ static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"" ); } -static int gdb_handle_packet (GDBState *s,const char *line_buf) +static void handle_extend_mode (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +put_packet (gdb_ctx->s,"OK" ); +} + +static void handle_target_halt (GdbCmdContext *gdb_ctx,void *user_ctx) { -const char *p; -int ch; -uint8_t mem_buf[MAX_PACKET_LENGTH ]; -char buf[sizeof (mem_buf) +1 /* trailing NUL */ ];char thread_id[16 ]; +/* TODO: Make this return the correct value for user-mode. */ +gdb_fmt_thread_id (gdb_ctx->s, gdb_ctx->s->c_cpu, thread_id, +sizeof (thread_id)); +snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),"T%02xthread:%s;" , +GDB_SIGNAL_TRAP , thread_id); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +/* +* Remove all the breakpoints when this query is issued, +* because gdb is doing and initial connect and the state +* should be cleaned up. +*/ +gdb_breakpoint_remove_all (); +} + +static void handle_kill (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +/* Kill the target */ +error_report ("QEMU: Terminated via GDBstub" ); +exit (0 ); +} + +static GdbCmdParseEntry gdb_packet_table[0x100 ] = { + ['!' ] = { + .handler = handle_extend_mode, + .cmd ="!" , + .cmd_startswith =1 + }, + ['?' ] = { + .handler = handle_target_halt, + .cmd ="?" , + .cmd_startswith =1 + }, + ['c' ] = { + .handler = handle_continue, + .cmd ="c" , + .cmd_startswith =1 , + .schema ="L0" + }, + ['C' ] = { + .handler = handle_cont_with_sig, + .cmd ="C" , + .cmd_startswith =1 , + .schema ="l0" + }, + ['v' ] = { + .handler = handle_v_commands, + .cmd ="v" , + .cmd_startswith =1 , + .schema ="s0" + }, + ['k' ] = { + .handler = handle_kill, + .cmd ="k" , + .cmd_startswith =1 + }, + ['D' ] = { + .handler = handle_detach, + .cmd ="D" , + .cmd_startswith =1 , + .schema ="?.l0" + }, + ['s' ] = { + .handler = handle_step, + .cmd ="s" , + .cmd_startswith =1 , + .schema ="L0" + }, + ['F' ] = { + .handler = handle_file_io, + .cmd ="F" , + .cmd_startswith =1 , + .schema ="s0" + }, + ['g' ] = { + .handler = handle_read_all_regs, + .cmd ="g" , + .cmd_startswith =1 + }, + ['G' ] = { + .handler = handle_write_all_regs, + .cmd ="G" , + .cmd_startswith =1 , + .schema ="s0" + }, + ['m' ] = { + .handler = handle_read_mem, + .cmd ="m" , + .cmd_startswith =1 , + .schema ="L,L0" + }, + ['M' ] = { + .handler = handle_write_mem, + .cmd ="M" , + .cmd_startswith =1 , + .schema ="L,L:s0" + }, + ['p' ] = { + .handler = handle_get_reg, + .cmd ="p" , + .cmd_startswith =1 , + .schema ="L0" + }, + ['P' ] = { + .handler = handle_set_reg, + .cmd ="P" , + .cmd_startswith =1 , + .schema ="L?s0" + }, + ['Z' ] = { + .handler = handle_insert_bp, + .cmd ="Z" , + .cmd_startswith =1 , + .schema ="l?L?L0" + }, + ['z' ] = { + .handler = handle_remove_bp, + .cmd ="z" , + .cmd_startswith =1 , + .schema ="l?L?L0" + }, + ['H' ] = { + .handler = handle_set_thread, + .cmd ="H" , + .cmd_startswith =1 , + .schema ="o.t0" + }, + ['T' ] = { + .handler = handle_thread_alive, + .cmd ="T" , + .cmd_startswith =1 , + .schema ="t0" + }, + ['q' ] = { + .handler = handle_gen_query, + .cmd ="q" , + .cmd_startswith =1 , + .schema ="s0" + }, + ['Q' ] = { + .handler = handle_gen_set, + .cmd ="Q" , + .cmd_startswith =1 , + .schema ="s0" + }, +}; + +static int gdb_handle_packet (GDBState *s,const char *line_buf) +{trace_gdbstub_io_command (line_buf); - p = line_buf; - ch = *p++; -switch (ch) { -case '!' : -put_packet (s,"OK" ); -break ; -case '?' : -/* TODO: Make this return the correct value for user-mode. */ -snprintf (buf,sizeof (buf),"T%02xthread:%s;" ,GDB_SIGNAL_TRAP , -gdb_fmt_thread_id (s, s->c_cpu, thread_id,sizeof (thread_id))); -put_packet (s, buf); -/* Remove all the breakpoints when this query is issued, -* because gdb is doing and initial connect and the state -* should be cleaned up. -*/ -gdb_breakpoint_remove_all (); -break ; -case 'c' : - { -static GdbCmdParseEntry continue_cmd_desc = { - .handler = handle_continue, - .cmd ="c" , - .cmd_startswith =1 , - .schema ="L0" - }; -process_string_cmd (s,NULL , line_buf, &continue_cmd_desc,1 ); - } -break ; -case 'C' : - { -static GdbCmdParseEntry cont_with_sig_cmd_desc = { - .handler = handle_cont_with_sig, - .cmd ="C" , - .cmd_startswith =1 , - .schema ="l0" - }; -process_string_cmd (s,NULL , line_buf, &cont_with_sig_cmd_desc,1 ); - } -break ; -case 'v' : - { -static GdbCmdParseEntry v_cmd_desc = { - .handler = handle_v_commands, - .cmd ="v" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &v_cmd_desc,1 ); - } -break ; -case 'k' : -/* Kill the target */ -error_report ("QEMU: Terminated via GDBstub" ); -exit (0 ); -case 'D' : - { -static GdbCmdParseEntry deatch_cmd_desc = { - .handler = handle_detach, - .cmd ="D" , - .cmd_startswith =1 , - .schema ="?.l0" - }; -process_string_cmd (s,NULL , line_buf, &deatch_cmd_desc,1 ); - } -break ; -case 's' : - { -static GdbCmdParseEntry step_cmd_desc = { - .handler = handle_step, - .cmd ="s" , - .cmd_startswith =1 , - .schema ="L0" - }; -process_string_cmd (s,NULL , line_buf, &step_cmd_desc,1 ); - } -break ; -case 'F' : - { -static GdbCmdParseEntry file_io_cmd_desc = { - .handler = handle_file_io, - .cmd ="F" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &file_io_cmd_desc,1 ); - } -break ; -case 'g' : - { -static GdbCmdParseEntry read_all_regs_cmd_desc = { - .handler = handle_read_all_regs, - .cmd ="g" , - .cmd_startswith =1 - }; -process_string_cmd (s,NULL , line_buf, &read_all_regs_cmd_desc,1 ); - } -break ; -case 'G' : - { -static GdbCmdParseEntry write_all_regs_cmd_desc = { - .handler = handle_write_all_regs, - .cmd ="G" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &write_all_regs_cmd_desc,1 ); - } -break ; -case 'm' : - { -static GdbCmdParseEntry read_mem_cmd_desc = { - .handler = handle_read_mem, - .cmd ="m" , - .cmd_startswith =1 , - .schema ="L,L0" - }; -process_string_cmd (s,NULL , line_buf, &read_mem_cmd_desc,1 ); - } -break ; -case 'M' : - { -static GdbCmdParseEntry write_mem_cmd_desc = { - .handler = handle_write_mem, - .cmd ="M" , - .cmd_startswith =1 , - .schema ="L,L:s0" - }; -process_string_cmd (s,NULL , line_buf, &write_mem_cmd_desc,1 ); - } -break ; -case 'p' : - { -static GdbCmdParseEntry get_reg_cmd_desc = { - .handler = handle_get_reg, - .cmd ="p" , - .cmd_startswith =1 , - .schema ="L0" - }; -process_string_cmd (s,NULL , line_buf, &get_reg_cmd_desc,1 ); - } -break ; -case 'P' : - { -static GdbCmdParseEntry set_reg_cmd_desc = { - .handler = handle_set_reg, - .cmd ="P" , - .cmd_startswith =1 , - .schema ="L?s0" - }; -process_string_cmd (s,NULL , line_buf, &set_reg_cmd_desc,1 ); - } -break ; -case 'Z' : - { -static GdbCmdParseEntry insert_bp_cmd_desc = { - .handler = handle_insert_bp, - .cmd ="Z" , - .cmd_startswith =1 , - .schema ="l?L?L0" - }; -process_string_cmd (s,NULL , line_buf, &insert_bp_cmd_desc,1 ); - } -break ; -case 'z' : - { -static GdbCmdParseEntry remove_bp_cmd_desc = { - .handler = handle_remove_bp, - .cmd ="z" , - .cmd_startswith =1 , - .schema ="l?L?L0" - }; -process_string_cmd (s,NULL , line_buf, &remove_bp_cmd_desc,1 ); - } -break ; -case 'H' : - { -static GdbCmdParseEntry set_thread_cmd_desc = { - .handler = handle_set_thread, - .cmd ="H" , - .cmd_startswith =1 , - .schema ="o.t0" - }; -process_string_cmd (s,NULL , line_buf, &set_thread_cmd_desc,1 ); - } -break ; -case 'T' : - { -static GdbCmdParseEntry thread_alive_cmd_desc = { - .handler = handle_thread_alive, - .cmd ="T" , - .cmd_startswith =1 , - .schema ="t0" - }; -process_string_cmd (s,NULL , line_buf, &thread_alive_cmd_desc,1 ); - } -break ; -case 'q' : - { -static GdbCmdParseEntry gen_query_cmd_desc = { - .handler = handle_gen_query, - .cmd ="q" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &gen_query_cmd_desc,1 ); - } -break ; -case 'Q' : - { -static GdbCmdParseEntry gen_set_cmd_desc = { - .handler = handle_gen_set, - .cmd ="Q" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &gen_set_cmd_desc,1 ); - } -break ; -default : -/* put empty packet */ - buf[0 ] ='\0' ; -put_packet (s, buf); -break ; +if (process_string_cmd (s,NULL , line_buf, + &gdb_packet_table[*(uint8_t *)line_buf],1 )) { +put_packet (s,"" ); } +return RS_IDLE ; }
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v3 20/20] gdbstub: Refactor parse handle packet to work with a static array
Quoted 1 line · On 4/24/19 7:27 AM, [email protected] wrote:
+static GdbCmdParseEntry gdb_packet_table[0x100] = {
21 out of 256 entries used? That's a pretty poor occupancy rate. What was wrong with the switch statement?
Or a modified version in which you sink the call to process_string_cmd and only load the pointer to the structure within the switch.
r~
Re: [Qemu-devel] [PATCH v3 20/20] gdbstub: Refactor parse handle packet to work with a static array
In reply to [email protected]Quoted 32 lines · [email protected] writes:
From: Jon Doron <[email protected]>
Signed-off-by Jon Doron <[email protected]>--- gdbstub.c | 386 ++++++++++++++++++++++-------------------------------- 1 file changed, 158 insertions(+), 228 deletions(-)gdbstub.c +9
-5@@ -2263,240 +2263,170 @@ static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx)put_packet (gdb_ctx->s,"" ); } -static int gdb_handle_packet (GDBState *s,const char *line_buf) +static void handle_extend_mode (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +put_packet (gdb_ctx->s,"OK" ); +} + +static void handle_target_halt (GdbCmdContext *gdb_ctx,void *user_ctx) { -const char *p; -int ch; -uint8_t mem_buf[MAX_PACKET_LENGTH ]; -char buf[sizeof (mem_buf) +1 /* trailing NUL */ ];char thread_id[16 ]; +/* TODO: Make this return the correct value for user-mode. */ +gdb_fmt_thread_id (gdb_ctx->s, gdb_ctx->s->c_cpu, thread_id, +sizeof (thread_id));
gdbstub.c static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx) · line 2287
Quoted 10 lines
gdbstub.c +10
-0+snprintf (gdb_ctx->str_buf,sizeof (gdb_ctx->str_buf),"T%02xthread:%s;" , +GDB_SIGNAL_TRAP , thread_id); +put_packet (gdb_ctx->s, gdb_ctx->str_buf); +/* +* Remove all the breakpoints when this query is issued, +* because gdb is doing and initial connect and the state +* should be cleaned up. +*/ +gdb_breakpoint_remove_all (); +}
This isn't a static conversion - this should be it's own patch.
Quoted 122 lines
gdbstub.c +122
-0+ +static void handle_kill (GdbCmdContext *gdb_ctx,void *user_ctx) +{ +/* Kill the target */ +error_report ("QEMU: Terminated via GDBstub" ); +exit (0 ); +} + +static GdbCmdParseEntry gdb_packet_table[0x100 ] = { + ['!' ] = { + .handler = handle_extend_mode, + .cmd ="!" , + .cmd_startswith =1 + }, + ['?' ] = { + .handler = handle_target_halt, + .cmd ="?" , + .cmd_startswith =1 + }, + ['c' ] = { + .handler = handle_continue, + .cmd ="c" , + .cmd_startswith =1 , + .schema ="L0" + }, + ['C' ] = { + .handler = handle_cont_with_sig, + .cmd ="C" , + .cmd_startswith =1 , + .schema ="l0" + }, + ['v' ] = { + .handler = handle_v_commands, + .cmd ="v" , + .cmd_startswith =1 , + .schema ="s0" + }, + ['k' ] = { + .handler = handle_kill, + .cmd ="k" , + .cmd_startswith =1 + }, + ['D' ] = { + .handler = handle_detach, + .cmd ="D" , + .cmd_startswith =1 , + .schema ="?.l0" + }, + ['s' ] = { + .handler = handle_step, + .cmd ="s" , + .cmd_startswith =1 , + .schema ="L0" + }, + ['F' ] = { + .handler = handle_file_io, + .cmd ="F" , + .cmd_startswith =1 , + .schema ="s0" + }, + ['g' ] = { + .handler = handle_read_all_regs, + .cmd ="g" , + .cmd_startswith =1 + }, + ['G' ] = { + .handler = handle_write_all_regs, + .cmd ="G" , + .cmd_startswith =1 , + .schema ="s0" + }, + ['m' ] = { + .handler = handle_read_mem, + .cmd ="m" , + .cmd_startswith =1 , + .schema ="L,L0" + }, + ['M' ] = { + .handler = handle_write_mem, + .cmd ="M" , + .cmd_startswith =1 , + .schema ="L,L:s0" + }, + ['p' ] = { + .handler = handle_get_reg, + .cmd ="p" , + .cmd_startswith =1 , + .schema ="L0" + }, + ['P' ] = { + .handler = handle_set_reg, + .cmd ="P" , + .cmd_startswith =1 , + .schema ="L?s0" + }, + ['Z' ] = { + .handler = handle_insert_bp, + .cmd ="Z" , + .cmd_startswith =1 , + .schema ="l?L?L0" + }, + ['z' ] = { + .handler = handle_remove_bp, + .cmd ="z" , + .cmd_startswith =1 , + .schema ="l?L?L0" + }, + ['H' ] = { + .handler = handle_set_thread, + .cmd ="H" , + .cmd_startswith =1 , + .schema ="o.t0" + }, + ['T' ] = { + .handler = handle_thread_alive, + .cmd ="T" , + .cmd_startswith =1 , + .schema ="t0" + }, + ['q' ] = { + .handler = handle_gen_query, + .cmd ="q" ,
gdbstub.c static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx) · line 2419
Quoted 10 lines
gdbstub.c +10
-0+ .cmd_startswith = 1, + .schema ="s0" + }, + ['Q'] = { + .handler = handle_gen_set, + .cmd = "Q", + .cmd_startswith = 1, + .schema ="s0" + }, +};
But I agree with Richard that swapping a switch for a very sparse table seems to be adding bloat for no useful gain.
Quoted 225 lines
gdbstub.c +3
-220+ +static int gdb_handle_packet (GDBState *s,const char *line_buf) +{trace_gdbstub_io_command (line_buf); - p = line_buf; - ch = *p++; -switch (ch) { -case '!' : -put_packet (s,"OK" ); -break ; -case '?' : -/* TODO: Make this return the correct value for user-mode. */ -snprintf (buf,sizeof (buf),"T%02xthread:%s;" ,GDB_SIGNAL_TRAP , -gdb_fmt_thread_id (s, s->c_cpu, thread_id,sizeof (thread_id))); -put_packet (s, buf); -/* Remove all the breakpoints when this query is issued, -* because gdb is doing and initial connect and the state -* should be cleaned up. -*/ -gdb_breakpoint_remove_all (); -break ; -case 'c' : - { -static GdbCmdParseEntry continue_cmd_desc = { - .handler = handle_continue, - .cmd ="c" , - .cmd_startswith =1 , - .schema ="L0" - }; -process_string_cmd (s,NULL , line_buf, &continue_cmd_desc,1 ); - } -break ; -case 'C' : - { -static GdbCmdParseEntry cont_with_sig_cmd_desc = { - .handler = handle_cont_with_sig, - .cmd ="C" , - .cmd_startswith =1 , - .schema ="l0" - }; -process_string_cmd (s,NULL , line_buf, &cont_with_sig_cmd_desc,1 ); - } -break ; -case 'v' : - { -static GdbCmdParseEntry v_cmd_desc = { - .handler = handle_v_commands, - .cmd ="v" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &v_cmd_desc,1 ); - } -break ; -case 'k' : -/* Kill the target */ -error_report ("QEMU: Terminated via GDBstub" ); -exit (0 ); -case 'D' : - { -static GdbCmdParseEntry deatch_cmd_desc = { - .handler = handle_detach, - .cmd ="D" , - .cmd_startswith =1 , - .schema ="?.l0" - }; -process_string_cmd (s,NULL , line_buf, &deatch_cmd_desc,1 ); - } -break ; -case 's' : - { -static GdbCmdParseEntry step_cmd_desc = { - .handler = handle_step, - .cmd ="s" , - .cmd_startswith =1 , - .schema ="L0" - }; -process_string_cmd (s,NULL , line_buf, &step_cmd_desc,1 ); - } -break ; -case 'F' : - { -static GdbCmdParseEntry file_io_cmd_desc = { - .handler = handle_file_io, - .cmd ="F" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &file_io_cmd_desc,1 ); - } -break ; -case 'g' : - { -static GdbCmdParseEntry read_all_regs_cmd_desc = { - .handler = handle_read_all_regs, - .cmd ="g" , - .cmd_startswith =1 - }; -process_string_cmd (s,NULL , line_buf, &read_all_regs_cmd_desc,1 ); - } -break ; -case 'G' : - { -static GdbCmdParseEntry write_all_regs_cmd_desc = { - .handler = handle_write_all_regs, - .cmd ="G" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &write_all_regs_cmd_desc,1 ); - } -break ; -case 'm' : - { -static GdbCmdParseEntry read_mem_cmd_desc = { - .handler = handle_read_mem, - .cmd ="m" , - .cmd_startswith =1 , - .schema ="L,L0" - }; -process_string_cmd (s,NULL , line_buf, &read_mem_cmd_desc,1 ); - } -break ; -case 'M' : - { -static GdbCmdParseEntry write_mem_cmd_desc = { - .handler = handle_write_mem, - .cmd ="M" , - .cmd_startswith =1 , - .schema ="L,L:s0" - }; -process_string_cmd (s,NULL , line_buf, &write_mem_cmd_desc,1 ); - } -break ; -case 'p' : - { -static GdbCmdParseEntry get_reg_cmd_desc = { - .handler = handle_get_reg, - .cmd ="p" , - .cmd_startswith =1 , - .schema ="L0" - }; -process_string_cmd (s,NULL , line_buf, &get_reg_cmd_desc,1 ); - } -break ; -case 'P' : - { -static GdbCmdParseEntry set_reg_cmd_desc = { - .handler = handle_set_reg, - .cmd ="P" , - .cmd_startswith =1 , - .schema ="L?s0" - }; -process_string_cmd (s,NULL , line_buf, &set_reg_cmd_desc,1 ); - } -break ; -case 'Z' : - { -static GdbCmdParseEntry insert_bp_cmd_desc = { - .handler = handle_insert_bp, - .cmd ="Z" , - .cmd_startswith =1 , - .schema ="l?L?L0" - }; -process_string_cmd (s,NULL , line_buf, &insert_bp_cmd_desc,1 ); - } -break ; -case 'z' : - { -static GdbCmdParseEntry remove_bp_cmd_desc = { - .handler = handle_remove_bp, - .cmd ="z" , - .cmd_startswith =1 , - .schema ="l?L?L0" - }; -process_string_cmd (s,NULL , line_buf, &remove_bp_cmd_desc,1 ); - } -break ; -case 'H' : - { -static GdbCmdParseEntry set_thread_cmd_desc = { - .handler = handle_set_thread, - .cmd ="H" , - .cmd_startswith =1 , - .schema ="o.t0" - }; -process_string_cmd (s,NULL , line_buf, &set_thread_cmd_desc,1 ); - } -break ; -case 'T' : - { -static GdbCmdParseEntry thread_alive_cmd_desc = { - .handler = handle_thread_alive, - .cmd ="T" , - .cmd_startswith =1 , - .schema ="t0" - }; -process_string_cmd (s,NULL , line_buf, &thread_alive_cmd_desc,1 ); - } -break ; -case 'q' : - { -static GdbCmdParseEntry gen_query_cmd_desc = { - .handler = handle_gen_query, - .cmd ="q" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &gen_query_cmd_desc,1 ); - } -break ; -case 'Q' : - { -static GdbCmdParseEntry gen_set_cmd_desc = { - .handler = handle_gen_set, - .cmd ="Q" , - .cmd_startswith =1 , - .schema ="s0" - }; -process_string_cmd (s,NULL , line_buf, &gen_set_cmd_desc,1 ); - } -break ; -default : -/* put empty packet */
gdbstub.c static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx) · line 2431
Quoted 10 lines
gdbstub.c +4
-3- buf[0 ] ='\0' ; -put_packet (s, buf); -break ; +if (process_string_cmd (s,NULL , line_buf, + &gdb_packet_table[*(uint8_t *)line_buf],1 )) { +put_packet (s,"" ); } +return RS_IDLE ; }
--
Alex Bennée
gdbstub.c out: · line 1286
Quoted 4 lines · On 4/24/19 7:26 AM, [email protected] wrote:
gdbstub.c +4
-0+static const char *cmd_next_param (const char *param,const char delimiter) +{ +const char *delim; +static char all_delimiters[] =",;:=" ;
static const char
gdbstub.c out: · line 1294
Quoted 8 lines
gdbstub.c +8
-0+static char no_delimiter[] ="\0" ; +char curr_delimiters[2 ] = {0 }; +const char *delimiters; + +if (delimiter =='?' ) { + delimiters = all_delimiters; + }else if (delimiter =='0' ) { + delimiters = no_delimiter;
return strchr(param, '\0')
gdbstub.c out: · line 1311
Quoted 10 lines
gdbstub.c +10
-0+while (*param) { + delim = delimiters; +while (*delim) { +if (*param == *delim) { +return param +1 ; + } + delim++; + } + param++; + }
Maybe
param += strcspn(param, delim);
if (*param) {
param++;
}
return param;r~
Quoted 132 lines · [email protected] writes:
From: Jon Doron <[email protected]>
Signed-off-by Jon Doron <[email protected]>--- gdbstub.c | 215 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 215 insertions(+)gdbstub.c +117
-0@@ -1268,6 +1268,221 @@ out:return res; } +typedef union GdbCmdVariant { +const char *data; +uint8_t opcode; +unsigned long val_ul; +unsigned long long val_ull; +struct { +GDBThreadIdKind kind; +uint32_t pid; +uint32_t tid; + } thread_id; +}GdbCmdVariant ; + +static const char *cmd_next_param (const char *param,const char delimiter) +{ +const char *delim; +static char all_delimiters[] =",;:=" ; +static char no_delimiter[] ="\0" ; +char curr_delimiters[2 ] = {0 }; +const char *delimiters; + +if (delimiter =='?' ) { + delimiters = all_delimiters; + }else if (delimiter =='0' ) { + delimiters = no_delimiter; + }else if (delimiter =='.' && *param) { +return param +1 ; + }else { + curr_delimiters[0 ] = delimiter; + delimiters = curr_delimiters; + } + +while (*param) { + delim = delimiters; +while (*delim) { +if (*param == *delim) { +return param +1 ; + } + delim++; + } + param++; + } + +return param; +} + +static int cmd_parse_params (const char *data,const char *schema, +GdbCmdVariant *params,int *num_params) +{ +int curr_param; +const char *curr_schema, *curr_data; + + *num_params =0 ; + +if (!schema) { +return 0 ; + } + + curr_schema = schema; + curr_param =0 ; + curr_data = data; +while (curr_schema[0 ] && curr_schema[1 ] && *curr_data) { +switch (curr_schema[0 ]) { +case 'l' : +if (qemu_strtoul (curr_data, &curr_data,16 , + ¶ms[curr_param].val_ul)) { +return -EINVAL ; + } + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'L' : +if (qemu_strtou64 (curr_data, &curr_data,16 , + (uint64_t *)¶ms[curr_param].val_ull)) { +return -EINVAL ; + } + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 's' : + params[curr_param].data = curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'o' : + params[curr_param].opcode = *(uint8_t *)curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 't' : + params[curr_param].thread_id.kind = +read_thread_id (curr_data, &curr_data, + ¶ms[curr_param].thread_id.pid, + ¶ms[curr_param].thread_id.tid); + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'x' : + params[curr_param].data = curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case '?' : + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +default : +return -EINVAL ; + } + curr_schema +=2 ; + } + + *num_params = curr_param; +return 0 ; +} + +typedef struct GdbCmdContext { + GDBState *s; + GdbCmdVariant *params;
gdbstub.c out: · line 1397
Quoted 10 lines
gdbstub.c +10
-0+int num_params; +uint8_t mem_buf[MAX_PACKET_LENGTH ]; +char str_buf[MAX_PACKET_LENGTH +1 ]; +} GdbCmdContext; + +typedef void (*GdbCmdHandler )(GdbCmdContext *gdb_ctx,void *user_ctx); + +/* +* cmd_startswith -> cmd is compared using startswith +* cmd_full_match -> cmd is compared using strcmp
Doesn't !cmd_full_match imply cmd_startswith?
Quoted 45 lines
gdbstub.c +45
-0+* +* +* schema definitions: +* Each schema parameter entry consists of 2 chars, +* the first char represents the parameter type handling +* the second char represents the delimiter for the next parameter +* +* Currently supported schema types: +* 'l' -> unsigned long (stored in .val_ul) +* 'L' -> unsigned long long (stored in .val_ull) +* 's' -> string (stored in .data) +* 'o' -> single char (stored in .opcode) +* 't' -> thread id (stored in .thread_id) +* 'x' -> xml (stored in .data), must have a ':' delimiter +* '?' -> skip according to delimiter +* +* Currently supported delimiters: +* '?' -> Stop at any delimiter (",;:=\0") +* '0' -> Stop at "\0" +* '.' -> Skip 1 char unless reached "\0" +* Any other value is treated as the delimiter value itself +*/ +typedef struct GdbCmdParseEntry { +GdbCmdHandler handler; +const char *cmd; +union { +int flags; +struct { +int cmd_startswith:1 ; +int cmd_full_match:1 ; + }; + }; +const char *schema; +}GdbCmdParseEntry ; + +static inline int startswith (const char *string,const char *pattern) +{ +return !strncmp (string, pattern,strlen (pattern)); +} + +__attribute__((unused))static int process_string_cmd ( +GDBState *s,void *user_ctx,const char *data, +GdbCmdParseEntry *cmds,int num_cmds); + +static int process_string_cmd(GDBState *s, void *user_ctx, const char *data,
gdbstub.c out: · line 1452
Quoted 10 lines
gdbstub.c +10
-0+ GdbCmdParseEntry *cmds, int num_cmds) +{ + int i, schema_len, max_num_params; +GdbCmdContext gdb_ctx; + +if (!cmds) { +return -1 ; + } + +for (i =0 ; i < num_cmds; i++) {
Allocating:
GdbCmdParseEntry *cmd = &cmds[i];
might make the remaining code a little simpler to deal with.
gdbstub.c out: · line 1453
Quoted 1 line
gdbstub.c +1
-0+ if (!cmds[i].handler || !cmds[i].cmd ||
Some of these seem like asserts:
g_assert(cmd->handler && cmd->cmd);
gdbstub.c out: · line 1455
Quoted 2 lines
gdbstub.c +2
-0+ (cmds[i].cmd_startswith && !startswith(data, cmds[i].cmd)) || + (cmds[i].cmd_full_match && strcmp(data, cmds[i].cmd))) {
then we can have the skip test:
if (cmd->cmd_startswith && !startswith(data, cmd->cmd)) {
continue;
} else if (strcmp(cmd->cmd, data)!=0) {
continue;
}gdbstub.c out: · line 1459
Quoted 4 lines
gdbstub.c +4
-0+continue ; + } + + max_num_params =0 ;
You can set the default when you declare this above
gdbstub.c out:
Quoted 13 lines
gdbstub.c +12
-0+if (cmds[i].schema) { + schema_len =strlen (cmds[i].schema); +if (schema_len %2 ) { +return -2 ; + } + + max_num_params = schema_len /2 ; + } + + gdb_ctx.params = + (GdbCmdVariant *)alloca (sizeof (*gdb_ctx.params) * max_num_params); +memset (gdb_ctx.params,0 ,sizeof (*gdb_ctx.params) * max_num_params);
You could use the glib function instead:
gdb_ctx.params = g_newa(GdbCmdVariant, max_num_params);
Although you still have to zero it which you could avoid with a g_new0() but you'd then have to free the pointer later. Parsing code is fiddly I guess...
gdbstub.c out: · line 1475
Quoted 3 lines
gdbstub.c +2
-0+ + if (cmd_parse_params(&data[strlen(cmds[i].cmd)], cmds[i].schema,
Is the strlen appropriate if we have cmd_startswith?
Quoted 13 lines
gdbstub.c +12
-0+ gdb_ctx.params, &gdb_ctx.num_params)) { +return -1 ; + } + + gdb_ctx.s = s; + cmds[i].handler (&gdb_ctx, user_ctx); +return 0 ; + } + +return -1 ; +} +static int gdb_handle_packet (GDBState *s,const char *line_buf)
Quoted 2 lines
{
CPUState *cpu;--
Alex Bennée
Thank you Alex I will publish v8 with fixes from your review :) please see my comments below
Quoted 140 lines · Alex Bennée
Quoted 136 lines · [email protected] writes:
From: Jon Doron <[email protected]>
Signed-off-by Jon Doron <[email protected]>--- gdbstub.c | 215 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 215 insertions(+)gdbstub.c +121
-0@@ -1268,6 +1268,221 @@ out:return res; } +typedef union GdbCmdVariant { +const char *data; +uint8_t opcode; +unsigned long val_ul; +unsigned long long val_ull; +struct { +GDBThreadIdKind kind; +uint32_t pid; +uint32_t tid; + } thread_id; +}GdbCmdVariant ; + +static const char *cmd_next_param (const char *param,const char delimiter) +{ +const char *delim; +static char all_delimiters[] =",;:=" ; +static char no_delimiter[] ="\0" ; +char curr_delimiters[2 ] = {0 }; +const char *delimiters; + +if (delimiter =='?' ) { + delimiters = all_delimiters; + }else if (delimiter =='0' ) { + delimiters = no_delimiter; + }else if (delimiter =='.' && *param) { +return param +1 ; + }else { + curr_delimiters[0 ] = delimiter; + delimiters = curr_delimiters; + } + +while (*param) { + delim = delimiters; +while (*delim) { +if (*param == *delim) { +return param +1 ; + } + delim++; + } + param++; + } + +return param; +} + +static int cmd_parse_params (const char *data,const char *schema, +GdbCmdVariant *params,int *num_params) +{ +int curr_param; +const char *curr_schema, *curr_data; + + *num_params =0 ; + +if (!schema) { +return 0 ; + } + + curr_schema = schema; + curr_param =0 ; + curr_data = data; +while (curr_schema[0 ] && curr_schema[1 ] && *curr_data) { +switch (curr_schema[0 ]) { +case 'l' : +if (qemu_strtoul (curr_data, &curr_data,16 , + ¶ms[curr_param].val_ul)) { +return -EINVAL ; + } + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'L' : +if (qemu_strtou64 (curr_data, &curr_data,16 , + (uint64_t *)¶ms[curr_param].val_ull)) { +return -EINVAL ; + } + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 's' : + params[curr_param].data = curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'o' : + params[curr_param].opcode = *(uint8_t *)curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 't' : + params[curr_param].thread_id.kind = +read_thread_id (curr_data, &curr_data, + ¶ms[curr_param].thread_id.pid, + ¶ms[curr_param].thread_id.tid); + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case 'x' : + params[curr_param].data = curr_data; + curr_param++; + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +case '?' : + curr_data =cmd_next_param (curr_data, curr_schema[1 ]); +break ; +default : +return -EINVAL ; + } + curr_schema +=2 ; + } + + *num_params = curr_param; +return 0 ; +} + +typedef struct GdbCmdContext { +GDBState *s; +GdbCmdVariant *params; +int num_params; +uint8_t mem_buf[MAX_PACKET_LENGTH ]; +char str_buf[MAX_PACKET_LENGTH +1 ]; +}GdbCmdContext ;
Quoted 8 lines
gdbstub.c out: · line 1397
Quoted 6 lines
gdbstub.c +6
-0+ +typedef void (*GdbCmdHandler )(GdbCmdContext *gdb_ctx,void *user_ctx); + +/* +* cmd_startswith -> cmd is compared using startswith +* cmd_full_match -> cmd is compared using strcmp Doesn't !cmd_full_match imply
cmd_startswith?
Done
Quoted 59 lines
Quoted 46 lines
gdbstub.c +45
-0+* +* +* schema definitions: +* Each schema parameter entry consists of 2 chars, +* the first char represents the parameter type handling +* the second char represents the delimiter for the next parameter +* +* Currently supported schema types: +* 'l' -> unsigned long (stored in .val_ul) +* 'L' -> unsigned long long (stored in .val_ull) +* 's' -> string (stored in .data) +* 'o' -> single char (stored in .opcode) +* 't' -> thread id (stored in .thread_id) +* 'x' -> xml (stored in .data), must have a ':' delimiter +* '?' -> skip according to delimiter +* +* Currently supported delimiters: +* '?' -> Stop at any delimiter (",;:=\0") +* '0' -> Stop at "\0" +* '.' -> Skip 1 char unless reached "\0" +* Any other value is treated as the delimiter value itself +*/ +typedef struct GdbCmdParseEntry { +GdbCmdHandler handler; +const char *cmd; +union { +int flags; +struct { +int cmd_startswith:1 ; +int cmd_full_match:1 ; + }; + }; +const char *schema; +}GdbCmdParseEntry ; + +static inline int startswith (const char *string,const char *pattern) +{ +return !strncmp (string, pattern,strlen (pattern)); +} + +__attribute__((unused))static int process_string_cmd ( +GDBState *s,void *user_ctx,const char *data, +GdbCmdParseEntry *cmds,int num_cmds); + +static int process_string_cmd(GDBState *s, void *user_ctx, const char *data,gdbstub.c out: · line 1452
Quoted 10 lines
gdbstub.c +10
-0+ GdbCmdParseEntry *cmds, int num_cmds) +{ + int i, schema_len, max_num_params; +GdbCmdContext gdb_ctx; + +if (!cmds) { +return -1 ; + } + +for (i =0 ; i < num_cmds; i++) {Allocating:
Quoted 5 lines
GdbCmdParseEntry *cmd = &cmds[i];might make the remaining code a little simpler to deal with.
Done
Quoted 9 lines
gdbstub.c out: · line 1453
Quoted 1 line
gdbstub.c +1
-0+ if (!cmds[i].handler || !cmds[i].cmd ||Some of these seem like asserts:
g_assert(cmd->handler && cmd->cmd);gdbstub.c out: · line 1455
Quoted 2 lines
gdbstub.c +2
-0+ (cmds[i].cmd_startswith && !startswith(data, cmds[i].cmd)) || + (cmds[i].cmd_full_match && strcmp(data, cmds[i].cmd))) {
Quoted 9 lines
then we can have the skip test:
if (cmd->cmd_startswith && !startswith(data, cmd->cmd)) { continue; } else if (strcmp(cmd->cmd, data)!=0) { continue; }
Done
Quoted 7 lines
gdbstub.c out: · line 1459
Quoted 4 lines
gdbstub.c +4
-0+continue ; + } + + max_num_params =0 ;You can set the default when you declare this above
Done but I figured it would be nicer to only initialize when required...
Quoted 16 lines
gdbstub.c out:
Quoted 13 lines
gdbstub.c +12
-0+if (cmds[i].schema) { + schema_len =strlen (cmds[i].schema); +if (schema_len %2 ) { +return -2 ; + } + + max_num_params = schema_len /2 ; + } + + gdb_ctx.params = + (GdbCmdVariant *)alloca (sizeof (*gdb_ctx.params) * max_num_params); +memset (gdb_ctx.params,0 ,sizeof (*gdb_ctx.params) * max_num_params);You could use the glib function instead:
Quoted 6 lines
gdb_ctx.params = g_newa(GdbCmdVariant, max_num_params);Although you still have to zero it which you could avoid with a
g_new0()but you'd then have to free the pointer later. Parsing code is fiddly I guess...
Stayed with _alloca for now unless you really want me to change...
Quoted 6 lines
gdbstub.c out: · line 1475
Quoted 3 lines
gdbstub.c +2
-0+ + if (cmd_parse_params(&data[strlen(cmds[i].cmd)], cmds[i].schema,Is the strlen appropriate if we have
cmd_startswith?
Well yes, because you want to skip the "cmd" part and get straight to the parameters, the strlen is on the cmd string
only, i.e: Maddr,length:XX…
the command is "M" and you want to only skip the M and get to the parameters
Quoted 19 lines
Quoted 13 lines
gdbstub.c +12
-0+ gdb_ctx.params, &gdb_ctx.num_params)) { +return -1 ; + } + + gdb_ctx.s = s; + cmds[i].handler (&gdb_ctx, user_ctx); +return 0 ; + } + +return -1 ; +} +static int gdb_handle_packet (GDBState *s,const char *line_buf)Quoted 2 lines
{ CPUState *cpu;--
Alex Bennée
Quoted 3 lines · [email protected] writes:
From: Jon Doron <[email protected]>
Signed-off-by Jon Doron <[email protected]>
Multi-patch series should have a cover letter:
https://wiki.qemu.org/index.php/Contribute/SubmitAPatch#Include_a_meaningful_cover_letter
Overall this looks like a nice improvement to the parsing code. Please CC me on the next revision.
I'm still curious as to what additional commands you plan to implement once this is merged?
--
Alex Bennée
Hi Alex,
Thank you for your comments I will add a cover-letter and update it with the review changes, as for what I'm was hoping to add later on is mostly
custom query commands for KVM perhaps might apply to other architectures as well here are things i had mind:
1. Get VM nested state, this way you can get the correct VMCS12 if we are in nested state
2. Read/Write MSR
3. Read/Write Control Registers
4. Read/Write physical memory
5. Search pattern in Physical memory
I did notice there are few custom things already in gdbstub one in particular that I would have considered that needs to modified a bit in order to be easier to parse is the 'F' command which is currently used only for ARM to syscall cb, but that's a different topic
Thanks,
-- Jon.
Quoted 20 lines · Alex Bennée
Quoted 3 lines · [email protected] writes:
From: Jon Doron <[email protected]>
Signed-off-by Jon Doron <[email protected]>Multi-patch series should have a cover letter:
https://wiki.qemu.org/index.php/Contribute/SubmitAPatch#Include_a_meaningful_cover_letter
Overall this looks like a nice improvement to the parsing code. Please CC me on the next revision.
I'm still curious as to what additional commands you plan to implement once this is merged?
--
Alex Bennée