X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Fserver.c;h=58907ec4a9ffa3bfbf6845b4c95e5081d2e81fa2;hb=f0db101d9897732d6556456e542d12ecf9e12e42;hp=ebdaba504673e05b073b083977a26bb1211a720c;hpb=602e3198bc03297b7d9cb34ed3838272254eba1f;p=binutils-gdb.git diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index ebdaba50467..58907ec4a9f 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -1,5 +1,5 @@ /* Main code for remote server for GDB. - Copyright (C) 1989-2013 Free Software Foundation, Inc. + Copyright (C) 1989-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -21,25 +21,27 @@ #include "agent.h" #include "notif.h" #include "tdesc.h" +#include "rsp-low.h" +#include #include #if HAVE_SIGNAL_H #include #endif +#include "gdb_vecs.h" #include "gdb_wait.h" #include "btrace-common.h" #include "filestuff.h" +#include "tracepoint.h" +#include "dll.h" +#include "hostio.h" /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of `vCont'. Note the multi-process extensions made `vCont' a requirement, so `Hc pPID.TID' is pretty much undefined. So CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for resuming all threads of the process (again, `Hc' isn't used for - multi-process), or a specific thread ptid_t. - - We also set this when handling a single-thread `vCont' resume, as - some places in the backends check it to know when (and for which - thread) single-thread scheduler-locking is in effect. */ + multi-process), or a specific thread ptid_t. */ ptid_t cont_thread; /* The thread set with an `Hg' packet. */ @@ -47,7 +49,7 @@ ptid_t general_thread; int server_waiting; -static int extended_protocol; +int extended_protocol; static int response_needed; static int exit_requested; @@ -55,7 +57,11 @@ static int exit_requested; int run_once; int multi_process; +int report_fork_events; +int report_vfork_events; int non_stop; +int swbreak_feature; +int hwbreak_feature; /* Whether we should attempt to disable the operating system's address space randomization feature before starting an inferior. */ @@ -63,19 +69,10 @@ int disable_randomization = 1; static char **program_argv, **wrapper_argv; -/* Enable miscellaneous debugging output. The name is historical - it - was originally used to debug LinuxThreads support. */ -int debug_threads; - -/* Enable debugging of h/w breakpoint/watchpoint support. */ -int debug_hw_points; - int pass_signals[GDB_SIGNAL_LAST]; int program_signals[GDB_SIGNAL_LAST]; int program_signals_p; -jmp_buf toplevel; - /* The PID of the originally created or attached inferior. Used to send signals to the process when GDB sends us an asynchronous interrupt (user hitting Control-C in the client), and to wait for the child to exit @@ -129,6 +126,10 @@ struct vstop_notif struct target_waitstatus status; }; +/* The current btrace configuration. This is gdbserver's mirror of GDB's + btrace configuration. */ +static struct btrace_config current_btrace_conf; + DEFINE_QUEUE_P (notif_event_p); /* Put a stop reply to the stop reply queue. */ @@ -190,7 +191,7 @@ struct notif_server notif_stop = static int target_running (void) { - return all_threads.head != NULL; + return get_first_thread () != NULL; } static int @@ -219,8 +220,8 @@ start_inferior (char **argv) { int i; for (i = 0; new_argv[i]; ++i) - fprintf (stderr, "new_argv[%d] = \"%s\"\n", i, new_argv[i]); - fflush (stderr); + debug_printf ("new_argv[%d] = \"%s\"\n", i, new_argv[i]); + debug_flush (); } #ifdef SIGTTOU @@ -228,10 +229,6 @@ start_inferior (char **argv) signal (SIGTTIN, SIG_DFL); #endif - /* Clear this so the backend doesn't get confused, thinking - CONT_THREAD died, and it needs to resume all threads. */ - cont_thread = null_ptid; - signal_pid = create_inferior (new_argv[0], new_argv); /* FIXME: we don't actually know at this point that the create @@ -253,28 +250,29 @@ start_inferior (char **argv) { struct thread_resume resume_info; + memset (&resume_info, 0, sizeof (resume_info)); resume_info.thread = pid_to_ptid (signal_pid); resume_info.kind = resume_continue; resume_info.sig = 0; last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); - if (last_status.kind != TARGET_WAITKIND_STOPPED) - return signal_pid; - - do + if (last_status.kind == TARGET_WAITKIND_STOPPED) { - (*the_target->resume) (&resume_info, 1); + do + { + (*the_target->resume) (&resume_info, 1); - last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); - if (last_status.kind != TARGET_WAITKIND_STOPPED) - return signal_pid; + last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); + if (last_status.kind != TARGET_WAITKIND_STOPPED) + break; - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; + } + while (last_status.value.sig != GDB_SIGNAL_TRAP); } - while (last_status.value.sig != GDB_SIGNAL_TRAP); - + target_arch_setup (); return signal_pid; } @@ -282,12 +280,16 @@ start_inferior (char **argv) (assuming success). */ last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); + target_arch_setup (); + if (last_status.kind != TARGET_WAITKIND_EXITED && last_status.kind != TARGET_WAITKIND_SIGNALLED) { - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; } + else + mourn_inferior (find_process_pid (ptid_get_pid (last_ptid))); return signal_pid; } @@ -309,10 +311,6 @@ attach_inferior (int pid) whichever we were told to attach to. */ signal_pid = pid; - /* Clear this so the backend doesn't get confused, thinking - CONT_THREAD died, and it needs to resume all threads. */ - cont_thread = null_ptid; - if (!non_stop) { last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0); @@ -324,8 +322,8 @@ attach_inferior (int pid) && last_status.value.sig == GDB_SIGNAL_STOP) last_status.value.sig = GDB_SIGNAL_TRAP; - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; } return 0; @@ -391,19 +389,38 @@ write_qxfer_response (char *buf, const void *data, int len, int is_more) else buf[0] = 'l'; - return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len, - PBUFSIZ - 2) + 1; + return remote_escape_output (data, len, 1, (unsigned char *) buf + 1, + &out_len, PBUFSIZ - 2) + 1; } -/* Handle btrace enabling. */ +/* Handle btrace enabling in BTS format. */ static const char * -handle_btrace_enable (struct thread_info *thread) +handle_btrace_enable_bts (struct thread_info *thread) { if (thread->btrace != NULL) return "E.Btrace already enabled."; - thread->btrace = target_enable_btrace (thread->entry.id); + current_btrace_conf.format = BTRACE_FORMAT_BTS; + thread->btrace = target_enable_btrace (thread->entry.id, + ¤t_btrace_conf); + if (thread->btrace == NULL) + return "E.Could not enable btrace."; + + return NULL; +} + +/* Handle btrace enabling in Intel(R) Processor Trace format. */ + +static const char * +handle_btrace_enable_pt (struct thread_info *thread) +{ + if (thread->btrace != NULL) + return "E.Btrace already enabled."; + + current_btrace_conf.format = BTRACE_FORMAT_PT; + thread->btrace = target_enable_btrace (thread->entry.id, + ¤t_btrace_conf); if (thread->btrace == NULL) return "E.Could not enable btrace."; @@ -435,17 +452,11 @@ handle_btrace_general_set (char *own_buf) const char *err; char *op; - if (strncmp ("Qbtrace:", own_buf, strlen ("Qbtrace:")) != 0) + if (!startswith (own_buf, "Qbtrace:")) return 0; op = own_buf + strlen ("Qbtrace:"); - if (!target_supports_btrace ()) - { - strcpy (own_buf, "E.Target does not support branch tracing."); - return -1; - } - if (ptid_equal (general_thread, null_ptid) || ptid_equal (general_thread, minus_one_ptid)) { @@ -463,11 +474,13 @@ handle_btrace_general_set (char *own_buf) err = NULL; if (strcmp (op, "bts") == 0) - err = handle_btrace_enable (thread); + err = handle_btrace_enable_bts (thread); + else if (strcmp (op, "pt") == 0) + err = handle_btrace_enable_pt (thread); else if (strcmp (op, "off") == 0) err = handle_btrace_disable (thread); else - err = "E.Bad Qbtrace operation. Use bts or off."; + err = "E.Bad Qbtrace operation. Use bts, pt, or off."; if (err != 0) strcpy (own_buf, err); @@ -477,12 +490,79 @@ handle_btrace_general_set (char *own_buf) return 1; } +/* Handle the "Qbtrace-conf" packet. */ + +static int +handle_btrace_conf_general_set (char *own_buf) +{ + struct thread_info *thread; + char *op; + + if (!startswith (own_buf, "Qbtrace-conf:")) + return 0; + + op = own_buf + strlen ("Qbtrace-conf:"); + + if (ptid_equal (general_thread, null_ptid) + || ptid_equal (general_thread, minus_one_ptid)) + { + strcpy (own_buf, "E.Must select a single thread."); + return -1; + } + + thread = find_thread_ptid (general_thread); + if (thread == NULL) + { + strcpy (own_buf, "E.No such thread."); + return -1; + } + + if (startswith (op, "bts:size=")) + { + unsigned long size; + char *endp = NULL; + + errno = 0; + size = strtoul (op + strlen ("bts:size="), &endp, 16); + if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX) + { + strcpy (own_buf, "E.Bad size value."); + return -1; + } + + current_btrace_conf.bts.size = (unsigned int) size; + } + else if (strncmp (op, "pt:size=", strlen ("pt:size=")) == 0) + { + unsigned long size; + char *endp = NULL; + + errno = 0; + size = strtoul (op + strlen ("pt:size="), &endp, 16); + if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX) + { + strcpy (own_buf, "E.Bad size value."); + return -1; + } + + current_btrace_conf.pt.size = (unsigned int) size; + } + else + { + strcpy (own_buf, "E.Bad Qbtrace configuration option."); + return -1; + } + + write_ok (own_buf); + return 1; +} + /* Handle all of the extended 'Q' packets. */ static void handle_general_set (char *own_buf) { - if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0) + if (startswith (own_buf, "QPassSignals:")) { int numsigs = (int) GDB_SIGNAL_LAST, i; const char *p = own_buf + strlen ("QPassSignals:"); @@ -507,7 +587,7 @@ handle_general_set (char *own_buf) return; } - if (strncmp ("QProgramSignals:", own_buf, strlen ("QProgramSignals:")) == 0) + if (startswith (own_buf, "QProgramSignals:")) { int numsigs = (int) GDB_SIGNAL_LAST, i; const char *p = own_buf + strlen ("QProgramSignals:"); @@ -547,11 +627,11 @@ handle_general_set (char *own_buf) return; } - if (strncmp (own_buf, "QNonStop:", 9) == 0) + if (startswith (own_buf, "QNonStop:")) { char *mode = own_buf + 9; int req = -1; - char *req_str; + const char *req_str; if (strcmp (mode, "0") == 0) req = 0; @@ -584,8 +664,7 @@ handle_general_set (char *own_buf) return; } - if (strncmp ("QDisableRandomization:", own_buf, - strlen ("QDisableRandomization:")) == 0) + if (startswith (own_buf, "QDisableRandomization:")) { char *packet = own_buf + strlen ("QDisableRandomization:"); ULONGEST setting; @@ -609,7 +688,7 @@ handle_general_set (char *own_buf) && handle_tracepoint_general_set (own_buf)) return; - if (strncmp ("QAgent:", own_buf, strlen ("QAgent:")) == 0) + if (startswith (own_buf, "QAgent:")) { char *mode = own_buf + strlen ("QAgent:"); int req = 0; @@ -636,6 +715,9 @@ handle_general_set (char *own_buf) if (handle_btrace_general_set (own_buf)) return; + if (handle_btrace_conf_general_set (own_buf)) + return; + /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ own_buf[0] = 0; @@ -690,6 +772,11 @@ monitor_show_help (void) monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n"); monitor_output (" set remote-debug <0|1>\n"); monitor_output (" Enable remote protocol debugging messages\n"); + monitor_output (" set debug-format option1[,option2,...]\n"); + monitor_output (" Add additional information to debugging messages\n"); + monitor_output (" Options: all, none"); + monitor_output (", timestamp"); + monitor_output ("\n"); monitor_output (" exit\n"); monitor_output (" Quit GDBserver\n"); } @@ -716,7 +803,7 @@ gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) if (traceframe_read_mem (current_traceframe, memaddr, myaddr, len, &nbytes)) - return EIO; + return -1; /* Data read from trace buffer, we're done. */ if (nbytes > 0) return nbytes; @@ -729,7 +816,10 @@ gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) res = prepare_to_access_memory (); if (res == 0) { - res = read_inferior_memory (memaddr, myaddr, len); + if (set_desired_thread (1)) + res = read_inferior_memory (memaddr, myaddr, len); + else + res = 1; done_accessing_memory (); return res == 0 ? len : -1; @@ -753,7 +843,10 @@ gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) ret = prepare_to_access_memory (); if (ret == 0) { - ret = write_inferior_memory (memaddr, myaddr, len); + if (set_desired_thread (1)) + ret = write_inferior_memory (memaddr, myaddr, len); + else + ret = EIO; done_accessing_memory (); } return ret; @@ -917,6 +1010,78 @@ handle_search_memory (char *own_buf, int packet_len) return; \ } +/* Parse options to --debug-format= and "monitor set debug-format". + ARG is the text after "--debug-format=" or "monitor set debug-format". + IS_MONITOR is non-zero if we're invoked via "monitor set debug-format". + This triggers calls to monitor_output. + The result is NULL if all options were parsed ok, otherwise an error + message which the caller must free. + + N.B. These commands affect all debug format settings, they are not + cumulative. If a format is not specified, it is turned off. + However, we don't go to extra trouble with things like + "monitor set debug-format all,none,timestamp". + Instead we just parse them one at a time, in order. + + The syntax for "monitor set debug" we support here is not identical + to gdb's "set debug foo on|off" because we also use this function to + parse "--debug-format=foo,bar". */ + +static char * +parse_debug_format_options (const char *arg, int is_monitor) +{ + VEC (char_ptr) *options; + int ix; + char *option; + + /* First turn all debug format options off. */ + debug_timestamp = 0; + + /* First remove leading spaces, for "monitor set debug-format". */ + while (isspace (*arg)) + ++arg; + + options = delim_string_to_char_ptr_vec (arg, ','); + + for (ix = 0; VEC_iterate (char_ptr, options, ix, option); ++ix) + { + if (strcmp (option, "all") == 0) + { + debug_timestamp = 1; + if (is_monitor) + monitor_output ("All extra debug format options enabled.\n"); + } + else if (strcmp (option, "none") == 0) + { + debug_timestamp = 0; + if (is_monitor) + monitor_output ("All extra debug format options disabled.\n"); + } + else if (strcmp (option, "timestamp") == 0) + { + debug_timestamp = 1; + if (is_monitor) + monitor_output ("Timestamps will be added to debug output.\n"); + } + else if (*option == '\0') + { + /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */ + continue; + } + else + { + char *msg = xstrprintf ("Unknown debug-format argument: \"%s\"\n", + option); + + free_char_ptr_vec (options); + return msg; + } + } + + free_char_ptr_vec (options); + return NULL; +} + /* Handle monitor commands not handled by target-specific handlers. */ static void @@ -934,12 +1099,12 @@ handle_monitor_command (char *mon, char *own_buf) } else if (strcmp (mon, "set debug-hw-points 1") == 0) { - debug_hw_points = 1; + show_debug_regs = 1; monitor_output ("H/W point debugging output enabled.\n"); } else if (strcmp (mon, "set debug-hw-points 0") == 0) { - debug_hw_points = 0; + show_debug_regs = 0; monitor_output ("H/W point debugging output disabled.\n"); } else if (strcmp (mon, "set remote-debug 1") == 0) @@ -952,6 +1117,20 @@ handle_monitor_command (char *mon, char *own_buf) remote_debug = 0; monitor_output ("Protocol debug output disabled.\n"); } + else if (startswith (mon, "set debug-format ")) + { + char *error_msg + = parse_debug_format_options (mon + sizeof ("set debug-format ") - 1, + 1); + + if (error_msg != NULL) + { + monitor_output (error_msg); + monitor_show_help (); + write_enn (own_buf); + xfree (error_msg); + } + } else if (strcmp (mon, "help") == 0) monitor_show_help (); else if (strcmp (mon, "exit") == 0) @@ -998,12 +1177,63 @@ handle_qxfer_auxv (const char *annex, if (the_target->read_auxv == NULL || writebuf != NULL) return -2; - if (annex[0] != '\0' || !target_running ()) + if (annex[0] != '\0' || current_thread == NULL) return -1; return (*the_target->read_auxv) (offset, readbuf, len); } +/* Handle qXfer:exec-file:read. */ + +static int +handle_qxfer_exec_file (const char *const_annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) +{ + char *file; + ULONGEST pid; + int total_len; + + if (the_target->pid_to_exec_file == NULL || writebuf != NULL) + return -2; + + if (const_annex[0] == '\0') + { + if (current_thread == NULL) + return -1; + + pid = pid_of (current_thread); + } + else + { + char *annex = alloca (strlen (const_annex) + 1); + + strcpy (annex, const_annex); + annex = unpack_varlen_hex (annex, &pid); + + if (annex[0] != '\0') + return -1; + } + + if (pid <= 0) + return -1; + + file = (*the_target->pid_to_exec_file) (pid); + if (file == NULL) + return -1; + + total_len = strlen (file); + + if (offset > total_len) + return -1; + + if (offset + len > total_len) + len = total_len - offset; + + memcpy (readbuf, file + offset, len); + return len; +} + /* Handle qXfer:features:read. */ static int @@ -1037,6 +1267,48 @@ handle_qxfer_features (const char *annex, return len; } +/* Worker routine for handle_qxfer_libraries. + Add to the length pointed to by ARG a conservative estimate of the + length needed to transmit the file name of INF. */ + +static void +accumulate_file_name_length (struct inferior_list_entry *inf, void *arg) +{ + struct dll_info *dll = (struct dll_info *) inf; + unsigned int *total_len = arg; + + /* Over-estimate the necessary memory. Assume that every character + in the library name must be escaped. */ + *total_len += 128 + 6 * strlen (dll->name); +} + +/* Worker routine for handle_qxfer_libraries. + Emit the XML to describe the library in INF. */ + +static void +emit_dll_description (struct inferior_list_entry *inf, void *arg) +{ + struct dll_info *dll = (struct dll_info *) inf; + char **p_ptr = arg; + char *p = *p_ptr; + char *name; + + strcpy (p, " name); + strcpy (p, name); + free (name); + p = p + strlen (p); + strcpy (p, "\">base_addr); + p = p + strlen (p); + strcpy (p, "\"/>\n"); + p = p + strlen (p); + + *p_ptr = p; +} + /* Handle qXfer:libraries:read. */ static int @@ -1046,45 +1318,25 @@ handle_qxfer_libraries (const char *annex, { unsigned int total_len; char *document, *p; - struct inferior_list_entry *dll_ptr; if (writebuf != NULL) return -2; - if (annex[0] != '\0' || !target_running ()) + if (annex[0] != '\0' || current_thread == NULL) return -1; - /* Over-estimate the necessary memory. Assume that every character - in the library name must be escaped. */ total_len = 64; - for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next) - total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name); + for_each_inferior_with_data (&all_dlls, accumulate_file_name_length, + &total_len); document = malloc (total_len); if (document == NULL) return -1; - strcpy (document, "\n"); + strcpy (document, "\n"); p = document + strlen (document); - for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next) - { - struct dll_info *dll = (struct dll_info *) dll_ptr; - char *name; - - strcpy (p, " name); - strcpy (p, name); - free (name); - p = p + strlen (p); - strcpy (p, "\">base_addr); - p = p + strlen (p); - strcpy (p, "\"/>\n"); - p = p + strlen (p); - } + for_each_inferior_with_data (&all_dlls, emit_dll_description, &p); strcpy (p, "\n"); @@ -1114,7 +1366,7 @@ handle_qxfer_libraries_svr4 (const char *annex, if (writebuf != NULL) return -2; - if (!target_running () || the_target->qxfer_libraries_svr4 == NULL) + if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL) return -1; return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len); @@ -1143,7 +1395,7 @@ handle_qxfer_siginfo (const char *annex, if (the_target->qxfer_siginfo == NULL) return -2; - if (annex[0] != '\0' || !target_running ()) + if (annex[0] != '\0' || current_thread == NULL) return -1; return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len); @@ -1159,7 +1411,7 @@ handle_qxfer_spu (const char *annex, if (the_target->qxfer_spu == NULL) return -2; - if (!target_running ()) + if (current_thread == NULL) return -1; return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len); @@ -1177,7 +1429,7 @@ handle_qxfer_statictrace (const char *annex, if (writebuf != NULL) return -2; - if (annex[0] != '\0' || !target_running () || current_traceframe == -1) + if (annex[0] != '\0' || current_thread == NULL || current_traceframe == -1) return -1; if (traceframe_read_sdata (current_traceframe, offset, @@ -1186,36 +1438,43 @@ handle_qxfer_statictrace (const char *annex, return nbytes; } -/* Helper for handle_qxfer_threads. */ +/* Helper for handle_qxfer_threads_proper. + Emit the XML to describe the thread of INF. */ static void -handle_qxfer_threads_proper (struct buffer *buffer) +handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg) { - struct inferior_list_entry *thread; + struct thread_info *thread = (struct thread_info *) inf; + struct buffer *buffer = arg; + ptid_t ptid = thread_to_gdb_id (thread); + char ptid_s[100]; + int core = target_core_of_thread (ptid); + char core_s[21]; - buffer_grow_str (buffer, "\n"); + write_ptid (ptid_s, ptid); - for (thread = all_threads.head; thread; thread = thread->next) + if (core != -1) + { + sprintf (core_s, "%d", core); + buffer_xml_printf (buffer, "\n", + ptid_s, core_s); + } + else { - ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread); - char ptid_s[100]; - int core = target_core_of_thread (ptid); - char core_s[21]; + buffer_xml_printf (buffer, "\n", + ptid_s); + } +} - write_ptid (ptid_s, ptid); +/* Helper for handle_qxfer_threads. */ - if (core != -1) - { - sprintf (core_s, "%d", core); - buffer_xml_printf (buffer, "\n", - ptid_s, core_s); - } - else - { - buffer_xml_printf (buffer, "\n", - ptid_s); - } - } +static void +handle_qxfer_threads_proper (struct buffer *buffer) +{ + buffer_grow_str (buffer, "\n"); + + for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker, + buffer); buffer_grow_str0 (buffer, "\n"); } @@ -1233,7 +1492,7 @@ handle_qxfer_threads (const char *annex, if (writebuf != NULL) return -2; - if (!target_running () || annex[0] != '\0') + if (annex[0] != '\0') return -1; if (offset == 0) @@ -1329,7 +1588,7 @@ handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf, if (the_target->read_loadmap == NULL) return -2; - if (!target_running ()) + if (current_thread == NULL) return -1; return (*the_target->read_loadmap) (annex, offset, readbuf, len); @@ -1344,14 +1603,11 @@ handle_qxfer_btrace (const char *annex, { static struct buffer cache; struct thread_info *thread; - int type; + int type, result; if (the_target->read_btrace == NULL || writebuf != NULL) return -2; - if (!target_running ()) - return -1; - if (ptid_equal (general_thread, null_ptid) || ptid_equal (general_thread, minus_one_ptid)) { @@ -1373,9 +1629,11 @@ handle_qxfer_btrace (const char *annex, } if (strcmp (annex, "all") == 0) - type = btrace_read_all; + type = BTRACE_READ_ALL; else if (strcmp (annex, "new") == 0) - type = btrace_read_new; + type = BTRACE_READ_NEW; + else if (strcmp (annex, "delta") == 0) + type = BTRACE_READ_DELTA; else { strcpy (own_buf, "E.Bad annex."); @@ -1386,7 +1644,74 @@ handle_qxfer_btrace (const char *annex, { buffer_free (&cache); - target_read_btrace (thread->btrace, &cache, type); + result = target_read_btrace (thread->btrace, &cache, type); + if (result != 0) + { + memcpy (own_buf, cache.buffer, cache.used_size); + return -3; + } + } + else if (offset > cache.used_size) + { + buffer_free (&cache); + return -3; + } + + if (len > cache.used_size - offset) + len = cache.used_size - offset; + + memcpy (readbuf, cache.buffer + offset, len); + + return len; +} + +/* Handle qXfer:btrace-conf:read. */ + +static int +handle_qxfer_btrace_conf (const char *annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) +{ + static struct buffer cache; + struct thread_info *thread; + int result; + + if (the_target->read_btrace_conf == NULL || writebuf != NULL) + return -2; + + if (annex[0] != '\0') + return -1; + + if (ptid_equal (general_thread, null_ptid) + || ptid_equal (general_thread, minus_one_ptid)) + { + strcpy (own_buf, "E.Must select a single thread."); + return -3; + } + + thread = find_thread_ptid (general_thread); + if (thread == NULL) + { + strcpy (own_buf, "E.No such thread."); + return -3; + } + + if (thread->btrace == NULL) + { + strcpy (own_buf, "E.Btrace not enabled."); + return -3; + } + + if (offset == 0) + { + buffer_free (&cache); + + result = target_read_btrace_conf (thread->btrace, &cache); + if (result != 0) + { + memcpy (own_buf, cache.buffer, cache.used_size); + return -3; + } } else if (offset > cache.used_size) { @@ -1406,6 +1731,8 @@ static const struct qxfer qxfer_packets[] = { { "auxv", handle_qxfer_auxv }, { "btrace", handle_qxfer_btrace }, + { "btrace-conf", handle_qxfer_btrace_conf }, + { "exec-file", handle_qxfer_exec_file}, { "fdpic", handle_qxfer_fdpic}, { "features", handle_qxfer_features }, { "libraries", handle_qxfer_libraries }, @@ -1427,7 +1754,7 @@ handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) char *annex; char *offset; - if (strncmp (own_buf, "qXfer:", 6) != 0) + if (!startswith (own_buf, "qXfer:")) return 0; /* Grab the object, r/w and annex. */ @@ -1578,6 +1905,37 @@ crc32 (CORE_ADDR base, int len, unsigned int crc) return (unsigned long long) crc; } +/* Add supported btrace packets to BUF. */ + +static void +supported_btrace_packets (char *buf) +{ + int btrace_supported = 0; + + if (target_supports_btrace (BTRACE_FORMAT_BTS)) + { + strcat (buf, ";Qbtrace:bts+"); + strcat (buf, ";Qbtrace-conf:bts:size+"); + + btrace_supported = 1; + } + + if (target_supports_btrace (BTRACE_FORMAT_PT)) + { + strcat (buf, ";Qbtrace:pt+"); + strcat (buf, ";Qbtrace-conf:pt:size+"); + + btrace_supported = 1; + } + + if (!btrace_supported) + return; + + strcat (buf, ";Qbtrace:off+"); + strcat (buf, ";qXfer:btrace:read+"); + strcat (buf, ";qXfer:btrace-conf:read+"); +} + /* Handle all of the extended 'q' packets. */ void @@ -1596,7 +1954,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) gdb_id = general_thread; else { - thread_ptr = all_threads.head; + thread_ptr = get_first_inferior (&all_threads); gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr); } @@ -1623,7 +1981,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (target_supports_tracepoints ()) tracepoint_look_up_symbols (); - if (target_running () && the_target->look_up_symbols != NULL) + if (current_thread != NULL && the_target->look_up_symbols != NULL) (*the_target->look_up_symbols) (); strcpy (own_buf, "OK"); @@ -1637,7 +1995,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) ptid_t gdb_id; require_running (own_buf); - thread_ptr = all_threads.head; + thread_ptr = get_first_inferior (&all_threads); *own_buf++ = 'm'; gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr); @@ -1683,7 +2041,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } /* Protocol features query. */ - if (strncmp ("qSupported", own_buf, 10) == 0 + if (startswith (own_buf, "qSupported") && (own_buf[10] == ':' || own_buf[10] == '\0')) { char *p = &own_buf[10]; @@ -1727,6 +2085,33 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) /* GDB supports relocate instruction requests. */ gdb_supports_qRelocInsn = 1; } + else if (strcmp (p, "swbreak+") == 0) + { + /* GDB wants us to report whether a trap is caused + by a software breakpoint and for us to handle PC + adjustment if necessary on this target. */ + if (target_supports_stopped_by_sw_breakpoint ()) + swbreak_feature = 1; + } + else if (strcmp (p, "hwbreak+") == 0) + { + /* GDB wants us to report whether a trap is caused + by a hardware breakpoint. */ + if (target_supports_stopped_by_hw_breakpoint ()) + hwbreak_feature = 1; + } + else if (strcmp (p, "fork-events+") == 0) + { + /* GDB supports and wants fork events if possible. */ + if (target_supports_fork_events ()) + report_fork_events = 1; + } + else if (strcmp (p, "vfork-events+") == 0) + { + /* GDB supports and wants vfork events if possible. */ + if (target_supports_vfork_events ()) + report_vfork_events = 1; + } else target_process_qsupported (p); @@ -1777,6 +2162,12 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (target_supports_multi_process ()) strcat (own_buf, ";multiprocess+"); + if (target_supports_fork_events ()) + strcat (own_buf, ";fork-events+"); + + if (target_supports_vfork_events ()) + strcat (own_buf, ";vfork-events+"); + if (target_supports_non_stop ()) strcat (own_buf, ";QNonStop+"); @@ -1803,25 +2194,34 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } /* Support target-side breakpoint conditions and commands. */ - strcat (own_buf, ";ConditionalBreakpoints+"); + if (target_supports_conditional_breakpoints ()) + strcat (own_buf, ";ConditionalBreakpoints+"); strcat (own_buf, ";BreakpointCommands+"); if (target_supports_agent ()) strcat (own_buf, ";QAgent+"); - if (target_supports_btrace ()) - { - strcat (own_buf, ";Qbtrace:bts+"); - strcat (own_buf, ";Qbtrace:off+"); - strcat (own_buf, ";qXfer:btrace:read+"); - } + supported_btrace_packets (own_buf); + + if (target_supports_stopped_by_sw_breakpoint ()) + strcat (own_buf, ";swbreak+"); + + if (target_supports_stopped_by_hw_breakpoint ()) + strcat (own_buf, ";hwbreak+"); + + if (the_target->pid_to_exec_file != NULL) + strcat (own_buf, ";qXfer:exec-file:read+"); + + /* Reinitialize components as needed for the new connection. */ + hostio_handle_new_gdb_connection (); + target_handle_new_gdb_connection (); return; } /* Thread-local storage support. */ if (the_target->get_tls_address != NULL - && strncmp ("qGetTLSAddr:", own_buf, 12) == 0) + && startswith (own_buf, "qGetTLSAddr:")) { char *p = own_buf + 12; CORE_ADDR parts[2], address = 0; @@ -1886,7 +2286,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) /* Windows OS Thread Information Block address support. */ if (the_target->get_tib_address != NULL - && strncmp ("qGetTIBAddr:", own_buf, 12) == 0) + && startswith (own_buf, "qGetTIBAddr:")) { char *annex; int n; @@ -1908,7 +2308,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } /* Handle "monitor" commands. */ - if (strncmp ("qRcmd,", own_buf, 6) == 0) + if (startswith (own_buf, "qRcmd,")) { char *mon = malloc (PBUFSIZ); int len = strlen (own_buf + 6); @@ -1919,7 +2319,8 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) return; } - if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2) + if ((len % 2) != 0 + || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2) { write_enn (own_buf); free (mon); @@ -1938,8 +2339,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) return; } - if (strncmp ("qSearch:memory:", own_buf, - sizeof ("qSearch:memory:") - 1) == 0) + if (startswith (own_buf, "qSearch:memory:")) { require_running (own_buf); handle_search_memory (own_buf, packet_len); @@ -1947,7 +2347,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } if (strcmp (own_buf, "qAttached") == 0 - || strncmp (own_buf, "qAttached:", sizeof ("qAttached:") - 1) == 0) + || startswith (own_buf, "qAttached:")) { struct process_info *process; @@ -1973,7 +2373,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) return; } - if (strncmp ("qCRC:", own_buf, 5) == 0) + if (startswith (own_buf, "qCRC:")) { /* CRC check (compare-section). */ char *comma; @@ -2012,6 +2412,73 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } static void gdb_wants_all_threads_stopped (void); +static void resume (struct thread_resume *actions, size_t n); + +/* The callback that is passed to visit_actioned_threads. */ +typedef int (visit_actioned_threads_callback_ftype) + (const struct thread_resume *, struct thread_info *); + +/* Struct to pass data to visit_actioned_threads. */ + +struct visit_actioned_threads_data +{ + const struct thread_resume *actions; + size_t num_actions; + visit_actioned_threads_callback_ftype *callback; +}; + +/* Call CALLBACK for any thread to which ACTIONS applies to. Returns + true if CALLBACK returns true. Returns false if no matching thread + is found or CALLBACK results false. + Note: This function is itself a callback for find_inferior. */ + +static int +visit_actioned_threads (struct inferior_list_entry *entry, void *datap) +{ + struct visit_actioned_threads_data *data = datap; + const struct thread_resume *actions = data->actions; + size_t num_actions = data->num_actions; + visit_actioned_threads_callback_ftype *callback = data->callback; + size_t i; + + for (i = 0; i < num_actions; i++) + { + const struct thread_resume *action = &actions[i]; + + if (ptid_equal (action->thread, minus_one_ptid) + || ptid_equal (action->thread, entry->id) + || ((ptid_get_pid (action->thread) + == ptid_get_pid (entry->id)) + && ptid_get_lwp (action->thread) == -1)) + { + struct thread_info *thread = (struct thread_info *) entry; + + if ((*callback) (action, thread)) + return 1; + } + } + + return 0; +} + +/* Callback for visit_actioned_threads. If the thread has a pending + status to report, report it now. */ + +static int +handle_pending_status (const struct thread_resume *resumption, + struct thread_info *thread) +{ + if (thread->status_pending_p) + { + thread->status_pending_p = 0; + + last_status = thread->last_status; + last_ptid = thread->entry.id; + prepare_resume_reply (own_buf, last_ptid, &last_status); + return 1; + } + return 0; +} /* Parse vCont packets. */ void @@ -2111,25 +2578,39 @@ handle_v_cont (char *own_buf) if (i < n) resume_info[i] = default_action; - /* `cont_thread' is still used in occasional places in the backend, - to implement single-thread scheduler-locking. Doesn't make sense - to set it if we see a stop request, or a wildcard action (one - with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */ - if (n == 1 - && !(ptid_equal (resume_info[0].thread, minus_one_ptid) - || ptid_get_lwp (resume_info[0].thread) == -1) - && resume_info[0].kind != resume_stop) - cont_thread = resume_info[0].thread; - else - cont_thread = minus_one_ptid; - set_desired_inferior (0); + resume (resume_info, n); + free (resume_info); + return; - if (!non_stop) - enable_async_io (); +err: + write_enn (own_buf); + free (resume_info); + return; +} - (*the_target->resume) (resume_info, n); +/* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */ - free (resume_info); +static void +resume (struct thread_resume *actions, size_t num_actions) +{ + if (!non_stop) + { + /* Check if among the threads that GDB wants actioned, there's + one with a pending status to report. If so, skip actually + resuming/stopping and report the pending event + immediately. */ + struct visit_actioned_threads_data data; + + data.actions = actions; + data.num_actions = num_actions; + data.callback = handle_pending_status; + if (find_inferior (&all_threads, visit_actioned_threads, &data) != NULL) + return; + + enable_async_io (); + } + + (*the_target->resume) (actions, num_actions); if (non_stop) write_ok (own_buf); @@ -2137,9 +2618,19 @@ handle_v_cont (char *own_buf) { last_ptid = mywait (minus_one_ptid, &last_status, 0, 1); + if (last_status.kind == TARGET_WAITKIND_NO_RESUMED) + { + /* No proper RSP support for this yet. At least return + error. */ + sprintf (own_buf, "E.No unwaited-for children left."); + disable_async_io (); + return; + } + if (last_status.kind != TARGET_WAITKIND_EXITED - && last_status.kind != TARGET_WAITKIND_SIGNALLED) - current_inferior->last_status = last_status; + && last_status.kind != TARGET_WAITKIND_SIGNALLED + && last_status.kind != TARGET_WAITKIND_NO_RESUMED) + current_thread->last_status = last_status; /* From the client's perspective, all-stop mode always stops all threads implicitly (and the target backend has already done @@ -2153,12 +2644,6 @@ handle_v_cont (char *own_buf) || last_status.kind == TARGET_WAITKIND_SIGNALLED) mourn_inferior (find_process_pid (ptid_get_pid (last_ptid))); } - return; - -err: - write_enn (own_buf); - free (resume_info); - return; } /* Attach to a new program. Return 1 if successful, 0 if failure. */ @@ -2229,7 +2714,7 @@ handle_v_run (char *own_buf) { /* FIXME: Fail request if out of memory instead of dying. */ new_argv[i] = xmalloc (1 + (next_p - p) / 2); - unhexify (new_argv[i], p, (next_p - p) / 2); + hex2bin (p, (gdb_byte *) new_argv[i], (next_p - p) / 2); new_argv[i][(next_p - p) / 2] = '\0'; } @@ -2316,14 +2801,14 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) { if (!disable_packet_vCont) { - if (strncmp (own_buf, "vCont;", 6) == 0) + if (startswith (own_buf, "vCont;")) { require_running (own_buf); handle_v_cont (own_buf); return; } - if (strncmp (own_buf, "vCont?", 6) == 0) + if (startswith (own_buf, "vCont?")) { strcpy (own_buf, "vCont;c;C;s;S;t"); if (target_supports_range_stepping ()) @@ -2335,11 +2820,11 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) } } - if (strncmp (own_buf, "vFile:", 6) == 0 + if (startswith (own_buf, "vFile:") && handle_vFile (own_buf, packet_len, new_packet_len)) return; - if (strncmp (own_buf, "vAttach;", 8) == 0) + if (startswith (own_buf, "vAttach;")) { if ((!extended_protocol || !multi_process) && target_running ()) { @@ -2351,7 +2836,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) return; } - if (strncmp (own_buf, "vRun;", 5) == 0) + if (startswith (own_buf, "vRun;")) { if ((!extended_protocol || !multi_process) && target_running ()) { @@ -2363,7 +2848,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) return; } - if (strncmp (own_buf, "vKill;", 6) == 0) + if (startswith (own_buf, "vKill;")) { if (!target_running ()) { @@ -2384,7 +2869,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) return; } -/* Resume inferior and wait for another event. In non-stop mode, +/* Resume thread and wait for another event. In non-stop mode, don't really wait here, but return immediatelly to the event loop. */ static void @@ -2394,8 +2879,6 @@ myresume (char *own_buf, int step, int sig) int n = 0; int valid_cont_thread; - set_desired_inferior (0); - valid_cont_thread = (!ptid_equal (cont_thread, null_ptid) && !ptid_equal (cont_thread, minus_one_ptid)); @@ -2418,31 +2901,7 @@ myresume (char *own_buf, int step, int sig) n++; } - if (!non_stop) - enable_async_io (); - - (*the_target->resume) (resume_info, n); - - if (non_stop) - write_ok (own_buf); - else - { - last_ptid = mywait (minus_one_ptid, &last_status, 0, 1); - - if (last_status.kind != TARGET_WAITKIND_EXITED - && last_status.kind != TARGET_WAITKIND_SIGNALLED) - { - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; - } - - prepare_resume_reply (own_buf, last_ptid, &last_status); - disable_async_io (); - - if (last_status.kind == TARGET_WAITKIND_EXITED - || last_status.kind == TARGET_WAITKIND_SIGNALLED) - mourn_inferior (find_process_pid (ptid_get_pid (last_ptid))); - } + resume (resume_info, n); } /* Callback for for_each_inferior. Make a new stop reply for each @@ -2475,10 +2934,9 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) char *status_string = target_waitstatus_to_string (&thread->last_status); - fprintf (stderr, - "Reporting thread %s as already stopped with %s\n", - target_pid_to_str (entry->id), - status_string); + debug_printf ("Reporting thread %s as already stopped with %s\n", + target_pid_to_str (entry->id), + status_string); xfree (status_string); } @@ -2532,6 +2990,48 @@ gdb_reattached_process (struct inferior_list_entry *entry) process->gdb_detached = 0; } +/* Callback for for_each_inferior. Clear the thread's pending status + flag. */ + +static void +clear_pending_status_callback (struct inferior_list_entry *entry) +{ + struct thread_info *thread = (struct thread_info *) entry; + + thread->status_pending_p = 0; +} + +/* Callback for for_each_inferior. If the thread is stopped with an + interesting event, mark it as having a pending event. */ + +static void +set_pending_status_callback (struct inferior_list_entry *entry) +{ + struct thread_info *thread = (struct thread_info *) entry; + + if (thread->last_status.kind != TARGET_WAITKIND_STOPPED + || (thread->last_status.value.sig != GDB_SIGNAL_0 + /* A breakpoint, watchpoint or finished step from a previous + GDB run isn't considered interesting for a new GDB run. + If we left those pending, the new GDB could consider them + random SIGTRAPs. This leaves out real async traps. We'd + have to peek into the (target-specific) siginfo to + distinguish those. */ + && thread->last_status.value.sig != GDB_SIGNAL_TRAP)) + thread->status_pending_p = 1; +} + +/* Callback for find_inferior. Return true if ENTRY (a thread) has a + pending status to report to GDB. */ + +static int +find_status_pending_thread_callback (struct inferior_list_entry *entry, void *data) +{ + struct thread_info *thread = (struct thread_info *) entry; + + return thread->status_pending_p; +} + /* Status handler for the '?' packet. */ static void @@ -2546,7 +3046,6 @@ handle_status (char *own_buf) if (non_stop) { - discard_queued_stop_replies (-1); find_inferior (&all_threads, queue_stop_reply_callback, NULL); /* The first is sent immediatly. OK is sent if there is no @@ -2556,18 +3055,53 @@ handle_status (char *own_buf) } else { + struct inferior_list_entry *thread = NULL; + pause_all (0); stabilize_threads (); gdb_wants_all_threads_stopped (); - if (all_threads.head) + /* We can only report one status, but we might be coming out of + non-stop -- if more than one thread is stopped with + interesting events, leave events for the threads we're not + reporting now pending. They'll be reported the next time the + threads are resumed. Start by marking all interesting events + as pending. */ + for_each_inferior (&all_threads, set_pending_status_callback); + + /* Prefer the last thread that reported an event to GDB (even if + that was a GDB_SIGNAL_TRAP). */ + if (last_status.kind != TARGET_WAITKIND_IGNORE + && last_status.kind != TARGET_WAITKIND_EXITED + && last_status.kind != TARGET_WAITKIND_SIGNALLED) + thread = find_inferior_id (&all_threads, last_ptid); + + /* If the last event thread is not found for some reason, look + for some other thread that might have an event to report. */ + if (thread == NULL) + thread = find_inferior (&all_threads, + find_status_pending_thread_callback, NULL); + + /* If we're still out of luck, simply pick the first thread in + the thread list. */ + if (thread == NULL) + thread = get_first_inferior (&all_threads); + + if (thread != NULL) { - struct target_waitstatus status; + struct thread_info *tp = (struct thread_info *) thread; + + /* We're reporting this event, so it's no longer + pending. */ + tp->status_pending_p = 0; + + /* GDB assumes the current thread is the thread we're + reporting the status for. */ + general_thread = thread->id; + set_desired_thread (1); - status.kind = TARGET_WAITKIND_STOPPED; - status.value.sig = GDB_SIGNAL_TRAP; - prepare_resume_reply (own_buf, - all_threads.head->id, &status); + gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE); + prepare_resume_reply (own_buf, tp->entry.id, &tp->last_status); } else strcpy (own_buf, "W00"); @@ -2578,7 +3112,7 @@ static void gdbserver_version (void) { printf ("GNU gdbserver %s%s\n" - "Copyright (C) 2013 Free Software Foundation, Inc.\n" + "Copyright (C) 2015 Free Software Foundation, Inc.\n" "gdbserver is free software, covered by the " "GNU General Public License.\n" "This gdbserver was configured as \"%s\"\n", @@ -2592,16 +3126,48 @@ gdbserver_usage (FILE *stream) "\tgdbserver [OPTIONS] --attach COMM PID\n" "\tgdbserver [OPTIONS] --multi COMM\n" "\n" - "COMM may either be a tty device (for serial debugging), or \n" - "HOST:PORT to listen for a TCP connection.\n" + "COMM may either be a tty device (for serial debugging),\n" + "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n" + "stdin/stdout of gdbserver.\n" + "PROG is the executable program. ARGS are arguments passed to inferior.\n" + "PID is the process ID to attach to, when --attach is specified.\n" "\n" - "Options:\n" - " --debug Enable general debugging output.\n" - " --remote-debug Enable remote protocol debugging output.\n" + "Operating modes:\n" + "\n" + " --attach Attach to running process PID.\n" + " --multi Start server without a specific program, and\n" + " only quit when explicitly commanded.\n" + " --once Exit after the first connection has closed.\n" + " --help Print this message and then exit.\n" " --version Display version information and exit.\n" + "\n" + "Other options:\n" + "\n" " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n" - " --once Exit after the first connection has " - "closed.\n"); + " --disable-randomization\n" + " Run PROG with address space randomization disabled.\n" + " --no-disable-randomization\n" + " Don't disable address space randomization when\n" + " starting PROG.\n" + "\n" + "Debug options:\n" + "\n" + " --debug Enable general debugging output.\n" + " --debug-format=opt1[,opt2,...]\n" + " Specify extra content in debugging output.\n" + " Options:\n" + " all\n" + " none\n" + " timestamp\n" + " --remote-debug Enable remote protocol debugging output.\n" + " --disable-packet=opt1[,opt2,...]\n" + " Disable support for RSP packets or features.\n" + " Options:\n" + " vCont, Tthread, qC, qfThreadInfo and \n" + " threads (disable all threading packets).\n" + "\n" + "For more information, consult the GDB manual (available as on-line \n" + "info or a printed manual).\n"); if (REPORT_BUGS_TO[0] && stream == stdout) fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO); } @@ -2642,7 +3208,7 @@ static void kill_inferior_callback (struct inferior_list_entry *entry) { struct process_info *process = (struct process_info *) entry; - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); kill_inferior (pid); discard_queued_stop_replies (pid); @@ -2657,7 +3223,7 @@ static void detach_or_kill_inferior_callback (struct inferior_list_entry *entry) { struct process_info *process = (struct process_info *) entry; - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); if (process->attached) detach_inferior (pid); @@ -2677,7 +3243,7 @@ print_started_pid (struct inferior_list_entry *entry) if (! process->attached) { - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); fprintf (stderr, " %d", pid); } } @@ -2692,7 +3258,7 @@ print_attached_pid (struct inferior_list_entry *entry) if (process->attached) { - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); fprintf (stderr, " %d", pid); } } @@ -2726,8 +3292,34 @@ detach_or_kill_for_exit (void) for_each_inferior (&all_processes, detach_or_kill_inferior_callback); } -int -main (int argc, char *argv[]) +/* Value that will be passed to exit(3) when gdbserver exits. */ +static int exit_code; + +/* Cleanup version of detach_or_kill_for_exit. */ + +static void +detach_or_kill_for_exit_cleanup (void *ignore) +{ + + TRY + { + detach_or_kill_for_exit (); + } + + CATCH (exception, RETURN_MASK_ALL) + { + fflush (stdout); + fprintf (stderr, "Detach or kill failed: %s\n", exception.message); + exit_code = 1; + } + END_CATCH +} + +/* Main function. This is called by the real "main" function, + wrapped in a TRY_CATCH that handles any uncaught exceptions. */ + +static void ATTRIBUTE_NORETURN +captured_main (int argc, char *argv[]) { int bad_attach; int pid; @@ -2772,6 +3364,18 @@ main (int argc, char *argv[]) } else if (strcmp (*next_arg, "--debug") == 0) debug_threads = 1; + else if (startswith (*next_arg, "--debug-format=")) + { + char *error_msg + = parse_debug_format_options ((*next_arg) + + sizeof ("--debug-format=") - 1, 0); + + if (error_msg != NULL) + { + fprintf (stderr, "%s", error_msg); + exit (1); + } + } else if (strcmp (*next_arg, "--remote-debug") == 0) remote_debug = 1; else if (strcmp (*next_arg, "--disable-packet") == 0) @@ -2779,9 +3383,7 @@ main (int argc, char *argv[]) gdbserver_show_disableable (stdout); exit (0); } - else if (strncmp (*next_arg, - "--disable-packet=", - sizeof ("--disable-packet=") - 1) == 0) + else if (startswith (*next_arg, "--disable-packet=")) { char *packets, *tok; @@ -2837,12 +3439,6 @@ main (int argc, char *argv[]) continue; } - if (setjmp (toplevel)) - { - fprintf (stderr, "Exiting\n"); - exit (1); - } - port = *next_arg; next_arg++; if (port == NULL || (!attach && !multi_mode && *next_arg == NULL)) @@ -2925,6 +3521,7 @@ main (int argc, char *argv[]) last_status.value.integer = 0; last_ptid = minus_one_ptid; } + make_cleanup (detach_or_kill_for_exit_cleanup, NULL); initialize_notif (); @@ -2933,19 +3530,6 @@ main (int argc, char *argv[]) shared library event" notice on gdb side. */ dlls_changed = 0; - if (setjmp (toplevel)) - { - /* If something fails and longjmps while detaching or killing - inferiors, we'd end up here again, stuck in an infinite loop - trap. Be sure that if that happens, we exit immediately - instead. */ - if (setjmp (toplevel) == 0) - detach_or_kill_for_exit (); - else - fprintf (stderr, "Detach or kill failed. Exiting\n"); - exit (1); - } - if (last_status.kind == TARGET_WAITKIND_EXITED || last_status.kind == TARGET_WAITKIND_SIGNALLED) was_running = 0; @@ -2953,96 +3537,136 @@ main (int argc, char *argv[]) was_running = 1; if (!was_running && !multi_mode) - { - fprintf (stderr, "No program to debug. GDBserver exiting.\n"); - exit (1); - } + error ("No program to debug"); while (1) { + noack_mode = 0; multi_process = 0; + report_fork_events = 0; + report_vfork_events = 0; /* Be sure we're out of tfind mode. */ current_traceframe = -1; + cont_thread = null_ptid; + swbreak_feature = 0; + hwbreak_feature = 0; remote_open (port); - if (setjmp (toplevel) != 0) + TRY + { + /* Wait for events. This will return when all event sources + are removed from the event loop. */ + start_event_loop (); + + /* If an exit was requested (using the "monitor exit" + command), terminate now. The only other way to get + here is for getpkt to fail; close the connection + and reopen it at the top of the loop. */ + + if (exit_requested || run_once) + throw_quit ("Quit"); + + fprintf (stderr, + "Remote side has terminated connection. " + "GDBserver will reopen the connection.\n"); + + /* Get rid of any pending statuses. An eventual reconnection + (by the same GDB instance or another) will refresh all its + state from scratch. */ + discard_queued_stop_replies (-1); + for_each_inferior (&all_threads, + clear_pending_status_callback); + + if (tracing) + { + if (disconnected_tracing) + { + /* Try to enable non-stop/async mode, so we we can + both wait for an async socket accept, and handle + async target events simultaneously. There's also + no point either in having the target always stop + all threads, when we're going to pass signals + down without informing GDB. */ + if (!non_stop) + { + if (start_non_stop (1)) + non_stop = 1; + + /* Detaching implicitly resumes all threads; + simply disconnecting does not. */ + } + } + else + { + fprintf (stderr, + "Disconnected tracing disabled; " + "stopping trace run.\n"); + stop_tracing (); + } + } + } + CATCH (exception, RETURN_MASK_ERROR) { - /* An error occurred. */ + fflush (stdout); + fprintf (stderr, "gdbserver: %s\n", exception.message); + if (response_needed) { write_enn (own_buf); putpkt (own_buf); } + + if (run_once) + throw_quit ("Quit"); } + END_CATCH + } +} - /* Wait for events. This will return when all event sources are - removed from the event loop. */ - start_event_loop (); +/* Main function. */ - /* If an exit was requested (using the "monitor exit" command), - terminate now. The only other way to get here is for - getpkt to fail; close the connection and reopen it at the - top of the loop. */ +int +main (int argc, char *argv[]) +{ - if (exit_requested || run_once) + TRY + { + captured_main (argc, argv); + } + CATCH (exception, RETURN_MASK_ALL) + { + if (exception.reason == RETURN_ERROR) { - /* If something fails and longjmps while detaching or - killing inferiors, we'd end up here again, stuck in an - infinite loop trap. Be sure that if that happens, we - exit immediately instead. */ - if (setjmp (toplevel) == 0) - { - detach_or_kill_for_exit (); - exit (0); - } - else - { - fprintf (stderr, "Detach or kill failed. Exiting\n"); - exit (1); - } + fflush (stdout); + fprintf (stderr, "%s\n", exception.message); + fprintf (stderr, "Exiting\n"); + exit_code = 1; } - fprintf (stderr, - "Remote side has terminated connection. " - "GDBserver will reopen the connection.\n"); + exit (exit_code); + } + END_CATCH - if (tracing) - { - if (disconnected_tracing) - { - /* Try to enable non-stop/async mode, so we we can both - wait for an async socket accept, and handle async - target events simultaneously. There's also no point - either in having the target always stop all threads, - when we're going to pass signals down without - informing GDB. */ - if (!non_stop) - { - if (start_non_stop (1)) - non_stop = 1; + gdb_assert_not_reached ("captured_main should never return"); +} - /* Detaching implicitly resumes all threads; simply - disconnecting does not. */ - } - } - else - { - fprintf (stderr, - "Disconnected tracing disabled; stopping trace run.\n"); - stop_tracing (); - } - } - } +/* Skip PACKET until the next semi-colon (or end of string). */ + +static void +skip_to_semicolon (char **packet) +{ + while (**packet != '\0' && **packet != ';') + (*packet)++; } -/* Process options coming from Z packets for *point at address - POINT_ADDR. PACKET is the packet buffer. *PACKET is updated - to point to the first char after the last processed option. */ +/* Process options coming from Z packets for a breakpoint. PACKET is + the packet buffer. *PACKET is updated to point to the first char + after the last processed option. */ static void -process_point_options (CORE_ADDR point_addr, char **packet) +process_point_options (struct breakpoint *bp, char **packet) { char *dataptr = *packet; int persist; @@ -3062,25 +3686,26 @@ process_point_options (CORE_ADDR point_addr, char **packet) { /* Conditional expression. */ if (debug_threads) - fprintf (stderr, "Found breakpoint condition.\n"); - add_breakpoint_condition (point_addr, &dataptr); + debug_printf ("Found breakpoint condition.\n"); + if (!add_breakpoint_condition (bp, &dataptr)) + skip_to_semicolon (&dataptr); } - else if (strncmp (dataptr, "cmds:", strlen ("cmds:")) == 0) + else if (startswith (dataptr, "cmds:")) { dataptr += strlen ("cmds:"); if (debug_threads) - fprintf (stderr, "Found breakpoint commands %s.\n", dataptr); + debug_printf ("Found breakpoint commands %s.\n", dataptr); persist = (*dataptr == '1'); dataptr += 2; - add_breakpoint_commands (point_addr, &dataptr, persist); + if (add_breakpoint_commands (bp, &dataptr, persist)) + skip_to_semicolon (&dataptr); } else { fprintf (stderr, "Unknown token %c, ignoring.\n", *dataptr); /* Skip tokens until we find one that we recognize. */ - while (*dataptr && *dataptr != ';') - dataptr++; + skip_to_semicolon (&dataptr); } } *packet = dataptr; @@ -3174,7 +3799,7 @@ process_serial_event (void) if (!non_stop) { if (debug_threads) - fprintf (stderr, "Forcing non-stop mode\n"); + debug_printf ("Forcing non-stop mode\n"); non_stop = 1; start_non_stop (1); @@ -3208,7 +3833,7 @@ process_serial_event (void) last_status.value.integer = 0; last_ptid = pid_to_ptid (pid); - current_inferior = NULL; + current_thread = NULL; } else { @@ -3259,7 +3884,7 @@ process_serial_event (void) break; } - thread_id = ((struct inferior_list_entry *)thread)->id; + thread_id = thread->entry.id; } else { @@ -3282,11 +3907,13 @@ process_serial_event (void) (struct thread_info *) find_inferior_id (&all_threads, general_thread); if (thread == NULL) - thread_id = all_threads.head->id; + thread = get_first_thread (); + thread_id = thread->entry.id; } general_thread = thread_id; - set_desired_inferior (1); + set_desired_thread (1); + gdb_assert (current_thread != NULL); } else if (own_buf[1] == 'c') cont_thread = thread_id; @@ -3318,9 +3945,13 @@ process_serial_event (void) { struct regcache *regcache; - set_desired_inferior (1); - regcache = get_thread_regcache (current_inferior, 1); - registers_to_string (regcache, own_buf); + if (!set_desired_thread (1)) + write_enn (own_buf); + else + { + regcache = get_thread_regcache (current_thread, 1); + registers_to_string (regcache, own_buf); + } } break; case 'G': @@ -3331,10 +3962,14 @@ process_serial_event (void) { struct regcache *regcache; - set_desired_inferior (1); - regcache = get_thread_regcache (current_inferior, 1); - registers_from_string (regcache, &own_buf[1]); - write_ok (own_buf); + if (!set_desired_thread (1)) + write_enn (own_buf); + else + { + regcache = get_thread_regcache (current_thread, 1); + registers_from_string (regcache, &own_buf[1]); + write_ok (own_buf); + } } break; case 'm': @@ -3344,7 +3979,7 @@ process_serial_event (void) if (res < 0) write_enn (own_buf); else - convert_int_to_ascii (mem_buf, own_buf, res); + bin2hex (mem_buf, own_buf, res); break; case 'M': require_running (own_buf); @@ -3365,7 +4000,7 @@ process_serial_event (void) break; case 'C': require_running (own_buf); - convert_ascii_to_int (own_buf + 1, &sig, 1); + hex2bin (own_buf + 1, &sig, 1); if (gdb_signal_to_host_p (sig)) signal = gdb_signal_to_host (sig); else @@ -3374,7 +4009,7 @@ process_serial_event (void) break; case 'S': require_running (own_buf); - convert_ascii_to_int (own_buf + 1, &sig, 1); + hex2bin (own_buf + 1, &sig, 1); if (gdb_signal_to_host_p (sig)) signal = gdb_signal_to_host (sig); else @@ -3406,39 +4041,26 @@ process_serial_event (void) p = unpack_varlen_hex (p, &addr); len = strtol (p + 1, &dataptr, 16); - /* Default to unrecognized/unsupported. */ - res = 1; - switch (type) + if (insert) { - case '0': /* software-breakpoint */ - case '1': /* hardware-breakpoint */ - case '2': /* write watchpoint */ - case '3': /* read watchpoint */ - case '4': /* access watchpoint */ - require_running (own_buf); - if (insert && the_target->insert_point != NULL) + struct breakpoint *bp; + + bp = set_gdb_breakpoint (type, addr, len, &res); + if (bp != NULL) { - /* Insert the breakpoint. If it is already inserted, nothing - will take place. */ - res = (*the_target->insert_point) (type, addr, len); - - /* GDB may have sent us a list of *point parameters to be - evaluated on the target's side. Read such list here. If we - already have a list of parameters, GDB is telling us to drop - that list and use this one instead. */ - if (!res && (type == '0' || type == '1')) - { - /* Remove previous conditions. */ - clear_gdb_breakpoint_conditions (addr); - process_point_options (addr, &dataptr); - } + res = 0; + + /* GDB may have sent us a list of *point parameters to + be evaluated on the target's side. Read such list + here. If we already have a list of parameters, GDB + is telling us to drop that list and use this one + instead. */ + clear_breakpoint_conditions_and_commands (bp); + process_point_options (bp, &dataptr); } - else if (!insert && the_target->remove_point != NULL) - res = (*the_target->remove_point) (type, addr, len); - break; - default: - break; } + else + res = delete_gdb_breakpoint (type, addr, len); if (res == 0) write_ok (own_buf); @@ -3504,7 +4126,20 @@ process_serial_event (void) /* Wait till we are at 1st instruction in prog. */ if (program_argv != NULL) - start_inferior (program_argv); + { + start_inferior (program_argv); + if (last_status.kind == TARGET_WAITKIND_STOPPED) + { + /* Stopped at the first instruction of the target + process. */ + general_thread = last_ptid; + } + else + { + /* Something went wrong. */ + general_thread = null_ptid; + } + } else { last_status.kind = TARGET_WAITKIND_EXITED; @@ -3546,7 +4181,10 @@ process_serial_event (void) the whole vStopped list (until it gets an OK). */ if (QUEUE_is_empty (notif_event_p, notif_stop.queue)) { - fprintf (stderr, "GDBserver exiting\n"); + /* Be transparent when GDB is connected through stdio -- no + need to spam GDB's console. */ + if (!remote_connection_is_stdio ()) + fprintf (stderr, "GDBserver exiting\n"); remote_close (); exit (0); } @@ -3564,15 +4202,15 @@ int handle_serial_event (int err, gdb_client_data client_data) { if (debug_threads) - fprintf (stderr, "handling possible serial event\n"); + debug_printf ("handling possible serial event\n"); /* Really handle it. */ if (process_serial_event () < 0) return -1; - /* Be sure to not change the selected inferior behind GDB's back. + /* Be sure to not change the selected thread behind GDB's back. Important in the non-stop mode asynchronous protocol. */ - set_desired_inferior (1); + set_desired_thread (1); return 0; } @@ -3583,12 +4221,16 @@ int handle_target_event (int err, gdb_client_data client_data) { if (debug_threads) - fprintf (stderr, "handling possible target event\n"); + debug_printf ("handling possible target event\n"); last_ptid = mywait (minus_one_ptid, &last_status, TARGET_WNOHANG, 1); - if (last_status.kind != TARGET_WAITKIND_IGNORE) + if (last_status.kind == TARGET_WAITKIND_NO_RESUMED) + { + /* No RSP support for this yet. */ + } + else if (last_status.kind != TARGET_WAITKIND_IGNORE) { int pid = ptid_get_pid (last_ptid); struct process_info *process = find_process_pid (pid); @@ -3605,8 +4247,8 @@ handle_target_event (int err, gdb_client_data client_data) /* We're reporting this thread as stopped. Update its "want-stopped" state to what the client wants, until it gets a new resume action. */ - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; } if (forward_event) @@ -3625,10 +4267,10 @@ handle_target_event (int err, gdb_client_data client_data) struct thread_resume resume_info; if (debug_threads) - fprintf (stderr, - "GDB not connected; forwarding event %d for [%s]\n", - (int) last_status.kind, - target_pid_to_str (last_ptid)); + debug_printf ("GDB not connected; forwarding event %d for" + " [%s]\n", + (int) last_status.kind, + target_pid_to_str (last_ptid)); resume_info.thread = last_ptid; resume_info.kind = resume_continue; @@ -3636,9 +4278,9 @@ handle_target_event (int err, gdb_client_data client_data) (*the_target->resume) (&resume_info, 1); } else if (debug_threads) - fprintf (stderr, "GDB not connected; ignoring event %d for [%s]\n", - (int) last_status.kind, - target_pid_to_str (last_ptid)); + debug_printf ("GDB not connected; ignoring event %d for [%s]\n", + (int) last_status.kind, + target_pid_to_str (last_ptid)); } else { @@ -3653,9 +4295,9 @@ handle_target_event (int err, gdb_client_data client_data) } } - /* Be sure to not change the selected inferior behind GDB's back. + /* Be sure to not change the selected thread behind GDB's back. Important in the non-stop mode asynchronous protocol. */ - set_desired_inferior (1); + set_desired_thread (1); return 0; }