* [PATCH v7 0/7] Remote fork events
@ 2015-04-10 17:09 Don Breazeal
2015-04-10 17:10 ` [PATCH v7 2/7] Clone remote breakpoints Don Breazeal
` (6 more replies)
0 siblings, 7 replies; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:09 UTC (permalink / raw)
To: gdb-patches
This is v7 of the patch series implementing remote follow-fork, last
posted here: https://sourceware.org/ml/gdb-patches/2015-03/msg00503.html
This patchset only implements fork and vfork events for extended remote,
omitting exec events and 'target remote' for now.
Changes from the previous version:
* Patch 1: removed documentation portion, putting it in a separate
documentation patch (patch 7).
* Patch 3: addressed a number of review comments. The significant
changes include:
- temporarily pause all lwps when gdb (re)connects, in
order to set the ptrace options.
- rework the mechanism for setting ptrace options.
- refactor remote_detach_1 per review comments.
- removed a test change (will submit it as a separate patch).
- moved documentation changes to doc patch #7.
* Patch 5: changed a couple a spots to address how gdbserver checks
whether fork events have been requested by gdb and whether they
are enabled. Also moved documentation changes to doc patch #7.
* Patch 6: significant changes include:
- changed method of removing fork child threads from the
thread list reported from the remote target, prior to
follow_fork.
- changed how gdb determines whether a process that is
to be killed contains a fork parent thread
- removed a test change that isn't needed for this patchset.
- moved documentation changes to doc patch #7.
* Patch 7: new patch that incorporates all doc changes for the patchset.
The patch descriptions are mostly unchanged except for the new patch:
1/6: Preparatory patch that implements qSupported support for fork events
and associated mechanisms.
Previously approved minus doc portions here:
https://sourceware.org/ml/gdb-patches/2015-03/msg00896.html
2/6: Implements functions to clone breakpoint lists in gdbserver.
Previously approved pending a few 'nits', fixes are documented here:
https://sourceware.org/ml/gdb-patches/2014-10/msg00883.html.
3/6: Implements follow fork for 'fork' but not 'vfork', for
extended-remote targets only.
4/6: Adds the architecture-specific pieces of follow-fork that allows
hardware watchpoints to be inherited by a forked child.
Previously approved here:
https://sourceware.org/ml/gdb-patches/2015-02/msg00262.html
5/6: Adds follow fork for 'vfork'.
6/6: Adds catchpoints for 'fork' and 'vfork', along with support for
killing a process that has forked before follow_fork is completed.
7/7: Documentation for the patch series.
TESTING:
Testing was mostly done using x86_64 Ubuntu, with the exception of the
architecture-specific patch, #4. There are a few failures that show up
but don't signify any problem.
- Intermediate patches show failures due to the lack of features
implemented in subsequent patches, like missing hardware watchpoint
or catchpoint support.
- Some vfork tests fail due to the lack of exec event support.
Thanks,
--Don
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v7 2/7] Clone remote breakpoints
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
@ 2015-04-10 17:10 ` Don Breazeal
2015-04-10 17:10 ` [PATCH v7 4/7] Arch-specific remote follow fork Don Breazeal
` (5 subsequent siblings)
6 siblings, 0 replies; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:10 UTC (permalink / raw)
To: gdb-patches
This version of this patch is unchanged except possibly for merges from
the mainline. This patch was approved pending a few 'nits', fixes are
documented here: https://sourceware.org/ml/gdb-patches/2014-10/msg00883.html.
Thanks!
--Don
This patch implements gdbserver routines to clone the breakpoint lists of a
process, duplicating them for another process. In gdbserver, each process
maintains its own independent breakpoint list. When a fork call creates a
child, all of the breakpoints currently inserted in the parent process are
also inserted in the child process, but there is nothing to describe them
in the data structures related to the child. The child must have a
breakpoint list describing them so that they can be removed (if detaching)
or recognized (if following). Implementation is a mechanical process of
just cloning the lists in several new functions in gdbserver/mem-break.c.
Tested by building, since none of the new functions are called yet. This
was tested with another patch in the series that implements follow-fork.
gdb/gdbserver/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* mem-break.c (APPEND_TO_LIST): Define macro.
(clone_agent_expr): New function.
(clone_one_breakpoint): New function.
(clone_all_breakpoints): New function.
* mem-break.h: Declare new functions.
---
gdb/gdbserver/mem-break.c | 105 ++++++++++++++++++++++++++++++++++++++++++++++
gdb/gdbserver/mem-break.h | 6 +++
2 files changed, 111 insertions(+)
diff --git a/gdb/gdbserver/mem-break.c b/gdb/gdbserver/mem-break.c
index 70fab2e..d1b66bf 100644
--- a/gdb/gdbserver/mem-break.c
+++ b/gdb/gdbserver/mem-break.c
@@ -28,6 +28,24 @@ int breakpoint_len;
#define MAX_BREAKPOINT_LEN 8
+/* Helper macro used in loops that append multiple items to a singly-linked
+ list instead of inserting items at the head of the list, as, say, in the
+ breakpoint lists. LISTPP is a pointer to the pointer that is the head of
+ the new list. ITEMP is a pointer to the item to be added to the list.
+ TAILP must be defined to be the same type as ITEMP, and initialized to
+ NULL. */
+
+#define APPEND_TO_LIST(listpp, itemp, tailp) \
+ do \
+ { \
+ if ((tailp) == NULL) \
+ *(listpp) = (itemp); \
+ else \
+ (tailp)->next = (itemp); \
+ (tailp) = (itemp); \
+ } \
+ while (0)
+
/* GDB will never try to install multiple breakpoints at the same
address. However, we can see GDB requesting to insert a breakpoint
at an address is had already inserted one previously in a few
@@ -1913,3 +1931,90 @@ free_all_breakpoints (struct process_info *proc)
while (proc->breakpoints)
delete_breakpoint_1 (proc, proc->breakpoints);
}
+
+/* Clone an agent expression. */
+
+static struct agent_expr *
+clone_agent_expr (const struct agent_expr *src_ax)
+{
+ struct agent_expr *ax;
+
+ ax = xcalloc (1, sizeof (*ax));
+ ax->length = src_ax->length;
+ ax->bytes = xcalloc (ax->length, 1);
+ memcpy (ax->bytes, src_ax->bytes, ax->length);
+ return ax;
+}
+
+/* Deep-copy the contents of one breakpoint to another. */
+
+static struct breakpoint *
+clone_one_breakpoint (const struct breakpoint *src)
+{
+ struct breakpoint *dest;
+ struct raw_breakpoint *dest_raw;
+ struct point_cond_list *current_cond;
+ struct point_cond_list *new_cond;
+ struct point_cond_list *cond_tail = NULL;
+ struct point_command_list *current_cmd;
+ struct point_command_list *new_cmd;
+ struct point_command_list *cmd_tail = NULL;
+
+ /* Clone the raw breakpoint. */
+ dest_raw = xcalloc (1, sizeof (*dest_raw));
+ dest_raw->raw_type = src->raw->raw_type;
+ dest_raw->refcount = src->raw->refcount;
+ dest_raw->pc = src->raw->pc;
+ dest_raw->size = src->raw->size;
+ memcpy (dest_raw->old_data, src->raw->old_data, MAX_BREAKPOINT_LEN);
+ dest_raw->inserted = src->raw->inserted;
+
+ /* Clone the high-level breakpoint. */
+ dest = xcalloc (1, sizeof (*dest));
+ dest->type = src->type;
+ dest->raw = dest_raw;
+ dest->handler = src->handler;
+
+ /* Clone the condition list. */
+ for (current_cond = src->cond_list; current_cond != NULL;
+ current_cond = current_cond->next)
+ {
+ new_cond = xcalloc (1, sizeof (*new_cond));
+ new_cond->cond = clone_agent_expr (current_cond->cond);
+ APPEND_TO_LIST (&dest->cond_list, new_cond, cond_tail);
+ }
+
+ /* Clone the command list. */
+ for (current_cmd = src->command_list; current_cmd != NULL;
+ current_cmd = current_cmd->next)
+ {
+ new_cmd = xcalloc (1, sizeof (*new_cmd));
+ new_cmd->cmd = clone_agent_expr (current_cmd->cmd);
+ new_cmd->persistence = current_cmd->persistence;
+ APPEND_TO_LIST (&dest->command_list, new_cmd, cmd_tail);
+ }
+
+ return dest;
+}
+
+/* Create a new breakpoint list NEW_LIST that is a copy of the
+ list starting at SRC_LIST. Create the corresponding new
+ raw_breakpoint list NEW_RAW_LIST as well. */
+
+void
+clone_all_breakpoints (struct breakpoint **new_list,
+ struct raw_breakpoint **new_raw_list,
+ const struct breakpoint *src_list)
+{
+ const struct breakpoint *bp;
+ struct breakpoint *new_bkpt;
+ struct breakpoint *bkpt_tail = NULL;
+ struct raw_breakpoint *raw_bkpt_tail = NULL;
+
+ for (bp = src_list; bp != NULL; bp = bp->next)
+ {
+ new_bkpt = clone_one_breakpoint (bp);
+ APPEND_TO_LIST (new_list, new_bkpt, bkpt_tail);
+ APPEND_TO_LIST (new_raw_list, new_bkpt->raw, raw_bkpt_tail);
+ }
+}
diff --git a/gdb/gdbserver/mem-break.h b/gdb/gdbserver/mem-break.h
index 8b010c1..b5a3208 100644
--- a/gdb/gdbserver/mem-break.h
+++ b/gdb/gdbserver/mem-break.h
@@ -253,4 +253,10 @@ int insert_memory_breakpoint (struct raw_breakpoint *bp);
int remove_memory_breakpoint (struct raw_breakpoint *bp);
+/* Create a new breakpoint list NEW_BKPT_LIST that is a copy of SRC. */
+
+void clone_all_breakpoints (struct breakpoint **new_bkpt_list,
+ struct raw_breakpoint **new_raw_bkpt_list,
+ const struct breakpoint *src);
+
#endif /* MEM_BREAK_H */
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v7 4/7] Arch-specific remote follow fork
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
2015-04-10 17:10 ` [PATCH v7 2/7] Clone remote breakpoints Don Breazeal
@ 2015-04-10 17:10 ` Don Breazeal
2015-04-10 17:10 ` [PATCH v7 1/7] Identify remote fork event support Don Breazeal
` (4 subsequent siblings)
6 siblings, 0 replies; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:10 UTC (permalink / raw)
To: gdb-patches
Hi Pedro,
This version of this patch is unchanged except possibly for merges from
the mainline. It was previously approved here:
https://sourceware.org/ml/gdb-patches/2015-02/msg00262.html
Thanks,
--Don
This patch implements the architecture-specific pieces of follow-fork
for remote and extended-remote Linux targets, which in the current
implementation copyies the parent's debug register state into the new
child's data structures. This is required for x86, arm, aarch64, and
mips.
This follows the native implementation as closely as possible by
implementing a new linux_target_ops function 'new_fork', which is
analogous to 'linux_nat_new_fork' in linux-nat.c. In gdbserver, the debug
registers are stored in the process list, instead of an
architecture-specific list, so the function arguments are process_info
pointers instead of an lwp_info and a pid as in the native implementation.
In the MIPS implementation the debug register mirror is stored differently
from x86, ARM, and aarch64, so instead of doing a simple structure assignment
I had to clone the list of watchpoint structures.
Tested using gdb.threads/watchpoint-fork.exp on x86, and ran manual tests
on a MIPS board and an ARM board.
I don't currently have access to an aarch64 board, so if someone is able
to test this easily, please do.
gdb/gdbserver/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* linux-aarch64-low.c (aarch64_linux_new_fork): New function.
(the_low_target) <new_fork>: Initialize new member.
* linux-arm-low.c (arm_new_fork): New function.
(the_low_target) <new_fork>: Initialize new member.
* linux-low.c (handle_extended_wait): Call new target function
new_fork.
* linux-low.h (struct linux_target_ops) <new_fork>: New member.
* linux-mips-low.c (mips_add_watchpoint): New function
extracted from mips_insert_point.
(the_low_target) <new_fork>: Initialize new member.
(mips_linux_new_fork): New function.
(mips_insert_point): Call mips_add_watchpoint.
* linux-x86-low.c (x86_linux_new_fork): New function.
(the_low_target) <new_fork>: Initialize new member.
---
gdb/gdbserver/linux-aarch64-low.c | 28 +++++++++++++++
gdb/gdbserver/linux-arm-low.c | 42 ++++++++++++++++++++++
gdb/gdbserver/linux-low.c | 4 +++
gdb/gdbserver/linux-low.h | 3 ++
gdb/gdbserver/linux-mips-low.c | 76 ++++++++++++++++++++++++++++++++-------
gdb/gdbserver/linux-x86-low.c | 29 +++++++++++++++
6 files changed, 170 insertions(+), 12 deletions(-)
diff --git a/gdb/gdbserver/linux-aarch64-low.c b/gdb/gdbserver/linux-aarch64-low.c
index d44175e..7e6e9ac 100644
--- a/gdb/gdbserver/linux-aarch64-low.c
+++ b/gdb/gdbserver/linux-aarch64-low.c
@@ -1135,6 +1135,33 @@ aarch64_linux_new_thread (struct lwp_info *lwp)
lwp->arch_private = info;
}
+static void
+aarch64_linux_new_fork (struct process_info *parent,
+ struct process_info *child)
+{
+ /* These are allocated by linux_add_process. */
+ gdb_assert (parent->private != NULL
+ && parent->private->arch_private != NULL);
+ gdb_assert (child->private != NULL
+ && child->private->arch_private != NULL);
+
+ /* Linux kernel before 2.6.33 commit
+ 72f674d203cd230426437cdcf7dd6f681dad8b0d
+ will inherit hardware debug registers from parent
+ on fork/vfork/clone. Newer Linux kernels create such tasks with
+ zeroed debug registers.
+
+ GDB core assumes the child inherits the watchpoints/hw
+ breakpoints of the parent, and will remove them all from the
+ forked off process. Copy the debug registers mirrors into the
+ new process so that all breakpoints and watchpoints can be
+ removed together. The debug registers mirror will become zeroed
+ in the end before detaching the forked off process, thus making
+ this compatible with older Linux kernels too. */
+
+ *child->private->arch_private = *parent->private->arch_private;
+}
+
/* Called when resuming a thread.
If the debug regs have changed, update the thread's copies. */
@@ -1299,6 +1326,7 @@ struct linux_target_ops the_low_target =
NULL,
aarch64_linux_new_process,
aarch64_linux_new_thread,
+ aarch64_linux_new_fork,
aarch64_linux_prepare_to_resume,
};
diff --git a/gdb/gdbserver/linux-arm-low.c b/gdb/gdbserver/linux-arm-low.c
index d408dcd..3420dea 100644
--- a/gdb/gdbserver/linux-arm-low.c
+++ b/gdb/gdbserver/linux-arm-low.c
@@ -717,6 +717,47 @@ arm_new_thread (struct lwp_info *lwp)
lwp->arch_private = info;
}
+static void
+arm_new_fork (struct process_info *parent, struct process_info *child)
+{
+ struct arch_process_info *parent_proc_info = parent->private->arch_private;
+ struct arch_process_info *child_proc_info = child->private->arch_private;
+ struct lwp_info *child_lwp;
+ struct arch_lwp_info *child_lwp_info;
+ int i;
+
+ /* These are allocated by linux_add_process. */
+ gdb_assert (parent->private != NULL
+ && parent->private->arch_private != NULL);
+ gdb_assert (child->private != NULL
+ && child->private->arch_private != NULL);
+
+ /* Linux kernel before 2.6.33 commit
+ 72f674d203cd230426437cdcf7dd6f681dad8b0d
+ will inherit hardware debug registers from parent
+ on fork/vfork/clone. Newer Linux kernels create such tasks with
+ zeroed debug registers.
+
+ GDB core assumes the child inherits the watchpoints/hw
+ breakpoints of the parent, and will remove them all from the
+ forked off process. Copy the debug registers mirrors into the
+ new process so that all breakpoints and watchpoints can be
+ removed together. The debug registers mirror will become zeroed
+ in the end before detaching the forked off process, thus making
+ this compatible with older Linux kernels too. */
+
+ *child_proc_info = *parent_proc_info;
+
+ /* Mark all the hardware breakpoints and watchpoints as changed to
+ make sure that the registers will be updated. */
+ child_lwp = find_lwp_pid (ptid_of (child));
+ child_lwp_info = child_lwp->arch_private;
+ for (i = 0; i < MAX_BPTS; i++)
+ child_lwp_info->bpts_changed[i] = 1;
+ for (i = 0; i < MAX_WPTS; i++)
+ child_lwp_info->wpts_changed[i] = 1;
+}
+
/* Called when resuming a thread.
If the debug regs have changed, update the thread's copies. */
static void
@@ -920,6 +961,7 @@ struct linux_target_ops the_low_target = {
NULL, /* siginfo_fixup */
arm_new_process,
arm_new_thread,
+ arm_new_fork,
arm_prepare_to_resume,
};
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index b8fbe45..645c94f 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -489,6 +489,10 @@ handle_extended_wait (struct lwp_info *event_lwp, int wstat)
child_proc->tdesc = tdesc;
child_lwp->must_set_ptrace_flags = 1;
+ /* Clone arch-specific process data. */
+ if (the_low_target.new_fork != NULL)
+ the_low_target.new_fork (parent_proc, child_proc);
+
/* Save fork info in the parent thread. */
event_lwp->waitstatus.kind = TARGET_WAITKIND_FORKED;
event_lwp->waitstatus.value.related_pid = ptid;
diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h
index 41067d6..3300da9 100644
--- a/gdb/gdbserver/linux-low.h
+++ b/gdb/gdbserver/linux-low.h
@@ -187,6 +187,9 @@ struct linux_target_ops
allocate it here. */
void (*new_thread) (struct lwp_info *);
+ /* Hook to call, if any, when a new fork is attached. */
+ void (*new_fork) (struct process_info *parent, struct process_info *child);
+
/* Hook to call prior to resuming a thread. */
void (*prepare_to_resume) (struct lwp_info *);
diff --git a/gdb/gdbserver/linux-mips-low.c b/gdb/gdbserver/linux-mips-low.c
index 7988d07..4601ad0 100644
--- a/gdb/gdbserver/linux-mips-low.c
+++ b/gdb/gdbserver/linux-mips-low.c
@@ -344,6 +344,68 @@ mips_linux_new_thread (struct lwp_info *lwp)
lwp->arch_private = info;
}
+/* Create a new mips_watchpoint and add it to the list. */
+
+static void
+mips_add_watchpoint (struct arch_process_info *private, CORE_ADDR addr,
+ int len, int watch_type)
+{
+ struct mips_watchpoint *new_watch;
+ struct mips_watchpoint **pw;
+
+ new_watch = xmalloc (sizeof (struct mips_watchpoint));
+ new_watch->addr = addr;
+ new_watch->len = len;
+ new_watch->type = watch_type;
+ new_watch->next = NULL;
+
+ pw = &private->current_watches;
+ while (*pw != NULL)
+ pw = &(*pw)->next;
+ *pw = new_watch;
+}
+
+/* Hook to call when a new fork is attached. */
+
+static void
+mips_linux_new_fork (struct process_info *parent,
+ struct process_info *child)
+{
+ struct arch_process_info *parent_private;
+ struct arch_process_info *child_private;
+ struct mips_watchpoint *wp;
+
+ /* These are allocated by linux_add_process. */
+ gdb_assert (parent->private != NULL
+ && parent->private->arch_private != NULL);
+ gdb_assert (child->private != NULL
+ && child->private->arch_private != NULL);
+
+ /* Linux kernel before 2.6.33 commit
+ 72f674d203cd230426437cdcf7dd6f681dad8b0d
+ will inherit hardware debug registers from parent
+ on fork/vfork/clone. Newer Linux kernels create such tasks with
+ zeroed debug registers.
+
+ GDB core assumes the child inherits the watchpoints/hw
+ breakpoints of the parent, and will remove them all from the
+ forked off process. Copy the debug registers mirrors into the
+ new process so that all breakpoints and watchpoints can be
+ removed together. The debug registers mirror will become zeroed
+ in the end before detaching the forked off process, thus making
+ this compatible with older Linux kernels too. */
+
+ parent_private = parent->private->arch_private;
+ child_private = child->private->arch_private;
+
+ child_private->watch_readback_valid = parent_private->watch_readback_valid;
+ child_private->watch_readback = parent_private->watch_readback;
+
+ for (wp = parent_private->current_watches; wp != NULL; wp = wp->next)
+ mips_add_watchpoint (child_private, wp->addr, wp->len, wp->type);
+
+ child_private->watch_mirror = parent_private->watch_mirror;
+}
/* This is the implementation of linux_target_ops method
prepare_to_resume. If the watch regs have changed, update the
thread's copies. */
@@ -397,8 +459,6 @@ mips_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
struct process_info *proc = current_process ();
struct arch_process_info *priv = proc->priv->arch_private;
struct pt_watch_regs regs;
- struct mips_watchpoint *new_watch;
- struct mips_watchpoint **pw;
int pid;
long lwpid;
enum target_hw_bp_type watch_type;
@@ -425,16 +485,7 @@ mips_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
return -1;
/* It fit. Stick it on the end of the list. */
- new_watch = xmalloc (sizeof (struct mips_watchpoint));
- new_watch->addr = addr;
- new_watch->len = len;
- new_watch->type = watch_type;
- new_watch->next = NULL;
-
- pw = &priv->current_watches;
- while (*pw != NULL)
- pw = &(*pw)->next;
- *pw = new_watch;
+ mips_add_watchpoint (priv, addr, len, watch_type);
priv->watch_mirror = regs;
@@ -845,6 +896,7 @@ struct linux_target_ops the_low_target = {
NULL, /* siginfo_fixup */
mips_linux_new_process,
mips_linux_new_thread,
+ mips_linux_new_fork,
mips_linux_prepare_to_resume
};
diff --git a/gdb/gdbserver/linux-x86-low.c b/gdb/gdbserver/linux-x86-low.c
index e293ba4..2d980c0 100644
--- a/gdb/gdbserver/linux-x86-low.c
+++ b/gdb/gdbserver/linux-x86-low.c
@@ -640,6 +640,34 @@ x86_linux_new_process (void)
return info;
}
+/* Target routine for linux_new_fork. */
+
+static void
+x86_linux_new_fork (struct process_info *parent, struct process_info *child)
+{
+ /* These are allocated by linux_add_process. */
+ gdb_assert (parent->priv != NULL
+ && parent->priv->arch_private != NULL);
+ gdb_assert (child->priv != NULL
+ && child->priv->arch_private != NULL);
+
+ /* Linux kernel before 2.6.33 commit
+ 72f674d203cd230426437cdcf7dd6f681dad8b0d
+ will inherit hardware debug registers from parent
+ on fork/vfork/clone. Newer Linux kernels create such tasks with
+ zeroed debug registers.
+
+ GDB core assumes the child inherits the watchpoints/hw
+ breakpoints of the parent, and will remove them all from the
+ forked off process. Copy the debug registers mirrors into the
+ new process so that all breakpoints and watchpoints can be
+ removed together. The debug registers mirror will become zeroed
+ in the end before detaching the forked off process, thus making
+ this compatible with older Linux kernels too. */
+
+ *child->priv->arch_private = *parent->priv->arch_private;
+}
+
/* See nat/x86-dregs.h. */
struct x86_debug_reg_state *
@@ -3269,6 +3297,7 @@ struct linux_target_ops the_low_target =
x86_siginfo_fixup,
x86_linux_new_process,
x86_linux_new_thread,
+ x86_linux_new_fork,
x86_linux_prepare_to_resume,
x86_linux_process_qsupported,
x86_supports_tracepoints,
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v7 3/7] Extended-remote Linux follow fork
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
` (2 preceding siblings ...)
2015-04-10 17:10 ` [PATCH v7 1/7] Identify remote fork event support Don Breazeal
@ 2015-04-10 17:10 ` Don Breazeal
2015-04-15 15:38 ` Pedro Alves
2015-04-10 17:11 ` [PATCH v7 5/7] Remote follow vfork Don Breazeal
` (2 subsequent siblings)
6 siblings, 1 reply; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:10 UTC (permalink / raw)
To: gdb-patches
Hi Pedro,
This version of the patch incorporates changes based on your comments on
the previous version, as outlined below. Thanks for all the detail in
this review.
On 3/24/2015 5:16 AM, Pedro Alves wrote:
> Hi Don,
>
> On 03/17/2015 08:56 PM, Don Breazeal wrote:
>
>> * 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 4, but they see their first use here).
>
> This description seems to be a bit out of date. We're in patch 3 still. :-)
Fixed.
>
>>
>> - 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/doc/
>> 2015-03-17 Don Breazeal <donb@codesourcery.com>
>>
>> * gdb.texinfo (Forks): List targets that have fork debugging
>> support.
>> (Stop Reply Packets): List new stop reason "xfork".
>
> I know I was the one who suggested avoiding "fork" because it starts
> with an hex char, but thinking further, if gdb must report
> support for fork events for the server to report these, it's ok
> to use "fork". I'm no thinking we can rename it back, thus
> fending off questions about this in the future. Could you
> do that? Sorry about the back and forth...
No problem. If only they were all so easy! :-)
>
>>
>> diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
>> index b089b1b..b62b37f 100644
>> --- a/gdb/doc/gdb.texinfo
>> +++ b/gdb/doc/gdb.texinfo
>> @@ -3142,6 +3142,9 @@ create additional processes using the @code{fork} or @code{vfork} functions.
>> Currently, the only platforms with this feature are HP-UX (11.x and later
>> only?) and @sc{gnu}/Linux (kernel version 2.5.60 and later).
>>
>> +The fork debugging commands are supported in both native mode and when
>> +connected to @code{gdbserver} using @kbd{target extended-remote}.
>> +
>> By default, when a program forks, @value{GDBN} will continue to debug
>> the parent process and the child process will run unimpeded.
>>
>> @@ -35197,6 +35200,12 @@ The packet indicates that the loaded libraries have changed.
>> @value{GDBN} should use @samp{qXfer:libraries:read} to fetch a new
>> list of loaded libraries. The @var{r} part is ignored.
>>
>> +@cindex fork events, remote reply
>> +@item xfork
>> +The packet indicates that @code{fork} was called, and @var{r}
>> +is the ptid of the new child process. This packet is only
>> +applicable to targets that support fork events.
>> +
>
> Please mention here the need for reporting support in qSupported.
> E.g., the new swbreak stop reason says:
>
> ~~~
> This packet should not be sent by default; older @value{GDBN} versions
> did not support it. @value{GDBN} requests it, by supplying an
> appropriate @samp{qSupported} feature (@pxref{qSupported}). The
> remote stub must also supply the appropriate @samp{qSupported} feature
> indicating support.
> ~~~
I've incorporated this change into the documentation patch.
>
>> if (debug_threads)
>> debug_printf ("HEW: Got clone event "
>> "from LWP %ld, new child is LWP %ld\n",
>> @@ -434,7 +487,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
>> @@ -1828,6 +1886,19 @@ check_stopped_by_watchpoint (struct lwp_info *child)
>> return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
>> }
>>
>> +/* Wrapper for linux_enable_event_reporting that disables any
>> + supported events that we have determined should not be
>> + reported (e.g. GDB did not request them). */
>> +
>> +static void
>> +linux_low_enable_events (pid_t pid, int attached)
>> +{
>> + if (!report_fork_events)
>> + linux_ptrace_clear_flags (PTRACE_O_TRACEFORK);
>> +
>> + linux_enable_event_reporting (pid, attached);
>> +}
>> +
>> /* 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.
>
>> struct process_info *proc = find_process_pid (pid_of (thread));
>>
>> - linux_enable_event_reporting (lwpid, proc->attached);
>> + linux_low_enable_events (lwpid, proc->attached);
>> child->must_set_ptrace_flags = 0;
>> }
>>
>> @@ -1926,8 +1997,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
>> @@ -2502,6 +2577,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
>> @@ -2868,7 +2955,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);
>>
>> @@ -2890,6 +2978,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
>> @@ -2999,7 +3094,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;
>> +
>> + /* Reset the event lwp's waitstatus since we handled it already. */
>> + event_child->waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
>
> I'd think this should be TARGET_WAITKIND_IGNORE? That's the usual
> status for "clear".
Fixed.
>
>> + }
>> + 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
>> @@ -3032,7 +3137,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));
>> }
>> @@ -4830,8 +4935,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. */
>> @@ -5271,6 +5376,39 @@ 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);
>> + struct process_info *proc = find_process_pid (pid_of (thread));
>> +
>> + linux_low_enable_events (lwpid_of (thread), proc->attached);
>> + 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;
>> +
>> + /* Reset the ptrace options to enable on the inferior(s). */
>> + linux_reset_ptrace_options ();
>> +
>> + /* Request that all the lwps reset their ptrace options. */
>> + find_inferior (&all_threads, reset_lwp_ptrace_options_callback , &pid);
>
> Spurious space before ', &pid'. But, you can't do this if threads
> are already running, such as when you reconnect after you left the
> target running for disconnected tracing. Instead, you need to
> force threads to momentarily pause and set their must_set_ptrace_flags
> flag, much like when we need to change running thread's debug registers
> for watchpoints. See linux-x86-low.c:update_debug_registers_callback.
I've added the mechanism to stop the lwps as in that function. In a
comment below I believe you were proposing that this mechanism could be
unnecessary, and that resetting the ptrace flags for a new connection
could be handled another way. I still think this mechanism is necessary.
See the comment below after linux_enable_event_reporting for my rationale.
>
>>
>> diff --git a/gdb/nat/linux-ptrace.c b/gdb/nat/linux-ptrace.c
>> index aba3da8..3494bcf 100644
>> --- a/gdb/nat/linux-ptrace.c
>> +++ b/gdb/nat/linux-ptrace.c
>> @@ -25,13 +25,16 @@
>>
>> #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. */
>> +/* Stores the ptrace options currently enabled by this gdbserver.
>
> Talking about "this gdbserver" here doesn't make sense. This file
> is used by native gdb too.
Fixed.
>> + A value of -1 means we did not check for features yet. A value
>> + of 0 means there are no enabled features. */
>> static int current_ptrace_options = -1;
>>
>> -/* Additional flags to test. */
>> +/* Stores the fork and exec ptrace options supported by the operating
>> + system. */
>> +static int supported_additional_flags = 0;
>>
>> +/* Additional flags to test. */
>> static int additional_flags;
>>
>> /* Find all possible reasons we could fail to attach PID and append
>> @@ -344,6 +347,7 @@ linux_check_ptrace_features (void)
>>
>> /* Initialize the options. */
>> current_ptrace_options = 0;
>> + supported_additional_flags = 0;
>>
>> /* Fork a child so we can do some testing. The child will call
>> linux_child_function and will get traced. The child will
>> @@ -394,7 +398,7 @@ linux_test_for_tracesysgood (int child_pid)
>> (PTRACE_TYPE_ARG4) PTRACE_O_TRACESYSGOOD);
>>
>> if (ret == 0)
>> - current_ptrace_options |= PTRACE_O_TRACESYSGOOD;
>> + supported_additional_flags |= PTRACE_O_TRACESYSGOOD;
>> }
>>
>> /* Determine if PTRACE_O_TRACEFORK can be used to follow fork
>> @@ -421,7 +425,7 @@ linux_test_for_tracefork (int child_pid)
>> (PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
>> | PTRACE_O_TRACEVFORKDONE));
>> if (ret == 0)
>> - current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
>> + supported_additional_flags |= PTRACE_O_TRACEVFORKDONE;
>> }
>>
>> /* Setting PTRACE_O_TRACEFORK did not cause an error, however we
>> @@ -459,9 +463,16 @@ 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));
>> +
>> + /* Save the "extended" options in case we need to reset
>> + the options later for a connect from a different GDB. */
>> + supported_additional_flags |= (PTRACE_O_TRACEFORK
>> + | PTRACE_O_TRACEVFORK
>> + | PTRACE_O_TRACEEXEC);
>> +
>> + /* Enable only those options requested by GDB. */
>> + current_ptrace_options |= (supported_additional_flags
>> + & additional_flags);
>>
>> /* Do some cleanup and kill the grandchild. */
>> my_waitpid (second_pid, &second_status, 0);
>> @@ -518,6 +529,25 @@ linux_enable_event_reporting (pid_t pid, int attached)
>> (PTRACE_TYPE_ARG4) (uintptr_t) ptrace_options);
>> }
>>
>> +/* Reset the ptrace options using potentially different
>> + additional_flags. */
>> +
>> +void
>> +linux_reset_ptrace_options (void)
>> +{
>> + /* Check if we have initialized the ptrace features for this
>> + target. If not, do it now. */
>> + if (current_ptrace_options == -1)
>> + linux_check_ptrace_features ();
>> +
>> + /* Clear only the "extended" options. */
>> + linux_ptrace_clear_flags (all_additional_flags);
>> +
>> + /* Add the new requested flags back in. */
>> + current_ptrace_options |= (supported_additional_flags
>> + & additional_flags);
>> +}
>> +
>> /* Disable reporting of all currently supported ptrace events. */
>>
>> void
>> @@ -603,9 +633,20 @@ linux_ptrace_init_warnings (void)
>> void
>> linux_ptrace_set_additional_flags (int flags)
>> {
>> + int invalid_flags = (flags & ~all_additional_flags);
>> +
>> + gdb_assert (invalid_flags == 0);
>> additional_flags = flags;
>> }
>>
>> +/* Clear FLAGS in current_ptrace_options. */
>> +
>> +void
>> +linux_ptrace_clear_flags (int flags)
>> +{
>> + current_ptrace_options &= ~flags;
>> +}
>> +
>
> This still looks a bit messy and mostly unnecessary to me. :-/
>
> Why not something based on this? In linux-ptrace.c:
>
> /* 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. */
>
> void
> linux_enable_event_reporting (pid_t pid, int options)
> {
> /* Check if we have initialized the ptrace features for this
> target. If not, do it now. */
> if (current_ptrace_options == -1)
> linux_check_ptrace_features ();
>
> /* We always want clone events. */
> options |= PTRACE_O_TRACECLONE;
>
> /* Filter out unsupported options. */
> options &= current_ptrace_options;
>
> /* Set the options. */
> ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0,
> (PTRACE_TYPE_ARG4) (uintptr_t) options);
> }
>
>
> (current_ptrace_options would be renamed to
> supported_ptrace_options or some such afterwards.)
>
> and then in linux-low.c:
>
> if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
> {
> struct process_info *proc = find_process_pid (pid_of (thread));
> int options = 0;
>
> if (!proc->attached)
> options |= PTRACE_O_EXITKILL;
>
> if (report_fork_events)
> options |= PTRACE_O_TRACEFORK;
>
> if (report_vfork_events)
> options |= (PTRACE_O_TRACEVFORKDONE | PTRACE_O_TRACEVFORK);
>
> if (report_exec_events)
> options |= PTRACE_O_TRACEEXEC;
>
> linux_enable_event_reporting (pid, options);
> child->must_set_ptrace_flags = 0;
> }
>
> That'd cope with a different gdb reconnecting and requesting
> different options too.
This is definitely more concise, thanks.
One outcome of my changes here is the elimination of the "additional_flags"
mechanism. This had a side-effect in the linux-ptrace functions like
linux_test_for_tracefork, removing the checks that allowed the functions to
bail out if additional_flags did not include the flags being tested. I
don't think that this is a problem, since the events will not be enabled
unless they are supported and requested.
As I noted above, I think we still need handle_new_gdb_connection to ensure
that the ptrace options are set properly when GDB reconnects.
Rationale: suppose we have the following sequence of events:
1) GDB that supports fork event connects, and gdbserver sets
PTRACE_O_TRACEFORK
2) inferior stops at a breakpoint
3) GDB disconnects, inferior remains stopped
4) GDB that does not support fork events connects. ptrace options are
unchanged without handle_new_gdb_connection.
5) inferior is resumed and executes a fork. A fork event is
generated and sent to GDB, who doesn't recognize it because we
did not reset the options when the new GDB connected.
>
>
>> -/* 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. */
>> +/* 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. If IS_FORK_CHILD is true, then inferior_ptid is the child
>> + of an unfollowed fork, and we need to avoid deleting breakpoints
>> + still needed by the parent. */
>>
>> static void
>> -remote_detach_1 (const char *args, int from_tty, int extended)
>> +remote_detach_1 (struct target_ops *ops, const char *args,
>> + int from_tty, int is_fork_child)
>> {
>> 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."));
>> @@ -4468,22 +4482,75 @@ remote_detach_1 (const char *args, int from_tty, int extended)
>> 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_child && !is_fork_parent)
>> + target_mourn_inferior ();
>> + else
>> + {
>> + inferior_ptid = null_ptid;
>> + detach_inferior (pid);
>> + }
>> }
>
> This looks quite confusing to me. Please instead simply factor out
> the bits that actually do the remote detach to a separate
> function, like:
>
> 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."));
> }
>
> And use that from both remote_detach_1 and the detach-child-fork
> case.
I've made this change.
>
>> +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. We can't use target_detach for the child process
because the host side doesn't know about that inferior.
Note that this means that in remote_detach_1 we still have to
handle the detach parent case to prevent target_mourn from being
called, which deletes the breakpoints that will be needed by the
followed child.
>
>> + {
>> + ptid_t parent_ptid;
>> + ptid_t child_ptid;
>> +
>> + gdb_assert (inferior_thread ()->pending_follow.kind
>> + == TARGET_WAITKIND_FORKED);
>> +
>> + /* remote_detach_1 detaches inferior_ptid, which is currently
>> + the ptid of the parent. Switch inferior_ptid to the ptid
>> + of the child for the duration of the call. */
>> + parent_ptid = inferior_ptid;
>> + child_ptid = inferior_thread ()->pending_follow.value.related_pid;
>> + inferior_ptid = child_ptid;
>> + gdb_assert (!ptid_equal (parent_ptid, child_ptid));
>> +
>> + remote_detach_1 (ops, NULL, 0, 1);
>
> This then ends up being just remote_detach_pid + detach_inferior, AFAICS.
>
>
>> +
>> + /* Restore the parent ptid. */
>> + inferior_ptid = parent_ptid;
>> + }
>> + }
>> + return 0;
>> }
>>
>> /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
>> @@ -5652,6 +5719,11 @@ Packet: '%s'\n"),
>> p = unpack_varlen_hex (++p1, &c);
>> event->core = c;
>> }
>> + else if (strncmp (p, "xfork", p1 - p) == 0)
>> + {
>> + event->ws.value.related_pid = read_ptid (++p1, &p);
>> + event->ws.kind = TARGET_WAITKIND_FORKED;
>> + }
>> else
>> {
>> ULONGEST pnum;
>> @@ -9514,8 +9586,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));
>> @@ -11938,6 +12013,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
>> diff --git a/gdb/testsuite/gdb.base/multi-forks.exp b/gdb/testsuite/gdb.base/multi-forks.exp
>> index e95cb4b..2a71e63 100644
>> --- a/gdb/testsuite/gdb.base/multi-forks.exp
>> +++ b/gdb/testsuite/gdb.base/multi-forks.exp
>> @@ -62,6 +62,23 @@ proc continue_to_exit_bp_loc {} {
>> set seen_break 0
>> set seen_prompt 0
>> set seen_timeout 0
>> +
>> + # If we are running with a native gdbserver, the output ($decimal done)
>> + # will come via the spawn_id of gdbserver, not the spawn_id of gdb (the
>> + # default). So we grab the spawn_id of gdbserver, if it exists, and
>> + # add it to the gdb_expect statement below using "-i", allowing us to
>> + # apply the expect statement to the output of both spawn_ids.
>> + #
>> + # If we are running with a truly remote gdbserver (gdb,noinferiorio),
>> + # the output of the program will be inaccessible. In this case we do
>> + # not check for the ($decimal done) output, but just look for the gdb
>> + # prompt.
>> + global server_spawn_id
>> + set current_spawn_id [board_info host fileid]
>> + if {![info exists server_spawn_id]} {
>> + set server_spawn_id ""
>> + }
>> +
>> while { ($seen_done < 16 || ! $seen_prompt) && ! $seen_timeout } {
>> # We don't know what order the interesting things will arrive in.
>> # Using a pattern of the form 'x|y|z' instead of -re x ... -re y
>> @@ -70,7 +87,8 @@ proc continue_to_exit_bp_loc {} {
>> # first in the script that occurs anywhere in the input, so that
>> # we don't skip anything.
>> gdb_expect {
>> - -re "($decimal done)|(Breakpoint)|($gdb_prompt)" {
>> + -i "$current_spawn_id $server_spawn_id" \
>
>
> Note this is currently working by chance. We need this one in:
>
> https://sourceware.org/ml/gdb-patches/2015-02/msg00659.html
>
> in order to safely be able to do '-i "$server_spawn_id"'.
I saw your subsequent email about having pushed the patch that affects
my changes to gdb.base/multi-forks.exp. I had already moved the changes
to this test into a separate patch. I'll update that to work with your
patch and submit it separately.
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-08 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-08 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 | 175 +++++++++++++++++++++++++++++++++++++++----
gdb/gdbserver/linux-low.h | 4 +
gdb/gdbserver/lynx-low.c | 1 +
gdb/gdbserver/remote-utils.c | 15 +++-
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 | 35 ++++++---
gdb/nat/linux-ptrace.c | 84 ++++++++-------------
gdb/nat/linux-ptrace.h | 1 -
gdb/remote.c | 122 ++++++++++++++++++++++++------
12 files changed, 346 insertions(+), 103 deletions(-)
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 06ac673..b8fbe45 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 host 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. */
@@ -5437,6 +5546,43 @@ 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);
+ 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;
+
+ 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)
{
@@ -6411,6 +6557,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..5c1982a 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -1114,12 +1114,25 @@ 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;
+
+ gdb_assert (report_fork_events);
+ 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 04707dc..3c9f3f7 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -368,6 +368,23 @@ pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
return 0;
}
+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 +393,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 +2320,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 +3122,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;
}
@@ -5018,14 +5039,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);
}
\f
diff --git a/gdb/nat/linux-ptrace.c b/gdb/nat/linux-ptrace.c
index aba3da8..e757bc2 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 target.
+ 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. */
+ 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 +482,29 @@ 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. */
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 +517,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 +584,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 0006618..6176620 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,44 @@ 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. If IS_FORK_CHILD is true, then inferior_ptid is the child
+ of an unfollowed fork, and we need to avoid deleting breakpoints
+ still needed by the parent. */
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)
{
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. */
+ if (!is_fork_child && !is_fork_parent)
+ target_mourn_inferior ();
+ else
+ {
+ inferior_ptid = null_ptid;
+ detach_inferior (pid);
+ }
}
static void
@@ -4480,6 +4516,37 @@ extended_remote_detach (struct target_ops *ops, const char *args, int from_tty)
remote_detach_1 (args, from_tty, 1);
}
+/* 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))
+ {
+ 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. */
static void
@@ -5640,6 +5707,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 +9561,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 +11892,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
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v7 1/7] Identify remote fork event support
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
2015-04-10 17:10 ` [PATCH v7 2/7] Clone remote breakpoints Don Breazeal
2015-04-10 17:10 ` [PATCH v7 4/7] Arch-specific remote follow fork Don Breazeal
@ 2015-04-10 17:10 ` Don Breazeal
2015-04-15 15:37 ` Pedro Alves
2015-04-10 17:10 ` [PATCH v7 3/7] Extended-remote Linux follow fork Don Breazeal
` (3 subsequent siblings)
6 siblings, 1 reply; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:10 UTC (permalink / raw)
To: gdb-patches
Hi Pedro,
This patch is mostly unchanged from the previous version, except for
moving the (updated) documentation pieces to a separate patch.
The remaining code portions of this patch were approved here:
https://sourceware.org/ml/gdb-patches/2015-03/msg00896.html
On 3/27/2015 4:14 AM, Pedro Alves wrote:
> On 03/26/2015 07:00 PM, Don Breazeal wrote:
>> On 3/24/2015 3:57 AM, Pedro Alves wrote:
>>> On 03/17/2015 08:56 PM, Don Breazeal wrote:
>> --- a/gdb/doc/gdb.texinfo
>> +++ b/gdb/doc/gdb.texinfo
>> @@ -35812,6 +35812,18 @@ extensions unless the stub also reports that it supports them by
>> including @samp{multiprocess+} in its @samp{qSupported} reply.
>> @xref{multiprocess extensions}, for details.
>>
>> +@item fork-events
>> +This feature indicates whether @value{GDBN} supports fork event
>> +extensions to the remote protocol. @value{GDBN} does not use such
>> +extensions unless the stub also reports that it supports them by
>> +including @samp{fork-events+} in its @samp{qSupported} reply.
>> +
>> +@item vfork-events
>> +This feature indicates whether @value{GDBN} supports vfork event
>> +extensions to the remote protocol. @value{GDBN} does not use such
>> +extensions unless the stub also reports that it supports them by
>> +including @samp{vfork-events+} in its @samp{qSupported} reply.
>> +
>> @item xmlRegisters
>> This feature indicates that @value{GDBN} supports the XML target
>> description. If the stub sees @samp{xmlRegisters=} with target
>> diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
>> index e4c5420..06ac673 100644
>
> You'll need to update the tables below, where it reads:
>
> "These are the currently defined stub features and their properties"
>
> and:
>
> "These are the currently defined stub features, in more detail"
>
> and also, mention the new commands in:
>
> "For each packet @var{name}, the command to enable or disable the
> packet is @code{set remote @var{name}-packet}. The available settings
> are:"
I have moved all the documentation pieces into a separate patch, and
incorporated these changes into that patch.
Thanks!
--Don
This patch implements a mechanism for GDB to determine whether fork
events are supported in gdbserver. This is a preparatory patch for
remote fork and exec event support.
Two new RSP packets are defined to represent fork and vfork event
support. These packets are used just like PACKET_multiprocess_feature
to denote whether the corresponding event is supported. GDB sends
fork-events+ and vfork-events+ to gdbserver to inquire about fork
event support. If the response enables these packets, then GDB
knows that gdbserver supports the corresponding events and will
enable them.
Target functions used to query for support are included along with
each new packet.
In order for gdbserver to know whether the events are supported at the
point where the qSupported packet arrives, the code in nat/linux-ptrace.c
had to be reorganized. Previously it would test for fork/exec event
support, then enable the events using the pid of the inferior. When the
qSupported packet arrives there may not be an inferior. So the mechanism
was split into two parts: a function that checks whether the events are
supported, called when gdbserver starts up, and another that enables the
events when the inferior stops for the first time.
Another gdbserver change was to add some global variables similar to
multi_process, one per new packet. These are used to control whether
the corresponding fork events are enabled. If GDB does not inquire
about the event support in the qSupported packet, then gdbserver will
not set these "report the event" flags. If the flags are not set, the
events are ignored like they were in the past. Thus, gdbserver will
never send fork event notification to an older GDB that doesn't
recognize fork events.
Tested on Ubuntu x64, native/remote/extended-remote, and as part of
subsequent patches in the series.
gdb/gdbserver/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* linux-low.c (linux_supports_fork_events): New function.
(linux_supports_vfork_events): New function.
(linux_target_ops): Initialize new structure members.
(initialize_low): Call linux_check_ptrace_features.
* lynx-low.c (lynx_target_ops): Initialize new structure
members.
* server.c (report_fork_events, report_vfork_events):
New global flags.
(handle_query): Add new features to qSupported packet and
response.
(captured_main): Initialize new global variables.
* target.h (struct target_ops) <supports_fork_events>:
New member.
<supports_vfork_events>: New member.
(target_supports_fork_events): New macro.
(target_supports_vfork_events): New macro.
* win32-low.c (win32_target_ops): Initialize new structure
members.
gdb/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* nat/linux-ptrace.c (linux_check_ptrace_features): Change
from static to extern.
* nat/linux-ptrace.h (linux_check_ptrace_features): Declare.
* remote.c (anonymous enum): <PACKET_fork_event_feature,
* PACKET_vfork_event_feature>: New enumeration constants.
(remote_protocol_features): Add table entries for new packets.
(remote_query_supported): Add new feature queries to qSupported
packet.
(_initialize_remote): Exempt new packets from the requirement
to have 'set remote' commands.
---
gdb/gdbserver/linux-low.c | 21 +++++++++++++++++++++
gdb/gdbserver/lynx-low.c | 2 ++
gdb/gdbserver/server.c | 22 ++++++++++++++++++++++
gdb/gdbserver/target.h | 14 ++++++++++++++
gdb/gdbserver/win32-low.c | 2 ++
gdb/nat/linux-ptrace.c | 2 +-
gdb/nat/linux-ptrace.h | 1 +
gdb/remote.c | 26 ++++++++++++++++++++++++++
8 files changed, 89 insertions(+), 1 deletion(-)
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index e4c5420..06ac673 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -5421,6 +5421,22 @@ linux_supports_multi_process (void)
return 1;
}
+/* Check if fork events are supported. */
+
+static int
+linux_supports_fork_events (void)
+{
+ return linux_supports_tracefork ();
+}
+
+/* Check if vfork events are supported. */
+
+static int
+linux_supports_vfork_events (void)
+{
+ return linux_supports_tracefork ();
+}
+
static int
linux_supports_disable_randomization (void)
{
@@ -6393,6 +6409,8 @@ static struct target_ops linux_target_ops = {
linux_async,
linux_start_non_stop,
linux_supports_multi_process,
+ linux_supports_fork_events,
+ linux_supports_vfork_events,
#ifdef USE_THREAD_DB
thread_db_handle_monitor_command,
#else
@@ -6469,4 +6487,7 @@ initialize_low (void)
sigaction (SIGCHLD, &sigchld_action, NULL);
initialize_low_arch ();
+
+ /* Enable extended ptrace events. */
+ linux_check_ptrace_features ();
}
diff --git a/gdb/gdbserver/lynx-low.c b/gdb/gdbserver/lynx-low.c
index 2f85829..687cce0 100644
--- a/gdb/gdbserver/lynx-low.c
+++ b/gdb/gdbserver/lynx-low.c
@@ -758,6 +758,8 @@ static struct target_ops lynx_target_ops = {
NULL, /* async */
NULL, /* start_non_stop */
NULL, /* supports_multi_process */
+ NULL, /* supports_fork_events */
+ NULL, /* supports_vfork_events */
NULL, /* handle_monitor_command */
};
diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
index 3408ef7..c609db9 100644
--- a/gdb/gdbserver/server.c
+++ b/gdb/gdbserver/server.c
@@ -57,6 +57,8 @@ static int exit_requested;
int run_once;
int multi_process;
+int report_fork_events;
+int report_vfork_events;
int non_stop;
int swbreak_feature;
int hwbreak_feature;
@@ -1992,6 +1994,18 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
if (target_supports_stopped_by_hw_breakpoint ())
hwbreak_feature = 1;
}
+ else if (strcmp (p, "fork-events+") == 0)
+ {
+ /* GDB supports and wants fork events if possible. */
+ if (target_supports_fork_events ())
+ report_fork_events = 1;
+ }
+ else if (strcmp (p, "vfork-events+") == 0)
+ {
+ /* GDB supports and wants vfork events if possible. */
+ if (target_supports_vfork_events ())
+ report_vfork_events = 1;
+ }
else
target_process_qsupported (p);
@@ -2042,6 +2056,12 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
if (target_supports_multi_process ())
strcat (own_buf, ";multiprocess+");
+ if (target_supports_fork_events ())
+ strcat (own_buf, ";fork-events+");
+
+ if (target_supports_vfork_events ())
+ strcat (own_buf, ";vfork-events+");
+
if (target_supports_non_stop ())
strcat (own_buf, ";QNonStop+");
@@ -3414,6 +3434,8 @@ captured_main (int argc, char *argv[])
noack_mode = 0;
multi_process = 0;
+ report_fork_events = 0;
+ report_vfork_events = 0;
/* Be sure we're out of tfind mode. */
current_traceframe = -1;
cont_thread = null_ptid;
diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h
index 126c861..dc51627 100644
--- a/gdb/gdbserver/target.h
+++ b/gdb/gdbserver/target.h
@@ -277,6 +277,12 @@ struct target_ops
/* Returns true if the target supports multi-process debugging. */
int (*supports_multi_process) (void);
+ /* Returns true if fork events are supported. */
+ int (*supports_fork_events) (void);
+
+ /* Returns true if vfork events are supported. */
+ int (*supports_vfork_events) (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 *);
@@ -408,6 +414,14 @@ void set_target_ops (struct target_ops *);
int kill_inferior (int);
+#define target_supports_fork_events() \
+ (the_target->supports_fork_events ? \
+ (*the_target->supports_fork_events) () : 0)
+
+#define target_supports_vfork_events() \
+ (the_target->supports_vfork_events ? \
+ (*the_target->supports_vfork_events) () : 0)
+
#define detach_inferior(pid) \
(*the_target->detach) (pid)
diff --git a/gdb/gdbserver/win32-low.c b/gdb/gdbserver/win32-low.c
index 6c86765..5f50e46 100644
--- a/gdb/gdbserver/win32-low.c
+++ b/gdb/gdbserver/win32-low.c
@@ -1827,6 +1827,8 @@ static struct target_ops win32_target_ops = {
NULL, /* async */
NULL, /* start_non_stop */
NULL, /* supports_multi_process */
+ NULL, /* supports_fork_events */
+ NULL, /* supports_vfork_events */
NULL, /* handle_monitor_command */
NULL, /* core_of_thread */
NULL, /* read_loadmap */
diff --git a/gdb/nat/linux-ptrace.c b/gdb/nat/linux-ptrace.c
index 2244d9d..aba3da8 100644
--- a/gdb/nat/linux-ptrace.c
+++ b/gdb/nat/linux-ptrace.c
@@ -337,7 +337,7 @@ static void linux_test_for_exitkill (int child_pid);
/* Determine ptrace features available on this target. */
-static void
+void
linux_check_ptrace_features (void)
{
int child_pid, ret, status;
diff --git a/gdb/nat/linux-ptrace.h b/gdb/nat/linux-ptrace.h
index 8354a4d..03d98c9 100644
--- a/gdb/nat/linux-ptrace.h
+++ b/gdb/nat/linux-ptrace.h
@@ -149,6 +149,7 @@ extern void linux_ptrace_attach_fail_reason (pid_t pid, struct buffer *buffer);
extern char *linux_ptrace_attach_fail_reason_string (ptid_t ptid, int err);
extern void linux_ptrace_init_warnings (void);
+extern void linux_check_ptrace_features (void);
extern void linux_enable_event_reporting (pid_t pid, int attached);
extern void linux_disable_event_reporting (pid_t pid);
extern int linux_supports_tracefork (void);
diff --git a/gdb/remote.c b/gdb/remote.c
index 69a67a8..0006618 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1341,6 +1341,12 @@ enum {
/* Support for hwbreak+ feature. */
PACKET_hwbreak_feature,
+ /* Support for fork events. */
+ PACKET_fork_event_feature,
+
+ /* Support for vfork events. */
+ PACKET_vfork_event_feature,
+
PACKET_MAX
};
@@ -4040,6 +4046,10 @@ static const struct protocol_feature remote_protocol_features[] = {
PACKET_Qbtrace_conf_bts_size },
{ "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature },
{ "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature },
+ { "fork-events", PACKET_DISABLE, remote_supported_packet,
+ PACKET_fork_event_feature },
+ { "vfork-events", PACKET_DISABLE, remote_supported_packet,
+ PACKET_vfork_event_feature },
};
static char *remote_support_xml;
@@ -4118,6 +4128,16 @@ remote_query_supported (void)
q = remote_query_supported_append (q, "qRelocInsn+");
+ if (rs->extended)
+ {
+ if (packet_set_cmd_state (PACKET_fork_event_feature)
+ != AUTO_BOOLEAN_FALSE)
+ q = remote_query_supported_append (q, "fork-events+");
+ if (packet_set_cmd_state (PACKET_vfork_event_feature)
+ != AUTO_BOOLEAN_FALSE)
+ q = remote_query_supported_append (q, "vfork-events+");
+ }
+
q = reconcat (q, "qSupported:", q, (char *) NULL);
putpkt (q);
@@ -12378,6 +12398,12 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
"hwbreak-feature", "hwbreak-feature", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
+ "fork-event-feature", "fork-event-feature", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature],
+ "vfork-event-feature", "vfork-event-feature", 0);
+
/* Assert that we've registered "set remote foo-packet" commands
for all packet configs. */
{
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v7 6/7] Remote fork catch
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
` (5 preceding siblings ...)
2015-04-10 17:11 ` [PATCH v7 7/7] Extended-remote follow fork documentation Don Breazeal
@ 2015-04-10 17:11 ` Don Breazeal
2015-04-15 15:39 ` Pedro Alves
6 siblings, 1 reply; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:11 UTC (permalink / raw)
To: gdb-patches
Hi Pedro,
This version of the patch incorporates changes based on your comments on
the previous version, as outlined below.
On 3/24/2015 5:47 AM, Pedro Alves wrote:
> On 03/17/2015 08:56 PM, Don Breazeal wrote:
>
>> diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
>> index 8fa6f8a..346f2c4 100644
>> --- a/gdb/gdbserver/server.c
>> +++ b/gdb/gdbserver/server.c
>> @@ -1356,6 +1356,15 @@ handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg)
>> int core = target_core_of_thread (ptid);
>> char core_s[21];
>>
>> + /* Skip new threads created as the result of a fork if we are not done
>> + handling that fork event. We won't know whether to tell GDB about
>> + the new thread until we are done following the fork. */
>> + if ((last_status.kind == TARGET_WAITKIND_FORKED
>> + || last_status.kind == TARGET_WAITKIND_VFORKED)
>> + && (ptid_get_pid (last_status.value.related_pid)
>> + == ptid_get_pid (ptid)))
>> + return;
>
> This use of last_status here is really just as bad as
> get_last_target_status, for the same reasons. What if a thread
> forks at the same time another thread hits a breakpoint, and
> we end up reporting the breakpoint first, leaving the fork
> pending? Sounds like we'll end up listing the child fork
> thread then.
I moved this operation (removing the new, unreported thread from the list
reported by the target) to the host side in remote.c:remove_new_fork_child,
called from remote.c:remote_update_thread_list.
>
>> +
>> write_ptid (ptid_s, ptid);
>>
>> if (core != -1)
>> @@ -4144,3 +4153,12 @@ handle_target_event (int err, gdb_client_data client_data)
>>
>> return 0;
>> }
>> +
>> +/* Retrieve the last waitstatus reported to GDB. */
>> +
>> +void
>> +get_last_target_status (ptid_t *ptid, struct target_waitstatus *last)
>> +{
>> + *ptid = last_ptid;
>> + *last = last_status;
>> +}
>
> Looks like you forgot to delete the function. :-)
Sorry for the sloppiness.
>
>> diff --git a/gdb/gdbserver/server.h b/gdb/gdbserver/server.h
>> index 09a5624..8c6ec27 100644
>> --- a/gdb/gdbserver/server.h
>> +++ b/gdb/gdbserver/server.h
>> @@ -113,6 +113,8 @@ typedef int gdb_fildes_t;
>> /* Functions from server.c. */
>> extern int handle_serial_event (int err, gdb_client_data client_data);
>> extern int handle_target_event (int err, gdb_client_data client_data);
>> +extern void get_last_target_status (ptid_t *ptid,
>> + struct target_waitstatus *last);
>>
>> #include "remote-utils.h"
>>
>> diff --git a/gdb/remote.c b/gdb/remote.c
>> index d1ba62d..44ee89f 100644
>> --- a/gdb/remote.c
>> +++ b/gdb/remote.c
>
>
>> @@ -8012,6 +8060,23 @@ extended_remote_kill (struct target_ops *ops)
>> int res;
>> int pid = ptid_get_pid (inferior_ptid);
>> struct remote_state *rs = get_remote_state ();
>> + struct thread_info *tp = find_thread_ptid (inferior_ptid);
>> +
>> + /* If we're stopped while forking and we haven't followed yet,
>> + kill the child task. We need to do this first because the
>> + parent will be sleeping if this is a vfork. */
>> +
>> + if (tp != NULL && (tp->pending_follow.kind == TARGET_WAITKIND_FORKED
>> + || tp->pending_follow.kind == TARGET_WAITKIND_VFORKED))
>
> Looks like this will miss killing the child if the user switches to
> some thread other than the one that forked, in case it was a multi-threaded
> program that forked.
Fixed, using a similar method as for removing the new unreported thread
in remote_update_thread_list above.
>
>> + {
>> + ptid_t parent_ptid = inferior_ptid;
>> +
>> + inferior_ptid = tp->pending_follow.value.related_pid;
>> + set_general_thread (inferior_ptid);
>> + extended_remote_kill (ops);
>> + inferior_ptid = parent_ptid;
>> + set_general_thread (inferior_ptid);
>
> We never want to use the 'k' packet here, so this could
> just simply be:
>
> int child_pid = tp->pending_follow.value.related_pid;
> remote_vkill (child_pid);
I made this change, thanks.
>
>> + }
>>
>> res = remote_vkill (pid, rs);
>> if (res == -1 && !(rs->extended && remote_multi_process_p (rs)))
>> @@ -12036,6 +12101,14 @@ Specify the serial device it is connected to (e.g. /dev/ttya).";
>> extended_remote_ops.to_supports_disable_randomization
>> = extended_remote_supports_disable_randomization;
>> extended_remote_ops.to_follow_fork = remote_follow_fork;
>> + extended_remote_ops.to_insert_fork_catchpoint
>> + = remote_insert_fork_catchpoint;
>> + extended_remote_ops.to_remove_fork_catchpoint
>> + = remote_remove_fork_catchpoint;
>> + extended_remote_ops.to_insert_vfork_catchpoint
>> + = remote_insert_vfork_catchpoint;
>> + extended_remote_ops.to_remove_vfork_catchpoint
>> + = remote_remove_vfork_catchpoint;
>> }
>>
>> static int
>> diff --git a/gdb/testsuite/gdb.threads/fork-thread-pending.exp b/gdb/testsuite/gdb.threads/fork-thread-pending.exp
>> index d229232..594f376 100644
>> --- a/gdb/testsuite/gdb.threads/fork-thread-pending.exp
>> +++ b/gdb/testsuite/gdb.threads/fork-thread-pending.exp
>> @@ -31,6 +31,26 @@ if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executab
>> return -1
>> }
>>
>> +# Find a thread that did not fork and is not the main thread and
>> +# return its thread number. We can't just hard-code the thread
>> +# number since we have no guarantee as to the ordering of the threads
>> +# in gdb.
>
> I don't understand this -- the test runs to main first, so the main
> thread should always be thread 1, no?
>
I can no longer reproduce the thread ordering problem that I was seeing
when I implemented this. Not sure why...my notes imply it might have
something to do with 'target remote', but I'm unsure at this point.
At any rate this test doesn't need to be changed for this patch, so
I've removed it from the patch.
>
>> We know that the main thread is in pthread_join and the
>> +# forking thread is in fork, so we use this rather ungainly regexp
>> +# to capture an entry from 'info threads' that doesn't show one of
>> +# those routines, then extract the thread number.
>> +
>> +proc find_unforked_thread { } {
>> + gdb_test_multiple "info threads" "find unforked thread" {
>> + -re "(\[^\r]*Thread\[^\r]* in \[^fp]\[^ot]\[^rh]\[^kr]\[^e]\[^a]\[^d]\[^_]\[^j]\[^\r]*\r\n)" {
>> + regexp "(\[ ]*)(\[0-9]*)(\[ ]*Thread\[^\r]*\r\n)" $expect_out(0,string) ignore lead_spc threadnum rest
>> + }
>> + timeout {
>> + set threadnum -1
>> + }
>> + }
>> + return $threadnum
>> +}
>> +
>> clean_restart ${binfile}
>>
>> if ![runto_main] then {
>> @@ -46,7 +66,8 @@ gdb_test "continue" "Catchpoint.*" "1, get to the fork event"
>>
>> gdb_test "info threads" " Thread .* Thread .* Thread .* Thread .*" "1, multiple threads found"
>>
>> -gdb_test "thread 1" ".*" "1, switched away from event thread"
>> +set threadnum [find_unforked_thread]
>> +gdb_test "thread $threadnum" ".*" "1, switched away from event thread to thread $threadnum"
>>
>> gdb_test "continue" "Not resuming.*" "1, refused to resume"
>>
>>
>
> Thanks,
> Pedro Alves
>
BTW, I still intend to submit a patch that removes the need to use
get_last_target_status in linux-nat.c:linux_nat_kill, along with a test
for that scenario.
Thanks
--Don
This patch implements catchpoints for fork events on extended-remote
Linux targets.
Implementation appeared to be straightforward, requiring four new functions
in remote.c to implement insert/remove of fork/vfork catchpoints. These
functions are essentially stubs that just return 0 ('success') if the
required features are enabled. If the fork events are being reported, then
catchpoints are set and hit.
However, there are some extra issues that arise with catchpoints.
1) Thread creation reporting -- fork catchpoints are hit before the
follow_fork has been completed. When stopped at a fork catchpoint
in the native implementation, the new process is not 'reported'
until after the follow is done. It doesn't show up in the inferiors
list or the threads list. However, in the gdbserver case, an
'info threads' while stopped at a fork catchpoint will retrieve the
new thread info from the target and add it to GDB's data structures,
prior to the follow operations. Because of this premature report,
things on the GDB side eventually get very confused.
So in remote.c:remote_update_thread_list, we check to see if there
are any pending fork parent threads. If there are we remove the
related fork child thread from the thread list sent by the target.
2) Kill process before fork is followed -- on the native side in
linux-nat.c:linux_nat_kill, there is some code to handle the case where
a fork has occurred but follow_fork hasn't been called yet. It does
this by using the last status to determine if a follow is pending, and
if it is, to kill the child task. The use of last_status is fragile
in situations like non-stop mode where other events may have occurred
after the fork event. This patch identifies a fork parent
in remote.c:extended_remote_kill in a way similar to that used in
thread creation reporting above. If one is found, it kills the new
child as well.
Tested on x64 Ubuntu Lucid, native, remote, extended-remote. Tested the
case of killing the forking process before the fork has been followed
manually.
Thanks
--Don
gdb/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* remote.c (remote_insert_fork_catchpoint): New function.
(remote_remove_fork_catchpoint): New function.
(remote_insert_vfork_catchpoint): New function.
(remote_remove_vfork_catchpoint): New function.
(pending_fork_parent_callback): New function.
(remove_new_fork_child): New function.
(remote_update_thread_list): Call remove_new_fork_child.
(extended_remote_kill): Kill fork child when killing the
parent before follow_fork completes.
(init_extended_remote_ops): Initialize target vector with
new fork catchpoint functions.
---
gdb/remote.c | 117 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 117 insertions(+)
diff --git a/gdb/remote.c b/gdb/remote.c
index 4e65092..224a520 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1477,6 +1477,46 @@ remote_vfork_event_p (struct remote_state *rs)
return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE;
}
+/* Insert fork catchpoint target routine. If fork events are enabled
+ then return success, nothing more to do. */
+
+static int
+remote_insert_fork_catchpoint (struct target_ops *ops, int pid)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return !remote_fork_event_p (rs);
+}
+
+/* Remove fork catchpoint target routine. Nothing to do, just
+ return success. */
+
+static int
+remote_remove_fork_catchpoint (struct target_ops *ops, int pid)
+{
+ return 0;
+}
+
+/* Insert vfork catchpoint target routine. If vfork events are enabled
+ then return success, nothing more to do. */
+
+static int
+remote_insert_vfork_catchpoint (struct target_ops *ops, int pid)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return !remote_vfork_event_p (rs);
+}
+
+/* Remove vfork catchpoint target routine. Nothing to do, just
+ return success. */
+
+static int
+remote_remove_vfork_catchpoint (struct target_ops *ops, int pid)
+{
+ return 0;
+}
+
/* 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;
@@ -2815,6 +2855,56 @@ remote_get_threads_with_qthreadinfo (struct target_ops *ops,
return 0;
}
+/* Determine if THREAD is a pending fork parent thread. ARG contains
+ the pid of the process who's threads we want to check, or -1 if
+ we want to check all threads. */
+
+static int
+pending_fork_parent_callback (struct thread_info *thread, void *arg)
+{
+ int pid = *(int *) arg;
+
+ if (thread->pending_follow.kind == TARGET_WAITKIND_FORKED
+ || thread->pending_follow.kind == TARGET_WAITKIND_VFORKED)
+ {
+ if ((pid == -1) || (pid == ptid_get_pid (thread->ptid)))
+ return 1;
+ }
+
+ return 0;
+}
+
+/* If CONTEXT contains any fork child threads that have not been
+ reported yet, remove them from the CONTEXT list. If such a
+ thread exists it is because we are stopped at a fork catchpoint
+ and have not yet called follow_fork, which will set up the
+ host-side data structures for the new process. */
+
+static void
+remove_new_fork_child (struct threads_listing_context *context)
+{
+ struct thread_info * thread;
+ int pid = -1;
+
+ /* Check to see if there is an in-progress fork parent. */
+ thread = iterate_over_threads (pending_fork_parent_callback, &pid);
+ if (thread != NULL)
+ {
+ ptid_t child_ptid = thread->pending_follow.value.related_pid;
+ struct thread_item *item;
+ int i;
+
+ for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
+ {
+ if (ptid_equal (item->ptid, child_ptid))
+ {
+ VEC_ordered_remove (thread_item_t, context->items, i);
+ break;
+ }
+ }
+ }
+}
+
/* Implement the to_update_thread_list function for the remote
targets. */
@@ -2874,6 +2964,10 @@ remote_update_thread_list (struct target_ops *ops)
}
}
+ /* Remove any unreported fork child from CONTEXT so that
+ we don't interfere with follow fork. */
+ remove_new_fork_child (&context);
+
/* And now add threads we don't know about yet to our list. */
for (i = 0;
VEC_iterate (thread_item_t, context.items, i, item);
@@ -7998,6 +8092,21 @@ extended_remote_kill (struct target_ops *ops)
int res;
int pid = ptid_get_pid (inferior_ptid);
struct remote_state *rs = get_remote_state ();
+ struct thread_info *thread;
+
+ /* If we're stopped while forking and we haven't followed yet,
+ kill the child task. We need to do this first because the
+ parent will be sleeping if this is a vfork. */
+ thread = iterate_over_threads (pending_fork_parent_callback, &pid);
+ if (thread != NULL)
+ {
+ int child_pid;
+
+ child_pid = ptid_get_pid (thread->pending_follow.value.related_pid);
+ res = remote_vkill (child_pid, rs);
+ if (res != 0)
+ error (_("Can't kill fork child process"));
+ }
res = remote_vkill (pid, rs);
if (res == -1 && !(rs->extended && remote_multi_process_p (rs)))
@@ -11913,6 +12022,14 @@ Specify the serial device it is connected to (e.g. /dev/ttya).";
extended_remote_ops.to_supports_disable_randomization
= extended_remote_supports_disable_randomization;
extended_remote_ops.to_follow_fork = remote_follow_fork;
+ extended_remote_ops.to_insert_fork_catchpoint
+ = remote_insert_fork_catchpoint;
+ extended_remote_ops.to_remove_fork_catchpoint
+ = remote_remove_fork_catchpoint;
+ extended_remote_ops.to_insert_vfork_catchpoint
+ = remote_insert_vfork_catchpoint;
+ extended_remote_ops.to_remove_vfork_catchpoint
+ = remote_remove_vfork_catchpoint;
}
static int
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v7 5/7] Remote follow vfork
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
` (3 preceding siblings ...)
2015-04-10 17:10 ` [PATCH v7 3/7] Extended-remote Linux follow fork Don Breazeal
@ 2015-04-10 17:11 ` Don Breazeal
2015-04-15 15:38 ` Pedro Alves
2015-04-10 17:11 ` [PATCH v7 7/7] Extended-remote follow fork documentation Don Breazeal
2015-04-10 17:11 ` [PATCH v7 6/7] Remote fork catch Don Breazeal
6 siblings, 1 reply; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:11 UTC (permalink / raw)
To: gdb-patches
Hi Pedro,
This version of the patch incorporates changes based on your comments on
the previous version, as outlined below.
On 3/24/2015 5:28 AM, Pedro Alves wrote:
> On 03/17/2015 08:56 PM, Don Breazeal wrote:
>
>> diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
>> index dc43e38..42c3ec5 100644
>> --- a/gdb/gdbserver/remote-utils.c
>> +++ b/gdb/gdbserver/remote-utils.c
>> @@ -1115,15 +1115,19 @@ prepare_resume_reply (char *buf, ptid_t ptid,
>> {
>> case TARGET_WAITKIND_STOPPED:
>> case TARGET_WAITKIND_FORKED:
>> + case TARGET_WAITKIND_VFORKED:
>> {
>> struct thread_info *saved_thread;
>> const char **regp;
>> struct regcache *regcache;
>>
>> - if (status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
>> + if ((status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
>> + || (status->kind == TARGET_WAITKIND_VFORKED
>> + && report_vfork_events))
>> {
>> enum gdb_signal signal = GDB_SIGNAL_TRAP;
>> - const char *event = "xfork";
>> + const char *event = (status->kind == TARGET_WAITKIND_FORKED
>> + ? "xfork" : "vfork");
>>
>> sprintf (buf, "T%02x%s:", signal, event);
>> buf += strlen (buf);
>> @@ -1245,6 +1249,15 @@ prepare_resume_reply (char *buf, ptid_t ptid,
>> else
>> sprintf (buf, "X%02x", status->value.sig);
>> break;
>> + case TARGET_WAITKIND_VFORK_DONE:
>> + if (multi_process)
>> + {
>> + enum gdb_signal signal = GDB_SIGNAL_TRAP;
>> + const char *event = "vforkdone";
>> +
>
> Should only include vforkdone if report_vfork_events is true, I'd think.
If we get one of these events (fork, vfork, vforkdone) and report_xxx_events
is not set, then it is a bug, so I put those flags into asserts for all
three events to ensure proper behavior.
>
>> + sprintf (buf, "T%02x%s:;", signal, event);
>> + }
>> + break;
>> default:
>> error ("unhandled waitkind");
>> break;
>> diff --git a/gdb/gdbserver/server.h b/gdb/gdbserver/server.h
>> index 696a24e..09a5624 100644
>> --- a/gdb/gdbserver/server.h
>> +++ b/gdb/gdbserver/server.h
>> @@ -85,6 +85,7 @@ extern int disable_packet_qfThreadInfo;
>> extern int run_once;
>> extern int multi_process;
>> extern int report_fork_events;
>> +extern int report_vfork_events;
>> extern int non_stop;
>>
>> /* True if the "swbreak+" feature is active. In that case, GDB wants
>> diff --git a/gdb/remote.c b/gdb/remote.c
>> index 899c7a2..d1ba62d 100644
>> --- a/gdb/remote.c
>> +++ b/gdb/remote.c
>> @@ -4526,15 +4526,20 @@ remote_follow_fork (struct target_ops *ops, int follow_child,
>> {
>> struct remote_state *rs = get_remote_state ();
>>
>> + /* If fork events aren't supported, then return. We know that if
>> + fork events are supported, then so are vfork events, since they
>> + were both introduced in the same version of the linux kernel. */
>
> "Linux", caps.
>
> But this really doesn't make sense -- if we define different
> qSupported features for fork and vfork, then we should check
> them separately. We don't know (and shouldn't care) whether
> we're debugging against a Linux target here. The packets/features
> should work with other OSs.
Point taken. I've made that change.
>
>> if (remote_fork_event_p (rs))
>> {
>> if (detach_fork && !follow_child)
>> {
>> ptid_t parent_ptid;
>> ptid_t child_ptid;
>> + enum target_waitkind kind;
>>
>
> Thanks,
> Pedro Alves
>
Thanks,
--Don
This patch implements follow-fork for vfork on remote and extended-remote
Linux targets.
The implementation follows the native implementation as much as possible.
Most of the work is done on the GDB side in the existing code now in
infrun.c. GDBserver just has to report the events and do a little
bookkeeping.
Implementation includes:
* enabling VFORK events by adding ptrace options for VFORK and VFORK_DONE
to linux-low.c:linux_low_ptrace_options.
* handling VFORK and VFORK_DONE events in linux-low.c:handle_extended_wait
and reporting them to GDB.
* including VFORK and VFORK_DONE events in the predicate
linux-low.c:extended_event_reported.
* adding support for VFORK and VFORK_DONE events in RSP by adding stop
reasons "vfork" and "vforkdone" to the 'T' Stop Reply Packet in both
gdbserver/remote-utils.c and gdb/remote.c.
Tested on x64 Ubuntu Lucid, native, remote, extended-remote.
Thanks
--Don
gdb/gdbserver/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* linux-low.c (handle_extended_wait): Handle PTRACE_EVENT_FORK and
PTRACE_EVENT_VFORK_DONE.
(linux_low_ptrace_options, extended_event_reported): Add vfork
events.
* remote-utils.c (prepare_resume_reply): New stop reasons "vfork"
and "vforkdone" for RSP 'T' Stop Reply Packet.
* server.h (report_vfork_events): Declare
global variable.
gdb/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* remote.c (remove_vfork_event_p): New function.
(remote_follow_fork): Add vfork event type to event checking.
(remote_parse_stop_reply): New stop reasons "vfork" and
"vforkdone" for RSP 'T' Stop Reply Packet.
---
gdb/gdbserver/linux-low.c | 26 ++++++++++++++++++++++----
gdb/gdbserver/remote-utils.c | 25 +++++++++++++++++++++----
gdb/gdbserver/server.h | 1 +
gdb/remote.c | 22 +++++++++++++++++++++-
4 files changed, 65 insertions(+), 9 deletions(-)
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 645c94f..0c3dfeb 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -425,7 +425,8 @@ handle_extended_wait (struct lwp_info *event_lwp, int wstat)
struct thread_info *event_thr = get_lwp_thread (event_lwp);
struct lwp_info *new_lwp;
- if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_CLONE))
+ if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_VFORK)
+ || (event == PTRACE_EVENT_CLONE))
{
ptid_t ptid;
unsigned long new_pid;
@@ -451,7 +452,7 @@ handle_extended_wait (struct lwp_info *event_lwp, int wstat)
warning ("wait returned unexpected status 0x%x", status);
}
- if (event == PTRACE_EVENT_FORK)
+ if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
{
struct process_info *parent_proc;
struct process_info *child_proc;
@@ -494,8 +495,13 @@ handle_extended_wait (struct lwp_info *event_lwp, int wstat)
the_low_target.new_fork (parent_proc, child_proc);
/* Save fork info in the parent thread. */
- event_lwp->waitstatus.kind = TARGET_WAITKIND_FORKED;
+ if (event == PTRACE_EVENT_FORK)
+ event_lwp->waitstatus.kind = TARGET_WAITKIND_FORKED;
+ else if (event == PTRACE_EVENT_VFORK)
+ event_lwp->waitstatus.kind = TARGET_WAITKIND_VFORKED;
+
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. */
@@ -538,6 +544,13 @@ handle_extended_wait (struct lwp_info *event_lwp, int wstat)
/* Don't report the event. */
return 1;
}
+ else if (event == PTRACE_EVENT_VFORK_DONE)
+ {
+ event_lwp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
+
+ /* Report the event. */
+ return 0;
+ }
internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event);
}
@@ -2010,6 +2023,9 @@ linux_low_ptrace_options (int attached)
if (report_fork_events)
options |= PTRACE_O_TRACEFORK;
+ if (report_vfork_events)
+ options |= (PTRACE_O_TRACEVFORK | PTRACE_O_TRACEVFORKDONE);
+
return options;
}
@@ -2714,7 +2730,9 @@ extended_event_reported (const struct target_waitstatus *waitstatus)
if (waitstatus == NULL)
return 0;
- return (waitstatus->kind == TARGET_WAITKIND_FORKED);
+ return (waitstatus->kind == TARGET_WAITKIND_FORKED
+ || waitstatus->kind == TARGET_WAITKIND_VFORKED
+ || waitstatus->kind == TARGET_WAITKIND_VFORK_DONE);
}
/* Wait for process, returns status. */
diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index 5c1982a..43e7916 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -1115,17 +1115,25 @@ prepare_resume_reply (char *buf, ptid_t ptid,
{
case TARGET_WAITKIND_STOPPED:
case TARGET_WAITKIND_FORKED:
+ case TARGET_WAITKIND_VFORKED:
{
struct thread_info *saved_thread;
const char **regp;
struct regcache *regcache;
- if (status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
+ if (status->kind == TARGET_WAITKIND_FORKED || status->kind == TARGET_WAITKIND_VFORKED)
{
enum gdb_signal signal = GDB_SIGNAL_TRAP;
-
- gdb_assert (report_fork_events);
- sprintf (buf, "T%02xfork:", signal);
+ if (status->kind == TARGET_WAITKIND_FORKED)
+ {
+ gdb_assert (report_fork_events);
+ sprintf (buf, "T%02xfork:", signal);
+ }
+ else
+ {
+ gdb_assert (report_vfork_events);
+ sprintf (buf, "T%02xvfork:", signal);
+ }
buf += strlen (buf);
buf = write_ptid (buf, status->value.related_pid);
strcat (buf, ";");
@@ -1245,6 +1253,15 @@ prepare_resume_reply (char *buf, ptid_t ptid,
else
sprintf (buf, "X%02x", status->value.sig);
break;
+ case TARGET_WAITKIND_VFORK_DONE:
+ if (multi_process)
+ {
+ enum gdb_signal signal = GDB_SIGNAL_TRAP;
+
+ gdb_assert (report_vfork_events);
+ sprintf (buf, "T%02xvforkdone:;", signal);
+ }
+ break;
default:
error ("unhandled waitkind");
break;
diff --git a/gdb/gdbserver/server.h b/gdb/gdbserver/server.h
index 696a24e..09a5624 100644
--- a/gdb/gdbserver/server.h
+++ b/gdb/gdbserver/server.h
@@ -85,6 +85,7 @@ extern int disable_packet_qfThreadInfo;
extern int run_once;
extern int multi_process;
extern int report_fork_events;
+extern int report_vfork_events;
extern int non_stop;
/* True if the "swbreak+" feature is active. In that case, GDB wants
diff --git a/gdb/remote.c b/gdb/remote.c
index 6176620..4e65092 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1469,6 +1469,14 @@ remote_fork_event_p (struct remote_state *rs)
return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
}
+/* Returns true if vfork events are supported. */
+
+static int
+remote_vfork_event_p (struct remote_state *rs)
+{
+ return packet_support (PACKET_vfork_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;
@@ -4528,8 +4536,10 @@ remote_follow_fork (struct target_ops *ops, int follow_child,
int detach_fork)
{
struct remote_state *rs = get_remote_state ();
+ enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
- if (remote_fork_event_p (rs))
+ if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
+ || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
{
if (detach_fork && !follow_child)
{
@@ -5712,6 +5722,16 @@ Packet: '%s'\n"),
event->ws.value.related_pid = read_ptid (++p1, &p);
event->ws.kind = TARGET_WAITKIND_FORKED;
}
+ else if (strncmp (p, "vfork", p1 - p) == 0)
+ {
+ event->ws.value.related_pid = read_ptid (++p1, &p);
+ event->ws.kind = TARGET_WAITKIND_VFORKED;
+ }
+ else if (strncmp (p, "vforkdone", p1 - p) == 0)
+ {
+ event->ws.kind = TARGET_WAITKIND_VFORK_DONE;
+ p = skip_to_semicolon (p1 + 1);
+ }
else
{
ULONGEST pnum;
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v7 7/7] Extended-remote follow fork documentation
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
` (4 preceding siblings ...)
2015-04-10 17:11 ` [PATCH v7 5/7] Remote follow vfork Don Breazeal
@ 2015-04-10 17:11 ` Don Breazeal
2015-04-10 17:56 ` Eli Zaretskii
2015-04-10 17:11 ` [PATCH v7 6/7] Remote fork catch Don Breazeal
6 siblings, 1 reply; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 17:11 UTC (permalink / raw)
To: gdb-patches
This patch contains the accumulated documentation changes for the
rest of the extended-remote follow fork patchset.
[Eli, you have reviewed parts of this before, but there are some new
bits as well. Sorry for all the iterations.]
Thanks
--Don
gdb/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* NEWS: Announce fork support in the RSP and support
for fork debugging in extended mode.
gdb/doc/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* gdb.texinfo (Forks): Note that fork debugging is
supported in extended mode.
(Remote Configuration): Add fork event features to table
of packet settings.
(Stop Reply Packets): Add fork events to list of stop reasons.
(General Query Packets): Add fork events to tables of
'gdbfeatures' and 'stub features' supported in the qSupported
packet, as well as to the list containing stub feature
details.
---
gdb/NEWS | 24 ++++++++++++++++
gdb/doc/gdb.texinfo | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 103 insertions(+)
diff --git a/gdb/NEWS b/gdb/NEWS
index 884c381..730b965 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -101,6 +101,30 @@ hwbreak stop reason
vFile:fstat:
Return information about files on the remote system.
+fork stop reason
+ Indicates that a fork system call was executed.
+
+vfork stop reason
+ Indicates that a vfork system call was executed.
+
+vforkdone stop reason
+ Indicates that a vfork child of the specified process has executed
+ an exec or exit, allowing the vfork parent to resume execution.
+
+fork-events and vfork-events features in qSupported
+ The qSupported packet allows GDB to request support for fork and
+ vfork events using new 'gdbfeatures' fork-events and vfork-events,
+ and the qSupported response can contain the corresponding
+ 'stubfeatures'. Set and show commands can be used to display
+ whether these features are enabled.
+
+* Extended-remote fork events
+
+ ** GDB now has support for fork events on extended-remote Linux
+ targets. For targets with Linux kernels 2.5.60 and later, this
+ enables follow-fork-mode and detach-on-fork for both fork and
+ vfork, as well as fork and vfork catchpoints.
+
* The info record command now shows the recording format and the
branch tracing configuration for the current thread when using
the btrace record target.
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index d794893..4ecbd11 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -3142,6 +3142,9 @@ create additional processes using the @code{fork} or @code{vfork} functions.
Currently, the only platforms with this feature are HP-UX (11.x and later
only?) and @sc{gnu}/Linux (kernel version 2.5.60 and later).
+The fork debugging commands are supported in both native mode and when
+connected to @code{gdbserver} using @kbd{target extended-remote}.
+
By default, when a program forks, @value{GDBN} will continue to debug
the parent process and the child process will run unimpeded.
@@ -19848,6 +19851,14 @@ are:
@tab @code{hwbreak stop reason}
@tab @code{hbreak}
+@item @code{fork-event-feature}
+@tab @code{fork stop reason}
+@tab @code{fork}
+
+@item @code{vfork-event-feature}
+@tab @code{vfork stop reason}
+@tab @code{vfork}
+
@end multitable
@node Remote Stub
@@ -35286,6 +35297,45 @@ The @var{r} part must be left empty.
The same remarks about @samp{qSupported} and non-stop mode above
apply.
+
+@cindex fork events, remote reply
+@item fork
+The packet indicates that @code{fork} was called, and @var{r}
+is the ptid of the new child process. This packet is only
+applicable to targets that support fork events.
+
+This packet should not be sent by default; older @value{GDBN} versions
+did not support it. @value{GDBN} requests it, by supplying an
+appropriate @samp{qSupported} feature (@pxref{qSupported}). The
+remote stub must also supply the appropriate @samp{qSupported} feature
+indicating support.
+
+@cindex vfork events, remote reply
+@item vfork
+The packet indicates that @code{vfork} was called, and @var{r}
+is the ptid of the new child process. This packet is only
+applicable to targets that support vfork events.
+
+This packet should not be sent by default; older @value{GDBN} versions
+did not support it. @value{GDBN} requests it, by supplying an
+appropriate @samp{qSupported} feature (@pxref{qSupported}). The
+remote stub must also supply the appropriate @samp{qSupported} feature
+indicating support.
+
+@cindex vforkdone events, remote reply
+@item vforkdone
+The packet indicates that a child process created by a vfork
+has either called @code{exec} or terminated, so that the
+address spaces of the parent and child process are no longer
+shared. The @var{r} part is ignored. This packet is only
+applicable to targets that support vforkdone events.
+
+This packet should not be sent by default; older @value{GDBN} versions
+did not support it. @value{GDBN} requests it, by supplying an
+appropriate @samp{qSupported} feature (@pxref{qSupported}). The
+remote stub must also supply the appropriate @samp{qSupported} feature
+indicating support.
+
@end table
@item W @var{AA}
@@ -35878,6 +35928,18 @@ reason in stop replies. @xref{swbreak stop reason}, for details.
@item hwbreak
This feature indicates whether @value{GDBN} supports the hwbreak stop
reason in stop replies. @xref{swbreak stop reason}, for details.
+
+@item fork-events
+This feature indicates whether @value{GDBN} supports fork event
+extensions to the remote protocol. @value{GDBN} does not use such
+extensions unless the stub also reports that it supports them by
+including @samp{fork-events+} in its @samp{qSupported} reply.
+
+@item vfork-events
+This feature indicates whether @value{GDBN} supports vfork event
+extensions to the remote protocol. @value{GDBN} does not use such
+extensions unless the stub also reports that it supports them by
+including @samp{vfork-events+} in its @samp{qSupported} reply.
@end table
Stubs should ignore any unknown values for
@@ -36116,6 +36178,16 @@ These are the currently defined stub features and their properties:
@tab @samp{-}
@tab No
+@item @samp{fork-events}
+@tab No
+@tab @samp{-}
+@tab No
+
+@item @samp{vfork-events}
+@tab No
+@tab @samp{-}
+@tab No
+
@end multitable
These are the currently defined stub features, in more detail:
@@ -36304,6 +36376,13 @@ breakpoints.
The remote stub reports the @samp{hwbreak} stop reason for hardware
breakpoints.
+@item fork-events
+The remote stub reports the @samp{fork} stop reason for fork events.
+
+@item vfork-events
+The remote stub reports the @samp{vfork} stop reason for vfork events
+and vforkdone events.
+
@end table
@item qSymbol::
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 7/7] Extended-remote follow fork documentation
2015-04-10 17:11 ` [PATCH v7 7/7] Extended-remote follow fork documentation Don Breazeal
@ 2015-04-10 17:56 ` Eli Zaretskii
2015-04-10 18:15 ` Breazeal, Don
0 siblings, 1 reply; 18+ messages in thread
From: Eli Zaretskii @ 2015-04-10 17:56 UTC (permalink / raw)
To: Don Breazeal; +Cc: gdb-patches
> From: Don Breazeal <donb@codesourcery.com>
> Date: Fri, 10 Apr 2015 10:09:46 -0700
>
> This patch contains the accumulated documentation changes for the
> rest of the extended-remote follow fork patchset.
Thanks.
> gdb/NEWS | 24 ++++++++++++++++
This part is OK.
> +@cindex fork events, remote reply
> +@item fork
> +The packet indicates that @code{fork} was called, and @var{r}
What does that @var{r} refer to? The previous text mentions
@var{n}:@var{r} pairs, but there's no @var{n} in this description, so
it doesn't seem to fit. What am I missing?
> +shared. The @var{r} part is ignored. This packet is only
^^
Two spaces.
OK with those fixed.
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 7/7] Extended-remote follow fork documentation
2015-04-10 17:56 ` Eli Zaretskii
@ 2015-04-10 18:15 ` Breazeal, Don
2015-04-10 18:29 ` Eli Zaretskii
0 siblings, 1 reply; 18+ messages in thread
From: Breazeal, Don @ 2015-04-10 18:15 UTC (permalink / raw)
To: Eli Zaretskii, Breazeal, Don; +Cc: gdb-patches
On 4/10/2015 10:56 AM, Eli Zaretskii wrote:
>> From: Don Breazeal <donb@codesourcery.com>
>> Date: Fri, 10 Apr 2015 10:09:46 -0700
>>
>
>> +@cindex fork events, remote reply
>> +@item fork
>> +The packet indicates that @code{fork} was called, and @var{r}
>
> What does that @var{r} refer to? The previous text mentions
> @var{n}:@var{r} pairs, but there's no @var{n} in this description, so
> it doesn't seem to fit. What am I missing?
Maybe I'm the one who is missing something. I thought that the @var{n}
was implied by '@item fork', because of this text above:
If @var{n} is a recognized @dfn{stop reason},
In this case @var{n} is a stop reason. Subsequently '@item fork' is in
this table:
The currently defined stop reasons are:
@table @samp
I pretty much just copied what had been done for shared library events
in the same table. Should I do this differently? I see that swbreak
and hwbreak aren't the same as the other items.
Thanks
--Don
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 7/7] Extended-remote follow fork documentation
2015-04-10 18:15 ` Breazeal, Don
@ 2015-04-10 18:29 ` Eli Zaretskii
2015-04-10 20:43 ` Don Breazeal
0 siblings, 1 reply; 18+ messages in thread
From: Eli Zaretskii @ 2015-04-10 18:29 UTC (permalink / raw)
To: Breazeal, Don; +Cc: Don_Breazeal, gdb-patches
> Date: Fri, 10 Apr 2015 11:15:30 -0700
> From: "Breazeal, Don" <donb@codesourcery.com>
> CC: "gdb-patches@sourceware.org" <gdb-patches@sourceware.org>
>
> >> +@cindex fork events, remote reply
> >> +@item fork
> >> +The packet indicates that @code{fork} was called, and @var{r}
> >
> > What does that @var{r} refer to? The previous text mentions
> > @var{n}:@var{r} pairs, but there's no @var{n} in this description, so
> > it doesn't seem to fit. What am I missing?
>
> Maybe I'm the one who is missing something. I thought that the @var{n}
> was implied by '@item fork', because of this text above:
>
> If @var{n} is a recognized @dfn{stop reason},
Sheesh! 2 pages ago...
> In this case @var{n} is a stop reason. Subsequently '@item fork' is in
> this table:
>
> The currently defined stop reasons are:
>
> @table @samp
>
> I pretty much just copied what had been done for shared library events
> in the same table. Should I do this differently? I see that swbreak
> and hwbreak aren't the same as the other items.
Never mind, let's leave it as it is.
Thanks.
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 7/7] Extended-remote follow fork documentation
2015-04-10 18:29 ` Eli Zaretskii
@ 2015-04-10 20:43 ` Don Breazeal
2015-04-15 15:47 ` Pedro Alves
0 siblings, 1 reply; 18+ messages in thread
From: Don Breazeal @ 2015-04-10 20:43 UTC (permalink / raw)
To: gdb-patches, eliz
Here is the updated patch with the whitespace fix.
Thanks
--Don
This patch contains the accumulated documentation changes for the
rest of the extended-remote follow fork patchset.
gdb/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* NEWS: Announce fork support in the RSP and support
for fork debugging in extended mode.
gdb/doc/
2015-04-08 Don Breazeal <donb@codesourcery.com>
* gdb.texinfo (Forks): Note that fork debugging is
supported in extended mode.
(Remote Configuration): Add fork event features to table
of packet settings.
(Stop Reply Packets): Add fork events to list of stop reasons.
(General Query Packets): Add fork events to tables of
'gdbfeatures' and 'stub features' supported in the qSupported
packet, as well as to the list containing stub feature
details.
---
gdb/NEWS | 24 ++++++++++++++++
gdb/doc/gdb.texinfo | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 103 insertions(+)
diff --git a/gdb/NEWS b/gdb/NEWS
index 884c381..730b965 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -101,6 +101,30 @@ hwbreak stop reason
vFile:fstat:
Return information about files on the remote system.
+fork stop reason
+ Indicates that a fork system call was executed.
+
+vfork stop reason
+ Indicates that a vfork system call was executed.
+
+vforkdone stop reason
+ Indicates that a vfork child of the specified process has executed
+ an exec or exit, allowing the vfork parent to resume execution.
+
+fork-events and vfork-events features in qSupported
+ The qSupported packet allows GDB to request support for fork and
+ vfork events using new 'gdbfeatures' fork-events and vfork-events,
+ and the qSupported response can contain the corresponding
+ 'stubfeatures'. Set and show commands can be used to display
+ whether these features are enabled.
+
+* Extended-remote fork events
+
+ ** GDB now has support for fork events on extended-remote Linux
+ targets. For targets with Linux kernels 2.5.60 and later, this
+ enables follow-fork-mode and detach-on-fork for both fork and
+ vfork, as well as fork and vfork catchpoints.
+
* The info record command now shows the recording format and the
branch tracing configuration for the current thread when using
the btrace record target.
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index d794893..0cdf059 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -3142,6 +3142,9 @@ create additional processes using the @code{fork} or @code{vfork} functions.
Currently, the only platforms with this feature are HP-UX (11.x and later
only?) and @sc{gnu}/Linux (kernel version 2.5.60 and later).
+The fork debugging commands are supported in both native mode and when
+connected to @code{gdbserver} using @kbd{target extended-remote}.
+
By default, when a program forks, @value{GDBN} will continue to debug
the parent process and the child process will run unimpeded.
@@ -19848,6 +19851,14 @@ are:
@tab @code{hwbreak stop reason}
@tab @code{hbreak}
+@item @code{fork-event-feature}
+@tab @code{fork stop reason}
+@tab @code{fork}
+
+@item @code{vfork-event-feature}
+@tab @code{vfork stop reason}
+@tab @code{vfork}
+
@end multitable
@node Remote Stub
@@ -35286,6 +35297,45 @@ The @var{r} part must be left empty.
The same remarks about @samp{qSupported} and non-stop mode above
apply.
+
+@cindex fork events, remote reply
+@item fork
+The packet indicates that @code{fork} was called, and @var{r}
+is the ptid of the new child process. This packet is only
+applicable to targets that support fork events.
+
+This packet should not be sent by default; older @value{GDBN} versions
+did not support it. @value{GDBN} requests it, by supplying an
+appropriate @samp{qSupported} feature (@pxref{qSupported}). The
+remote stub must also supply the appropriate @samp{qSupported} feature
+indicating support.
+
+@cindex vfork events, remote reply
+@item vfork
+The packet indicates that @code{vfork} was called, and @var{r}
+is the ptid of the new child process. This packet is only
+applicable to targets that support vfork events.
+
+This packet should not be sent by default; older @value{GDBN} versions
+did not support it. @value{GDBN} requests it, by supplying an
+appropriate @samp{qSupported} feature (@pxref{qSupported}). The
+remote stub must also supply the appropriate @samp{qSupported} feature
+indicating support.
+
+@cindex vforkdone events, remote reply
+@item vforkdone
+The packet indicates that a child process created by a vfork
+has either called @code{exec} or terminated, so that the
+address spaces of the parent and child process are no longer
+shared. The @var{r} part is ignored. This packet is only
+applicable to targets that support vforkdone events.
+
+This packet should not be sent by default; older @value{GDBN} versions
+did not support it. @value{GDBN} requests it, by supplying an
+appropriate @samp{qSupported} feature (@pxref{qSupported}). The
+remote stub must also supply the appropriate @samp{qSupported} feature
+indicating support.
+
@end table
@item W @var{AA}
@@ -35878,6 +35928,18 @@ reason in stop replies. @xref{swbreak stop reason}, for details.
@item hwbreak
This feature indicates whether @value{GDBN} supports the hwbreak stop
reason in stop replies. @xref{swbreak stop reason}, for details.
+
+@item fork-events
+This feature indicates whether @value{GDBN} supports fork event
+extensions to the remote protocol. @value{GDBN} does not use such
+extensions unless the stub also reports that it supports them by
+including @samp{fork-events+} in its @samp{qSupported} reply.
+
+@item vfork-events
+This feature indicates whether @value{GDBN} supports vfork event
+extensions to the remote protocol. @value{GDBN} does not use such
+extensions unless the stub also reports that it supports them by
+including @samp{vfork-events+} in its @samp{qSupported} reply.
@end table
Stubs should ignore any unknown values for
@@ -36116,6 +36178,16 @@ These are the currently defined stub features and their properties:
@tab @samp{-}
@tab No
+@item @samp{fork-events}
+@tab No
+@tab @samp{-}
+@tab No
+
+@item @samp{vfork-events}
+@tab No
+@tab @samp{-}
+@tab No
+
@end multitable
These are the currently defined stub features, in more detail:
@@ -36304,6 +36376,13 @@ breakpoints.
The remote stub reports the @samp{hwbreak} stop reason for hardware
breakpoints.
+@item fork-events
+The remote stub reports the @samp{fork} stop reason for fork events.
+
+@item vfork-events
+The remote stub reports the @samp{vfork} stop reason for vfork events
+and vforkdone events.
+
@end table
@item qSymbol::
--
1.8.1.1
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 1/7] Identify remote fork event support
2015-04-10 17:10 ` [PATCH v7 1/7] Identify remote fork event support Don Breazeal
@ 2015-04-15 15:37 ` Pedro Alves
0 siblings, 0 replies; 18+ messages in thread
From: Pedro Alves @ 2015-04-15 15:37 UTC (permalink / raw)
To: Don Breazeal, gdb-patches
On 04/10/2015 06:09 PM, Don Breazeal wrote:
> @@ -6469,4 +6487,7 @@ initialize_low (void)
> sigaction (SIGCHLD, &sigchld_action, NULL);
>
> initialize_low_arch ();
> +
> + /* Enable extended ptrace events. */
> + linux_check_ptrace_features ();
I think the comment might have made sense possibly in a earlier revision
that added to additional ptrace options, but it looks a bit strange
now, as this isn't enabling the features yet, just checking what is
supported. A comment like
/* Check supported ptrace features. */
would just repeat the function's signature, so I'd suggest just
dropping the comment.
Otherwise OK.
Thanks,
Pedro Alves
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 3/7] Extended-remote Linux follow fork
2015-04-10 17:10 ` [PATCH v7 3/7] Extended-remote Linux follow fork Don Breazeal
@ 2015-04-15 15:38 ` Pedro Alves
0 siblings, 0 replies; 18+ messages in thread
From: Pedro Alves @ 2015-04-15 15:38 UTC (permalink / raw)
To: Don Breazeal, gdb-patches
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.
>
>>
>>> struct process_info *proc = find_process_pid (pid_of (thread));
>>>
>>> - linux_enable_event_reporting (lwpid, proc->attached);
>>> + linux_low_enable_events (lwpid, proc->attached);
>>> child->must_set_ptrace_flags = 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;
>>> +
>>> + /* Reset the ptrace options to enable on the inferior(s). */
>>> + linux_reset_ptrace_options ();
>>> +
>>> + /* Request that all the lwps reset their ptrace options. */
>>> + find_inferior (&all_threads, reset_lwp_ptrace_options_callback , &pid);
>>
>> Spurious space before ', &pid'. But, you can't do this if threads
>> are already running, such as when you reconnect after you left the
>> target running for disconnected tracing. Instead, you need to
>> force threads to momentarily pause and set their must_set_ptrace_flags
>> flag, much like when we need to change running thread's debug registers
>> for watchpoints. See linux-x86-low.c:update_debug_registers_callback.
>
> I've added the mechanism to stop the lwps as in that function. In a
> comment below I believe you were proposing that this mechanism could be
> unnecessary, and that resetting the ptrace flags for a new connection
> could be handled another way. I still think this mechanism is necessary.
> See the comment below after linux_enable_event_reporting for my rationale.
No, that must be a misunderstanding. The mechanism to reset the ptrace
flags for a new connection is indeed necessary (I was the one that brought
it up); what I thought was unnecessary was the additional_flags juggling
in the previous iteration.
>> That'd cope with a different gdb reconnecting and requesting
>> different options too.
>
> This is definitely more concise, thanks.
>
> One outcome of my changes here is the elimination of the "additional_flags"
> mechanism.
Right.
> This had a side-effect in the linux-ptrace functions like
> linux_test_for_tracefork, removing the checks that allowed the functions to
> bail out if additional_flags did not include the flags being tested. I
> don't think that this is a problem, since the events will not be enabled
> unless they are supported and requested.
That's not really a problem. We want gdbserver to support all those
features anyway.
>
> As I noted above, I think we still need handle_new_gdb_connection to ensure
> that the ptrace options are set properly when GDB reconnects.
>
> Rationale: suppose we have the following sequence of events:
> 1) GDB that supports fork event connects, and gdbserver sets
> PTRACE_O_TRACEFORK
> 2) inferior stops at a breakpoint
> 3) GDB disconnects, inferior remains stopped
> 4) GDB that does not support fork events connects. ptrace options are
> unchanged without handle_new_gdb_connection.
> 5) inferior is resumed and executes a fork. A fork event is
> generated and sent to GDB, who doesn't recognize it because we
> did not reset the options when the new GDB connected.
Right.
>>
>>> +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?
> @@ -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".
> +/* 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);
}
>
> +static int
> +linux_nat_ptrace_options (int attached)
Missing intro comment.
> +{
> + 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;
> +}
> +
> --- 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/
> + 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.
> + 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. */
>
> 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);
> }
> +
> +/* 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. If IS_FORK_CHILD is true, then inferior_ptid is the child
> + of an unfollowed fork, and we need to avoid deleting breakpoints
> + still needed by the parent. */
>
> 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":
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.
> {
> 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?
> + if (!is_fork_child && !is_fork_parent)
> + target_mourn_inferior ();
> + else
> + {
> + inferior_ptid = null_ptid;
> + detach_inferior (pid);
> + }
> }
>
Thanks,
Pedro Alves
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 5/7] Remote follow vfork
2015-04-10 17:11 ` [PATCH v7 5/7] Remote follow vfork Don Breazeal
@ 2015-04-15 15:38 ` Pedro Alves
2015-04-15 15:41 ` Pedro Alves
0 siblings, 1 reply; 18+ messages in thread
From: Pedro Alves @ 2015-04-15 15:38 UTC (permalink / raw)
To: Don Breazeal, gdb-patches
On 04/10/2015 06:09 PM, Don Breazeal wrote:
> Hi Pedro,
>
> This version of the patch incorporates changes based on your comments on
> the previous version, as outlined below.
>
> On 3/24/2015 5:28 AM, Pedro Alves wrote:
>> On 03/17/2015 08:56 PM, Don Breazeal wrote:
>>
>>> diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
>>> index dc43e38..42c3ec5 100644
>>> --- a/gdb/gdbserver/remote-utils.c
>>> +++ b/gdb/gdbserver/remote-utils.c
>>> @@ -1115,15 +1115,19 @@ prepare_resume_reply (char *buf, ptid_t ptid,
>>> {
>>> case TARGET_WAITKIND_STOPPED:
>>> case TARGET_WAITKIND_FORKED:
>>> + case TARGET_WAITKIND_VFORKED:
>>> {
>>> struct thread_info *saved_thread;
>>> const char **regp;
>>> struct regcache *regcache;
>>>
>>> - if (status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
>>> + if ((status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
>>> + || (status->kind == TARGET_WAITKIND_VFORKED
>>> + && report_vfork_events))
>>> {
>>> enum gdb_signal signal = GDB_SIGNAL_TRAP;
>>> - const char *event = "xfork";
>>> + const char *event = (status->kind == TARGET_WAITKIND_FORKED
>>> + ? "xfork" : "vfork");
>>>
>>> sprintf (buf, "T%02x%s:", signal, event);
>>> buf += strlen (buf);
>>> @@ -1245,6 +1249,15 @@ prepare_resume_reply (char *buf, ptid_t ptid,
>>> else
>>> sprintf (buf, "X%02x", status->value.sig);
>>> break;
>>> + case TARGET_WAITKIND_VFORK_DONE:
>>> + if (multi_process)
>>> + {
>>> + enum gdb_signal signal = GDB_SIGNAL_TRAP;
>>> + const char *event = "vforkdone";
>>> +
>>
>> Should only include vforkdone if report_vfork_events is true, I'd think.
>
> If we get one of these events (fork, vfork, vforkdone) and report_xxx_events
> is not set, then it is a bug, so I put those flags into asserts for all
> three events to ensure proper behavior.
I don't think that's a good idea. For instance, what if
a thread/lwp has already stopped for VFORK_DONE but the event is left
pending to report to the gdb. Meanwhile, gdb disconnects before the
event is sent. Now a new gdb reconnects, without support for vfork-done.
See server.c:handle_status, both non-stop and all-stop. That would
trigger that assertion.
> + if (status->kind == TARGET_WAITKIND_FORKED)
> + {
> + gdb_assert (report_fork_events);
> + sprintf (buf, "T%02xfork:", signal);
> + }
> + else
> + {
> + gdb_assert (report_vfork_events);
> + sprintf (buf, "T%02xvfork:", signal);
Eh, I had asked to _remove_ the 'x's, not add them. Could you
please drop them?
Thanks,
Pedro Alves
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 6/7] Remote fork catch
2015-04-10 17:11 ` [PATCH v7 6/7] Remote fork catch Don Breazeal
@ 2015-04-15 15:39 ` Pedro Alves
0 siblings, 0 replies; 18+ messages in thread
From: Pedro Alves @ 2015-04-15 15:39 UTC (permalink / raw)
To: Don Breazeal, gdb-patches
On 04/10/2015 06:09 PM, Don Breazeal wrote:
> Hi Pedro,
> This version of the patch incorporates changes based on your comments on
> the previous version, as outlined below.
>
> On 3/24/2015 5:47 AM, Pedro Alves wrote:
>> On 03/17/2015 08:56 PM, Don Breazeal wrote:
>>
>>> diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
>>> index 8fa6f8a..346f2c4 100644
>>> --- a/gdb/gdbserver/server.c
>>> +++ b/gdb/gdbserver/server.c
>>> @@ -1356,6 +1356,15 @@ handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg)
>>> int core = target_core_of_thread (ptid);
>>> char core_s[21];
>>>
>>> + /* Skip new threads created as the result of a fork if we are not done
>>> + handling that fork event. We won't know whether to tell GDB about
>>> + the new thread until we are done following the fork. */
>>> + if ((last_status.kind == TARGET_WAITKIND_FORKED
>>> + || last_status.kind == TARGET_WAITKIND_VFORKED)
>>> + && (ptid_get_pid (last_status.value.related_pid)
>>> + == ptid_get_pid (ptid)))
>>> + return;
>>
>> This use of last_status here is really just as bad as
>> get_last_target_status, for the same reasons. What if a thread
>> forks at the same time another thread hits a breakpoint, and
>> we end up reporting the breakpoint first, leaving the fork
>> pending? Sounds like we'll end up listing the child fork
>> thread then.
>
> I moved this operation (removing the new, unreported thread from the list
> reported by the target) to the host side in remote.c:remove_new_fork_child,
> called from remote.c:remote_update_thread_list.
Agreed, I think that's the right thing to do. This gives us the
most flexibility to change the follow-fork model in core gdb.
Also, if you disconnect while stopped at an unfollowed fork, and then
reconnect, it's not clear to me whether the child should be
hidden from the user until the next continue then. Again, leaving it
up to the client gives us the flexibility either way.
>>> diff --git a/gdb/testsuite/gdb.threads/fork-thread-pending.exp b/gdb/testsuite/gdb.threads/fork-thread-pending.exp
>>> index d229232..594f376 100644
>>> --- a/gdb/testsuite/gdb.threads/fork-thread-pending.exp
>>> +++ b/gdb/testsuite/gdb.threads/fork-thread-pending.exp
>>> @@ -31,6 +31,26 @@ if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executab
>>> return -1
>>> }
>>>
>>> +# Find a thread that did not fork and is not the main thread and
>>> +# return its thread number. We can't just hard-code the thread
>>> +# number since we have no guarantee as to the ordering of the threads
>>> +# in gdb.
>>
>> I don't understand this -- the test runs to main first, so the main
>> thread should always be thread 1, no?
>>
>
> I can no longer reproduce the thread ordering problem that I was seeing
> when I implemented this. Not sure why...my notes imply it might have
> something to do with 'target remote', but I'm unsure at this point.
Maybe it was necessary before:
https://sourceware.org/ml/gdb-patches/2014-09/msg00734.html
> At any rate this test doesn't need to be changed for this patch, so
> I've removed it from the patch.
>
> BTW, I still intend to submit a patch that removes the need to use
> get_last_target_status in linux-nat.c:linux_nat_kill, along with a test
> for that scenario.
That'd be great!
> +/* Determine if THREAD is a pending fork parent thread. ARG contains
> + the pid of the process who's threads we want to check, or -1 if
> + we want to check all threads. */
> +
> +static int
> +pending_fork_parent_callback (struct thread_info *thread, void *arg)
> +{
> + int pid = *(int *) arg;
> +
> + if (thread->pending_follow.kind == TARGET_WAITKIND_FORKED
> + || thread->pending_follow.kind == TARGET_WAITKIND_VFORKED)
> + {
> + if ((pid == -1) || (pid == ptid_get_pid (thread->ptid)))
Unnecessary parens:
if (pid == -1 || pid == ptid_get_pid (thread->ptid))
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +/* If CONTEXT contains any fork child threads that have not been
> + reported yet, remove them from the CONTEXT list. If such a
> + thread exists it is because we are stopped at a fork catchpoint
> + and have not yet called follow_fork, which will set up the
> + host-side data structures for the new process. */
> +
> +static void
> +remove_new_fork_child (struct threads_listing_context *context)
> +{
> + struct thread_info * thread;
> + int pid = -1;
> +
> + /* Check to see if there is an in-progress fork parent. */
> + thread = iterate_over_threads (pending_fork_parent_callback, &pid);
> + if (thread != NULL)
In non-stop mode, if you're debugging multiple process, multiple
processes can fork at the same, and then we end up with multiple
threads with an in-progress fork parent. So this needs to walk
the whole thread list, not just stop at the first. Either
use ALL_NON_EXITED_THREADS, or move the loop below to
pending_fork_parent_callback (or to a helper function called
by that).
> + {
> + ptid_t child_ptid = thread->pending_follow.value.related_pid;
> + struct thread_item *item;
> + int i;
> +
> + for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
> + {
> + if (ptid_equal (item->ptid, child_ptid))
> + {
> + VEC_ordered_remove (thread_item_t, context->items, i);
> + break;
> + }
> + }
> + }
> +}
> +
> /* Implement the to_update_thread_list function for the remote
> targets. */
>
> @@ -2874,6 +2964,10 @@ remote_update_thread_list (struct target_ops *ops)
> }
> }
>
> + /* Remove any unreported fork child from CONTEXT so that
> + we don't interfere with follow fork. */
> + remove_new_fork_child (&context);
I think there's a race here, in non-stop mode. Consider:
#1 - process forks just before gdb starts fetching the remote thread
list.
#2 - gdbserver adds the fork child its thread list.
#3 - gdbserver queues the fork event, sends vStopped notification
#4 - gdb/remote_update_thread_list pulls the thread list
#5 - we're now in remove_new_fork_child, but we don't know
about the fork event yet. It's still pending in the vStopped
queue.
So I think that we need to make remote_update_thread_list do,
in this order:
#1 - fetch the remote thread list
#2 - fetch the pending vStopped notifications
(remote_notif_get_pending_events)
#3 - call remove_new_fork_child
#4 - add threads we don't know about yet to our list.
and make remove_new_fork_child also peek at the
pending vStopped events queue (and in the future at
any other layers of pending events in the core side.)
> + child_pid = ptid_get_pid (thread->pending_follow.value.related_pid);
> + res = remote_vkill (child_pid, rs);
> + if (res != 0)
> + error (_("Can't kill fork child process"));
It'll probably be good to include the PID in the error message.
> + }
Thanks,
Pedro Alves
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 5/7] Remote follow vfork
2015-04-15 15:38 ` Pedro Alves
@ 2015-04-15 15:41 ` Pedro Alves
0 siblings, 0 replies; 18+ messages in thread
From: Pedro Alves @ 2015-04-15 15:41 UTC (permalink / raw)
To: Don Breazeal, gdb-patches
On 04/15/2015 04:38 PM, Pedro Alves wrote:
>> > + sprintf (buf, "T%02xvfork:", signal);
> Eh, I had asked to _remove_ the 'x's, not add them. Could you
> please drop them?
LOL, paperbag moment. I should get new glasses... Please ignore.
Thanks,
Pedro Alves
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v7 7/7] Extended-remote follow fork documentation
2015-04-10 20:43 ` Don Breazeal
@ 2015-04-15 15:47 ` Pedro Alves
0 siblings, 0 replies; 18+ messages in thread
From: Pedro Alves @ 2015-04-15 15:47 UTC (permalink / raw)
To: Don Breazeal, gdb-patches, eliz
On 04/10/2015 09:43 PM, Don Breazeal wrote:
> @tab @code{hbreak}
>
> +@item @code{fork-event-feature}
> +@tab @code{fork stop reason}
> +@tab @code{fork}
> +
> +@item @code{vfork-event-feature}
> +@tab @code{vfork stop reason}
> +@tab @code{vfork}
> +
> @end multitable
>
> @node Remote Stub
> @@ -35286,6 +35297,45 @@ The @var{r} part must be left empty.
>
> The same remarks about @samp{qSupported} and non-stop mode above
> apply.
> +
> +@cindex fork events, remote reply
> +@item fork
> +The packet indicates that @code{fork} was called, and @var{r}
> +is the ptid of the new child process. This packet is only
I don't think we document what a ptid is --- that's an internal
gdb implementation detail. This should probably say that it's the
thread id of the new child process, and cross reference
to "thread-id syntax".
> +applicable to targets that support fork events.
Thanks,
Pedro Alves
^ permalink raw reply [flat|nested] 18+ messages in thread
end of thread, other threads:[~2015-04-15 15:47 UTC | newest]
Thread overview: 18+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-04-10 17:09 [PATCH v7 0/7] Remote fork events Don Breazeal
2015-04-10 17:10 ` [PATCH v7 2/7] Clone remote breakpoints Don Breazeal
2015-04-10 17:10 ` [PATCH v7 4/7] Arch-specific remote follow fork Don Breazeal
2015-04-10 17:10 ` [PATCH v7 1/7] Identify remote fork event support Don Breazeal
2015-04-15 15:37 ` Pedro Alves
2015-04-10 17:10 ` [PATCH v7 3/7] Extended-remote Linux follow fork Don Breazeal
2015-04-15 15:38 ` Pedro Alves
2015-04-10 17:11 ` [PATCH v7 5/7] Remote follow vfork Don Breazeal
2015-04-15 15:38 ` Pedro Alves
2015-04-15 15:41 ` Pedro Alves
2015-04-10 17:11 ` [PATCH v7 7/7] Extended-remote follow fork documentation Don Breazeal
2015-04-10 17:56 ` Eli Zaretskii
2015-04-10 18:15 ` Breazeal, Don
2015-04-10 18:29 ` Eli Zaretskii
2015-04-10 20:43 ` Don Breazeal
2015-04-15 15:47 ` Pedro Alves
2015-04-10 17:11 ` [PATCH v7 6/7] Remote fork catch Don Breazeal
2015-04-15 15:39 ` Pedro Alves
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).