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

/* Remote notification in GDB protocol

   Copyright (C) 1988-2018 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 "observable.h"
#include "event-loop.h"
#include "target.h"
#include "inferior.h"
#include "infrun.h"
#include "gdbcmd.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 (remote_target *remote,
		  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 (remote, nc, buf, event);
  nc->ack (remote, nc, buf, event);

  discard_cleanups (old_chain);
}

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

struct notif_event *
remote_notif_parse (remote_target *remote,
		    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 (remote, 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 (state->remote, nc))
	remote_notif_get_pending_events (state->remote, nc);
    }
}

static void
remote_async_get_pending_events_handler (gdb_client_data data)
{
  gdb_assert (target_is_non_stop_p ());
  remote_notif_process ((struct remote_notif_state *) 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 (startswith (buf, name)
	  && 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 (state->remote, 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 (target_is_non_stop_p ())
	{
	  /* 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 ((struct notif_event *) arg);
}

/* Return an allocated remote_notif_state.  */

struct remote_notif_state *
remote_notif_state_allocate (remote_target *remote)
{
  struct remote_notif_state *notif_state = XCNEW (struct remote_notif_state);

  notif_state->remote = remote;

  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);
}

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
e2882c85	3	Copyright (C) 1988-2018 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"
76727919	37	#include "observable.h"
722247f1 YQ	38	#include "event-loop.h"
	39	#include "target.h"
	40	#include "inferior.h"
45741a9c	41	#include "infrun.h"
c9b6281a	42	#include "gdbcmd.h"
722247f1	43
99f0a309	44	int notif_debug = 0;
722247f1 YQ	45
	46	/* Supported clients of notifications. */
	47
	48	static struct notif_client *notifs[] =
	49	{
	50	&notif_client_stop,
	51	};
	52
f48ff2a7 YQ	53	gdb_static_assert (ARRAY_SIZE (notifs) == REMOTE_NOTIF_LAST);
f48ff2a7 YQ	54
722247f1 YQ	55	static void do_notif_event_xfree (void *arg);
	56
	57	/* Parse the BUF for the expected notification NC, and send packet to
	58	acknowledge. */
	59
	60	void
6b8edb51 PA	61	remote_notif_ack (remote_target *remote,
6b8edb51 PA	62	struct notif_client nc, char buf)
722247f1 YQ	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
6b8edb51 PA	72	nc->parse (remote, nc, buf, event);
6b8edb51 PA	73	nc->ack (remote, nc, buf, event);
722247f1 YQ	74
	75	discard_cleanups (old_chain);
	76	}
	77
	78	/* Parse the BUF for the expected notification NC. */
	79
	80	struct notif_event *
6b8edb51 PA	81	remote_notif_parse (remote_target *remote,
6b8edb51 PA	82	struct notif_client nc, char buf)
722247f1 YQ	83	{
	84	struct notif_event *event = nc->alloc_event ();
	85	struct cleanup *old_chain
	86	= make_cleanup (do_notif_event_xfree, event);
	87
	88	if (notif_debug)
	89	fprintf_unfiltered (gdb_stdlog, "notif: parse '%s'\n", nc->name);
	90
6b8edb51	91	nc->parse (remote, nc, buf, event);
722247f1 YQ	92
	93	discard_cleanups (old_chain);
	94	return event;
	95	}
	96
