* server.h (non_stop): Declare.
(gdb_client_data, handler_func): Declare.
(delete_file_handler, add_file_handler, start_event_loop):
Declare.
(handle_serial_event, handle_target_event, push_event)
(putpkt_notif): Declare.
* target.h (enum resume_kind): New.
(struct thread_resume): Replace `step' field by `kind' field.
(TARGET_WNOHANG): Define.
(struct target_ops) <wait>: Add `options' argument.
<supports_non_stop, async, start_non_stop>: New fields.
(target_supports_non_stop, target_async): New.
(start_non_stop): Declare.
(mywait): Add `options' argument.
* target.c (mywait): Add `options' argument. Print child exit
notifications here.
(start_non_stop): New.
* server.c (non_stop, own_buf, mem_buf): New globals.
(struct vstop_notif): New.
(notif_queue): New global.
(queue_stop_reply, push_event, discard_queued_stop_replies)
(send_next_stop_reply): New.
(start_inferior): Adjust to use resume_kind. Adjust to mywait
interface changes.
(attach_inferior): In non-stop mode, don't wait for the target
here.
(handle_general_set): Handle QNonStop.
(handle_query): When handling qC, return the current general
thread, instead of the first thread of the list.
(handle_query): If the backend supports non-stop mode, include
QNonStop+ in the qSupported query response.
(handle_v_cont): Adjust to use resume_kind. Handle resume_stop
and non-stop mode.
(handle_v_attach, handle_v_run): Handle non-stop mode.
(handle_v_stopped): New.
(handle_v_requests): Report support for vCont;t. Handle vStopped.
(myresume): Adjust to use resume_kind. Handle non-stop.
(queue_stop_reply_callback): New.
(handle_status): Handle non-stop mode.
(main): Clear non_stop flag on reconnection. Use the event-loop.
Refactor serial protocol handling from here ...
(process_serial_event): ... to this new function. When GDB
selects any thread, select one here. In non-stop mode, wait until
GDB acks all pending events before exiting.
(handle_serial_event, handle_target_event): New.
* remote-utils.c (remote_open): Install remote_desc in the event
loop.
(remote_close): Remove remote_desc from the event loop.
(putpkt_binary): Rename to...
(putpkt_binary_1): ... this. Add `is_notic' argument. Handle it.
(putpkt_binary): New as wrapper around putpkt_binary_1.
(putpkt_notif): New.
(prepare_resume_reply): In non-stop mode, don't change the
general_thread.
* event-loop.c: New.
* Makefile.in (OBJ): Add event-loop.o.
(event-loop.o): New rule.
* linux-low.h (pid_of): Moved here.
(lwpid_of): New.
(get_lwp_thread): Use lwpid_of.
(struct lwp_info): Delete `lwpid' field. Add `suspended' field.
* linux-low.c (pid_of): Delete.
(inferior_pid): Use lwpid_of.
(linux_event_pipe): New.
(target_is_async_p): New.
(delete_lwp): New.
(handle_extended_wait): Use lwpid_of.
(add_lwp): Don't set lwpid field.
(linux_attach_lwp): Adjust debug output. Use lwpid_of.
(linux_kill_one_lwp): If killing a running lwp, stop it first.
Use lwpid_of. Adjust to linux_wait_for_event interface changes.
(linux_detach_one_lwp): If detaching from a running lwp, stop it
first. Adjust to linux_wait_for_event interface changes. Use
lwpid_of.
(linux_detach): Don't delete the main lwp here.
(linux_join): Use my_waitpid. Avoid signal_pid. Use lwpid_of.
(status_pending_p): Don't consider explicitly suspended lwps.
(linux_wait_for_lwp): Take an integer pid instead of a lwp_info
pointer. Add OPTIONS argument. Change return type to int. Use
my_waitpid instead of sleeping. Handle WNOHANG. Use lwpid_of.
(linux_wait_for_event): Take an integer pid instead of a lwp_info
pointer. Add status pointer argument. Return a pid instead of a
status. Use lwpid_of. Adjust to linux_wait_for_lwp interface
changes. In non-stop mode, don't switch to a random thread.
(linux_wait): Rename to...
(linux_wait_1): ... this. Add target_options argument, and handle
it. Adjust to use resume_kind. Use lwpid_of. In non-stop mode,
don't handle the continue thread. Handle TARGET_WNOHANG. Merge
clean exit and signal exit code. Don't stop all threads in
non-stop mode. In all-stop mode, only stop all threads when
reporting a stop to GDB. Handle explicit thread stop requests.
(async_file_flush, async_file_mark): New.
(linux_wait): New.
(send_sigstop): Use lwpid_of.
(wait_for_sigstop): Use lwpid_of. Adjust to linux_wait_for_event
interface changes. In non-stop mode, don't switch to a random
thread.
(linux_resume_one_lwp): Use lwpid_of.
(linux_continue_one_thread, linux_queue_one_thread): Merge into ...
(linux_resume_one_thread): ... this. Handle resume_stop. In
non-stop mode, don't look for pending flag in all threads.
(resume_status_pending_p): Don't consider explicitly suspended
threads.
(my_waitpid): Reimplement. Emulate __WALL.
(linux_request_interrupt, linux_read_offsets, linux_xfer_siginfo):
Use lwpid_of.
(sigchld_handler, linux_supports_non_stop, linux_async)
(linux_start_non_stop): New.
(linux_target_ops): Register linux_supports_non_stop, linux_async
and linux_start_non_stop.
(initialize_low): Install SIGCHLD handler.
* thread-db.c (thread_db_create_event, find_one_thread)
(thread_db_get_tls_address): Use lwpid_of.
* win32-low.c (win32_detach): Adjust to use resume_kind.
(win32_wait): Add `options' argument.
* spu-low.c (spu_resume): Adjust to use resume_kind.
(spu_wait): Add `options' argument.
+2009-04-01 Pedro Alves <pedro@codesourcery.com>
+
+ Non-stop mode support.
+
+ * server.h (non_stop): Declare.
+ (gdb_client_data, handler_func): Declare.
+ (delete_file_handler, add_file_handler, start_event_loop):
+ Declare.
+ (handle_serial_event, handle_target_event, push_event)
+ (putpkt_notif): Declare.
+ * target.h (enum resume_kind): New.
+ (struct thread_resume): Replace `step' field by `kind' field.
+ (TARGET_WNOHANG): Define.
+ (struct target_ops) <wait>: Add `options' argument.
+ <supports_non_stop, async, start_non_stop>: New fields.
+ (target_supports_non_stop, target_async): New.
+ (start_non_stop): Declare.
+ (mywait): Add `options' argument.
+ * target.c (mywait): Add `options' argument. Print child exit
+ notifications here.
+ (start_non_stop): New.
+ * server.c (non_stop, own_buf, mem_buf): New globals.
+ (struct vstop_notif): New.
+ (notif_queue): New global.
+ (queue_stop_reply, push_event, discard_queued_stop_replies)
+ (send_next_stop_reply): New.
+ (start_inferior): Adjust to use resume_kind. Adjust to mywait
+ interface changes.
+ (attach_inferior): In non-stop mode, don't wait for the target
+ here.
+ (handle_general_set): Handle QNonStop.
+ (handle_query): When handling qC, return the current general
+ thread, instead of the first thread of the list.
+ (handle_query): If the backend supports non-stop mode, include
+ QNonStop+ in the qSupported query response.
+ (handle_v_cont): Adjust to use resume_kind. Handle resume_stop
+ and non-stop mode.
+ (handle_v_attach, handle_v_run): Handle non-stop mode.
+ (handle_v_stopped): New.
+ (handle_v_requests): Report support for vCont;t. Handle vStopped.
+ (myresume): Adjust to use resume_kind. Handle non-stop.
+ (queue_stop_reply_callback): New.
+ (handle_status): Handle non-stop mode.
+ (main): Clear non_stop flag on reconnection. Use the event-loop.
+ Refactor serial protocol handling from here ...
+ (process_serial_event): ... to this new function. When GDB
+ selects any thread, select one here. In non-stop mode, wait until
+ GDB acks all pending events before exiting.
+ (handle_serial_event, handle_target_event): New.
+ * remote-utils.c (remote_open): Install remote_desc in the event
+ loop.
+ (remote_close): Remove remote_desc from the event loop.
+ (putpkt_binary): Rename to...
+ (putpkt_binary_1): ... this. Add `is_notic' argument. Handle it.
+ (putpkt_binary): New as wrapper around putpkt_binary_1.
+ (putpkt_notif): New.
+ (prepare_resume_reply): In non-stop mode, don't change the
+ general_thread.
+ * event-loop.c: New.
+ * Makefile.in (OBJ): Add event-loop.o.
+ (event-loop.o): New rule.
+
+ * linux-low.h (pid_of): Moved here.
+ (lwpid_of): New.
+ (get_lwp_thread): Use lwpid_of.
+ (struct lwp_info): Delete `lwpid' field. Add `suspended' field.
+ * linux-low.c (pid_of): Delete.
+ (inferior_pid): Use lwpid_of.
+ (linux_event_pipe): New.
+ (target_is_async_p): New.
+ (delete_lwp): New.
+ (handle_extended_wait): Use lwpid_of.
+ (add_lwp): Don't set lwpid field.
+ (linux_attach_lwp): Adjust debug output. Use lwpid_of.
+ (linux_kill_one_lwp): If killing a running lwp, stop it first.
+ Use lwpid_of. Adjust to linux_wait_for_event interface changes.
+ (linux_detach_one_lwp): If detaching from a running lwp, stop it
+ first. Adjust to linux_wait_for_event interface changes. Use
+ lwpid_of.
+ (linux_detach): Don't delete the main lwp here.
+ (linux_join): Use my_waitpid. Avoid signal_pid. Use lwpid_of.
+ (status_pending_p): Don't consider explicitly suspended lwps.
+ (linux_wait_for_lwp): Take an integer pid instead of a lwp_info
+ pointer. Add OPTIONS argument. Change return type to int. Use
+ my_waitpid instead of sleeping. Handle WNOHANG. Use lwpid_of.
+ (linux_wait_for_event): Take an integer pid instead of a lwp_info
+ pointer. Add status pointer argument. Return a pid instead of a
+ status. Use lwpid_of. Adjust to linux_wait_for_lwp interface
+ changes. In non-stop mode, don't switch to a random thread.
+ (linux_wait): Rename to...
+ (linux_wait_1): ... this. Add target_options argument, and handle
+ it. Adjust to use resume_kind. Use lwpid_of. In non-stop mode,
+ don't handle the continue thread. Handle TARGET_WNOHANG. Merge
+ clean exit and signal exit code. Don't stop all threads in
+ non-stop mode. In all-stop mode, only stop all threads when
+ reporting a stop to GDB. Handle explicit thread stop requests.
+ (async_file_flush, async_file_mark): New.
+ (linux_wait): New.
+ (send_sigstop): Use lwpid_of.
+ (wait_for_sigstop): Use lwpid_of. Adjust to linux_wait_for_event
+ interface changes. In non-stop mode, don't switch to a random
+ thread.
+ (linux_resume_one_lwp): Use lwpid_of.
+ (linux_continue_one_thread, linux_queue_one_thread): Merge into ...
+ (linux_resume_one_thread): ... this. Handle resume_stop. In
+ non-stop mode, don't look for pending flag in all threads.
+ (resume_status_pending_p): Don't consider explicitly suspended
+ threads.
+ (my_waitpid): Reimplement. Emulate __WALL.
+ (linux_request_interrupt, linux_read_offsets, linux_xfer_siginfo):
+ Use lwpid_of.
+ (sigchld_handler, linux_supports_non_stop, linux_async)
+ (linux_start_non_stop): New.
+ (linux_target_ops): Register linux_supports_non_stop, linux_async
+ and linux_start_non_stop.
+ (initialize_low): Install SIGCHLD handler.
+ * thread-db.c (thread_db_create_event, find_one_thread)
+ (thread_db_get_tls_address): Use lwpid_of.
+ * win32-low.c (win32_detach): Adjust to use resume_kind.
+ (win32_wait): Add `options' argument.
+ * spu-low.c (spu_resume): Adjust to use resume_kind.
+ (spu_wait): Add `options' argument.
+
2009-04-01 Pedro Alves <pedro@codesourcery.com>
Decouple target code from remote protocol.
OBS = inferiors.o regcache.o remote-utils.o server.o signals.o target.o \
utils.o version.o \
- mem-break.o hostio.o \
+ mem-break.o hostio.o event-loop.o \
$(XML_BUILTIN) \
$(DEPFILES) $(LIBOBJS)
GDBREPLAY_OBS = gdbreplay.o version.o
linux_low_h = $(srcdir)/linux-low.h
+event-loop.o: event-loop.c $(server_h)
hostio.o: hostio.c $(server_h)
hostio-errno.o: hostio-errno.c $(server_h)
inferiors.o: inferiors.c $(server_h)
--- /dev/null
+/* Event loop machinery for the remote server for GDB.
+ Copyright (C) 1999, 2000, 2001, 2002, 2005, 2006, 2007, 2008
+ Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* Based on src/gdb/event-loop.c. */
+
+#include "server.h"
+
+#include <sys/types.h>
+#include <string.h>
+#include <sys/time.h>
+
+#ifdef USE_WIN32API
+#include <windows.h>
+#include <io.h>
+#endif
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
+typedef struct gdb_event gdb_event;
+typedef void (event_handler_func) (int);
+
+/* Tell create_file_handler what events we are interested in. */
+
+#define GDB_READABLE (1<<1)
+#define GDB_WRITABLE (1<<2)
+#define GDB_EXCEPTION (1<<3)
+
+/* Events are queued by calling async_queue_event and serviced later
+ on by do_one_event. An event can be, for instance, a file
+ descriptor becoming ready to be read. Servicing an event simply
+ means that the procedure PROC will be called. We have 2 queues,
+ one for file handlers that we listen to in the event loop, and one
+ for the file handlers+events that are ready. The procedure PROC
+ associated with each event is always the same (handle_file_event).
+ Its duty is to invoke the handler associated with the file
+ descriptor whose state change generated the event, plus doing other
+ cleanups and such. */
+
+struct gdb_event
+ {
+ /* Procedure to call to service this event. */
+ event_handler_func *proc;
+
+ /* File descriptor that is ready. */
+ int fd;
+
+ /* Next in list of events or NULL. */
+ struct gdb_event *next_event;
+ };
+
+/* Information about each file descriptor we register with the event
+ loop. */
+
+typedef struct file_handler
+ {
+ /* File descriptor. */
+ int fd;
+
+ /* Events we want to monitor. */
+ int mask;
+
+ /* Events that have been seen since the last time. */
+ int ready_mask;
+
+ /* Procedure to call when fd is ready. */
+ handler_func *proc;
+
+ /* Argument to pass to proc. */
+ gdb_client_data client_data;
+
+ /* Was an error detected on this fd? */
+ int error;
+
+ /* Next registered file descriptor. */
+ struct file_handler *next_file;
+ }
+file_handler;
+
+/* Event queue:
+
+ Events can be inserted at the front of the queue or at the end of
+ the queue. Events will be extracted from the queue for processing
+ starting from the head. Therefore, events inserted at the head of
+ the queue will be processed in a last in first out fashion, while
+ those inserted at the tail of the queue will be processed in a
+ first in first out manner. All the fields are NULL if the queue is
+ empty. */
+
+static struct
+ {
+ /* The first pending event. */
+ gdb_event *first_event;
+
+ /* The last pending event. */
+ gdb_event *last_event;
+ }
+event_queue;
+
+/* Gdb_notifier is just a list of file descriptors gdb is interested
+ in. These are the input file descriptor, and the target file
+ descriptor. Each of the elements in the gdb_notifier list is
+ basically a description of what kind of events gdb is interested
+ in, for each fd. */
+
+static struct
+ {
+ /* Ptr to head of file handler list. */
+ file_handler *first_file_handler;
+
+ /* Masks to be used in the next call to select. Bits are set in
+ response to calls to create_file_handler. */
+ fd_set check_masks[3];
+
+ /* What file descriptors were found ready by select. */
+ fd_set ready_masks[3];
+
+ /* Number of valid bits (highest fd value + 1). (for select) */
+ int num_fds;
+ }
+gdb_notifier;
+
+/* Insert an event object into the gdb event queue.
+
+ EVENT_PTR points to the event to be inserted into the queue. The
+ caller must allocate memory for the event. It is freed after the
+ event has ben handled. Events in the queue will be processed head
+ to tail, therefore, events will be processed first in first
+ out. */
+
+static void
+async_queue_event (gdb_event *event_ptr)
+{
+ /* The event will become the new last_event. */
+
+ event_ptr->next_event = NULL;
+ if (event_queue.first_event == NULL)
+ event_queue.first_event = event_ptr;
+ else
+ event_queue.last_event->next_event = event_ptr;
+ event_queue.last_event = event_ptr;
+}
+
+/* Process one event. If an event was processed, 1 is returned
+ otherwise 0 is returned. Scan the queue from head to tail,
+ processing therefore the high priority events first, by invoking
+ the associated event handler procedure. */
+
+static int
+process_event (void)
+{
+ gdb_event *event_ptr, *prev_ptr;
+ event_handler_func *proc;
+ int fd;
+
+ /* Look in the event queue to find an event that is ready
+ to be processed. */
+
+ for (event_ptr = event_queue.first_event;
+ event_ptr != NULL;
+ event_ptr = event_ptr->next_event)
+ {
+ /* Call the handler for the event. */
+
+ proc = event_ptr->proc;
+ fd = event_ptr->fd;
+
+ /* Let's get rid of the event from the event queue. We need to
+ do this now because while processing the event, since the
+ proc function could end up jumping out to the caller of this
+ function. In that case, we would have on the event queue an
+ event which has been processed, but not deleted. */
+
+ if (event_queue.first_event == event_ptr)
+ {
+ event_queue.first_event = event_ptr->next_event;
+ if (event_ptr->next_event == NULL)
+ event_queue.last_event = NULL;
+ }
+ else
+ {
+ prev_ptr = event_queue.first_event;
+ while (prev_ptr->next_event != event_ptr)
+ prev_ptr = prev_ptr->next_event;
+
+ prev_ptr->next_event = event_ptr->next_event;
+ if (event_ptr->next_event == NULL)
+ event_queue.last_event = prev_ptr;
+ }
+ free (event_ptr);
+
+ /* Now call the procedure associated with the event. */
+ (*proc) (fd);
+ return 1;
+ }
+
+ /* This is the case if there are no event on the event queue. */
+ return 0;
+}
+
+/* Add a file handler/descriptor to the list of descriptors we are
+ interested in. FD is the file descriptor for the file/stream to be
+ listened to. MASK is a combination of READABLE, WRITABLE,
+ EXCEPTION. PROC is the procedure that will be called when an event
+ occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
+
+static void
+create_file_handler (int fd, int mask, handler_func *proc,
+ gdb_client_data client_data)
+{
+ file_handler *file_ptr;
+
+ /* Do we already have a file handler for this file? (We may be
+ changing its associated procedure). */
+ for (file_ptr = gdb_notifier.first_file_handler;
+ file_ptr != NULL;
+ file_ptr = file_ptr->next_file)
+ if (file_ptr->fd == fd)
+ break;
+
+ /* It is a new file descriptor. Add it to the list. Otherwise,
+ just change the data associated with it. */
+ if (file_ptr == NULL)
+ {
+ file_ptr = xmalloc (sizeof (*file_ptr));
+ file_ptr->fd = fd;
+ file_ptr->ready_mask = 0;
+ file_ptr->next_file = gdb_notifier.first_file_handler;
+ gdb_notifier.first_file_handler = file_ptr;
+
+ if (mask & GDB_READABLE)
+ FD_SET (fd, &gdb_notifier.check_masks[0]);
+ else
+ FD_CLR (fd, &gdb_notifier.check_masks[0]);
+
+ if (mask & GDB_WRITABLE)
+ FD_SET (fd, &gdb_notifier.check_masks[1]);
+ else
+ FD_CLR (fd, &gdb_notifier.check_masks[1]);
+
+ if (mask & GDB_EXCEPTION)
+ FD_SET (fd, &gdb_notifier.check_masks[2]);
+ else
+ FD_CLR (fd, &gdb_notifier.check_masks[2]);
+
+ if (gdb_notifier.num_fds <= fd)
+ gdb_notifier.num_fds = fd + 1;
+ }
+
+ file_ptr->proc = proc;
+ file_ptr->client_data = client_data;
+ file_ptr->mask = mask;
+}
+
+/* Wrapper function for create_file_handler. */
+
+void
+add_file_handler (int fd, handler_func *proc, gdb_client_data client_data)
+{
+ create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
+}
+
+/* Remove the file descriptor FD from the list of monitored fd's:
+ i.e. we don't care anymore about events on the FD. */
+
+void
+delete_file_handler (int fd)
+{
+ file_handler *file_ptr, *prev_ptr = NULL;
+ int i;
+
+ /* Find the entry for the given file. */
+
+ for (file_ptr = gdb_notifier.first_file_handler;
+ file_ptr != NULL;
+ file_ptr = file_ptr->next_file)
+ if (file_ptr->fd == fd)
+ break;
+
+ if (file_ptr == NULL)
+ return;
+
+ if (file_ptr->mask & GDB_READABLE)
+ FD_CLR (fd, &gdb_notifier.check_masks[0]);
+ if (file_ptr->mask & GDB_WRITABLE)
+ FD_CLR (fd, &gdb_notifier.check_masks[1]);
+ if (file_ptr->mask & GDB_EXCEPTION)
+ FD_CLR (fd, &gdb_notifier.check_masks[2]);
+
+ /* Find current max fd. */
+
+ if ((fd + 1) == gdb_notifier.num_fds)
+ {
+ gdb_notifier.num_fds--;
+ for (i = gdb_notifier.num_fds; i; i--)
+ {
+ if (FD_ISSET (i - 1, &gdb_notifier.check_masks[0])
+ || FD_ISSET (i - 1, &gdb_notifier.check_masks[1])
+ || FD_ISSET (i - 1, &gdb_notifier.check_masks[2]))
+ break;
+ }
+ gdb_notifier.num_fds = i;
+ }
+
+ /* Deactivate the file descriptor, by clearing its mask, so that it
+ will not fire again. */
+
+ file_ptr->mask = 0;
+
+ /* Get rid of the file handler in the file handler list. */
+ if (file_ptr == gdb_notifier.first_file_handler)
+ gdb_notifier.first_file_handler = file_ptr->next_file;
+ else
+ {
+ for (prev_ptr = gdb_notifier.first_file_handler;
+ prev_ptr->next_file != file_ptr;
+ prev_ptr = prev_ptr->next_file)
+ ;
+ prev_ptr->next_file = file_ptr->next_file;
+ }
+ free (file_ptr);
+}
+
+/* Handle the given event by calling the procedure associated to the
+ corresponding file handler. Called by process_event indirectly,
+ through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
+ event in the front of the event queue. */
+
+static void
+handle_file_event (int event_file_desc)
+{
+ file_handler *file_ptr;
+ int mask;
+
+ /* Search the file handler list to find one that matches the fd in
+ the event. */
+ for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
+ file_ptr = file_ptr->next_file)
+ {
+ if (file_ptr->fd == event_file_desc)
+ {
+ /* See if the desired events (mask) match the received
+ events (ready_mask). */
+
+ if (file_ptr->ready_mask & GDB_EXCEPTION)
+ {
+ fprintf (stderr, "Exception condition detected on fd %d\n",
+ file_ptr->fd);
+ file_ptr->error = 1;
+ }
+ else
+ file_ptr->error = 0;
+ mask = file_ptr->ready_mask & file_ptr->mask;
+
+ /* Clear the received events for next time around. */
+ file_ptr->ready_mask = 0;
+
+ /* If there was a match, then call the handler. */
+ if (mask != 0)
+ (*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
+ break;
+ }
+ }
+}
+
+/* Create a file event, to be enqueued in the event queue for
+ processing. The procedure associated to this event is always
+ handle_file_event, which will in turn invoke the one that was
+ associated to FD when it was registered with the event loop. */
+
+static gdb_event *
+create_file_event (int fd)
+{
+ gdb_event *file_event_ptr;
+
+ file_event_ptr = xmalloc (sizeof (gdb_event));
+ file_event_ptr->proc = handle_file_event;
+ file_event_ptr->fd = fd;
+ return file_event_ptr;
+}
+
+/* Called by do_one_event to wait for new events on the monitored file
+ descriptors. Queue file events as they are detected by the poll.
+ If there are no events, this function will block in the call to
+ select. Return -1 if there are no files descriptors to monitor,
+ otherwise return 0. */
+
+static int
+wait_for_event (void)
+{
+ file_handler *file_ptr;
+ gdb_event *file_event_ptr;
+ int num_found = 0;
+
+ /* Make sure all output is done before getting another event. */
+ fflush (stdout);
+ fflush (stderr);
+
+ if (gdb_notifier.num_fds == 0)
+ return -1;
+
+ gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
+ gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1];
+ gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2];
+ num_found = select (gdb_notifier.num_fds,
+ &gdb_notifier.ready_masks[0],
+ &gdb_notifier.ready_masks[1],
+ &gdb_notifier.ready_masks[2],
+ NULL);
+
+ /* Clear the masks after an error from select. */
+ if (num_found == -1)
+ {
+ FD_ZERO (&gdb_notifier.ready_masks[0]);
+ FD_ZERO (&gdb_notifier.ready_masks[1]);
+ FD_ZERO (&gdb_notifier.ready_masks[2]);
+#ifdef EINTR
+ /* Dont print anything if we got a signal, let gdb handle
+ it. */
+ if (errno != EINTR)
+ perror_with_name ("select");
+#endif
+ }
+
+ /* Enqueue all detected file events. */
+
+ for (file_ptr = gdb_notifier.first_file_handler;
+ file_ptr != NULL && num_found > 0;
+ file_ptr = file_ptr->next_file)
+ {
+ int mask = 0;
+
+ if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0]))
+ mask |= GDB_READABLE;
+ if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1]))
+ mask |= GDB_WRITABLE;
+ if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2]))
+ mask |= GDB_EXCEPTION;
+
+ if (!mask)
+ continue;
+ else
+ num_found--;
+
+ /* Enqueue an event only if this is still a new event for this
+ fd. */
+
+ if (file_ptr->ready_mask == 0)
+ {
+ file_event_ptr = create_file_event (file_ptr->fd);
+ async_queue_event (file_event_ptr);
+ }
+ file_ptr->ready_mask = mask;
+ }
+
+ return 0;
+}
+
+/* Start up the event loop. This is the entry point to the event
+ loop. */
+
+void
+start_event_loop (void)
+{
+ /* Loop until there is nothing to do. This is the entry point to
+ the event loop engine. If nothing is ready at this time, wait
+ for something to happen (via wait_for_event), then process it.
+ Return when there are no longer event sources to wait for. */
+
+ while (1)
+ {
+ /* Any events already waiting in the queue? */
+ if (process_event ())
+ continue;
+
+ /* Wait for a new event. If wait_for_event returns -1, we
+ should get out because this means that there are no event
+ sources left. This will make the event loop stop, and the
+ application exit. */
+
+ if (wait_for_event () < 0)
+ return;
+ }
+
+ /* We are done with the event loop. There are no more event sources
+ to listen to. So we exit gdbserver. */
+}
int step, int signal, siginfo_t *info);
static void linux_resume (struct thread_resume *resume_info, size_t n);
static void stop_all_lwps (void);
-static int linux_wait_for_event (struct thread_info *child);
+static int linux_wait_for_event (int pid, int *wstat, int options);
static int check_removed_breakpoint (struct lwp_info *event_child);
static void *add_lwp (unsigned long pid);
static int my_waitpid (int pid, int *status, int flags);
static int num_regsets;
#endif
-#define pid_of(proc) ((proc)->head.id)
-
/* FIXME: Delete eventually. */
-#define inferior_pid (pid_of (get_thread_lwp (current_inferior)))
+#define inferior_pid (lwpid_of (get_thread_lwp (current_inferior)))
+
+/* The read/write ends of the pipe registered as waitable file in the
+ event loop. */
+static int linux_event_pipe[2] = { -1, -1 };
+
+/* True if we're currently in async mode. */
+#define target_is_async_p() (linux_event_pipe[0] != -1)
+
+static void send_sigstop (struct inferior_list_entry *entry);
+static void wait_for_sigstop (struct inferior_list_entry *entry);
+
+static void
+delete_lwp (struct lwp_info *lwp)
+{
+ remove_thread (get_lwp_thread (lwp));
+ remove_inferior (&all_lwps, &lwp->head);
+ free (lwp);
+}
+
+/* Handle a GNU/Linux extended wait response. If we see a clone
+ event, we need to add the new LWP to our list (and not report the
+ trap to higher layers). */
static void
handle_extended_wait (struct lwp_info *event_child, int wstat)
unsigned long new_pid;
int ret, status = W_STOPCODE (SIGSTOP);
- ptrace (PTRACE_GETEVENTMSG, inferior_pid, 0, &new_pid);
+ ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
/* If we haven't already seen the new PID stop, wait for it now. */
if (! pull_pid_from_list (&stopped_pids, new_pid))
new_lwp = (struct lwp_info *) add_lwp (new_pid);
add_thread (new_pid, new_lwp, new_pid);
- new_thread_notify (thread_id_to_gdb_id (new_lwp->lwpid));
+ new_thread_notify (thread_id_to_gdb_id (lwpid_of (new_lwp)));
/* Normally we will get the pending SIGSTOP. But in some cases
we might get another signal delivered to the group first.
memset (lwp, 0, sizeof (*lwp));
lwp->head.id = pid;
- lwp->lwpid = pid;
add_inferior_to_list (&all_lwps, &lwp->head);
}
else
/* If we fail to attach to a process, report an error. */
- error ("Cannot attach to process %ld: %s (%d)\n", pid,
+ error ("Cannot attach to lwp %ld: %s (%d)\n", pid,
strerror (errno), errno);
}
new_lwp = (struct lwp_info *) add_lwp (pid);
add_thread (pid, new_lwp, pid);
- new_thread_notify (thread_id_to_gdb_id (new_lwp->lwpid));
+ new_thread_notify (thread_id_to_gdb_id (lwpid_of (new_lwp)));
/* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
brings it to a halt.
linux_attach_lwp (pid);
- /* Don't ignore the initial SIGSTOP if we just attached to this process.
- It will be collected by wait shortly. */
- lwp = (struct lwp_info *) find_inferior_id (&all_lwps, pid);
- lwp->stop_expected = 0;
+ if (!non_stop)
+ {
+ /* Don't ignore the initial SIGSTOP if we just attached to this
+ process. It will be collected by wait shortly. */
+ lwp = (struct lwp_info *) find_inferior_id (&all_lwps, pid);
+ lwp->stop_expected = 0;
+ }
new_inferior = 1;
{
struct thread_info *thread = (struct thread_info *) entry;
struct lwp_info *lwp = get_thread_lwp (thread);
+ int pid;
int wstat;
/* We avoid killing the first thread here, because of a Linux kernel (at
if (entry == all_threads.head)
return;
+ /* If we're killing a running inferior, make sure it is stopped
+ first, as PTRACE_KILL will not work otherwise. */
+ if (!lwp->stopped)
+ send_sigstop (&lwp->head);
+
do
{
- ptrace (PTRACE_KILL, pid_of (lwp), 0, 0);
+ ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
/* Make sure it died. The loop is most likely unnecessary. */
- wstat = linux_wait_for_event (thread);
- } while (WIFSTOPPED (wstat));
+ pid = linux_wait_for_event (lwpid_of (lwp), &wstat, __WALL);
+ } while (pid > 0 && WIFSTOPPED (wstat));
}
static void
struct thread_info *thread = (struct thread_info *) all_threads.head;
struct lwp_info *lwp;
int wstat;
+ int pid;
if (thread == NULL)
return;
/* See the comment in linux_kill_one_lwp. We did not kill the first
thread in the list, so do so now. */
lwp = get_thread_lwp (thread);
+
+ if (debug_threads)
+ fprintf (stderr, "lk_1: killing lwp %ld\n", lwpid_of (lwp));
+
+ /* If we're killing a running inferior, make sure it is stopped
+ first, as PTRACE_KILL will not work otherwise. */
+ if (!lwp->stopped)
+ send_sigstop (&lwp->head);
+
do
{
- ptrace (PTRACE_KILL, pid_of (lwp), 0, 0);
+ ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
/* Make sure it died. The loop is most likely unnecessary. */
- wstat = linux_wait_for_event (thread);
- } while (WIFSTOPPED (wstat));
+ pid = linux_wait_for_event (lwpid_of (lwp), &wstat, __WALL);
+ } while (pid > 0 && WIFSTOPPED (wstat));
+ delete_lwp (lwp);
clear_inferiors ();
- free (all_lwps.head);
- all_lwps.head = all_lwps.tail = NULL;
}
static void
struct thread_info *thread = (struct thread_info *) entry;
struct lwp_info *lwp = get_thread_lwp (thread);
+ /* If we're detaching from a running inferior, make sure it is
+ stopped first, as PTRACE_DETACH will not work otherwise. */
+ if (!lwp->stopped)
+ {
+ int pid = lwpid_of (lwp);
+
+ stopping_threads = 1;
+ send_sigstop (&lwp->head);
+
+ /* If this detects a new thread through a clone event, the new
+ thread is appended to the end of the lwp list, so we'll
+ eventually detach from it. */
+ wait_for_sigstop (&lwp->head);
+ stopping_threads = 0;
+
+ /* If LWP exits while we're trying to stop it, there's nothing
+ left to do. */
+ lwp = (struct lwp_info *) find_inferior_id (&all_lwps, pid);
+ if (lwp == NULL)
+ return;
+ }
+
/* Make sure the process isn't stopped at a breakpoint that's
no longer there. */
check_removed_breakpoint (lwp);
to collect the SIGSTOP, but is fairly likely to. */
if (lwp->stop_expected)
{
+ int wstat;
/* Clear stop_expected, so that the SIGSTOP will be reported. */
lwp->stop_expected = 0;
if (lwp->stopped)
linux_resume_one_lwp (&lwp->head, 0, 0, NULL);
- linux_wait_for_event (thread);
+ linux_wait_for_event (lwpid_of (lwp), &wstat, __WALL);
}
/* Flush any pending changes to the process's registers. */
get_lwp_thread (lwp));
/* Finally, let it resume. */
- ptrace (PTRACE_DETACH, pid_of (lwp), 0, 0);
+ ptrace (PTRACE_DETACH, lwpid_of (lwp), 0, 0);
+
+ delete_lwp (lwp);
}
static int
delete_all_breakpoints ();
for_each_inferior (&all_threads, linux_detach_one_lwp);
clear_inferiors ();
- free (all_lwps.head);
- all_lwps.head = all_lwps.tail = NULL;
return 0;
}
static void
linux_join (void)
{
- extern unsigned long signal_pid;
int status, ret;
+ struct thread_info *thread;
+ struct lwp_info *lwp;
+
+ thread = (struct thread_info *) all_threads.head;
+ lwp = get_thread_lwp (thread);
do {
- ret = waitpid (signal_pid, &status, 0);
+ ret = my_waitpid (lwpid_of (lwp), &status, 0);
if (WIFEXITED (status) || WIFSIGNALED (status))
break;
} while (ret != -1 || errno != ECHILD);
if (debug_threads)
fprintf (stderr, "Checking for breakpoint in lwp %ld.\n",
- event_child->lwpid);
+ lwpid_of (event_child));
saved_inferior = current_inferior;
current_inferior = get_lwp_thread (event_child);
{
struct lwp_info *lwp = (struct lwp_info *) entry;
- if (lwp->status_pending_p)
+ if (lwp->status_pending_p && !lwp->suspended)
if (check_removed_breakpoint (lwp))
{
/* This thread was stopped at a breakpoint, and the breakpoint
return 0;
}
- return lwp->status_pending_p;
+ return (lwp->status_pending_p && !lwp->suspended);
}
-static void
-linux_wait_for_lwp (struct lwp_info **childp, int *wstatp)
+static struct lwp_info *
+linux_wait_for_lwp (int pid, int *wstatp, int options)
{
int ret;
- int to_wait_for = -1;
-
- if (*childp != NULL)
- to_wait_for = (*childp)->lwpid;
-
-retry:
- while (1)
- {
- ret = waitpid (to_wait_for, wstatp, WNOHANG);
+ int to_wait_for = pid;
+ struct lwp_info *child = NULL;
- if (ret == -1)
- {
- if (errno != ECHILD)
- perror_with_name ("waitpid");
- }
- else if (ret > 0)
- break;
+ if (debug_threads)
+ fprintf (stderr, "linux_wait_for_lwp: %d\n", pid);
- ret = waitpid (to_wait_for, wstatp, WNOHANG | __WCLONE);
+ options |= __WALL;
- if (ret == -1)
- {
- if (errno != ECHILD)
- perror_with_name ("waitpid (WCLONE)");
- }
- else if (ret > 0)
- break;
+retry:
- usleep (1000);
- }
+ ret = my_waitpid (to_wait_for, wstatp, options);
+ if (ret == 0 || (ret == -1 && errno == ECHILD && (options & WNOHANG)))
+ return NULL;
+ else if (ret == -1)
+ perror_with_name ("waitpid");
if (debug_threads
&& (!WIFSTOPPED (*wstatp)
&& WSTOPSIG (*wstatp) != 33)))
fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
- if (to_wait_for == -1)
- *childp = (struct lwp_info *) find_inferior_id (&all_lwps, ret);
+ child = (struct lwp_info *) find_inferior_id (&all_lwps, ret);
/* If we didn't find a process, one of two things presumably happened:
- A process we started and then detached from has exited. Ignore it.
- A process we are controlling has forked and the new child's stop
was reported to us by the kernel. Save its PID. */
- if (*childp == NULL && WIFSTOPPED (*wstatp))
+ if (child == NULL && WIFSTOPPED (*wstatp))
{
add_pid_to_list (&stopped_pids, ret);
goto retry;
}
- else if (*childp == NULL)
+ else if (child == NULL)
goto retry;
- (*childp)->stopped = 1;
- (*childp)->pending_is_breakpoint = 0;
+ child->stopped = 1;
+ child->pending_is_breakpoint = 0;
- (*childp)->last_status = *wstatp;
+ child->last_status = *wstatp;
/* Architecture-specific setup after inferior is running.
This needs to happen after we have attached to the inferior
{
struct thread_info *saved_inferior = current_inferior;
current_inferior = (struct thread_info *)
- find_inferior_id (&all_threads, (*childp)->lwpid);
+ find_inferior_id (&all_threads, lwpid_of (child));
/* For testing only; i386_stop_pc prints out a diagnostic. */
if (the_low_target.get_pc != NULL)
get_stop_pc ();
current_inferior = saved_inferior;
}
+
+ return child;
}
+/* Wait for an event from child PID. If PID is -1, wait for any
+ child. Store the stop status through the status pointer WSTAT.
+ OPTIONS is passed to the waitpid call. Return 0 if no child stop
+ event was found and OPTIONS contains WNOHANG. Return the PID of
+ the stopped child otherwise. */
+
static int
-linux_wait_for_event (struct thread_info *child)
+linux_wait_for_event (int pid, int *wstat, int options)
{
CORE_ADDR stop_pc;
- struct lwp_info *event_child;
- int wstat;
+ struct lwp_info *event_child = NULL;
int bp_status;
+ struct lwp_info *requested_child = NULL;
/* Check for a process with a pending status. */
/* It is possible that the user changed the pending task's registers since
it stopped. We correctly handle the change of PC if we hit a breakpoint
(in check_removed_breakpoint); signals should be reported anyway. */
- if (child == NULL)
+
+ if (pid == -1)
{
event_child = (struct lwp_info *)
find_inferior (&all_lwps, status_pending_p, NULL);
if (debug_threads && event_child)
- fprintf (stderr, "Got a pending child %ld\n", event_child->lwpid);
+ fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
}
else
{
- event_child = get_thread_lwp (child);
- if (event_child->status_pending_p
- && check_removed_breakpoint (event_child))
- event_child = NULL;
+ requested_child = (struct lwp_info *)
+ find_inferior_id (&all_lwps, pid);
+ if (requested_child->status_pending_p
+ && !check_removed_breakpoint (requested_child))
+ event_child = requested_child;
}
if (event_child != NULL)
{
- if (event_child->status_pending_p)
- {
- if (debug_threads)
- fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
- event_child->lwpid, event_child->status_pending);
- wstat = event_child->status_pending;
- event_child->status_pending_p = 0;
- event_child->status_pending = 0;
- current_inferior = get_lwp_thread (event_child);
- return wstat;
- }
+ if (debug_threads)
+ fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
+ lwpid_of (event_child), event_child->status_pending);
+ *wstat = event_child->status_pending;
+ event_child->status_pending_p = 0;
+ event_child->status_pending = 0;
+ current_inferior = get_lwp_thread (event_child);
+ return lwpid_of (event_child);
}
/* We only enter this loop if no process has a pending wait status. Thus
events. */
while (1)
{
- if (child == NULL)
- event_child = NULL;
- else
- event_child = get_thread_lwp (child);
+ event_child = linux_wait_for_lwp (pid, wstat, options);
- linux_wait_for_lwp (&event_child, &wstat);
+ if ((options & WNOHANG) && event_child == NULL)
+ return 0;
if (event_child == NULL)
error ("event from unknown child");
- current_inferior = (struct thread_info *)
- find_inferior_id (&all_threads, event_child->lwpid);
+ current_inferior = get_lwp_thread (event_child);
/* Check for thread exit. */
- if (! WIFSTOPPED (wstat))
+ if (! WIFSTOPPED (*wstat))
{
+ int lwpid = lwpid_of (event_child);
if (debug_threads)
- fprintf (stderr, "LWP %ld exiting\n", event_child->head.id);
+ fprintf (stderr, "LWP %d exiting\n", lwpid);
/* If the last thread is exiting, just return. */
if (all_threads.head == all_threads.tail)
- return wstat;
+ {
+ if (debug_threads)
+ fprintf (stderr, "LWP %d is last lwp of process\n", lwpid);
+ return lwpid_of (event_child);
+ }
- dead_thread_notify (thread_id_to_gdb_id (event_child->lwpid));
+ dead_thread_notify (thread_id_to_gdb_id (lwpid_of (event_child)));
+ delete_lwp (event_child);
- remove_inferior (&all_lwps, &event_child->head);
- free (event_child);
- remove_thread (current_inferior);
- current_inferior = (struct thread_info *) all_threads.head;
+ if (!non_stop)
+ {
+ current_inferior = (struct thread_info *) all_threads.head;
+ if (debug_threads)
+ fprintf (stderr, "Current inferior is now %ld\n",
+ lwpid_of (get_thread_lwp (current_inferior)));
+ }
+ else
+ {
+ current_inferior = NULL;
+ if (debug_threads)
+ fprintf (stderr, "Current inferior is now <NULL>\n");
+ }
/* If we were waiting for this particular child to do something...
well, it did something. */
- if (child != NULL)
- return wstat;
+ if (requested_child != NULL)
+ return lwpid;
/* Wait for a more interesting event. */
continue;
}
- if (WIFSTOPPED (wstat)
- && WSTOPSIG (wstat) == SIGSTOP
+ if (WIFSTOPPED (*wstat)
+ && WSTOPSIG (*wstat) == SIGSTOP
&& event_child->stop_expected)
{
if (debug_threads)
continue;
}
- if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
- && wstat >> 16 != 0)
+ if (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) == SIGTRAP
+ && *wstat >> 16 != 0)
{
- handle_extended_wait (event_child, wstat);
+ handle_extended_wait (event_child, *wstat);
continue;
}
special handling to skip the signal handler. */
/* FIXME drow/2002-06-09: Get signal numbers from the inferior's
thread library? */
- if (WIFSTOPPED (wstat)
+ if (WIFSTOPPED (*wstat)
&& !event_child->stepping
&& (
#ifdef USE_THREAD_DB
- (thread_db_active && (WSTOPSIG (wstat) == __SIGRTMIN
- || WSTOPSIG (wstat) == __SIGRTMIN + 1))
+ (thread_db_active
+ && (WSTOPSIG (*wstat) == __SIGRTMIN
+ || WSTOPSIG (*wstat) == __SIGRTMIN + 1))
||
#endif
- (pass_signals[target_signal_from_host (WSTOPSIG (wstat))]
- && (WSTOPSIG (wstat) != SIGSTOP || !stopping_threads))))
+ (pass_signals[target_signal_from_host (WSTOPSIG (*wstat))]
+ && (WSTOPSIG (*wstat) != SIGSTOP || !stopping_threads))))
{
siginfo_t info, *info_p;
if (debug_threads)
fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
- WSTOPSIG (wstat), event_child->head.id);
+ WSTOPSIG (*wstat), lwpid_of (event_child));
- if (ptrace (PTRACE_GETSIGINFO, event_child->lwpid, 0, &info) == 0)
+ if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), 0, &info) == 0)
info_p = &info;
else
info_p = NULL;
linux_resume_one_lwp (&event_child->head,
event_child->stepping,
- WSTOPSIG (wstat), info_p);
+ WSTOPSIG (*wstat), info_p);
continue;
}
/* If this event was not handled above, and is not a SIGTRAP, report
it. */
- if (!WIFSTOPPED (wstat) || WSTOPSIG (wstat) != SIGTRAP)
- return wstat;
+ if (!WIFSTOPPED (*wstat) || WSTOPSIG (*wstat) != SIGTRAP)
+ return lwpid_of (event_child);
/* If this target does not support breakpoints, we simply report the
SIGTRAP; it's of no concern to us. */
if (the_low_target.get_pc == NULL)
- return wstat;
+ return lwpid_of (event_child);
stop_pc = get_stop_pc ();
Otherwise, call the target function to figure out where we need
our temporary breakpoint, create it, and continue executing this
process. */
+
+ /* NOTE: we're lifting breakpoints in non-stop mode. This
+ is currently only used for thread event breakpoints, so
+ it isn't that bad as long as we have PTRACE_EVENT_CLONE
+ events. */
if (bp_status == 2)
/* No need to reinsert. */
linux_resume_one_lwp (&event_child->head, 0, 0, NULL);
do not clear clear the stepping flag yet; we need to check it
in wait_for_sigstop. */
if (event_child->stepping)
- return wstat;
+ return lwpid_of (event_child);
/* A SIGTRAP that we can't explain. It may have been a breakpoint.
Check if it is a breakpoint, and if so mark the process information
event_child->pending_stop_pc = stop_pc;
}
- return wstat;
+ return lwpid_of (event_child);
}
/* NOTREACHED */
/* Wait for process, returns status. */
static unsigned long
-linux_wait (struct target_waitstatus *ourstatus)
+linux_wait_1 (struct target_waitstatus *ourstatus, int target_options)
{
int w;
- struct thread_info *child = NULL;
- struct lwp_info *lwp;
+ struct thread_info *thread = NULL;
+ struct lwp_info *lwp = NULL;
+ int options;
+ int wait_pid = -1;
+ int pid;
+
+ /* Translate generic target options into linux options. */
+ options = __WALL;
+ if (target_options & TARGET_WNOHANG)
+ options |= WNOHANG;
retry:
+ ourstatus->kind = TARGET_WAITKIND_IGNORE;
+
/* If we were only supposed to resume one thread, only wait for
that thread - if it's still alive. If it died, however - which
can happen if we're coming from the thread death case below -
then we need to make sure we restart the other threads. We could
pick a thread at random or restart all; restarting all is less
arbitrary. */
- if (cont_thread != 0 && cont_thread != -1)
+ if (!non_stop && cont_thread != 0 && cont_thread != -1)
{
- child = (struct thread_info *) find_inferior_id (&all_threads,
- cont_thread);
+ thread = (struct thread_info *) find_inferior_id (&all_threads,
+ cont_thread);
/* No stepping, no signal - unless one is pending already, of course. */
- if (child == NULL)
+ if (thread == NULL)
{
struct thread_resume resume_info;
resume_info.thread = -1;
- resume_info.step = resume_info.sig = 0;
+ resume_info.kind = resume_continue;
+ resume_info.sig = 0;
linux_resume (&resume_info, 1);
}
+ else
+ wait_pid = cont_thread;
}
- w = linux_wait_for_event (child);
- stop_all_lwps ();
+ pid = linux_wait_for_event (wait_pid, &w, options);
+ if (pid == 0) /* only if TARGET_WNOHANG */
+ return pid;
+
+ lwp = get_thread_lwp (current_inferior);
if (must_set_ptrace_flags)
{
- ptrace (PTRACE_SETOPTIONS, inferior_pid, 0, PTRACE_O_TRACECLONE);
+ ptrace (PTRACE_SETOPTIONS, lwpid_of (lwp), 0, PTRACE_O_TRACECLONE);
must_set_ptrace_flags = 0;
}
-
- lwp = get_thread_lwp (current_inferior);
-
/* If we are waiting for a particular child, and it exited,
linux_wait_for_event will return its exit status. Similarly if
the last child exited. If this is not the last child, however,
if (all_threads.head == all_threads.tail)
{
- int pid = pid_of (lwp);
- if (WIFEXITED (w))
+ if (WIFEXITED (w) || WIFSIGNALED (w))
{
- if (debug_threads)
- fprintf (stderr, "\nChild exited with retcode = %x \n",
- WEXITSTATUS (w));
+ int pid;
+
+ pid = pid_of (lwp);
- ourstatus->kind = TARGET_WAITKIND_EXITED;
- ourstatus->value.integer = WEXITSTATUS (w);
+ delete_lwp (lwp);
clear_inferiors ();
- free (all_lwps.head);
- all_lwps.head = all_lwps.tail = NULL;
- return pid;
- }
- else if (!WIFSTOPPED (w))
- {
- if (debug_threads)
- fprintf (stderr, "\nChild terminated with signal = %x \n",
- WTERMSIG (w));
+ current_inferior = NULL;
- ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
- ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
- clear_inferiors ();
- free (all_lwps.head);
- all_lwps.head = all_lwps.tail = NULL;
+ if (WIFEXITED (w))
+ {
+ ourstatus->kind = TARGET_WAITKIND_EXITED;
+ ourstatus->value.integer = WEXITSTATUS (w);
+
+ if (debug_threads)
+ fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
+ }
+ else
+ {
+ ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+ ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
+
+ if (debug_threads)
+ fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
+
+ }
return pid;
}
goto retry;
}
+ /* In all-stop, stop all threads. Be careful to only do this if
+ we're about to report an event to GDB. */
+ if (!non_stop)
+ stop_all_lwps ();
+
ourstatus->kind = TARGET_WAITKIND_STOPPED;
- ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
- return lwp->lwpid;
+ if (lwp->suspended && WSTOPSIG (w) == SIGSTOP)
+ {
+ /* A thread that has been requested to stop by GDB with vCont;t,
+ and it stopped cleanly, so report as SIG0. The use of
+ SIGSTOP is an implementation detail. */
+ ourstatus->value.sig = TARGET_SIGNAL_0;
+ }
+ else if (lwp->suspended && WSTOPSIG (w) != SIGSTOP)
+ {
+ /* A thread that has been requested to stop by GDB with vCont;t,
+ but, it stopped for other reasons. Set stop_expected so the
+ pending SIGSTOP is ignored and the LWP is resumed. */
+ lwp->stop_expected = 1;
+ ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
+ }
+ else
+ {
+ ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
+ }
+
+ if (debug_threads)
+ fprintf (stderr, "linux_wait ret = %ld, %d, %d\n",
+ lwpid_of (lwp),
+ ourstatus->kind,
+ ourstatus->value.sig);
+
+ return lwpid_of (lwp);
+}
+
+/* Get rid of any pending event in the pipe. */
+static void
+async_file_flush (void)
+{
+ int ret;
+ char buf;
+
+ do
+ ret = read (linux_event_pipe[0], &buf, 1);
+ while (ret >= 0 || (ret == -1 && errno == EINTR));
+}
+
+/* Put something in the pipe, so the event loop wakes up. */
+static void
+async_file_mark (void)
+{
+ int ret;
+
+ async_file_flush ();
+
+ do
+ ret = write (linux_event_pipe[1], "+", 1);
+ while (ret == 0 || (ret == -1 && errno == EINTR));
+
+ /* Ignore EAGAIN. If the pipe is full, the event loop will already
+ be awakened anyway. */
+}
+
+static unsigned long
+linux_wait (struct target_waitstatus *ourstatus, int target_options)
+{
+ unsigned long event_ptid;
+
+ if (debug_threads)
+ fprintf (stderr, "linux_wait\n");
+
+ /* Flush the async file first. */
+ if (target_is_async_p ())
+ async_file_flush ();
+
+ event_ptid = linux_wait_1 (ourstatus, target_options);
+
+ /* If at least one stop was reported, there may be more. A single
+ SIGCHLD can signal more than one child stop. */
+ if (target_is_async_p ()
+ && (target_options & TARGET_WNOHANG) != 0
+ && event_ptid != 0)
+ async_file_mark ();
+
+ return event_ptid;
}
/* Send a signal to an LWP. For LinuxThreads, kill is enough; however, if
send_sigstop (struct inferior_list_entry *entry)
{
struct lwp_info *lwp = (struct lwp_info *) entry;
+ int pid;
if (lwp->stopped)
return;
+ pid = lwpid_of (lwp);
+
/* If we already have a pending stop signal for this process, don't
send another. */
if (lwp->stop_expected)
{
if (debug_threads)
- fprintf (stderr, "Have pending sigstop for lwp %ld\n",
- lwp->lwpid);
+ fprintf (stderr, "Have pending sigstop for lwp %d\n", pid);
/* We clear the stop_expected flag so that wait_for_sigstop
will receive the SIGSTOP event (instead of silently resuming and
}
if (debug_threads)
- fprintf (stderr, "Sending sigstop to lwp %ld\n", lwp->head.id);
+ fprintf (stderr, "Sending sigstop to lwp %d\n", pid);
- kill_lwp (lwp->head.id, SIGSTOP);
+ kill_lwp (pid, SIGSTOP);
}
static void
wait_for_sigstop (struct inferior_list_entry *entry)
{
struct lwp_info *lwp = (struct lwp_info *) entry;
- struct thread_info *saved_inferior, *thread;
+ struct thread_info *saved_inferior;
int wstat;
unsigned long saved_tid;
+ unsigned long ptid;
if (lwp->stopped)
return;
saved_inferior = current_inferior;
- saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
- thread = (struct thread_info *) find_inferior_id (&all_threads,
- lwp->lwpid);
- wstat = linux_wait_for_event (thread);
+ if (saved_inferior != NULL)
+ saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
+ else
+ saved_tid = 0; /* avoid bogus unused warning */
+
+ ptid = lwpid_of (lwp);
+
+ linux_wait_for_event (ptid, &wstat, __WALL);
/* If we stopped with a non-SIGSTOP signal, save it for later
and record the pending SIGSTOP. If the process exited, just
{
if (debug_threads)
fprintf (stderr, "LWP %ld stopped with non-sigstop status %06x\n",
- lwp->lwpid, wstat);
+ lwpid_of (lwp), wstat);
/* Do not leave a pending single-step finish to be reported to
the client. The client will give us a new action for this
lwp->stop_expected = 1;
}
- if (linux_thread_alive (saved_tid))
+ if (saved_inferior == NULL || linux_thread_alive (saved_tid))
current_inferior = saved_inferior;
else
{
if (debug_threads)
fprintf (stderr, "Previously current thread died.\n");
- /* Set a valid thread as current. */
- set_desired_inferior (0);
+ if (non_stop)
+ {
+ /* We can't change the current inferior behind GDB's back,
+ otherwise, a subsequent command may apply to the wrong
+ process. */
+ current_inferior = NULL;
+ }
+ else
+ {
+ /* Set a valid thread as current. */
+ set_desired_inferior (0);
+ }
}
}
if (debug_threads)
fprintf (stderr, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
- inferior_pid, step ? "step" : "continue", signal,
+ lwpid_of (lwp), step ? "step" : "continue", signal,
lwp->stop_expected ? "expected" : "not expected");
/* This bit needs some thinking about. If we get a signal that
signal = (*p_sig)->signal;
if ((*p_sig)->info.si_signo != 0)
- ptrace (PTRACE_SETSIGINFO, lwp->lwpid, 0, &(*p_sig)->info);
+ ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
free (*p_sig);
*p_sig = NULL;
errno = 0;
lwp->stopped = 0;
lwp->stepping = step;
- ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwp->lwpid, 0, signal);
+ ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), 0, signal);
current_inferior = saved_inferior;
if (errno)
return 0;
}
-/* This function is called once per thread. We check the thread's resume
- request, which will tell us whether to resume, step, or leave the thread
- stopped; and what signal, if any, it should be sent. For threads which
- we aren't explicitly told otherwise, we preserve the stepping flag; this
- is used for stepping over gdbserver-placed breakpoints. */
-static void
-linux_continue_one_thread (struct inferior_list_entry *entry)
+/* Set *FLAG_P if this lwp has an interesting status pending. */
+static int
+resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
{
- struct lwp_info *lwp;
- struct thread_info *thread;
- int step;
-
- thread = (struct thread_info *) entry;
- lwp = get_thread_lwp (thread);
+ struct lwp_info *lwp = (struct lwp_info *) entry;
+ /* LWPs which will not be resumed are not interesting, because
+ we might not wait for them next time through linux_wait. */
if (lwp->resume == NULL)
- return;
+ return 0;
- if (lwp->resume->thread == -1
- && lwp->stepping
- && lwp->pending_is_breakpoint)
- step = 1;
- else
- step = lwp->resume->step;
+ /* If this thread has a removed breakpoint, we won't have any
+ events to report later, so check now. check_removed_breakpoint
+ may clear status_pending_p. We avoid calling check_removed_breakpoint
+ for any thread that we are not otherwise going to resume - this
+ lets us preserve stopped status when two threads hit a breakpoint.
+ GDB removes the breakpoint to single-step a particular thread
+ past it, then re-inserts it and resumes all threads. We want
+ to report the second thread without resuming it in the interim. */
+ if (lwp->status_pending_p)
+ check_removed_breakpoint (lwp);
- linux_resume_one_lwp (&lwp->head, step, lwp->resume->sig, NULL);
+ if (lwp->status_pending_p)
+ * (int *) flag_p = 1;
- lwp->resume = NULL;
+ return 0;
}
/* This function is called once per thread. We check the thread's resume
request, which will tell us whether to resume, step, or leave the thread
- stopped; and what signal, if any, it should be sent. We queue any needed
- signals, since we won't actually resume. We already have a pending event
- to report, so we don't need to preserve any step requests; they should
- be re-issued if necessary. */
+ stopped; and what signal, if any, it should be sent.
-static void
-linux_queue_one_thread (struct inferior_list_entry *entry)
+ For threads which we aren't explicitly told otherwise, we preserve
+ the stepping flag; this is used for stepping over gdbserver-placed
+ breakpoints.
+
+ If pending_flags was set in any thread, we queue any needed
+ signals, since we won't actually resume. We already have a pending
+ event to report, so we don't need to preserve any step requests;
+ they should be re-issued if necessary. */
+
+static int
+linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
{
struct lwp_info *lwp;
struct thread_info *thread;
+ int step;
+ int pending_flag = * (int *) arg;
thread = (struct thread_info *) entry;
lwp = get_thread_lwp (thread);
if (lwp->resume == NULL)
- return;
+ return 0;
- /* If we have a new signal, enqueue the signal. */
- if (lwp->resume->sig != 0)
+ if (lwp->resume->kind == resume_stop)
{
- struct pending_signals *p_sig;
- p_sig = xmalloc (sizeof (*p_sig));
- p_sig->prev = lwp->pending_signals;
- p_sig->signal = lwp->resume->sig;
- memset (&p_sig->info, 0, sizeof (siginfo_t));
+ if (debug_threads)
+ fprintf (stderr, "suspending LWP %ld\n", lwpid_of (lwp));
+
+ if (!lwp->stopped)
+ {
+ if (debug_threads)
+ fprintf (stderr, "running -> suspending %ld\n", lwpid_of (lwp));
+
+ lwp->suspended = 1;
+ send_sigstop (&lwp->head);
+ }
+ else
+ {
+ if (debug_threads)
+ {
+ if (lwp->suspended)
+ fprintf (stderr, "already stopped/suspended LWP %ld\n",
+ lwpid_of (lwp));
+ else
+ fprintf (stderr, "already stopped/not suspended LWP %ld\n",
+ lwpid_of (lwp));
+ }
- /* If this is the same signal we were previously stopped by,
- make sure to queue its siginfo. We can ignore the return
- value of ptrace; if it fails, we'll skip
- PTRACE_SETSIGINFO. */
- if (WIFSTOPPED (lwp->last_status)
- && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
- ptrace (PTRACE_GETSIGINFO, lwp->lwpid, 0, &p_sig->info);
+ /* Make sure we leave the LWP suspended, so we don't try to
+ resume it without GDB telling us to. FIXME: The LWP may
+ have been stopped in an internal event that was not meant
+ to be notified back to GDB (e.g., gdbserver breakpoint),
+ so we should be reporting a stop event in that case
+ too. */
+ lwp->suspended = 1;
+ }
- lwp->pending_signals = p_sig;
+ /* For stop requests, we're done. */
+ lwp->resume = NULL;
+ return 0;
}
+ else
+ lwp->suspended = 0;
- lwp->resume = NULL;
-}
+ /* If this thread which is about to be resumed has a pending status,
+ then don't resume any threads - we can just report the pending
+ status. Make sure to queue any signals that would otherwise be
+ sent. In all-stop mode, we do this decision based on if *any*
+ thread has a pending status. */
+ if (non_stop)
+ resume_status_pending_p (&lwp->head, &pending_flag);
-/* Set DUMMY if this process has an interesting status pending. */
-static int
-resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
-{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ if (!pending_flag)
+ {
+ if (debug_threads)
+ fprintf (stderr, "resuming LWP %ld\n", lwpid_of (lwp));
- /* Processes which will not be resumed are not interesting, because
- we might not wait for them next time through linux_wait. */
- if (lwp->resume == NULL)
- return 0;
+ if (lwp->resume->thread == -1
+ && lwp->stepping
+ && lwp->pending_is_breakpoint)
+ step = 1;
+ else
+ step = (lwp->resume->kind == resume_step);
- /* If this thread has a removed breakpoint, we won't have any
- events to report later, so check now. check_removed_breakpoint
- may clear status_pending_p. We avoid calling check_removed_breakpoint
- for any thread that we are not otherwise going to resume - this
- lets us preserve stopped status when two threads hit a breakpoint.
- GDB removes the breakpoint to single-step a particular thread
- past it, then re-inserts it and resumes all threads. We want
- to report the second thread without resuming it in the interim. */
- if (lwp->status_pending_p)
- check_removed_breakpoint (lwp);
+ linux_resume_one_lwp (&lwp->head, step, lwp->resume->sig, NULL);
+ }
+ else
+ {
+ if (debug_threads)
+ fprintf (stderr, "leaving LWP %ld stopped\n", lwpid_of (lwp));
- if (lwp->status_pending_p)
- * (int *) flag_p = 1;
+ /* If we have a new signal, enqueue the signal. */
+ if (lwp->resume->sig != 0)
+ {
+ struct pending_signals *p_sig;
+ p_sig = xmalloc (sizeof (*p_sig));
+ p_sig->prev = lwp->pending_signals;
+ p_sig->signal = lwp->resume->sig;
+ memset (&p_sig->info, 0, sizeof (siginfo_t));
+
+ /* If this is the same signal we were previously stopped by,
+ make sure to queue its siginfo. We can ignore the return
+ value of ptrace; if it fails, we'll skip
+ PTRACE_SETSIGINFO. */
+ if (WIFSTOPPED (lwp->last_status)
+ && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
+ ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
+
+ lwp->pending_signals = p_sig;
+ }
+ }
+ lwp->resume = NULL;
return 0;
}
/* If there is a thread which would otherwise be resumed, which
has a pending status, then don't resume any threads - we can just
report the pending status. Make sure to queue any signals
- that would otherwise be sent. */
+ that would otherwise be sent. In non-stop mode, we'll apply this
+ logic to each thread individually. */
pending_flag = 0;
- find_inferior (&all_lwps, resume_status_pending_p, &pending_flag);
+ if (!non_stop)
+ find_inferior (&all_lwps, resume_status_pending_p, &pending_flag);
if (debug_threads)
{
fprintf (stderr, "Resuming, no pending status\n");
}
- if (pending_flag)
- for_each_inferior (&all_threads, linux_queue_one_thread);
- else
- for_each_inferior (&all_threads, linux_continue_one_thread);
+ find_inferior (&all_threads, linux_resume_one_thread, &pending_flag);
}
#ifdef HAVE_LINUX_USRREGS
_exit (0);
}
-/* Wrapper function for waitpid which handles EINTR. */
+/* Wrapper function for waitpid which handles EINTR, and emulates
+ __WALL for systems where that is not available. */
static int
my_waitpid (int pid, int *status, int flags)
{
- int ret;
- do
+ int ret, out_errno;
+
+ if (debug_threads)
+ fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
+
+ if (flags & __WALL)
{
- ret = waitpid (pid, status, flags);
+ sigset_t block_mask, org_mask, wake_mask;
+ int wnohang;
+
+ wnohang = (flags & WNOHANG) != 0;
+ flags &= ~(__WALL | __WCLONE);
+ flags |= WNOHANG;
+
+ /* Block all signals while here. This avoids knowing about
+ LinuxThread's signals. */
+ sigfillset (&block_mask);
+ sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
+
+ /* ... except during the sigsuspend below. */
+ sigemptyset (&wake_mask);
+
+ while (1)
+ {
+ /* Since all signals are blocked, there's no need to check
+ for EINTR here. */
+ ret = waitpid (pid, status, flags);
+ out_errno = errno;
+
+ if (ret == -1 && out_errno != ECHILD)
+ break;
+ else if (ret > 0)
+ break;
+
+ if (flags & __WCLONE)
+ {
+ /* We've tried both flavors now. If WNOHANG is set,
+ there's nothing else to do, just bail out. */
+ if (wnohang)
+ break;
+
+ if (debug_threads)
+ fprintf (stderr, "blocking\n");
+
+ /* Block waiting for signals. */
+ sigsuspend (&wake_mask);
+ }
+
+ flags ^= __WCLONE;
+ }
+
+ sigprocmask (SIG_SETMASK, &org_mask, NULL);
}
- while (ret == -1 && errno == EINTR);
+ else
+ {
+ do
+ ret = waitpid (pid, status, flags);
+ while (ret == -1 && errno == EINTR);
+ out_errno = errno;
+ }
+
+ if (debug_threads)
+ fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
+ pid, flags, status ? *status : -1, ret);
+ errno = out_errno;
return ret;
}
if (cont_thread != 0 && cont_thread != -1)
{
struct lwp_info *lwp;
+ int lwpid;
lwp = get_thread_lwp (current_inferior);
- kill_lwp (lwp->lwpid, SIGINT);
+ lwpid = lwpid_of (lwp);
+ kill_lwp (lwpid, SIGINT);
}
else
kill_lwp (signal_pid, SIGINT);
{
#if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
unsigned long text, text_end, data;
- int pid = get_thread_lwp (current_inferior)->head.id;
+ int pid = lwpid_of (get_thread_lwp (current_inferior));
errno = 0;
if (current_inferior == NULL)
return -1;
- pid = pid_of (get_thread_lwp (current_inferior));
+ pid = lwpid_of (get_thread_lwp (current_inferior));
if (debug_threads)
fprintf (stderr, "%s siginfo for lwp %ld.\n",
return len;
}
+/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
+ so we notice when children change state; as the handler for the
+ sigsuspend in my_waitpid. */
+
+static void
+sigchld_handler (int signo)
+{
+ int old_errno = errno;
+
+ if (debug_threads)
+ /* fprintf is not async-signal-safe, so call write directly. */
+ write (2, "sigchld_handler\n", sizeof ("sigchld_handler\n") - 1);
+
+ if (target_is_async_p ())
+ async_file_mark (); /* trigger a linux_wait */
+
+ errno = old_errno;
+}
+
+static int
+linux_supports_non_stop (void)
+{
+ return 1;
+}
+
+static int
+linux_async (int enable)
+{
+ int previous = (linux_event_pipe[0] != -1);
+
+ if (previous != enable)
+ {
+ sigset_t mask;
+ sigemptyset (&mask);
+ sigaddset (&mask, SIGCHLD);
+
+ sigprocmask (SIG_BLOCK, &mask, NULL);
+
+ if (enable)
+ {
+ if (pipe (linux_event_pipe) == -1)
+ fatal ("creating event pipe failed.");
+
+ fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
+ fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
+
+ /* Register the event loop handler. */
+ add_file_handler (linux_event_pipe[0],
+ handle_target_event, NULL);
+
+ /* Always trigger a linux_wait. */
+ async_file_mark ();
+ }
+ else
+ {
+ delete_file_handler (linux_event_pipe[0]);
+
+ close (linux_event_pipe[0]);
+ close (linux_event_pipe[1]);
+ linux_event_pipe[0] = -1;
+ linux_event_pipe[1] = -1;
+ }
+
+ sigprocmask (SIG_UNBLOCK, &mask, NULL);
+ }
+
+ return previous;
+}
+
+static int
+linux_start_non_stop (int nonstop)
+{
+ /* Register or unregister from event-loop accordingly. */
+ linux_async (nonstop);
+ return 0;
+}
+
static struct target_ops linux_target_ops = {
linux_create_inferior,
linux_attach,
hostio_last_error_from_errno,
linux_qxfer_osdata,
linux_xfer_siginfo,
+ linux_supports_non_stop,
+ linux_async,
+ linux_start_non_stop,
};
static void
void
initialize_low (void)
{
+ struct sigaction sigchld_action;
+ memset (&sigchld_action, 0, sizeof (sigchld_action));
thread_db_active = 0;
set_target_ops (&linux_target_ops);
set_breakpoint_data (the_low_target.breakpoint,
;
disabled_regsets = xmalloc (num_regsets);
#endif
+
+ sigchld_action.sa_handler = sigchld_handler;
+ sigemptyset (&sigchld_action.sa_mask);
+ sigchld_action.sa_flags = SA_RESTART;
+ sigaction (SIGCHLD, &sigchld_action, NULL);
}
extern struct linux_target_ops the_low_target;
+#define pid_of(proc) ((proc)->head.id)
+#define lwpid_of(proc) ((proc)->head.id)
+
#define get_lwp(inf) ((struct lwp_info *)(inf))
#define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr)))
#define get_lwp_thread(proc) ((struct thread_info *) \
find_inferior_id (&all_threads, \
- get_lwp (proc)->lwpid))
+ lwpid_of (get_lwp (proc))))
struct lwp_info
{
struct inferior_list_entry head;
- unsigned long lwpid;
/* If this flag is set, the next SIGSTOP will be ignored (the
process will be immediately resumed). This means that either we
yet. */
int stop_expected;
- /* If this flag is set, the process is known to be stopped right now (stop
+ /* True if this thread was suspended (with vCont;t). */
+ int suspended;
+
+ /* If this flag is set, the lwp is known to be stopped right now (stop
event already received in a wait()). */
int stopped;
- /* When stopped is set, the last wait status recorded for this process. */
+ /* When stopped is set, the last wait status recorded for this lwp. */
int last_status;
/* If this flag is set, STATUS_PENDING is a waitstatus that has not yet
fcntl (remote_desc, F_SETOWN, getpid ());
#endif
#endif
+
+ /* Register the event loop handler. */
+ add_file_handler (remote_desc, handle_serial_event, NULL);
}
void
remote_close (void)
{
+ delete_file_handler (remote_desc);
+
#ifdef USE_WIN32API
closesocket (remote_desc);
#else
The data of the packet is in BUF, and the length of the
packet is in CNT. Returns >= 0 on success, -1 otherwise. */
-int
-putpkt_binary (char *buf, int cnt)
+static int
+putpkt_binary_1 (char *buf, int cnt, int is_notif)
{
int i;
unsigned char csum = 0;
and giving it a checksum. */
p = buf2;
- *p++ = '$';
+ if (is_notif)
+ *p++ = '%';
+ else
+ *p++ = '$';
for (i = 0; i < cnt;)
i += try_rle (buf + i, cnt - i, &csum, &p);
return -1;
}
- if (noack_mode)
+ if (noack_mode || is_notif)
{
/* Don't expect an ack then. */
if (remote_debug)
{
- fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
+ if (is_notif)
+ fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
+ else
+ fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
fflush (stderr);
}
break;
return 1; /* Success! */
}
+int
+putpkt_binary (char *buf, int cnt)
+{
+ return putpkt_binary_1 (buf, cnt, 0);
+}
+
/* Send a packet to the remote machine, with error checking. The data
of the packet is in BUF, and the packet should be a NUL-terminated
string. Returns >= 0 on success, -1 otherwise. */
return putpkt_binary (buf, strlen (buf));
}
+int
+putpkt_notif (char *buf)
+{
+ return putpkt_binary_1 (buf, strlen (buf), 1);
+}
+
/* Come here when we get an input interrupt from the remote side. This
interrupt should only be active while we are waiting for the child to do
something. About the only thing that should come through is a ^C, which
gdbserver to know what inferior_ptid is. */
if (1 || general_thread != ptid)
{
- general_thread = ptid;
+ /* In non-stop, don't change the general thread behind
+ GDB's back. */
+ if (!non_stop)
+ general_thread = ptid;
sprintf (buf, "thread:%lx;", ptid);
buf += strlen (buf);
}
static int response_needed;
static int exit_requested;
+int non_stop;
+
static char **program_argv, **wrapper_argv;
/* Enable miscellaneous debugging output. The name is historical - it
static struct target_waitstatus last_status;
static unsigned long 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. */
+struct vstop_notif
+{
+ /* Pointer to next in list. */
+ struct vstop_notif *next;
+
+ /* Thread or process that got the event. */
+ unsigned long ptid;
+
+ /* Event info. */
+ struct target_waitstatus status;
+};
+
+/* The pending stop replies list head. */
+static struct vstop_notif *notif_queue = NULL;
+
+/* Put a stop reply to the stop reply queue. */
+
+static void
+queue_stop_reply (unsigned long ptid, struct target_waitstatus *status)
+{
+ struct vstop_notif *new_notif;
+
+ new_notif = malloc (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);
+ }
+}
+
+/* Place an event in the stop reply queue, and push a notification if
+ we aren't sending one yet. */
+
+void
+push_event (unsigned long ptid, struct target_waitstatus *status)
+{
+ 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)
+ {
+ char *p = own_buf;
+ strcpy (p, "Stop:");
+ p += strlen (p);
+ prepare_resume_reply (p,
+ notif_queue->ptid, ¬if_queue->status);
+ putpkt_notif (own_buf);
+ }
+}
+
+/* Get rid of the currently pending stop replies. */
+
+static void
+discard_queued_stop_replies (void)
+{
+ struct vstop_notif *next;
+
+ while (notif_queue)
+ {
+ next = notif_queue->next;
+ notif_queue = next;
+
+ free (next);
+ }
+}
+
+/* If there are more stop replies to push, push one now. */
+
+static void
+send_next_stop_reply (char *own_buf)
+{
+ if (notif_queue)
+ prepare_resume_reply (own_buf,
+ notif_queue->ptid,
+ ¬if_queue->status);
+ else
+ write_ok (own_buf);
+}
+
static int
target_running (void)
{
unsigned long ptid;
resume_info.thread = -1;
- resume_info.step = 0;
+ resume_info.kind = resume_continue;
resume_info.sig = 0;
- ptid = mywait (&last_status, 0);
+ ptid = mywait (&last_status, 0, 0);
+
if (last_status.kind != TARGET_WAITKIND_STOPPED)
return signal_pid;
{
(*the_target->resume) (&resume_info, 1);
- mywait (&last_status, 0);
+ mywait (&last_status, 0, 0);
if (last_status.kind != TARGET_WAITKIND_STOPPED)
return signal_pid;
}
/* Wait till we are at 1st instruction in program, return new pid
(assuming success). */
- last_ptid = mywait (&last_status, 0);
+ last_ptid = mywait (&last_status, 0, 0);
return signal_pid;
}
whichever we were told to attach to. */
signal_pid = pid;
- last_ptid = mywait (&last_status, 0);
-
- /* GDB knows to ignore the first SIGSTOP after attaching to a running
- 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;
+ if (!non_stop)
+ {
+ last_ptid = mywait (&last_status, 0, 0);
+
+ /* GDB knows to ignore the first SIGSTOP after attaching to a running
+ 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;
+ }
return 0;
}
return;
}
+ if (strncmp (own_buf, "QNonStop:", 9) == 0)
+ {
+ char *mode = own_buf + 9;
+ int req = -1;
+ char *req_str;
+
+ if (strcmp (mode, "0") == 0)
+ req = 0;
+ else if (strcmp (mode, "1") == 0)
+ req = 1;
+ else
+ {
+ /* We don't know what this mode is, so complain to
+ GDB. */
+ fprintf (stderr, "Unknown non-stop mode requested: %s\n",
+ own_buf);
+ write_enn (own_buf);
+ return;
+ }
+
+ req_str = req ? "non-stop" : "all-stop";
+ if (start_non_stop (req) != 0)
+ {
+ fprintf (stderr, "Setting %s mode failed\n", req_str);
+ write_enn (own_buf);
+ return;
+ }
+
+ non_stop = req;
+
+ if (remote_debug)
+ fprintf (stderr, "[%s mode enabled]\n", req_str);
+
+ write_ok (own_buf);
+ return;
+ }
+
/* Otherwise we didn't know what packet it was. Say we didn't
understand it. */
own_buf[0] = 0;
/* Reply the current thread id. */
if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
{
+ unsigned long gdb_id;
require_running (own_buf);
- thread_ptr = all_threads.head;
- sprintf (own_buf, "QC%x",
- thread_to_gdb_id ((struct thread_info *)thread_ptr));
+
+ if (general_thread != 0 && general_thread != -1)
+ gdb_id = general_thread;
+ else
+ {
+ thread_ptr = all_threads.head;
+ gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
+ }
+
+ sprintf (own_buf, "QC%lx", gdb_id);
return;
}
if (the_target->qxfer_osdata != NULL)
strcat (own_buf, ";qXfer:osdata:read+");
+ if (target_supports_non_stop ())
+ strcat (own_buf, ";QNonStop+");
+
return;
}
char *p = own_buf + 12;
CORE_ADDR parts[2], address = 0;
int i, err;
- unsigned long ptid;
+ unsigned long ptid = 0;
require_running (own_buf);
p++;
if (p[0] == 's' || p[0] == 'S')
- resume_info[i].step = 1;
+ resume_info[i].kind = resume_step;
else if (p[0] == 'c' || p[0] == 'C')
- resume_info[i].step = 0;
+ resume_info[i].kind = resume_continue;
+ else if (p[0] == 't')
+ resume_info[i].kind = resume_stop;
else
goto err;
resume_info[i] = default_action;
/* Still used in occasional places in the backend. */
- if (n == 1 && resume_info[0].thread != -1)
+ if (n == 1
+ && resume_info[0].thread != -1
+ && resume_info[0].kind != resume_stop)
cont_thread = resume_info[0].thread;
else
cont_thread = -1;
set_desired_inferior (0);
- enable_async_io ();
+ if (!non_stop)
+ enable_async_io ();
+
(*the_target->resume) (resume_info, n);
free (resume_info);
- last_ptid = mywait (&last_status, 1);
- prepare_resume_reply (own_buf, last_ptid, &last_status);
- disable_async_io ();
+ if (non_stop)
+ write_ok (own_buf);
+ else
+ {
+ last_ptid = mywait (&last_status, 0, 1);
+ prepare_resume_reply (own_buf, last_ptid, &last_status);
+ disable_async_io ();
+ }
return;
err:
library list. Avoids the "stopped by shared library event"
notice on the GDB side. */
dlls_changed = 0;
- prepare_resume_reply (own_buf, last_ptid, &last_status);
+
+ if (non_stop)
+ {
+ /* In non-stop, we don't send a resume reply. Stop events
+ will follow up using the normal notification
+ mechanism. */
+ write_ok (own_buf);
+ }
+ else
+ prepare_resume_reply (own_buf, last_ptid, &last_status);
+
return 1;
}
else
if (last_status.kind == TARGET_WAITKIND_STOPPED)
{
prepare_resume_reply (own_buf, last_ptid, &last_status);
+
+ /* In non-stop, sending a resume reply doesn't set the general
+ thread, but GDB assumes a vRun sets it (this is so GDB can
+ query which is the main thread of the new inferior. */
+ if (non_stop)
+ general_thread = last_ptid;
+
return 1;
}
else
}
}
+/* 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 %ld\n", 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 (strncmp (own_buf, "vCont?", 6) == 0)
{
- strcpy (own_buf, "vCont;c;C;s;S");
+ strcpy (own_buf, "vCont;c;C;s;S;t");
return;
}
}
return;
}
+ if (strncmp (own_buf, "vStopped", 8) == 0)
+ {
+ handle_v_stopped (own_buf);
+ return;
+ }
+
/* Otherwise we didn't know what packet it was. Say we didn't
understand it. */
own_buf[0] = 0;
return;
}
+/* Resume inferior and wait for another event. In non-stop mode,
+ don't really wait here, but return immediatelly to the event
+ loop. */
void
myresume (char *own_buf, int step, int sig)
{
{
resume_info[0].thread
= ((struct inferior_list_entry *) current_inferior)->id;
- resume_info[0].step = step;
+ if (step)
+ resume_info[0].kind = resume_step;
+ else
+ resume_info[0].kind = resume_continue;
resume_info[0].sig = sig;
n++;
}
if (!valid_cont_thread)
{
resume_info[n].thread = -1;
- resume_info[n].step = 0;
+ resume_info[n].kind = resume_continue;
resume_info[n].sig = 0;
n++;
}
- enable_async_io ();
+ if (!non_stop)
+ enable_async_io ();
+
(*the_target->resume) (resume_info, n);
- last_ptid = mywait (&last_status, 1);
- prepare_resume_reply (own_buf, last_ptid, &last_status);
- disable_async_io ();
+
+ if (non_stop)
+ write_ok (own_buf);
+ else
+ {
+ last_ptid = mywait (&last_status, 0, 1);
+ prepare_resume_reply (own_buf, last_ptid, &last_status);
+ disable_async_io ();
+ }
+}
+
+/* Callback for for_each_inferior. Make a new stop reply for each
+ stopped thread. */
+
+static void
+queue_stop_reply_callback (struct inferior_list_entry *entry)
+{
+ struct target_waitstatus status;
+
+ status.kind = TARGET_WAITKIND_STOPPED;
+ status.value.sig = TARGET_SIGNAL_TRAP;
+
+ /* Pass the last stop reply back to GDB, but don't notify. */
+ queue_stop_reply (entry->id, &status);
}
/* Status handler for the '?' packet. */
static void
handle_status (char *own_buf)
{
- if (all_threads.head)
- prepare_resume_reply (own_buf,
- all_threads.head->id, &last_status);
+ struct target_waitstatus status;
+ status.kind = TARGET_WAITKIND_STOPPED;
+ status.value.sig = TARGET_SIGNAL_TRAP;
+
+ /* In non-stop mode, we must send a stop reply for each stopped
+ thread. In all-stop mode, just send one for the first stopped
+ thread we find. */
+
+ if (non_stop)
+ {
+ discard_queued_stop_replies ();
+ for_each_inferior (&all_threads, queue_stop_reply_callback);
+
+ /* 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);
+ }
else
- strcpy (own_buf, "W00");
+ {
+ if (all_threads.head)
+ prepare_resume_reply (own_buf,
+ all_threads.head->id, &status);
+ else
+ strcpy (own_buf, "W00");
+ }
}
static void
int
main (int argc, char *argv[])
{
- char ch, *own_buf;
- unsigned char *mem_buf;
- int i = 0;
- int signal;
- unsigned int len;
- CORE_ADDR mem_addr;
int bad_attach;
int pid;
char *arg_end, *port;
while (1)
{
noack_mode = 0;
+ non_stop = 0;
+
remote_open (port);
- restart:
if (setjmp (toplevel) != 0)
{
/* An error occurred. */
}
}
- disable_async_io ();
- while (!exit_requested)
+ /* 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)
{
- unsigned char sig;
- int packet_len;
- int new_packet_len = -1;
+ if (attached)
+ detach_inferior ();
+ else
+ kill_inferior ();
+ exit (0);
+ }
+ else
+ fprintf (stderr, "Remote side has terminated connection. "
+ "GDBserver will reopen the connection.\n");
+ }
+}
- response_needed = 0;
- packet_len = getpkt (own_buf);
- if (packet_len <= 0)
- break;
- response_needed = 1;
+/* Event loop callback that handles a serial event. The first byte in
+ the serial buffer gets us here. We expect characters to arrive at
+ a brisk pace, so we read the rest of the packet with a blocking
+ getpkt call. */
- i = 0;
- ch = own_buf[i++];
- switch (ch)
+static void
+process_serial_event (void)
+{
+ char ch;
+ int i = 0;
+ int signal;
+ unsigned int len;
+ CORE_ADDR mem_addr;
+ unsigned char sig;
+ int packet_len;
+ int new_packet_len = -1;
+
+ /* Used to decide when gdbserver should exit in
+ multi-mode/remote. */
+ static int have_ran = 0;
+
+ if (!have_ran)
+ have_ran = target_running ();
+
+ disable_async_io ();
+
+ response_needed = 0;
+ packet_len = getpkt (own_buf);
+ if (packet_len <= 0)
+ {
+ target_async (0);
+ remote_close ();
+ return;
+ }
+ response_needed = 1;
+
+ i = 0;
+ ch = own_buf[i++];
+ switch (ch)
+ {
+ case 'q':
+ handle_query (own_buf, packet_len, &new_packet_len);
+ break;
+ case 'Q':
+ handle_general_set (own_buf);
+ break;
+ case 'D':
+ require_running (own_buf);
+ fprintf (stderr, "Detaching from inferior\n");
+ if (detach_inferior () != 0)
+ write_enn (own_buf);
+ else
+ {
+ discard_queued_stop_replies ();
+ write_ok (own_buf);
+
+ if (extended_protocol)
{
- case 'q':
- handle_query (own_buf, packet_len, &new_packet_len);
- break;
- case 'Q':
- handle_general_set (own_buf);
- break;
- case 'D':
- require_running (own_buf);
- fprintf (stderr, "Detaching from inferior\n");
- if (detach_inferior () != 0)
- write_enn (own_buf);
- else
- {
- write_ok (own_buf);
-
- if (extended_protocol)
- {
- /* Treat this like a normal program exit. */
- last_status.kind = TARGET_WAITKIND_EXITED;
- last_status.value.integer = 0;
- last_ptid = signal_pid;
- }
- else
- {
- putpkt (own_buf);
- remote_close ();
-
- /* If we are attached, then we can exit. Otherwise, we
- need to hang around doing nothing, until the child
- is gone. */
- if (!attached)
- join_inferior ();
-
- exit (0);
- }
- }
- break;
- case '!':
- extended_protocol = 1;
- write_ok (own_buf);
- break;
- case '?':
- handle_status (own_buf);
- break;
- case 'H':
- if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
- {
- unsigned long gdb_id, thread_id;
-
- require_running (own_buf);
- gdb_id = strtoul (&own_buf[2], NULL, 16);
- if (gdb_id == 0 || gdb_id == -1)
- thread_id = gdb_id;
- else
- {
- thread_id = gdb_id_to_thread_id (gdb_id);
- if (thread_id == 0)
- {
- write_enn (own_buf);
- break;
- }
- }
-
- if (own_buf[1] == 'g')
- {
- general_thread = thread_id;
- set_desired_inferior (1);
- }
- else if (own_buf[1] == 'c')
- cont_thread = thread_id;
- else if (own_buf[1] == 's')
- step_thread = thread_id;
-
- write_ok (own_buf);
- }
- else
- {
- /* Silently ignore it so that gdb can extend the protocol
- without compatibility headaches. */
- own_buf[0] = '\0';
- }
- break;
- case 'g':
- require_running (own_buf);
- set_desired_inferior (1);
- registers_to_string (own_buf);
- break;
- case 'G':
- require_running (own_buf);
- set_desired_inferior (1);
- registers_from_string (&own_buf[1]);
- write_ok (own_buf);
- break;
- case 'm':
- require_running (own_buf);
- decode_m_packet (&own_buf[1], &mem_addr, &len);
- if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
- convert_int_to_ascii (mem_buf, own_buf, len);
- else
- write_enn (own_buf);
- break;
- case 'M':
- require_running (own_buf);
- decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
- if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
- write_ok (own_buf);
- else
- write_enn (own_buf);
- break;
- case 'X':
- require_running (own_buf);
- if (decode_X_packet (&own_buf[1], packet_len - 1,
- &mem_addr, &len, mem_buf) < 0
- || write_inferior_memory (mem_addr, mem_buf, len) != 0)
- write_enn (own_buf);
- else
- write_ok (own_buf);
- 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);
- 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);
- else
- signal = 0;
- myresume (own_buf, 1, signal);
- break;
- case 'c':
- require_running (own_buf);
- signal = 0;
- myresume (own_buf, 0, signal);
- break;
- case 's':
- require_running (own_buf);
- signal = 0;
- myresume (own_buf, 1, signal);
- break;
- case 'Z':
- {
- char *lenptr;
- char *dataptr;
- CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
- int len = strtol (lenptr + 1, &dataptr, 16);
- char type = own_buf[1];
-
- if (the_target->insert_watchpoint == NULL
- || (type < '2' || type > '4'))
- {
- /* No watchpoint support or not a watchpoint command;
- unrecognized either way. */
- own_buf[0] = '\0';
- }
- else
- {
- int res;
-
- require_running (own_buf);
- res = (*the_target->insert_watchpoint) (type, addr, len);
- if (res == 0)
- write_ok (own_buf);
- else if (res == 1)
- /* Unsupported. */
- own_buf[0] = '\0';
- else
- write_enn (own_buf);
- }
- break;
- }
- case 'z':
- {
- char *lenptr;
- char *dataptr;
- CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
- int len = strtol (lenptr + 1, &dataptr, 16);
- char type = own_buf[1];
-
- if (the_target->remove_watchpoint == NULL
- || (type < '2' || type > '4'))
- {
- /* No watchpoint support or not a watchpoint command;
- unrecognized either way. */
- own_buf[0] = '\0';
- }
- else
- {
- int res;
-
- require_running (own_buf);
- res = (*the_target->remove_watchpoint) (type, addr, len);
- if (res == 0)
- write_ok (own_buf);
- else if (res == 1)
- /* Unsupported. */
- own_buf[0] = '\0';
- else
- write_enn (own_buf);
- }
- break;
- }
- case 'k':
- response_needed = 0;
- if (!target_running ())
- /* The packet we received doesn't make sense - but we
- can't reply to it, either. */
- goto restart;
-
- fprintf (stderr, "Killing inferior\n");
- kill_inferior ();
+ /* Treat this like a normal program exit. */
+ last_status.kind = TARGET_WAITKIND_EXITED;
+ last_status.value.integer = 0;
+ last_ptid = signal_pid;
- /* When using the extended protocol, we wait with no
- program running. The traditional protocol will exit
- instead. */
- if (extended_protocol)
- {
- last_status.kind = TARGET_WAITKIND_EXITED;
- last_status.value.sig = TARGET_SIGNAL_KILL;
- was_running = 0;
- goto restart;
- }
- else
+ current_inferior = NULL;
+ }
+ else
+ {
+ putpkt (own_buf);
+ remote_close ();
+
+ /* If we are attached, then we can exit. Otherwise, we
+ need to hang around doing nothing, until the child is
+ gone. */
+ if (!attached)
+ join_inferior ();
+
+ exit (0);
+ }
+ }
+ break;
+ case '!':
+ extended_protocol = 1;
+ write_ok (own_buf);
+ break;
+ case '?':
+ handle_status (own_buf);
+ break;
+ case 'H':
+ if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
+ {
+ unsigned long gdb_id, thread_id;
+
+ require_running (own_buf);
+ gdb_id = strtoul (&own_buf[2], NULL, 16);
+ if (gdb_id == 0 || gdb_id == -1)
+ thread_id = gdb_id;
+ else
+ {
+ thread_id = gdb_id_to_thread_id (gdb_id);
+ if (thread_id == 0)
{
- exit (0);
- break;
- }
- case 'T':
- {
- unsigned long gdb_id, thread_id;
-
- require_running (own_buf);
- gdb_id = strtoul (&own_buf[1], NULL, 16);
- thread_id = gdb_id_to_thread_id (gdb_id);
- if (thread_id == 0)
- {
- write_enn (own_buf);
- break;
- }
-
- if (mythread_alive (thread_id))
- write_ok (own_buf);
- else
write_enn (own_buf);
- }
- break;
- case 'R':
- response_needed = 0;
-
- /* Restarting the inferior is only supported in the
- extended protocol. */
- if (extended_protocol)
- {
- if (target_running ())
- kill_inferior ();
- fprintf (stderr, "GDBserver restarting\n");
-
- /* Wait till we are at 1st instruction in prog. */
- if (program_argv != NULL)
- start_inferior (program_argv);
- else
- {
- last_status.kind = TARGET_WAITKIND_EXITED;
- last_status.value.sig = TARGET_SIGNAL_KILL;
- }
- goto restart;
- }
- else
- {
- /* It is a request we don't understand. Respond with an
- empty packet so that gdb knows that we don't support this
- request. */
- own_buf[0] = '\0';
break;
}
- case 'v':
- /* Extended (long) request. */
- handle_v_requests (own_buf, packet_len, &new_packet_len);
- break;
-
- default:
- /* It is a request we don't understand. Respond with an
- empty packet so that gdb knows that we don't support this
- request. */
- own_buf[0] = '\0';
- break;
}
- if (new_packet_len != -1)
- putpkt_binary (own_buf, new_packet_len);
- else
- putpkt (own_buf);
-
- response_needed = 0;
-
- if (was_running
- && (last_status.kind == TARGET_WAITKIND_EXITED
- || last_status.kind == TARGET_WAITKIND_SIGNALLED))
+ if (own_buf[1] == 'g')
{
- was_running = 0;
-
- if (last_status.kind == TARGET_WAITKIND_EXITED)
- fprintf (stderr,
- "\nChild exited with status %d\n",
- last_status.value.integer);
- else if (last_status.kind == TARGET_WAITKIND_SIGNALLED)
- fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
- target_signal_to_host (last_status.value.sig),
- target_signal_to_name (last_status.value.sig));
-
- if (extended_protocol)
- goto restart;
- else
+ if (thread_id == 0)
{
- fprintf (stderr, "GDBserver exiting\n");
- remote_close ();
- exit (0);
+ /* GDB is telling us to choose any thread. Check if
+ the currently selected thread is still valid. If
+ it is not, select the first available. */
+ struct thread_info *thread =
+ (struct thread_info *) find_inferior_id (&all_threads,
+ general_thread);
+ if (thread == NULL)
+ thread_id = all_threads.head->id;
}
+
+ general_thread = thread_id;
+ set_desired_inferior (1);
}
+ else if (own_buf[1] == 'c')
+ cont_thread = thread_id;
+ else if (own_buf[1] == 's')
+ step_thread = thread_id;
- if (last_status.kind != TARGET_WAITKIND_EXITED
- && last_status.kind != TARGET_WAITKIND_SIGNALLED)
- was_running = 1;
+ write_ok (own_buf);
+ }
+ else
+ {
+ /* Silently ignore it so that gdb can extend the protocol
+ without compatibility headaches. */
+ own_buf[0] = '\0';
}
+ break;
+ case 'g':
+ require_running (own_buf);
+ set_desired_inferior (1);
+ registers_to_string (own_buf);
+ break;
+ case 'G':
+ require_running (own_buf);
+ set_desired_inferior (1);
+ registers_from_string (&own_buf[1]);
+ write_ok (own_buf);
+ break;
+ case 'm':
+ require_running (own_buf);
+ decode_m_packet (&own_buf[1], &mem_addr, &len);
+ if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
+ convert_int_to_ascii (mem_buf, own_buf, len);
+ else
+ write_enn (own_buf);
+ break;
+ case 'M':
+ require_running (own_buf);
+ decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
+ if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
+ write_ok (own_buf);
+ else
+ write_enn (own_buf);
+ break;
+ case 'X':
+ require_running (own_buf);
+ if (decode_X_packet (&own_buf[1], packet_len - 1,
+ &mem_addr, &len, mem_buf) < 0
+ || write_inferior_memory (mem_addr, mem_buf, len) != 0)
+ write_enn (own_buf);
+ else
+ write_ok (own_buf);
+ 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);
+ 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);
+ else
+ signal = 0;
+ myresume (own_buf, 1, signal);
+ break;
+ case 'c':
+ require_running (own_buf);
+ signal = 0;
+ myresume (own_buf, 0, signal);
+ break;
+ case 's':
+ require_running (own_buf);
+ signal = 0;
+ myresume (own_buf, 1, signal);
+ break;
+ case 'Z':
+ {
+ char *lenptr;
+ char *dataptr;
+ CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
+ int len = strtol (lenptr + 1, &dataptr, 16);
+ char type = own_buf[1];
+
+ if (the_target->insert_watchpoint == NULL
+ || (type < '2' || type > '4'))
+ {
+ /* No watchpoint support or not a watchpoint command;
+ unrecognized either way. */
+ own_buf[0] = '\0';
+ }
+ else
+ {
+ int res;
+
+ require_running (own_buf);
+ res = (*the_target->insert_watchpoint) (type, addr, len);
+ if (res == 0)
+ write_ok (own_buf);
+ else if (res == 1)
+ /* Unsupported. */
+ own_buf[0] = '\0';
+ else
+ write_enn (own_buf);
+ }
+ break;
+ }
+ case 'z':
+ {
+ char *lenptr;
+ char *dataptr;
+ CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
+ int len = strtol (lenptr + 1, &dataptr, 16);
+ char type = own_buf[1];
+
+ if (the_target->remove_watchpoint == NULL
+ || (type < '2' || type > '4'))
+ {
+ /* No watchpoint support or not a watchpoint command;
+ unrecognized either way. */
+ own_buf[0] = '\0';
+ }
+ else
+ {
+ int res;
+
+ require_running (own_buf);
+ res = (*the_target->remove_watchpoint) (type, addr, len);
+ if (res == 0)
+ write_ok (own_buf);
+ else if (res == 1)
+ /* Unsupported. */
+ own_buf[0] = '\0';
+ else
+ write_enn (own_buf);
+ }
+ break;
+ }
+ case 'k':
+ response_needed = 0;
+ if (!target_running ())
+ /* The packet we received doesn't make sense - but we
+ can't reply to it, either. */
+ return;
- /* 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. */
+ fprintf (stderr, "Killing inferior\n");
+ kill_inferior ();
+ discard_queued_stop_replies ();
- if (exit_requested)
+ /* When using the extended protocol, we wait with no program
+ running. The traditional protocol will exit instead. */
+ if (extended_protocol)
+ {
+ last_status.kind = TARGET_WAITKIND_EXITED;
+ last_status.value.sig = TARGET_SIGNAL_KILL;
+ return;
+ }
+ else
{
- remote_close ();
- if (attached && target_running ())
- detach_inferior ();
- else if (target_running ())
- kill_inferior ();
exit (0);
+ break;
+ }
+ case 'T':
+ {
+ unsigned long gdb_id, thread_id;
+
+ require_running (own_buf);
+ gdb_id = strtoul (&own_buf[1], NULL, 16);
+ thread_id = gdb_id_to_thread_id (gdb_id);
+ if (thread_id == 0)
+ {
+ write_enn (own_buf);
+ break;
+ }
+
+ if (mythread_alive (thread_id))
+ write_ok (own_buf);
+ else
+ write_enn (own_buf);
+ }
+ break;
+ case 'R':
+ response_needed = 0;
+
+ /* Restarting the inferior is only supported in the extended
+ protocol. */
+ if (extended_protocol)
+ {
+ if (target_running ())
+ {
+ kill_inferior ();
+ discard_queued_stop_replies ();
+ }
+ fprintf (stderr, "GDBserver restarting\n");
+
+ /* Wait till we are at 1st instruction in prog. */
+ if (program_argv != NULL)
+ start_inferior (program_argv);
+ else
+ {
+ last_status.kind = TARGET_WAITKIND_EXITED;
+ last_status.value.sig = TARGET_SIGNAL_KILL;
+ }
+ return;
}
else
{
- fprintf (stderr, "Remote side has terminated connection. "
- "GDBserver will reopen the connection.\n");
+ /* It is a request we don't understand. Respond with an
+ empty packet so that gdb knows that we don't support this
+ request. */
+ own_buf[0] = '\0';
+ break;
+ }
+ case 'v':
+ /* Extended (long) request. */
+ handle_v_requests (own_buf, packet_len, &new_packet_len);
+ break;
+
+ default:
+ /* It is a request we don't understand. Respond with an empty
+ packet so that gdb knows that we don't support this
+ request. */
+ own_buf[0] = '\0';
+ break;
+ }
+
+ if (new_packet_len != -1)
+ putpkt_binary (own_buf, new_packet_len);
+ else
+ putpkt (own_buf);
+
+ response_needed = 0;
+
+ if (!extended_protocol && have_ran && !target_running ())
+ {
+ /* In non-stop, defer exiting until GDB had a chance to query
+ the whole vStopped list (until it gets an OK). */
+ if (!notif_queue)
+ {
+ fprintf (stderr, "GDBserver exiting\n");
remote_close ();
+ exit (0);
}
}
}
+
+/* Event-loop callback for serial events. */
+
+void
+handle_serial_event (int err, gdb_client_data client_data)
+{
+ if (debug_threads)
+ fprintf (stderr, "handling possible serial event\n");
+
+ /* Really handle it. */
+ process_serial_event ();
+
+ /* Be sure to not change the selected inferior behind GDB's back.
+ Important in the non-stop mode asynchronous protocol. */
+ set_desired_inferior (1);
+}
+
+/* Event-loop callback for target events. */
+
+void
+handle_target_event (int err, gdb_client_data client_data)
+{
+ if (debug_threads)
+ fprintf (stderr, "handling possible target event\n");
+
+ last_ptid = mywait (&last_status, TARGET_WNOHANG, 1);
+
+ if (last_status.kind != TARGET_WAITKIND_IGNORE)
+ {
+ /* Something interesting. Tell GDB about it. */
+ push_event (last_ptid, &last_status);
+ }
+
+ /* Be sure to not change the selected inferior behind GDB's back.
+ Important in the non-stop mode asynchronous protocol. */
+ set_desired_inferior (1);
+}
extern int disable_packet_qC;
extern int disable_packet_qfThreadInfo;
+extern int non_stop;
+
+/* Functions from event-loop.c. */
+typedef void *gdb_client_data;
+typedef void (handler_func) (int, gdb_client_data);
+
+extern void delete_file_handler (int fd);
+extern void add_file_handler (int fd, handler_func *proc,
+ gdb_client_data client_data);
+
+extern void start_event_loop (void);
+
+/* Functions from server.c. */
+extern void handle_serial_event (int err, gdb_client_data client_data);
+extern void handle_target_event (int err, gdb_client_data client_data);
+
+extern void push_event (unsigned long ptid, struct target_waitstatus *status);
+
/* Functions from hostio.c. */
extern int handle_vFile (char *, int, int *);
int putpkt (char *buf);
int putpkt_binary (char *buf, int len);
+int putpkt_notif (char *buf);
int getpkt (char *buf);
void remote_open (char *name);
void remote_close (void);
/* We don't support hardware single-stepping right now, assume
GDB knows to use software single-stepping. */
- if (resume_info[i].step)
+ if (resume_info[i].kind == resume_step)
fprintf (stderr, "Hardware single-step not supported.\n");
regcache_invalidate ();
/* Wait for process, returns status. */
static unsigned long
-spu_wait (struct target_waitstatus *ourstatus)
+spu_wait (struct target_waitstatus *ourstatus, int options)
{
int tid = current_tid;
int w;
}
unsigned long
-mywait (struct target_waitstatus *ourstatus, int connected_wait)
+mywait (struct target_waitstatus *ourstatus, int options,
+ int connected_wait)
{
unsigned long ret;
if (connected_wait)
server_waiting = 1;
- ret = (*the_target->wait) (ourstatus);
+ ret = (*the_target->wait) (ourstatus, options);
+
+ if (ourstatus->kind == TARGET_WAITKIND_EXITED
+ || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
+ {
+ if (ourstatus->kind == TARGET_WAITKIND_EXITED)
+ fprintf (stderr,
+ "\nChild exited with status %d\n", ourstatus->value.sig);
+ if (ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
+ fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
+ target_signal_to_host (ourstatus->value.sig),
+ target_signal_to_name (ourstatus->value.sig));
+ }
if (connected_wait)
server_waiting = 0;
return ret;
}
+int
+start_non_stop (int nonstop)
+{
+ if (the_target->start_non_stop == NULL)
+ {
+ if (nonstop)
+ return -1;
+ else
+ return 0;
+ }
+
+ return (*the_target->start_non_stop) (nonstop);
+}
+
void
set_target_ops (struct target_ops *target)
{
#ifndef TARGET_H
#define TARGET_H
+/* Ways to "resume" a thread. */
+
+enum resume_kind
+{
+ /* Thread should continue. */
+ resume_continue,
+
+ /* Thread should single-step. */
+ resume_step,
+
+ /* Thread should be stopped. */
+ resume_stop
+};
+
/* This structure describes how to resume a particular thread (or all
threads) based on the client's request. If thread is -1, then this
entry applies to all threads. These are passed around as an
{
unsigned long thread;
- /* If non-zero, we want to single-step. */
- int step;
+ /* How to "resume". */
+ enum resume_kind kind;
- /* If non-zero, send this signal when we resume. */
+ /* If non-zero, send this signal when we resume, or to stop the
+ thread. If stopping a thread, and this is 0, the target should
+ stop the thread however it best decides to (e.g., SIGSTOP on
+ linux; SuspendThread on win32). */
int sig;
};
value;
};
+/* Options that can be passed to target_ops->wait. */
+
+#define TARGET_WNOHANG 1
+
struct target_ops
{
/* Start a new process.
/* Wait for the inferior process or thread to change state. Store
status through argument pointer STATUS. */
- unsigned long (*wait) (struct target_waitstatus *status);
+ unsigned long (*wait) (struct target_waitstatus *status, int options);
/* Fetch registers from the inferior process.
int (*qxfer_siginfo) (const char *annex, unsigned char *readbuf,
unsigned const char *writebuf,
CORE_ADDR offset, int len);
+
+ int (*supports_non_stop) (void);
+
+ /* Enables async target events. Returns the previous enable
+ state. */
+ int (*async) (int enable);
+
+ /* Switch to non-stop (1) or all-stop (0) mode. Return 0 on
+ success, -1 otherwise. */
+ int (*start_non_stop) (int);
};
extern struct target_ops *the_target;
#define join_inferior() \
(*the_target->join) ()
-unsigned long mywait (struct target_waitstatus *ourstatus, int connected_wait);
+#define target_supports_non_stop() \
+ (the_target->supports_non_stop ? (*the_target->supports_non_stop ) () : 0)
+
+#define target_async(enable) \
+ (the_target->async ? (*the_target->async) (enable) : 0)
+
+/* Start non-stop mode, returns 0 on success, -1 on failure. */
+
+int start_non_stop (int nonstop);
+
+unsigned long mywait (struct target_waitstatus *ourstatus, int options,
+ int connected_wait);
int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len);
created threads. */
lwp = get_thread_lwp (current_inferior);
if (lwp->thread_known == 0)
- find_one_thread (lwp->lwpid);
+ find_one_thread (lwpid_of (lwp));
/* msg.event == TD_EVENT_CREATE */
return 1;
/* Get information about this thread. */
- err = td_ta_map_lwp2thr (thread_agent, lwp->lwpid, &th);
+ err = td_ta_map_lwp2thr (thread_agent, lwpid_of (lwp), &th);
if (err != TD_OK)
error ("Cannot get thread handle for LWP %d: %s",
lwpid, thread_db_err_str (err));
fprintf (stderr, "Found thread %ld (LWP %d)\n",
ti.ti_tid, ti.ti_lid);
- if (lwp->lwpid != ti.ti_lid)
+ if (lwpid_of (lwp) != ti.ti_lid)
{
warning ("PID mismatch! Expected %ld, got %ld",
- (long) lwp->lwpid, (long) ti.ti_lid);
+ (long) lwpid_of (lwp), (long) ti.ti_lid);
return 0;
}
lwp = get_thread_lwp (thread);
if (!lwp->thread_known)
- find_one_thread (lwp->lwpid);
+ find_one_thread (lwpid_of (lwp));
if (!lwp->thread_known)
return TD_NOTHR;
{
struct thread_resume resume;
resume.thread = -1;
- resume.step = 0;
+ resume.kind = resume_continue;
resume.sig = 0;
win32_resume (&resume, 1);
}
if (resume_info[0].thread != -1)
{
sig = resume_info[0].sig;
- step = resume_info[0].step;
+ step = resume_info[0].kind == resume_step;
}
else
{
STATUS will be filled in with a response code to send to GDB.
Returns the signal which caused the process to stop. */
static unsigned long
-win32_wait (struct target_waitstatus *ourstatus)
+win32_wait (struct target_waitstatus *ourstatus, int options)
{
while (1)
{
projects / binutils-gdb.git / commitdiff