Re: [patch] Change trace buffer size(v3)

["Abid, Hafiz" <hafiz_abid@mentor.com>]

[-- Attachment #1: Type: text/plain, Size: 7054 bytes --]

Hi Pedro,
Thanks for review. Here is an updated patch which tries to addresses  
your comments.

On 01/03/13 20:01:58, Pedro Alves wrote:
> but, OTOH, new packets should really be using packet_ok.
> I think you missed this note.
Fixed.
> 
> Good idea.
> 
> I think it'd be even better to run the test twice, once with
> a larger buffer that fits the same trace frames, and make sure
> the buffer doesn't end up full, and then another time with the
> small buffer.  That'd cover the case of the target's buffer being
> small by default, and the buffer size packet failing to work.
Done.
> 
> Please model from previous examples:
> 
> * New remote packets
> ...
> QTBuffer:circular
>    Set the trace buffer to be linear or circular.
Done.
> 
> > +@item QTBuffer:size:@var{size}
> > +This packet directs the target to make the trace buffer be of size
> > +@var{size} if possible. A value of @code{-1} tells the target to
> > +use whatever size it likes.
> 
> Double space after period.  I think "prefers" is more natural in the
> manual.
Fixed.
> 

> > +  /* If we don't care about the size, or the size is unchanged,
> > +     all is happy and nothing to do.  */
> 
>      s/all is happy and/there's/
Fixed.
> 
> > +  /* Right now we can't change the size during a tracing run.  */
> 
> Let's drop distracting speculation:
>   s/Right now we can't/Can't/
Fixed.
> 
> > +  if (tracing)
> > +    {
> > +       write_enn (own_buf);
> > +       return;
> > +    }
> 
> Better do this check before anything else, avoid
> unnecessary special cases.
Moved to start of function.
> 
> Also, if sval is < 0, this is not checking for "tracing" (fixed
> by doing the check earlier), but also,
> 
> > +  init_trace_buffer (sval);
> 
> ... nor does init_trace_buffer have any logic to
> set the trace buffer size to whatever the "target likes":
I have now added a default size. On -1, that deafult size is used.
> 
>  static void
> -init_trace_buffer (unsigned char *buf, int bufsize)
> +init_trace_buffer (LONGEST bufsize)
>  {
> -  trace_buffer_lo = buf;
> +  trace_buffer_size = bufsize;
> +
> +  /* If we already have a trace buffer, try realloc'ing.  */
> +  trace_buffer_lo = xrealloc (trace_buffer_lo, bufsize);
> +
>    trace_buffer_hi = trace_buffer_lo + bufsize;
> 
>    clear_trace_buffer ();
> 
> 
> Please make sure to test that at least manually, though
> it'd be better if the testsuite also exercised this.
I tested this manualy by running trace experiment to fill the trace  
buffer.
Then changed the size to a larger value and run trace again. It worked  
ok.
> 
> 
> > +static void
> > +remote_set_trace_buffer_size (LONGEST val)
> > +{
> > +  struct remote_state *rs = get_remote_state ();
> > +  char *reply;
> > +  char *buf = rs->buf;
> > +  char *endbuf = rs->buf + get_remote_packet_size ();
> > +
> > +  buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:");
> > +  /* Send -1 as literal "-1" to avoid host size dependency.  */
> > +  if (val == -1)
> > +    buf += xsnprintf (buf, endbuf - buf, "-1");
> > +  else
> > +    buf += hexnumstr (buf, (ULONGEST) val);
> 
> This would mishandle other negative numbers (though
> something else should be preventing those.
> var_zuinteger_unlimited would be one way, though it'd
> probably be a good idea to check for val<0 && val != -1 here too.
Added check for val<0 && val != -1.
> 
> FYI, there's no need to special case -1 actually:
> 
>   if (val < 0)
>     buf += hexnumstr (buf, (ULONGEST) -val);
>   else
>     buf += hexnumstr (buf, (ULONGEST) val);
I did not clearly understand how it works. Because -val will end up  
sending 1. So I kept the
literal -1 as you suggested in previous email. Although I modified the  
check from == -1 to < 0.
> 
> 
> > +
> > +  putpkt (rs->buf);
> > +  reply = remote_get_noisy_reply (&rs->buf, &rs->buf_size);
> > +  if (*rs->buf == '\0')
> 
> Did you try packet_ok?  Really new commands/packets should be
> using it.
I have used packet_ok and related machinery so that gdbserver informs  
about the support of QTBuffer:size packet now.
> 
> > +set BUFFER_SIZE 4
> > +gdb_test_no_output "set trace-buffer-size $BUFFER_SIZE" "Set Trace  
> Buffer Size"
> > +gdb_test "show trace-buffer-size $BUFFER_SIZE" "Requested size of  
> trace buffer is $BUFFER_SIZE.*" \
> > +"Show Trace Buffer Size"
> 
> I think this overflows 80 columns.  Since you're breaking the line,  
> could
> you break it so it doesn't overflow 80 columns, please?
Fixed

> > +
> > +# We set trace buffer to very small size. Then after running  
> trace, we check
> > +# if it is full. This will show if setting trace buffer size  
> really worked.
> 
> Double space after period.
Fixed
> 
> > +gdb_test "tstart"     ".*" ""
> 
> gdb_test_no_output "tstart"
Done
> 
> > +gdb_test "continue"   ".*" ""
> Better to match something rather than ".*".
> Look for "run trace experiment" on other tests.
Fixed.
> 
> > +gdb_test "tstatus"    ".*Trace stopped because the buffer was  
> full.*" \
> > +"Buffer full check"
> 
> Column overflow again, I think.
Fixed.
> 
> gdb_test_test_no_output.
Removed this command as it was not really needed.
> 
> 
> As I mentioned elsewhere, I think it'd be better to use the
> new var_zuinteger_unlimited.
Done.
> 
> We should really fix the broken -1 handling too, before 7.6.
> 
How do you suggest we do that?

Regards,
Abid

2012-03-04  Stan Shebs  <stan@codesourcery.com>
	    Hafiz Abid Qadeer  <abidh@codesourcery.com>

	gdb/
	* NEWS: Mention set and show trace-buffer-size commands.
	Mention new packet.
	* target.h (struct target_ops): New method
	to_set_trace_buffer_size.
	(target_set_trace_buffer_size): New macro.
	* target.c (update_current_target): Set up new method.
	* tracepoint.c (trace_buffer_size): New global.
	(start_tracing): Send it to the target.
	(set_trace_buffer_size): New function.
	(_initialize_tracepoint): Add new setshow for trace-buffer-size.
	* remote.c (remote_set_trace_buffer_size): New function.
	(_initialize_remote): Use it.
	(PACKET_QTBuffer_size): New enum.
	(remote_protocol_features): Added an entry for
	PACKET_QTBuffer_size.

	gdb/gdbserver/
	* tracepoint.c (trace_buffer_size): New global.
	(DEFAULT_TRACE_BUFFER_SIZE): New define.
	(init_trace_buffer): Change to one-argument function, add
	realloc option.
	(handle_tracepoint_general_set): Call cmd_bigqtbuffer_size to
	handle QTBuffer:size packet.
	(cmd_bigqtbuffer_size): New function.
	(initialize_tracepoint): Call init_trace_buffer with
	DEFAULT_TRACE_BUFFER_SIZE.
	* server.c (handle_query): Added QTBuffer:size in the
	supported packets.

	gdb/doc/
	* gdb.texinfo (Starting and Stopping Trace Experiments):  
Document
	trace-buffer-size set and show commands.
	(Tracepoint Packets): Document QTBuffer:size .

	gdb/testsuite/
	* gdb.trace/trace-buffer-size.exp: New file.
	* gdb.trace/trace-buffer-size.c: New file.




[-- Attachment #2: trace-buffer-size_v3.patch --]
[-- Type: text/x-patch, Size: 16884 bytes --]

diff --git a/gdb/NEWS b/gdb/NEWS
index 0877aa2..3fb68eb 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -104,6 +104,10 @@ set debug notification
 show debug notification
   Control display of debugging info for async remote notification.
 
+set trace-buffer-size
+show trace-buffer-size
+  Request target to change the size of trace buffer.
+
 * Removed commands
 
   ** For the Renesas Super-H architecture, the "regs" command has been removed
@@ -159,6 +163,11 @@ show filename-display
   feature to be enabled.  For more information, see:
       http://fedoraproject.org/wiki/Features/MiniDebugInfo
 
+* New remote packets
+
+QTBuffer:size
+   Set the size of trace buffer.
+
 *** Changes in GDB 7.5
 
 * GDB now supports x32 ABI.  Visit <http://sites.google.com/site/x32abi/>
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 5f39d2e..99745f1 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -11728,6 +11728,25 @@ for instance if you are looking at frames from a trace file.
 @end table
 
 @table @code
+@item set trace-buffer-size @var{n}
+@kindex set trace-buffer-size
+Request that the target use a trace buffer of @var{n} bytes.  Not all
+targets will honor the request; they may have a compiled-in size for
+the trace buffer, or some other limitation.  Set to a value of
+@code{-1} to let the target use whatever size it likes.  This is also
+the default.
+
+@item show trace-buffer-size
+@kindex show trace-buffer-size
+Show the current requested size for the trace buffer.  Note that this
+will only match the actual size if the target supports size-setting,
+and was able to handle the requested size.  For instance, if the
+target can only change buffer size between runs, this variable will
+not reflect the change until the next run starts.  Use @code{tstatus}
+to get a report of the actual buffer size.
+@end table
+
+@table @code
 @item set trace-user @var{text}
 @kindex set trace-user
 
@@ -38450,6 +38469,11 @@ available.
 This packet directs the target to use a circular trace buffer if
 @var{value} is 1, or a linear buffer if the value is 0.
 
+@item QTBuffer:size:@var{size}
+This packet directs the target to make the trace buffer be of size
+@var{size} if possible.  A value of @code{-1} tells the target to
+use whatever size it prefers.
+
 @item QTNotes:@r{[}@var{type}:@var{text}@r{]}@r{[};@var{type}:@var{text}@r{]}@dots{}
 @cindex @samp{QTNotes} packet
 This packet adds optional textual notes to the trace run.  Allowable
diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
index 768eae7..922a5bf 100644
--- a/gdb/gdbserver/server.c
+++ b/gdb/gdbserver/server.c
@@ -1637,6 +1637,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
 	  strcat (own_buf, ";qXfer:statictrace:read+");
 	  strcat (own_buf, ";qXfer:traceframe-info:read+");
 	  strcat (own_buf, ";EnableDisableTracepoints+");
+	  strcat (own_buf, ";QTBuffer:size+");
 	  strcat (own_buf, ";tracenz+");
 	}
 
diff --git a/gdb/gdbserver/tracepoint.c b/gdb/gdbserver/tracepoint.c
index 0f83ae6..61d09c0 100644
--- a/gdb/gdbserver/tracepoint.c
+++ b/gdb/gdbserver/tracepoint.c
@@ -30,6 +30,8 @@
 
 #include "ax.h"
 
+#define DEFAULT_TRACE_BUFFER_SIZE 1048576 /* 1024*1024 */
+
 /* This file is built for both GDBserver, and the in-process
    agent (IPA), a shared library that includes a tracing agent that is
    loaded by the inferior to support fast tracepoints.  Fast
@@ -992,6 +994,8 @@ int current_traceframe = -1;
 static int circular_trace_buffer;
 #endif
 
+static LONGEST trace_buffer_size;
+
 /* Pointer to the block of memory that traceframes all go into.  */
 
 static unsigned char *trace_buffer_lo;
@@ -1478,9 +1482,13 @@ clear_inferior_trace_buffer (void)
 #endif
 
 static void
-init_trace_buffer (unsigned char *buf, int bufsize)
+init_trace_buffer (LONGEST bufsize)
 {
-  trace_buffer_lo = buf;
+  trace_buffer_size = bufsize;
+
+  /* If we already have a trace buffer, try realloc'ing.  */
+  trace_buffer_lo = xrealloc (trace_buffer_lo, bufsize);
+
   trace_buffer_hi = trace_buffer_lo + bufsize;
 
   clear_trace_buffer ();
@@ -4020,6 +4028,43 @@ cmd_bigqtbuffer_circular (char *own_buf)
 }
 
 static void
+cmd_bigqtbuffer_size (char *own_buf)
+{
+  ULONGEST val;
+  LONGEST sval;
+  char *packet = own_buf;
+
+  /* Can't change the size during a tracing run.  */
+  if (tracing)
+    {
+      write_enn (own_buf);
+      return;
+    }
+
+  packet += strlen ("QTBuffer:size:");
+
+  /* -1 is sent as literal "-1".  */
+  if (strcmp (packet, "-1") == 0)
+    sval = DEFAULT_TRACE_BUFFER_SIZE;
+  else
+    {
+      unpack_varlen_hex (packet, &val);
+      sval = (LONGEST)val;
+    }
+  /* If the size is unchanged, there's nothing to do.  */
+  if (sval == trace_buffer_size)
+    {
+      write_ok (own_buf);
+      return;
+    }
+
+  init_trace_buffer (sval);
+  trace_debug ("Trace buffer is now %s bytes",
+	       plongest (trace_buffer_size));
+  write_ok (own_buf);
+}
+
+static void
 cmd_qtnotes (char *own_buf)
 {
   size_t nbytes;
@@ -4143,6 +4188,11 @@ handle_tracepoint_general_set (char *packet)
       cmd_bigqtbuffer_circular (packet);
       return 1;
     }
+  else if (strncmp ("QTBuffer:size:", packet, strlen ("QTBuffer:size:")) == 0)
+    {
+      cmd_bigqtbuffer_size (packet);
+      return 1;
+    }
   else if (strncmp ("QTNotes:", packet, strlen ("QTNotes:")) == 0)
     {
       cmd_qtnotes (packet);
@@ -7228,10 +7278,8 @@ get_timestamp (void)
 void
 initialize_tracepoint (void)
 {
-  /* There currently no way to change the buffer size.  */
-  const int sizeOfBuffer = 5 * 1024 * 1024;
-  unsigned char *buf = xmalloc (sizeOfBuffer);
-  init_trace_buffer (buf, sizeOfBuffer);
+  /* Start with the default size.  */
+  init_trace_buffer (DEFAULT_TRACE_BUFFER_SIZE);
 
   /* Wire trace state variable 1 to be the timestamp.  This will be
      uploaded to GDB upon connection and become one of its trace state
diff --git a/gdb/remote.c b/gdb/remote.c
index 88a57c8..6e9a59b 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1284,6 +1284,7 @@ enum {
   PACKET_qXfer_fdpic,
   PACKET_QDisableRandomization,
   PACKET_QAgent,
+  PACKET_QTBuffer_size,
   PACKET_MAX
 };
 
@@ -3993,6 +3994,8 @@ static struct protocol_feature remote_protocol_features[] = {
   { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
     PACKET_QDisableRandomization },
   { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
+  { "QTBuffer:size", PACKET_DISABLE,
+    remote_supported_packet, PACKET_QTBuffer_size},
   { "tracenz", PACKET_DISABLE,
     remote_string_tracing_feature, -1 },
 };
@@ -11042,6 +11045,41 @@ remote_get_min_fast_tracepoint_insn_len (void)
     }
 }
 
+static void
+remote_set_trace_buffer_size (LONGEST val)
+{
+  if (remote_protocol_packets[PACKET_QTBuffer_size].support !=
+      PACKET_DISABLE)
+    {
+      struct remote_state *rs = get_remote_state ();
+      char *buf = rs->buf;
+      char *endbuf = rs->buf + get_remote_packet_size ();
+      enum packet_result result;
+
+      if (val < 0 && val != -1)
+	{
+	  warning (_("Invalid value %s for the size of trace buffer."),
+		   plongest (val) );
+	  return;
+	}
+
+      buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:");
+      /* Send -1 as literal "-1" to avoid host size dependency.  */
+      if (val < 0)
+	buf += xsnprintf (buf, endbuf - buf, "-1");
+      else
+	buf += hexnumstr (buf, (ULONGEST) val);
+
+      putpkt (rs->buf);
+      getpkt (&rs->buf, &rs->buf_size, 0);
+      result = packet_ok (rs->buf,
+		  &remote_protocol_packets[PACKET_QTBuffer_size]);
+
+      if (result != PACKET_OK)
+	warning (_("Bogus reply from target: %s"), rs->buf);
+    }
+}
+
 static int
 remote_set_trace_notes (char *user, char *notes, char *stop_notes)
 {
@@ -11219,6 +11257,7 @@ Specify the serial device it is connected to\n\
   remote_ops.to_get_min_fast_tracepoint_insn_len = remote_get_min_fast_tracepoint_insn_len;
   remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing;
   remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer;
+  remote_ops.to_set_trace_buffer_size = remote_set_trace_buffer_size;
   remote_ops.to_set_trace_notes = remote_set_trace_notes;
   remote_ops.to_core_of_thread = remote_core_of_thread;
   remote_ops.to_verify_memory = remote_verify_memory;
@@ -11755,6 +11794,9 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
   add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
 			 "QAgent", "agent", 0);
 
+  add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size],
+			 "QTBuffer:size", "trace-buffer-size", 0);
+
   /* Keep the old ``set remote Z-packet ...'' working.  Each individual
      Z sub-packet has its own set and show commands, but users may
      have sets to this variable in their .gdbinit files (or in their
diff --git a/gdb/target.c b/gdb/target.c
index 9d8bf6e..2e507e0 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -693,6 +693,7 @@ update_current_target (void)
       INHERIT (to_get_min_fast_tracepoint_insn_len, t);
       INHERIT (to_set_disconnected_tracing, t);
       INHERIT (to_set_circular_trace_buffer, t);
+      INHERIT (to_set_trace_buffer_size, t);
       INHERIT (to_set_trace_notes, t);
       INHERIT (to_get_tib_address, t);
       INHERIT (to_set_permissions, t);
@@ -912,6 +913,9 @@ update_current_target (void)
   de_fault (to_set_circular_trace_buffer,
 	    (void (*) (int))
 	    target_ignore);
+  de_fault (to_set_trace_buffer_size,
+	    (void (*) (LONGEST))
+	    target_ignore);
   de_fault (to_set_trace_notes,
 	    (int (*) (char *, char *, char *))
 	    return_zero);
diff --git a/gdb/target.h b/gdb/target.h
index 1971265..c99642d 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -806,6 +806,8 @@ struct target_ops
        disconnection - set VAL to 1 to keep tracing, 0 to stop.  */
     void (*to_set_disconnected_tracing) (int val);
     void (*to_set_circular_trace_buffer) (int val);
+    /* Set the size of trace buffer in the target.  */
+    void (*to_set_trace_buffer_size) (LONGEST val);
 
     /* Add/change textual notes about the trace run, returning 1 if
        successful, 0 otherwise.  */
@@ -1700,6 +1702,9 @@ extern char *target_fileio_read_stralloc (const char *filename);
 #define	target_set_circular_trace_buffer(val)	\
   (*current_target.to_set_circular_trace_buffer) (val)
 
+#define	target_set_trace_buffer_size(val)	\
+  (*current_target.to_set_trace_buffer_size) (val)
+
 #define	target_set_trace_notes(user,notes,stopnotes)		\
   (*current_target.to_set_trace_notes) ((user), (notes), (stopnotes))
 
diff --git a/gdb/testsuite/gdb.trace/trace-buffer-size.c b/gdb/testsuite/gdb.trace/trace-buffer-size.c
new file mode 100644
index 0000000..e32b756
--- /dev/null
+++ b/gdb/testsuite/gdb.trace/trace-buffer-size.c
@@ -0,0 +1,31 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2011-2013 Free Software Foundation, Inc.
+
+   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/>.  */
+
+int var = 10;
+
+int
+test_function ()
+{
+  return 0;
+}
+
+int
+main ()
+{
+  test_function (); 
+  return 0; /*breakpoint1*/
+}
diff --git a/gdb/testsuite/gdb.trace/trace-buffer-size.exp b/gdb/testsuite/gdb.trace/trace-buffer-size.exp
new file mode 100644
index 0000000..7891cc6
--- /dev/null
+++ b/gdb/testsuite/gdb.trace/trace-buffer-size.exp
@@ -0,0 +1,79 @@
+# Copyright 1998-2013 Free Software Foundation, Inc.
+
+# 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/>.
+
+load_lib "trace-support.exp"
+
+standard_testfile
+
+if [prepare_for_testing ${testfile}.exp $testfile $srcfile \
+        {debug nowarnings}] {
+    untested "failed to prepare for trace tests"
+    return -1
+}
+
+if ![runto_main] {
+    fail "can't run to main to check for trace support"
+    return -1
+}
+
+if ![gdb_target_supports_trace] {
+    unsupported "target does not support trace"
+    return -1;
+}
+
+set BUFFER_SIZE 4
+gdb_test_no_output \
+"set trace-buffer-size $BUFFER_SIZE" \
+"Set Trace Buffer Size"
+
+gdb_test "show trace-buffer-size $BUFFER_SIZE" \
+"Requested size of trace buffer is $BUFFER_SIZE.*" \
+"Show Trace Buffer Size"
+
+# We set trace buffer to very small size.  Then after running trace,
+# we check if it is full.  This will show if setting trace buffer
+# size really worked.
+gdb_breakpoint ${srcfile}:[gdb_get_line_number "breakpoint1"]
+gdb_test "trace test_function" \
+  "Tracepoint \[0-9\]+ at .*" \
+  "set tracepoint at test_function"
+gdb_trace_setactions "Set action for trace point 1" "" \
+  "collect var" "^$"
+gdb_test_no_output "tstart" 
+gdb_test "continue" \
+  "Continuing.*Breakpoint $decimal.*" \
+  "run trace experiment 1"
+gdb_test "tstatus" \
+  ".*Trace stopped because the buffer was full.*" \
+  "Buffer full check 1"
+
+# Use the default size  and trace buffer should not be
+# full this time.
+clean_restart ${testfile}
+runto_main
+gdb_breakpoint ${srcfile}:[gdb_get_line_number "breakpoint1"]
+gdb_test "trace test_function" \
+  "Tracepoint \[0-9\]+ at .*" \
+  "set tracepoint at test_function"
+gdb_trace_setactions "Set action for trace point 2" "" \
+  "collect var" "^$"
+gdb_test_no_output "tstart" 
+gdb_test "continue" \
+  "Continuing.*Breakpoint $decimal.*" \
+  "run trace experiment 2"
+gdb_test "tstatus" \
+  ".*Trace is running on the target.*" \
+  "Buffer full check 2"
+gdb_test_no_output "tstop"
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 9a80aa3..b8945bb 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -173,6 +173,11 @@ static int disconnected_tracing;
 
 static int circular_trace_buffer;
 
+/* This variable is the requested trace buffer size, or -1 to indicate
+   that we don't care and leave it up to the target to set a size.  */
+
+static int trace_buffer_size = -1;
+
 /* Textual notes applying to the current and/or future trace runs.  */
 
 char *trace_user = NULL;
@@ -1829,6 +1834,7 @@ start_tracing (char *notes)
   /* Set some mode flags.  */
   target_set_disconnected_tracing (disconnected_tracing);
   target_set_circular_trace_buffer (circular_trace_buffer);
+  target_set_trace_buffer_size (trace_buffer_size);
 
   if (!notes)
     notes = trace_notes;
@@ -3231,6 +3237,13 @@ set_circular_trace_buffer (char *args, int from_tty,
 }
 
 static void
+set_trace_buffer_size (char *args, int from_tty,
+			   struct cmd_list_element *c)
+{
+  target_set_trace_buffer_size (trace_buffer_size);
+}
+
+static void
 set_trace_user (char *args, int from_tty,
 		struct cmd_list_element *c)
 {
@@ -5416,6 +5429,16 @@ up and stopping the trace run."),
 			   &setlist,
 			   &showlist);
 
+  add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
+			    &trace_buffer_size, _("\
+Set requested size of trace buffer."), _("\
+Show requested size of trace buffer."), _("\
+Use this to choose a size for the trace buffer.  Some targets\n\
+may have fixed or limited buffer sizes.  A value of -1 disables\n\
+any attempt to set the buffer size and lets the target choose."),
+			    set_trace_buffer_size, NULL,
+			    &setlist, &showlist);
+
   add_setshow_string_cmd ("trace-user", class_trace,
 			  &trace_user, _("\
 Set the user name to use for current and future trace runs"), _("\