722247f1 YQ	97	DEFINE_QUEUE_P (notif_client_p);
722247f1 YQ	98
5965e028 YQ	99	/* Process notifications in STATE's notification queue one by one.
5965e028 YQ	100	EXCEPT is not expected in the queue. */
722247f1 YQ	101
722247f1 YQ	102	void
5965e028 YQ	103	remote_notif_process (struct remote_notif_state *state,
5965e028 YQ	104	struct notif_client *except)
722247f1	105	{
5965e028	106	while (!QUEUE_is_empty (notif_client_p, state->notif_queue))
722247f1 YQ	107	{
722247f1 YQ	108	struct notif_client *nc = QUEUE_deque (notif_client_p,
5965e028	109	state->notif_queue);
722247f1 YQ	110
	111	gdb_assert (nc != except);
	112
6b8edb51 PA	113	if (nc->can_get_pending_events (state->remote, nc))
6b8edb51 PA	114	remote_notif_get_pending_events (state->remote, nc);
722247f1 YQ	115	}
	116	}
	117
	118	static void
	119	remote_async_get_pending_events_handler (gdb_client_data data)
	120	{
6efcd9a8	121	gdb_assert (target_is_non_stop_p ());
19ba03f4	122	remote_notif_process ((struct remote_notif_state *) data, NULL);
722247f1 YQ	123	}
722247f1 YQ	124
5965e028 YQ	125	/* Remote notification handler. Parse BUF, queue notification and
5965e028 YQ	126	update STATE. */
722247f1 YQ	127
722247f1 YQ	128	void
5965e028	129	handle_notification (struct remote_notif_state state, char buf)
722247f1	130	{
62972e0b YQ	131	struct notif_client *nc;
62972e0b YQ	132	size_t i;
722247f1 YQ	133
	134	for (i = 0; i < ARRAY_SIZE (notifs); i++)
	135	{
62972e0b YQ	136	const char *name = notifs[i]->name;
62972e0b YQ	137
61012eef	138	if (startswith (buf, name)
62972e0b	139	&& buf[strlen (name)] == ':')
722247f1 YQ	140	break;
	141	}
	142
	143	/* We ignore notifications we don't recognize, for compatibility
	144	with newer stubs. */
62972e0b	145	if (i == ARRAY_SIZE (notifs))
722247f1 YQ	146	return;
722247f1 YQ	147
62972e0b YQ	148	nc = notifs[i];
62972e0b YQ	149
f48ff2a7	150	if (state->pending_event[nc->id] != NULL)
722247f1 YQ	151	{
	152	/* We've already parsed the in-flight reply, but the stub for some
	153	reason thought we didn't, possibly due to timeout on its side.
	154	Just ignore it. */
	155	if (notif_debug)
	156	fprintf_unfiltered (gdb_stdlog,
	157	"notif: ignoring resent notification\n");
	158	}
	159	else
	160	{
	161	struct notif_event *event
6b8edb51	162	= remote_notif_parse (state->remote, nc, buf + strlen (nc->name) + 1);
722247f1 YQ	163
	164	/* Be careful to only set it after parsing, since an error
	165	may be thrown then. */
f48ff2a7	166	state->pending_event[nc->id] = event;
722247f1 YQ	167
	168	/* Notify the event loop there's a stop reply to acknowledge
	169	and that there may be more events to fetch. */
5965e028	170	QUEUE_enque (notif_client_p, state->notif_queue, nc);
6efcd9a8	171	if (target_is_non_stop_p ())
722247f1 YQ	172	{
	173	/* In non-stop, We mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
	174	in order to go on what we were doing and postpone
	175	querying notification events to some point safe to do so.
	176	See details in the function comment of
	177	remote.c:remote_notif_get_pending_events.
	178
	179	In all-stop, GDB may be blocked to wait for the reply, we
	180	shouldn't return to event loop until the expected reply
	181	arrives. For example:
	182
	183	1.1) --> vCont;c
	184	GDB expects getting stop reply 'T05 thread:2'.
	185	1.2) <-- %Notif
	186	<GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
	187
	188	After step #1.2, we return to the event loop, which
	189	notices there is a new event on the
	190	REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and calls the
	191	handler, which will send 'vNotif' packet.
	192	1.3) --> vNotif
	193	It is not safe to start a new sequence, because target
	194	is still running and GDB is expecting the stop reply
	195	from stub.
	196
	197	To solve this, whenever we parse a notification
	198	successfully, we don't mark the
	199	REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and let GDB blocked
	200	there as before to get the sequence done.
	201
	202	2.1) --> vCont;c
	203	GDB expects getting stop reply 'T05 thread:2'
	204	2.2) <-- %Notif
	205	<Don't mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
	206	2.3) <-- T05 thread:2
	207
	208	These pending notifications can be processed later. */
5965e028	209	mark_async_event_handler (state->get_pending_events_token);
722247f1 YQ	210	}
	211
	212	if (notif_debug)
	213	fprintf_unfiltered (gdb_stdlog,
	214	"notif: Notification '%s' captured\n",
	215	nc->name);
	216	}
	217	}
	218
f48ff2a7	219	/* Invoke destructor of EVENT and xfree it. */
722247f1	220
f48ff2a7 YQ	221	void
f48ff2a7 YQ	222	notif_event_xfree (struct notif_event *event)
722247f1	223	{
f48ff2a7	224	if (event != NULL && event->dtr != NULL)
722247f1 YQ	225	event->dtr (event);
	226
	227	xfree (event);
	228	}
	229
f48ff2a7 YQ	230	/* Cleanup wrapper. */
	231
	232	static void
	233	do_notif_event_xfree (void *arg)
	234	{
19ba03f4	235	notif_event_xfree ((struct notif_event *) arg);
f48ff2a7 YQ	236	}
f48ff2a7 YQ	237
5965e028 YQ	238	/* Return an allocated remote_notif_state. */
	239
	240	struct remote_notif_state *
6b8edb51	241	remote_notif_state_allocate (remote_target *remote)
5965e028	242	{
8d749320	243	struct remote_notif_state *notif_state = XCNEW (struct remote_notif_state);
5965e028	244
6b8edb51 PA	245	notif_state->remote = remote;
6b8edb51 PA	246
5965e028 YQ	247	notif_state->notif_queue = QUEUE_alloc (notif_client_p, NULL);
	248
	249	/* Register async_event_handler for notification. */
	250
	251	notif_state->get_pending_events_token
	252	= create_async_event_handler (remote_async_get_pending_events_handler,
	253	notif_state);
	254
	255	return notif_state;
	256	}
	257
	258	/* Free STATE and its fields. */
	259
	260	void
	261	remote_notif_state_xfree (struct remote_notif_state *state)
722247f1	262	{
f48ff2a7 YQ	263	int i;
f48ff2a7 YQ	264
5965e028 YQ	265	QUEUE_free (notif_client_p, state->notif_queue);
	266
	267	/* Unregister async_event_handler for notification. */
	268	if (state->get_pending_events_token != NULL)
	269	delete_async_event_handler (&state->get_pending_events_token);
722247f1	270
f48ff2a7 YQ	271	for (i = 0; i < REMOTE_NOTIF_LAST; i++)
	272	notif_event_xfree (state->pending_event[i]);
	273
5965e028	274	xfree (state);
722247f1 YQ	275	}
722247f1 YQ	276
722247f1 YQ	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	}