Patchwork [v8,3/7] Extended-remote Linux follow fork

login
register
mail settings
Submitter Don Breazeal
Date April 17, 2015, 8:58 p.m.
Message ID <1429304325-13878-4-git-send-email-donb@codesourcery.com>
Download mbox | patch
Permalink /patch/6308/
State New
Headers show

Comments

Don Breazeal - April 17, 2015, 8:58 p.m.
Hi Pedro,

This version of the patch incorporates changes based on your comments on
the previous version here:
https://sourceware.org/ml/gdb-patches/2015-04/msg00573.html.

On 4/15/2015 8:38 AM, Pedro Alves wrote:
> On 04/10/2015 06:09 PM, Don Breazeal wrote:
> 
>>>>  /* Do low-level handling of the event, and check if we should go on
>>>>     and pass it to caller code.  Return the affected lwp if we are, or
>>>>     NULL otherwise.  */
>>>> @@ -1912,11 +1983,11 @@ linux_low_filter_event (int lwpid, int wstat)
>>>>  	}
>>>>      }
>>>>  
>>>> -  if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
>>>> +  if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags && gdb_connected ())
>>>>      {
>>>
>>> I don't really understand this.  If the flag is set, why would it matter
>>> whether gdb is connected?
>>
>> My thinking was that there was no point in setting the ptrace options 
>> until GDB had connected, since the qSupported packet right after connection
>> would cause a reset of the ptrace options. However, your point is taken, it
>> doesn't really matter, so I have remove the call to gdb_connected.
> 
> It's not just that it doesn't matter; it's really wrong.  If we attach to
> a multi-threaded program in non-stop mode, and set some tracepoints and
> detach for disconnected tracing before all threads stop and set their
> ptrace flags, we'll miss setting the ptrace options on some threads.
> But we need to be able to at least follow clone events in that case.

OK, thanks.

---snip snip---

> 
>>>
>>>> +static int
>>>> +remote_follow_fork (struct target_ops *ops, int follow_child,
>>>> +		    int detach_fork)
>>>> +{
>>>> +  struct remote_state *rs = get_remote_state ();
>>>> +
>>>> +  if (remote_fork_event_p (rs))
>>>> +    {
>>>> +      if (detach_fork && !follow_child)
>>>
>>> Aren't we missing the "detach_fork && follow_child" case?
>>
>> That case is handled in the target-independent code in infrun.c by 
>> calling target_detach.  
> 
> Could you add a one-liner comment mentioning that?

Done, a bit more than one line.

> 
>> @@ -449,6 +451,57 @@ handle_extended_wait (struct lwp_info *event_child, int wstat)
>>  	    warning ("wait returned unexpected status 0x%x", status);
>>  	}
>>  
>> +      if (event == PTRACE_EVENT_FORK)
>> +	{
>> +	  struct process_info *parent_proc;
>> +	  struct process_info *child_proc;
>> +	  struct lwp_info *child_lwp;
>> +	  struct target_desc *tdesc;
>> +
>> +	  ptid = ptid_build (new_pid, new_pid, 0);
>> +
>> +	  if (debug_threads)
>> +	    {
>> +	      debug_printf ("HEW: Got fork event from LWP %ld, "
>> +			    "new child is %d\n",
>> +			    ptid_get_lwp (ptid_of (event_thr)),
>> +			    ptid_get_pid (ptid));
>> +	    }
>> +
>> +	  /* Add the new process to the tables and clone the breakpoint
>> +	     lists of the parent.  We need to do this even if the new process
>> +	     will be detached, since we will need the process object and the
>> +	     breakpoints to remove any breakpoints from memory when we
>> +	     detach, and the host side will access registers.  */
> 
> Say "client side" instead of "host side".

Done.

> 
> 
>> +/* Callback for 'find_inferior'.  Set the (possibly changed) ptrace
>> +   options for the specified lwp.  */
>> +
>> +static int
>> +reset_lwp_ptrace_options_callback (struct inferior_list_entry *entry,
>> +				   void *args)
>> +{
>> +  struct thread_info *thread = (struct thread_info *) entry;
>> +  struct lwp_info *lwp = get_thread_lwp (thread);
>> +  struct process_info *proc = find_process_pid (pid_of (thread));
>> +  int options = linux_low_ptrace_options (proc->attached);
>> +
>> +  if (!lwp->stopped)
>> +    {
>> +      /* Stop the lwp so we can modify its ptrace options.  */
>> +      linux_stop_lwp (lwp);
>> +    }
>> +
>> +  linux_enable_event_reporting (lwpid_of (thread), options);
>> +  lwp->must_set_ptrace_flags = 0;
> 
> This still has the same problem.  linux_stop_lwp does not
> wait for the LWP to stop, it just sends it a SIGSTOP signal.
> We can only set the ptrace options when the LWP ptrace-stops,
> that is, after we see it stop with waitpid.  That is the whole
> point of the must_set_ptrace_flags flag.  Do it like this:
> 
>   if (!lwp->stopped)
>     {
>       /* Stop the lwp so we can modify its ptrace options.  */
>       lwp->must_set_ptrace_flags = 1;
>       stop_lwp (lwp);
>     }
>   else
>     {
>        /* Already stopped; go ahead and set the ptrace options.  */
>        struct process_info *proc = find_process_pid (pid_of (thread));
>        int options = linux_low_ptrace_options (proc->attached);
> 
>        linux_enable_event_reporting (lwpid_of (thread), options);
>     }
> 

Sheesh.  Thanks.

> 
> 
>>  
>> +static int
>> +linux_nat_ptrace_options (int attached)
> 
> Missing intro comment.

Fixed.

---snip snip---

>> --- a/gdb/nat/linux-ptrace.c
>> +++ b/gdb/nat/linux-ptrace.c
>> @@ -25,14 +25,10 @@
>>  
>>  #include <stdint.h>
>>  
>> -/* Stores the currently supported ptrace options.  A value of
>> -   -1 means we did not check for features yet.  A value of 0 means
>> -   there are no supported features.  */
>> -static int current_ptrace_options = -1;
>> -
>> -/* Additional flags to test.  */
>> -
>> -static int additional_flags;
>> +/* Stores the ptrace options supported by the target.
> 
> s/by the target/by the running kernel/

Done.

> 
>> +   A value of -1 means we did not check for features yet.  A value
>> +   of 0 means there are no supported features.  */
>> +static int supported_ptrace_options = -1;
>>  
>>  /* Find all possible reasons we could fail to attach PID and append
>>     these as strings to the already initialized BUFFER.  '\0'
>> @@ -343,7 +339,7 @@ linux_check_ptrace_features (void)
>>    int child_pid, ret, status;
>>  
>>    /* Initialize the options.  */
>> -  current_ptrace_options = 0;
>> +  supported_ptrace_options = 0;
>>  
>>    /* Fork a child so we can do some testing.  The child will call
>>       linux_child_function and will get traced.  The child will
>> @@ -387,14 +383,11 @@ linux_test_for_tracesysgood (int child_pid)
>>  {
>>    int ret;
>>  
>> -  if ((additional_flags & PTRACE_O_TRACESYSGOOD) == 0)
>> -    return;
>> -
>>    ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
>>  		(PTRACE_TYPE_ARG4) PTRACE_O_TRACESYSGOOD);
>>  
>>    if (ret == 0)
>> -    current_ptrace_options |= PTRACE_O_TRACESYSGOOD;
>> +    supported_ptrace_options |= PTRACE_O_TRACESYSGOOD;
>>  }
>>  
>>  /* Determine if PTRACE_O_TRACEFORK can be used to follow fork
>> @@ -414,15 +407,12 @@ linux_test_for_tracefork (int child_pid)
>>    if (ret != 0)
>>      return;
>>  
>> -  if ((additional_flags & PTRACE_O_TRACEVFORKDONE) != 0)
>> -    {
>> -      /* Check if the target supports PTRACE_O_TRACEVFORKDONE.  */
>> -      ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
>> -		    (PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
>> -					| PTRACE_O_TRACEVFORKDONE));
>> -      if (ret == 0)
>> -	current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
>> -    }
>> +  /* Check if the target supports PTRACE_O_TRACEVFORKDONE.  */
>> +  ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
>> +		(PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
>> +				    | PTRACE_O_TRACEVFORKDONE));
>> +  if (ret == 0)
>> +    supported_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
>>  
>>    /* Setting PTRACE_O_TRACEFORK did not cause an error, however we
>>       don't know for sure that the feature is available; old
>> @@ -458,10 +448,13 @@ linux_test_for_tracefork (int child_pid)
>>  
>>  	  /* We got the PID from the grandchild, which means fork
>>  	     tracing is supported.  */
>> -	  current_ptrace_options |= PTRACE_O_TRACECLONE;
>> -	  current_ptrace_options |= (additional_flags & (PTRACE_O_TRACEFORK
>> -                                                         | PTRACE_O_TRACEVFORK
>> -                                                         | PTRACE_O_TRACEEXEC));
>> +	  supported_ptrace_options |= PTRACE_O_TRACECLONE;
>> +
>> +	  /* Save the "extended" options in case we need to reset
>> +	     the options later for a connect from a different GDB.  */
> 
> Remove now stale comment.

Done.

> 
>> +	  supported_ptrace_options |= (PTRACE_O_TRACEFORK
>> +				       | PTRACE_O_TRACEVFORK
>> +				       | PTRACE_O_TRACEEXEC);
>>  
>>  	  /* Do some cleanup and kill the grandchild.  */
>>  	  my_waitpid (second_pid, &second_status, 0);
> 
>>  
>>  /* Enable reporting of all currently supported ptrace events.
>>     ATTACHED should be nonzero if we have attached to the inferior.  */
> 
> Update comment.  I had suggested:
> 
> /* Enable reporting of all currently supported ptrace events.
>    OPTIONS is a bit mask of extended features we want enabled,
>    if supported by the kernel.  PTRACE_O_TRACECLONE is always
>    enabled, if supported.  */

Ow, sorry for the repeat.  There are several things that were somehow
dropped from the final version of my patch.  Hopefully things are 
better this time around.

---snip snip---

>>  static void
>> -remote_detach_1 (const char *args, int from_tty, int extended)
>> +remote_detach_1 (const char *args, int from_tty, int is_fork_child)
> 
> Do we still need this "is_fork_child" change?  I don't see where
> any caller has been updated in this version of the patch.  AFAICS
> current callers still pass "extended":

This is another item that I apparently dropped from the final version
of the last patch. :-/  We no longer need the is_fork_child change, nor
do we need the 'extended' argument since we can get that information
from struct remote_state.

> 
> static void
> remote_detach (struct target_ops *ops, const char *args, int from_tty)
> {
>   remote_detach_1 (args, from_tty, 0);
> }
> 
> static void
> extended_remote_detach (struct target_ops *ops, const char *args, int from_tty)
> {
>   remote_detach_1 (args, from_tty, 1);
> }
> 
> So something doesn't feel right here.

Fixed in this version.

> 
>>  {
>>    int pid = ptid_get_pid (inferior_ptid);
>>    struct remote_state *rs = get_remote_state ();
>> +  struct thread_info *tp = find_thread_ptid (inferior_ptid);
>> +  int is_fork_parent;
>>  
>>    if (args)
>>      error (_("Argument given to \"detach\" when remotely debugging."));
>> @@ -4447,25 +4483,25 @@ remote_detach_1 (const char *args, int from_tty, int extended)
>>      }
>>  
>>    /* Tell the remote target to detach.  */
>> -  if (remote_multi_process_p (rs))
>> -    xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
>> -  else
>> -    strcpy (rs->buf, "D");
>> +  remote_detach_pid (pid);
>>  
>> -  putpkt (rs->buf);
>> -  getpkt (&rs->buf, &rs->buf_size, 0);
>> -
>> -  if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
>> -    ;
>> -  else if (rs->buf[0] == '\0')
>> -    error (_("Remote doesn't know how to detach"));
>> -  else
>> -    error (_("Can't detach process."));
>> -
>> -  if (from_tty && !extended)
>> +  if (from_tty && !rs->extended)
>>      puts_filtered (_("Ending remote debugging.\n"));
>>  
>> -  target_mourn_inferior ();
>> +  /* Check to see if we are detaching a fork parent.  Note that if we
>> +     are detaching a fork child, tp == NULL.  */
>> +  if (tp != NULL)
>> +    is_fork_parent = tp->pending_follow.kind == TARGET_WAITKIND_FORKED;
>> +
>> +  /* If doing detach-on-fork, we don't mourn, because that will delete
>> +     breakpoints that should be available for the followed inferior.  */
> 
> How does this work in the native case then?

In this scenario we are following the fork child and detaching from
the parent, which is sending us through the target's detach code.

In the native Linux case the detach code is linux_nat_detach, which in
turn calls inf_ptrace_detach.  There is no call to target_mourn_inferior
in this sequence of function calls, so the breakpoints aren't affected
at that point.  The breakpoints are "fixed up" for the child by
follow_inferior_reset_breakpoints at the very end of follow_fork, at
which point the child inferior has been set up.

The is_fork_parent condition in remote_detach_1 preventing the call
to target_mourn_inferior essentially makes the procedure the same as
for the native case.

> 
>> +  if (!is_fork_child && !is_fork_parent)
>> +    target_mourn_inferior ();
>> +  else
>> +    {
>> +      inferior_ptid = null_ptid;
>> +      detach_inferior (pid);
>> +    }
>>  }
>>  
> 
> Thanks,
> Pedro Alves
> 

