From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 24747 invoked by alias); 7 Aug 2014 18:00:43 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 24687 invoked by uid 89); 7 Aug 2014 18:00:42 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.7 required=5.0 tests=AWL,BAYES_00 autolearn=ham version=3.3.2 X-HELO: relay1.mentorg.com Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 07 Aug 2014 18:00:41 +0000 Received: from svr-orw-exc-10.mgc.mentorg.com ([147.34.98.58]) by relay1.mentorg.com with esmtp id 1XFRzR-0007cM-T0 from donb@codesourcery.com for gdb-patches@sourceware.org; Thu, 07 Aug 2014 11:00:37 -0700 Received: from SVR-ORW-FEM-02.mgc.mentorg.com ([147.34.96.206]) by SVR-ORW-EXC-10.mgc.mentorg.com with Microsoft SMTPSVC(6.0.3790.4675); Thu, 7 Aug 2014 11:00:37 -0700 Received: from build4-lucid-cs (147.34.91.1) by svr-orw-fem-02.mgc.mentorg.com (147.34.96.168) with Microsoft SMTP Server id 14.2.247.3; Thu, 7 Aug 2014 11:00:36 -0700 Received: by build4-lucid-cs (Postfix, from userid 1905) id D015540A74; Thu, 7 Aug 2014 11:00:36 -0700 (PDT) From: Don Breazeal To: Subject: [PATCH 05/10] GDBserver clone breakpoint list Date: Thu, 07 Aug 2014 18:00:00 -0000 Message-ID: <1407434395-19089-6-git-send-email-donb@codesourcery.com> In-Reply-To: <1407434395-19089-1-git-send-email-donb@codesourcery.com> References: <1407434395-19089-1-git-send-email-donb@codesourcery.com> MIME-Version: 1.0 Content-Type: text/plain X-IsSubscribed: yes X-SW-Source: 2014-08/txt/msg00150.txt.bz2 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 context of 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 the subsequent patch 6, the follow-fork patch. Thanks, --Don gdb/gdbserver/ 2014-08-06 Don Breazeal * 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 (clone_all_breakpoints): Declare. --- gdb/gdbserver/mem-break.c | 104 +++++++++++++++++++++++++++++++++++++++++++++ gdb/gdbserver/mem-break.h | 6 +++ 2 files changed, 110 insertions(+), 0 deletions(-) diff --git a/gdb/gdbserver/mem-break.c b/gdb/gdbserver/mem-break.c index 2ce3ab2..d433493 100644 --- a/gdb/gdbserver/mem-break.c +++ b/gdb/gdbserver/mem-break.c @@ -28,6 +28,22 @@ 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) \ + { \ + if (tailp == NULL) \ + *(listpp) = itemp; \ + else \ + tailp->next = itemp; \ + tailp = itemp; \ + } + /* 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 @@ -1878,3 +1894,91 @@ free_all_breakpoints (struct process_info *proc) while (proc->breakpoints) delete_breakpoint_1 (proc, proc->breakpoints); } + +/* Clone an agent expression. */ + +static void +clone_agent_expr (struct agent_expr **new_ax, 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); + *new_ax = ax; +} + +/* Deep-copy the contents of one breakpoint to another. */ + +static void +clone_one_breakpoint (struct breakpoint **new_bkpt, + struct raw_breakpoint **new_raw, 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)); + clone_agent_expr (&new_cond->cond, 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)); + clone_agent_expr (&new_cmd->cmd, current_cmd->cmd); + new_cmd->persistence = current_cmd->persistence; + APPEND_TO_LIST (&dest->command_list, new_cmd, cmd_tail); + } + *new_bkpt = dest; + *new_raw = dest_raw; +} + +/* Create a new breakpoint list NEW_LIST that is a copy of SRC. 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, + struct breakpoint *src) +{ + struct breakpoint *bp; + struct breakpoint *new_bkpt; + struct raw_breakpoint *new_raw_bkpt; + struct breakpoint *bkpt_tail = NULL; + struct raw_breakpoint *raw_bkpt_tail = NULL; + + for (bp = src; bp != NULL; bp = bp->next) + { + clone_one_breakpoint (&new_bkpt, &new_raw_bkpt, bp); + APPEND_TO_LIST (new_list, new_bkpt, bkpt_tail); + APPEND_TO_LIST (new_raw_list, new_raw_bkpt, raw_bkpt_tail); + } +} diff --git a/gdb/gdbserver/mem-break.h b/gdb/gdbserver/mem-break.h index c84c688..439792f 100644 --- a/gdb/gdbserver/mem-break.h +++ b/gdb/gdbserver/mem-break.h @@ -243,4 +243,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, + struct breakpoint *src); + #endif /* MEM_BREAK_H */ -- 1.7.0.4