[deliverable/binutils-gdb.git] / gdb / remote-notif.c

/* Remote notification in GDB protocol

   Copyright (C) 1988-2014 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/>.  */

/* Remote async notification is sent from remote target over RSP.
   Each type of notification is represented by an object of
   'struct notif', which has a field 'pending_reply'.  It is not
   NULL when GDB receives a notification from GDBserver, but hasn't
   acknowledge yet.  Before GDB acknowledges the notification,
   GDBserver shouldn't send notification again (see the header comments
   in gdbserver/notif.c).

   Notifications are processed in an almost-unified approach for both
   all-stop mode and non-stop mode, except the timing to process them.
   In non-stop mode, notifications are processed in
   remote_async_get_pending_events_handler, while in all-stop mode,
   they are processed in remote_resume.  */

#include "defs.h"
#include "remote.h"
#include "remote-notif.h"
#include "observer.h"
#include "event-loop.h"
#include "target.h"
#include "inferior.h"
#include "gdbcmd.h"

#include <string.h>

int notif_debug = 0;

/* Supported clients of notifications.  */

static struct notif_client *notifs[] =
{
  &notif_client_stop,
};

gdb_static_assert (ARRAY_SIZE (notifs) == REMOTE_NOTIF_LAST);

static void do_notif_event_xfree (void *arg);

/* Parse the BUF for the expected notification NC, and send packet to
   acknowledge.  */

void
remote_notif_ack (struct notif_client *nc, char *buf)
{
  struct notif_event *event = nc->alloc_event ();
  struct cleanup *old_chain
    = make_cleanup (do_notif_event_xfree, event);

  if (notif_debug)
    fprintf_unfiltered (gdb_stdlog, "notif: ack '%s'\n",
			nc->ack_command);

  nc->parse (nc, buf, event);
  nc->ack (nc, buf, event);

  discard_cleanups (old_chain);
}

/* Parse the BUF for the expected notification NC.  */

struct notif_event *
remote_notif_parse (struct notif_client *nc, char *buf)
{
  struct notif_event *event = nc->alloc_event ();
  struct cleanup *old_chain
    = make_cleanup (do_notif_event_xfree, event);

  if (notif_debug)
    fprintf_unfiltered (gdb_stdlog, "notif: parse '%s'\n", nc->name);

  nc->parse (nc, buf, event);

  discard_cleanups (old_chain);
  return event;
}

DEFINE_QUEUE_P (notif_client_p);

/* Process notifications in STATE's notification queue one by one.
   EXCEPT is not expected in the queue.  */

void
remote_notif_process (struct remote_notif_state *state,
		      struct notif_client *except)
{
  while (!QUEUE_is_empty (notif_client_p, state->notif_queue))
    {
      struct notif_client *nc = QUEUE_deque (notif_client_p,
					     state->notif_queue);

      gdb_assert (nc != except);

      if (nc->can_get_pending_events (nc))
	remote_notif_get_pending_events (nc);
    }
}

static void
remote_async_get_pending_events_handler (gdb_client_data data)
{
  gdb_assert (non_stop);
  remote_notif_process (data, NULL);
}

/* Remote notification handler.  Parse BUF, queue notification and
   update STATE.  */

void
handle_notification (struct remote_notif_state *state, char *buf)
{
  struct notif_client *nc;
  size_t i;

  for (i = 0; i < ARRAY_SIZE (notifs); i++)
    {
      const char *name = notifs[i]->name;

      if (strncmp (buf, name, strlen (name)) == 0
	  && buf[strlen (name)] == ':')
	break;
    }

  /* We ignore notifications we don't recognize, for compatibility
     with newer stubs.  */
  if (i == ARRAY_SIZE (notifs))
    return;

  nc =  notifs[i];

  if (state->pending_event[nc->id] != NULL)
    {
      /* We've already parsed the in-flight reply, but the stub for some
	 reason thought we didn't, possibly due to timeout on its side.
	 Just ignore it.  */
      if (notif_debug)
	fprintf_unfiltered (gdb_stdlog,
			    "notif: ignoring resent notification\n");
    }
  else
    {
      struct notif_event *event
	= remote_notif_parse (nc, buf + strlen (nc->name) + 1);

      /* Be careful to only set it after parsing, since an error
	 may be thrown then.  */
      state->pending_event[nc->id] = event;

      /* Notify the event loop there's a stop reply to acknowledge
	 and that there may be more events to fetch.  */
      QUEUE_enque (notif_client_p, state->notif_queue, nc);
      if (non_stop)
	{
	  /* In non-stop, We mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
	     in order to go on what we were doing and postpone
	     querying notification events to some point safe to do so.
	     See details in the function comment of
	     remote.c:remote_notif_get_pending_events.

	     In all-stop, GDB may be blocked to wait for the reply, we
	     shouldn't return to event loop until the expected reply
	     arrives.  For example:

	     1.1) --> vCont;c
	       GDB expects getting stop reply 'T05 thread:2'.
	     1.2) <-- %Notif
	       <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>

	     After step #1.2, we return to the event loop, which
	     notices there is a new event on the
	     REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and calls the
	     handler, which will send 'vNotif' packet.
	     1.3) --> vNotif
	     It is not safe to start a new sequence, because target
	     is still running and GDB is expecting the stop reply
	     from stub.

	     To solve this, whenever we parse a notification
	     successfully, we don't mark the
	     REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and let GDB blocked
	     there as before to get the sequence done.

	     2.1) --> vCont;c
	       GDB expects getting stop reply 'T05 thread:2'
	     2.2) <-- %Notif
	       <Don't mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
	     2.3) <-- T05 thread:2

	     These pending notifications can be processed later.  */
	  mark_async_event_handler (state->get_pending_events_token);
	}

      if (notif_debug)
	fprintf_unfiltered (gdb_stdlog,
			    "notif: Notification '%s' captured\n",
			    nc->name);
    }
}