Thanks
--Don

This patch implements basic support for follow-fork and detach-on-fork on
extended-remote Linux targets.  Only 'fork' is supported in this patch;
'vfork' support is added n a subsequent patch.  This patch depends on 
the previous patches in the patch series.

Sufficient extended-remote functionality has been implemented here to pass
gdb.base/multi-forks.exp, as well as gdb.base/foll-fork.exp with the
catchpoint tests commented out.  Some other fork tests fail with this
patch because it doesn't provide the architecture support needed for
watchpoint inheritance or fork catchpoints.

The implementation follows the same general structure as for the native
implementation as much as possible.

This implementation includes:
 * enabling fork events in linux-low.c in initialize_low and
   linux_enable_extended_features

 * handling fork events in gdbserver/linux-low.c:handle_extended_wait

   - when a fork event occurs in gdbserver, we must do the full creation
     of the new process, thread, lwp, and breakpoint lists.  This is
     required whether or not the new child is destined to be
     detached-on-fork, because GDB will make target calls that require all
     the structures.  In particular we need the breakpoint lists in order
     to remove the breakpoints from a detaching child.  If we are not
     detaching the child we will need all these structures anyway.

   - as part of this event handling we store the target_waitstatus in a new
     member of the parent lwp_info structure, 'waitstatus'.  This
     is used to store extended event information for reporting to GDB.

   - handle_extended_wait is given a return value, denoting whether the
     handled event should be reported to GDB.  Previously it had only
     handled clone events, which were never reported.

 * using a new predicate in gdbserver to control handling of the fork event
   (and eventually all extended events) in linux_wait_1.  The predicate,
   extended_event_reported, checks a target_waitstatus.kind for an
   extended ptrace event.

 * implementing a new RSP 'T' Stop Reply Packet stop reason: "fork", in
   gdbserver/remote-utils.c and remote.c.

 * implementing new target and RSP support for target_follow_fork with
   target extended-remote.  (The RSP components were actually defined in
   patch 1, but they see their first use here).

   - remote target routine remote_follow_fork, which just sends the 'D;pid'
     detach packet to detach the new fork child cleanly.  We can't just
     call target_detach because the data structures for the forked child
     have not been allocated on the host side.

