From patchwork Wed Feb 12 15:40:03 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Omair Javaid X-Patchwork-Id: 24549 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-ve0-f199.google.com (mail-ve0-f199.google.com [209.85.128.199]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 43BAF203F3 for ; Wed, 12 Feb 2014 15:40:25 +0000 (UTC) Received: by mail-ve0-f199.google.com with SMTP id oy12sf21921515veb.10 for ; Wed, 12 Feb 2014 07:40:24 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:mailing-list:precedence:list-id :list-unsubscribe:list-subscribe:list-archive:list-post:list-help :sender:delivered-to:message-id:date:from:user-agent:mime-version:to :cc:subject:references:in-reply-to:x-original-sender :x-original-authentication-results:content-type :content-transfer-encoding; bh=zu5mCa6PHCrh4VIVWczETk3NmqZ2esCtjyPXS1UuCcM=; b=e2ySOM+8a8mUxpNTJnfZRmYyT3gjDOlHM/Lr8+2X9FoOdcHbg0qLvQ6O0hNEOG0aXp 3R2abiNQhji5hsxhbI1E5xRzMMr2Mce7D5kUY6jlMVA3OHRW/+PER3cLQJ+/P8ZquTar YdrJJBca2wp+bVuaaphG1lqUkeH7E7sfXNIZflyhtr4K4se5SRYP6GZ/BnIK/kCNpbIi bqbgDV50XgBPGNECfiqTbg3xkBf0wQI9DDQBcWNIa1j4tfTWDzQOwgcEw4zThfgtCE2P yA+WcszwAI8DovT99HFsCrOvl/jTLIDWMAyf9Qpkf/QZ9GoAdckgiEtlzH0YbzSKhXMi v2MQ== X-Gm-Message-State: ALoCoQkHG6BWVOreqAT7y5XGLOHz0RGj2WI3a82ftiI30dmJwEXpqwF3rD+45JeYRkCS3FkTHffb X-Received: by 10.236.133.82 with SMTP id p58mr1510761yhi.37.1392219624351; Wed, 12 Feb 2014 07:40:24 -0800 (PST) X-BeenThere: patchwork-forward@linaro.org Received: by 10.140.85.35 with SMTP id m32ls2885284qgd.81.gmail; Wed, 12 Feb 2014 07:40:24 -0800 (PST) X-Received: by 10.58.106.37 with SMTP id gr5mr94393veb.57.1392219624183; Wed, 12 Feb 2014 07:40:24 -0800 (PST) Received: from mail-ve0-x230.google.com (mail-ve0-x230.google.com [2607:f8b0:400c:c01::230]) by mx.google.com with ESMTPS id yj2si7441388veb.123.2014.02.12.07.40.24 for (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Wed, 12 Feb 2014 07:40:24 -0800 (PST) Received-SPF: neutral (google.com: 2607:f8b0:400c:c01::230 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) client-ip=2607:f8b0:400c:c01::230; Received: by mail-ve0-f176.google.com with SMTP id jx11so243715veb.7 for ; Wed, 12 Feb 2014 07:40:24 -0800 (PST) X-Received: by 10.58.37.67 with SMTP id w3mr11068855vej.22.1392219623794; Wed, 12 Feb 2014 07:40:23 -0800 (PST) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.220.174.196 with SMTP id u4csp9314vcz; Wed, 12 Feb 2014 07:40:23 -0800 (PST) X-Received: by 10.68.35.129 with SMTP id h1mr17910403pbj.163.1392219622382; Wed, 12 Feb 2014 07:40:22 -0800 (PST) Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id ez5si23069997pab.135.2014.02.12.07.40.21 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 12 Feb 2014 07:40:22 -0800 (PST) Received-SPF: pass (google.com: domain of gdb-patches-return-110315-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Received: (qmail 29300 invoked by alias); 12 Feb 2014 15:40:15 -0000 Mailing-List: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org Precedence: list List-Id: List-Unsubscribe: , List-Subscribe: List-Archive: List-Post: , List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 29291 invoked by uid 89); 12 Feb 2014 15:40:14 -0000 X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.4 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-ea0-f177.google.com Received: from mail-ea0-f177.google.com (HELO mail-ea0-f177.google.com) (209.85.215.177) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Wed, 12 Feb 2014 15:40:12 +0000 Received: by mail-ea0-f177.google.com with SMTP id m10so1881635eaj.22 for ; Wed, 12 Feb 2014 07:40:08 -0800 (PST) X-Received: by 10.14.205.3 with SMTP id i3mr4653822eeo.23.1392219608644; Wed, 12 Feb 2014 07:40:08 -0800 (PST) Received: from [192.168.1.2] ([182.185.165.140]) by mx.google.com with ESMTPSA id g1sm82117704eet.6.2014.02.12.07.40.05 for (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Wed, 12 Feb 2014 07:40:07 -0800 (PST) Message-ID: <52FB95D3.5000207@linaro.org> Date: Wed, 12 Feb 2014 20:40:03 +0500 From: Omair Javaid User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Thunderbird/24.2.0 MIME-Version: 1.0 To: Yao Qi CC: gdb-patches@sourceware.org Subject: Re: [PATCH] Support for HWbreak/watchpoint accross fork/vfork on arm-native References: <1391119790-6580-1-git-send-email-omair.javaid@linaro.org> <52EAD0DC.506@linaro.org> <52F57EA2.20908@codesourcery.com> In-Reply-To: <52F57EA2.20908@codesourcery.com> X-IsSubscribed: yes X-Original-Sender: omair.javaid@linaro.org X-Original-Authentication-Results: mx.google.com; spf=neutral (google.com: 2607:f8b0:400c:c01::230 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org; dkim=pass header.i=@sourceware.org X-Google-Group-Id: 836684582541 On Sat 08 Feb 2014 05:47:30 AM PKT, Yao Qi wrote: > On 01/31/2014 06:23 AM, Omair Javaid wrote: >> This patch updates arm native support for hardware breakpoints and watchpoints >> to accommodate watchpoint/breakpoints across fork/vfork. Previously for arm >> native a record of breakpoints at thread level was being kept which has been >> changed to a process level record to come in sync with gdb-linux calls to >> threads and process creation/destruction hooks. > > Is it possible to write a test case which fails before the patch applies > but passes after? > This is an update on the previous patch after incorporating suggestions. This patch updates arm native support for hwbreak-/watchpoints to enable support for hwbreak-/watchpoints across fork/vfork. This involves changes to hwbreak-/watchpoint insertion mechanism to the modern way, by marking debug registers as needing update, but only really updating them on resume, which is necessary for supporting watchpoints in non-stop mode. This also updates a previously maintained per thread hwbreak-/watchpoint cache to a per process cache which allows target specific code to come in sync with gdb-linux calls to threads create/destroy and process fork/exit hooks. This patch makes good improvement in arm-linux-gdb testsuite results. Fixes 24 failures in watchpoint-fork.exp like the one copied below: FAIL: gdb.threads/watchpoint-fork.exp: parent: singlethreaded: breakpoint after the first fork (GDB internal error) Also fixes a few other watchpoint related failures in gdb.base and gdb.threads testsuite. gdb: 2014-02-11 Omair Javaid * arm-linux-nat.c (struct arm_linux_thread_points): Removed. (MAX_BPTS): Define. (MAX_WPTS): Define. (struct arm_linux_process_info): New. (DEF_VEC_P (arm_linux_thread_points_p)): Removed. (VEC(arm_linux_thread_points_p) *arm_threads): Removed. (arm_linux_find_breakpoints_by_tid): Removed. (struct arch_lwp_info): New. (arm_linux_find_process_pid): New functions. (arm_linux_add_process): New functions. (arm_linux_process_info_get): New functions. (arm_linux_forget_process): New function. (arm_linux_get_debug_reg_state): New function. (struct update_registers_data): New. (update_registers_callback): New function. (arm_linux_insert_hw_breakpoint1): Updated. (arm_linux_remove_hw_breakpoint1): Updated. (arm_linux_insert_hw_breakpoint): Updated. (arm_linux_remove_hw_breakpoint): Updated. (arm_linux_insert_watchpoint): Updated. (arm_linux_remove_watchpoint): Updated. (arm_linux_new_thread): Updated. (arm_linux_prepare_to_resume): New function. (arm_linux_new_fork): New function. (_initialize_arm_linux_nat): Updated. --- gdb/arm-linux-nat.c | 397 +++++++++++++++++++++++++++++++++++----------------- 1 file changed, 272 insertions(+), 125 deletions(-) diff --git a/gdb/arm-linux-nat.c b/gdb/arm-linux-nat.c index 6f56634..4047725 100644 --- a/gdb/arm-linux-nat.c +++ b/gdb/arm-linux-nat.c @@ -787,8 +787,13 @@ struct arm_linux_hw_breakpoint arm_hwbp_control_t control; }; -/* Structure containing arrays of the break and watch points which are have - active in each thread. +/* Since we cannot dynamically allocate subfields of arm_linux_process_info, + assume a maximum number of supported break-/watchpoints. */ +#define MAX_BPTS 16 +#define MAX_WPTS 16 + +/* Structure containing arrays of per process hardware break-/watchpoints + for caching address and control information. The Linux ptrace interface to hardware break-/watch-points presents the values in a vector centred around 0 (which is used fo generic information). @@ -808,49 +813,114 @@ struct arm_linux_hw_breakpoint We treat break-/watch-points with their enable bit clear as being deleted. */ -typedef struct arm_linux_thread_points +struct arm_linux_debug_reg_state { - /* Thread ID. */ - int tid; - /* Breakpoints for thread. */ - struct arm_linux_hw_breakpoint *bpts; - /* Watchpoint for threads. */ - struct arm_linux_hw_breakpoint *wpts; -} *arm_linux_thread_points_p; -DEF_VEC_P (arm_linux_thread_points_p); - -/* Vector of hardware breakpoints for each thread. */ -VEC(arm_linux_thread_points_p) *arm_threads = NULL; - -/* Find the list of hardware break-/watch-points for a thread with id TID. - If no list exists for TID we return NULL if ALLOC_NEW is 0, otherwise we - create a new list and return that. */ -static struct arm_linux_thread_points * -arm_linux_find_breakpoints_by_tid (int tid, int alloc_new) + /* Hardware breakpoints for this process. */ + struct arm_linux_hw_breakpoint bpts[MAX_BPTS]; + /* Hardware watchpoints for this process. */ + struct arm_linux_hw_breakpoint wpts[MAX_WPTS]; +}; + +/* Per-process arch-specific data we want to keep. */ +struct arm_linux_process_info { - int i; - struct arm_linux_thread_points *t; + /* Linked list. */ + struct arm_linux_process_info *next; + /* The process identifier. */ + pid_t pid; + /* Hardware break-/watchpoints state information. */ + struct arm_linux_debug_reg_state state; - for (i = 0; VEC_iterate (arm_linux_thread_points_p, arm_threads, i, t); ++i) - { - if (t->tid == tid) - return t; - } +}; + +/* Per-thread arch-specific data we want to keep. */ +struct arch_lwp_info +{ + /* Non-zero if our copy differs from what's recorded in the thread. */ + char bpts_changed[MAX_BPTS]; + char wpts_changed[MAX_WPTS]; +}; + +static struct arm_linux_process_info *arm_linux_process_list = NULL; + +/* Find process data for process PID. */ + +static struct arm_linux_process_info * +arm_linux_find_process_pid (pid_t pid) +{ + struct arm_linux_process_info *proc; + + for (proc = arm_linux_process_list; proc; proc = proc->next) + if (proc->pid == pid) + return proc; + + return NULL; +} + +/* Add process data for process PID. Returns newly allocated info + object. */ + +static struct arm_linux_process_info * +arm_linux_add_process (pid_t pid) +{ + struct arm_linux_process_info *proc; - t = NULL; + proc = xcalloc (1, sizeof (*proc)); + proc->pid = pid; - if (alloc_new) + proc->next = arm_linux_process_list; + arm_linux_process_list = proc; + + return proc; +} + +/* Get data specific info for process PID, creating it if necessary. + Never returns NULL. */ + +static struct arm_linux_process_info * +arm_linux_process_info_get (pid_t pid) +{ + struct arm_linux_process_info *proc; + + proc = arm_linux_find_process_pid (pid); + if (proc == NULL) + proc = arm_linux_add_process (pid); + + return proc; +} + +/* Called whenever GDB is no longer debugging process PID. It deletes + data structures that keep track of debug register state. */ + +static void +arm_linux_forget_process (pid_t pid) +{ + struct arm_linux_process_info *proc, **proc_link; + + proc = arm_linux_process_list; + proc_link = &arm_linux_process_list; + + while (proc != NULL) { - t = xmalloc (sizeof (struct arm_linux_thread_points)); - t->tid = tid; - t->bpts = xzalloc (arm_linux_get_hw_breakpoint_count () - * sizeof (struct arm_linux_hw_breakpoint)); - t->wpts = xzalloc (arm_linux_get_hw_watchpoint_count () - * sizeof (struct arm_linux_hw_breakpoint)); - VEC_safe_push (arm_linux_thread_points_p, arm_threads, t); + if (proc->pid == pid) + { + *proc_link = proc->next; + + xfree (proc); + return; } - return t; + proc_link = &proc->next; + proc = *proc_link; + } +} + +/* Get hardware break-/watchpoint state for process PID. */ + +static struct arm_linux_debug_reg_state * +arm_linux_get_debug_reg_state (pid_t pid) +{ + return &arm_linux_process_info_get (pid)->state; } /* Initialize an ARM hardware break-/watch-point control register value. @@ -950,45 +1020,82 @@ arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint *p1, return p1->address == p2->address && p1->control == p2->control; } +/* Callback to mark a watch-/breakpoint to be updated in all threads of + the current process. */ + +struct update_registers_data +{ + int watch; + int index; +}; + +static int +update_registers_callback (struct lwp_info *lwp, void *arg) +{ + struct update_registers_data *data = (struct update_registers_data *) arg; + + /* Force iterate_over_lwps to return matched lwp_info*. */ + if (arg == NULL) + return 1; + + if (lwp->arch_private == NULL) + lwp->arch_private = XCNEW (struct arch_lwp_info); + + /* The actual update is done later just before resuming the lwp, + we just mark that the registers need updating. */ + if (data->watch) + lwp->arch_private->wpts_changed[data->index] = 1; + else + lwp->arch_private->bpts_changed[data->index] = 1; + + /* If the lwp isn't stopped, force it to momentarily pause, so + we can update its breakpoint registers. */ + if (!lwp->stopped) + linux_stop_lwp (lwp); + + return 0; +} + /* Insert the hardware breakpoint (WATCHPOINT = 0) or watchpoint (WATCHPOINT =1) BPT for thread TID. */ static void arm_linux_insert_hw_breakpoint1 (const struct arm_linux_hw_breakpoint* bpt, - int tid, int watchpoint) + int watchpoint) { - struct arm_linux_thread_points *t = arm_linux_find_breakpoints_by_tid (tid, 1); + int pid; + ptid_t pid_ptid; gdb_byte count, i; struct arm_linux_hw_breakpoint* bpts; - int dir; + struct update_registers_data data; - gdb_assert (t != NULL); + pid = ptid_get_pid (inferior_ptid); + pid_ptid = pid_to_ptid (pid); if (watchpoint) { count = arm_linux_get_hw_watchpoint_count (); - bpts = t->wpts; - dir = -1; + bpts = arm_linux_get_debug_reg_state (pid)->wpts; + if (count > MAX_WPTS) + warning (_("arm-linux-gdb supports %d hardware watchpoints but target \ + supports %d"), MAX_WPTS, count); } else { count = arm_linux_get_hw_breakpoint_count (); - bpts = t->bpts; - dir = 1; + bpts = arm_linux_get_debug_reg_state (pid)->bpts; + if (count > MAX_BPTS) + warning (_("arm-linux-gdb supports %d hardware breakpoints but target \ + supports %d"), MAX_BPTS, count); } for (i = 0; i < count; ++i) if (!arm_hwbp_control_is_enabled (bpts[i].control)) { - errno = 0; - if (ptrace (PTRACE_SETHBPREGS, tid, dir * ((i << 1) + 1), - &bpt->address) < 0) - perror_with_name (_("Unexpected error setting breakpoint address")); - if (ptrace (PTRACE_SETHBPREGS, tid, dir * ((i << 1) + 2), - &bpt->control) < 0) - perror_with_name (_("Unexpected error setting breakpoint")); - - memcpy (bpts + i, bpt, sizeof (struct arm_linux_hw_breakpoint)); - break; + data.watch = watchpoint; + data.index = i; + bpts[i] = *bpt; + iterate_over_lwps (pid_ptid, update_registers_callback, &data); + break; } gdb_assert (i != count); @@ -998,37 +1105,36 @@ arm_linux_insert_hw_breakpoint1 (const struct arm_linux_hw_breakpoint* bpt, (WATCHPOINT = 1) BPT for thread TID. */ static void arm_linux_remove_hw_breakpoint1 (const struct arm_linux_hw_breakpoint *bpt, - int tid, int watchpoint) + int watchpoint) { - struct arm_linux_thread_points *t = arm_linux_find_breakpoints_by_tid (tid, 0); + int pid; gdb_byte count, i; - struct arm_linux_hw_breakpoint *bpts; - int dir; + ptid_t pid_ptid; + struct arm_linux_hw_breakpoint* bpts; + struct update_registers_data data; - gdb_assert (t != NULL); + pid = ptid_get_pid (inferior_ptid); + pid_ptid = pid_to_ptid (pid); if (watchpoint) { count = arm_linux_get_hw_watchpoint_count (); - bpts = t->wpts; - dir = -1; + bpts = arm_linux_get_debug_reg_state (pid)->wpts; } else { count = arm_linux_get_hw_breakpoint_count (); - bpts = t->bpts; - dir = 1; + bpts = arm_linux_get_debug_reg_state (pid)->bpts; } for (i = 0; i < count; ++i) if (arm_linux_hw_breakpoint_equal (bpt, bpts + i)) { - errno = 0; - bpts[i].control = arm_hwbp_control_disable (bpts[i].control); - if (ptrace (PTRACE_SETHBPREGS, tid, dir * ((i << 1) + 2), - &bpts[i].control) < 0) - perror_with_name (_("Unexpected error clearing breakpoint")); - break; + data.watch = watchpoint; + data.index = i; + bpts[i].control = arm_hwbp_control_disable (bpts[i].control); + iterate_over_lwps (pid_ptid, update_registers_callback, &data); + break; } gdb_assert (i != count); @@ -1046,8 +1152,8 @@ arm_linux_insert_hw_breakpoint (struct gdbarch *gdbarch, return -1; arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p); - ALL_LWPS (lp) - arm_linux_insert_hw_breakpoint1 (&p, ptid_get_lwp (lp->ptid), 0); + + arm_linux_insert_hw_breakpoint1 (&p, 0); return 0; } @@ -1064,8 +1170,8 @@ arm_linux_remove_hw_breakpoint (struct gdbarch *gdbarch, return -1; arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p); - ALL_LWPS (lp) - arm_linux_remove_hw_breakpoint1 (&p, ptid_get_lwp (lp->ptid), 0); + + arm_linux_remove_hw_breakpoint1 (&p, 0); return 0; } @@ -1115,8 +1221,8 @@ arm_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, return -1; arm_linux_hw_watchpoint_initialize (addr, len, rw, &p); - ALL_LWPS (lp) - arm_linux_insert_hw_breakpoint1 (&p, ptid_get_lwp (lp->ptid), 1); + + arm_linux_insert_hw_breakpoint1 (&p, 1); return 0; } @@ -1133,8 +1239,8 @@ arm_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw, return -1; arm_linux_hw_watchpoint_initialize (addr, len, rw, &p); - ALL_LWPS (lp) - arm_linux_remove_hw_breakpoint1 (&p, ptid_get_lwp (lp->ptid), 1); + + arm_linux_remove_hw_breakpoint1 (&p, 1); return 0; } @@ -1190,63 +1296,100 @@ arm_linux_watchpoint_addr_within_range (struct target_ops *target, static void arm_linux_new_thread (struct lwp_info *lp) { - int tid = ptid_get_lwp (lp->ptid); - const struct arm_linux_hwbp_cap *info = arm_linux_get_hwbp_cap (); + int i; + struct arch_lwp_info *info = XCNEW (struct arch_lwp_info); + + /* Mark that all the hardware breakpoint/watchpoint register pairs + for this thread need to be initialized. */ - if (info != NULL) + for (i = 0; i < MAX_BPTS; i++) { - int i; - struct arm_linux_thread_points *p; - struct arm_linux_hw_breakpoint *bpts; - - if (VEC_empty (arm_linux_thread_points_p, arm_threads)) - return; - - /* Get a list of breakpoints from any thread. */ - p = VEC_last (arm_linux_thread_points_p, arm_threads); - - /* Copy that thread's breakpoints and watchpoints to the new thread. */ - for (i = 0; i < info->bp_count; i++) - if (arm_hwbp_control_is_enabled (p->bpts[i].control)) - arm_linux_insert_hw_breakpoint1 (p->bpts + i, tid, 0); - for (i = 0; i < info->wp_count; i++) - if (arm_hwbp_control_is_enabled (p->wpts[i].control)) - arm_linux_insert_hw_breakpoint1 (p->wpts + i, tid, 1); + info->bpts_changed[i] = 1; + info->wpts_changed[i] = 1; } + + lp->arch_private = info; } -/* Handle thread exit. Tidy up the memory that has been allocated for the - thread. */ +/* Called when resuming a thread. + The hardware debug registers are updated when there is any change. */ + static void -arm_linux_thread_exit (struct thread_info *tp, int silent) +arm_linux_prepare_to_resume (struct lwp_info *lwp) { - const struct arm_linux_hwbp_cap *info = arm_linux_get_hwbp_cap (); + int pid, i; + struct arm_linux_hw_breakpoint *bpts, *wpts; + struct arch_lwp_info *arm_lwp_info = lwp->arch_private; + + pid = ptid_get_lwp (lwp->ptid); + bpts = arm_linux_get_debug_reg_state (ptid_get_pid (lwp->ptid))->bpts; + wpts = arm_linux_get_debug_reg_state (ptid_get_pid (lwp->ptid))->wpts; + + /* NULL means this is the main thread still going through the shell, + or, no watchpoint has been set yet. In that case, there's + nothing to do. */ + if (arm_lwp_info == NULL) + return; - if (info != NULL) - { - int i; - int tid = ptid_get_lwp (tp->ptid); - struct arm_linux_thread_points *t = NULL, *p; + for (i = 0; i < arm_linux_get_hw_breakpoint_count (); i++) + if (arm_lwp_info->bpts_changed[i]) + { + errno = 0; + if (arm_hwbp_control_is_enabled (bpts[i].control)) + if (ptrace (PTRACE_SETHBPREGS, pid, + (PTRACE_TYPE_ARG3) ((i << 1) + 1), &bpts[i].address) < 0) + perror_with_name (_("Unexpected error setting breakpoint")); + + if (bpts[i].control != 0) + if (ptrace (PTRACE_SETHBPREGS, pid, + (PTRACE_TYPE_ARG3) ((i << 1) + 2), &bpts[i].control) < 0) + perror_with_name (_("Unexpected error setting breakpoint")); + + arm_lwp_info->bpts_changed[i] = 0; + } - for (i = 0; - VEC_iterate (arm_linux_thread_points_p, arm_threads, i, p); i++) - { - if (p->tid == tid) - { - t = p; - break; - } - } + for (i = 0; i < arm_linux_get_hw_watchpoint_count (); i++) + if (arm_lwp_info->wpts_changed[i]) + { + errno = 0; + if (arm_hwbp_control_is_enabled (wpts[i].control)) + if (ptrace (PTRACE_SETHBPREGS, pid, + (PTRACE_TYPE_ARG3) -((i << 1) + 1), &wpts[i].address) < 0) + perror_with_name (_("Unexpected error setting watchpoint")); + + if (wpts[i].control != 0) + if (ptrace (PTRACE_SETHBPREGS, pid, + (PTRACE_TYPE_ARG3) -((i << 1) + 2), &wpts[i].control) < 0) + perror_with_name (_("Unexpected error setting watchpoint")); + + arm_lwp_info->wpts_changed[i] = 0; + } +} + +/* linux_nat_new_fork hook. */ + +static void +arm_linux_new_fork (struct lwp_info *parent, pid_t child_pid) +{ + pid_t parent_pid; + struct arm_linux_debug_reg_state *parent_state; + struct arm_linux_debug_reg_state *child_state; - if (t == NULL) - return; + /* NULL means no watchpoint has ever been set in the parent. In + that case, there's nothing to do. */ + if (parent->arch_private == NULL) + return; - VEC_unordered_remove (arm_linux_thread_points_p, arm_threads, i); + /* 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. */ - xfree (t->bpts); - xfree (t->wpts); - xfree (t); - } + parent_pid = ptid_get_pid (parent->ptid); + parent_state = arm_linux_get_debug_reg_state (parent_pid); + child_state = arm_linux_get_debug_reg_state (child_pid); + *child_state = *parent_state; } void _initialize_arm_linux_nat (void); @@ -1279,7 +1422,11 @@ _initialize_arm_linux_nat (void) /* Register the target. */ linux_nat_add_target (t); - /* Handle thread creation and exit */ - observer_attach_thread_exit (arm_linux_thread_exit); + /* Handle thread creation and exit. */ linux_nat_set_new_thread (t, arm_linux_new_thread); + linux_nat_set_prepare_to_resume (t, arm_linux_prepare_to_resume); + + /* Handle process creation and exit. */ + linux_nat_set_new_fork (t, arm_linux_new_fork); + linux_nat_set_forget_process (t, arm_linux_forget_process); }