gdbstub: Add infrastructure to parse cmd packets
PATCH v4 1/20 gdbstub: Add infrastructure to parse cmd packets
--- gdbstub.c | 209 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 209 insertions(+)
gdbstub.c +209 -0
@@ -1268,6 +1268,215 @@ 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 '?' : + 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) +* '?' -> 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 v4 2/20 gdbstub: Implement deatch (D pkt) with new infra
--- gdbstub.c | 82 +++++++++++++++++++++++++++++-------------------------- 1 file changed, 43 insertions(+), 39 deletions(-)
gdbstub.c +43 -39
@@ -1429,10 +1429,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) {
@@ -1477,6 +1473,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;
@@ -1591,42 +1622,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
PATCH v4 3/20 gdbstub: Implement thread_alive (T pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 43 ++++++++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 11 deletions(-)
gdbstub.c +32 -11
@@ -1508,6 +1508,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;
@@ -1807,17 +1831,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 v4 4/20 gdbstub: Implement continue (c pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-)
gdbstub.c +19 -6
@@ -1532,6 +1532,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;
@@ -1567,13 +1577,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
PATCH v4 5/20 gdbstub: Implement continue with signal (C pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-)
gdbstub.c +25 -5
@@ -1542,6 +1542,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;
@@ -1588,11 +1603,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 v4 6/20 gdbstub: Implement set_thread (H pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 79 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 49 insertions(+), 30 deletions(-)
gdbstub.c +49 -30
@@ -1557,6 +1557,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;
@@ -1570,7 +1611,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);
@@ -1832,35 +1872,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 v4 7/20 gdbstub: Implement insert breakpoint (Z pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
gdbstub.c +33 -0
@@ -1598,6 +1598,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;
@@ -1852,6 +1875,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 v4 8/20 gdbstub: Implement remove breakpoint (z pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 49 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 32 insertions(+), 17 deletions(-)
gdbstub.c +32 -17
@@ -1621,6 +1621,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;
@@ -1886,23 +1909,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 v4 9/20 gdbstub: Implement set register (P pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 39 ++++++++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 9 deletions(-)
gdbstub.c +30 -9
@@ -1644,6 +1644,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;
@@ -1887,15 +1908,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 v4 10/20 gdbstub: Implement get register (p pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 50 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 38 insertions(+), 12 deletions(-)
gdbstub.c +38 -12
@@ -1665,6 +1665,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;
@@ -1893,18 +1923,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 v4 11/20 gdbstub: Implement write memory (M pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 51 +++++++++++++++++++++++++++++++++------------------ 1 file changed, 33 insertions(+), 18 deletions(-)
gdbstub.c +33 -18
@@ -1695,6 +1695,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;
@@ -1902,24 +1927,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 v4 12/20 gdbstub: Implement read memory (m pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 48 ++++++++++++++++++++++++++++++++---------------- 1 file changed, 32 insertions(+), 16 deletions(-)
gdbstub.c +32 -16
@@ -1720,6 +1720,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;
@@ -1908,22 +1932,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 v4 13/20 gdbstub: Implement write all registers (G pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 41 +++++++++++++++++++++++++++++++---------- 1 file changed, 31 insertions(+), 10 deletions(-)
gdbstub.c +31 -10
@@ -1744,6 +1744,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;
@@ -1755,7 +1778,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);
@@ -1920,16 +1942,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 v4 14/20 gdbstub: Implement read all registers (g pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-)
gdbstub.c +23 -8
@@ -1767,6 +1767,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;
@@ -1774,7 +1789,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 ];
@@ -1932,14 +1947,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 v4 15/20 gdbstub: Implement file io (F pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 62 +++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 40 insertions(+), 22 deletions(-)
gdbstub.c +40 -22
@@ -1782,6 +1782,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;
@@ -1922,28 +1955,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 v4 16/20 gdbstub: Implement step (s pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-)
gdbstub.c +19 -6
@@ -1815,6 +1815,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;
@@ -1946,13 +1956,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 v4 17/20 gdbstub: Implement v commands with new infra
In reply to Jon Doron--- gdbstub.c | 170 +++++++++++++++++++++++++++++++++++------------------- 1 file changed, 110 insertions(+), 60 deletions(-)
gdbstub.c +110 -60
@@ -1825,6 +1825,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;
@@ -1832,7 +1932,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 ];
@@ -1880,66 +1980,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 v4 18/20 gdbstub: Implement generic query (q pkt) with new infra
In reply to Jon Doron--- gdbstub.c | 335 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 335 insertions(+)
gdbstub.c +335 -0
@@ -1925,6 +1925,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 ="s: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;
@@ -2137,6 +2462,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 v4 19/20 gdbstub: Implement generic set (Q pkt) with new infra
In reply to Jon Doron--- 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
@@ -2250,18 +2242,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);
@@ -2473,182 +2475,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 v4 20/20 gdbstub: Refactor parse handle packet to work with a static array
In reply to Jon Doron--- gdbstub.c | 386 ++++++++++++++++++++++-------------------------------- 1 file changed, 158 insertions(+), 228 deletions(-)
gdbstub.c +158 -228
@@ -2257,240 +2257,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