Tested on x64 Ubuntu Lucid, native, remote, extended-remote.

gdb/gdbserver/
2015-04-17  Don Breazeal  <donb@codesourcery.com>

	* linux-low.c (handle_extended_wait): Implement return value,
	rename argument 'event_child' to 'event_lwp', handle
	PTRACE_EVENT_FORK, call internal_error for unrecognized event.
	(linux_low_ptrace_options): New function.
	(linux_low_filter_event): Call linux_low_ptrace_options,
	use different argument fo linux_enable_event_reporting,
	use return value from handle_extended_wait.
	(extended_event_reported): New function.
	(linux_wait_1): Call extended_event_reported and set
	status to report fork events.
	(linux_write_memory): Add pid to debug message.
	(reset_lwp_ptrace_options_callback): New function.
	(linux_handle_new_gdb_connection): New function.
	(linux_target_ops): Initialize new structure member.
	* linux-low.h (struct lwp_info) <waitstatus>: New member.
	* lynx-low.c: Initialize new structure member.
	* remote-utils.c (prepare_resume_reply): Implement stop reason
	"fork" for "T" stop message.
	* server.c (handle_query): Call handle_new_gdb_connection.
	* server.h (report_fork_events): Declare global flag.
	* target.h (struct target_ops) <handle_new_gdb_connection>:
	New member.
	(target_handle_new_gdb_connection): New macro.
	* win32-low.c: Initialize new structure member.

gdb/
2015-04-17  Don Breazeal  <donb@codesourcery.com>

	* linux-nat.c (linux_nat_ptrace_options): New function.
	(linux_init_ptrace, wait_lwp, linux_nat_filter_event):
	Call linux_nat_ptrace_options and use different argument to
	linux_enable_event_reporting.
	(_initialize_linux_nat): Delete call to
	linux_ptrace_set_additional_flags.
	* nat/linux-ptrace.c (current_ptrace_options): Rename to
	supported_ptrace_options.
	(additional_flags): Delete variable.
	(linux_check_ptrace_features): Use supported_ptrace_options.
	(linux_test_for_tracesysgood, linux_test_for_tracefork):
	Likewise, and remove additional_flags check.
	(linux_enable_event_reporting): Change 'attached' argument to
	'options'.  Use supported_ptrace_options.
	(ptrace_supports_feature): Change comment.  Use
	supported_ptrace_options.
	(linux_ptrace_set_additional_flags): Delete function.
	* nat/linux-ptrace.h (linux_ptrace_set_additional_flags):
	Delete function prototype.
	* remote.c (remote_fork_event_p): New function.
	(remote_detach_pid): New function.
	(remote_detach_1): Call remote_detach_pid, don't mourn inferior
	if doing detach-on-fork.
	(remote_follow_fork): New function.
	(remote_parse_stop_reply): Handle new "T" stop reason "fork".
	(remote_pid_to_str): Print "process" strings for pid/0/0 ptids.
	(init_extended_remote_ops): Initialize to_follow_fork.


---
 gdb/gdbserver/linux-low.c    | 180 +++++++++++++++++++++++++++++++++++++++----
 gdb/gdbserver/linux-low.h    |   4 +
 gdb/gdbserver/lynx-low.c     |   1 +
 gdb/gdbserver/remote-utils.c |  14 +++-
 gdb/gdbserver/server.c       |   3 +
 gdb/gdbserver/server.h       |   1 +
 gdb/gdbserver/target.h       |   7 ++
 gdb/gdbserver/win32-low.c    |   1 +
 gdb/linux-nat.c              |  37 ++++++---
 gdb/nat/linux-ptrace.c       |  85 ++++++++------------
 gdb/nat/linux-ptrace.h       |   1 -
 gdb/remote.c                 | 130 +++++++++++++++++++++++++------
 12 files changed, 358 insertions(+), 106 deletions(-)
Pedro Alves - April 23, 2015, 2:18 p.m.
On 04/17/2015 09:58 PM, Don Breazeal wrote:

