Re: [PATCH] store trace default-collect to target [3/6] tfile

Hui Zhu
2013-04-15T15:12:09Z

[-- Attachment #1: Type: text/plain, Size: 5737 bytes --]

Post a new version to fix the typo of "collest".

Thanks,
Hui

2013-04-15 Hui Zhu <hui@codesourcery.com>

* ctf.c (ctf_write_default_collect): New.
(trace_file_write_ops): Add ctf_write_default_collect.
* tracepoint.c (tfile_write_default_collect): New.
(trace_file_write_ops): Add tfile_write_default_collect.
(trace_save): Call writer->ops->write_default_collect.
(tfile_interp_line): Add collectp.
(tfile_open): Add support of default collect.
* tracepoint.h (trace_file_write_ops): Add write_default_collect.

On Fri, Apr 12, 2013 at 6:45 PM, Hui Zhu <teawater@gmail.com> wrote:
> Hi Yao,
>
> Thanks for your patch.
>
> I should do it but I didn't because when I work on this part I cannot
> find example in GDB src bceause the code that can be example is still
> not check in. :P
>
> Best,
> Hui
>
> On Thu, Apr 11, 2013 at 8:53 PM, Yao Qi <yao@codesourcery.com> wrote:
>> On 04/11/2013 02:17 PM, Hui Zhu wrote:
>>> /* This is the implementation of trace_file_write_ops method
>>> + write_default_collect. */
>>> +
>>> +static void
>>> +ctf_write_default_collect (struct trace_file_writer *self,
>>> + char *collect)
>>> +{
>>> + /* It is not supported yet to write default collect
>>> + into CTF trace data. */
>>> +}
>>> +
>>
>> It is pity to see "default-collect" is not written to CTF in this
>> patch. The patch below is about teaching GDB to write
>> "default-collect" action in CTF and read "default-collect" action from
>> CTF. Do you mind incorporating the patch below into your patch series,
>> so that your series is more complete.
>>
>> --
>> Yao (齐尧)
>>
>> gdb:
>>
>> 2013-04-11 Yao Qi <yao@codesourcery.com>
>>
>> * ctf.c (CTF_EVENT_ID_DEFAULT_COLLECT): New macro.
>> (ctf_write_header): Write metadata for "default-collect"
>> action.
>> (ctf_write_default_collect): Write "default-collect" action
>> in CTF.
>> (ctf_read_default_collect): New.
>> (ctf_open): Call ctf_read_default_collect.
>> ---
>> gdb/ctf.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
>> 1 files changed, 57 insertions(+), 2 deletions(-)
>>
>> diff --git a/gdb/ctf.c b/gdb/ctf.c
>> index 2dd2ed8..5757b47 100644
>> --- a/gdb/ctf.c
>> +++ b/gdb/ctf.c
>> @@ -74,6 +74,7 @@
>> #define CTF_EVENT_ID_STATUS 4
>> #define CTF_EVENT_ID_TSV_DEF 5
>> #define CTF_EVENT_ID_TP_DEF 6
>> +#define CTF_EVENT_ID_DEFAULT_COLLECT 7
>>
>> /* The state kept while writing the CTF datastream file. */
>>
>> @@ -428,6 +429,16 @@ ctf_write_header (struct trace_file_writer *self)
>> "\t};\n"
>> "};\n", CTF_EVENT_ID_TP_DEF);
>>
>> + ctf_save_write_metadata (&writer->tcs, "\n");
>> + ctf_save_write_metadata (&writer->tcs,
>> + "event {\n\tname = \"default_collect\";\n"
>> + "\tid = %u;\n"
>> + "\tfields := struct { \n"
>> + "\t\tchars contents;\n"
>> + "\t};\n"
>> + "};\n",
>> + CTF_EVENT_ID_DEFAULT_COLLECT);
>> +
>> gdb_assert (writer->tcs.content_size == 0);
>> gdb_assert (writer->tcs.packet_start == 0);
>>
>> @@ -622,8 +633,17 @@ static void
>> ctf_write_default_collect (struct trace_file_writer *self,
>> char *collect)
>> {
>> - /* It is not supported yet to write default collect
>> - into CTF trace data. */
>> + struct ctf_trace_file_writer *writer
>> + = (struct ctf_trace_file_writer *) self;
>> + int32_t int32;
>> +
>> + /* Event Id. */
>> + int32 = CTF_EVENT_ID_DEFAULT_COLLECT;
>> + ctf_save_align_write (&writer->tcs, (gdb_byte *) &int32, 4, 4);
>> +
>> + /* Contents. */
>> + ctf_save_write (&writer->tcs, collect, strlen (collect) + 1);
>> +
>> }
>>
>> /* This is the implementation of trace_file_write_ops method
>> @@ -1149,6 +1169,39 @@ ctf_read_tp (struct uploaded_tp **uploaded_tps)
>> }
>> }
>>
>> +/* Read a CTF event on "default-collect" and update the
>> + "default-collect" action. */
>> +
>> +static void
>> +ctf_read_default_collect (void)
>> +{
>> + struct bt_ctf_event *event;
>> + const struct bt_definition *scope;
>> + uint32_t u32;
>> + char *default_collect;
>> +
>> + event = bt_ctf_iter_read_event (ctf_iter);
>> + scope = bt_ctf_get_top_level_scope (event,
>> + BT_STREAM_EVENT_HEADER);
>> + u32 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
>> + "id"));
>> +
>> + if (u32 != CTF_EVENT_ID_DEFAULT_COLLECT)
>> + error (_("Wrong event id!"));
>> +
>> + default_collect
>> + = bt_ctf_get_string (bt_ctf_get_field (event, scope, "contents"));
>> +
>> + if (default_collect == NULL)
>> + default_collect = xstrdup ("");
>> + else
>> + default_collect = xstrdup (default_collect);
>> +
>> + trace_set_default_collect (default_collect);
>> +
>> + bt_iter_next (bt_ctf_get_iter (ctf_iter));
>> +}
>> +
>> /* This is the implementation of target_ops method to_open. Open CTF
>> trace data, read trace status, trace state variables and tracepoint
>> definitions from the first packet. Set the start position at the
>> @@ -1190,6 +1243,8 @@ ctf_open (char *dirname, int from_tty)
>>
>> ctf_read_tp (&uploaded_tps);
>>
>> + ctf_read_default_collect ();
>> +
>> event = bt_ctf_iter_read_event (ctf_iter);
>> /* EVENT can be NULL if we've already gone to the end of stream of
>> events. */
>> --
>> 1.7.7.6