/* Invoke destructor of EVENT and xfree it.  */

void
notif_event_xfree (struct notif_event *event)
{
  if (event != NULL && event->dtr != NULL)
    event->dtr (event);

  xfree (event);
}

/* Cleanup wrapper.  */

static void
do_notif_event_xfree (void *arg)
{
  notif_event_xfree (arg);
}

/* Return an allocated remote_notif_state.  */

struct remote_notif_state *
remote_notif_state_allocate (void)
{
  struct remote_notif_state *notif_state = xzalloc (sizeof (*notif_state));

  notif_state->notif_queue = QUEUE_alloc (notif_client_p, NULL);

  /* Register async_event_handler for notification.  */

  notif_state->get_pending_events_token
    = create_async_event_handler (remote_async_get_pending_events_handler,
				  notif_state);

  return notif_state;
}

/* Free STATE and its fields.  */

void
remote_notif_state_xfree (struct remote_notif_state *state)
{
  int i;

  QUEUE_free (notif_client_p, state->notif_queue);

  /* Unregister async_event_handler for notification.  */
  if (state->get_pending_events_token != NULL)
    delete_async_event_handler (&state->get_pending_events_token);

  for (i = 0; i < REMOTE_NOTIF_LAST; i++)
    notif_event_xfree (state->pending_event[i]);

  xfree (state);
}

/* -Wmissing-prototypes */
extern initialize_file_ftype _initialize_notif;

void
_initialize_notif (void)
{
  add_setshow_boolean_cmd ("notification", no_class, &notif_debug,
			   _("\
Set debugging of async remote notification."), _("\
Show debugging of async remote notification."), _("\
When non-zero, debugging output about async remote notifications"
" is enabled."),
			   NULL,
			   NULL,
			   &setdebuglist, &showdebuglist);
}
Commit	Line	Data
722247f1 YQ	1	/* Remote notification in GDB protocol
722247f1 YQ	2
ecd75fc8	3	Copyright (C) 1988-2014 Free Software Foundation, Inc.
722247f1 YQ	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	/* Remote async notification is sent from remote target over RSP.
	21	Each type of notification is represented by an object of
	22	'struct notif', which has a field 'pending_reply'. It is not
	23	NULL when GDB receives a notification from GDBserver, but hasn't
	24	acknowledge yet. Before GDB acknowledges the notification,
	25	GDBserver shouldn't send notification again (see the header comments
	26	in gdbserver/notif.c).
	27
	28	Notifications are processed in an almost-unified approach for both
	29	all-stop mode and non-stop mode, except the timing to process them.
	30	In non-stop mode, notifications are processed in
	31	remote_async_get_pending_events_handler, while in all-stop mode,
	32	they are processed in remote_resume. */
	33
	34	#include "defs.h"
	35	#include "remote.h"
	36	#include "remote-notif.h"
	37	#include "observer.h"
	38	#include "event-loop.h"
	39	#include "target.h"
	40	#include "inferior.h"
c9b6281a	41	#include "gdbcmd.h"
722247f1 YQ	42
	43	#include <string.h>
	44
99f0a309	45	int notif_debug = 0;
722247f1 YQ	46
	47	/* Supported clients of notifications. */
	48
	49	static struct notif_client *notifs[] =
	50	{
	51	&notif_client_stop,
	52	};
	53