> +	if (status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
> +	  {
> +	    enum gdb_signal signal = GDB_SIGNAL_TRAP;
> +
> +	    sprintf (buf, "T%02xfork:", signal);
> +	    buf += strlen (buf);
> +	    buf = write_ptid (buf, status->value.related_pid);
> +	    strcat (buf, ";");

We don't really need that ';', right?

> +	  }
> +	else
> +	  sprintf (buf, "T%02x", status->value.sig);

I think we should not rely on the value of "status->value.sig"
here, and send GDB_SIGNAL_0 explicitly.

>>> -  if (from_tty && !extended)
>>> +  if (from_tty && !rs->extended)
>>>      puts_filtered (_("Ending remote debugging.\n"));
>>>  
>>> -  target_mourn_inferior ();
>>> +  /* Check to see if we are detaching a fork parent.  Note that if we
>>> +     are detaching a fork child, tp == NULL.  */
>>> +  if (tp != NULL)
>>> +    is_fork_parent = tp->pending_follow.kind == TARGET_WAITKIND_FORKED;
>>> +
>>> +  /* If doing detach-on-fork, we don't mourn, because that will delete
>>> +     breakpoints that should be available for the followed inferior.  */
>>
>> How does this work in the native case then?
> 
> In this scenario we are following the fork child and detaching from
> the parent, which is sending us through the target's detach code.
> 
> In the native Linux case the detach code is linux_nat_detach, which in
> turn calls inf_ptrace_detach.  There is no call to target_mourn_inferior
> in this sequence of function calls, so the breakpoints aren't affected
> at that point.  The breakpoints are "fixed up" for the child by
> follow_inferior_reset_breakpoints at the very end of follow_fork, at
> which point the child inferior has been set up.
> 
> The is_fork_parent condition in remote_detach_1 preventing the call
> to target_mourn_inferior essentially makes the procedure the same as
> for the native case.

But how come the native side doesn't ever need to call mourn from
detach then?  Or put another way, why do we call generic_mourn_inferior
in remote.c's detach for?

I think something's still not very right in grand scheme of things.


> +
> +/* This detaches a program to which we previously attached, using
> +   inferior_ptid to identify the process.  After this is done, GDB
> +   can be used to debug some other program.  We better not have left
> +   any breakpoints in the target program or it'll die when it hits
> +   one.  */
>  
>  static void
> -remote_detach_1 (const char *args, int from_tty, int extended)
> +remote_detach_1 (const char *args, int from_tty)
>  {
>    int pid = ptid_get_pid (inferior_ptid);
>    struct remote_state *rs = get_remote_state ();
> +  struct thread_info *tp = find_thread_ptid (inferior_ptid);
> +  int is_fork_parent;

...

>  
> -  target_mourn_inferior ();
> +  /* Check to see if we are detaching a fork parent.  Note that if we
> +     are detaching a fork child, tp == NULL.  */
> +  if (tp != NULL)
> +    is_fork_parent = tp->pending_follow.kind == TARGET_WAITKIND_FORKED;

Seems like is_fork_parent is left uninitialized in the fork child case.
Should probably be:

  is_fork_parent = (tp != NULL
                    && tp->pending_follow.kind == TARGET_WAITKIND_FORKED);


I'm still confused about this though.

How can we distinguish whether we're detaching the parent for
detach-on-fork, or whether detach-on-fork is off, vs the user
doing an explicit "detach" before following the fork?

I notice that the native side forgets to detach the child in
the latter case...

...
Catchpoint 2 (forked process 32471), 0x0000003615ebc7cc in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
130       pid = ARCH_FORK ();
(gdb) detach
Detaching from program: /home/pedro/gdb/mygit/build/gdb/testsuite/gdb.base/foll-fork, process 32467
(gdb) shell cat /proc/32471/status
Name:   foll-fork
State:  t (tracing stop)
Tgid:   32471

> +
> +  /* If doing detach-on-fork, we don't mourn, because that will delete
> +     breakpoints that should be available for the followed inferior.  */
> +  if (!is_fork_parent)
> +    target_mourn_inferior ();
> +  else
> +    {
> +      inferior_ptid = null_ptid;
> +      detach_inferior (pid);
> +    }
>  }


So I think the detach scenario is still in need of further work,
but given that the native code doesn't get it right either, we can
address that as follow ups.

Thus, this version is OK with the issues mentioned
above fixed.

Thanks,
Pedro Alves

Patch

diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index ddd0c69..7f61946 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -20,6 +20,7 @@ 
 #include "linux-low.h"
 #include "nat/linux-osdata.h"
 #include "agent.h"
+#include "tdesc.h"
 
 #include "nat/linux-nat.h"
 #include "nat/linux-waitpid.h"
@@ -414,22 +415,23 @@  linux_add_process (int pid, int attached)
 static CORE_ADDR get_pc (struct lwp_info *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).  */
+   event, we need to add the new LWP to our list (and return 0 so as
+   not to report the trap to higher layers).  */
 
-static void
-handle_extended_wait (struct lwp_info *event_child, int wstat)
+static int
+handle_extended_wait (struct lwp_info *event_lwp, int wstat)
 {
   int event = linux_ptrace_get_extended_event (wstat);
-  struct thread_info *event_thr = get_lwp_thread (event_child);
+  struct thread_info *event_thr = get_lwp_thread (event_lwp);
   struct lwp_info *new_lwp;
 
-  if (event == PTRACE_EVENT_CLONE)
+  if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_CLONE))
     {
       ptid_t ptid;
       unsigned long new_pid;
       int ret, status;
 
+      /* Get the pid of the new lwp.  */
       ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_thr), (PTRACE_TYPE_ARG3) 0,
 	      &new_pid);
 
@@ -449,6 +451,57 @@  handle_extended_wait (struct lwp_info *event_child, int wstat)
 	    warning ("wait returned unexpected status 0x%x", status);
 	}
 
+      if (event == PTRACE_EVENT_FORK)
+	{
+	  struct process_info *parent_proc;
+	  struct process_info *child_proc;
+	  struct lwp_info *child_lwp;
+	  struct target_desc *tdesc;
+
+	  ptid = ptid_build (new_pid, new_pid, 0);
+
+	  if (debug_threads)
+	    {
+	      debug_printf ("HEW: Got fork event from LWP %ld, "
+			    "new child is %d\n",
+			    ptid_get_lwp (ptid_of (event_thr)),
+			    ptid_get_pid (ptid));
+	    }
+
+	  /* Add the new process to the tables and clone the breakpoint
+	     lists of the parent.  We need to do this even if the new process
+	     will be detached, since we will need the process object and the
+	     breakpoints to remove any breakpoints from memory when we
+	     detach, and the client side will access registers.  */
+	  child_proc = linux_add_process (new_pid, 0);
+	  gdb_assert (child_proc != NULL);
+	  child_lwp = add_lwp (ptid);
+	  gdb_assert (child_lwp != NULL);
+	  child_lwp->stopped = 1;
+	  parent_proc = get_thread_process (event_thr);
+	  child_proc->attached = parent_proc->attached;
+	  clone_all_breakpoints (&child_proc->breakpoints,
+				 &child_proc->raw_breakpoints,
+				 parent_proc->breakpoints);
+
+	  tdesc = xmalloc (sizeof (struct target_desc));
+	  copy_target_description (tdesc, parent_proc->tdesc);
+	  child_proc->tdesc = tdesc;
+	  child_lwp->must_set_ptrace_flags = 1;
+
+	  /* Save fork info in the parent thread.  */
+	  event_lwp->waitstatus.kind = TARGET_WAITKIND_FORKED;
+	  event_lwp->waitstatus.value.related_pid = ptid;
+	  /* The status_pending field contains bits denoting the
+	     extended event, so when the pending event is handled,
+	     the handler will look at lwp->waitstatus.  */
+	  event_lwp->status_pending_p = 1;
+	  event_lwp->status_pending = wstat;
+
+	  /* Report the event.  */
+	  return 0;
+	}
+
       if (debug_threads)
 	debug_printf ("HEW: Got clone event "
 		      "from LWP %ld, new child is LWP %ld\n",
@@ -477,7 +530,12 @@  handle_extended_wait (struct lwp_info *event_child, int wstat)
 	  new_lwp->status_pending_p = 1;
 	  new_lwp->status_pending = status;
 	}
+
+      /* Don't report the event.  */
+      return 1;
     }
