remove target argument from gdb packet handling functions

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

diff --git a/src/rtos/rtos.h b/src/rtos/rtos.h
index a6378c63050d4bd0b1746cf82430aa8bbe8df5c6..1a73bd765f9da98f664dcf934dc65c76bf620a87 100644 (file)
--- a/src/rtos/rtos.h
+++ b/src/rtos/rtos.h
@@ -99,8 +99,8 @@ struct rtos_register_stacking
 int rtos_create(Jim_GetOptInfo *goi, struct target * target);
 int rtos_generic_stack_read( struct target * target, const struct rtos_register_stacking* stacking, int64_t stack_ptr, char ** hex_reg_list );
 int rtos_try_next( struct target * target );
-int gdb_thread_packet(struct connection *connection, struct target *target, char *packet, int packet_size);
-int rtos_get_gdb_reg_list(struct connection *connection, struct target *target, struct reg **reg_list[], int *reg_list_size);
+int gdb_thread_packet(struct connection *connection, char *packet, int packet_size);
+int rtos_get_gdb_reg_list(struct connection *connection, struct reg **reg_list[], int *reg_list_size);
 int rtos_update_threads( struct target *target );
 
 #endif // RTOS_H

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

diff --git a/src/server/gdb_server.h b/src/server/gdb_server.h
index e393fb726a375a85311b7bdb68f0d50d45a029ec..2792a2030df17c21238147d205173900b3f2c6ad 100644 (file)
--- a/src/server/gdb_server.h
+++ b/src/server/gdb_server.h
@@ -40,6 +40,12 @@ int gdb_register_commands(struct command_context *command_context);
 
 int gdb_put_packet(struct connection *connection, char *buffer, int len);
 
+static inline struct target *get_target_from_connection(struct connection *connection)
+{
+       struct gdb_service *gdb_service = connection->service->priv;
+       return gdb_service->target;
+}
+
 #define ERROR_GDB_BUFFER_TOO_SMALL (-800)
 #define ERROR_GDB_TIMEOUT (-801)
 

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

diff --git a/src/target/smp.h b/src/target/smp.h
index f85c9a4aaf20527c190da65bd3f528643630f641..b8f0ea5274ad2330c0a78d01b7f2320a5bba0692 100644 (file)
--- a/src/target/smp.h
+++ b/src/target/smp.h
@@ -19,7 +19,7 @@
  ***************************************************************************/
 #include "server/server.h"
 int gdb_read_smp_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size);
+               char *packet, int packet_size);
 int gdb_write_smp_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size);
+               char *packet, int packet_size);