gdb/tracefile-tfile.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Trace file TFILE format support in GDB.

  3.    Copyright (C) 1997-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.

  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.

  17.    You should have received a copy of the GNU General Public License
  18.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  20. #include "defs.h"
  21. #include "tracefile.h"
  22. #include "readline/tilde.h"
  23. #include "filestuff.h"
  24. #include "rsp-low.h" /* bin2hex */
  25. #include "regcache.h"
  26. #include "inferior.h"
  27. #include "gdbthread.h"
  28. #include "exec.h" /* exec_bfd */
  29. #include "completer.h"
  30. #include "filenames.h"

  32. #ifndef O_LARGEFILE
  33. ‌#define O_LARGEFILE 0
  34. #endif

  36. /* TFILE trace writer.  */

  38. ‌struct tfile_trace_file_writer
  39. {
  40.   struct trace_file_writer base;

  42.   /* File pointer to tfile trace file.  */
  43.   FILE *fp;
  44.   /* Path name of the tfile trace file.  */
  45.   char *pathname;
  46. };

  48. /* This is the implementation of trace_file_write_ops method
  49.    target_save.  We just call the generic target
  50.    target_save_trace_data to do target-side saving.  */

  52. static int
  53. ‌tfile_target_save (struct trace_file_writer *self,
  54.                    const char *filename)
  55. {
  56.   int err = target_save_trace_data (filename);

  58.   return (err >= 0);
  59. }

  61. /* This is the implementation of trace_file_write_ops method
  62.    dtor.  */

  64. static void
  65. ‌tfile_dtor (struct trace_file_writer *self)
  66. {
  67.   struct tfile_trace_file_writer *writer
  68.     = (struct tfile_trace_file_writer *) self;

  70.   xfree (writer->pathname);

  72.   if (writer->fp != NULL)
  73.     fclose (writer->fp);
  74. }

  76. /* This is the implementation of trace_file_write_ops method
  77.    start.  It creates the trace file FILENAME and registers some
  78.    cleanups.  */

  80. static void
  81. ‌tfile_start (struct trace_file_writer *self, const char *filename)
  82. {
  83.   struct tfile_trace_file_writer *writer
  84.     = (struct tfile_trace_file_writer *) self;

  86.   writer->pathname = tilde_expand (filename);
  87.   writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
  88.   if (writer->fp == NULL)
  89.     error (_("Unable to open file '%s' for saving trace data (%s)"),
  90.            writer->pathname, safe_strerror (errno));
  91. }

  93. /* This is the implementation of trace_file_write_ops method
  94.    write_header.  Write the TFILE header.  */

  96. static void
  97. ‌tfile_write_header (struct trace_file_writer *self)
  98. {
  99.   struct tfile_trace_file_writer *writer
  100.     = (struct tfile_trace_file_writer *) self;
  101.   int written;

  103.   /* Write a file header, with a high-bit-set char to indicate a
  104.      binary file, plus a hint as what this file is, and a version
  105.      number in case of future needs.  */
  106.   written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
  107.   if (written < 1)
  108.     perror_with_name (writer->pathname);
  109. }

  111. /* This is the implementation of trace_file_write_ops method
  112.    write_regblock_type.  Write the size of register block.  */

  114. static void
  115. ‌tfile_write_regblock_type (struct trace_file_writer *self, int size)
  116. {
  117.   struct tfile_trace_file_writer *writer
  118.     = (struct tfile_trace_file_writer *) self;

  120.   fprintf (writer->fp, "R %x\n", size);
  121. }

  123. /* This is the implementation of trace_file_write_ops method
  124.    write_status.  */

  126. static void
  127. ‌tfile_write_status (struct trace_file_writer *self,
  128.                     struct trace_status *ts)
  129. {
  130.   struct tfile_trace_file_writer *writer
  131.     = (struct tfile_trace_file_writer *) self;

  133.   fprintf (writer->fp, "status %c;%s",
  134.            (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
  135.   if (ts->stop_reason == tracepoint_error
  136.       || ts->stop_reason == tstop_command)
  137.     {
  138.       char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);

  140.       bin2hex ((gdb_byte *) ts->stop_desc, buf, strlen (ts->stop_desc));
  141.       fprintf (writer->fp, ":%s", buf);
  142.     }
  143.   fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
  144.   if (ts->traceframe_count >= 0)
  145.     fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
  146.   if (ts->traceframes_created >= 0)
  147.     fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
  148.   if (ts->buffer_free >= 0)
  149.     fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
  150.   if (ts->buffer_size >= 0)
  151.     fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
  152.   if (ts->disconnected_tracing)
  153.     fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
  154.   if (ts->circular_buffer)
  155.     fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
  156.   if (ts->start_time)
  157.     {
  158.       fprintf (writer->fp, ";starttime:%s",
  159.       phex_nz (ts->start_time, sizeof (ts->start_time)));
  160.     }
  161.   if (ts->stop_time)
  162.     {
  163.       fprintf (writer->fp, ";stoptime:%s",
  164.       phex_nz (ts->stop_time, sizeof (ts->stop_time)));
  165.     }
  166.   if (ts->notes != NULL)
  167.     {
  168.       char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);

  170.       bin2hex ((gdb_byte *) ts->notes, buf, strlen (ts->notes));
  171.       fprintf (writer->fp, ";notes:%s", buf);
  172.     }
  173.   if (ts->user_name != NULL)
  174.     {
  175.       char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);

  177.       bin2hex ((gdb_byte *) ts->user_name, buf, strlen (ts->user_name));
  178.       fprintf (writer->fp, ";username:%s", buf);
  179.     }
  180.   fprintf (writer->fp, "\n");
  181. }

  183. /* This is the implementation of trace_file_write_ops method
  184.    write_uploaded_tsv.  */

  186. static void
  187. ‌tfile_write_uploaded_tsv (struct trace_file_writer *self,
  188.                           struct uploaded_tsv *utsv)
  189. {
  190.   char *buf = "";
  191.   struct tfile_trace_file_writer *writer
  192.     = (struct tfile_trace_file_writer *) self;

  194.   if (utsv->name)
  195.     {
  196.       buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
  197.       bin2hex ((gdb_byte *) (utsv->name), buf, strlen (utsv->name));
  198.     }

  200.   fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
  201.            utsv->number, phex_nz (utsv->initial_value, 8),
  202.            utsv->builtin, buf);

  204.   if (utsv->name)
  205.     xfree (buf);
  206. }

  208. ‌#define MAX_TRACE_UPLOAD 2000

  210. /* This is the implementation of trace_file_write_ops method
  211.    write_uploaded_tp.  */

  213. static void
  214. ‌tfile_write_uploaded_tp (struct trace_file_writer *self,
  215.                          struct uploaded_tp *utp)
  216. {
  217.   struct tfile_trace_file_writer *writer
  218.     = (struct tfile_trace_file_writer *) self;
  219.   int a;
  220.   char *act;
  221.   char buf[MAX_TRACE_UPLOAD];

  223.   fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
  224.            utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
  225.            (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
  226.   if (utp->type == bp_fast_tracepoint)
  227.     fprintf (writer->fp, ":F%x", utp->orig_size);
  228.   if (utp->cond)
  229.     fprintf (writer->fp,
  230.              ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
  231.              utp->cond);
  232.   fprintf (writer->fp, "\n");
  233.   for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
  234.     fprintf (writer->fp, "tp A%x:%s:%s\n",
  235.              utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
  236.   for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
  237.     fprintf (writer->fp, "tp S%x:%s:%s\n",
  238.              utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
  239.   if (utp->at_string)
  240.     {
  241.       encode_source_string (utp->number, utp->addr,
  242.                             "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
  243.       fprintf (writer->fp, "tp Z%s\n", buf);
  244.     }
  245.   if (utp->cond_string)
  246.     {
  247.       encode_source_string (utp->number, utp->addr,
  248.                             "cond", utp->cond_string,
  249.                             buf, MAX_TRACE_UPLOAD);
  250.       fprintf (writer->fp, "tp Z%s\n", buf);
  251.     }
  252.   for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
  253.     {
  254.       encode_source_string (utp->number, utp->addr, "cmd", act,
  255.                             buf, MAX_TRACE_UPLOAD);
  256.       fprintf (writer->fp, "tp Z%s\n", buf);
  257.     }
  258.   fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
  259.            utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
  260.            utp->hit_count,
  261.            phex_nz (utp->traceframe_usage,
  262.                     sizeof (utp->traceframe_usage)));
  263. }

  265. /* This is the implementation of trace_file_write_ops method
  266.    write_definition_end.  */

  268. static void
  269. ‌tfile_write_definition_end (struct trace_file_writer *self)
  270. {
  271.   struct tfile_trace_file_writer *writer
  272.     = (struct tfile_trace_file_writer *) self;

  274.   fprintf (writer->fp, "\n");
  275. }

  277. /* This is the implementation of trace_file_write_ops method
  278.    write_raw_data.  */

  280. static void
  281. ‌tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
  282.                       LONGEST len)
  283. {
  284.   struct tfile_trace_file_writer *writer
  285.     = (struct tfile_trace_file_writer *) self;

  287.   if (fwrite (buf, len, 1, writer->fp) < 1)
  288.     perror_with_name (writer->pathname);
  289. }

  291. /* This is the implementation of trace_file_write_ops method
  292.    end.  */

  294. static void
  295. ‌tfile_end (struct trace_file_writer *self)
  296. {
  297.   struct tfile_trace_file_writer *writer
  298.     = (struct tfile_trace_file_writer *) self;
  299.   uint32_t gotten = 0;

  301.   /* Mark the end of trace data.  */
  302.   if (fwrite (&gotten, 4, 1, writer->fp) < 1)
  303.     perror_with_name (writer->pathname);
  304. }

  306. /* Operations to write trace buffers into TFILE format.  */

  308. ‌static const struct trace_file_write_ops tfile_write_ops =
  309. {
  310.   tfile_dtor,
  311.   tfile_target_save,
  312.   tfile_start,
  313.   tfile_write_header,
  314.   tfile_write_regblock_type,
  315.   tfile_write_status,
  316.   tfile_write_uploaded_tsv,
  317.   tfile_write_uploaded_tp,
  318.   tfile_write_definition_end,
  319.   tfile_write_raw_data,
  320.   NULL,
  321.   tfile_end,
  322. };

  324. /* Return a trace writer for TFILE format.  */

  326. struct trace_file_writer *
  327. ‌tfile_trace_file_writer_new (void)
  328. {
  329.   struct tfile_trace_file_writer *writer
  330.     = xmalloc (sizeof (struct tfile_trace_file_writer));

  332.   writer->base.ops = &tfile_write_ops;
  333.   writer->fp = NULL;
  334.   writer->pathname = NULL;

  336.   return (struct trace_file_writer *) writer;
  337. }

  339. /* target tfile command */

  341. ‌static struct target_ops tfile_ops;

  343. /* Fill in tfile_ops with its defined operations and properties.  */

  345. ‌#define TRACE_HEADER_SIZE 8

  347. ‌#define TFILE_PID (1)

  349. ‌static char *trace_filename;
  350. ‌static int trace_fd = -1;
  351. ‌static off_t trace_frames_offset;
  352. ‌static off_t cur_offset;
  353. ‌static int cur_data_size;
  354. ‌int trace_regblock_size;

  356. static void tfile_interp_line (char *line,
  357.                                struct uploaded_tp **utpp,
  358.                                struct uploaded_tsv **utsvp);

  360. /* Read SIZE bytes into READBUF from the trace frame, starting at
  361.    TRACE_FD's current position.  Note that this call `read'
  362.    underneath, hence it advances the file's seek position.  Throws an
  363.    error if the `read' syscall fails, or less than SIZE bytes are
  364.    read.  */

  366. static void
  367. ‌tfile_read (gdb_byte *readbuf, int size)
  368. {
  369.   int gotten;

  371.   gotten = read (trace_fd, readbuf, size);
  372.   if (gotten < 0)
  373.     perror_with_name (trace_filename);
  374.   else if (gotten < size)
  375.     error (_("Premature end of file while reading trace file"));
  376. }

  378. static void
  379. ‌tfile_open (const char *arg, int from_tty)
  380. {
  381.   volatile struct gdb_exception ex;
  382.   char *temp;
  383.   struct cleanup *old_chain;
  384.   int flags;
  385.   int scratch_chan;
  386.   char header[TRACE_HEADER_SIZE];
  387.   char linebuf[1000]; /* Should be max remote packet size or so.  */
  388.   gdb_byte byte;
  389.   int bytes, i;
  390.   struct trace_status *ts;
  391.   struct uploaded_tp *uploaded_tps = NULL;
  392.   struct uploaded_tsv *uploaded_tsvs = NULL;
  393.   char *filename;

  395.   target_preopen (from_tty);
  396.   if (!arg)
  397.     error (_("No trace file specified."));

  399.   filename = tilde_expand (arg);
  400.   if (!IS_ABSOLUTE_PATH(filename))
  401.     {
  402.       temp = concat (current_directory, "/", filename, (char *) NULL);
  403.       xfree (filename);
  404.       filename = temp;
  405.     }

  407.   old_chain = make_cleanup (xfree, filename);

  409.   flags = O_BINARY | O_LARGEFILE;
  410.   flags |= O_RDONLY;
  411.   scratch_chan = gdb_open_cloexec (filename, flags, 0);
  412.   if (scratch_chan < 0)
  413.     perror_with_name (filename);

  415.   /* Looks semi-reasonable.  Toss the old trace file and work on the new.  */

  417.   discard_cleanups (old_chain);        /* Don't free filename any more.  */
  418.   unpush_target (&tfile_ops);

  420.   trace_filename = xstrdup (filename);
  421.   trace_fd = scratch_chan;

  423.   bytes = 0;
  424.   /* Read the file header and test for validity.  */
  425.   tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);

  427.   bytes += TRACE_HEADER_SIZE;
  428.   if (!(header[0] == 0x7f
  429.         && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
  430.     error (_("File is not a valid trace file."));

  432.   push_target (&tfile_ops);

  434.   trace_regblock_size = 0;
  435.   ts = current_trace_status ();
  436.   /* We know we're working with a file.  Record its name.  */
  437.   ts->filename = trace_filename;
  438.   /* Set defaults in case there is no status line.  */
  439.   ts->running_known = 0;
  440.   ts->stop_reason = trace_stop_reason_unknown;
  441.   ts->traceframe_count = -1;
  442.   ts->buffer_free = 0;
  443.   ts->disconnected_tracing = 0;
  444.   ts->circular_buffer = 0;

  446.   TRY_CATCH (ex, RETURN_MASK_ALL)
  447.     {
  448.       /* Read through a section of newline-terminated lines that
  449.          define things like tracepoints.  */
  450.       i = 0;
  451.       while (1)
  452.         {
  453.           tfile_read (&byte, 1);

  455.           ++bytes;
  456.           if (byte == '\n')
  457.             {
  458.               /* Empty line marks end of the definition section.  */
  459.               if (i == 0)
  460.                 break;
  461.               linebuf[i] = '\0';
  462.               i = 0;
  463.               tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
  464.             }
  465.           else
  466.             linebuf[i++] = byte;
  467.           if (i >= 1000)
  468.             error (_("Excessively long lines in trace file"));
  469.         }

  471.       /* Record the starting offset of the binary trace data.  */
  472.       trace_frames_offset = bytes;

  474.       /* If we don't have a blocksize, we can't interpret the
  475.          traceframes.  */
  476.       if (trace_regblock_size == 0)
  477.         error (_("No register block size recorded in trace file"));
  478.     }
  479.   if (ex.reason < 0)
  480.     {
  481.       /* Remove the partially set up target.  */
  482.       unpush_target (&tfile_ops);
  483.       throw_exception (ex);
  484.     }

  486.   inferior_appeared (current_inferior (), TFILE_PID);
  487.   inferior_ptid = pid_to_ptid (TFILE_PID);
  488.   add_thread_silent (inferior_ptid);

  490.   if (ts->traceframe_count <= 0)
  491.     warning (_("No traceframes present in this file."));

  493.   /* Add the file's tracepoints and variables into the current mix.  */

  495.   /* Get trace state variables first, they may be checked when parsing
  496.      uploaded commands.  */
  497.   merge_uploaded_trace_state_variables (&uploaded_tsvs);

  499.   merge_uploaded_tracepoints (&uploaded_tps);

  501.   post_create_inferior (&tfile_ops, from_tty);
  502. }

  504. /* Interpret the given line from the definitions part of the trace
  505.    file.  */

  507. static void
  508. ‌tfile_interp_line (char *line, struct uploaded_tp **utpp,
  509.                    struct uploaded_tsv **utsvp)
  510. {
  511.   char *p = line;

  513.   if (strncmp (p, "R ", strlen ("R ")) == 0)
  514.     {
  515.       p += strlen ("R ");
  516.       trace_regblock_size = strtol (p, &p, 16);
  517.     }
  518.   else if (strncmp (p, "status ", strlen ("status ")) == 0)
  519.     {
  520.       p += strlen ("status ");
  521.       parse_trace_status (p, current_trace_status ());
  522.     }
  523.   else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
  524.     {
  525.       p += strlen ("tp ");
  526.       parse_tracepoint_definition (p, utpp);
  527.     }
  528.   else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
  529.     {
  530.       p += strlen ("tsv ");
  531.       parse_tsv_definition (p, utsvp);
  532.     }
  533.   else
  534.     warning (_("Ignoring trace file definition \"%s\""), line);
  535. }

  537. /* Close the trace file and generally clean up.  */

  539. static void
  540. ‌tfile_close (struct target_ops *self)
  541. {
  542.   int pid;

  544.   if (trace_fd < 0)
  545.     return;

  547.   pid = ptid_get_pid (inferior_ptid);
  548.   inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff.  */
  549.   exit_inferior_silent (pid);

  551.   close (trace_fd);
  552.   trace_fd = -1;
  553.   xfree (trace_filename);
  554.   trace_filename = NULL;

  556.   trace_reset_local_state ();
  557. }

  559. static void
  560. ‌tfile_files_info (struct target_ops *t)
  561. {
  562.   printf_filtered ("\t`%s'\n", trace_filename);
  563. }

  565. static void
  566. ‌tfile_get_tracepoint_status (struct target_ops *self,
  567.                              struct breakpoint *tp, struct uploaded_tp *utp)
  568. {
  569.   /* Other bits of trace status were collected as part of opening the
  570.      trace files, so nothing to do here.  */
  571. }

  573. /* Given the position of a traceframe in the file, figure out what
  574.    address the frame was collected at.  This would normally be the
  575.    value of a collected PC register, but if not available, we
  576.    improvise.  */

  578. static CORE_ADDR
  579. ‌tfile_get_traceframe_address (off_t tframe_offset)
  580. {
  581.   CORE_ADDR addr = 0;
  582.   short tpnum;
  583.   struct tracepoint *tp;
  584.   off_t saved_offset = cur_offset;

  586.   /* FIXME dig pc out of collected registers.  */

  588.   /* Fall back to using tracepoint address.  */
  589.   lseek (trace_fd, tframe_offset, SEEK_SET);
  590.   tfile_read ((gdb_byte *) &tpnum, 2);
  591.   tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
  592.                                           gdbarch_byte_order
  593.                                               (target_gdbarch ()));

  595.   tp = get_tracepoint_by_number_on_target (tpnum);
  596.   /* FIXME this is a poor heuristic if multiple locations.  */
  597.   if (tp && tp->base.loc)
  598.     addr = tp->base.loc->address;

  600.   /* Restore our seek position.  */
  601.   cur_offset = saved_offset;
  602.   lseek (trace_fd, cur_offset, SEEK_SET);
  603.   return addr;
  604. }

  606. /* Given a type of search and some parameters, scan the collection of
  607.    traceframes in the file looking for a match.  When found, return
  608.    both the traceframe and tracepoint number, otherwise -1 for
  609.    each.  */

  611. static int
  612. ‌tfile_trace_find (struct target_ops *self, enum trace_find_type type, int num,
  613.                   CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
  614. {
  615.   short tpnum;
  616.   int tfnum = 0, found = 0;
  617.   unsigned int data_size;
  618.   struct tracepoint *tp;
  619.   off_t offset, tframe_offset;
  620.   CORE_ADDR tfaddr;

  622.   if (num == -1)
  623.     {
  624.       if (tpp)
  625.         *tpp = -1;
  626.       return -1;
  627.     }

  629.   lseek (trace_fd, trace_frames_offset, SEEK_SET);
  630.   offset = trace_frames_offset;
  631.   while (1)
  632.     {
  633.       tframe_offset = offset;
  634.       tfile_read ((gdb_byte *) &tpnum, 2);
  635.       tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
  636.                                               gdbarch_byte_order
  637.                                                   (target_gdbarch ()));
  638.       offset += 2;
  639.       if (tpnum == 0)
  640.         break;
  641.       tfile_read ((gdb_byte *) &data_size, 4);
  642.       data_size = (unsigned int) extract_unsigned_integer
  643.                                      ((gdb_byte *) &data_size, 4,
  644.                                       gdbarch_byte_order (target_gdbarch ()));
  645.       offset += 4;

  647.       if (type == tfind_number)
  648.         {
  649.           /* Looking for a specific trace frame.  */
  650.           if (tfnum == num)
  651.             found = 1;
  652.         }
  653.       else
  654.         {
  655.           /* Start from the _next_ trace frame.  */
  656.           if (tfnum > get_traceframe_number ())
  657.             {
  658.               switch (type)
  659.                 {
  660.                 case tfind_pc:
  661.                   tfaddr = tfile_get_traceframe_address (tframe_offset);
  662.                   if (tfaddr == addr1)
  663.                     found = 1;
  664.                   break;
  665.                 case tfind_tp:
  666.                   tp = get_tracepoint (num);
  667.                   if (tp && tpnum == tp->number_on_target)
  668.                     found = 1;
  669.                   break;
  670.                 case tfind_range:
  671.                   tfaddr = tfile_get_traceframe_address (tframe_offset);
  672.                   if (addr1 <= tfaddr && tfaddr <= addr2)
  673.                     found = 1;
  674.                   break;
  675.                 case tfind_outside:
  676.                   tfaddr = tfile_get_traceframe_address (tframe_offset);
  677.                   if (!(addr1 <= tfaddr && tfaddr <= addr2))
  678.                     found = 1;
  679.                   break;
  680.                 default:
  681.                   internal_error (__FILE__, __LINE__, _("unknown tfind type"));
  682.                 }
  683.             }
  684.         }

  686.       if (found)
  687.         {
  688.           if (tpp)
  689.             *tpp = tpnum;
  690.           cur_offset = offset;
  691.           cur_data_size = data_size;

  693.           return tfnum;
  694.         }
  695.       /* Skip past the traceframe's data.  */
  696.       lseek (trace_fd, data_size, SEEK_CUR);
  697.       offset += data_size;
  698.       /* Update our own count of traceframes.  */
  699.       ++tfnum;
  700.     }
  701.   /* Did not find what we were looking for.  */
  702.   if (tpp)
  703.     *tpp = -1;
  704.   return -1;
  705. }

  707. /* Prototype of the callback passed to tframe_walk_blocks.  */
  708. ‌typedef int (*walk_blocks_callback_func) (char blocktype, void *data);

  710. /* Callback for traceframe_walk_blocks, used to find a given block
  711.    type in a traceframe.  */

  713. static int
  714. ‌match_blocktype (char blocktype, void *data)
  715. {
  716.   char *wantedp = data;

  718.   if (*wantedp == blocktype)
  719.     return 1;

  721.   return 0;
  722. }

  724. /* Walk over all traceframe block starting at POS offset from
  725.    CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
  726.    unmodified.  If CALLBACK returns true, this returns the position in
  727.    the traceframe where the block is found, relative to the start of
  728.    the traceframe (cur_offset).  Returns -1 if no callback call
  729.    returned true, indicating that all blocks have been walked.  */

  731. static int
  732. ‌traceframe_walk_blocks (walk_blocks_callback_func callback,
  733.                         int pos, void *data)
  734. {
  735.   /* Iterate through a traceframe's blocks, looking for a block of the
  736.      requested type.  */

  738.   lseek (trace_fd, cur_offset + pos, SEEK_SET);
  739.   while (pos < cur_data_size)
  740.     {
  741.       unsigned short mlen;
  742.       char block_type;

  744.       tfile_read ((gdb_byte *) &block_type, 1);

  746.       ++pos;

  748.       if ((*callback) (block_type, data))
  749.         return pos;

  751.       switch (block_type)
  752.         {
  753.         case 'R':
  754.           lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
  755.           pos += trace_regblock_size;
  756.           break;
  757.         case 'M':
  758.           lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
  759.           tfile_read ((gdb_byte *) &mlen, 2);
  760.           mlen = (unsigned short)
  761.                 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
  762.                                           gdbarch_byte_order
  763.                                               (target_gdbarch ()));
  764.           lseek (trace_fd, mlen, SEEK_CUR);
  765.           pos += (8 + 2 + mlen);
  766.           break;
  767.         case 'V':
  768.           lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
  769.           pos += (4 + 8);
  770.           break;
  771.         default:
  772.           error (_("Unknown block type '%c' (0x%x) in trace frame"),
  773.                  block_type, block_type);
  774.           break;
  775.         }
  776.     }

  778.   return -1;
  779. }

  781. /* Convenience wrapper around traceframe_walk_blocks.  Looks for the
  782.    position offset of a block of type TYPE_WANTED in the current trace
  783.    frame, starting at POS.  Returns -1 if no such block was found.  */

  785. static int
  786. ‌traceframe_find_block_type (char type_wanted, int pos)
  787. {
  788.   return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
  789. }

  791. /* Look for a block of saved registers in the traceframe, and get the
  792.    requested register from it.  */

  794. static void
  795. ‌tfile_fetch_registers (struct target_ops *ops,
  796.                        struct regcache *regcache, int regno)
  797. {
  798.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  799.   int offset, regn, regsize;

  801.   /* An uninitialized reg size says we're not going to be
  802.      successful at getting register blocks.  */
  803.   if (!trace_regblock_size)
  804.     return;

  806.   if (traceframe_find_block_type ('R', 0) >= 0)
  807.     {
  808.       gdb_byte *regs = alloca (trace_regblock_size);

  810.       tfile_read (regs, trace_regblock_size);

  812.       /* Assume the block is laid out in GDB register number order,
  813.          each register with the size that it has in GDB.  */
  814.       offset = 0;
  815.       for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
  816.         {
  817.           regsize = register_size (gdbarch, regn);
  818.           /* Make sure we stay within block bounds.  */
  819.           if (offset + regsize >= trace_regblock_size)
  820.             break;
  821.           if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
  822.             {
  823.               if (regno == regn)
  824.                 {
  825.                   regcache_raw_supply (regcache, regno, regs + offset);
  826.                   break;
  827.                 }
  828.               else if (regno == -1)
  829.                 {
  830.                   regcache_raw_supply (regcache, regn, regs + offset);
  831.                 }
  832.             }
  833.           offset += regsize;
  834.         }
  835.     }
  836.   else
  837.     tracefile_fetch_registers (regcache, regno);
  838. }

  840. static enum target_xfer_status
  841. ‌tfile_xfer_partial (struct target_ops *ops, enum target_object object,
  842.                     const char *annex, gdb_byte *readbuf,
  843.                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  844.                     ULONGEST *xfered_len)
  845. {
  846.   /* We're only doing regular memory for now.  */
  847.   if (object != TARGET_OBJECT_MEMORY)
  848.     return TARGET_XFER_E_IO;

  850.   if (readbuf == NULL)
  851.     error (_("tfile_xfer_partial: trace file is read-only"));

  853.   if (get_traceframe_number () != -1)
  854.     {
  855.       int pos = 0;
  856.       enum target_xfer_status res;
  857.       /* Records the lowest available address of all blocks that
  858.          intersects the requested range.  */
  859.       ULONGEST low_addr_available = 0;

  861.       /* Iterate through the traceframe's blocks, looking for
  862.          memory.  */
  863.       while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
  864.         {
  865.           ULONGEST maddr, amt;
  866.           unsigned short mlen;
  867.           enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());

  869.           tfile_read ((gdb_byte *) &maddr, 8);
  870.           maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
  871.                                             byte_order);
  872.           tfile_read ((gdb_byte *) &mlen, 2);
  873.           mlen = (unsigned short)
  874.             extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);

  876.           /* If the block includes the first part of the desired
  877.              range, return as much it has; GDB will re-request the
  878.              remainder, which might be in a different block of this
  879.              trace frame.  */
  880.           if (maddr <= offset && offset < (maddr + mlen))
  881.             {
  882.               amt = (maddr + mlen) - offset;
  883.               if (amt > len)
  884.                 amt = len;

  886.               if (maddr != offset)
  887.                 lseek (trace_fd, offset - maddr, SEEK_CUR);
  888.               tfile_read (readbuf, amt);
  889.               *xfered_len = amt;
  890.               return TARGET_XFER_OK;
  891.             }

  893.           if (offset < maddr && maddr < (offset + len))
  894.             if (low_addr_available == 0 || low_addr_available > maddr)
  895.               low_addr_available = maddr;

  897.           /* Skip over this block.  */
  898.           pos += (8 + 2 + mlen);
  899.         }

  901.       /* Requested memory is unavailable in the context of traceframes,
  902.          and this address falls within a read-only section, fallback
  903.          to reading from executable, up to LOW_ADDR_AVAILABLE.  */
  904.       if (offset < low_addr_available)
  905.         len = min (len, low_addr_available - offset);
  906.       res = exec_read_partial_read_only (readbuf, offset, len, xfered_len);

  908.       if (res == TARGET_XFER_OK)
  909.         return TARGET_XFER_OK;
  910.       else
  911.         {
  912.           /* No use trying further, we know some memory starting
  913.              at MEMADDR isn't available.  */
  914.           *xfered_len = len;
  915.           return TARGET_XFER_UNAVAILABLE;
  916.         }
  917.     }
  918.   else
  919.     {
  920.       /* Fallback to reading from read-only sections.  */
  921.       return section_table_read_available_memory (readbuf, offset, len,
  922.                                                   xfered_len);
  923.     }
  924. }

  926. /* Iterate through the blocks of a trace frame, looking for a 'V'
  927.    block with a matching tsv number.  */

  929. static int
  930. ‌tfile_get_trace_state_variable_value (struct target_ops *self,
  931.                                       int tsvnum, LONGEST *val)
  932. {
  933.   int pos;
  934.   int found = 0;

  936.   /* Iterate over blocks in current frame and find the last 'V'
  937.      block in which tsv number is TSVNUM.  In one trace frame, there
  938.      may be multiple 'V' blocks created for a given trace variable,
  939.      and the last matched 'V' block contains the updated value.  */
  940.   pos = 0;
  941.   while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
  942.     {
  943.       int vnum;

  945.       tfile_read ((gdb_byte *) &vnum, 4);
  946.       vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
  947.                                            gdbarch_byte_order
  948.                                            (target_gdbarch ()));
  949.       if (tsvnum == vnum)
  950.         {
  951.           tfile_read ((gdb_byte *) val, 8);
  952.           *val = extract_signed_integer ((gdb_byte *) val, 8,
  953.                                          gdbarch_byte_order
  954.                                          (target_gdbarch ()));
  955.           found = 1;
  956.         }
  957.       pos += (4 + 8);
  958.     }

  960.   return found;
  961. }

  963. /* Callback for traceframe_walk_blocks.  Builds a traceframe_info
  964.    object for the tfile target's current traceframe.  */

  966. static int
  967. ‌build_traceframe_info (char blocktype, void *data)
  968. {
  969.   struct traceframe_info *info = data;

  971.   switch (blocktype)
  972.     {
  973.     case 'M':
  974.       {
  975.         struct mem_range *r;
  976.         ULONGEST maddr;
  977.         unsigned short mlen;

  979.         tfile_read ((gdb_byte *) &maddr, 8);
  980.         maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
  981.                                           gdbarch_byte_order
  982.                                           (target_gdbarch ()));
  983.         tfile_read ((gdb_byte *) &mlen, 2);
  984.         mlen = (unsigned short)
  985.                 extract_unsigned_integer ((gdb_byte *) &mlen,
  986.                                           2, gdbarch_byte_order
  987.                                           (target_gdbarch ()));

  989.         r = VEC_safe_push (mem_range_s, info->memory, NULL);

  991.         r->start = maddr;
  992.         r->length = mlen;
  993.         break;
  994.       }
  995.     case 'V':
  996.       {
  997.         int vnum;

  999.         tfile_read ((gdb_byte *) &vnum, 4);
  1000.         VEC_safe_push (int, info->tvars, vnum);
  1001.       }
  1002.     case 'R':
  1003.     case 'S':
  1004.       {
  1005.         break;
  1006.       }
  1007.     default:
  1008.       warning (_("Unhandled trace block type (%d) '%c ' "
  1009.                  "while building trace frame info."),
  1010.                blocktype, blocktype);
  1011.       break;
  1012.     }

  1014.   return 0;
  1015. }

  1017. static struct traceframe_info *
  1018. ‌tfile_traceframe_info (struct target_ops *self)
  1019. {
  1020.   struct traceframe_info *info = XCNEW (struct traceframe_info);

  1022.   traceframe_walk_blocks (build_traceframe_info, 0, info);
  1023.   return info;
  1024. }

  1026. static void
  1027. ‌init_tfile_ops (void)
  1028. {
  1029.   init_tracefile_ops (&tfile_ops);

  1031.   tfile_ops.to_shortname = "tfile";
  1032.   tfile_ops.to_longname = "Local trace dump file";
  1033.   tfile_ops.to_doc
  1034.     = "Use a trace file as a target.  Specify the filename of the trace file.";
  1035.   tfile_ops.to_open = tfile_open;
  1036.   tfile_ops.to_close = tfile_close;
  1037.   tfile_ops.to_fetch_registers = tfile_fetch_registers;
  1038.   tfile_ops.to_xfer_partial = tfile_xfer_partial;
  1039.   tfile_ops.to_files_info = tfile_files_info;
  1040.   tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
  1041.   tfile_ops.to_trace_find = tfile_trace_find;
  1042.   tfile_ops.to_get_trace_state_variable_value
  1043.     = tfile_get_trace_state_variable_value;
  1044.   tfile_ops.to_traceframe_info = tfile_traceframe_info;
  1045. }

  1047. extern initialize_file_ftype _initialize_tracefile_tfile;

  1049. void
  1050. ‌_initialize_tracefile_tfile (void)
  1051. {
  1052.   init_tfile_ops ();

  1054.   add_target_with_completer (&tfile_ops, filename_completer);
  1055. }