f48ff2a7 YQ	54	gdb_static_assert (ARRAY_SIZE (notifs) == REMOTE_NOTIF_LAST);
f48ff2a7 YQ	55
722247f1 YQ	56	static void do_notif_event_xfree (void *arg);
	57
	58	/* Parse the BUF for the expected notification NC, and send packet to
	59	acknowledge. */
	60
	61	void
	62	remote_notif_ack (struct notif_client nc, char buf)
	63	{
	64	struct notif_event *event = nc->alloc_event ();
	65	struct cleanup *old_chain
	66	= make_cleanup (do_notif_event_xfree, event);
	67
	68	if (notif_debug)
	69	fprintf_unfiltered (gdb_stdlog, "notif: ack '%s'\n",
	70	nc->ack_command);
	71
	72	nc->parse (nc, buf, event);
	73	nc->ack (nc, buf, event);
	74
	75	discard_cleanups (old_chain);
	76	}
	77
	78	/* Parse the BUF for the expected notification NC. */
	79
	80	struct notif_event *
	81	remote_notif_parse (struct notif_client nc, char buf)
	82	{
	83	struct notif_event *event = nc->alloc_event ();
	84	struct cleanup *old_chain
	85	= make_cleanup (do_notif_event_xfree, event);
	86
	87	if (notif_debug)
	88	fprintf_unfiltered (gdb_stdlog, "notif: parse '%s'\n", nc->name);
	89
	90	nc->parse (nc, buf, event);
	91
	92	discard_cleanups (old_chain);
	93	return event;
	94	}
	95
722247f1 YQ	96	DEFINE_QUEUE_P (notif_client_p);
722247f1 YQ	97
5965e028 YQ	98	/* Process notifications in STATE's notification queue one by one.
5965e028 YQ	99	EXCEPT is not expected in the queue. */
722247f1 YQ	100
722247f1 YQ	101	void
5965e028 YQ	102	remote_notif_process (struct remote_notif_state *state,
5965e028 YQ	103	struct notif_client *except)
722247f1	104	{
5965e028	105	while (!QUEUE_is_empty (notif_client_p, state->notif_queue))
722247f1 YQ	106	{
722247f1 YQ	107	struct notif_client *nc = QUEUE_deque (notif_client_p,
5965e028	108	state->notif_queue);
722247f1 YQ	109
	110	gdb_assert (nc != except);
	111
	112	if (nc->can_get_pending_events (nc))
	113	remote_notif_get_pending_events (nc);
	114	}
	115	}
	116
	117	static void
	118	remote_async_get_pending_events_handler (gdb_client_data data)
	119	{
	120	gdb_assert (non_stop);
5965e028	121	remote_notif_process (data, NULL);
722247f1 YQ	122	}
722247f1 YQ	123
5965e028 YQ	124	/* Remote notification handler. Parse BUF, queue notification and
5965e028 YQ	125	update STATE. */
722247f1 YQ	126
722247f1 YQ	127	void
5965e028	128	handle_notification (struct remote_notif_state state, char buf)
722247f1	129	{
62972e0b YQ	130	struct notif_client *nc;
62972e0b YQ	131	size_t i;
722247f1 YQ	132
	133	for (i = 0; i < ARRAY_SIZE (notifs); i++)
	134	{
62972e0b YQ	135	const char *name = notifs[i]->name;
	136
	137	if (strncmp (buf, name, strlen (name)) == 0
	138	&& buf[strlen (name)] == ':')
722247f1 YQ	139	break;
	140	}
	141
	142	/* We ignore notifications we don't recognize, for compatibility
	143	with newer stubs. */
62972e0b	144	if (i == ARRAY_SIZE (notifs))
722247f1 YQ	145	return;
722247f1 YQ	146
62972e0b YQ	147	nc = notifs[i];
62972e0b YQ	148
f48ff2a7	149	if (state->pending_event[nc->id] != NULL)
722247f1 YQ	150	{
	151	/* We've already parsed the in-flight reply, but the stub for some
	152	reason thought we didn't, possibly due to timeout on its side.
	153	Just ignore it. */
	154	if (notif_debug)
	155	fprintf_unfiltered (gdb_stdlog,
	156	"notif: ignoring resent notification\n");
	157	}
	158	else
	159	{
	160	struct notif_event *event
	161	= remote_notif_parse (nc, buf + strlen (nc->name) + 1);
	162
	163	/* Be careful to only set it after parsing, since an error
	164	may be thrown then. */
f48ff2a7	165	state->pending_event[nc->id] = event;
722247f1 YQ	166
	167	/* Notify the event loop there's a stop reply to acknowledge
	168	and that there may be more events to fetch. */
5965e028	169	QUEUE_enque (notif_client_p, state->notif_queue, nc);
722247f1 YQ	170	if (non_stop)
	171	{
	172	/* In non-stop, We mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
	173	in order to go on what we were doing and postpone
	174	querying notification events to some point safe to do so.
	175	See details in the function comment of
	176	remote.c:remote_notif_get_pending_events.
	177
	178	In all-stop, GDB may be blocked to wait for the reply, we
	179	shouldn't return to event loop until the expected reply
	180	arrives. For example:
	181
	182	1.1) --> vCont;c
	183	GDB expects getting stop reply 'T05 thread:2'.
	184	1.2) <-- %Notif
	185	<GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
	186
	187	After step #1.2, we return to the event loop, which
	188	notices there is a new event on the
	189	REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and calls the
	190	handler, which will send 'vNotif' packet.
	191	1.3) --> vNotif
	192	It is not safe to start a new sequence, because target
	193	is still running and GDB is expecting the stop reply
	194	from stub.
	195
	196	To solve this, whenever we parse a notification
	197	successfully, we don't mark the
	198	REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and let GDB blocked
	199	there as before to get the sequence done.
	200
	201	2.1) --> vCont;c
	202	GDB expects getting stop reply 'T05 thread:2'
	203	2.2) <-- %Notif
	204	<Don't mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
	205	2.3) <-- T05 thread:2
	206
	207	These pending notifications can be processed later. */
5965e028	208	mark_async_event_handler (state->get_pending_events_token);
722247f1 YQ	209	}
	210
	211	if (notif_debug)
	212	fprintf_unfiltered (gdb_stdlog,
	213	"notif: Notification '%s' captured\n",
	214	nc->name);
	215	}
	216	}
	217
