Re: [PATCH 1/6] Move notif_queue to remote_state

[Yao Qi <yao@codesourcery.com>]

On 10/02/2013 06:48 PM, Pedro Alves wrote:
> Since remote_async_get_pending_events_token is no longer a global,
> it doesn't need the "remote_" prefix (or even remote_async_?) anymore.
> WDYT?

Yeah, I agree.  I thought of this renaming during writing the patch,
but I didn't do that to keep the patch simple.

> 
> The patch is OK with or without that change.

Patch below is what I committed, with the renaming.

-- 
Yao (齐尧)

gdb:

2013-10-04  Yao Qi  <yao@codesourcery.com>

	* remote-notif.c (DECLARE_QUEUE_P): Remove.
	(notif_queue): Remove.
	(remote_notif_process): Add one parameter 'notif_queue'.
	Update comments.  Callers update.
	(remote_async_get_pending_events_token): Remove.
	(remote_notif_register_async_event_handler): Remove.
	(remote_notif_unregister_async_event_handler): Remove.
	(handle_notification): Add parameter 'notif_queue'.  Update
	comments.  Callers update.
	(notif_xfree): Remove.
	(remote_notif_state_allocate): New function.
	(remote_notif_state_xfree): New function.
	(_initialize_notif): Remove code to allocate queue.
	* remote-notif.h (DECLARE_QUEUE_P): Moved from remote-notif.c.
	(struct remote_notif_state): New.
	(handle_notification): Update declaration.
	(remote_notif_process): Likewise.
	(remote_notif_register_async_event_handler): Remove.
	(remote_notif_unregister_async_event_handler): Remove.
	(remote_notif_state_allocate): Declare.
	(remote_notif_state_xfree): Declare.
	* remote.c (struct remote_state) <notif_state>: New field.
	(remote_close): Don't call
	remote_notif_unregister_async_event_handler.  Call
	remote_notif_state_xfree.
	(remote_open_1): Don't call
	remote_notif_register_async_event_handler.  Call
	remote_notif_state_allocate.
---
 gdb/remote-notif.c |   88 +++++++++++++++++++++++----------------------------
 gdb/remote-notif.h |   28 ++++++++++++++--
 gdb/remote.c       |   13 +++++---
 3 files changed, 72 insertions(+), 57 deletions(-)

diff --git a/gdb/remote-notif.c b/gdb/remote-notif.c
index 0f73a52..905b8a1 100644
--- a/gdb/remote-notif.c
+++ b/gdb/remote-notif.c
@@ -91,21 +91,19 @@ remote_notif_parse (struct notif_client *nc, char *buf)
   return event;
 }
 
-DECLARE_QUEUE_P (notif_client_p);
 DEFINE_QUEUE_P (notif_client_p);
 
-static QUEUE(notif_client_p) *notif_queue;
-
-/* Process notifications one by one.  EXCEPT is not expected in
-   the queue.  */
+/* Process notifications in STATE's notification queue one by one.
+   EXCEPT is not expected in the queue.  */
 
 void
-remote_notif_process (struct notif_client *except)
+remote_notif_process (struct remote_notif_state *state,
+		      struct notif_client *except)
 {
-  while (!QUEUE_is_empty (notif_client_p, notif_queue))
+  while (!QUEUE_is_empty (notif_client_p, state->notif_queue))
     {
       struct notif_client *nc = QUEUE_deque (notif_client_p,
-					     notif_queue);
+					     state->notif_queue);
 
       gdb_assert (nc != except);
 
@@ -118,39 +116,14 @@ static void
 remote_async_get_pending_events_handler (gdb_client_data data)
 {
   gdb_assert (non_stop);
-  remote_notif_process (NULL);
-}
-
-/* Asynchronous signal handle registered as event loop source for when
-   the remote sent us a notification.  The registered callback
-   will do a ACK sequence to pull the rest of the events out of
-   the remote side into our event queue.  */
-
-static struct async_event_handler *remote_async_get_pending_events_token;
-
-/* Register async_event_handler for notification.  */
-
-void
-remote_notif_register_async_event_handler (void)
-{
-  remote_async_get_pending_events_token
-    = create_async_event_handler (remote_async_get_pending_events_handler,
-				  NULL);
-}
-
-/* Unregister async_event_handler for notification.  */
-
-void
-remote_notif_unregister_async_event_handler (void)
-{
-  if (remote_async_get_pending_events_token)
-    delete_async_event_handler (&remote_async_get_pending_events_token);
+  remote_notif_process (data, NULL);
 }
 
-/* Remote notification handler.  */
+/* Remote notification handler.  Parse BUF, queue notification and
+   update STATE.  */
 
 void
-handle_notification (char *buf)
+handle_notification (struct remote_notif_state *state, char *buf)
 {
   struct notif_client *nc = NULL;
   int i;
@@ -188,7 +161,7 @@ handle_notification (char *buf)
 
       /* 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, notif_queue, nc);
+      QUEUE_enque (notif_client_p, state->notif_queue, nc);
       if (non_stop)
 	{
 	  /* In non-stop, We mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
@@ -227,7 +200,7 @@ handle_notification (char *buf)
 	     2.3) <-- T05 thread:2
 
 	     These pending notifications can be processed later.  */
-	  mark_async_event_handler (remote_async_get_pending_events_token);
+	  mark_async_event_handler (state->get_pending_events_token);
 	}
 
       if (notif_debug)
@@ -250,15 +223,36 @@ do_notif_event_xfree (void *arg)
   xfree (event);
 }
 
