X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Fserver.c;h=29187704c1972e021b1fceb77d01ee5b659c2ae1;hb=c06cbd92be66d82eb323a8c6ec451c1dccc02107;hp=0f963e8bb144026c7c277de19d1f6b6b96633d4c;hpb=1e4d17643d49f247df304245675551ee71995a37;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 0f963e8bb1..29187704c1 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -1,7 +1,5 @@ /* Main code for remote server for GDB. - Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, - 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 1989-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -19,18 +17,34 @@ along with this program. If not, see . */ #include "server.h" +#include "gdbthread.h" +#include "agent.h" +#include "notif.h" +#include "tdesc.h" +#include "rsp-low.h" -#if HAVE_UNISTD_H +#include #include -#endif #if HAVE_SIGNAL_H #include #endif -#if HAVE_SYS_WAIT_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. */ ptid_t cont_thread; + +/* The thread set with an `Hg' packet. */ ptid_t general_thread; int server_waiting; @@ -43,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. */ @@ -51,18 +69,9 @@ 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[TARGET_SIGNAL_LAST]; - -jmp_buf toplevel; - -const char *gdbserver_xmltarget; +int pass_signals[GDB_SIGNAL_LAST]; +int program_signals[GDB_SIGNAL_LAST]; +int program_signals_p; /* The PID of the originally created or attached inferior. Used to send signals to the process when GDB sends us an asynchronous interrupt @@ -102,13 +111,13 @@ static ptid_t last_ptid; static char *own_buf; static unsigned char *mem_buf; -/* Structure holding information relative to a single stop reply. We - keep a queue of these (really a singly-linked list) to push to GDB - in non-stop mode. */ +/* A sub-class of 'struct notif_event' for stop, holding information + relative to a single stop reply. We keep a queue of these to + push to GDB in non-stop mode. */ + struct vstop_notif { - /* Pointer to next in list. */ - struct vstop_notif *next; + struct notif_event base; /* Thread or process that got the event. */ ptid_t ptid; @@ -117,66 +126,43 @@ struct vstop_notif struct target_waitstatus status; }; -/* The pending stop replies list head. */ -static struct vstop_notif *notif_queue = NULL; +/* 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. */ static void queue_stop_reply (ptid_t ptid, struct target_waitstatus *status) { - struct vstop_notif *new_notif; + struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif)); - new_notif = xmalloc (sizeof (*new_notif)); - new_notif->next = NULL; new_notif->ptid = ptid; new_notif->status = *status; - if (notif_queue) - { - struct vstop_notif *tail; - for (tail = notif_queue; - tail && tail->next; - tail = tail->next) - ; - tail->next = new_notif; - } - else - notif_queue = new_notif; - - if (remote_debug) - { - int i = 0; - struct vstop_notif *n; - - for (n = notif_queue; n; n = n->next) - i++; - - fprintf (stderr, "pending stop replies: %d\n", i); - } + notif_event_enque (¬if_stop, (struct notif_event *) new_notif); } -/* Place an event in the stop reply queue, and push a notification if - we aren't sending one yet. */ - -void -push_event (ptid_t ptid, struct target_waitstatus *status) +static int +remove_all_on_match_pid (QUEUE (notif_event_p) *q, + QUEUE_ITER (notif_event_p) *iter, + struct notif_event *event, + void *data) { - gdb_assert (status->kind != TARGET_WAITKIND_IGNORE); + int *pid = data; - queue_stop_reply (ptid, status); - - /* If this is the first stop reply in the queue, then inform GDB - about it, by sending a Stop notification. */ - if (notif_queue->next == NULL) + if (*pid == -1 + || ptid_get_pid (((struct vstop_notif *) event)->ptid) == *pid) { - char *p = own_buf; - strcpy (p, "Stop:"); - p += strlen (p); - prepare_resume_reply (p, - notif_queue->ptid, ¬if_queue->status); - putpkt_notif (own_buf); + if (q->free_func != NULL) + q->free_func (event); + + QUEUE_remove_elem (notif_event_p, q, iter); } + + return 1; } /* Get rid of the currently pending stop replies for PID. If PID is @@ -185,44 +171,27 @@ push_event (ptid_t ptid, struct target_waitstatus *status) static void discard_queued_stop_replies (int pid) { - struct vstop_notif *prev = NULL, *reply, *next; - - for (reply = notif_queue; reply; reply = next) - { - next = reply->next; - - if (pid == -1 - || ptid_get_pid (reply->ptid) == pid) - { - if (reply == notif_queue) - notif_queue = next; - else - prev->next = reply->next; - - free (reply); - } - else - prev = reply; - } + QUEUE_iterate (notif_event_p, notif_stop.queue, + remove_all_on_match_pid, &pid); } -/* If there are more stop replies to push, push one now. */ - static void -send_next_stop_reply (char *own_buf) +vstop_notif_reply (struct notif_event *event, char *own_buf) { - if (notif_queue) - prepare_resume_reply (own_buf, - notif_queue->ptid, - ¬if_queue->status); - else - write_ok (own_buf); + struct vstop_notif *vstop = (struct vstop_notif *) event; + + prepare_resume_reply (own_buf, vstop->ptid, &vstop->status); } +struct notif_server notif_stop = +{ + "vStopped", "Stop", NULL, vstop_notif_reply, +}; + static int target_running (void) { - return all_threads.head != NULL; + return get_first_thread () != NULL; } static int @@ -251,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 @@ -281,30 +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; - mywait (pid_to_ptid (signal_pid), &last_status, 0, 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); - 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 != TARGET_SIGNAL_TRAP); - - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + target_arch_setup (); return signal_pid; } @@ -312,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; } @@ -347,11 +319,11 @@ attach_inferior (int pid) process using the "attach" command, but this is different; it's just using "target remote". Pretend it's just starting up. */ if (last_status.kind == TARGET_WAITKIND_STOPPED - && last_status.value.sig == TARGET_SIGNAL_STOP) - last_status.value.sig = TARGET_SIGNAL_TRAP; + && 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; @@ -417,8 +389,172 @@ 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 in BTS format. */ + +static const char * +handle_btrace_enable_bts (struct thread_info *thread) +{ + if (thread->btrace != NULL) + return "E.Btrace already enabled."; + + 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."; + + return NULL; +} + +/* Handle btrace disabling. */ + +static const char * +handle_btrace_disable (struct thread_info *thread) +{ + + if (thread->btrace == NULL) + return "E.Branch tracing not enabled."; + + if (target_disable_btrace (thread->btrace) != 0) + return "E.Could not disable branch tracing."; + + thread->btrace = NULL; + return NULL; +} + +/* Handle the "Qbtrace" packet. */ + +static int +handle_btrace_general_set (char *own_buf) +{ + struct thread_info *thread; + const char *err; + char *op; + + if (!startswith (own_buf, "Qbtrace:")) + return 0; + + op = own_buf + strlen ("Qbtrace:"); + + 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; + } + + err = NULL; + + if (strcmp (op, "bts") == 0) + 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, pt, or off."; + + if (err != 0) + strcpy (own_buf, err); + else + write_ok (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. */ @@ -426,9 +562,9 @@ write_qxfer_response (char *buf, const void *data, int len, int is_more) static void handle_general_set (char *own_buf) { - if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0) + if (startswith (own_buf, "QPassSignals:")) { - int numsigs = (int) TARGET_SIGNAL_LAST, i; + int numsigs = (int) GDB_SIGNAL_LAST, i; const char *p = own_buf + strlen ("QPassSignals:"); CORE_ADDR cursig; @@ -451,6 +587,33 @@ handle_general_set (char *own_buf) return; } + if (startswith (own_buf, "QProgramSignals:")) + { + int numsigs = (int) GDB_SIGNAL_LAST, i; + const char *p = own_buf + strlen ("QProgramSignals:"); + CORE_ADDR cursig; + + program_signals_p = 1; + + p = decode_address_to_semicolon (&cursig, p); + for (i = 0; i < numsigs; i++) + { + if (i == cursig) + { + program_signals[i] = 1; + if (*p == '\0') + /* Keep looping, to clear the remaining signals. */ + cursig = -1; + else + p = decode_address_to_semicolon (&cursig, p); + } + else + program_signals[i] = 0; + } + strcpy (own_buf, "OK"); + return; + } + if (strcmp (own_buf, "QStartNoAckMode") == 0) { if (remote_debug) @@ -464,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; @@ -501,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; @@ -526,6 +688,36 @@ handle_general_set (char *own_buf) && handle_tracepoint_general_set (own_buf)) return; + if (startswith (own_buf, "QAgent:")) + { + char *mode = own_buf + strlen ("QAgent:"); + int req = 0; + + if (strcmp (mode, "0") == 0) + req = 0; + else if (strcmp (mode, "1") == 0) + req = 1; + else + { + /* We don't know what this value is, so complain to GDB. */ + sprintf (own_buf, "E.Unknown QAgent value"); + return; + } + + /* Update the flag. */ + use_agent = req; + if (remote_debug) + fprintf (stderr, "[%s agent]\n", req ? "Enable" : "Disable"); + write_ok (own_buf); + return; + } + + 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; @@ -534,21 +726,22 @@ handle_general_set (char *own_buf) static const char * get_features_xml (const char *annex) { - /* gdbserver_xmltarget defines what to return when looking - for the "target.xml" file. Its contents can either be - verbatim XML code (prefixed with a '@') or else the name - of the actual XML file to be used in place of "target.xml". + const struct target_desc *desc = current_target_desc (); + + /* `desc->xmltarget' defines what to return when looking for the + "target.xml" file. Its contents can either be verbatim XML code + (prefixed with a '@') or else the name of the actual XML file to + be used in place of "target.xml". This variable is set up from the auto-generated init_registers_... routine for the current target. */ - if (gdbserver_xmltarget - && strcmp (annex, "target.xml") == 0) + if (desc->xmltarget != NULL && strcmp (annex, "target.xml") == 0) { - if (*gdbserver_xmltarget == '@') - return gdbserver_xmltarget + 1; + if (*desc->xmltarget == '@') + return desc->xmltarget + 1; else - annex = gdbserver_xmltarget; + annex = desc->xmltarget; } #ifdef USE_XML @@ -579,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"); } @@ -605,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; @@ -663,8 +861,9 @@ handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len, if (gdb_read_memory (start_addr, search_buf, search_buf_size) != search_buf_size) { - warning ("Unable to access target memory at 0x%lx, halting search.", - (long) start_addr); + warning ("Unable to access %ld bytes of target " + "memory at 0x%lx, halting search.", + (long) search_buf_size, (long) start_addr); return -1; } @@ -715,9 +914,9 @@ handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len, if (gdb_read_memory (read_addr, search_buf + keep_len, nr_to_read) != search_buf_size) { - warning ("Unable to access target memory " + warning ("Unable to access %ld bytes of target memory " "at 0x%lx, halting search.", - (long) read_addr); + (long) nr_to_read, (long) read_addr); return -1; } @@ -805,10 +1004,82 @@ 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 -handle_monitor_command (char *mon) +handle_monitor_command (char *mon, char *own_buf) { if (strcmp (mon, "set debug 1") == 0) { @@ -822,12 +1093,12 @@ handle_monitor_command (char *mon) } 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) @@ -840,6 +1111,20 @@ handle_monitor_command (char *mon) 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) @@ -865,10 +1150,10 @@ struct qxfer data-specific information to the target. Return the number of bytes actually transfered, zero when no - further transfer is possible, -1 on error, and -2 when the - transfer is not supported. Return of a positive value smaller - than LEN does not indicate the end of the object, only the end of - the transfer. + further transfer is possible, -1 on error, -2 when the transfer + is not supported, and -3 on a verbose error message that should + be preserved. Return of a positive value smaller than LEN does + not indicate the end of the object, only the end of the transfer. One, and only one, of readbuf or writebuf must be non-NULL. */ int (*xfer) (const char *annex, @@ -892,6 +1177,57 @@ handle_qxfer_auxv (const char *annex, 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 @@ -925,6 +1261,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 @@ -934,7 +1312,6 @@ handle_qxfer_libraries (const char *annex, { unsigned int total_len; char *document, *p; - struct inferior_list_entry *dll_ptr; if (writebuf != NULL) return -2; @@ -942,37 +1319,18 @@ handle_qxfer_libraries (const char *annex, if (annex[0] != '\0' || !target_running ()) 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"); @@ -992,6 +1350,22 @@ handle_qxfer_libraries (const char *annex, return len; } +/* Handle qXfer:libraries-svr4:read. */ + +static int +handle_qxfer_libraries_svr4 (const char *annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) +{ + if (writebuf != NULL) + return -2; + + if (!target_running () || the_target->qxfer_libraries_svr4 == NULL) + return -1; + + return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len); +} + /* Handle qXfer:osadata:read. */ static int @@ -1058,39 +1432,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) { - ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread); - char ptid_s[100]; - int core = -1; - char core_s[21]; + sprintf (core_s, "%d", core); + buffer_xml_printf (buffer, "\n", + ptid_s, core_s); + } + else + { + buffer_xml_printf (buffer, "\n", + ptid_s); + } +} - write_ptid (ptid_s, ptid); +/* Helper for handle_qxfer_threads. */ - if (the_target->core_of_thread) - core = (*the_target->core_of_thread) (ptid); +static void +handle_qxfer_threads_proper (struct buffer *buffer) +{ + buffer_grow_str (buffer, "\n"); - 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); - } - } + for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker, + buffer); buffer_grow_str0 (buffer, "\n"); } @@ -1210,12 +1588,152 @@ handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf, return (*the_target->read_loadmap) (annex, offset, readbuf, len); } +/* Handle qXfer:btrace:read. */ + +static int +handle_qxfer_btrace (const char *annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) +{ + static struct buffer cache; + struct thread_info *thread; + 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)) + { + 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 (strcmp (annex, "all") == 0) + type = BTRACE_READ_ALL; + else if (strcmp (annex, "new") == 0) + type = BTRACE_READ_NEW; + else if (strcmp (annex, "delta") == 0) + type = BTRACE_READ_DELTA; + else + { + strcpy (own_buf, "E.Bad annex."); + return -3; + } + + if (offset == 0) + { + buffer_free (&cache); + + 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' || !target_running ()) + 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) + { + buffer_free (&cache); + return -3; + } + + if (len > cache.used_size - offset) + len = cache.used_size - offset; + + memcpy (readbuf, cache.buffer + offset, len); + + return len; +} + 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 }, + { "libraries-svr4", handle_qxfer_libraries_svr4 }, { "osdata", handle_qxfer_osdata }, { "siginfo", handle_qxfer_siginfo }, { "spu", handle_qxfer_spu }, @@ -1233,7 +1751,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. */ @@ -1281,6 +1799,10 @@ handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) free (data); return 0; } + else if (n == -3) + { + /* Preserve error message. */ + } else if (n < 0) write_enn (own_buf); else if (n > len) @@ -1319,6 +1841,10 @@ handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) free (data); return 0; } + else if (n == -3) + { + /* Preserve error message. */ + } else if (n < 0) write_enn (own_buf); else @@ -1376,6 +1902,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 @@ -1394,7 +1951,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); } @@ -1435,7 +1992,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); @@ -1481,7 +2038,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]; @@ -1525,6 +2082,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); @@ -1534,11 +2118,19 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) free (qsupported); } - sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1); + sprintf (own_buf, + "PacketSize=%x;QPassSignals+;QProgramSignals+", + PBUFSIZ - 1); - /* We do not have any hook to indicate whether the target backend - supports qXfer:libraries:read, so always report it. */ - strcat (own_buf, ";qXfer:libraries:read+"); + if (the_target->qxfer_libraries_svr4 != NULL) + strcat (own_buf, ";qXfer:libraries-svr4:read+" + ";augmented-libraries-svr4-read+"); + else + { + /* We do not have any hook to indicate whether the non-SVR4 target + backend supports qXfer:libraries:read, so always report it. */ + strcat (own_buf, ";qXfer:libraries:read+"); + } if (the_target->read_auxv != NULL) strcat (own_buf, ";qXfer:auxv:read+"); @@ -1567,6 +2159,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+"); @@ -1588,15 +2186,39 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) strcat (own_buf, ";qXfer:statictrace:read+"); strcat (own_buf, ";qXfer:traceframe-info:read+"); strcat (own_buf, ";EnableDisableTracepoints+"); + strcat (own_buf, ";QTBuffer:size+"); strcat (own_buf, ";tracenz+"); } + /* Support target-side breakpoint conditions and commands. */ + if (target_supports_conditional_breakpoints ()) + strcat (own_buf, ";ConditionalBreakpoints+"); + strcat (own_buf, ";BreakpointCommands+"); + + if (target_supports_agent ()) + strcat (own_buf, ";QAgent+"); + + 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; @@ -1661,7 +2283,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; @@ -1683,7 +2305,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); @@ -1694,7 +2316,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); @@ -1707,14 +2330,13 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (the_target->handle_monitor_command == NULL || (*the_target->handle_monitor_command) (mon) == 0) /* Default processing. */ - handle_monitor_command (mon); + handle_monitor_command (mon, own_buf); free (mon); 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); @@ -1722,7 +2344,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; @@ -1748,16 +2370,16 @@ 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; - CORE_ADDR base; + ULONGEST base; int len; unsigned long long crc; require_running (own_buf); - base = strtoul (own_buf + 5, &comma, 16); + comma = unpack_varlen_hex (own_buf + 5, &base); if (*comma++ != ',') { write_enn (own_buf); @@ -1768,25 +2390,92 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) /* Check for memory failure. */ if (crc == (unsigned long long) -1) { - write_enn (own_buf); - return; + write_enn (own_buf); + return; + } + sprintf (own_buf, "C%lx", (unsigned long) crc); + return; + } + + if (handle_qxfer (own_buf, packet_len, new_packet_len_p)) + return; + + if (target_supports_tracepoints () && handle_tracepoint_query (own_buf)) + return; + + /* Otherwise we didn't know what packet it was. Say we didn't + understand it. */ + own_buf[0] = 0; +} + +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; } - sprintf (own_buf, "C%lx", (unsigned long) crc); - return; } - if (handle_qxfer (own_buf, packet_len, new_packet_len_p)) - return; + return 0; +} - if (target_supports_tracepoints () && handle_tracepoint_query (own_buf)) - return; +/* Callback for visit_actioned_threads. If the thread has a pending + status to report, report it now. */ - /* Otherwise we didn't know what packet it was. Say we didn't - understand it. */ - own_buf[0] = 0; -} +static int +handle_pending_status (const struct thread_resume *resumption, + struct thread_info *thread) +{ + if (thread->status_pending_p) + { + thread->status_pending_p = 0; -static void gdb_wants_all_threads_stopped (void); + 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 @@ -1816,8 +2505,12 @@ handle_v_cont (char *own_buf) { p++; + memset (&resume_info[i], 0, sizeof resume_info[i]); + if (p[0] == 's' || p[0] == 'S') resume_info[i].kind = resume_step; + else if (p[0] == 'r') + resume_info[i].kind = resume_step; else if (p[0] == 'c' || p[0] == 'C') resume_info[i].kind = resume_continue; else if (p[0] == 't') @@ -1833,13 +2526,25 @@ handle_v_cont (char *own_buf) goto err; p = q; - if (!target_signal_to_host_p (sig)) + if (!gdb_signal_to_host_p (sig)) + goto err; + resume_info[i].sig = gdb_signal_to_host (sig); + } + else if (p[0] == 'r') + { + ULONGEST addr; + + p = unpack_varlen_hex (p + 1, &addr); + resume_info[i].step_range_start = addr; + + if (*p != ',') goto err; - resume_info[i].sig = target_signal_to_host (sig); + + p = unpack_varlen_hex (p + 1, &addr); + resume_info[i].step_range_end = addr; } else { - resume_info[i].sig = 0; p = p + 1; } @@ -1870,21 +2575,41 @@ handle_v_cont (char *own_buf) if (i < n) resume_info[i] = default_action; - /* Still used in occasional places in the backend. */ - if (n == 1 - && !ptid_equal (resume_info[0].thread, minus_one_ptid) - && resume_info[0].kind != resume_stop) - cont_thread = resume_info[0].thread; - else - cont_thread = minus_one_ptid; - set_desired_inferior (0); - - if (!non_stop) - enable_async_io (); + set_desired_thread (0); - (*the_target->resume) (resume_info, n); + resume (resume_info, n); + free (resume_info); + return; +err: + write_enn (own_buf); free (resume_info); + return; +} + +/* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */ + +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); @@ -1892,9 +2617,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 @@ -1908,12 +2643,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. */ @@ -1984,7 +2713,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'; } @@ -2052,7 +2781,7 @@ handle_v_kill (char *own_buf) if (pid != 0 && kill_inferior (pid) == 0) { last_status.kind = TARGET_WAITKIND_SIGNALLED; - last_status.value.sig = TARGET_SIGNAL_KILL; + last_status.value.sig = GDB_SIGNAL_KILL; last_ptid = pid_to_ptid (pid); discard_queued_stop_replies (pid); write_ok (own_buf); @@ -2065,56 +2794,38 @@ handle_v_kill (char *own_buf) } } -/* Handle a 'vStopped' packet. */ -static void -handle_v_stopped (char *own_buf) -{ - /* If we're waiting for GDB to acknowledge a pending stop reply, - consider that done. */ - if (notif_queue) - { - struct vstop_notif *head; - - if (remote_debug) - fprintf (stderr, "vStopped: acking %s\n", - target_pid_to_str (notif_queue->ptid)); - - head = notif_queue; - notif_queue = notif_queue->next; - free (head); - } - - /* Push another stop reply, or if there are no more left, an OK. */ - send_next_stop_reply (own_buf); -} - /* Handle all of the extended 'v' packets. */ void 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 ()) + { + own_buf = own_buf + strlen (own_buf); + strcpy (own_buf, ";r"); + } return; } } - 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 (!multi_process && target_running ()) + if ((!extended_protocol || !multi_process) && target_running ()) { fprintf (stderr, "Already debugging a process\n"); write_enn (own_buf); @@ -2124,9 +2835,9 @@ 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 (!multi_process && target_running ()) + if ((!extended_protocol || !multi_process) && target_running ()) { fprintf (stderr, "Already debugging a process\n"); write_enn (own_buf); @@ -2136,7 +2847,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 ()) { @@ -2148,11 +2859,8 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) return; } - if (strncmp (own_buf, "vStopped", 8) == 0) - { - handle_v_stopped (own_buf); - return; - } + if (handle_notif_ack (own_buf, packet_len)) + return; /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ @@ -2160,7 +2868,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 @@ -2170,15 +2878,14 @@ myresume (char *own_buf, int step, int sig) int n = 0; int valid_cont_thread; - set_desired_inferior (0); + set_desired_thread (0); valid_cont_thread = (!ptid_equal (cont_thread, null_ptid) && !ptid_equal (cont_thread, minus_one_ptid)); if (step || sig || valid_cont_thread) { - resume_info[0].thread - = ((struct inferior_list_entry *) current_inferior)->id; + resume_info[0].thread = current_ptid; if (step) resume_info[0].kind = resume_step; else @@ -2195,31 +2902,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 @@ -2234,19 +2917,30 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) manage the thread's last_status field. */ if (the_target->thread_stopped == NULL) { + struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif)); + + new_notif->ptid = entry->id; + new_notif->status = thread->last_status; /* Pass the last stop reply back to GDB, but don't notify yet. */ - queue_stop_reply (entry->id, &thread->last_status); + notif_event_enque (¬if_stop, + (struct notif_event *) new_notif); } else { if (thread_stopped (thread)) { if (debug_threads) - fprintf (stderr, - "Reporting thread %s as already stopped with %s\n", - target_pid_to_str (entry->id), - target_waitstatus_to_string (&thread->last_status)); + { + char *status_string + = target_waitstatus_to_string (&thread->last_status); + + debug_printf ("Reporting thread %s as already stopped with %s\n", + target_pid_to_str (entry->id), + status_string); + + xfree (status_string); + } gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE); @@ -2275,7 +2969,7 @@ gdb_wants_thread_stopped (struct inferior_list_entry *entry) /* Most threads are stopped implicitly (all-stop); tag that with signal 0. */ thread->last_status.kind = TARGET_WAITKIND_STOPPED; - thread->last_status.value.sig = TARGET_SIGNAL_0; + thread->last_status.value.sig = GDB_SIGNAL_0; } } @@ -2297,6 +2991,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 @@ -2311,28 +3047,62 @@ 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 stopped thread, which is the same handling of the vStopped packet (by design). */ - send_next_stop_reply (own_buf); + notif_write_event (¬if_stop, 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; - status.kind = TARGET_WAITKIND_STOPPED; - status.value.sig = TARGET_SIGNAL_TRAP; - prepare_resume_reply (own_buf, - all_threads.head->id, &status); + /* GDB assumes the current thread is the thread we're + reporting the status for. */ + general_thread = thread->id; + set_desired_thread (1); + + 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"); @@ -2343,7 +3113,7 @@ static void gdbserver_version (void) { printf ("GNU gdbserver %s%s\n" - "Copyright (C) 2011 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", @@ -2357,16 +3127,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); } @@ -2407,7 +3209,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); @@ -2422,7 +3224,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); @@ -2442,7 +3244,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); } } @@ -2457,7 +3259,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); } } @@ -2491,15 +3293,41 @@ 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; char *arg_end, *port; char **next_arg = &argv[1]; - int multi_mode = 0; - int attach = 0; + volatile int multi_mode = 0; + volatile int attach = 0; int was_running; while (*next_arg != NULL && **next_arg == '-') @@ -2537,6 +3365,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) @@ -2544,9 +3384,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; @@ -2579,6 +3417,13 @@ main (int argc, char *argv[]) } } } + else if (strcmp (*next_arg, "-") == 0) + { + /* "-" specifies a stdio connection and is a form of port + specification. */ + *next_arg = STDIO_CONNECTION_NAME; + break; + } else if (strcmp (*next_arg, "--disable-randomization") == 0) disable_randomization = 1; else if (strcmp (*next_arg, "--no-disable-randomization") == 0) @@ -2595,12 +3440,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)) @@ -2609,6 +3448,16 @@ main (int argc, char *argv[]) exit (1); } + /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be + opened by remote_prepare. */ + notice_open_fds (); + + /* We need to know whether the remote connection is stdio before + starting the inferior. Inferiors created in this scenario have + stdin,stdout redirected. So do this here before we call + start_inferior. */ + remote_prepare (port); + bad_attach = 0; pid = 0; @@ -2636,6 +3485,7 @@ main (int argc, char *argv[]) initialize_async_io (); initialize_low (); + initialize_event_loop (); if (target_supports_tracepoints ()) initialize_tracepoint (); @@ -2672,18 +3522,15 @@ 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 (); /* Don't report shared library events on the initial connection, even if some libraries are preloaded. Avoids the "stopped by shared library event" notice on gdb side. */ dlls_changed = 0; - if (setjmp (toplevel)) - { - detach_or_kill_for_exit (); - exit (1); - } - if (last_status.kind == TARGET_WAITKIND_EXITED || last_status.kind == TARGET_WAITKIND_SIGNALLED) was_running = 0; @@ -2691,78 +3538,172 @@ main (int argc, char *argv[]) was_running = 1; if (!was_running && !multi_mode) - { - fprintf (stderr, "No program to debug. GDBserver exiting.\n"); - exit (1); - } - - remote_prepare (port); + 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. */ if (response_needed) { write_enn (own_buf); putpkt (own_buf); } } + 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) { - detach_or_kill_for_exit (); - exit (0); + 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 + + gdb_assert_not_reached ("captured_main should never return"); +} - 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; +/* Skip PACKET until the next semi-colon (or end of string). */ - /* Detaching implicitly resumes all threads; simply - disconnecting does not. */ - } - } - else - { - fprintf (stderr, - "Disconnected tracing disabled; stopping trace run.\n"); - stop_tracing (); - } +static void +skip_to_semicolon (char **packet) +{ + while (**packet != '\0' && **packet != ';') + (*packet)++; +} + +/* 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 (struct breakpoint *bp, char **packet) +{ + char *dataptr = *packet; + int persist; + + /* Check if data has the correct format. */ + if (*dataptr != ';') + return; + + dataptr++; + + while (*dataptr) + { + if (*dataptr == ';') + ++dataptr; + + if (*dataptr == 'X') + { + /* Conditional expression. */ + if (debug_threads) + debug_printf ("Found breakpoint condition.\n"); + if (!add_breakpoint_condition (bp, &dataptr)) + skip_to_semicolon (&dataptr); + } + else if (startswith (dataptr, "cmds:")) + { + dataptr += strlen ("cmds:"); + if (debug_threads) + debug_printf ("Found breakpoint commands %s.\n", dataptr); + persist = (*dataptr == '1'); + dataptr += 2; + 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. */ + skip_to_semicolon (&dataptr); } } + *packet = dataptr; } /* Event loop callback that handles a serial event. The first byte in @@ -2822,10 +3763,9 @@ process_serial_event (void) pid = strtol (&own_buf[i], NULL, 16); } else - pid = - ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id); + pid = ptid_get_pid (current_ptid); - if (tracing && disconnected_tracing) + if ((tracing && disconnected_tracing) || any_persistent_commands ()) { struct thread_resume resume_info; struct process_info *process = find_process_pid (pid); @@ -2836,9 +3776,15 @@ process_serial_event (void) break; } - fprintf (stderr, - "Disconnected tracing in effect, " - "leaving gdbserver attached to the process\n"); + if (tracing && disconnected_tracing) + fprintf (stderr, + "Disconnected tracing in effect, " + "leaving gdbserver attached to the process\n"); + + if (any_persistent_commands ()) + fprintf (stderr, + "Persistent commands are present, " + "leaving gdbserver attached to the process\n"); /* Make sure we're in non-stop/async mode, so we we can both wait for an async socket accept, and handle async target @@ -2848,7 +3794,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); @@ -2882,7 +3828,7 @@ process_serial_event (void) last_status.value.integer = 0; last_ptid = pid_to_ptid (pid); - current_inferior = NULL; + current_thread = NULL; } else { @@ -2933,7 +3879,7 @@ process_serial_event (void) break; } - thread_id = ((struct inferior_list_entry *)thread)->id; + thread_id = thread->entry.id; } else { @@ -2956,11 +3902,14 @@ 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); } else if (own_buf[1] == 'c') cont_thread = thread_id; @@ -2978,7 +3927,8 @@ process_serial_event (void) require_running (own_buf); if (current_traceframe >= 0) { - struct regcache *regcache = new_register_cache (); + struct regcache *regcache + = new_register_cache (current_target_desc ()); if (fetch_traceframe_registers (current_traceframe, regcache, -1) == 0) @@ -2991,8 +3941,8 @@ process_serial_event (void) { struct regcache *regcache; - set_desired_inferior (1); - regcache = get_thread_regcache (current_inferior, 1); + set_desired_thread (1); + regcache = get_thread_regcache (current_thread, 1); registers_to_string (regcache, own_buf); } break; @@ -3004,8 +3954,8 @@ process_serial_event (void) { struct regcache *regcache; - set_desired_inferior (1); - regcache = get_thread_regcache (current_inferior, 1); + set_desired_thread (1); + regcache = get_thread_regcache (current_thread, 1); registers_from_string (regcache, &own_buf[1]); write_ok (own_buf); } @@ -3017,7 +3967,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); @@ -3038,18 +3988,18 @@ process_serial_event (void) break; case 'C': require_running (own_buf); - convert_ascii_to_int (own_buf + 1, &sig, 1); - if (target_signal_to_host_p (sig)) - signal = target_signal_to_host (sig); + hex2bin (own_buf + 1, &sig, 1); + if (gdb_signal_to_host_p (sig)) + signal = gdb_signal_to_host (sig); else signal = 0; myresume (own_buf, 0, signal); break; case 'S': require_running (own_buf); - convert_ascii_to_int (own_buf + 1, &sig, 1); - if (target_signal_to_host_p (sig)) - signal = target_signal_to_host (sig); + hex2bin (own_buf + 1, &sig, 1); + if (gdb_signal_to_host_p (sig)) + signal = gdb_signal_to_host (sig); else signal = 0; myresume (own_buf, 1, signal); @@ -3068,32 +4018,37 @@ process_serial_event (void) /* Fallthrough. */ case 'z': /* remove_ ... */ { - char *lenptr; char *dataptr; - CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16); - int len = strtol (lenptr + 1, &dataptr, 16); + ULONGEST addr; + int len; char type = own_buf[1]; int res; const int insert = ch == 'Z'; + char *p = &own_buf[3]; + + 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) - res = (*the_target->insert_point) (type, addr, len); - else if (!insert && the_target->remove_point != NULL) - res = (*the_target->remove_point) (type, addr, len); - break; - default: - break; + struct breakpoint *bp; + + bp = set_gdb_breakpoint (type, addr, len, &res); + if (bp != NULL) + { + 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 + res = delete_gdb_breakpoint (type, addr, len); if (res == 0) write_ok (own_buf); @@ -3119,7 +4074,7 @@ process_serial_event (void) if (extended_protocol) { last_status.kind = TARGET_WAITKIND_EXITED; - last_status.value.sig = TARGET_SIGNAL_KILL; + last_status.value.sig = GDB_SIGNAL_KILL; return 0; } else @@ -3159,11 +4114,24 @@ 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; - last_status.value.sig = TARGET_SIGNAL_KILL; + last_status.value.sig = GDB_SIGNAL_KILL; } return 0; } @@ -3199,9 +4167,12 @@ process_serial_event (void) { /* In non-stop, defer exiting until GDB had a chance to query the whole vStopped list (until it gets an OK). */ - if (!notif_queue) + 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); } @@ -3219,15 +4190,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; } @@ -3238,12 +4209,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); @@ -3260,8 +4235,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) @@ -3280,31 +4255,37 @@ 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; - resume_info.sig = target_signal_to_host (last_status.value.sig); + resume_info.sig = gdb_signal_to_host (last_status.value.sig); (*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 { - /* Something interesting. Tell GDB about it. */ - push_event (last_ptid, &last_status); + struct vstop_notif *vstop_notif + = xmalloc (sizeof (struct vstop_notif)); + + vstop_notif->status = last_status; + vstop_notif->ptid = last_ptid; + /* Push Stop notification. */ + notif_push (¬if_stop, + (struct notif_event *) vstop_notif); } } - /* 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; }