+
+  internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event);
 }
 
 /* Return the PC as read from the regcache of LWP, without any
@@ -1935,6 +1993,22 @@  check_stopped_by_watchpoint (struct lwp_info *child)
   return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
 }
 
+/* Return the ptrace options that we want to try to enable.  */
+
+static int
+linux_low_ptrace_options (int attached)
+{
+  int options = 0;
+
+  if (!attached)
+    options |= PTRACE_O_EXITKILL;
+
+  if (report_fork_events)
+    options |= PTRACE_O_TRACEFORK;
+
+  return options;
+}
+
 /* Do low-level handling of the event, and check if we should go on
    and pass it to caller code.  Return the affected lwp if we are, or
    NULL otherwise.  */
@@ -2022,8 +2096,9 @@  linux_low_filter_event (int lwpid, int wstat)
   if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
     {
       struct process_info *proc = find_process_pid (pid_of (thread));
+      int options = linux_low_ptrace_options (proc->attached);
 
-      linux_enable_event_reporting (lwpid, proc->attached);
+      linux_enable_event_reporting (lwpid, options);
       child->must_set_ptrace_flags = 0;
     }
 
@@ -2033,8 +2108,12 @@  linux_low_filter_event (int lwpid, int wstat)
       && linux_is_extended_waitstatus (wstat))
     {
       child->stop_pc = get_pc (child);
-      handle_extended_wait (child, wstat);
-      return NULL;
+      if (handle_extended_wait (child, wstat))
+	{
+	  /* The event has been handled, so just return without
+	     reporting it.  */
+	  return NULL;
+	}
     }
 
   /* Check first whether this was a SW/HW breakpoint before checking
@@ -2622,6 +2701,18 @@  ignore_event (struct target_waitstatus *ourstatus)
   return null_ptid;
 }
 
+/* Return non-zero if WAITSTATUS reflects an extended linux
+   event.  Otherwise, return zero.  */
+
+static int
+extended_event_reported (const struct target_waitstatus *waitstatus)
+{
+  if (waitstatus == NULL)
+    return 0;
+
+  return (waitstatus->kind == TARGET_WAITKIND_FORKED);
+}
+
 /* Wait for process, returns status.  */
 
 static ptid_t
@@ -2988,7 +3079,8 @@  linux_wait_1 (ptid_t ptid,
 		       && !bp_explains_trap && !trace_event)
 		   || (gdb_breakpoint_here (event_child->stop_pc)
 		       && gdb_condition_true_at_breakpoint (event_child->stop_pc)
-		       && gdb_no_commands_at_breakpoint (event_child->stop_pc)));
+		       && gdb_no_commands_at_breakpoint (event_child->stop_pc))
+		   || extended_event_reported (&event_child->waitstatus));
 
   run_breakpoint_commands (event_child->stop_pc);
 
@@ -3010,6 +3102,13 @@  linux_wait_1 (ptid_t ptid,
 			  paddress (event_child->stop_pc),
 			  paddress (event_child->step_range_start),
 			  paddress (event_child->step_range_end));
+	  if (extended_event_reported (&event_child->waitstatus))
+	    {
+	      char *str = target_waitstatus_to_string (ourstatus);
+	      debug_printf ("LWP %ld: extended event with waitstatus %s\n",
+			    lwpid_of (get_lwp_thread (event_child)), str);
+	      xfree (str);
+	    }
 	}
 
       /* We're not reporting this breakpoint to GDB, so apply the
@@ -3119,7 +3218,17 @@  linux_wait_1 (ptid_t ptid,
 	unstop_all_lwps (1, event_child);
     }
 
-  ourstatus->kind = TARGET_WAITKIND_STOPPED;
+  if (extended_event_reported (&event_child->waitstatus))
+    {
+      /* If the reported event is a fork, vfork or exec, let GDB know.  */
+      ourstatus->kind = event_child->waitstatus.kind;
+      ourstatus->value = event_child->waitstatus.value;
+
+      /* Clear the event lwp's waitstatus since we handled it already.  */
+      event_child->waitstatus.kind = TARGET_WAITKIND_IGNORE;
+    }
+  else
+    ourstatus->kind = TARGET_WAITKIND_STOPPED;
 
   /* Now that we've selected our final event LWP, un-adjust its PC if
      it was a software breakpoint, and the client doesn't know we can
@@ -3152,7 +3261,7 @@  linux_wait_1 (ptid_t ptid,
 	 but, it stopped for other reasons.  */
       ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
     }
-  else
+  else if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
     {
       ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
     }
@@ -4996,8 +5105,8 @@  linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 	val = val & 0xffff;
       else if (len == 3)
 	val = val & 0xffffff;
-      debug_printf ("Writing %0*x to 0x%08lx\n", 2 * ((len < 4) ? len : 4),
-		    val, (long)memaddr);
+      debug_printf ("Writing %0*x to 0x%08lx in process %d\n",
+		    2 * ((len < 4) ? len : 4), val, (long)memaddr, pid);
     }
 
   /* Fill start and end extra bytes of buffer with existing memory data.  */
@@ -5441,6 +5550,48 @@  linux_supports_vfork_events (void)
   return linux_supports_tracefork ();
 }
 