-static void
-notif_xfree (struct notif_client *notif)
+/* 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)
 {
-  if (notif->pending_event != NULL
-      && notif->pending_event->dtr != NULL)
-    notif->pending_event->dtr (notif->pending_event);
+  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);
 
-  xfree (notif->pending_event);
-  xfree (notif);
+  xfree (state);
 }
 
 /* -Wmissing-prototypes */
@@ -267,8 +261,6 @@ extern initialize_file_ftype _initialize_notif;
 void
 _initialize_notif (void)
 {
-  notif_queue = QUEUE_alloc (notif_client_p, notif_xfree);
-
   add_setshow_boolean_cmd ("notification", no_class, &notif_debug,
 			   _("\
 Set debugging of async remote notification."), _("\
diff --git a/gdb/remote-notif.h b/gdb/remote-notif.h
index da4fdea..4c3617e 100644
--- a/gdb/remote-notif.h
+++ b/gdb/remote-notif.h
@@ -68,16 +68,36 @@ typedef struct notif_client
   struct notif_event *pending_event;
 } *notif_client_p;
 
+DECLARE_QUEUE_P (notif_client_p);
+
+/* State on remote async notification.  */
+
+struct remote_notif_state
+{
+  /* Notification queue.  */
+
+  QUEUE(notif_client_p) *notif_queue;
+
+  /* Asynchronous signal handle registered as event loop source for when
+     the remote sent us a notification.  The registered callback
+     will do a ACK sequence to pull the rest of the events out of
+     the remote side into our event queue.  */
+
+  struct async_event_handler *get_pending_events_token;
+};
+
 void remote_notif_ack (struct notif_client *nc, char *buf);
 struct notif_event *remote_notif_parse (struct notif_client *nc,
 					char *buf);
 
-void handle_notification (char *buf);
+void handle_notification (struct remote_notif_state *notif_state,
+			  char *buf);
 
-void remote_notif_register_async_event_handler (void);
-void remote_notif_unregister_async_event_handler (void);
+void remote_notif_process (struct remote_notif_state *state,
+			   struct notif_client *except);
+struct remote_notif_state *remote_notif_state_allocate (void);
+void remote_notif_state_xfree (struct remote_notif_state *state);
 
-void remote_notif_process (struct notif_client *except);
 extern struct notif_client notif_client_stop;
 
 extern int notif_debug;
diff --git a/gdb/remote.c b/gdb/remote.c
index a9ef297..6ac3f51 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -425,6 +425,9 @@ struct remote_state
   threadref echo_nextthread;
   threadref nextthread;
   threadref resultthreadlist[MAXTHREADLISTRESULTS];
+
+  /* The state of remote notification.  */
+  struct remote_notif_state *notif_state;
 };
 
 /* Private data that we'll store in (struct thread_info)->private.  */
@@ -3073,7 +3076,7 @@ remote_close (void)
   if (remote_async_inferior_event_token)
     delete_async_event_handler (&remote_async_inferior_event_token);
 
-  remote_notif_unregister_async_event_handler ();
+  remote_notif_state_xfree (rs->notif_state);
 
   trace_reset_local_state ();
 }
@@ -4337,7 +4340,7 @@ remote_open_1 (char *name, int from_tty,
   remote_async_inferior_event_token
     = create_async_event_handler (remote_async_inferior_event_handler,
 				  NULL);
-  remote_notif_register_async_event_handler ();
+  rs->notif_state = remote_notif_state_allocate ();
 
   /* Reset the target state; these things will be queried either by
      remote_query_supported or as they are needed.  */
@@ -4931,7 +4934,7 @@ remote_resume (struct target_ops *ops,
      before resuming inferior, because inferior was stopped and no RSP
      traffic at that moment.  */
   if (!non_stop)
-    remote_notif_process (&notif_client_stop);
+    remote_notif_process (rs->notif_state, &notif_client_stop);
 
   rs->last_sent_signal = siggnal;
   rs->last_sent_step = step;
@@ -7352,7 +7355,7 @@ putpkt_binary (char *buf, int cnt)
 					    str);
 			do_cleanups (old_chain);
 		      }
-		    handle_notification (rs->buf);
+		    handle_notification (rs->notif_state, rs->buf);
 		    /* We're in sync now, rewait for the ack.  */
 		    tcount = 0;
 		  }
@@ -7738,7 +7741,7 @@ getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
 	  if (is_notif != NULL)
 	    *is_notif = 1;
 
-	  handle_notification (*buf);
+	  handle_notification (rs->notif_state, *buf);
 
 	  /* Notifications require no acknowledgement.  */
 
-- 
1.7.7.6