From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23877 invoked by alias); 14 Aug 2012 13:01:02 -0000 Received: (qmail 23564 invoked by uid 22791); 14 Aug 2012 13:00:52 -0000 X-SWARE-Spam-Status: No, hits=-7.7 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_THREADED,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,TW_CP,TW_QX,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mga02.intel.com (HELO mga02.intel.com) (134.134.136.20) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 14 Aug 2012 13:00:16 +0000 Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga101.jf.intel.com with ESMTP; 14 Aug 2012 06:00:14 -0700 X-ExtLoop1: 1 Received: from swsutil001.isw.intel.com ([10.237.237.11]) by orsmga002.jf.intel.com with ESMTP; 14 Aug 2012 05:59:55 -0700 Received: from ulslx001.iul.intel.com (ulslx001.iul.intel.com [172.28.207.63]) by swsutil001.isw.intel.com (8.13.6/8.13.6/MailSET/Hub) with ESMTP id q7ECxsq6029073; Tue, 14 Aug 2012 13:59:54 +0100 Received: from ulslx001.iul.intel.com (localhost [127.0.0.1]) by ulslx001.iul.intel.com with ESMTP id q7ECxrQ5009961; Tue, 14 Aug 2012 14:59:53 +0200 Received: (from mmetzger@localhost) by ulslx001.iul.intel.com with id q7ECxr2G009957; Tue, 14 Aug 2012 14:59:53 +0200 From: markus.t.metzger@intel.com To: gdb-patches@sourceware.org Cc: markus.t.metzger@gmail.com, jan.kratochvil@redhat.com, palves@redhat.com, tromey@redhat.com, kettenis@gnu.org, Markus Metzger Subject: [patch v3 12/16] gdbserver, btrace: add generic btrace support Date: Tue, 14 Aug 2012 13:01:00 -0000 Message-Id: <1344949171-9545-13-git-send-email-markus.t.metzger@intel.com> In-Reply-To: <1344949171-9545-1-git-send-email-markus.t.metzger@intel.com> References: <1344949171-9545-1-git-send-email-markus.t.metzger@intel.com> X-IsSubscribed: yes 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 X-SW-Source: 2012-08/txt/msg00389.txt.bz2 From: Markus Metzger Add support to gdbserver to understand branch trace related packages. 2012-08-14 Markus Metzger gdbserver/ * target.h (struct target_ops): Add btrace ops. (target_supports_btrace): New macro. (target_btrace_has_changed): New macro. (target_enable_btrace): New macro. (target_disable_btrace): New macro. (target_read_btrace): New macro. * gdbthread.h (struct thread_info): Add btrace field. * server.c (handle_btrace_general_set): New function. (handle_btrace_enable): New function. (handle_btrace_disable): New function. (handle_general_set): Call handle_btrace_general_set. (handle_qxfer_btrace): New function. (struct qxfer qxfer_packets[]): Add btrace entry. (handle_btrace_query): New function. (handle_query): Add btrace to supported query, call handle_btrace_query. * inferiors.c (remove_thread): Disable btrace. --- gdb/gdbserver/gdbthread.h | 5 ++ gdb/gdbserver/inferiors.c | 3 + gdb/gdbserver/server.c | 167 +++++++++++++++++++++++++++++++++++++++++++++ gdb/gdbserver/target.h | 33 +++++++++ 4 files changed, 208 insertions(+), 0 deletions(-) diff --git a/gdb/gdbserver/gdbthread.h b/gdb/gdbserver/gdbthread.h index d863ec0..b2b6f62 100644 --- a/gdb/gdbserver/gdbthread.h +++ b/gdb/gdbserver/gdbthread.h @@ -22,6 +22,8 @@ #include "server.h" +struct btrace_target_info; + struct thread_info { struct inferior_list_entry entry; @@ -58,6 +60,9 @@ struct thread_info Each item in the list holds the current step of the while-stepping action. */ struct wstep_state *while_stepping; + + /* Branch trace target information for this thread. */ + struct btrace_target_info *btrace; }; extern struct inferior_list all_threads; diff --git a/gdb/gdbserver/inferiors.c b/gdb/gdbserver/inferiors.c index 76abaf5..76f5731 100644 --- a/gdb/gdbserver/inferiors.c +++ b/gdb/gdbserver/inferiors.c @@ -161,6 +161,9 @@ free_one_thread (struct inferior_list_entry *inf) void remove_thread (struct thread_info *thread) { + if (thread->btrace) + target_disable_btrace (thread->btrace); + remove_inferior (&all_threads, (struct inferior_list_entry *) thread); free_one_thread (&thread->entry); } diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 547552f..f51845f 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -444,6 +444,82 @@ write_qxfer_response (char *buf, const void *data, int len, int is_more) /* Handle all of the extended 'Q' packets. */ +/* Handle btrace enabling. */ +static int +handle_btrace_enable (char *ptid_str) +{ + ptid_t ptid = read_ptid (ptid_str, NULL); + struct thread_info *thread = find_thread_ptid (ptid); + int err = 1; + + if (!thread) + fprintf (stderr, "No such thread: %s.\n", ptid_str); + else if (thread->btrace) + fprintf (stderr, "Btrace already enabled for %s.\n", ptid_str); + else if (!the_target->enable_btrace) + fprintf (stderr, "Target does not support branch tracing."); + else + { + thread->btrace = target_enable_btrace (thread->entry.id); + if (!thread->btrace) + fprintf (stderr, "Could not enable btrace for %s.\n", ptid_str); + else + err = 0; + } + + return err; +} + +/* Handle btrace disabling. */ +static int +handle_btrace_disable (char *ptid_str) +{ + ptid_t ptid = read_ptid (ptid_str, NULL); + struct thread_info *thread = find_thread_ptid (ptid); + int err = 1; + + if (!thread) + fprintf (stderr, "No such thread: %s.\n", ptid_str); + else if (!thread->btrace) + fprintf (stderr, "Branch tracing not enabled for %s.\n", ptid_str); + else if (!the_target->disable_btrace) + fprintf (stderr, "Target does not support branch tracing."); + else if (target_disable_btrace (thread->btrace) != 0) + fprintf (stderr, "Could not disable branch tracing for %s.\n", ptid_str); + else + { + thread->btrace = NULL; + err = 0; + } + + return err; +} + +/* Handle the "Qbtrace" packet. */ +static int +handle_btrace_general_set (char *own_buf) +{ + char *operation = own_buf + strlen ("Qbtrace:"); + int err = 1; + + if (strncmp ("Qbtrace:", own_buf, strlen ("Qbtrace:")) != 0) + return 0; + + if (strncmp ("on:", operation, strlen ("on:")) == 0) + err = handle_btrace_enable (operation + strlen ("on:")); + else if (strncmp ("off:", operation, strlen ("off:")) == 0) + err = handle_btrace_disable (operation + strlen ("off:")); + else + fprintf (stderr, "Unknown btrace operation: %s. Use on or off.\n", own_buf); + + if (err) + write_enn (own_buf); + else + write_ok (own_buf); + + return 1; +} + static void handle_general_set (char *own_buf) { @@ -598,6 +674,9 @@ handle_general_set (char *own_buf) return; } + if (handle_btrace_general_set (own_buf)) + return; + /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ own_buf[0] = 0; @@ -1296,6 +1375,55 @@ handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf, return (*the_target->read_loadmap) (annex, offset, readbuf, len); } +/* Handle branch trace data transfer. */ +static int +handle_qxfer_btrace (const char *annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) +{ + static struct buffer cache; + struct thread_info *thread; + ptid_t ptid; + + if (!the_target->read_btrace || writebuf) + return -2; + + if (!target_running () || !annex) + return -1; + + ptid = read_ptid ((char *) annex, NULL); + thread = find_thread_ptid (ptid); + if (!thread) + { + fprintf (stderr, "No such thread: %s\n", annex); + return -1; + } + else if (!thread->btrace) + { + fprintf (stderr, "Btrace not enabled for %s\n", annex); + return -1; + } + + if (!offset) + { + buffer_free (&cache); + + target_read_btrace (thread->btrace, &cache); + } + else if (offset >= cache.used_size) + { + buffer_free (&cache); + return 0; + } + + if (len > (cache.used_size - offset)) + len = cache.used_size - offset; + + memcpy (readbuf, cache.buffer + offset, len); + + return len; +} + static const struct qxfer qxfer_packets[] = { { "auxv", handle_qxfer_auxv }, @@ -1309,6 +1437,7 @@ static const struct qxfer qxfer_packets[] = { "statictrace", handle_qxfer_statictrace }, { "threads", handle_qxfer_threads }, { "traceframe-info", handle_qxfer_traceframe_info }, + { "btrace", handle_qxfer_btrace }, }; static int @@ -1465,6 +1594,34 @@ crc32 (CORE_ADDR base, int len, unsigned int crc) /* Handle all of the extended 'q' packets. */ +/* Handle the "qbtrace" packet. */ +static int +handle_btrace_query (char *own_buf) +{ + if (strncmp ("qbtrace:", own_buf, strlen ("qbtrace:")) == 0) + { + char *ptid_str = own_buf + strlen ("qbtrace:"); + ptid_t ptid = read_ptid (ptid_str, NULL); + struct thread_info *thread = find_thread_ptid (ptid); + + if (!thread) + { + fprintf (stderr, "No such thread: %s\n", ptid_str); + write_enn (own_buf); + } + else if (!thread->btrace) + { + fprintf (stderr, "Btrace not enabled for %s\n", ptid_str); + write_enn (own_buf); + } + else + strcpy (own_buf, + (target_btrace_has_changed (thread->btrace) ? "yes" : "no")); + return 1; + } + return 0; +} + void handle_query (char *own_buf, int packet_len, int *new_packet_len_p) { @@ -1692,6 +1849,13 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (target_supports_agent ()) strcat (own_buf, ";QAgent+"); + if (target_supports_btrace ()) + { + strcat (own_buf, ";qbtrace+"); + strcat (own_buf, ";Qbtrace+"); + strcat (own_buf, ";qXfer:btrace:read+"); + } + return; } @@ -1882,6 +2046,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (target_supports_tracepoints () && handle_tracepoint_query (own_buf)) return; + if (handle_btrace_query (own_buf)) + return; + /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ own_buf[0] = 0; diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h index 9f96e04..952c973 100644 --- a/gdb/gdbserver/target.h +++ b/gdb/gdbserver/target.h @@ -22,6 +22,8 @@ #define TARGET_H struct emit_ops; +struct btrace_target_info; +struct buffer; /* Ways to "resume" a thread. */ @@ -397,6 +399,22 @@ struct target_ops /* Return true if target supports debugging agent. */ int (*supports_agent) (void); + + /* Check whether the target supports branch tracing. */ + int (*supports_btrace) (void); + + /* Enable branch tracing for @ptid and allocate a branch trace target + information struct for reading and for disabling branch trace. */ + struct btrace_target_info *(*enable_btrace) (ptid_t ptid); + + /* Disable branch tracing. */ + int (*disable_btrace) (struct btrace_target_info *tinfo); + + /* Check whether branch trace changed on the target. */ + int (*btrace_has_changed) (struct btrace_target_info *); + + /* Read branch trace data into buffer. */ + void (*read_btrace) (struct btrace_target_info *, struct buffer *); }; extern struct target_ops *the_target; @@ -520,6 +538,21 @@ int kill_inferior (int); (the_target->supports_agent ? \ (*the_target->supports_agent) () : 0) +#define target_supports_btrace() \ + (the_target->supports_btrace ? (*the_target->supports_btrace) () : 0) + +#define target_enable_btrace(ptid) \ + (*the_target->enable_btrace) (ptid) + +#define target_disable_btrace(tinfo) \ + (*the_target->disable_btrace) (tinfo) + +#define target_btrace_has_changed(tinfo) \ + (*the_target->btrace_has_changed) (tinfo) + +#define target_read_btrace(tinfo, buffer) \ + (*the_target->read_btrace) (tinfo, buffer) + /* Start non-stop mode, returns 0 on success, -1 on failure. */ int start_non_stop (int nonstop); -- 1.7.1