+/* Callback for 'find_inferior'.  Set the (possibly changed) ptrace
+   options for the specified lwp.  */
+
+static int
+reset_lwp_ptrace_options_callback (struct inferior_list_entry *entry,
+				   void *args)
+{
+  struct thread_info *thread = (struct thread_info *) entry;
+  struct lwp_info *lwp = get_thread_lwp (thread);
+
+  if (!lwp->stopped)
+    {
+      /* Stop the lwp so we can modify its ptrace options.  */
+      lwp->must_set_ptrace_flags = 1;
+      linux_stop_lwp (lwp);
+    }
+  else
+    {
+      /* Already stopped; go ahead and set the ptrace options.  */
+      struct process_info *proc = find_process_pid (pid_of (thread));
+      int options = linux_low_ptrace_options (proc->attached);
+
+      linux_enable_event_reporting (lwpid_of (thread), options);
+      lwp->must_set_ptrace_flags = 0;
+    }
+
+  return 0;
+}
+
+/* Target hook for 'handle_new_gdb_connection'.  Causes a reset of the
+   ptrace flags for all inferiors.  This is in case the new GDB connection
+   doesn't support the same set of events that the previous one did.  */
+
+static void
+linux_handle_new_gdb_connection (void)
+{
+  pid_t pid;
+
+  /* Request that all the lwps reset their ptrace options.  */
+  find_inferior (&all_threads, reset_lwp_ptrace_options_callback , &pid);
+}
+
 static int
 linux_supports_disable_randomization (void)
 {
@@ -6415,6 +6566,7 @@  static struct target_ops linux_target_ops = {
   linux_supports_multi_process,
   linux_supports_fork_events,
   linux_supports_vfork_events,
+  linux_handle_new_gdb_connection,
 #ifdef USE_THREAD_DB
   thread_db_handle_monitor_command,
 #else
diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h
index 1ae3701..41067d6 100644
--- a/gdb/gdbserver/linux-low.h
+++ b/gdb/gdbserver/linux-low.h
@@ -271,6 +271,10 @@  struct lwp_info
   /* When stopped is set, the last wait status recorded for this lwp.  */
   int last_status;
 
+  /* This is used to store extended ptrace event information until
+     it is reported to GDB.  */
+  struct target_waitstatus waitstatus;
+
   /* When stopped is set, this is where the lwp last stopped, with
      decr_pc_after_break already accounted for.  If the LWP is
      running, this is the address at which the lwp was resumed.  */
diff --git a/gdb/gdbserver/lynx-low.c b/gdb/gdbserver/lynx-low.c
index 687cce0..38df1b7 100644
--- a/gdb/gdbserver/lynx-low.c
+++ b/gdb/gdbserver/lynx-low.c
@@ -760,6 +760,7 @@  static struct target_ops lynx_target_ops = {
   NULL,  /* supports_multi_process */
   NULL,  /* supports_fork_events */
   NULL,  /* supports_vfork_events */
+  NULL,  /* handle_new_gdb_connection */
   NULL,  /* handle_monitor_command */
 };
 
diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index 1de86be..6078348 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -1114,12 +1114,24 @@  prepare_resume_reply (char *buf, ptid_t ptid,
   switch (status->kind)
     {
     case TARGET_WAITKIND_STOPPED:
+    case TARGET_WAITKIND_FORKED:
       {
 	struct thread_info *saved_thread;
 	const char **regp;
 	struct regcache *regcache;
 
-	sprintf (buf, "T%02x", status->value.sig);
+	if (status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
+	  {
+	    enum gdb_signal signal = GDB_SIGNAL_TRAP;
+
+	    sprintf (buf, "T%02xfork:", signal);
+	    buf += strlen (buf);
+	    buf = write_ptid (buf, status->value.related_pid);
+	    strcat (buf, ";");
+	  }
+	else
+	  sprintf (buf, "T%02x", status->value.sig);
+
 	buf += strlen (buf);
 
 	saved_thread = current_thread;
diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
index c609db9..144e2f8 100644
--- a/gdb/gdbserver/server.c
+++ b/gdb/gdbserver/server.c
@@ -2102,6 +2102,9 @@  handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
       if (target_supports_stopped_by_hw_breakpoint ())
 	strcat (own_buf, ";hwbreak+");
 
+      /* Reinitialize the target as needed for the new connection.  */
+      target_handle_new_gdb_connection ();
+
       return;
     }
 
diff --git a/gdb/gdbserver/server.h b/gdb/gdbserver/server.h
index 91d4080..696a24e 100644
--- a/gdb/gdbserver/server.h
+++ b/gdb/gdbserver/server.h
@@ -84,6 +84,7 @@  extern int disable_packet_qfThreadInfo;
 
 extern int run_once;
 extern int multi_process;
+extern int report_fork_events;
 extern int non_stop;
 
 /* True if the "swbreak+" feature is active.  In that case, GDB wants
diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h
index dc51627..ca010ff 100644
--- a/gdb/gdbserver/target.h
+++ b/gdb/gdbserver/target.h
@@ -283,6 +283,9 @@  struct target_ops
   /* Returns true if vfork events are supported.  */
   int (*supports_vfork_events) (void);
 
+  /* Allows target to re-initialize connection-specific settings.  */
+  void (*handle_new_gdb_connection) (void);
+
   /* If not NULL, target-specific routine to process monitor command.
      Returns 1 if handled, or 0 to perform default processing.  */
   int (*handle_monitor_command) (char *);
@@ -422,6 +425,10 @@  int kill_inferior (int);
   (the_target->supports_vfork_events ? \
    (*the_target->supports_vfork_events) () : 0)
 
+#define target_handle_new_gdb_connection() \
+  (the_target->handle_new_gdb_connection ? \
+   (*the_target->handle_new_gdb_connection) () : 0)
+
 #define detach_inferior(pid) \
   (*the_target->detach) (pid)
 
diff --git a/gdb/gdbserver/win32-low.c b/gdb/gdbserver/win32-low.c
index 5f50e46..e7c04d6 100644
--- a/gdb/gdbserver/win32-low.c
+++ b/gdb/gdbserver/win32-low.c
@@ -1829,6 +1829,7 @@  static struct target_ops win32_target_ops = {
   NULL, /* supports_multi_process */
   NULL, /* supports_fork_events */
   NULL, /* supports_vfork_events */
+  NULL, /* handle_new_gdb_connection */
   NULL, /* handle_monitor_command */
   NULL, /* core_of_thread */
   NULL, /* read_loadmap */
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 6c198cf..22990b9 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -368,6 +368,25 @@  pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
   return 0;
 }
 
+/* Return the ptrace options that we want to try to enable.  */
+
+static int
+linux_nat_ptrace_options (int attached)
+{
+  int options = 0;
+
+  if (!attached)
+    options |= PTRACE_O_EXITKILL;
+
+  options |= (PTRACE_O_TRACESYSGOOD
+	      | PTRACE_O_TRACEVFORKDONE
+	      | PTRACE_O_TRACEVFORK
+	      | PTRACE_O_TRACEFORK
+	      | PTRACE_O_TRACEEXEC);
+
+  return options;
+}
+
 /* Initialize ptrace warnings and check for supported ptrace
    features given PID.
 
@@ -376,7 +395,9 @@  pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
 static void
 linux_init_ptrace (pid_t pid, int attached)
 {
-  linux_enable_event_reporting (pid, attached);
+  int options = linux_nat_ptrace_options (attached);
+
+  linux_enable_event_reporting (pid, options);
   linux_ptrace_init_warnings ();
 }
 
@@ -2301,8 +2322,9 @@  wait_lwp (struct lwp_info *lp)
   if (lp->must_set_ptrace_flags)
     {
       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
+      int options = linux_nat_ptrace_options (inf->attach_flag);
 
-      linux_enable_event_reporting (ptid_get_lwp (lp->ptid), inf->attach_flag);
+      linux_enable_event_reporting (ptid_get_lwp (lp->ptid), options);
       lp->must_set_ptrace_flags = 0;
     }
 
@@ -3102,8 +3124,9 @@  linux_nat_filter_event (int lwpid, int status)
   if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
     {
       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
+      int options = linux_nat_ptrace_options (inf->attach_flag);
 
-      linux_enable_event_reporting (ptid_get_lwp (lp->ptid), inf->attach_flag);
+      linux_enable_event_reporting (ptid_get_lwp (lp->ptid), options);
       lp->must_set_ptrace_flags = 0;
     }
 
@@ -5036,14 +5059,6 @@  Enables printf debugging output."),
   sigdelset (&suspend_mask, SIGCHLD);
 
   sigemptyset (&blocked_mask);
-
-  /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to
-     support read-only process state.  */
-  linux_ptrace_set_additional_flags (PTRACE_O_TRACESYSGOOD
-				     | PTRACE_O_TRACEVFORKDONE
-				     | PTRACE_O_TRACEVFORK
-				     | PTRACE_O_TRACEFORK
-				     | PTRACE_O_TRACEEXEC);
 }
 
 
diff --git a/gdb/nat/linux-ptrace.c b/gdb/nat/linux-ptrace.c
index aba3da8..fb12606 100644
--- a/gdb/nat/linux-ptrace.c
+++ b/gdb/nat/linux-ptrace.c
@@ -25,14 +25,10 @@ 
 
 #include <stdint.h>
 
-/* Stores the currently supported ptrace options.  A value of
-   -1 means we did not check for features yet.  A value of 0 means
-   there are no supported features.  */
-static int current_ptrace_options = -1;
-
-/* Additional flags to test.  */
-
-static int additional_flags;
+/* Stores the ptrace options supported by the running kernel.
+   A value of -1 means we did not check for features yet.  A value
+   of 0 means there are no supported features.  */
+static int supported_ptrace_options = -1;
 
 /* Find all possible reasons we could fail to attach PID and append
    these as strings to the already initialized BUFFER.  '\0'
@@ -343,7 +339,7 @@  linux_check_ptrace_features (void)
   int child_pid, ret, status;
 
   /* Initialize the options.  */
-  current_ptrace_options = 0;
+  supported_ptrace_options = 0;
 
   /* Fork a child so we can do some testing.  The child will call
      linux_child_function and will get traced.  The child will
@@ -387,14 +383,11 @@  linux_test_for_tracesysgood (int child_pid)
 {
   int ret;
 
-  if ((additional_flags & PTRACE_O_TRACESYSGOOD) == 0)
-    return;
-
   ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
 		(PTRACE_TYPE_ARG4) PTRACE_O_TRACESYSGOOD);
 
   if (ret == 0)
-    current_ptrace_options |= PTRACE_O_TRACESYSGOOD;
+    supported_ptrace_options |= PTRACE_O_TRACESYSGOOD;
 }
 
 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork
@@ -414,15 +407,12 @@  linux_test_for_tracefork (int child_pid)
   if (ret != 0)
     return;
 
-  if ((additional_flags & PTRACE_O_TRACEVFORKDONE) != 0)
-    {
-      /* Check if the target supports PTRACE_O_TRACEVFORKDONE.  */
-      ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
-		    (PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
-					| PTRACE_O_TRACEVFORKDONE));
-      if (ret == 0)
-	current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
-    }
+  /* Check if the target supports PTRACE_O_TRACEVFORKDONE.  */
+  ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
+		(PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
+				    | PTRACE_O_TRACEVFORKDONE));
+  if (ret == 0)
+    supported_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
 
   /* Setting PTRACE_O_TRACEFORK did not cause an error, however we
      don't know for sure that the feature is available; old
@@ -458,10 +448,10 @@  linux_test_for_tracefork (int child_pid)
 
 	  /* We got the PID from the grandchild, which means fork
 	     tracing is supported.  */
-	  current_ptrace_options |= PTRACE_O_TRACECLONE;
-	  current_ptrace_options |= (additional_flags & (PTRACE_O_TRACEFORK
-                                                         | PTRACE_O_TRACEVFORK
-                                                         | PTRACE_O_TRACEEXEC));
+	  supported_ptrace_options |= PTRACE_O_TRACECLONE;
+	  supported_ptrace_options |= (PTRACE_O_TRACEFORK
+				       | PTRACE_O_TRACEVFORK
+				       | PTRACE_O_TRACEEXEC);
 
 	  /* Do some cleanup and kill the grandchild.  */
 	  my_waitpid (second_pid, &second_status, 0);
@@ -489,33 +479,31 @@  linux_test_for_exitkill (int child_pid)
 		(PTRACE_TYPE_ARG4) PTRACE_O_EXITKILL);
 
   if (ret == 0)
