gdb/tracefile.c

   1 /* Trace file support in GDB.
   2
   3    Copyright (C) 1997-2018 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #include "defs.h"
  21 #include "tracefile.h"
  22 #include "ctf.h"
  23 #include "exec.h"
  24 #include "regcache.h"
  25
  26 /* Helper macros.  */
  27
  28 #define TRACE_WRITE_R_BLOCK(writer, buf, size)  \
  29   writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
  30 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size)            \
  31   writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
  32                                                 (size))
  33 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size)     \
  34   writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
  35                                                 (size))
  36 #define TRACE_WRITE_V_BLOCK(writer, num, val)   \
  37   writer->ops->frame_ops->write_v_block ((writer), (num), (val))
  38
  39 /* Free trace file writer.  */
  40
  41 static void
  42 trace_file_writer_xfree (void *arg)
  43 {
  44   struct trace_file_writer *writer = (struct trace_file_writer *) arg;
  45
  46   writer->ops->dtor (writer);
  47   xfree (writer);
  48 }
  49
  50 /* Save tracepoint data to file named FILENAME through WRITER.  WRITER
  51    determines the trace file format.  If TARGET_DOES_SAVE is non-zero,
  52    the save is performed on the target, otherwise GDB obtains all trace
  53    data and saves it locally.  */
  54
  55 static void
  56 trace_save (const char *filename, struct trace_file_writer *writer,
  57             int target_does_save)
  58 {
  59   struct trace_status *ts = current_trace_status ();
  60   struct uploaded_tp *uploaded_tps = NULL, *utp;
  61   struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
  62
  63   ULONGEST offset = 0;
  64 #define MAX_TRACE_UPLOAD 2000
  65   gdb_byte buf[MAX_TRACE_UPLOAD];
  66   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  67
  68   /* If the target is to save the data to a file on its own, then just
  69      send the command and be done with it.  */
  70   if (target_does_save)
  71     {
  72       if (!writer->ops->target_save (writer, filename))
  73         error (_("Target failed to save trace data to '%s'."),
  74                filename);
  75       return;
  76     }
  77
  78   /* Get the trace status first before opening the file, so if the
  79      target is losing, we can get out without touching files.  Since
  80      we're just calling this for side effects, we ignore the
  81      result.  */
  82   target_get_trace_status (ts);
  83
  84   writer->ops->start (writer, filename);
  85
  86   writer->ops->write_header (writer);
  87
  88   /* Write descriptive info.  */
  89
  90   /* Write out the size of a register block.  */
  91   writer->ops->write_regblock_type (writer, trace_regblock_size);
  92
  93   /* Write out the target description info.  */
  94   writer->ops->write_tdesc (writer);
  95
  96   /* Write out status of the tracing run (aka "tstatus" info).  */
  97   writer->ops->write_status (writer, ts);
  98
  99   /* Note that we want to upload tracepoints and save those, rather
 100      than simply writing out the local ones, because the user may have
 101      changed tracepoints in GDB in preparation for a future tracing
 102      run, or maybe just mass-deleted all types of breakpoints as part
 103      of cleaning up.  So as not to contaminate the session, leave the
 104      data in its uploaded form, don't make into real tracepoints.  */
 105
 106   /* Get trace state variables first, they may be checked when parsing
 107      uploaded commands.  */
 108
 109   target_upload_trace_state_variables (&uploaded_tsvs);
 110
 111   for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
 112     writer->ops->write_uploaded_tsv (writer, utsv);
 113
 114   free_uploaded_tsvs (&uploaded_tsvs);
 115
 116   target_upload_tracepoints (&uploaded_tps);
 117
 118   for (utp = uploaded_tps; utp; utp = utp->next)
 119     target_get_tracepoint_status (NULL, utp);
 120
 121   for (utp = uploaded_tps; utp; utp = utp->next)
 122     writer->ops->write_uploaded_tp (writer, utp);
 123
 124   free_uploaded_tps (&uploaded_tps);
 125
 126   /* Mark the end of the definition section.  */
 127   writer->ops->write_definition_end (writer);
 128
 129   /* Get and write the trace data proper.  */
 130   while (1)
 131     {
 132       LONGEST gotten = 0;
 133
 134       /* The writer supports writing the contents of trace buffer
 135           directly to trace file.  Don't parse the contents of trace
 136           buffer.  */
 137       if (writer->ops->write_trace_buffer != NULL)
 138         {
 139           /* We ask for big blocks, in the hopes of efficiency, but
 140              will take less if the target has packet size limitations
 141              or some such.  */
 142           gotten = target_get_raw_trace_data (buf, offset,
 143                                               MAX_TRACE_UPLOAD);
 144           if (gotten < 0)
 145             error (_("Failure to get requested trace buffer data"));
 146           /* No more data is forthcoming, we're done.  */
 147           if (gotten == 0)
 148             break;
 149
 150           writer->ops->write_trace_buffer (writer, buf, gotten);
 151
 152           offset += gotten;
 153         }
 154       else
 155         {
 156           uint16_t tp_num;
 157           uint32_t tf_size;
 158           /* Parse the trace buffers according to how data are stored
 159              in trace buffer in GDBserver.  */
 160
 161           gotten = target_get_raw_trace_data (buf, offset, 6);
 162
 163           if (gotten == 0)
 164             break;
 165
 166           /* Read the first six bytes in, which is the tracepoint
 167              number and trace frame size.  */
 168           tp_num = (uint16_t)
 169             extract_unsigned_integer (&buf[0], 2, byte_order);
 170
 171           tf_size = (uint32_t)
 172             extract_unsigned_integer (&buf[2], 4, byte_order);
 173
 174           writer->ops->frame_ops->start (writer, tp_num);
 175           gotten = 6;
 176
 177           if (tf_size > 0)
 178             {
 179               unsigned int block;
 180
 181               offset += 6;
 182
 183               for (block = 0; block < tf_size; )
 184                 {
 185                   gdb_byte block_type;
 186
 187                   /* We'll fetch one block each time, in order to
 188                      handle the extremely large 'M' block.  We first
 189                      fetch one byte to get the type of the block.  */
 190                   gotten = target_get_raw_trace_data (buf, offset, 1);
 191                   if (gotten < 1)
 192                     error (_("Failure to get requested trace buffer data"));
 193
 194                   gotten = 1;
 195                   block += 1;
 196                   offset += 1;
 197
 198                   block_type = buf[0];
 199                   switch (block_type)
 200                     {
 201                     case 'R':
 202                       gotten
 203                         = target_get_raw_trace_data (buf, offset,
 204                                                      trace_regblock_size);
 205                       if (gotten < trace_regblock_size)
 206                         error (_("Failure to get requested trace"
 207                                  " buffer data"));
 208
 209                       TRACE_WRITE_R_BLOCK (writer, buf,
 210                                            trace_regblock_size);
 211                       break;
 212                     case 'M':
 213                       {
 214                         unsigned short mlen;
 215                         ULONGEST addr;
 216                         LONGEST t;
 217                         int j;
 218
 219                         t = target_get_raw_trace_data (buf,offset, 10);
 220                         if (t < 10)
 221                           error (_("Failure to get requested trace"
 222                                    " buffer data"));
 223
 224                         offset += 10;
 225                         block += 10;
 226
 227                         gotten = 0;
 228                         addr = (ULONGEST)
 229                           extract_unsigned_integer (buf, 8,
 230                                                     byte_order);
 231                         mlen = (unsigned short)
 232                           extract_unsigned_integer (&buf[8], 2,
 233                                                     byte_order);
 234
 235                         TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
 236                                                     mlen);
 237
 238                         /* The memory contents in 'M' block may be
 239                            very large.  Fetch the data from the target
 240                            and write them into file one by one.  */
 241                         for (j = 0; j < mlen; )
 242                           {
 243                             unsigned int read_length;
 244
 245                             if (mlen - j > MAX_TRACE_UPLOAD)
 246                               read_length = MAX_TRACE_UPLOAD;
 247                             else
 248                               read_length = mlen - j;
 249
 250                             t = target_get_raw_trace_data (buf,
 251                                                            offset + j,
 252                                                            read_length);
 253                             if (t < read_length)
 254                               error (_("Failure to get requested"
 255                                        " trace buffer data"));
 256
 257                             TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
 258                                                         read_length);
 259
 260                             j += read_length;
 261                             gotten += read_length;
 262                           }
 263
 264                         break;
 265                       }
 266                     case 'V':
 267                       {
 268                         int vnum;
 269                         LONGEST val;
 270
 271                         gotten
 272                           = target_get_raw_trace_data (buf, offset,
 273                                                        12);
 274                         if (gotten < 12)
 275                           error (_("Failure to get requested"
 276                                    " trace buffer data"));
 277
 278                         vnum  = (int) extract_signed_integer (buf,
 279                                                               4,
 280                                                               byte_order);
 281                         val
 282                           = extract_signed_integer (&buf[4], 8,
 283                                                     byte_order);
 284
 285                         TRACE_WRITE_V_BLOCK (writer, vnum, val);
 286                       }
 287                       break;
 288                     default:
 289                       error (_("Unknown block type '%c' (0x%x) in"
 290                                " trace frame"),
 291                              block_type, block_type);
 292                     }
 293
 294                   block += gotten;
 295                   offset += gotten;
 296                 }
 297             }
 298           else
 299             offset += gotten;
 300
 301           writer->ops->frame_ops->end (writer);
 302         }
 303     }
 304
 305   writer->ops->end (writer);
 306 }
 307
 308 static void
 309 tsave_command (const char *args, int from_tty)
 310 {
 311   int target_does_save = 0;
 312   char **argv;
 313   char *filename = NULL;
 314   struct cleanup *back_to;
 315   int generate_ctf = 0;
 316   struct trace_file_writer *writer = NULL;
 317
 318   if (args == NULL)
 319     error_no_arg (_("file in which to save trace data"));
 320
 321   gdb_argv built_argv (args);
 322   argv = built_argv.get ();
 323
 324   for (; *argv; ++argv)
 325     {
 326       if (strcmp (*argv, "-r") == 0)
 327         target_does_save = 1;
 328       else if (strcmp (*argv, "-ctf") == 0)
 329         generate_ctf = 1;
 330       else if (**argv == '-')
 331         error (_("unknown option `%s'"), *argv);
 332       else
 333         filename = *argv;
 334     }
 335
 336   if (!filename)
 337     error_no_arg (_("file in which to save trace data"));
 338
 339   if (generate_ctf)
 340     writer = ctf_trace_file_writer_new ();
 341   else
 342     writer = tfile_trace_file_writer_new ();
 343
 344   back_to = make_cleanup (trace_file_writer_xfree, writer);
 345
 346   trace_save (filename, writer, target_does_save);
 347
 348   if (from_tty)
 349     printf_filtered (_("Trace data saved to %s '%s'.\n"),
 350                      generate_ctf ? "directory" : "file", filename);
 351
 352   do_cleanups (back_to);
 353 }
 354
 355 /* Save the trace data to file FILENAME of tfile format.  */
 356
 357 void
 358 trace_save_tfile (const char *filename, int target_does_save)
 359 {
 360   struct trace_file_writer *writer;
 361   struct cleanup *back_to;
 362
 363   writer = tfile_trace_file_writer_new ();
 364   back_to = make_cleanup (trace_file_writer_xfree, writer);
 365   trace_save (filename, writer, target_does_save);
 366   do_cleanups (back_to);
 367 }
 368
 369 /* Save the trace data to dir DIRNAME of ctf format.  */
 370
 371 void
 372 trace_save_ctf (const char *dirname, int target_does_save)
 373 {
 374   struct trace_file_writer *writer;
 375   struct cleanup *back_to;
 376
 377   writer = ctf_trace_file_writer_new ();
 378   back_to = make_cleanup (trace_file_writer_xfree, writer);
 379
 380   trace_save (dirname, writer, target_does_save);
 381   do_cleanups (back_to);
 382 }
 383
 384 /* Fetch register data from tracefile, shared for both tfile and
 385    ctf.  */
 386
 387 void
 388 tracefile_fetch_registers (struct regcache *regcache, int regno)
 389 {
 390   struct gdbarch *gdbarch = regcache->arch ();
 391   struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
 392   int regn;
 393
 394   /* We get here if no register data has been found.  Mark registers
 395      as unavailable.  */
 396   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
 397     regcache->raw_supply (regn, NULL);
 398
 399   /* We can often usefully guess that the PC is going to be the same
 400      as the address of the tracepoint.  */
 401   if (tp == NULL || tp->loc == NULL)
 402     return;
 403
 404   /* But don't try to guess if tracepoint is multi-location...  */
 405   if (tp->loc->next)
 406     {
 407       warning (_("Tracepoint %d has multiple "
 408                  "locations, cannot infer $pc"),
 409                tp->number);
 410       return;
 411     }
 412   /* ... or does while-stepping.  */
 413   else if (tp->step_count > 0)
 414     {
 415       warning (_("Tracepoint %d does while-stepping, "
 416                  "cannot infer $pc"),
 417                tp->number);
 418       return;
 419     }
 420
 421   /* Guess what we can from the tracepoint location.  */
 422   gdbarch_guess_tracepoint_registers (gdbarch, regcache,
 423                                       tp->loc->address);
 424 }
 425
 426 /* This is the implementation of target_ops method to_has_all_memory.  */
 427
 428 bool
 429 tracefile_target::has_all_memory ()
 430 {
 431   return 1;
 432 }
 433
 434 /* This is the implementation of target_ops method to_has_memory.  */
 435
 436 bool
 437 tracefile_target::has_memory ()
 438 {
 439   return 1;
 440 }
 441
 442 /* This is the implementation of target_ops method to_has_stack.
 443    The target has a stack when GDB has already selected one trace
 444    frame.  */
 445
 446 bool
 447 tracefile_target::has_stack ()
 448 {
 449   return get_traceframe_number () != -1;
 450 }
 451
 452 /* This is the implementation of target_ops method to_has_registers.
 453    The target has registers when GDB has already selected one trace
 454    frame.  */
 455
 456 bool
 457 tracefile_target::has_registers ()
 458 {
 459   return get_traceframe_number () != -1;
 460 }
 461
 462 /* This is the implementation of target_ops method to_thread_alive.
 463    tracefile has one thread faked by GDB.  */
 464
 465 bool
 466 tracefile_target::thread_alive (ptid_t ptid)
 467 {
 468   return 1;
 469 }
 470
 471 /* This is the implementation of target_ops method to_get_trace_status.
 472    The trace status for a file is that tracing can never be run.  */
 473
 474 int
 475 tracefile_target::get_trace_status (struct trace_status *ts)
 476 {
 477   /* Other bits of trace status were collected as part of opening the
 478      trace files, so nothing to do here.  */
 479
 480   return -1;
 481 }
 482
 483 tracefile_target::tracefile_target ()
 484 {
 485   this->to_stratum = process_stratum;
 486 }
 487
 488 void
 489 _initialize_tracefile (void)
 490 {
 491   add_com ("tsave", class_trace, tsave_command, _("\
 492 Save the trace data to a file.\n\
 493 Use the '-ctf' option to save the data to CTF format.\n\
 494 Use the '-r' option to direct the target to save directly to the file,\n\
 495 using its own filesystem."));
 496 }