[-- Attachment #2: defc-tfile.txt --]
[-- Type: text/plain, Size: 4085 bytes --]

--- a/ctf.c
+++ b/ctf.c
@@ -616,6 +616,17 @@ ctf_write_uploaded_tp (struct trace_file
}

/* This is the implementation of trace_file_write_ops method
+ write_default_collect. */
+
+static void
+ctf_write_default_collect (struct trace_file_writer *self,
+ char *collect)
+{
+ /* It is not supported yet to write default collect
+ into CTF trace data. */
+}
+
+/* This is the implementation of trace_file_write_ops method
write_definition_end. */

static void
@@ -847,6 +858,7 @@ static const struct trace_file_write_ops
ctf_write_status,
ctf_write_uploaded_tsv,
ctf_write_uploaded_tp,
+ ctf_write_default_collect,
ctf_write_definition_end,
NULL,
&ctf_write_frame_ops,
--- a/tracepoint.c
+++ b/tracepoint.c
@@ -3237,6 +3237,19 @@ tfile_write_uploaded_tp (struct trace_fi
}

/* This is the implementation of trace_file_write_ops method
+ write_default_collect. */
+
+static void
+tfile_write_default_collect (struct trace_file_writer *self,
+ char *collect)
+{
+ struct tfile_trace_file_writer *writer
+ = (struct tfile_trace_file_writer *) self;
+
+ fprintf (writer->fp, "dc %s\n", collect);
+}
+
+/* This is the implementation of trace_file_write_ops method
write_definition_end. */

static void
@@ -3289,6 +3302,7 @@ static const struct trace_file_write_ops
tfile_write_status,
tfile_write_uploaded_tsv,
tfile_write_uploaded_tp,
+ tfile_write_default_collect,
tfile_write_definition_end,
tfile_write_raw_data,
NULL,
@@ -3378,6 +3392,8 @@ trace_save (const char *filename, struct
for (utp = uploaded_tps; utp; utp = utp->next)
writer->ops->write_uploaded_tp (writer, utp);

+ writer->ops->write_default_collect (writer, default_collect);
+
free_uploaded_tps (&uploaded_tps);

/* Mark the end of the definition section. */
@@ -4147,7 +4163,8 @@ int trace_regblock_size;

static void tfile_interp_line (char *line,
struct uploaded_tp **utpp,
- struct uploaded_tsv **utsvp);
+ struct uploaded_tsv **utsvp,
+ char **collectp);

/* Read SIZE bytes into READBUF from the trace frame, starting at
TRACE_FD's current position. Note that this call `read'
@@ -4182,6 +4199,7 @@ tfile_open (char *filename, int from_tty
struct trace_status *ts;
struct uploaded_tp *uploaded_tps = NULL;
struct uploaded_tsv *uploaded_tsvs = NULL;
+ char *uploaded_default_collect = NULL;

target_preopen (from_tty);
if (!filename)
@@ -4251,7 +4269,8 @@ tfile_open (char *filename, int from_tty
break;
linebuf[i] = '\0';
i = 0;
- tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
+ tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs,
+ &uploaded_default_collect);
}
else
linebuf[i++] = byte;
@@ -4289,6 +4308,8 @@ tfile_open (char *filename, int from_tty

merge_uploaded_tracepoints (&uploaded_tps);

+ trace_set_default_collect (uploaded_default_collect);
+
post_create_inferior (&tfile_ops, from_tty);
}

@@ -4297,7 +4318,8 @@ tfile_open (char *filename, int from_tty

static void
tfile_interp_line (char *line,
- struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
+ struct uploaded_tp **utpp, struct uploaded_tsv **utsvp,
+ char **collectp)
{
char *p = line;

@@ -4321,6 +4343,11 @@ tfile_interp_line (char *line,
p += strlen ("tsv ");
parse_tsv_definition (p, utsvp);
}
+ else if (strncmp (p, "dc ", strlen ("dc ")) == 0)
+ {
+ p += strlen ("dc ");
+ *collectp = xstrdup (p);
+ }
else
warning (_("Ignoring trace file definition \"%s\""), line);
}
--- a/tracepoint.h
+++ b/tracepoint.h
@@ -296,6 +296,10 @@ struct trace_file_write_ops
void (*write_uploaded_tp) (struct trace_file_writer *self,
struct uploaded_tp *tp);

+ /* Write the tracepoint default collect. */
+ void (*write_default_collect) (struct trace_file_writer *self,
+ char *collect);
+
/* Write to mark the end of the definition part. */
void (*write_definition_end) (struct trace_file_writer *self);