-    current_ptrace_options |= PTRACE_O_EXITKILL;
+    supported_ptrace_options |= PTRACE_O_EXITKILL;
 }
 
 /* Enable reporting of all currently supported ptrace events.
-   ATTACHED should be nonzero if we have attached to the inferior.  */
+   OPTIONS is a bit mask of extended features we want enabled,
+   if supported by the kernel.  PTRACE_O_TRACECLONE is always
+   enabled, if supported.  */
 
 void
-linux_enable_event_reporting (pid_t pid, int attached)
+linux_enable_event_reporting (pid_t pid, int options)
 {
-  int ptrace_options;
-
   /* Check if we have initialized the ptrace features for this
      target.  If not, do it now.  */
-  if (current_ptrace_options == -1)
+  if (supported_ptrace_options == -1)
     linux_check_ptrace_features ();
 
-  ptrace_options = current_ptrace_options;
-  if (attached)
-    {
-      /* When attached to our inferior, we do not want the inferior
-	 to die with us if we terminate unexpectedly.  */
-      ptrace_options &= ~PTRACE_O_EXITKILL;
-    }
+  /* We always want clone events.  */
+  options |= PTRACE_O_TRACECLONE;
+
+  /* Filter out unsupported options.  */
+  options &= supported_ptrace_options;
 
   /* Set the options.  */
   ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0,
-	  (PTRACE_TYPE_ARG4) (uintptr_t) ptrace_options);
+	  (PTRACE_TYPE_ARG4) (uintptr_t) options);
 }
 
 /* Disable reporting of all currently supported ptrace events.  */
@@ -528,16 +516,16 @@  linux_disable_event_reporting (pid_t pid)
 }
 
 /* Returns non-zero if PTRACE_OPTIONS is contained within
-   CURRENT_PTRACE_OPTIONS, therefore supported.  Returns 0
+   SUPPORTED_PTRACE_OPTIONS, therefore supported.  Returns 0
    otherwise.  */
 
 static int
 ptrace_supports_feature (int ptrace_options)
 {
-  if (current_ptrace_options == -1)
+  if (supported_ptrace_options == -1)
     linux_check_ptrace_features ();
 
-  return ((current_ptrace_options & ptrace_options) == ptrace_options);
+  return ((supported_ptrace_options & ptrace_options) == ptrace_options);
 }
 
 /* Returns non-zero if PTRACE_EVENT_FORK is supported by ptrace,
@@ -595,17 +583,6 @@  linux_ptrace_init_warnings (void)
   linux_ptrace_test_ret_to_nx ();
 }
 
-/* Set additional ptrace flags to use.  Some such flags may be checked
-   by the implementation above.  This function must be called before
-   any other function in this file; otherwise the flags may not take
-   effect appropriately.  */
-
-void
-linux_ptrace_set_additional_flags (int flags)
-{
-  additional_flags = flags;
-}
-
 /* Extract extended ptrace event from wait status.  */
 
 int
diff --git a/gdb/nat/linux-ptrace.h b/gdb/nat/linux-ptrace.h
index 03d98c9..1db0cde 100644
--- a/gdb/nat/linux-ptrace.h
+++ b/gdb/nat/linux-ptrace.h
@@ -156,7 +156,6 @@  extern int linux_supports_tracefork (void);
 extern int linux_supports_traceclone (void);
 extern int linux_supports_tracevforkdone (void);
 extern int linux_supports_tracesysgood (void);