f48ff2a7	218	/* Invoke destructor of EVENT and xfree it. */
722247f1	219
f48ff2a7 YQ	220	void
f48ff2a7 YQ	221	notif_event_xfree (struct notif_event *event)
722247f1	222	{
f48ff2a7	223	if (event != NULL && event->dtr != NULL)
722247f1 YQ	224	event->dtr (event);
	225
	226	xfree (event);
	227	}
	228
f48ff2a7 YQ	229	/* Cleanup wrapper. */
	230
	231	static void
	232	do_notif_event_xfree (void *arg)
	233	{
	234	notif_event_xfree (arg);
	235	}
	236
5965e028 YQ	237	/* Return an allocated remote_notif_state. */
	238
	239	struct remote_notif_state *
	240	remote_notif_state_allocate (void)
	241	{
	242	struct remote_notif_state notif_state = xzalloc (sizeof (notif_state));
	243
	244	notif_state->notif_queue = QUEUE_alloc (notif_client_p, NULL);
	245
	246	/* Register async_event_handler for notification. */
	247
	248	notif_state->get_pending_events_token
	249	= create_async_event_handler (remote_async_get_pending_events_handler,
	250	notif_state);
	251
	252	return notif_state;
	253	}
	254
	255	/* Free STATE and its fields. */
	256
	257	void
	258	remote_notif_state_xfree (struct remote_notif_state *state)
722247f1	259	{
f48ff2a7 YQ	260	int i;
f48ff2a7 YQ	261
5965e028 YQ	262	QUEUE_free (notif_client_p, state->notif_queue);
	263
	264	/* Unregister async_event_handler for notification. */
	265	if (state->get_pending_events_token != NULL)
	266	delete_async_event_handler (&state->get_pending_events_token);
722247f1	267
f48ff2a7 YQ	268	for (i = 0; i < REMOTE_NOTIF_LAST; i++)
	269	notif_event_xfree (state->pending_event[i]);
	270
5965e028	271	xfree (state);
722247f1 YQ	272	}
	273
	274	/* -Wmissing-prototypes */
	275	extern initialize_file_ftype _initialize_notif;
	276
	277	void
	278	_initialize_notif (void)
	279	{
c9b6281a YQ	280	add_setshow_boolean_cmd ("notification", no_class, &notif_debug,
	281	_("\
	282	Set debugging of async remote notification."), _("\
	283	Show debugging of async remote notification."), _("\
	284	When non-zero, debugging output about async remote notifications"
	285	" is enabled."),
	286	NULL,
	287	NULL,
	288	&setdebuglist, &showdebuglist);
722247f1	289	}