-extern void linux_ptrace_set_additional_flags (int);
 extern int linux_ptrace_get_extended_event (int wstat);
 extern int linux_is_extended_waitstatus (int wstat);
 extern int linux_wstatus_maybe_breakpoint (int wstat);
diff --git a/gdb/remote.c b/gdb/remote.c
index f939059..8e26e5e 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1461,6 +1461,14 @@  remote_multi_process_p (struct remote_state *rs)
   return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE;
 }
 
+/* Returns true if fork events are supported.  */
+
+static int
+remote_fork_event_p (struct remote_state *rs)
+{
+  return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
+}
+
 /* Tokens for use by the asynchronous signal handlers for SIGINT.  */
 static struct async_signal_handler *async_sigint_remote_twice_token;
 static struct async_signal_handler *async_sigint_remote_token;
@@ -4419,16 +4427,42 @@  remote_open_1 (const char *name, int from_tty,
     wait_forever_enabled_p = 1;
 }
 
-/* This takes a program previously attached to and detaches it.  After
-   this is done, GDB can be used to debug some other program.  We
-   better not have left any breakpoints in the target program or it'll
-   die when it hits one.  */
+/* Detach the specified process.  */
+
+static void
+remote_detach_pid (int pid)
+{
+  struct remote_state *rs = get_remote_state ();
+
+  if (remote_multi_process_p (rs))
+    xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
+  else
+    strcpy (rs->buf, "D");
+
+  putpkt (rs->buf);
+  getpkt (&rs->buf, &rs->buf_size, 0);
+
+  if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
+    ;
+  else if (rs->buf[0] == '\0')
+    error (_("Remote doesn't know how to detach"));
+  else
+    error (_("Can't detach process."));
+}
+
+/* This detaches a program to which we previously attached, using
+   inferior_ptid to identify the process.  After this is done, GDB
+   can be used to debug some other program.  We better not have left
+   any breakpoints in the target program or it'll die when it hits
+   one.  */
 
 static void
-remote_detach_1 (const char *args, int from_tty, int extended)
+remote_detach_1 (const char *args, int from_tty)
 {
   int pid = ptid_get_pid (inferior_ptid);
   struct remote_state *rs = get_remote_state ();
+  struct thread_info *tp = find_thread_ptid (inferior_ptid);
+  int is_fork_parent;
 
   if (args)
     error (_("Argument given to \"detach\" when remotely debugging."));
@@ -4447,37 +4481,74 @@  remote_detach_1 (const char *args, int from_tty, int extended)
     }
 
   /* Tell the remote target to detach.  */
-  if (remote_multi_process_p (rs))
-    xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
-  else
-    strcpy (rs->buf, "D");
+  remote_detach_pid (pid);
 
-  putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
-
-  if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
-    ;
-  else if (rs->buf[0] == '\0')
-    error (_("Remote doesn't know how to detach"));
-  else
-    error (_("Can't detach process."));
-
-  if (from_tty && !extended)
+  if (from_tty && !rs->extended)
     puts_filtered (_("Ending remote debugging.\n"));
 
-  target_mourn_inferior ();
+  /* Check to see if we are detaching a fork parent.  Note that if we
+     are detaching a fork child, tp == NULL.  */
+  if (tp != NULL)
+    is_fork_parent = tp->pending_follow.kind == TARGET_WAITKIND_FORKED;
+
+  /* If doing detach-on-fork, we don't mourn, because that will delete
+     breakpoints that should be available for the followed inferior.  */
+  if (!is_fork_parent)
+    target_mourn_inferior ();
+  else
+    {
+      inferior_ptid = null_ptid;
+      detach_inferior (pid);
+    }
 }
 
 static void
 remote_detach (struct target_ops *ops, const char *args, int from_tty)
 {
-  remote_detach_1 (args, from_tty, 0);
+  remote_detach_1 (args, from_tty);
 }
 
 static void
 extended_remote_detach (struct target_ops *ops, const char *args, int from_tty)
 {
-  remote_detach_1 (args, from_tty, 1);
+  remote_detach_1 (args, from_tty);
+}
+
+/* Target follow-fork function for remote targets.  On entry, and
+   at return, the current inferior is the fork parent.
+
+   Note that although this is currently only used for extended-remote,
+   it is named remote_follow_fork in anticipation of using it for the
+   remote target as well.  */
+
+static int
+remote_follow_fork (struct target_ops *ops, int follow_child,
+		    int detach_fork)
+{
+  struct remote_state *rs = get_remote_state ();
+
+  if (remote_fork_event_p (rs))
+    {
+      /* When following the parent and detaching the child, we detach
+	 the child here.  For the case of following the child and
+	 detaching the parent, the detach is done in the target-
+	 independent follow fork code in infrun.c.  We can't use
+	 target_detach when detaching an unfollowed child because
+	 the client side doesn't know anything about the child.  */
+      if (detach_fork && !follow_child)
+	{
+	  /* Detach the fork child.  */
+	  ptid_t child_ptid;
+	  pid_t child_pid;
+
+	  child_ptid = inferior_thread ()->pending_follow.value.related_pid;
+	  child_pid = ptid_get_pid (child_ptid);
+
+	  remote_detach_pid (child_pid);
+	  detach_inferior (child_pid);
+	}
+    }
+  return 0;
 }
 
 /* Same as remote_detach, but don't send the "D" packet; just disconnect.  */
@@ -5640,6 +5711,11 @@  Packet: '%s'\n"),
 	      p = unpack_varlen_hex (++p1, &c);
 	      event->core = c;
 	    }
+	  else if (strncmp (p, "fork", p1 - p) == 0)
+	    {
+	      event->ws.value.related_pid = read_ptid (++p1, &p);
+	      event->ws.kind = TARGET_WAITKIND_FORKED;
+	    }
 	  else
 	    {
 	      ULONGEST pnum;
@@ -9489,8 +9565,11 @@  remote_pid_to_str (struct target_ops *ops, ptid_t ptid)
       if (ptid_equal (magic_null_ptid, ptid))
 	xsnprintf (buf, sizeof buf, "Thread <main>");
       else if (rs->extended && remote_multi_process_p (rs))
-	xsnprintf (buf, sizeof buf, "Thread %d.%ld",
-		   ptid_get_pid (ptid), ptid_get_lwp (ptid));
+	if (ptid_get_lwp (ptid) == 0)
+	  return normal_pid_to_str (ptid);
+	else
+	  xsnprintf (buf, sizeof buf, "Thread %d.%ld",
+		     ptid_get_pid (ptid), ptid_get_lwp (ptid));
       else
 	xsnprintf (buf, sizeof buf, "Thread %ld",
 		   ptid_get_lwp (ptid));
@@ -11817,6 +11896,7 @@  Specify the serial device it is connected to (e.g. /dev/ttya).";
   extended_remote_ops.to_kill = extended_remote_kill;
   extended_remote_ops.to_supports_disable_randomization
     = extended_remote_supports_disable_randomization;
+  extended_remote_ops.to_follow_fork = remote_follow_fork;
 }
 
 static int