GDBserver
tracepoint.c
Go to the documentation of this file.
1 /* Tracepoint code for remote server for GDB.
2  Copyright (C) 2009-2015 Free Software Foundation, Inc.
3 
4  This file is part of GDB.
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 3 of the License, or
9  (at your option) any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with this program. If not, see <http://www.gnu.org/licenses/>. */
18 
19 #include "server.h"
20 #include "tracepoint.h"
21 #include "gdbthread.h"
22 #include "agent.h"
23 #include "rsp-low.h"
24 
25 #include <ctype.h>
26 #include <fcntl.h>
27 #include <unistd.h>
28 #include <sys/time.h>
29 #include <inttypes.h>
30 #include "ax.h"
31 #include "tdesc.h"
32 
33 #define DEFAULT_TRACE_BUFFER_SIZE 5242880 /* 5*1024*1024 */
34 
35 /* This file is built for both GDBserver, and the in-process
36  agent (IPA), a shared library that includes a tracing agent that is
37  loaded by the inferior to support fast tracepoints. Fast
38  tracepoints (or more accurately, jump based tracepoints) are
39  implemented by patching the tracepoint location with a jump into a
40  small trampoline function whose job is to save the register state,
41  call the in-process tracing agent, and then execute the original
42  instruction that was under the tracepoint jump (possibly adjusted,
43  if PC-relative, or some such).
44 
45  The current synchronization design is pull based. That means,
46  GDBserver does most of the work, by peeking/poking at the inferior
47  agent's memory directly for downloading tracepoint and associated
48  objects, and for uploading trace frames. Whenever the IPA needs
49  something from GDBserver (trace buffer is full, tracing stopped for
50  some reason, etc.) the IPA calls a corresponding hook function
51  where GDBserver has placed a breakpoint.
52 
53  Each of the agents has its own trace buffer. When browsing the
54  trace frames built from slow and fast tracepoints from GDB (tfind
55  mode), there's no guarantee the user is seeing the trace frames in
56  strict chronological creation order, although, GDBserver tries to
57  keep the order relatively reasonable, by syncing the trace buffers
58  at appropriate times.
59 
60 */
61 
62 #ifdef IN_PROCESS_AGENT
63 
64 static void trace_vdebug (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
65 
66 static void
67 trace_vdebug (const char *fmt, ...)
68 {
69  char buf[1024];
70  va_list ap;
71 
72  va_start (ap, fmt);
73  vsprintf (buf, fmt, ap);
74  fprintf (stderr, PROG "/tracepoint: %s\n", buf);
75  va_end (ap);
76 }
77 
78 #define trace_debug_1(level, fmt, args...) \
79  do { \
80  if (level <= debug_threads) \
81  trace_vdebug ((fmt), ##args); \
82  } while (0)
83 
84 #else
85 
86 #define trace_debug_1(level, fmt, args...) \
87  do { \
88  if (level <= debug_threads) \
89  { \
90  debug_printf ((fmt), ##args); \
91  debug_printf ("\n"); \
92  } \
93  } while (0)
94 
95 #endif
96 
97 #define trace_debug(FMT, args...) \
98  trace_debug_1 (1, FMT, ##args)
99 
100 /* Prefix exported symbols, for good citizenship. All the symbols
101  that need exporting are defined in this module. Note that all
102  these symbols must be tagged with IP_AGENT_EXPORT_*. */
103 #ifdef IN_PROCESS_AGENT
104 # define gdb_tp_heap_buffer IPA_SYM_EXPORTED_NAME (gdb_tp_heap_buffer)
105 # define gdb_jump_pad_buffer IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer)
106 # define gdb_jump_pad_buffer_end IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer_end)
107 # define gdb_trampoline_buffer IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer)
108 # define gdb_trampoline_buffer_end IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_end)
109 # define gdb_trampoline_buffer_error IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_error)
110 # define collecting IPA_SYM_EXPORTED_NAME (collecting)
111 # define gdb_collect IPA_SYM_EXPORTED_NAME (gdb_collect)
112 # define stop_tracing IPA_SYM_EXPORTED_NAME (stop_tracing)
113 # define flush_trace_buffer IPA_SYM_EXPORTED_NAME (flush_trace_buffer)
114 # define about_to_request_buffer_space IPA_SYM_EXPORTED_NAME (about_to_request_buffer_space)
115 # define trace_buffer_is_full IPA_SYM_EXPORTED_NAME (trace_buffer_is_full)
116 # define stopping_tracepoint IPA_SYM_EXPORTED_NAME (stopping_tracepoint)
117 # define expr_eval_result IPA_SYM_EXPORTED_NAME (expr_eval_result)
118 # define error_tracepoint IPA_SYM_EXPORTED_NAME (error_tracepoint)
119 # define tracepoints IPA_SYM_EXPORTED_NAME (tracepoints)
120 # define tracing IPA_SYM_EXPORTED_NAME (tracing)
121 # define trace_buffer_ctrl IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl)
122 # define trace_buffer_ctrl_curr IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl_curr)
123 # define trace_buffer_lo IPA_SYM_EXPORTED_NAME (trace_buffer_lo)
124 # define trace_buffer_hi IPA_SYM_EXPORTED_NAME (trace_buffer_hi)
125 # define traceframe_read_count IPA_SYM_EXPORTED_NAME (traceframe_read_count)
126 # define traceframe_write_count IPA_SYM_EXPORTED_NAME (traceframe_write_count)
127 # define traceframes_created IPA_SYM_EXPORTED_NAME (traceframes_created)
128 # define trace_state_variables IPA_SYM_EXPORTED_NAME (trace_state_variables)
129 # define get_raw_reg IPA_SYM_EXPORTED_NAME (get_raw_reg)
130 # define get_trace_state_variable_value \
131  IPA_SYM_EXPORTED_NAME (get_trace_state_variable_value)
132 # define set_trace_state_variable_value \
133  IPA_SYM_EXPORTED_NAME (set_trace_state_variable_value)
134 # define ust_loaded IPA_SYM_EXPORTED_NAME (ust_loaded)
135 # define helper_thread_id IPA_SYM_EXPORTED_NAME (helper_thread_id)
136 # define cmd_buf IPA_SYM_EXPORTED_NAME (cmd_buf)
137 #endif
138 
139 #ifndef IN_PROCESS_AGENT
140 
141 /* Addresses of in-process agent's symbols GDBserver cares about. */
142 
144 {
174 };
175 
176 static struct
177 {
178  const char *name;
179  int offset;
180  int required;
181 } symbol_list[] = {
182  IPA_SYM(gdb_tp_heap_buffer),
183  IPA_SYM(gdb_jump_pad_buffer),
184  IPA_SYM(gdb_jump_pad_buffer_end),
185  IPA_SYM(gdb_trampoline_buffer),
186  IPA_SYM(gdb_trampoline_buffer_end),
187  IPA_SYM(gdb_trampoline_buffer_error),
188  IPA_SYM(collecting),
189  IPA_SYM(gdb_collect),
191  IPA_SYM(flush_trace_buffer),
192  IPA_SYM(about_to_request_buffer_space),
193  IPA_SYM(trace_buffer_is_full),
194  IPA_SYM(stopping_tracepoint),
195  IPA_SYM(expr_eval_result),
196  IPA_SYM(error_tracepoint),
197  IPA_SYM(tracepoints),
198  IPA_SYM(tracing),
200  IPA_SYM(trace_buffer_ctrl_curr),
201  IPA_SYM(trace_buffer_lo),
202  IPA_SYM(trace_buffer_hi),
203  IPA_SYM(traceframe_read_count),
204  IPA_SYM(traceframe_write_count),
205  IPA_SYM(traceframes_created),
206  IPA_SYM(trace_state_variables),
207  IPA_SYM(get_raw_reg),
210  IPA_SYM(ust_loaded),
211 };
212 
214 
215 static int read_inferior_integer (CORE_ADDR symaddr, int *val);
216 
217 /* Returns true if both the in-process agent library and the static
218  tracepoints libraries are loaded in the inferior, and agent has
219  capability on static tracepoints. */
220 
221 static int
223 {
224  int loaded = 0;
225 
226  if (!agent_loaded_p ())
227  {
228  warning ("In-process agent not loaded");
229  return 0;
230  }
231 
233  {
234  /* Agent understands static tracepoint, then check whether UST is in
235  fact loaded in the inferior. */
237  {
238  warning ("Error reading ust_loaded in lib");
239  return 0;
240  }
241 
242  return loaded;
243  }
244  else
245  return 0;
246 }
247 
248 static void
250 {
251  sprintf (buffer,
252  "E.In-process agent library not loaded in process. "
253  "Fast and static tracepoints unavailable.");
254 }
255 
256 /* Write an error to BUFFER indicating that UST isn't loaded in the
257  inferior. */
258 
259 static void
261 {
262 #ifdef HAVE_UST
263  sprintf (buffer,
264  "E.UST library not loaded in process. "
265  "Static tracepoints unavailable.");
266 #else
267  sprintf (buffer, "E.GDBserver was built without static tracepoints support");
268 #endif
269 }
270 
271 /* If the in-process agent library isn't loaded in the inferior, write
272  an error to BUFFER, and return 1. Otherwise, return 0. */
273 
274 static int
276 {
277  if (!agent_loaded_p ())
278  {
279  write_e_ipa_not_loaded (buffer);
280  return 1;
281  }
282  return 0;
283 }
284 
285 /* If the in-process agent library and the ust (static tracepoints)
286  library aren't loaded in the inferior, write an error to BUFFER,
287  and return 1. Otherwise, return 0. */
288 
289 static int
291 {
292  if (!agent_loaded_p ())
293  {
294  write_e_ipa_not_loaded (buffer);
295  return 1;
296  }
297  else if (!in_process_agent_supports_ust ())
298  {
299  write_e_ust_not_loaded (buffer);
300  return 1;
301  }
302  return 0;
303 }
304 
305 /* Cache all future symbols that the tracepoints module might request.
306  We can not request symbols at arbitrary states in the remote
307  protocol, only when the client tells us that new symbols are
308  available. So when we load the in-process library, make sure to
309  check the entire list. */
310 
311 void
313 {
314  int i;
315 
316  if (agent_loaded_p ())
317  return;
318 
319  for (i = 0; i < sizeof (symbol_list) / sizeof (symbol_list[0]); i++)
320  {
321  CORE_ADDR *addrp =
322  (CORE_ADDR *) ((char *) &ipa_sym_addrs + symbol_list[i].offset);
323 
324  if (look_up_one_symbol (symbol_list[i].name, addrp, 1) == 0)
325  {
326  if (debug_threads)
327  debug_printf ("symbol `%s' not found\n", symbol_list[i].name);
328  return;
329  }
330  }
331 
332  agent_look_up_symbols (NULL);
333 }
334 
335 #endif
336 
337 /* GDBserver places a breakpoint on the IPA's version (which is a nop)
338  of the "stop_tracing" function. When this breakpoint is hit,
339  tracing stopped in the IPA for some reason. E.g., due to
340  tracepoint reaching the pass count, hitting conditional expression
341  evaluation error, etc.
342 
343  The IPA's trace buffer is never in circular tracing mode: instead,
344  GDBserver's is, and whenever the in-process buffer fills, it calls
345  "flush_trace_buffer", which triggers an internal breakpoint.
346  GDBserver reacts to this breakpoint by pulling the meanwhile
347  collected data. Old frames discarding is always handled on the
348  GDBserver side. */
349 
350 #ifdef IN_PROCESS_AGENT
351 int
352 read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
353 {
354  memcpy (myaddr, (void *) (uintptr_t) memaddr, len);
355  return 0;
356 }
357 
358 /* Call this in the functions where GDBserver places a breakpoint, so
359  that the compiler doesn't try to be clever and skip calling the
360  function at all. This is necessary, even if we tell the compiler
361  to not inline said functions. */
362 
363 #if defined(__GNUC__)
364 # define UNKNOWN_SIDE_EFFECTS() asm ("")
365 #else
366 # define UNKNOWN_SIDE_EFFECTS() do {} while (0)
367 #endif
368 
370 stop_tracing (void)
371 {
372  /* GDBserver places breakpoint here. */
373  UNKNOWN_SIDE_EFFECTS();
374 }
375 
377 flush_trace_buffer (void)
378 {
379  /* GDBserver places breakpoint here. */
380  UNKNOWN_SIDE_EFFECTS();
381 }
382 
383 #endif
384 
385 #ifndef IN_PROCESS_AGENT
386 static int
388 {
389  trace_debug ("tracepoint_handler: tracepoint at 0x%s hit",
390  paddress (address));
391  return 0;
392 }
393 
394 /* Breakpoint at "stop_tracing" in the inferior lib. */
396 static int stop_tracing_handler (CORE_ADDR);
397 
398 /* Breakpoint at "flush_trace_buffer" in the inferior lib. */
401 
402 static void download_trace_state_variables (void);
403 static void upload_fast_traceframes (void);
404 
405 static int run_inferior_command (char *cmd, int len);
406 
407 static int
408 read_inferior_integer (CORE_ADDR symaddr, int *val)
409 {
410  return read_inferior_memory (symaddr, (unsigned char *) val,
411  sizeof (*val));
412 }
413 
414 struct tracepoint;
415 static int tracepoint_send_agent (struct tracepoint *tpoint);
416 
417 static int
418 read_inferior_uinteger (CORE_ADDR symaddr, unsigned int *val)
419 {
420  return read_inferior_memory (symaddr, (unsigned char *) val,
421  sizeof (*val));
422 }
423 
424 static int
426 {
427  void *pval = (void *) (uintptr_t) val;
428  int ret;
429 
430  ret = read_inferior_memory (symaddr, (unsigned char *) &pval, sizeof (pval));
431  *val = (uintptr_t) pval;
432  return ret;
433 }
434 
435 static int
437 {
438  void *pval = (void *) (uintptr_t) val;
439  return write_inferior_memory (symaddr,
440  (unsigned char *) &pval, sizeof (pval));
441 }
442 
443 static int
445 {
446  return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
447 }
448 
449 static int
450 write_inferior_uinteger (CORE_ADDR symaddr, unsigned int val)
451 {
452  return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
453 }
454 
455 static CORE_ADDR target_malloc (ULONGEST size);
456 static int write_inferior_data_ptr (CORE_ADDR where, CORE_ADDR ptr);
457 
458 #define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD) \
459  do { \
460  memcpy (BUF, &(OBJ)->FIELD, sizeof ((OBJ)->FIELD)); \
461  BUF += sizeof ((OBJ)->FIELD); \
462  } while (0)
463 
464 #endif
465 
466 /* Operations on various types of tracepoint actions. */
467 
468 struct tracepoint_action;
469 
471 {
472  /* Download tracepoint action ACTION to IPA. Return the address of action
473  in IPA/inferior. */
474  CORE_ADDR (*download) (const struct tracepoint_action *action);
475 
476  /* Send ACTION to agent via command buffer started from BUFFER. Return
477  updated head of command buffer. */
478  char* (*send) (char *buffer, const struct tracepoint_action *action);
479 };
480 
481 /* Base action. Concrete actions inherit this. */
482 
484 {
485 #ifndef IN_PROCESS_AGENT
486  const struct tracepoint_action_ops *ops;
487 #endif
488  char type;
489 };
490 
491 /* An 'M' (collect memory) action. */
493 {
495 
498  int32_t basereg;
499 };
500 
501 /* An 'R' (collect registers) action. */
502 
504 {
506 };
507 
508 /* An 'X' (evaluate expression) action. */
509 
511 {
513 
514  struct agent_expr *expr;
515 };
516 
517 /* An 'L' (collect static trace data) action. */
519 {
521 };
522 
523 #ifndef IN_PROCESS_AGENT
524 static CORE_ADDR
526 {
527  int size_in_ipa = (sizeof (struct collect_memory_action)
528  - offsetof (struct tracepoint_action, type));
529  CORE_ADDR ipa_action = target_malloc (size_in_ipa);
530 
531  write_inferior_memory (ipa_action, (unsigned char *) &action->type,
532  size_in_ipa);
533 
534  return ipa_action;
535 }
536 static char *
537 m_tracepoint_action_send (char *buffer, const struct tracepoint_action *action)
538 {
539  struct collect_memory_action *maction
540  = (struct collect_memory_action *) action;
541 
542  COPY_FIELD_TO_BUF (buffer, maction, addr);
543  COPY_FIELD_TO_BUF (buffer, maction, len);
544  COPY_FIELD_TO_BUF (buffer, maction, basereg);
545 
546  return buffer;
547 }
548 
549 static const struct tracepoint_action_ops m_tracepoint_action_ops =
550 {
553 };
554 
555 static CORE_ADDR
557 {
558  int size_in_ipa = (sizeof (struct collect_registers_action)
559  - offsetof (struct tracepoint_action, type));
560  CORE_ADDR ipa_action = target_malloc (size_in_ipa);
561 
562  write_inferior_memory (ipa_action, (unsigned char *) &action->type,
563  size_in_ipa);
564 
565  return ipa_action;
566 }
567 
568 static char *
569 r_tracepoint_action_send (char *buffer, const struct tracepoint_action *action)
570 {
571  return buffer;
572 }
573 
574 static const struct tracepoint_action_ops r_tracepoint_action_ops =
575 {
578 };
579 
580 static CORE_ADDR download_agent_expr (struct agent_expr *expr);
581 
582 static CORE_ADDR
584 {
585  int size_in_ipa = (sizeof (struct eval_expr_action)
586  - offsetof (struct tracepoint_action, type));
587  CORE_ADDR ipa_action = target_malloc (size_in_ipa);
588  CORE_ADDR expr;
589 
590  write_inferior_memory (ipa_action, (unsigned char *) &action->type,
591  size_in_ipa);
592  expr = download_agent_expr (((struct eval_expr_action *)action)->expr);
593  write_inferior_data_ptr (ipa_action + offsetof (struct eval_expr_action, expr)
594  - offsetof (struct tracepoint_action, type),
595  expr);
596 
597  return ipa_action;
598 }
599 
600 /* Copy agent expression AEXPR to buffer pointed by P. If AEXPR is NULL,
601  copy 0 to P. Return updated header of buffer. */
602 
603 static char *
604 agent_expr_send (char *p, const struct agent_expr *aexpr)
605 {
606  /* Copy the length of condition first, and then copy its
607  content. */
608  if (aexpr == NULL)
609  {
610  memset (p, 0, 4);
611  p += 4;
612  }
613  else
614  {
615  memcpy (p, &aexpr->length, 4);
616  p +=4;
617 
618  memcpy (p, aexpr->bytes, aexpr->length);
619  p += aexpr->length;
620  }
621  return p;
622 }
623 
624 static char *
625 x_tracepoint_action_send ( char *buffer, const struct tracepoint_action *action)
626 {
627  struct eval_expr_action *eaction = (struct eval_expr_action *) action;
628 
629  return agent_expr_send (buffer, eaction->expr);
630 }
631 
632 static const struct tracepoint_action_ops x_tracepoint_action_ops =
633 {
636 };
637 
638 static CORE_ADDR
640 {
641  int size_in_ipa = (sizeof (struct collect_static_trace_data_action)
642  - offsetof (struct tracepoint_action, type));
643  CORE_ADDR ipa_action = target_malloc (size_in_ipa);
644 
645  write_inferior_memory (ipa_action, (unsigned char *) &action->type,
646  size_in_ipa);
647 
648  return ipa_action;
649 }
650 
651 static char *
652 l_tracepoint_action_send (char *buffer, const struct tracepoint_action *action)
653 {
654  return buffer;
655 }
656 
657 static const struct tracepoint_action_ops l_tracepoint_action_ops =
658 {
661 };
662 #endif
663 
664 /* This structure describes a piece of the source-level definition of
665  the tracepoint. The contents are not interpreted by the target,
666  but preserved verbatim for uploading upon reconnection. */
667 
669 {
670  /* The type of string, such as "cond" for a conditional. */
671  char *type;
672 
673  /* The source-level string itself. For the sake of target
674  debugging, we store it in plaintext, even though it is always
675  transmitted in hex. */
676  char *str;
677 
678  /* Link to the next one in the list. We link them in the order
679  received, in case some make up an ordered list of commands or
680  some such. */
682 };
683 
685 {
686  /* Trap based tracepoint. */
688 
689  /* A fast tracepoint implemented with a jump instead of a trap. */
691 
692  /* A static tracepoint, implemented by a program call into a tracing
693  library. */
695 };
696 
697 struct tracepoint_hit_ctx;
698 
699 typedef enum eval_result_type (*condfn) (struct tracepoint_hit_ctx *,
700  ULONGEST *);
701 
702 /* The definition of a tracepoint. */
703 
704 /* Tracepoints may have multiple locations, each at a different
705  address. This can occur with optimizations, template
706  instantiation, etc. Since the locations may be in different
707  scopes, the conditions and actions may be different for each
708  location. Our target version of tracepoints is more like GDB's
709  notion of "breakpoint locations", but we have almost nothing that
710  is not per-location, so we bother having two kinds of objects. The
711  key consequence is that numbers are not unique, and that it takes
712  both number and address to identify a tracepoint uniquely. */
713 
715 {
716  /* The number of the tracepoint, as specified by GDB. Several
717  tracepoint objects here may share a number. */
718  uint32_t number;
719 
720  /* Address at which the tracepoint is supposed to trigger. Several
721  tracepoints may share an address. */
723 
724  /* Tracepoint type. */
726 
727  /* True if the tracepoint is currently enabled. */
728  int8_t enabled;
729 
730  /* The number of single steps that will be performed after each
731  tracepoint hit. */
732  uint64_t step_count;
733 
734  /* The number of times the tracepoint may be hit before it will
735  terminate the entire tracing run. */
736  uint64_t pass_count;
737 
738  /* Pointer to the agent expression that is the tracepoint's
739  conditional, or NULL if the tracepoint is unconditional. */
740  struct agent_expr *cond;
741 
742  /* The list of actions to take when the tracepoint triggers. */
743  uint32_t numactions;
745 
746  /* Count of the times we've hit this tracepoint during the run.
747  Note that while-stepping steps are not counted as "hits". */
748  uint64_t hit_count;
749 
750  /* Cached sum of the sizes of traceframes created by this point. */
752 
754 
755  /* Link to the next tracepoint in the list. */
756  struct tracepoint *next;
757 
758 #ifndef IN_PROCESS_AGENT
759  /* The list of actions to take when the tracepoint triggers, in
760  string/packet form. */
761  char **actions_str;
762 
763  /* The collection of strings that describe the tracepoint as it was
764  entered into GDB. These are not used by the target, but are
765  reported back to GDB upon reconnection. */
767 
768  /* The number of bytes displaced by fast tracepoints. It may subsume
769  multiple instructions, for multi-byte fast tracepoints. This
770  field is only valid for fast tracepoints. */
771  uint32_t orig_size;
772 
773  /* Only for fast tracepoints. */
775 
776  /* Address range where the original instruction under a fast
777  tracepoint was relocated to. (_end is actually one byte past
778  the end). */
781 
782  /* The address range of the piece of the jump pad buffer that was
783  assigned to this fast tracepoint. (_end is actually one byte
784  past the end).*/
787 
788  /* The address range of the piece of the trampoline buffer that was
789  assigned to this fast tracepoint. (_end is actually one byte
790  past the end). */
793 
794  /* The list of actions to take while in a stepping loop. These
795  fields are only valid for patch-based tracepoints. */
798  /* Same, but in string/packet form. */
800 
801  /* Handle returned by the breakpoint or tracepoint module when we
802  inserted the trap or jump, or hooked into a static tracepoint.
803  NULL if we haven't inserted it yet. */
804  void *handle;
805 #endif
806 
807 };
808 
809 #ifndef IN_PROCESS_AGENT
810 
811 /* Given `while-stepping', a thread may be collecting data for more
812  than one tracepoint simultaneously. On the other hand, the same
813  tracepoint with a while-stepping action may be hit by more than one
814  thread simultaneously (but not quite, each thread could be handling
815  a different step). Each thread holds a list of these objects,
816  representing the current step of each while-stepping action being
817  collected. */
818 
820 {
821  struct wstep_state *next;
822 
823  /* The tracepoint number. */
825  /* The tracepoint's address. */
827 
828  /* The number of the current step in this 'while-stepping'
829  action. */
831 };
832 
833 #endif
834 
836 
837 /* The linked list of all tracepoints. Marked explicitly as used as
838  the in-process library doesn't use it for the fast tracepoints
839  support. */
841 
842 /* The first tracepoint to exceed its pass count. */
843 
845 
846 /* True if the trace buffer is full or otherwise no longer usable. */
847 
849 
850 /* The first error that occurred during expression evaluation. */
851 
853 
855 
856 #ifndef IN_PROCESS_AGENT
857 
858 /* Pointer to the last tracepoint in the list, new tracepoints are
859  linked in at the end. */
860 
862 
863 static const char *eval_result_names[] =
864  {
865  "terror:in the attic", /* this should never be reported */
866  "terror:empty expression",
867  "terror:empty stack",
868  "terror:stack overflow",
869  "terror:stack underflow",
870  "terror:unhandled opcode",
871  "terror:unrecognized opcode",
872  "terror:divide by zero"
873  };
874 
875 #endif
876 
877 /* The tracepoint in which the error occurred. */
878 
882 
884 {
885  /* This is the name of the variable as used in GDB. The target
886  doesn't use the name, but needs to have it for saving and
887  reconnection purposes. */
888  char *name;
889 
890  /* This number identifies the variable uniquely. Numbers may be
891  assigned either by the target (in the case of builtin variables),
892  or by GDB, and are presumed unique during the course of a trace
893  experiment. */
894  int number;
895 
896  /* The variable's initial value, a 64-bit signed integer always. */
898 
899  /* The variable's value, a 64-bit signed integer always. */
901 
902  /* Pointer to a getter function, used to supply computed values. */
903  LONGEST (*getter) (void);
904 
905  /* Link to the next variable. */
907 };
908 
909 /* Linked list of all trace state variables. */
910 
911 #ifdef IN_PROCESS_AGENT
912 struct trace_state_variable *alloced_trace_state_variables;
913 #endif
914 
916 
917 /* The results of tracing go into a fixed-size space known as the
918  "trace buffer". Because usage follows a limited number of
919  patterns, we manage it ourselves rather than with malloc. Basic
920  rules are that we create only one trace frame at a time, each is
921  variable in size, they are never moved once created, and we only
922  discard if we are doing a circular buffer, and then only the oldest
923  ones. Each trace frame includes its own size, so we don't need to
924  link them together, and the trace frame number is relative to the
925  first one, so we don't need to record numbers. A trace frame also
926  records the number of the tracepoint that created it. The data
927  itself is a series of blocks, each introduced by a single character
928  and with a defined format. Each type of block has enough
929  type/length info to allow scanners to jump quickly from one block
930  to the next without reading each byte in the block. */
931 
932 /* Trace buffer management would be simple - advance a free pointer
933  from beginning to end, then stop - were it not for the circular
934  buffer option, which is a useful way to prevent a trace run from
935  stopping prematurely because the buffer filled up. In the circular
936  case, the location of the first trace frame (trace_buffer_start)
937  moves as old trace frames are discarded. Also, since we grow trace
938  frames incrementally as actions are performed, we wrap around to
939  the beginning of the trace buffer. This is per-block, so each
940  block within a trace frame remains contiguous. Things get messy
941  when the wrapped-around trace frame is the one being discarded; the
942  free space ends up in two parts at opposite ends of the buffer. */
943 
944 #ifndef ATTR_PACKED
945 # if defined(__GNUC__)
946 # define ATTR_PACKED __attribute__ ((packed))
947 # else
948 # define ATTR_PACKED /* nothing */
949 # endif
950 #endif
951 
952 /* The data collected at a tracepoint hit. This object should be as
953  small as possible, since there may be a great many of them. We do
954  not need to keep a frame number, because they are all sequential
955  and there are no deletions; so the Nth frame in the buffer is
956  always frame number N. */
957 
959 {
960  /* Number of the tracepoint that collected this traceframe. A value
961  of 0 indicates the current end of the trace buffer. We make this
962  a 16-bit field because it's never going to happen that GDB's
963  numbering of tracepoints reaches 32,000. */
964  int tpnum : 16;
965 
966  /* The size of the data in this trace frame. We limit this to 32
967  bits, even on a 64-bit target, because it's just implausible that
968  one is validly going to collect 4 gigabytes of data at a single
969  tracepoint hit. */
970  unsigned int data_size : 32;
971 
972  /* The base of the trace data, which is contiguous from this point. */
973  unsigned char data[0];
974 
975 } ATTR_PACKED;
976 
977 /* The size of the EOB marker, in bytes. A traceframe with zeroed
978  fields (and no data) marks the end of trace data. */
979 #define TRACEFRAME_EOB_MARKER_SIZE offsetof (struct traceframe, data)
980 
981 /* The traceframe to be used as the source of data to send back to
982  GDB. A value of -1 means to get data from the live program. */
983 
984 int current_traceframe = -1;
985 
986 /* This flag is true if the trace buffer is circular, meaning that
987  when it fills, the oldest trace frames are discarded in order to
988  make room. */
989 
990 #ifndef IN_PROCESS_AGENT
992 #endif
993 
994 /* Size of the trace buffer. */
995 
997 
999 
1000 /* Pointer to the block of memory that traceframes all go into. */
1001 
1003 
1004 /* Pointer to the end of the trace buffer, more precisely to the byte
1005  after the end of the buffer. */
1006 
1008 
1010 
1011 /* Control structure holding the read/write/etc. pointers into the
1012  trace buffer. We need more than one of these to implement a
1013  transaction-like mechanism to garantees that both GDBserver and the
1014  in-process agent can try to change the trace buffer
1015  simultaneously. */
1016 
1018 {
1019  /* Pointer to the first trace frame in the buffer. In the
1020  non-circular case, this is equal to trace_buffer_lo, otherwise it
1021  moves around in the buffer. */
1022  unsigned char *start;
1023 
1024  /* Pointer to the free part of the trace buffer. Note that we clear
1025  several bytes at and after this pointer, so that traceframe
1026  scans/searches terminate properly. */
1027  unsigned char *free;
1028 
1029  /* Pointer to the byte after the end of the free part. Note that
1030  this may be smaller than trace_buffer_free in the circular case,
1031  and means that the free part is in two pieces. Initially it is
1032  equal to trace_buffer_hi, then is generally equivalent to
1033  trace_buffer_start. */
1034  unsigned char *end_free;
1035 
1036  /* Pointer to the wraparound. If not equal to trace_buffer_hi, then
1037  this is the point at which the trace data breaks, and resumes at
1038  trace_buffer_lo. */
1039  unsigned char *wrap;
1040 };
1041 
1042 /* Same as above, to be used by GDBserver when updating the in-process
1043  agent. */
1045 {
1046  uintptr_t start;
1047  uintptr_t free;
1048  uintptr_t end_free;
1049  uintptr_t wrap;
1050 };
1051 
1052 
1053 /* We have possibly both GDBserver and an inferior thread accessing
1054  the same IPA trace buffer memory. The IPA is the producer (tries
1055  to put new frames in the buffer), while GDBserver occasionally
1056  consumes them, that is, flushes the IPA's buffer into its own
1057  buffer. Both sides need to update the trace buffer control
1058  pointers (current head, tail, etc.). We can't use a global lock to
1059  synchronize the accesses, as otherwise we could deadlock GDBserver
1060  (if the thread holding the lock stops for a signal, say). So
1061  instead of that, we use a transaction scheme where GDBserver writes
1062  always prevail over the IPAs writes, and, we have the IPA detect
1063  the commit failure/overwrite, and retry the whole attempt. This is
1064  mainly implemented by having a global token object that represents
1065  who wrote last to the buffer control structure. We need to freeze
1066  any inferior writing to the buffer while GDBserver touches memory,
1067  so that the inferior can correctly detect that GDBserver had been
1068  there, otherwise, it could mistakingly think its commit was
1069  successful; that's implemented by simply having GDBserver set a
1070  breakpoint the inferior hits if it is the critical region.
1071 
1072  There are three cycling trace buffer control structure copies
1073  (buffer head, tail, etc.), with the token object including an index
1074  indicating which is current live copy. The IPA tentatively builds
1075  an updated copy in a non-current control structure, while GDBserver
1076  always clobbers the current version directly. The IPA then tries
1077  to atomically "commit" its version; if GDBserver clobbered the
1078  structure meanwhile, that will fail, and the IPA restarts the
1079  allocation process.
1080 
1081  Listing the step in further detail, we have:
1082 
1083  In-process agent (producer):
1084 
1085  - passes by `about_to_request_buffer_space' breakpoint/lock
1086 
1087  - reads current token, extracts current trace buffer control index,
1088  and starts tentatively updating the rightmost one (0->1, 1->2,
1089  2->0). Note that only one inferior thread is executing this code
1090  at any given time, due to an outer lock in the jump pads.
1091 
1092  - updates counters, and tries to commit the token.
1093 
1094  - passes by second `about_to_request_buffer_space' breakpoint/lock,
1095  leaving the sync region.
1096 
1097  - checks if the update was effective.
1098 
1099  - if trace buffer was found full, hits flush_trace_buffer
1100  breakpoint, and restarts later afterwards.
1101 
1102  GDBserver (consumer):
1103 
1104  - sets `about_to_request_buffer_space' breakpoint/lock.
1105 
1106  - updates the token unconditionally, using the current buffer
1107  control index, since it knows that the IP agent always writes to
1108  the rightmost, and due to the breakpoint, at most one IP thread
1109  can try to update the trace buffer concurrently to GDBserver, so
1110  there will be no danger of trace buffer control index wrap making
1111  the IPA write to the same index as GDBserver.
1112 
1113  - flushes the IP agent's trace buffer completely, and updates the
1114  current trace buffer control structure. GDBserver *always* wins.
1115 
1116  - removes the `about_to_request_buffer_space' breakpoint.
1117 
1118 The token is stored in the `trace_buffer_ctrl_curr' variable.
1119 Internally, it's bits are defined as:
1120 
1121  |-------------+-----+-------------+--------+-------------+--------------|
1122  | Bit offsets | 31 | 30 - 20 | 19 | 18-8 | 7-0 |
1123  |-------------+-----+-------------+--------+-------------+--------------|
1124  | What | GSB | PC (11-bit) | unused | CC (11-bit) | TBCI (8-bit) |
1125  |-------------+-----+-------------+--------+-------------+--------------|
1126 
1127  GSB - GDBserver Stamp Bit
1128  PC - Previous Counter
1129  CC - Current Counter
1130  TBCI - Trace Buffer Control Index
1131 
1132 
1133 An IPA update of `trace_buffer_ctrl_curr' does:
1134 
1135  - read CC from the current token, save as PC.
1136  - updates pointers
1137  - atomically tries to write PC+1,CC
1138 
1139 A GDBserver update of `trace_buffer_ctrl_curr' does:
1140 
1141  - reads PC and CC from the current token.
1142  - updates pointers
1143  - writes GSB,PC,CC
1144 */
1145 
1146 /* These are the bits of `trace_buffer_ctrl_curr' that are reserved
1147  for the counters described below. The cleared bits are used to
1148  hold the index of the items of the `trace_buffer_ctrl' array that
1149  is "current". */
1150 #define GDBSERVER_FLUSH_COUNT_MASK 0xfffffff0
1151 
1152 /* `trace_buffer_ctrl_curr' contains two counters. The `previous'
1153  counter, and the `current' counter. */
1154 
1155 #define GDBSERVER_FLUSH_COUNT_MASK_PREV 0x7ff00000
1156 #define GDBSERVER_FLUSH_COUNT_MASK_CURR 0x0007ff00
1157 
1158 /* When GDBserver update the IP agent's `trace_buffer_ctrl_curr', it
1159  always stamps this bit as set. */
1160 #define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
1161 
1162 #ifdef IN_PROCESS_AGENT
1164 IP_AGENT_EXPORT_VAR unsigned int trace_buffer_ctrl_curr;
1165 
1166 # define TRACE_BUFFER_CTRL_CURR \
1167  (trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
1168 
1169 #else
1170 
1171 /* The GDBserver side agent only needs one instance of this object, as
1172  it doesn't need to sync with itself. Define it as array anyway so
1173  that the rest of the code base doesn't need to care for the
1174  difference. */
1176 # define TRACE_BUFFER_CTRL_CURR 0
1177 #endif
1178 
1179 /* These are convenience macros used to access the current trace
1180  buffer control in effect. */
1181 #define trace_buffer_start (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].start)
1182 #define trace_buffer_free (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].free)
1183 #define trace_buffer_end_free \
1184  (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].end_free)
1185 #define trace_buffer_wrap (trace_buffer_ctrl[TRACE_BUFFER_CTRL_CURR].wrap)
1186 
1187 
1188 /* Macro that returns a pointer to the first traceframe in the buffer. */
1189 
1190 #define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start)
1191 
1192 /* Macro that returns a pointer to the next traceframe in the buffer.
1193  If the computed location is beyond the wraparound point, subtract
1194  the offset of the wraparound. */
1195 
1196 #define NEXT_TRACEFRAME_1(TF) \
1197  (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size)
1198 
1199 #define NEXT_TRACEFRAME(TF) \
1200  ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \
1201  - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \
1202  ? (trace_buffer_wrap - trace_buffer_lo) \
1203  : 0)))
1204 
1205 /* The difference between these counters represents the total number
1206  of complete traceframes present in the trace buffer. The IP agent
1207  writes to the write count, GDBserver writes to read count. */
1208 
1211 
1212 /* Convenience macro. */
1213 
1214 #define traceframe_count \
1215  ((unsigned int) (traceframe_write_count - traceframe_read_count))
1216 
1217 /* The count of all traceframes created in the current run, including
1218  ones that were discarded to make room. */
1219 
1221 
1222 #ifndef IN_PROCESS_AGENT
1223 
1224 /* Read-only regions are address ranges whose contents don't change,
1225  and so can be read from target memory even while looking at a trace
1226  frame. Without these, disassembly for instance will likely fail,
1227  because the program code is not usually collected into a trace
1228  frame. This data structure does not need to be very complicated or
1229  particularly efficient, it's only going to be used occasionally,
1230  and only by some commands. */
1231 
1233 {
1234  /* The bounds of the region. */
1236 
1237  /* Link to the next one. */
1239 };
1240 
1241 /* Linked list of readonly regions. This list stays in effect from
1242  one tstart to the next. */
1243 
1245 
1246 #endif
1247 
1248 /* The global that controls tracing overall. */
1249 
1251 
1252 #ifndef IN_PROCESS_AGENT
1253 
1254 /* Controls whether tracing should continue after GDB disconnects. */
1255 
1257 
1258 /* The reason for the last tracing run to have stopped. We initialize
1259  to a distinct string so that GDB can distinguish between "stopped
1260  after running" and "stopped because never run" cases. */
1261 
1262 static const char *tracing_stop_reason = "tnotrun";
1263 
1265 
1266 /* 64-bit timestamps for the trace run's start and finish, expressed
1267  in microseconds from the Unix epoch. */
1268 
1271 
1272 /* The (optional) user-supplied name of the user that started the run.
1273  This is an arbitrary string, and may be NULL. */
1274 
1276 
1277 /* Optional user-supplied text describing the run. This is
1278  an arbitrary string, and may be NULL. */
1279 
1281 
1282 /* Optional user-supplied text explaining a tstop command. This is an
1283  arbitrary string, and may be NULL. */
1284 
1286 
1287 #endif
1288 
1289 /* Functions local to this file. */
1290 
1291 /* Base "class" for tracepoint type specific data to be passed down to
1292  collect_data_at_tracepoint. */
1294 {
1296 };
1297 
1298 #ifdef IN_PROCESS_AGENT
1299 
1300 /* Fast/jump tracepoint specific data to be passed down to
1301  collect_data_at_tracepoint. */
1302 struct fast_tracepoint_ctx
1303 {
1304  struct tracepoint_hit_ctx base;
1305 
1306  struct regcache regcache;
1307  int regcache_initted;
1308  unsigned char *regspace;
1309 
1310  unsigned char *regs;
1311  struct tracepoint *tpoint;
1312 };
1313 
1314 /* Static tracepoint specific data to be passed down to
1315  collect_data_at_tracepoint. */
1316 struct static_tracepoint_ctx
1317 {
1318  struct tracepoint_hit_ctx base;
1319 
1320  /* The regcache corresponding to the registers state at the time of
1321  the tracepoint hit. Initialized lazily, from REGS. */
1322  struct regcache regcache;
1323  int regcache_initted;
1324 
1325  /* The buffer space REGCACHE above uses. We use a separate buffer
1326  instead of letting the regcache malloc for both signal safety and
1327  performance reasons; this is allocated on the stack instead. */
1328  unsigned char *regspace;
1329 
1330  /* The register buffer as passed on by lttng/ust. */
1331  struct registers *regs;
1332 
1333  /* The "printf" formatter and the args the user passed to the marker
1334  call. We use this to be able to collect "static trace data"
1335  ($_sdata). */
1336  const char *fmt;
1337  va_list *args;
1338 
1339  /* The GDB tracepoint matching the probed marker that was "hit". */
1340  struct tracepoint *tpoint;
1341 };
1342 
1343 #else
1344 
1345 /* Static tracepoint specific data to be passed down to
1346  collect_data_at_tracepoint. */
1348 {
1350 
1352 };
1353 
1354 #endif
1355 
1356 #ifndef IN_PROCESS_AGENT
1357 static CORE_ADDR traceframe_get_pc (struct traceframe *tframe);
1358 static int traceframe_read_tsv (int num, LONGEST *val);
1359 #endif
1360 
1361 static int condition_true_at_tracepoint (struct tracepoint_hit_ctx *ctx,
1362  struct tracepoint *tpoint);
1363 
1364 #ifndef IN_PROCESS_AGENT
1365 static void clear_readonly_regions (void);
1366 static void clear_installed_tracepoints (void);
1367 #endif
1368 
1369 static void collect_data_at_tracepoint (struct tracepoint_hit_ctx *ctx,
1370  CORE_ADDR stop_pc,
1371  struct tracepoint *tpoint);
1372 #ifndef IN_PROCESS_AGENT
1373 static void collect_data_at_step (struct tracepoint_hit_ctx *ctx,
1374  CORE_ADDR stop_pc,
1375  struct tracepoint *tpoint, int current_step);
1376 static void compile_tracepoint_condition (struct tracepoint *tpoint,
1377  CORE_ADDR *jump_entry);
1378 #endif
1379 static void do_action_at_tracepoint (struct tracepoint_hit_ctx *ctx,
1380  CORE_ADDR stop_pc,
1381  struct tracepoint *tpoint,
1382  struct traceframe *tframe,
1383  struct tracepoint_action *taction);
1384 
1385 #ifndef IN_PROCESS_AGENT
1387 
1388 static void install_tracepoint (struct tracepoint *, char *own_buf);
1389 static void download_tracepoint (struct tracepoint *);
1390 static int install_fast_tracepoint (struct tracepoint *, char *errbuf);
1391 static void clone_fast_tracepoint (struct tracepoint *to,
1392  const struct tracepoint *from);
1393 #endif
1394 
1395 static LONGEST get_timestamp (void);
1396 
1397 #if defined(__GNUC__)
1398 # define memory_barrier() asm volatile ("" : : : "memory")
1399 #else
1400 # define memory_barrier() do {} while (0)
1401 #endif
1402 
1403 /* We only build the IPA if this builtin is supported, and there are
1404  no uses of this in GDBserver itself, so we're safe in defining this
1405  unconditionally. */
1406 #define cmpxchg(mem, oldval, newval) \
1407  __sync_val_compare_and_swap (mem, oldval, newval)
1408 
1409 /* Record that an error occurred during expression evaluation. */
1410 
1411 static void
1412 record_tracepoint_error (struct tracepoint *tpoint, const char *which,
1413  enum eval_result_type rtype)
1414 {
1415  trace_debug ("Tracepoint %d at %s %s eval reports error %d",
1416  tpoint->number, paddress (tpoint->address), which, rtype);
1417 
1418 #ifdef IN_PROCESS_AGENT
1419  /* Only record the first error we get. */
1420  if (cmpxchg (&expr_eval_result,
1422  rtype) != expr_eval_no_error)
1423  return;
1424 #else
1425  if (expr_eval_result != expr_eval_no_error)
1426  return;
1427 #endif
1428 
1429  error_tracepoint = tpoint;
1430 }
1431 
1432 /* Trace buffer management. */
1433 
1434 static void
1436 {
1441  /* A traceframe with zeroed fields marks the end of trace data. */
1442  ((struct traceframe *) trace_buffer_free)->tpnum = 0;
1443  ((struct traceframe *) trace_buffer_free)->data_size = 0;
1444  traceframe_read_count = traceframe_write_count = 0;
1445  traceframes_created = 0;
1446 }
1447 
1448 #ifndef IN_PROCESS_AGENT
1449 
1450 static void
1452 {
1453  CORE_ADDR ipa_trace_buffer_lo;
1454  CORE_ADDR ipa_trace_buffer_hi;
1455  struct traceframe ipa_traceframe = { 0 };
1456  struct ipa_trace_buffer_control ipa_trace_buffer_ctrl;
1457 
1459  &ipa_trace_buffer_lo);
1461  &ipa_trace_buffer_hi);
1462 
1463  ipa_trace_buffer_ctrl.start = ipa_trace_buffer_lo;
1464  ipa_trace_buffer_ctrl.free = ipa_trace_buffer_lo;
1465  ipa_trace_buffer_ctrl.end_free = ipa_trace_buffer_hi;
1466  ipa_trace_buffer_ctrl.wrap = ipa_trace_buffer_hi;
1467 
1468  /* A traceframe with zeroed fields marks the end of trace data. */
1470  (unsigned char *) &ipa_trace_buffer_ctrl,
1471  sizeof (ipa_trace_buffer_ctrl));
1472 
1474 
1475  /* A traceframe with zeroed fields marks the end of trace data. */
1476  write_inferior_memory (ipa_trace_buffer_lo,
1477  (unsigned char *) &ipa_traceframe,
1478  sizeof (ipa_traceframe));
1479 
1483 }
1484 
1485 #endif
1486 
1487 static void
1489 {
1490  size_t alloc_size;
1491 
1492  trace_buffer_size = bufsize;
1493 
1494  /* Make sure to internally allocate at least space for the EOB
1495  marker. */
1496  alloc_size = (bufsize < TRACEFRAME_EOB_MARKER_SIZE
1497  ? TRACEFRAME_EOB_MARKER_SIZE : bufsize);
1498  trace_buffer_lo = xrealloc (trace_buffer_lo, alloc_size);
1499 
1500  trace_buffer_hi = trace_buffer_lo + trace_buffer_size;
1501 
1502  clear_trace_buffer ();
1503 }
1504 
1505 #ifdef IN_PROCESS_AGENT
1506 
1508 about_to_request_buffer_space (void)
1509 {
1510  /* GDBserver places breakpoint here while it goes about to flush
1511  data at random times. */
1512  UNKNOWN_SIDE_EFFECTS();
1513 }
1514 
1515 #endif
1516 
1517 /* Carve out a piece of the trace buffer, returning NULL in case of
1518  failure. */
1519 
1520 static void *
1522 {
1523  unsigned char *rslt;
1524  struct trace_buffer_control *tbctrl;
1525  unsigned int curr;
1526 #ifdef IN_PROCESS_AGENT
1527  unsigned int prev, prev_filtered;
1528  unsigned int commit_count;
1529  unsigned int commit;
1530  unsigned int readout;
1531 #else
1532  struct traceframe *oldest;
1533  unsigned char *new_start;
1534 #endif
1535 
1536  trace_debug ("Want to allocate %ld+%ld bytes in trace buffer",
1537  (long) amt, (long) sizeof (struct traceframe));
1538 
1539  /* Account for the EOB marker. */
1541 
1542 #ifdef IN_PROCESS_AGENT
1543  again:
1544  memory_barrier ();
1545 
1546  /* Read the current token and extract the index to try to write to,
1547  storing it in CURR. */
1548  prev = trace_buffer_ctrl_curr;
1549  prev_filtered = prev & ~GDBSERVER_FLUSH_COUNT_MASK;
1550  curr = prev_filtered + 1;
1551  if (curr > 2)
1552  curr = 0;
1553 
1554  about_to_request_buffer_space ();
1555 
1556  /* Start out with a copy of the current state. GDBserver may be
1557  midway writing to the PREV_FILTERED TBC, but, that's OK, we won't
1558  be able to commit anyway if that happens. */
1559  trace_buffer_ctrl[curr]
1560  = trace_buffer_ctrl[prev_filtered];
1561  trace_debug ("trying curr=%u", curr);
1562 #else
1563  /* The GDBserver's agent doesn't need all that syncing, and always
1564  updates TCB 0 (there's only one, mind you). */
1565  curr = 0;
1566 #endif
1567  tbctrl = &trace_buffer_ctrl[curr];
1568 
1569  /* Offsets are easier to grok for debugging than raw addresses,
1570  especially for the small trace buffer sizes that are useful for
1571  testing. */
1572  trace_debug ("Trace buffer [%d] start=%d free=%d endfree=%d wrap=%d hi=%d",
1573  curr,
1574  (int) (tbctrl->start - trace_buffer_lo),
1575  (int) (tbctrl->free - trace_buffer_lo),
1576  (int) (tbctrl->end_free - trace_buffer_lo),
1577  (int) (tbctrl->wrap - trace_buffer_lo),
1578  (int) (trace_buffer_hi - trace_buffer_lo));
1579 
1580  /* The algorithm here is to keep trying to get a contiguous block of
1581  the requested size, possibly discarding older traceframes to free
1582  up space. Since free space might come in one or two pieces,
1583  depending on whether discarded traceframes wrapped around at the
1584  high end of the buffer, we test both pieces after each
1585  discard. */
1586  while (1)
1587  {
1588  /* First, if we have two free parts, try the upper one first. */
1589  if (tbctrl->end_free < tbctrl->free)
1590  {
1591  if (tbctrl->free + amt <= trace_buffer_hi)
1592  /* We have enough in the upper part. */
1593  break;
1594  else
1595  {
1596  /* Our high part of free space wasn't enough. Give up
1597  on it for now, set wraparound. We will recover the
1598  space later, if/when the wrapped-around traceframe is
1599  discarded. */
1600  trace_debug ("Upper part too small, setting wraparound");
1601  tbctrl->wrap = tbctrl->free;
1602  tbctrl->free = trace_buffer_lo;
1603  }
1604  }
1605 
1606  /* The normal case. */
1607  if (tbctrl->free + amt <= tbctrl->end_free)
1608  break;
1609 
1610 #ifdef IN_PROCESS_AGENT
1611  /* The IP Agent's buffer is always circular. It isn't used
1612  currently, but `circular_trace_buffer' could represent
1613  GDBserver's mode. If we didn't find space, ask GDBserver to
1614  flush. */
1615 
1616  flush_trace_buffer ();
1617  memory_barrier ();
1618  if (tracing)
1619  {
1620  trace_debug ("gdbserver flushed buffer, retrying");
1621  goto again;
1622  }
1623 
1624  /* GDBserver cancelled the tracing. Bail out as well. */
1625  return NULL;
1626 #else
1627  /* If we're here, then neither part is big enough, and
1628  non-circular trace buffers are now full. */
1629  if (!circular_trace_buffer)
1630  {
1631  trace_debug ("Not enough space in the trace buffer");
1632  return NULL;
1633  }
1634 
1635  trace_debug ("Need more space in the trace buffer");
1636 
1637  /* If we have a circular buffer, we can try discarding the
1638  oldest traceframe and see if that helps. */
1639  oldest = FIRST_TRACEFRAME ();
1640  if (oldest->tpnum == 0)
1641  {
1642  /* Not good; we have no traceframes to free. Perhaps we're
1643  asking for a block that is larger than the buffer? In
1644  any case, give up. */
1645  trace_debug ("No traceframes to discard");
1646  return NULL;
1647  }
1648 
1649  /* We don't run this code in the in-process agent currently.
1650  E.g., we could leave the in-process agent in autonomous
1651  circular mode if we only have fast tracepoints. If we do
1652  that, then this bit becomes racy with GDBserver, which also
1653  writes to this counter. */
1655 
1656  new_start = (unsigned char *) NEXT_TRACEFRAME (oldest);
1657  /* If we freed the traceframe that wrapped around, go back
1658  to the non-wrap case. */
1659  if (new_start < tbctrl->start)
1660  {
1661  trace_debug ("Discarding past the wraparound");
1662  tbctrl->wrap = trace_buffer_hi;
1663  }
1664  tbctrl->start = new_start;
1665  tbctrl->end_free = tbctrl->start;
1666 
1667  trace_debug ("Discarded a traceframe\n"
1668  "Trace buffer [%d], start=%d free=%d "
1669  "endfree=%d wrap=%d hi=%d",
1670  curr,
1671  (int) (tbctrl->start - trace_buffer_lo),
1672  (int) (tbctrl->free - trace_buffer_lo),
1673  (int) (tbctrl->end_free - trace_buffer_lo),
1674  (int) (tbctrl->wrap - trace_buffer_lo),
1675  (int) (trace_buffer_hi - trace_buffer_lo));
1676 
1677  /* Now go back around the loop. The discard might have resulted
1678  in either one or two pieces of free space, so we want to try
1679  both before freeing any more traceframes. */
1680 #endif
1681  }
1682 
1683  /* If we get here, we know we can provide the asked-for space. */
1684 
1685  rslt = tbctrl->free;
1686 
1687  /* Adjust the request back down, now that we know we have space for
1688  the marker, but don't commit to AMT yet, we may still need to
1689  restart the operation if GDBserver touches the trace buffer
1690  (obviously only important in the in-process agent's version). */
1691  tbctrl->free += (amt - sizeof (struct traceframe));
1692 
1693  /* Or not. If GDBserver changed the trace buffer behind our back,
1694  we get to restart a new allocation attempt. */
1695 
1696 #ifdef IN_PROCESS_AGENT
1697  /* Build the tentative token. */
1698  commit_count = (((prev & GDBSERVER_FLUSH_COUNT_MASK_CURR) + 0x100)
1700  commit = (((prev & GDBSERVER_FLUSH_COUNT_MASK_CURR) << 12)
1701  | commit_count
1702  | curr);
1703 
1704  /* Try to commit it. */
1705  readout = cmpxchg (&trace_buffer_ctrl_curr, prev, commit);
1706  if (readout != prev)
1707  {
1708  trace_debug ("GDBserver has touched the trace buffer, restarting."
1709  " (prev=%08x, commit=%08x, readout=%08x)",
1710  prev, commit, readout);
1711  goto again;
1712  }
1713 
1714  /* Hold your horses here. Even if that change was committed,
1715  GDBserver could come in, and clobber it. We need to hold to be
1716  able to tell if GDBserver clobbers before or after we committed
1717  the change. Whenever GDBserver goes about touching the IPA
1718  buffer, it sets a breakpoint in this routine, so we have a sync
1719  point here. */
1720  about_to_request_buffer_space ();
1721 
1722  /* Check if the change has been effective, even if GDBserver stopped
1723  us at the breakpoint. */
1724 
1725  {
1726  unsigned int refetch;
1727 
1728  memory_barrier ();
1729 
1730  refetch = trace_buffer_ctrl_curr;
1731 
1732  if (refetch == commit
1733  || ((refetch & GDBSERVER_FLUSH_COUNT_MASK_PREV) >> 12) == commit_count)
1734  {
1735  /* effective */
1736  trace_debug ("change is effective: (prev=%08x, commit=%08x, "
1737  "readout=%08x, refetch=%08x)",
1738  prev, commit, readout, refetch);
1739  }
1740  else
1741  {
1742  trace_debug ("GDBserver has touched the trace buffer, not effective."
1743  " (prev=%08x, commit=%08x, readout=%08x, refetch=%08x)",
1744  prev, commit, readout, refetch);
1745  goto again;
1746  }
1747  }
1748 #endif
1749 
1750  /* We have a new piece of the trace buffer. Hurray! */
1751 
1752  /* Add an EOB marker just past this allocation. */
1753  ((struct traceframe *) tbctrl->free)->tpnum = 0;
1754  ((struct traceframe *) tbctrl->free)->data_size = 0;
1755 
1756  /* Adjust the request back down, now that we know we have space for
1757  the marker. */
1758  amt -= sizeof (struct traceframe);
1759 
1760  if (debug_threads)
1761  {
1762  trace_debug ("Allocated %d bytes", (int) amt);
1763  trace_debug ("Trace buffer [%d] start=%d free=%d "
1764  "endfree=%d wrap=%d hi=%d",
1765  curr,
1766  (int) (tbctrl->start - trace_buffer_lo),
1767  (int) (tbctrl->free - trace_buffer_lo),
1768  (int) (tbctrl->end_free - trace_buffer_lo),
1769  (int) (tbctrl->wrap - trace_buffer_lo),
1770  (int) (trace_buffer_hi - trace_buffer_lo));
1771  }
1772 
1773  return rslt;
1774 }
1775 
1776 #ifndef IN_PROCESS_AGENT
1777 
1778 /* Return the total free space. This is not necessarily the largest
1779  block we can allocate, because of the two-part case. */
1780 
1781 static int
1783 {
1786  else
1787  return ((trace_buffer_end_free - trace_buffer_lo)
1788  + (trace_buffer_hi - trace_buffer_free));
1789 }
1790 
1791 /* An 'S' in continuation packets indicates remainder are for
1792  while-stepping. */
1793 
1795 
1796 /* Create a tracepoint (location) with given number and address. Add this
1797  new tracepoint to list and sort this list. */
1798 
1799 static struct tracepoint *
1800 add_tracepoint (int num, CORE_ADDR addr)
1801 {
1802  struct tracepoint *tpoint, **tp_next;
1803 
1804  tpoint = xmalloc (sizeof (struct tracepoint));
1805  tpoint->number = num;
1806  tpoint->address = addr;
1807  tpoint->numactions = 0;
1808  tpoint->actions = NULL;
1809  tpoint->actions_str = NULL;
1810  tpoint->cond = NULL;
1811  tpoint->num_step_actions = 0;
1812  tpoint->step_actions = NULL;
1813  tpoint->step_actions_str = NULL;
1814  /* Start all off as regular (slow) tracepoints. */
1815  tpoint->type = trap_tracepoint;
1816  tpoint->orig_size = -1;
1817  tpoint->source_strings = NULL;
1818  tpoint->compiled_cond = 0;
1819  tpoint->handle = NULL;
1820  tpoint->next = NULL;
1821 
1822  /* Find a place to insert this tracepoint into list in order to keep
1823  the tracepoint list still in the ascending order. There may be
1824  multiple tracepoints at the same address as TPOINT's, and this
1825  guarantees TPOINT is inserted after all the tracepoints which are
1826  set at the same address. For example, fast tracepoints A, B, C are
1827  set at the same address, and D is to be insert at the same place as
1828  well,
1829 
1830  -->| A |--> | B |-->| C |->...
1831 
1832  One jump pad was created for tracepoint A, B, and C, and the target
1833  address of A is referenced/used in jump pad. So jump pad will let
1834  inferior jump to A. If D is inserted in front of A, like this,
1835 
1836  -->| D |-->| A |--> | B |-->| C |->...
1837 
1838  without updating jump pad, D is not reachable during collect, which
1839  is wrong. As we can see, the order of B, C and D doesn't matter, but
1840  A should always be the `first' one. */
1841  for (tp_next = &tracepoints;
1842  (*tp_next) != NULL && (*tp_next)->address <= tpoint->address;
1843  tp_next = &(*tp_next)->next)
1844  ;
1845  tpoint->next = *tp_next;
1846  *tp_next = tpoint;
1847  last_tracepoint = tpoint;
1848 
1849  seen_step_action_flag = 0;
1850 
1851  return tpoint;
1852 }
1853 
1854 #ifndef IN_PROCESS_AGENT
1855 
1856 /* Return the tracepoint with the given number and address, or NULL. */
1857 
1858 static struct tracepoint *
1860 {
1861  struct tracepoint *tpoint;
1862 
1863  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
1864  if (tpoint->number == id && tpoint->address == addr)
1865  return tpoint;
1866 
1867  return NULL;
1868 }
1869 
1870 /* Remove TPOINT from global list. */
1871 
1872 static void
1874 {
1875  struct tracepoint *tp, *tp_prev;
1876 
1877  for (tp = tracepoints, tp_prev = NULL; tp && tp != tpoint;
1878  tp_prev = tp, tp = tp->next)
1879  ;
1880 
1881  if (tp)
1882  {
1883  if (tp_prev)
1884  tp_prev->next = tp->next;
1885  else
1886  tracepoints = tp->next;
1887 
1888  xfree (tp);
1889  }
1890 }
1891 
1892 /* There may be several tracepoints with the same number (because they
1893  are "locations", in GDB parlance); return the next one after the
1894  given tracepoint, or search from the beginning of the list if the
1895  first argument is NULL. */
1896 
1897 static struct tracepoint *
1898 find_next_tracepoint_by_number (struct tracepoint *prev_tp, int num)
1899 {
1900  struct tracepoint *tpoint;
1901 
1902  if (prev_tp)
1903  tpoint = prev_tp->next;
1904  else
1905  tpoint = tracepoints;
1906  for (; tpoint; tpoint = tpoint->next)
1907  if (tpoint->number == num)
1908  return tpoint;
1909 
1910  return NULL;
1911 }
1912 
1913 #endif
1914 
1915 /* Append another action to perform when the tracepoint triggers. */
1916 
1917 static void
1918 add_tracepoint_action (struct tracepoint *tpoint, char *packet)
1919 {
1920  char *act;
1921 
1922  if (*packet == 'S')
1923  {
1924  seen_step_action_flag = 1;
1925  ++packet;
1926  }
1927 
1928  act = packet;
1929 
1930  while (*act)
1931  {
1932  char *act_start = act;
1933  struct tracepoint_action *action = NULL;
1934 
1935  switch (*act)
1936  {
1937  case 'M':
1938  {
1939  struct collect_memory_action *maction;
1940  ULONGEST basereg;
1941  int is_neg;
1942 
1943  maction = xmalloc (sizeof *maction);
1944  maction->base.type = *act;
1945  maction->base.ops = &m_tracepoint_action_ops;
1946  action = &maction->base;
1947 
1948  ++act;
1949  is_neg = (*act == '-');
1950  if (*act == '-')
1951  ++act;
1952  act = unpack_varlen_hex (act, &basereg);
1953  ++act;
1954  act = unpack_varlen_hex (act, &maction->addr);
1955  ++act;
1956  act = unpack_varlen_hex (act, &maction->len);
1957  maction->basereg = (is_neg
1958  ? - (int) basereg
1959  : (int) basereg);
1960  trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
1961  pulongest (maction->len),
1962  paddress (maction->addr), maction->basereg);
1963  break;
1964  }
1965  case 'R':
1966  {
1967  struct collect_registers_action *raction;
1968 
1969  raction = xmalloc (sizeof *raction);
1970  raction->base.type = *act;
1971  raction->base.ops = &r_tracepoint_action_ops;
1972  action = &raction->base;
1973 
1974  trace_debug ("Want to collect registers");
1975  ++act;
1976  /* skip past hex digits of mask for now */
1977  while (isxdigit(*act))
1978  ++act;
1979  break;
1980  }
1981  case 'L':
1982  {
1983  struct collect_static_trace_data_action *raction;
1984 
1985  raction = xmalloc (sizeof *raction);
1986  raction->base.type = *act;
1987  raction->base.ops = &l_tracepoint_action_ops;
1988  action = &raction->base;
1989 
1990  trace_debug ("Want to collect static trace data");
1991  ++act;
1992  break;
1993  }
1994  case 'S':
1995  trace_debug ("Unexpected step action, ignoring");
1996  ++act;
1997  break;
1998  case 'X':
1999  {
2000  struct eval_expr_action *xaction;
2001 
2002  xaction = xmalloc (sizeof (*xaction));
2003  xaction->base.type = *act;
2004  xaction->base.ops = &x_tracepoint_action_ops;
2005  action = &xaction->base;
2006 
2007  trace_debug ("Want to evaluate expression");
2008  xaction->expr = gdb_parse_agent_expr (&act);
2009  break;
2010  }
2011  default:
2012  trace_debug ("unknown trace action '%c', ignoring...", *act);
2013  break;
2014  case '-':
2015  break;
2016  }
2017 
2018  if (action == NULL)
2019  break;
2020 
2021  if (seen_step_action_flag)
2022  {
2023  tpoint->num_step_actions++;
2024 
2025  tpoint->step_actions
2026  = xrealloc (tpoint->step_actions,
2027  (sizeof (*tpoint->step_actions)
2028  * tpoint->num_step_actions));
2029  tpoint->step_actions_str
2030  = xrealloc (tpoint->step_actions_str,
2031  (sizeof (*tpoint->step_actions_str)
2032  * tpoint->num_step_actions));
2033  tpoint->step_actions[tpoint->num_step_actions - 1] = action;
2034  tpoint->step_actions_str[tpoint->num_step_actions - 1]
2035  = savestring (act_start, act - act_start);
2036  }
2037  else
2038  {
2039  tpoint->numactions++;
2040  tpoint->actions
2041  = xrealloc (tpoint->actions,
2042  sizeof (*tpoint->actions) * tpoint->numactions);
2043  tpoint->actions_str
2044  = xrealloc (tpoint->actions_str,
2045  sizeof (*tpoint->actions_str) * tpoint->numactions);
2046  tpoint->actions[tpoint->numactions - 1] = action;
2047  tpoint->actions_str[tpoint->numactions - 1]
2048  = savestring (act_start, act - act_start);
2049  }
2050  }
2051 }
2052 
2053 #endif
2054 
2055 /* Find or create a trace state variable with the given number. */
2056 
2057 static struct trace_state_variable *
2059 {
2060  struct trace_state_variable *tsv;
2061 
2062 #ifdef IN_PROCESS_AGENT
2063  /* Search for an existing variable. */
2064  for (tsv = alloced_trace_state_variables; tsv; tsv = tsv->next)
2065  if (tsv->number == num)
2066  return tsv;
2067 #endif
2068 
2069  /* Search for an existing variable. */
2070  for (tsv = trace_state_variables; tsv; tsv = tsv->next)
2071  if (tsv->number == num)
2072  return tsv;
2073 
2074  return NULL;
2075 }
2076 
2077 /* Find or create a trace state variable with the given number. */
2078 
2079 static struct trace_state_variable *
2081 {
2082  struct trace_state_variable *tsv;
2083 
2084  tsv = get_trace_state_variable (num);
2085  if (tsv != NULL)
2086  return tsv;
2087 
2088  /* Create a new variable. */
2089  tsv = xmalloc (sizeof (struct trace_state_variable));
2090  tsv->number = num;
2091  tsv->initial_value = 0;
2092  tsv->value = 0;
2093  tsv->getter = NULL;
2094  tsv->name = NULL;
2095 #ifdef IN_PROCESS_AGENT
2096  if (!gdb)
2097  {
2098  tsv->next = alloced_trace_state_variables;
2099  alloced_trace_state_variables = tsv;
2100  }
2101  else
2102 #endif
2103  {
2104  tsv->next = trace_state_variables;
2105  trace_state_variables = tsv;
2106  }
2107  return tsv;
2108 }
2109 
2112 {
2113  struct trace_state_variable *tsv;
2114 
2115  tsv = get_trace_state_variable (num);
2116 
2117  if (!tsv)
2118  {
2119  trace_debug ("No trace state variable %d, skipping value get", num);
2120  return 0;
2121  }
2122 
2123  /* Call a getter function if we have one. While it's tempting to
2124  set up something to only call the getter once per tracepoint hit,
2125  it could run afoul of thread races. Better to let the getter
2126  handle it directly, if necessary to worry about it. */
2127  if (tsv->getter)
2128  tsv->value = (tsv->getter) ();
2129 
2130  trace_debug ("get_trace_state_variable_value(%d) ==> %s",
2131  num, plongest (tsv->value));
2132 
2133  return tsv->value;
2134 }
2135 
2138 {
2139  struct trace_state_variable *tsv;
2140 
2141  tsv = get_trace_state_variable (num);
2142 
2143  if (!tsv)
2144  {
2145  trace_debug ("No trace state variable %d, skipping value set", num);
2146  return;
2147  }
2148 
2149  tsv->value = val;
2150 }
2151 
2152 LONGEST
2154 {
2155  return get_trace_state_variable_value (num);
2156 }
2157 
2158 void
2160 {
2161  set_trace_state_variable_value (num, val);
2162 }
2163 
2164 static void
2165 set_trace_state_variable_name (int num, const char *name)
2166 {
2167  struct trace_state_variable *tsv;
2168 
2169  tsv = get_trace_state_variable (num);
2170 
2171  if (!tsv)
2172  {
2173  trace_debug ("No trace state variable %d, skipping name set", num);
2174  return;
2175  }
2176 
2177  tsv->name = (char *) name;
2178 }
2179 
2180 static void
2182 {
2183  struct trace_state_variable *tsv;
2184 
2185  tsv = get_trace_state_variable (num);
2186 
2187  if (!tsv)
2188  {
2189  trace_debug ("No trace state variable %d, skipping getter set", num);
2190  return;
2191  }
2192 
2193  tsv->getter = getter;
2194 }
2195 
2196 /* Add a raw traceframe for the given tracepoint. */
2197 
2198 static struct traceframe *
2199 add_traceframe (struct tracepoint *tpoint)
2200 {
2201  struct traceframe *tframe;
2202 
2203  tframe = trace_buffer_alloc (sizeof (struct traceframe));
2204 
2205  if (tframe == NULL)
2206  return NULL;
2207 
2208  tframe->tpnum = tpoint->number;
2209  tframe->data_size = 0;
2210 
2211  return tframe;
2212 }
2213 
2214 /* Add a block to the traceframe currently being worked on. */
2215 
2216 static unsigned char *
2218  struct tracepoint *tpoint, int amt)
2219 {
2220  unsigned char *block;
2221 
2222  if (!tframe)
2223  return NULL;
2224 
2225  block = trace_buffer_alloc (amt);
2226 
2227  if (!block)
2228  return NULL;
2229 
2230  gdb_assert (tframe->tpnum == tpoint->number);
2231 
2232  tframe->data_size += amt;
2233  tpoint->traceframe_usage += amt;
2234 
2235  return block;
2236 }
2237 
2238 /* Flag that the current traceframe is finished. */
2239 
2240 static void
2242 {
2245 }
2246 
2247 #ifndef IN_PROCESS_AGENT
2248 
2249 /* Given a traceframe number NUM, find the NUMth traceframe in the
2250  buffer. */
2251 
2252 static struct traceframe *
2254 {
2255  struct traceframe *tframe;
2256  int tfnum = 0;
2257 
2258  for (tframe = FIRST_TRACEFRAME ();
2259  tframe->tpnum != 0;
2260  tframe = NEXT_TRACEFRAME (tframe))
2261  {
2262  if (tfnum == num)
2263  return tframe;
2264  ++tfnum;
2265  }
2266 
2267  return NULL;
2268 }
2269 
2270 static CORE_ADDR
2272 {
2273  CORE_ADDR addr;
2274  struct tracepoint *tpoint;
2275 
2276  addr = traceframe_get_pc (tframe);
2277 
2278  if (addr)
2279  return addr;
2280 
2281  /* Fallback strategy, will be incorrect for while-stepping frames
2282  and multi-location tracepoints. */
2283  tpoint = find_next_tracepoint_by_number (NULL, tframe->tpnum);
2284  return tpoint->address;
2285 }
2286 
2287 /* Search for the next traceframe whose address is inside or outside
2288  the given range. */
2289 
2290 static struct traceframe *
2292  int *tfnump)
2293 {
2294  struct traceframe *tframe;
2295  CORE_ADDR tfaddr;
2296 
2297  *tfnump = current_traceframe + 1;
2298  tframe = find_traceframe (*tfnump);
2299  /* The search is not supposed to wrap around. */
2300  if (!tframe)
2301  {
2302  *tfnump = -1;
2303  return NULL;
2304  }
2305 
2306  for (; tframe->tpnum != 0; tframe = NEXT_TRACEFRAME (tframe))
2307  {
2308  tfaddr = get_traceframe_address (tframe);
2309  if (inside_p
2310  ? (lo <= tfaddr && tfaddr <= hi)
2311  : (lo > tfaddr || tfaddr > hi))
2312  return tframe;
2313  ++*tfnump;
2314  }
2315 
2316  *tfnump = -1;
2317  return NULL;
2318 }
2319 
2320 /* Search for the next traceframe recorded by the given tracepoint.
2321  Note that for multi-location tracepoints, this will find whatever
2322  location appears first. */
2323 
2324 static struct traceframe *
2326 {
2327  struct traceframe *tframe;
2328 
2329  *tfnump = current_traceframe + 1;
2330  tframe = find_traceframe (*tfnump);
2331  /* The search is not supposed to wrap around. */
2332  if (!tframe)
2333  {
2334  *tfnump = -1;
2335  return NULL;
2336  }
2337 
2338  for (; tframe->tpnum != 0; tframe = NEXT_TRACEFRAME (tframe))
2339  {
2340  if (tframe->tpnum == num)
2341  return tframe;
2342  ++*tfnump;
2343  }
2344 
2345  *tfnump = -1;
2346  return NULL;
2347 }
2348 
2349 #endif
2350 
2351 #ifndef IN_PROCESS_AGENT
2352 
2353 /* Clear all past trace state. */
2354 
2355 static void
2356 cmd_qtinit (char *packet)
2357 {
2358  struct trace_state_variable *tsv, *prev, *next;
2359 
2360  /* Can't do this command without a pid attached. */
2361  if (current_thread == NULL)
2362  {
2363  write_enn (packet);
2364  return;
2365  }
2366 
2367  /* Make sure we don't try to read from a trace frame. */
2368  current_traceframe = -1;
2369 
2370  stop_tracing ();
2371 
2372  trace_debug ("Initializing the trace");
2373 
2376 
2377  tracepoints = NULL;
2378  last_tracepoint = NULL;
2379 
2380  /* Clear out any leftover trace state variables. Ones with target
2381  defined getters should be kept however. */
2382  prev = NULL;
2383  tsv = trace_state_variables;
2384  while (tsv)
2385  {
2386  trace_debug ("Looking at var %d", tsv->number);
2387  if (tsv->getter == NULL)
2388  {
2389  next = tsv->next;
2390  if (prev)
2391  prev->next = next;
2392  else
2393  trace_state_variables = next;
2394  trace_debug ("Deleting var %d", tsv->number);
2395  free (tsv);
2396  tsv = next;
2397  }
2398  else
2399  {
2400  prev = tsv;
2401  tsv = tsv->next;
2402  }
2403  }
2404 
2405  clear_trace_buffer ();
2407 
2408  write_ok (packet);
2409 }
2410 
2411 /* Unprobe the UST marker at ADDRESS. */
2412 
2413 static void
2415 {
2416  char cmd[IPA_CMD_BUF_SIZE];
2417 
2418  sprintf (cmd, "unprobe_marker_at:%s", paddress (address));
2419  run_inferior_command (cmd, strlen (cmd) + 1);
2420 }
2421 
2422 /* Restore the program to its pre-tracing state. This routine may be called
2423  in error situations, so it needs to be careful about only restoring
2424  from known-valid bits. */
2425 
2426 static void
2428 {
2429  struct tracepoint *tpoint;
2430  struct tracepoint *prev_stpoint;
2431 
2432  pause_all (1);
2433 
2434  prev_stpoint = NULL;
2435 
2436  /* Restore any bytes overwritten by tracepoints. */
2437  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
2438  {
2439  /* Catch the case where we might try to remove a tracepoint that
2440  was never actually installed. */
2441  if (tpoint->handle == NULL)
2442  {
2443  trace_debug ("Tracepoint %d at 0x%s was "
2444  "never installed, nothing to clear",
2445  tpoint->number, paddress (tpoint->address));
2446  continue;
2447  }
2448 
2449  switch (tpoint->type)
2450  {
2451  case trap_tracepoint:
2452  delete_breakpoint (tpoint->handle);
2453  break;
2454  case fast_tracepoint:
2456  break;
2457  case static_tracepoint:
2458  if (prev_stpoint != NULL
2459  && prev_stpoint->address == tpoint->address)
2460  /* Nothing to do. We already unprobed a tracepoint set at
2461  this marker address (and there can only be one probe
2462  per marker). */
2463  ;
2464  else
2465  {
2466  unprobe_marker_at (tpoint->address);
2467  prev_stpoint = tpoint;
2468  }
2469  break;
2470  }
2471 
2472  tpoint->handle = NULL;
2473  }
2474 
2475  unpause_all (1);
2476 }
2477 
2478 /* Parse a packet that defines a tracepoint. */
2479 
2480 static void
2482 {
2483  int tppacket;
2484  /* Whether there is a trailing hyphen at the end of the QTDP packet. */
2485  int trail_hyphen = 0;
2486  ULONGEST num;
2487  ULONGEST addr;
2488  ULONGEST count;
2489  struct tracepoint *tpoint;
2490  char *actparm;
2491  char *packet = own_buf;
2492 
2493  packet += strlen ("QTDP:");
2494 
2495  /* A hyphen at the beginning marks a packet specifying actions for a
2496  tracepoint already supplied. */
2497  tppacket = 1;
2498  if (*packet == '-')
2499  {
2500  tppacket = 0;
2501  ++packet;
2502  }
2503  packet = unpack_varlen_hex (packet, &num);
2504  ++packet; /* skip a colon */
2505  packet = unpack_varlen_hex (packet, &addr);
2506  ++packet; /* skip a colon */
2507 
2508  /* See if we already have this tracepoint. */
2509  tpoint = find_tracepoint (num, addr);
2510 
2511  if (tppacket)
2512  {
2513  /* Duplicate tracepoints are never allowed. */
2514  if (tpoint)
2515  {
2516  trace_debug ("Tracepoint error: tracepoint %d"
2517  " at 0x%s already exists",
2518  (int) num, paddress (addr));
2519  write_enn (own_buf);
2520  return;
2521  }
2522 
2523  tpoint = add_tracepoint (num, addr);
2524 
2525  tpoint->enabled = (*packet == 'E');
2526  ++packet; /* skip 'E' */
2527  ++packet; /* skip a colon */
2528  packet = unpack_varlen_hex (packet, &count);
2529  tpoint->step_count = count;
2530  ++packet; /* skip a colon */
2531  packet = unpack_varlen_hex (packet, &count);
2532  tpoint->pass_count = count;
2533  /* See if we have any of the additional optional fields. */
2534  while (*packet == ':')
2535  {
2536  ++packet;
2537  if (*packet == 'F')
2538  {
2539  tpoint->type = fast_tracepoint;
2540  ++packet;
2541  packet = unpack_varlen_hex (packet, &count);
2542  tpoint->orig_size = count;
2543  }
2544  else if (*packet == 'S')
2545  {
2546  tpoint->type = static_tracepoint;
2547  ++packet;
2548  }
2549  else if (*packet == 'X')
2550  {
2551  actparm = (char *) packet;
2552  tpoint->cond = gdb_parse_agent_expr (&actparm);
2553  packet = actparm;
2554  }
2555  else if (*packet == '-')
2556  break;
2557  else if (*packet == '\0')
2558  break;
2559  else
2560  trace_debug ("Unknown optional tracepoint field");
2561  }
2562  if (*packet == '-')
2563  {
2564  trail_hyphen = 1;
2565  trace_debug ("Also has actions\n");
2566  }
2567 
2568  trace_debug ("Defined %stracepoint %d at 0x%s, "
2569  "enabled %d step %" PRIu64 " pass %" PRIu64,
2570  tpoint->type == fast_tracepoint ? "fast "
2571  : tpoint->type == static_tracepoint ? "static " : "",
2572  tpoint->number, paddress (tpoint->address), tpoint->enabled,
2573  tpoint->step_count, tpoint->pass_count);
2574  }
2575  else if (tpoint)
2576  add_tracepoint_action (tpoint, packet);
2577  else
2578  {
2579  trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2580  (int) num, paddress (addr));
2581  write_enn (own_buf);
2582  return;
2583  }
2584 
2585  /* Install tracepoint during tracing only once for each tracepoint location.
2586  For each tracepoint loc, GDB may send multiple QTDP packets, and we can
2587  determine the last QTDP packet for one tracepoint location by checking
2588  trailing hyphen in QTDP packet. */
2589  if (tracing && !trail_hyphen)
2590  {
2591  struct tracepoint *tp = NULL;
2592 
2593  /* Pause all threads temporarily while we patch tracepoints. */
2594  pause_all (0);
2595 
2596  /* download_tracepoint will update global `tracepoints'
2597  list, so it is unsafe to leave threads in jump pad. */
2598  stabilize_threads ();
2599 
2600  /* Freeze threads. */
2601  pause_all (1);
2602 
2603 
2604  if (tpoint->type != trap_tracepoint)
2605  {
2606  /* Find another fast or static tracepoint at the same address. */
2607  for (tp = tracepoints; tp; tp = tp->next)
2608  {
2609  if (tp->address == tpoint->address && tp->type == tpoint->type
2610  && tp->number != tpoint->number)
2611  break;
2612  }
2613 
2614  /* TPOINT is installed at the same address as TP. */
2615  if (tp)
2616  {
2617  if (tpoint->type == fast_tracepoint)
2618  clone_fast_tracepoint (tpoint, tp);
2619  else if (tpoint->type == static_tracepoint)
2620  tpoint->handle = (void *) -1;
2621  }
2622  }
2623 
2624  if (use_agent && tpoint->type == fast_tracepoint
2626  {
2627  /* Download and install fast tracepoint by agent. */
2628  if (tracepoint_send_agent (tpoint) == 0)
2629  write_ok (own_buf);
2630  else
2631  {
2632  write_enn (own_buf);
2633  remove_tracepoint (tpoint);
2634  }
2635  }
2636  else
2637  {
2638  download_tracepoint (tpoint);
2639 
2640  if (tpoint->type == trap_tracepoint || tp == NULL)
2641  {
2642  install_tracepoint (tpoint, own_buf);
2643  if (strcmp (own_buf, "OK") != 0)
2644  remove_tracepoint (tpoint);
2645  }
2646  else
2647  write_ok (own_buf);
2648  }
2649 
2650  unpause_all (1);
2651  return;
2652  }
2653 
2654  write_ok (own_buf);
2655 }
2656 
2657 static void
2659 {
2660  ULONGEST num, addr, start, slen;
2661  struct tracepoint *tpoint;
2662  char *packet = own_buf;
2663  char *saved, *srctype, *src;
2664  size_t nbytes;
2665  struct source_string *last, *newlast;
2666 
2667  packet += strlen ("QTDPsrc:");
2668 
2669  packet = unpack_varlen_hex (packet, &num);
2670  ++packet; /* skip a colon */
2671  packet = unpack_varlen_hex (packet, &addr);
2672  ++packet; /* skip a colon */
2673 
2674  /* See if we already have this tracepoint. */
2675  tpoint = find_tracepoint (num, addr);
2676 
2677  if (!tpoint)
2678  {
2679  trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
2680  (int) num, paddress (addr));
2681  write_enn (own_buf);
2682  return;
2683  }
2684 
2685  saved = packet;
2686  packet = strchr (packet, ':');
2687  srctype = xmalloc (packet - saved + 1);
2688  memcpy (srctype, saved, packet - saved);
2689  srctype[packet - saved] = '\0';
2690  ++packet;
2691  packet = unpack_varlen_hex (packet, &start);
2692  ++packet; /* skip a colon */
2693  packet = unpack_varlen_hex (packet, &slen);
2694  ++packet; /* skip a colon */
2695  src = xmalloc (slen + 1);
2696  nbytes = hex2bin (packet, (gdb_byte *) src, strlen (packet) / 2);
2697  src[nbytes] = '\0';
2698 
2699  newlast = xmalloc (sizeof (struct source_string));
2700  newlast->type = srctype;
2701  newlast->str = src;
2702  newlast->next = NULL;
2703  /* Always add a source string to the end of the list;
2704  this keeps sequences of actions/commands in the right
2705  order. */
2706  if (tpoint->source_strings)
2707  {
2708  for (last = tpoint->source_strings; last->next; last = last->next)
2709  ;
2710  last->next = newlast;
2711  }
2712  else
2713  tpoint->source_strings = newlast;
2714 
2715  write_ok (own_buf);
2716 }
2717 
2718 static void
2720 {
2721  ULONGEST num, val, builtin;
2722  char *varname;
2723  size_t nbytes;
2724  struct trace_state_variable *tsv;
2725  char *packet = own_buf;
2726 
2727  packet += strlen ("QTDV:");
2728 
2729  packet = unpack_varlen_hex (packet, &num);
2730  ++packet; /* skip a colon */
2731  packet = unpack_varlen_hex (packet, &val);
2732  ++packet; /* skip a colon */
2733  packet = unpack_varlen_hex (packet, &builtin);
2734  ++packet; /* skip a colon */
2735 
2736  nbytes = strlen (packet) / 2;
2737  varname = xmalloc (nbytes + 1);
2738  nbytes = hex2bin (packet, (gdb_byte *) varname, nbytes);
2739  varname[nbytes] = '\0';
2740 
2741  tsv = create_trace_state_variable (num, 1);
2742  tsv->initial_value = (LONGEST) val;
2743  tsv->name = varname;
2744 
2746 
2747  write_ok (own_buf);
2748 }
2749 
2750 static void
2751 cmd_qtenable_disable (char *own_buf, int enable)
2752 {
2753  char *packet = own_buf;
2754  ULONGEST num, addr;
2755  struct tracepoint *tp;
2756 
2757  packet += strlen (enable ? "QTEnable:" : "QTDisable:");
2758  packet = unpack_varlen_hex (packet, &num);
2759  ++packet; /* skip a colon */
2760  packet = unpack_varlen_hex (packet, &addr);
2761 
2762  tp = find_tracepoint (num, addr);
2763 
2764  if (tp)
2765  {
2766  if ((enable && tp->enabled) || (!enable && !tp->enabled))
2767  {
2768  trace_debug ("Tracepoint %d at 0x%s is already %s",
2769  (int) num, paddress (addr),
2770  enable ? "enabled" : "disabled");
2771  write_ok (own_buf);
2772  return;
2773  }
2774 
2775  trace_debug ("%s tracepoint %d at 0x%s",
2776  enable ? "Enabling" : "Disabling",
2777  (int) num, paddress (addr));
2778 
2779  tp->enabled = enable;
2780 
2781  if (tp->type == fast_tracepoint || tp->type == static_tracepoint)
2782  {
2783  int ret;
2784  int offset = offsetof (struct tracepoint, enabled);
2785  CORE_ADDR obj_addr = tp->obj_addr_on_target + offset;
2786 
2787  ret = prepare_to_access_memory ();
2788  if (ret)
2789  {
2790  trace_debug ("Failed to temporarily stop inferior threads");
2791  write_enn (own_buf);
2792  return;
2793  }
2794 
2795  ret = write_inferior_integer (obj_addr, enable);
2797 
2798  if (ret)
2799  {
2800  trace_debug ("Cannot write enabled flag into "
2801  "inferior process memory");
2802  write_enn (own_buf);
2803  return;
2804  }
2805  }
2806 
2807  write_ok (own_buf);
2808  }
2809  else
2810  {
2811  trace_debug ("Tracepoint %d at 0x%s not found",
2812  (int) num, paddress (addr));
2813  write_enn (own_buf);
2814  }
2815 }
2816 
2817 static void
2819 {
2820  ULONGEST num;
2821  LONGEST val = 0;
2822  int err;
2823  char *packet = own_buf;
2824 
2825  packet += strlen ("qTV:");
2826  unpack_varlen_hex (packet, &num);
2827 
2828  if (current_traceframe >= 0)
2829  {
2830  err = traceframe_read_tsv ((int) num, &val);
2831  if (err)
2832  {
2833  strcpy (own_buf, "U");
2834  return;
2835  }
2836  }
2837  /* Only make tsv's be undefined before the first trace run. After a
2838  trace run is over, the user might want to see the last value of
2839  the tsv, and it might not be available in a traceframe. */
2840  else if (!tracing && strcmp (tracing_stop_reason, "tnotrun") == 0)
2841  {
2842  strcpy (own_buf, "U");
2843  return;
2844  }
2845  else
2846  val = get_trace_state_variable_value (num);
2847 
2848  sprintf (own_buf, "V%s", phex_nz (val, 0));
2849 }
2850 
2851 /* Clear out the list of readonly regions. */
2852 
2853 static void
2855 {
2856  struct readonly_region *roreg;
2857 
2858  while (readonly_regions)
2859  {
2860  roreg = readonly_regions;
2861  readonly_regions = readonly_regions->next;
2862  free (roreg);
2863  }
2864 }
2865 
2866 /* Parse the collection of address ranges whose contents GDB believes
2867  to be unchanging and so can be read directly from target memory
2868  even while looking at a traceframe. */
2869 
2870 static void
2872 {
2873  ULONGEST start, end;
2874  struct readonly_region *roreg;
2875  char *packet = own_buf;
2876 
2877  trace_debug ("Want to mark readonly regions");
2878 
2880 
2881  packet += strlen ("QTro");
2882 
2883  while (*packet == ':')
2884  {
2885  ++packet; /* skip a colon */
2886  packet = unpack_varlen_hex (packet, &start);
2887  ++packet; /* skip a comma */
2888  packet = unpack_varlen_hex (packet, &end);
2889  roreg = xmalloc (sizeof (struct readonly_region));
2890  roreg->start = start;
2891  roreg->end = end;
2892  roreg->next = readonly_regions;
2893  readonly_regions = roreg;
2894  trace_debug ("Added readonly region from 0x%s to 0x%s",
2895  paddress (roreg->start), paddress (roreg->end));
2896  }
2897 
2898  write_ok (own_buf);
2899 }
2900 
2901 /* Test to see if the given range is in our list of readonly ranges.
2902  We only test for being entirely within a range, GDB is not going to
2903  send a single memory packet that spans multiple regions. */
2904 
2905 int
2907 {
2908  struct readonly_region *roreg;
2909 
2910  for (roreg = readonly_regions; roreg; roreg = roreg->next)
2911  if (roreg->start <= addr && (addr + length - 1) <= roreg->end)
2912  return 1;
2913 
2914  return 0;
2915 }
2916 
2917 /* The maximum size of a jump pad entry. */
2918 static const int max_jump_pad_size = 0x100;
2919 
2921 
2922 /* Return the address of the next free jump space. */
2923 
2924 static CORE_ADDR
2926 {
2927  if (gdb_jump_pad_head == 0)
2928  {
2930  &gdb_jump_pad_head))
2931  {
2932  internal_error (__FILE__, __LINE__,
2933  "error extracting jump_pad_buffer");
2934  }
2935  }
2936 
2937  return gdb_jump_pad_head;
2938 }
2939 
2940 /* Reserve USED bytes from the jump space. */
2941 
2942 static void
2944 {
2945  trace_debug ("claim_jump_space reserves %s bytes at %s",
2946  pulongest (used), paddress (gdb_jump_pad_head));
2947  gdb_jump_pad_head += used;
2948 }
2949 
2950 static CORE_ADDR trampoline_buffer_head = 0;
2952 
2953 /* Reserve USED bytes from the trampoline buffer and return the
2954  address of the start of the reserved space in TRAMPOLINE. Returns
2955  non-zero if the space is successfully claimed. */
2956 
2957 int
2959 {
2960  if (!trampoline_buffer_head)
2961  {
2963  &trampoline_buffer_tail))
2964  {
2965  internal_error (__FILE__, __LINE__,
2966  "error extracting trampoline_buffer");
2967  }
2968 
2970  &trampoline_buffer_head))
2971  {
2972  internal_error (__FILE__, __LINE__,
2973  "error extracting trampoline_buffer_end");
2974  }
2975  }
2976 
2977  /* Start claiming space from the top of the trampoline space. If
2978  the space is located at the bottom of the virtual address space,
2979  this reduces the possibility that corruption will occur if a null
2980  pointer is used to write to memory. */
2981  if (trampoline_buffer_head - trampoline_buffer_tail < used)
2982  {
2983  trace_debug ("claim_trampoline_space failed to reserve %s bytes",
2984  pulongest (used));
2985  return 0;
2986  }
2987 
2988  trampoline_buffer_head -= used;
2989 
2990  trace_debug ("claim_trampoline_space reserves %s bytes at %s",
2991  pulongest (used), paddress (trampoline_buffer_head));
2992 
2993  *trampoline = trampoline_buffer_head;
2994  return 1;
2995 }
2996 
2997 /* Returns non-zero if there is space allocated for use in trampolines
2998  for fast tracepoints. */
2999 
3000 int
3002 {
3003  CORE_ADDR trampoline_end, errbuf;
3004 
3006  &trampoline_end))
3007  {
3008  internal_error (__FILE__, __LINE__,
3009  "error extracting trampoline_buffer_end");
3010  }
3011 
3012  if (buf)
3013  {
3014  buf[0] = '\0';
3015  strcpy (buf, "was claiming");
3017  &errbuf))
3018  {
3019  internal_error (__FILE__, __LINE__,
3020  "error extracting errbuf");
3021  }
3022 
3023  read_inferior_memory (errbuf, (unsigned char *) buf, 100);
3024  }
3025 
3026  return trampoline_end != 0;
3027 }
3028 
3029 /* Ask the IPA to probe the marker at ADDRESS. Returns -1 if running
3030  the command fails, or 0 otherwise. If the command ran
3031  successfully, but probing the marker failed, ERROUT will be filled
3032  with the error to reply to GDB, and -1 is also returned. This
3033  allows directly passing IPA errors to GDB. */
3034 
3035 static int
3036 probe_marker_at (CORE_ADDR address, char *errout)
3037 {
3038  char cmd[IPA_CMD_BUF_SIZE];
3039  int err;
3040 
3041  sprintf (cmd, "probe_marker_at:%s", paddress (address));
3042  err = run_inferior_command (cmd, strlen (cmd) + 1);
3043 
3044  if (err == 0)
3045  {
3046  if (*cmd == 'E')
3047  {
3048  strcpy (errout, cmd);
3049  return -1;
3050  }
3051  }
3052 
3053  return err;
3054 }
3055 
3056 static void
3057 clone_fast_tracepoint (struct tracepoint *to, const struct tracepoint *from)
3058 {
3059  to->jump_pad = from->jump_pad;
3060  to->jump_pad_end = from->jump_pad_end;
3061  to->trampoline = from->trampoline;
3062  to->trampoline_end = from->trampoline_end;
3065  to->handle = from->handle;
3066 
3067  gdb_assert (from->handle);
3069 }
3070 
3071 #define MAX_JUMP_SIZE 20
3072 
3073 /* Install fast tracepoint. Return 0 if successful, otherwise return
3074  non-zero. */
3075 
3076 static int
3077 install_fast_tracepoint (struct tracepoint *tpoint, char *errbuf)
3078 {
3079  CORE_ADDR jentry, jump_entry;
3080  CORE_ADDR trampoline;
3081  ULONGEST trampoline_size;
3082  int err = 0;
3083  /* The jump to the jump pad of the last fast tracepoint
3084  installed. */
3085  unsigned char fjump[MAX_JUMP_SIZE];
3086  ULONGEST fjump_size;
3087 
3089  {
3090  trace_debug ("Requested a fast tracepoint on an instruction "
3091  "that is of less than the minimum length.");
3092  return 0;
3093  }
3094 
3095  jentry = jump_entry = get_jump_space_head ();
3096 
3097  trampoline = 0;
3098  trampoline_size = 0;
3099 
3100  /* Install the jump pad. */
3102  tpoint->address,
3105  tpoint->orig_size,
3106  &jentry,
3107  &trampoline, &trampoline_size,
3108  fjump, &fjump_size,
3109  &tpoint->adjusted_insn_addr,
3110  &tpoint->adjusted_insn_addr_end,
3111  errbuf);
3112 
3113  if (err)
3114  return 1;
3115 
3116  /* Wire it in. */
3117  tpoint->handle = set_fast_tracepoint_jump (tpoint->address, fjump,
3118  fjump_size);
3119 
3120  if (tpoint->handle != NULL)
3121  {
3122  tpoint->jump_pad = jump_entry;
3123  tpoint->jump_pad_end = jentry;
3124  tpoint->trampoline = trampoline;
3125  tpoint->trampoline_end = trampoline + trampoline_size;
3126 
3127  /* Pad to 8-byte alignment. */
3128  jentry = ((jentry + 7) & ~0x7);
3129  claim_jump_space (jentry - jump_entry);
3130  }
3131 
3132  return 0;
3133 }
3134 
3135 
3136 /* Install tracepoint TPOINT, and write reply message in OWN_BUF. */
3137 
3138 static void
3139 install_tracepoint (struct tracepoint *tpoint, char *own_buf)
3140 {
3141  tpoint->handle = NULL;
3142  *own_buf = '\0';
3143 
3144  if (tpoint->type == trap_tracepoint)
3145  {
3146  /* Tracepoints are installed as memory breakpoints. Just go
3147  ahead and install the trap. The breakpoints module
3148  handles duplicated breakpoints, and the memory read
3149  routine handles un-patching traps from memory reads. */
3150  tpoint->handle = set_breakpoint_at (tpoint->address,
3152  }
3153  else if (tpoint->type == fast_tracepoint || tpoint->type == static_tracepoint)
3154  {
3155  if (!agent_loaded_p ())
3156  {
3157  trace_debug ("Requested a %s tracepoint, but fast "
3158  "tracepoints aren't supported.",
3159  tpoint->type == static_tracepoint ? "static" : "fast");
3160  write_e_ipa_not_loaded (own_buf);
3161  return;
3162  }
3163  if (tpoint->type == static_tracepoint
3165  {
3166  trace_debug ("Requested a static tracepoint, but static "
3167  "tracepoints are not supported.");
3168  write_e_ust_not_loaded (own_buf);
3169  return;
3170  }
3171 
3172  if (tpoint->type == fast_tracepoint)
3173  install_fast_tracepoint (tpoint, own_buf);
3174  else
3175  {
3176  if (probe_marker_at (tpoint->address, own_buf) == 0)
3177  tpoint->handle = (void *) -1;
3178  }
3179 
3180  }
3181  else
3182  internal_error (__FILE__, __LINE__, "Unknown tracepoint type");
3183 
3184  if (tpoint->handle == NULL)
3185  {
3186  if (*own_buf == '\0')
3187  write_enn (own_buf);
3188  }
3189  else
3190  write_ok (own_buf);
3191 }
3192 
3193 static void download_tracepoint_1 (struct tracepoint *tpoint);
3194 
3195 static void
3196 cmd_qtstart (char *packet)
3197 {
3198  struct tracepoint *tpoint, *prev_ftpoint, *prev_stpoint;
3199  CORE_ADDR tpptr = 0, prev_tpptr = 0;
3200 
3201  trace_debug ("Starting the trace");
3202 
3203  /* Pause all threads temporarily while we patch tracepoints. */
3204  pause_all (0);
3205 
3206  /* Get threads out of jump pads. Safe to do here, since this is a
3207  top level command. And, required to do here, since we're
3208  deleting/rewriting jump pads. */
3209 
3210  stabilize_threads ();
3211 
3212  /* Freeze threads. */
3213  pause_all (1);
3214 
3215  /* Sync the fast tracepoints list in the inferior ftlib. */
3216  if (agent_loaded_p ())
3218 
3219  /* No previous fast tpoint yet. */
3220  prev_ftpoint = NULL;
3221 
3222  /* No previous static tpoint yet. */
3223  prev_stpoint = NULL;
3224 
3225  *packet = '\0';
3226 
3227  /* Start out empty. */
3228  if (agent_loaded_p ())
3230 
3231  /* Download and install tracepoints. */
3232  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
3233  {
3234  /* Ensure all the hit counts start at zero. */
3235  tpoint->hit_count = 0;
3236  tpoint->traceframe_usage = 0;
3237 
3238  if (tpoint->type == trap_tracepoint)
3239  {
3240  /* Tracepoints are installed as memory breakpoints. Just go
3241  ahead and install the trap. The breakpoints module
3242  handles duplicated breakpoints, and the memory read
3243  routine handles un-patching traps from memory reads. */
3244  tpoint->handle = set_breakpoint_at (tpoint->address,
3246  }
3247  else if (tpoint->type == fast_tracepoint
3248  || tpoint->type == static_tracepoint)
3249  {
3250  if (maybe_write_ipa_not_loaded (packet))
3251  {
3252  trace_debug ("Requested a %s tracepoint, but fast "
3253  "tracepoints aren't supported.",
3254  tpoint->type == static_tracepoint
3255  ? "static" : "fast");
3256  break;
3257  }
3258 
3259  if (tpoint->type == fast_tracepoint)
3260  {
3261  int use_agent_p
3263 
3264  if (prev_ftpoint != NULL
3265  && prev_ftpoint->address == tpoint->address)
3266  {
3267  if (use_agent_p)
3268  tracepoint_send_agent (tpoint);
3269  else
3270  download_tracepoint_1 (tpoint);
3271 
3272  clone_fast_tracepoint (tpoint, prev_ftpoint);
3273  }
3274  else
3275  {
3276  /* Tracepoint is installed successfully? */
3277  int installed = 0;
3278 
3279  /* Download and install fast tracepoint by agent. */
3280  if (use_agent_p)
3281  installed = !tracepoint_send_agent (tpoint);
3282  else
3283  {
3284  download_tracepoint_1 (tpoint);
3285  installed = !install_fast_tracepoint (tpoint, packet);
3286  }
3287 
3288  if (installed)
3289  prev_ftpoint = tpoint;
3290  }
3291  }
3292  else
3293  {
3295  {
3296  trace_debug ("Requested a static tracepoint, but static "
3297  "tracepoints are not supported.");
3298  break;
3299  }
3300 
3301  download_tracepoint_1 (tpoint);
3302  /* Can only probe a given marker once. */
3303  if (prev_stpoint != NULL
3304  && prev_stpoint->address == tpoint->address)
3305  tpoint->handle = (void *) -1;
3306  else
3307  {
3308  if (probe_marker_at (tpoint->address, packet) == 0)
3309  {
3310  tpoint->handle = (void *) -1;
3311 
3312  /* So that we can handle multiple static tracepoints
3313  at the same address easily. */
3314  prev_stpoint = tpoint;
3315  }
3316  }
3317  }
3318 
3319  prev_tpptr = tpptr;
3320  tpptr = tpoint->obj_addr_on_target;
3321 
3322  if (tpoint == tracepoints)
3323  /* First object in list, set the head pointer in the
3324  inferior. */
3326  else
3327  write_inferior_data_ptr (prev_tpptr + offsetof (struct tracepoint,
3328  next),
3329  tpptr);
3330  }
3331 
3332  /* Any failure in the inner loop is sufficient cause to give
3333  up. */
3334  if (tpoint->handle == NULL)
3335  break;
3336  }
3337 
3338  /* Any error in tracepoint insertion is unacceptable; better to
3339  address the problem now, than end up with a useless or misleading
3340  trace run. */
3341  if (tpoint != NULL)
3342  {
3344  if (*packet == '\0')
3345  write_enn (packet);
3346  unpause_all (1);
3347  return;
3348  }
3349 
3350  stopping_tracepoint = NULL;
3351  trace_buffer_is_full = 0;
3352  expr_eval_result = expr_eval_no_error;
3353  error_tracepoint = NULL;
3354  tracing_start_time = get_timestamp ();
3355 
3356  /* Tracing is now active, hits will now start being logged. */
3357  tracing = 1;
3358 
3359  if (agent_loaded_p ())
3360  {
3362  {
3363  internal_error (__FILE__, __LINE__,
3364  "Error setting tracing variable in lib");
3365  }
3366 
3368  0))
3369  {
3370  internal_error (__FILE__, __LINE__,
3371  "Error clearing stopping_tracepoint variable"
3372  " in lib");
3373  }
3374 
3376  {
3377  internal_error (__FILE__, __LINE__,
3378  "Error clearing trace_buffer_is_full variable"
3379  " in lib");
3380  }
3381 
3382  stop_tracing_bkpt = set_breakpoint_at (ipa_sym_addrs.addr_stop_tracing,
3384  if (stop_tracing_bkpt == NULL)
3385  error ("Error setting stop_tracing breakpoint");
3386 
3387  flush_trace_buffer_bkpt
3390  if (flush_trace_buffer_bkpt == NULL)
3391  error ("Error setting flush_trace_buffer breakpoint");
3392  }
3393 
3394  unpause_all (1);
3395 
3396  write_ok (packet);
3397 }
3398 
3399 /* End a tracing run, filling in a stop reason to report back to GDB,
3400  and removing the tracepoints from the code. */
3401 
3402 void
3404 {
3405  if (!tracing)
3406  {
3407  trace_debug ("Tracing is already off, ignoring");
3408  return;
3409  }
3410 
3411  trace_debug ("Stopping the trace");
3412 
3413  /* Pause all threads before removing fast jumps from memory,
3414  breakpoints, and touching IPA state variables (inferior memory).
3415  Some thread may hit the internal tracing breakpoints, or be
3416  collecting this moment, but that's ok, we don't release the
3417  tpoint object's memory or the jump pads here (we only do that
3418  when we're sure we can move all threads out of the jump pads).
3419  We can't now, since we may be getting here due to the inferior
3420  agent calling us. */
3421  pause_all (1);
3422 
3423  /* Stop logging. Tracepoints can still be hit, but they will not be
3424  recorded. */
3425  tracing = 0;
3426  if (agent_loaded_p ())
3427  {
3429  {
3430  internal_error (__FILE__, __LINE__,
3431  "Error clearing tracing variable in lib");
3432  }
3433  }
3434 
3435  tracing_stop_time = get_timestamp ();
3436  tracing_stop_reason = "t???";
3437  tracing_stop_tpnum = 0;
3438  if (stopping_tracepoint)
3439  {
3440  trace_debug ("Stopping the trace because "
3441  "tracepoint %d was hit %" PRIu64 " times",
3442  stopping_tracepoint->number,
3443  stopping_tracepoint->pass_count);
3444  tracing_stop_reason = "tpasscount";
3445  tracing_stop_tpnum = stopping_tracepoint->number;
3446  }
3447  else if (trace_buffer_is_full)
3448  {
3449  trace_debug ("Stopping the trace because the trace buffer is full");
3450  tracing_stop_reason = "tfull";
3451  }
3452  else if (expr_eval_result != expr_eval_no_error)
3453  {
3454  trace_debug ("Stopping the trace because of an expression eval error");
3455  tracing_stop_reason = eval_result_names[expr_eval_result];
3456  tracing_stop_tpnum = error_tracepoint->number;
3457  }
3458 #ifndef IN_PROCESS_AGENT
3459  else if (!gdb_connected ())
3460  {
3461  trace_debug ("Stopping the trace because GDB disconnected");
3462  tracing_stop_reason = "tdisconnected";
3463  }
3464 #endif
3465  else
3466  {
3467  trace_debug ("Stopping the trace because of a tstop command");
3468  tracing_stop_reason = "tstop";
3469  }
3470 
3471  stopping_tracepoint = NULL;
3472  error_tracepoint = NULL;
3473 
3474  /* Clear out the tracepoints. */
3476 
3477  if (agent_loaded_p ())
3478  {
3479  /* Pull in fast tracepoint trace frames from the inferior lib
3480  buffer into our buffer, even if our buffer is already full,
3481  because we want to present the full number of created frames
3482  in addition to what fit in the trace buffer. */
3484  }
3485 
3486  if (stop_tracing_bkpt != NULL)
3487  {
3488  delete_breakpoint (stop_tracing_bkpt);
3489  stop_tracing_bkpt = NULL;
3490  }
3491 
3492  if (flush_trace_buffer_bkpt != NULL)
3493  {
3494  delete_breakpoint (flush_trace_buffer_bkpt);
3495  flush_trace_buffer_bkpt = NULL;
3496  }
3497 
3498  unpause_all (1);
3499 }
3500 
3501 static int
3503 {
3504  trace_debug ("lib hit stop_tracing");
3505 
3506  /* Don't actually handle it here. When we stop tracing we remove
3507  breakpoints from the inferior, and that is not allowed in a
3508  breakpoint handler (as the caller is walking the breakpoint
3509  list). */
3510  return 0;
3511 }
3512 
3513 static int
3515 {
3516  trace_debug ("lib hit flush_trace_buffer");
3517  return 0;
3518 }
3519 
3520 static void
3521 cmd_qtstop (char *packet)
3522 {
3523  stop_tracing ();
3524  write_ok (packet);
3525 }
3526 
3527 static void
3529 {
3530  ULONGEST setting;
3531  char *packet = own_buf;
3532 
3533  packet += strlen ("QTDisconnected:");
3534 
3535  unpack_varlen_hex (packet, &setting);
3536 
3537  write_ok (own_buf);
3538 
3539  disconnected_tracing = setting;
3540 }
3541 
3542 static void
3544 {
3545  ULONGEST frame, pc, lo, hi, num;
3546  int tfnum, tpnum;
3547  struct traceframe *tframe;
3548  char *packet = own_buf;
3549 
3550  packet += strlen ("QTFrame:");
3551 
3552  if (startswith (packet, "pc:"))
3553  {
3554  packet += strlen ("pc:");
3555  unpack_varlen_hex (packet, &pc);
3556  trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc));
3557  tframe = find_next_traceframe_in_range (pc, pc, 1, &tfnum);
3558  }
3559  else if (startswith (packet, "range:"))
3560  {
3561  packet += strlen ("range:");
3562  packet = unpack_varlen_hex (packet, &lo);
3563  ++packet;
3564  unpack_varlen_hex (packet, &hi);
3565  trace_debug ("Want to find next traceframe in the range 0x%s to 0x%s",
3566  paddress (lo), paddress (hi));
3567  tframe = find_next_traceframe_in_range (lo, hi, 1, &tfnum);
3568  }
3569  else if (startswith (packet, "outside:"))
3570  {
3571  packet += strlen ("outside:");
3572  packet = unpack_varlen_hex (packet, &lo);
3573  ++packet;
3574  unpack_varlen_hex (packet, &hi);
3575  trace_debug ("Want to find next traceframe "
3576  "outside the range 0x%s to 0x%s",
3577  paddress (lo), paddress (hi));
3578  tframe = find_next_traceframe_in_range (lo, hi, 0, &tfnum);
3579  }
3580  else if (startswith (packet, "tdp:"))
3581  {
3582  packet += strlen ("tdp:");
3583  unpack_varlen_hex (packet, &num);
3584  tpnum = (int) num;
3585  trace_debug ("Want to find next traceframe for tracepoint %d", tpnum);
3586  tframe = find_next_traceframe_by_tracepoint (tpnum, &tfnum);
3587  }
3588  else
3589  {
3590  unpack_varlen_hex (packet, &frame);
3591  tfnum = (int) frame;
3592  if (tfnum == -1)
3593  {
3594  trace_debug ("Want to stop looking at traceframes");
3595  current_traceframe = -1;
3596  write_ok (own_buf);
3597  return;
3598  }
3599  trace_debug ("Want to look at traceframe %d", tfnum);
3600  tframe = find_traceframe (tfnum);
3601  }
3602 
3603  if (tframe)
3604  {
3605  current_traceframe = tfnum;
3606  sprintf (own_buf, "F%xT%x", tfnum, tframe->tpnum);
3607  }
3608  else
3609  sprintf (own_buf, "F-1");
3610 }
3611 
3612 static void
3613 cmd_qtstatus (char *packet)
3614 {
3615  char *stop_reason_rsp = NULL;
3616  char *buf1, *buf2, *buf3;
3617  const char *str;
3618  int slen;
3619 
3620  /* Translate the plain text of the notes back into hex for
3621  transmission. */
3622 
3623  str = (tracing_user_name ? tracing_user_name : "");
3624  slen = strlen (str);
3625  buf1 = (char *) alloca (slen * 2 + 1);
3626  bin2hex ((gdb_byte *) str, buf1, slen);
3627 
3628  str = (tracing_notes ? tracing_notes : "");
3629  slen = strlen (str);
3630  buf2 = (char *) alloca (slen * 2 + 1);
3631  bin2hex ((gdb_byte *) str, buf2, slen);
3632 
3633  str = (tracing_stop_note ? tracing_stop_note : "");
3634  slen = strlen (str);
3635  buf3 = (char *) alloca (slen * 2 + 1);
3636  bin2hex ((gdb_byte *) str, buf3, slen);
3637 
3638  trace_debug ("Returning trace status as %d, stop reason %s",
3639  tracing, tracing_stop_reason);
3640 
3641  if (agent_loaded_p ())
3642  {
3643  pause_all (1);
3644 
3646 
3647  unpause_all (1);
3648  }
3649 
3650  stop_reason_rsp = (char *) tracing_stop_reason;
3651 
3652  /* The user visible error string in terror needs to be hex encoded.
3653  We leave it as plain string in `tracing_stop_reason' to ease
3654  debugging. */
3655  if (startswith (stop_reason_rsp, "terror:"))
3656  {
3657  const char *result_name;
3658  int hexstr_len;
3659  char *p;
3660 
3661  result_name = stop_reason_rsp + strlen ("terror:");
3662  hexstr_len = strlen (result_name) * 2;
3663  p = stop_reason_rsp = alloca (strlen ("terror:") + hexstr_len + 1);
3664  strcpy (p, "terror:");
3665  p += strlen (p);
3666  bin2hex ((gdb_byte *) result_name, p, strlen (result_name));
3667  }
3668 
3669  /* If this was a forced stop, include any stop note that was supplied. */
3670  if (strcmp (stop_reason_rsp, "tstop") == 0)
3671  {
3672  stop_reason_rsp = alloca (strlen ("tstop:") + strlen (buf3) + 1);
3673  strcpy (stop_reason_rsp, "tstop:");
3674  strcat (stop_reason_rsp, buf3);
3675  }
3676 
3677  sprintf (packet,
3678  "T%d;"
3679  "%s:%x;"
3680  "tframes:%x;tcreated:%x;"
3681  "tfree:%x;tsize:%s;"
3682  "circular:%d;"
3683  "disconn:%d;"
3684  "starttime:%s;stoptime:%s;"
3685  "username:%s;notes:%s:",
3686  tracing ? 1 : 0,
3687  stop_reason_rsp, tracing_stop_tpnum,
3688  traceframe_count, traceframes_created,
3689  free_space (), phex_nz (trace_buffer_hi - trace_buffer_lo, 0),
3690  circular_trace_buffer,
3691  disconnected_tracing,
3692  phex_nz (tracing_start_time, sizeof (tracing_start_time)),
3693  phex_nz (tracing_stop_time, sizeof (tracing_stop_time)),
3694  buf1, buf2);
3695 }
3696 
3697 static void
3699 {
3700  ULONGEST num, addr;
3701  struct tracepoint *tpoint;
3702  char *packet = own_buf;
3703 
3704  packet += strlen ("qTP:");
3705 
3706  packet = unpack_varlen_hex (packet, &num);
3707  ++packet; /* skip a colon */
3708  packet = unpack_varlen_hex (packet, &addr);
3709 
3710  /* See if we already have this tracepoint. */
3711  tpoint = find_tracepoint (num, addr);
3712 
3713  if (!tpoint)
3714  {
3715  trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
3716  (int) num, paddress (addr));
3717  write_enn (own_buf);
3718  return;
3719  }
3720 
3721  sprintf (own_buf, "V%" PRIu64 ":%" PRIu64 "", tpoint->hit_count,
3722  tpoint->traceframe_usage);
3723 }
3724 
3725 /* State variables to help return all the tracepoint bits. */
3726 static struct tracepoint *cur_tpoint;
3727 static unsigned int cur_action;
3728 static unsigned int cur_step_action;
3731 
3732 /* Compose a response that is an imitation of the syntax by which the
3733  tracepoint was originally downloaded. */
3734 
3735 static void
3736 response_tracepoint (char *packet, struct tracepoint *tpoint)
3737 {
3738  char *buf;
3739 
3740  sprintf (packet, "T%x:%s:%c:%" PRIx64 ":%" PRIx64, tpoint->number,
3741  paddress (tpoint->address),
3742  (tpoint->enabled ? 'E' : 'D'), tpoint->step_count,
3743  tpoint->pass_count);
3744  if (tpoint->type == fast_tracepoint)
3745  sprintf (packet + strlen (packet), ":F%x", tpoint->orig_size);
3746  else if (tpoint->type == static_tracepoint)
3747  sprintf (packet + strlen (packet), ":S");
3748 
3749  if (tpoint->cond)
3750  {
3751  buf = gdb_unparse_agent_expr (tpoint->cond);
3752  sprintf (packet + strlen (packet), ":X%x,%s",
3753  tpoint->cond->length, buf);
3754  free (buf);
3755  }
3756 }
3757 
3758 /* Compose a response that is an imitation of the syntax by which the
3759  tracepoint action was originally downloaded (with the difference
3760  that due to the way we store the actions, this will output a packet
3761  per action, while GDB could have combined more than one action
3762  per-packet. */
3763 
3764 static void
3765 response_action (char *packet, struct tracepoint *tpoint,
3766  char *taction, int step)
3767 {
3768  sprintf (packet, "%c%x:%s:%s",
3769  (step ? 'S' : 'A'), tpoint->number, paddress (tpoint->address),
3770  taction);
3771 }
3772 
3773 /* Compose a response that is an imitation of the syntax by which the
3774  tracepoint source piece was originally downloaded. */
3775 
3776 static void
3777 response_source (char *packet,
3778  struct tracepoint *tpoint, struct source_string *src)
3779 {
3780  char *buf;
3781  int len;
3782 
3783  len = strlen (src->str);
3784  buf = alloca (len * 2 + 1);
3785  bin2hex ((gdb_byte *) src->str, buf, len);
3786 
3787  sprintf (packet, "Z%x:%s:%s:%x:%x:%s",
3788  tpoint->number, paddress (tpoint->address),
3789  src->type, 0, len, buf);
3790 }
3791 
3792 /* Return the first piece of tracepoint definition, and initialize the
3793  state machine that will iterate through all the tracepoint
3794  bits. */
3795 
3796 static void
3797 cmd_qtfp (char *packet)
3798 {
3799  trace_debug ("Returning first tracepoint definition piece");
3800 
3801  cur_tpoint = tracepoints;
3802  cur_action = cur_step_action = 0;
3803  cur_source_string = NULL;
3804 
3805  if (cur_tpoint)
3806  response_tracepoint (packet, cur_tpoint);
3807  else
3808  strcpy (packet, "l");
3809 }
3810 
3811 /* Return additional pieces of tracepoint definition. Each action and
3812  stepping action must go into its own packet, because of packet size
3813  limits, and so we use state variables to deliver one piece at a
3814  time. */
3815 
3816 static void
3817 cmd_qtsp (char *packet)
3818 {
3819  trace_debug ("Returning subsequent tracepoint definition piece");
3820 
3821  if (!cur_tpoint)
3822  {
3823  /* This case would normally never occur, but be prepared for
3824  GDB misbehavior. */
3825  strcpy (packet, "l");
3826  }
3827  else if (cur_action < cur_tpoint->numactions)
3828  {
3829  response_action (packet, cur_tpoint,
3830  cur_tpoint->actions_str[cur_action], 0);
3831  ++cur_action;
3832  }
3833  else if (cur_step_action < cur_tpoint->num_step_actions)
3834  {
3835  response_action (packet, cur_tpoint,
3836  cur_tpoint->step_actions_str[cur_step_action], 1);
3837  ++cur_step_action;
3838  }
3839  else if ((cur_source_string
3840  ? cur_source_string->next
3841  : cur_tpoint->source_strings))
3842  {
3843  if (cur_source_string)
3844  cur_source_string = cur_source_string->next;
3845  else
3846  cur_source_string = cur_tpoint->source_strings;
3847  response_source (packet, cur_tpoint, cur_source_string);
3848  }
3849  else
3850  {
3851  cur_tpoint = cur_tpoint->next;
3852  cur_action = cur_step_action = 0;
3853  cur_source_string = NULL;
3854  if (cur_tpoint)
3855  response_tracepoint (packet, cur_tpoint);
3856  else
3857  strcpy (packet, "l");
3858  }
3859 }
3860 
3861 /* Compose a response that is an imitation of the syntax by which the
3862  trace state variable was originally downloaded. */
3863 
3864 static void
3865 response_tsv (char *packet, struct trace_state_variable *tsv)
3866 {
3867  char *buf = (char *) "";
3868  int namelen;
3869 
3870  if (tsv->name)
3871  {
3872  namelen = strlen (tsv->name);
3873  buf = alloca (namelen * 2 + 1);
3874  bin2hex ((gdb_byte *) tsv->name, buf, namelen);
3875  }
3876 
3877  sprintf (packet, "%x:%s:%x:%s", tsv->number, phex_nz (tsv->initial_value, 0),
3878  tsv->getter ? 1 : 0, buf);
3879 }
3880 
3881 /* Return the first trace state variable definition, and initialize
3882  the state machine that will iterate through all the tsv bits. */
3883 
3884 static void
3885 cmd_qtfv (char *packet)
3886 {
3887  trace_debug ("Returning first trace state variable definition");
3888 
3889  cur_tsv = trace_state_variables;
3890 
3891  if (cur_tsv)
3892  response_tsv (packet, cur_tsv);
3893  else
3894  strcpy (packet, "l");
3895 }
3896 
3897 /* Return additional trace state variable definitions. */
3898 
3899 static void
3900 cmd_qtsv (char *packet)
3901 {
3902  trace_debug ("Returning additional trace state variable definition");
3903 
3904  if (cur_tsv)
3905  {
3906  cur_tsv = cur_tsv->next;
3907  if (cur_tsv)
3908  response_tsv (packet, cur_tsv);
3909  else
3910  strcpy (packet, "l");
3911  }
3912  else
3913  strcpy (packet, "l");
3914 }
3915 
3916 /* Return the first static tracepoint marker, and initialize the state
3917  machine that will iterate through all the static tracepoints
3918  markers. */
3919 
3920 static void
3921 cmd_qtfstm (char *packet)
3922 {
3923  if (!maybe_write_ipa_ust_not_loaded (packet))
3924  run_inferior_command (packet, strlen (packet) + 1);
3925 }
3926 
3927 /* Return additional static tracepoints markers. */
3928 
3929 static void
3930 cmd_qtsstm (char *packet)
3931 {
3932  if (!maybe_write_ipa_ust_not_loaded (packet))
3933  run_inferior_command (packet, strlen (packet) + 1);
3934 }
3935 
3936 /* Return the definition of the static tracepoint at a given address.
3937  Result packet is the same as qTsST's. */
3938 
3939 static void
3940 cmd_qtstmat (char *packet)
3941 {
3942  if (!maybe_write_ipa_ust_not_loaded (packet))
3943  run_inferior_command (packet, strlen (packet) + 1);
3944 }
3945 
3946 /* Helper for gdb_agent_about_to_close.
3947  Return non-zero if thread ENTRY is in the same process in DATA. */
3948 
3949 static int
3950 same_process_p (struct inferior_list_entry *entry, void *data)
3951 {
3952  int *pid = data;
3953 
3954  return ptid_get_pid (entry->id) == *pid;
3955 }
3956 
3957 /* Sent the agent a command to close it. */
3958 
3959 void
3961 {
3962  char buf[IPA_CMD_BUF_SIZE];
3963 
3964  if (!maybe_write_ipa_not_loaded (buf))
3965  {
3966  struct thread_info *saved_thread;
3967 
3968  saved_thread = current_thread;
3969 
3970  /* Find any thread which belongs to process PID. */
3971  current_thread = (struct thread_info *)
3973 
3974  strcpy (buf, "close");
3975 
3976  run_inferior_command (buf, strlen (buf) + 1);
3977 
3978  current_thread = saved_thread;
3979  }
3980 }
3981 
3982 /* Return the minimum instruction size needed for fast tracepoints as a
3983  hexadecimal number. */
3984 
3985 static void
3986 cmd_qtminftpilen (char *packet)
3987 {
3988  if (current_thread == NULL)
3989  {
3990  /* Indicate that the minimum length is currently unknown. */
3991  strcpy (packet, "0");
3992  return;
3993  }
3994 
3995  sprintf (packet, "%x", target_get_min_fast_tracepoint_insn_len ());
3996 }
3997 
3998 /* Respond to qTBuffer packet with a block of raw data from the trace
3999  buffer. GDB may ask for a lot, but we are allowed to reply with
4000  only as much as will fit within packet limits or whatever. */
4001 
4002 static void
4004 {
4005  ULONGEST offset, num, tot;
4006  unsigned char *tbp;
4007  char *packet = own_buf;
4008 
4009  packet += strlen ("qTBuffer:");
4010 
4011  packet = unpack_varlen_hex (packet, &offset);
4012  ++packet; /* skip a comma */
4013  unpack_varlen_hex (packet, &num);
4014 
4015  trace_debug ("Want to get trace buffer, %d bytes at offset 0x%s",
4016  (int) num, phex_nz (offset, 0));
4017 
4018  tot = (trace_buffer_hi - trace_buffer_lo) - free_space ();
4019 
4020  /* If we're right at the end, reply specially that we're done. */
4021  if (offset == tot)
4022  {
4023  strcpy (own_buf, "l");
4024  return;
4025  }
4026 
4027  /* Object to any other out-of-bounds request. */
4028  if (offset > tot)
4029  {
4030  write_enn (own_buf);
4031  return;
4032  }
4033 
4034  /* Compute the pointer corresponding to the given offset, accounting
4035  for wraparound. */
4036  tbp = trace_buffer_start + offset;
4037  if (tbp >= trace_buffer_wrap)
4039 
4040  /* Trim to the remaining bytes if we're close to the end. */
4041  if (num > tot - offset)
4042  num = tot - offset;
4043 
4044  /* Trim to available packet size. */
4045  if (num >= (PBUFSIZ - 16) / 2 )
4046  num = (PBUFSIZ - 16) / 2;
4047 
4048  bin2hex (tbp, own_buf, num);
4049 }
4050 
4051 static void
4053 {
4054  ULONGEST val;
4055  char *packet = own_buf;
4056 
4057  packet += strlen ("QTBuffer:circular:");
4058 
4059  unpack_varlen_hex (packet, &val);
4060  circular_trace_buffer = val;
4061  trace_debug ("Trace buffer is now %s",
4062  circular_trace_buffer ? "circular" : "linear");
4063  write_ok (own_buf);
4064 }
4065 
4066 static void
4068 {
4069  ULONGEST val;
4070  LONGEST sval;
4071  char *packet = own_buf;
4072 
4073  /* Can't change the size during a tracing run. */
4074  if (tracing)
4075  {
4076  write_enn (own_buf);
4077  return;
4078  }
4079 
4080  packet += strlen ("QTBuffer:size:");
4081 
4082  /* -1 is sent as literal "-1". */
4083  if (strcmp (packet, "-1") == 0)
4085  else
4086  {
4087  unpack_varlen_hex (packet, &val);
4088  sval = (LONGEST) val;
4089  }
4090 
4091  init_trace_buffer (sval);
4092  trace_debug ("Trace buffer is now %s bytes",
4093  plongest (trace_buffer_size));
4094  write_ok (own_buf);
4095 }
4096 
4097 static void
4099 {
4100  size_t nbytes;
4101  char *saved, *user, *notes, *stopnote;
4102  char *packet = own_buf;
4103 
4104  packet += strlen ("QTNotes:");
4105 
4106  while (*packet)
4107  {
4108  if (startswith (packet, "user:"))
4109  {
4110  packet += strlen ("user:");
4111  saved = packet;
4112  packet = strchr (packet, ';');
4113  nbytes = (packet - saved) / 2;
4114  user = xmalloc (nbytes + 1);
4115  nbytes = hex2bin (saved, (gdb_byte *) user, nbytes);
4116  user[nbytes] = '\0';
4117  ++packet; /* skip the semicolon */
4118  trace_debug ("User is '%s'", user);
4119  xfree (tracing_user_name);
4120  tracing_user_name = user;
4121  }
4122  else if (startswith (packet, "notes:"))
4123  {
4124  packet += strlen ("notes:");
4125  saved = packet;
4126  packet = strchr (packet, ';');
4127  nbytes = (packet - saved) / 2;
4128  notes = xmalloc (nbytes + 1);
4129  nbytes = hex2bin (saved, (gdb_byte *) notes, nbytes);
4130  notes[nbytes] = '\0';
4131  ++packet; /* skip the semicolon */
4132  trace_debug ("Notes is '%s'", notes);
4133  xfree (tracing_notes);
4134  tracing_notes = notes;
4135  }
4136  else if (startswith (packet, "tstop:"))
4137  {
4138  packet += strlen ("tstop:");
4139  saved = packet;
4140  packet = strchr (packet, ';');
4141  nbytes = (packet - saved) / 2;
4142  stopnote = xmalloc (nbytes + 1);
4143  nbytes = hex2bin (saved, (gdb_byte *) stopnote, nbytes);
4144  stopnote[nbytes] = '\0';
4145  ++packet; /* skip the semicolon */
4146  trace_debug ("tstop note is '%s'", stopnote);
4147  xfree (tracing_stop_note);
4148  tracing_stop_note = stopnote;
4149  }
4150  else
4151  break;
4152  }
4153 
4154  write_ok (own_buf);
4155 }
4156 
4157 int
4159 {
4160  if (strcmp ("QTinit", packet) == 0)
4161  {
4162  cmd_qtinit (packet);
4163  return 1;
4164  }
4165  else if (startswith (packet, "QTDP:"))
4166  {
4167  cmd_qtdp (packet);
4168  return 1;
4169  }
4170  else if (startswith (packet, "QTDPsrc:"))
4171  {
4172  cmd_qtdpsrc (packet);
4173  return 1;
4174  }
4175  else if (startswith (packet, "QTEnable:"))
4176  {
4177  cmd_qtenable_disable (packet, 1);
4178  return 1;
4179  }
4180  else if (startswith (packet, "QTDisable:"))
4181  {
4182  cmd_qtenable_disable (packet, 0);
4183  return 1;
4184  }
4185  else if (startswith (packet, "QTDV:"))
4186  {
4187  cmd_qtdv (packet);
4188  return 1;
4189  }
4190  else if (startswith (packet, "QTro:"))
4191  {
4192  cmd_qtro (packet);
4193  return 1;
4194  }
4195  else if (strcmp ("QTStart", packet) == 0)
4196  {
4197  cmd_qtstart (packet);
4198  return 1;
4199  }
4200  else if (strcmp ("QTStop", packet) == 0)
4201  {
4202  cmd_qtstop (packet);
4203  return 1;
4204  }
4205  else if (startswith (packet, "QTDisconnected:"))
4206  {
4207  cmd_qtdisconnected (packet);
4208  return 1;
4209  }
4210  else if (startswith (packet, "QTFrame:"))
4211  {
4212  cmd_qtframe (packet);
4213  return 1;
4214  }
4215  else if (startswith (packet, "QTBuffer:circular:"))
4216  {
4217  cmd_bigqtbuffer_circular (packet);
4218  return 1;
4219  }
4220  else if (startswith (packet, "QTBuffer:size:"))
4221  {
4222  cmd_bigqtbuffer_size (packet);
4223  return 1;
4224  }
4225  else if (startswith (packet, "QTNotes:"))
4226  {
4227  cmd_qtnotes (packet);
4228  return 1;
4229  }
4230 
4231  return 0;
4232 }
4233 
4234 int
4236 {
4237  if (strcmp ("qTStatus", packet) == 0)
4238  {
4239  cmd_qtstatus (packet);
4240  return 1;
4241  }
4242  else if (startswith (packet, "qTP:"))
4243  {
4244  cmd_qtp (packet);
4245  return 1;
4246  }
4247  else if (strcmp ("qTfP", packet) == 0)
4248  {
4249  cmd_qtfp (packet);
4250  return 1;
4251  }
4252  else if (strcmp ("qTsP", packet) == 0)
4253  {
4254  cmd_qtsp (packet);
4255  return 1;
4256  }
4257  else if (strcmp ("qTfV", packet) == 0)
4258  {
4259  cmd_qtfv (packet);
4260  return 1;
4261  }
4262  else if (strcmp ("qTsV", packet) == 0)
4263  {
4264  cmd_qtsv (packet);
4265  return 1;
4266  }
4267  else if (startswith (packet, "qTV:"))
4268  {
4269  cmd_qtv (packet);
4270  return 1;
4271  }
4272  else if (startswith (packet, "qTBuffer:"))
4273  {
4274  cmd_qtbuffer (packet);
4275  return 1;
4276  }
4277  else if (strcmp ("qTfSTM", packet) == 0)
4278  {
4279  cmd_qtfstm (packet);
4280  return 1;
4281  }
4282  else if (strcmp ("qTsSTM", packet) == 0)
4283  {
4284  cmd_qtsstm (packet);
4285  return 1;
4286  }
4287  else if (startswith (packet, "qTSTMat:"))
4288  {
4289  cmd_qtstmat (packet);
4290  return 1;
4291  }
4292  else if (strcmp ("qTMinFTPILen", packet) == 0)
4293  {
4294  cmd_qtminftpilen (packet);
4295  return 1;
4296  }
4297 
4298  return 0;
4299 }
4300 
4301 #endif
4302 #ifndef IN_PROCESS_AGENT
4303 
4304 /* Call this when thread TINFO has hit the tracepoint defined by
4305  TP_NUMBER and TP_ADDRESS, and that tracepoint has a while-stepping
4306  action. This adds a while-stepping collecting state item to the
4307  threads' collecting state list, so that we can keep track of
4308  multiple simultaneous while-stepping actions being collected by the
4309  same thread. This can happen in cases like:
4310 
4311  ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs
4312  ff0002 INSN2
4313  ff0003 INSN3 <-- TP2, collect $regs
4314  ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs
4315  ff0005 INSN5
4316 
4317  Notice that when instruction INSN5 is reached, the while-stepping
4318  actions of both TP1 and TP3 are still being collected, and that TP2
4319  had been collected meanwhile. The whole range of ff0001-ff0005
4320  should be single-stepped, due to at least TP1's while-stepping
4321  action covering the whole range. */
4322 
4323 static void
4325  int tp_number, CORE_ADDR tp_address)
4326 {
4327  struct wstep_state *wstep;
4328 
4329  wstep = xmalloc (sizeof (*wstep));
4330  wstep->next = tinfo->while_stepping;
4331 
4332  wstep->tp_number = tp_number;
4333  wstep->tp_address = tp_address;
4334  wstep->current_step = 0;
4335 
4336  tinfo->while_stepping = wstep;
4337 }
4338 
4339 /* Release the while-stepping collecting state WSTEP. */
4340 
4341 static void
4343 {
4344  free (wstep);
4345 }
4346 
4347 /* Release all while-stepping collecting states currently associated
4348  with thread TINFO. */
4349 
4350 void
4352 {
4353  struct wstep_state *head;
4354 
4355  while (tinfo->while_stepping)
4356  {
4357  head = tinfo->while_stepping;
4358  tinfo->while_stepping = head->next;
4360  }
4361 }
4362 
4363 /* If TINFO was handling a 'while-stepping' action, the step has
4364  finished, so collect any step data needed, and check if any more
4365  steps are required. Return true if the thread was indeed
4366  collecting tracepoint data, false otherwise. */
4367 
4368 int
4370 {
4371  struct tracepoint *tpoint;
4372  struct wstep_state *wstep;
4373  struct wstep_state **wstep_link;
4374  struct trap_tracepoint_ctx ctx;
4375 
4376  /* Pull in fast tracepoint trace frames from the inferior lib buffer into
4377  our buffer. */
4378  if (agent_loaded_p ())
4380 
4381  /* Check if we were indeed collecting data for one of more
4382  tracepoints with a 'while-stepping' count. */
4383  if (tinfo->while_stepping == NULL)
4384  return 0;
4385 
4386  if (!tracing)
4387  {
4388  /* We're not even tracing anymore. Stop this thread from
4389  collecting. */
4391 
4392  /* The thread had stopped due to a single-step request indeed
4393  explained by a tracepoint. */
4394  return 1;
4395  }
4396 
4397  wstep = tinfo->while_stepping;
4398  wstep_link = &tinfo->while_stepping;
4399 
4400  trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
4401  target_pid_to_str (tinfo->entry.id),
4402  wstep->tp_number, paddress (wstep->tp_address));
4403 
4404  ctx.base.type = trap_tracepoint;
4405  ctx.regcache = get_thread_regcache (tinfo, 1);
4406 
4407  while (wstep != NULL)
4408  {
4409  tpoint = find_tracepoint (wstep->tp_number, wstep->tp_address);
4410  if (tpoint == NULL)
4411  {
4412  trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
4413  wstep->tp_number, paddress (wstep->tp_address),
4414  target_pid_to_str (tinfo->entry.id));
4415 
4416  /* Unlink. */
4417  *wstep_link = wstep->next;
4419  wstep = *wstep_link;
4420  continue;
4421  }
4422 
4423  /* We've just finished one step. */
4424  ++wstep->current_step;
4425 
4426  /* Collect data. */
4427  collect_data_at_step ((struct tracepoint_hit_ctx *) &ctx,
4428  stop_pc, tpoint, wstep->current_step);
4429 
4430  if (wstep->current_step >= tpoint->step_count)
4431  {
4432  /* The requested numbers of steps have occurred. */
4433  trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
4434  target_pid_to_str (tinfo->entry.id),
4435  wstep->tp_number, paddress (wstep->tp_address));
4436 
4437  /* Unlink the wstep. */
4438  *wstep_link = wstep->next;
4440  wstep = *wstep_link;
4441 
4442  /* Only check the hit count now, which ensure that we do all
4443  our stepping before stopping the run. */
4444  if (tpoint->pass_count > 0
4445  && tpoint->hit_count >= tpoint->pass_count
4446  && stopping_tracepoint == NULL)
4447  stopping_tracepoint = tpoint;
4448  }
4449  else
4450  {
4451  /* Keep single-stepping until the requested numbers of steps
4452  have occurred. */
4453  wstep_link = &wstep->next;
4454  wstep = *wstep_link;
4455  }
4456 
4457  if (stopping_tracepoint
4458  || trace_buffer_is_full
4459  || expr_eval_result != expr_eval_no_error)
4460  {
4461  stop_tracing ();
4462  break;
4463  }
4464  }
4465 
4466  return 1;
4467 }
4468 
4469 /* Handle any internal tracing control breakpoint hits. That means,
4470  pull traceframes from the IPA to our buffer, and syncing both
4471  tracing agents when the IPA's tracing stops for some reason. */
4472 
4473 int
4475 {
4476  /* Pull in fast tracepoint trace frames from the inferior in-process
4477  agent's buffer into our buffer. */
4478 
4479  if (!agent_loaded_p ())
4480  return 0;
4481 
4483 
4484  /* Check if the in-process agent had decided we should stop
4485  tracing. */
4486  if (stop_pc == ipa_sym_addrs.addr_stop_tracing)
4487  {
4488  int ipa_trace_buffer_is_full;
4489  CORE_ADDR ipa_stopping_tracepoint;
4490  int ipa_expr_eval_result;
4491  CORE_ADDR ipa_error_tracepoint;
4492 
4493  trace_debug ("lib stopped at stop_tracing");
4494 
4496  &ipa_trace_buffer_is_full);
4497 
4499  &ipa_stopping_tracepoint);
4501 
4503  &ipa_error_tracepoint);
4505 
4507  &ipa_expr_eval_result);
4509 
4510  trace_debug ("lib: trace_buffer_is_full: %d, "
4511  "stopping_tracepoint: %s, "
4512  "ipa_expr_eval_result: %d, "
4513  "error_tracepoint: %s, ",
4514  ipa_trace_buffer_is_full,
4515  paddress (ipa_stopping_tracepoint),
4516  ipa_expr_eval_result,
4517  paddress (ipa_error_tracepoint));
4518 
4519  if (debug_threads)
4520  {
4521  if (ipa_trace_buffer_is_full)
4522  trace_debug ("lib stopped due to full buffer.");
4523  if (ipa_stopping_tracepoint)
4524  trace_debug ("lib stopped due to tpoint");
4525  if (ipa_stopping_tracepoint)
4526  trace_debug ("lib stopped due to error");
4527  }
4528 
4529  if (ipa_stopping_tracepoint != 0)
4530  {
4531  stopping_tracepoint
4532  = fast_tracepoint_from_ipa_tpoint_address (ipa_stopping_tracepoint);
4533  }
4534  else if (ipa_expr_eval_result != expr_eval_no_error)
4535  {
4536  expr_eval_result = ipa_expr_eval_result;
4537  error_tracepoint
4538  = fast_tracepoint_from_ipa_tpoint_address (ipa_error_tracepoint);
4539  }
4540  stop_tracing ();
4541  return 1;
4542  }
4543  else if (stop_pc == ipa_sym_addrs.addr_flush_trace_buffer)
4544  {
4545  trace_debug ("lib stopped at flush_trace_buffer");
4546  return 1;
4547  }
4548 
4549  return 0;
4550 }
4551 
4552 /* Return true if TINFO just hit a tracepoint. Collect data if
4553  so. */
4554 
4555 int
4556 tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc)
4557 {
4558  struct tracepoint *tpoint;
4559  int ret = 0;
4560  struct trap_tracepoint_ctx ctx;
4561 
4562  /* Not tracing, don't handle. */
4563  if (!tracing)
4564  return 0;
4565 
4566  ctx.base.type = trap_tracepoint;
4567  ctx.regcache = get_thread_regcache (tinfo, 1);
4568 
4569  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
4570  {
4571  /* Note that we collect fast tracepoints here as well. We'll
4572  step over the fast tracepoint jump later, which avoids the
4573  double collect. However, we don't collect for static
4574  tracepoints here, because UST markers are compiled in program,
4575  and probes will be executed in program. So static tracepoints
4576  are collected there. */
4577  if (tpoint->enabled && stop_pc == tpoint->address
4578  && tpoint->type != static_tracepoint)
4579  {
4580  trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
4581  target_pid_to_str (tinfo->entry.id),
4582  tpoint->number, paddress (tpoint->address));
4583 
4584  /* Test the condition if present, and collect if true. */
4585  if (!tpoint->cond
4587  ((struct tracepoint_hit_ctx *) &ctx, tpoint)))
4589  stop_pc, tpoint);
4590 
4591  if (stopping_tracepoint
4592  || trace_buffer_is_full
4593  || expr_eval_result != expr_eval_no_error)
4594  {
4595  stop_tracing ();
4596  }
4597  /* If the tracepoint had a 'while-stepping' action, then set
4598  the thread to collect this tracepoint on the following
4599  single-steps. */
4600  else if (tpoint->step_count > 0)
4601  {
4602  add_while_stepping_state (tinfo,
4603  tpoint->number, tpoint->address);
4604  }
4605 
4606  ret = 1;
4607  }
4608  }
4609 
4610  return ret;
4611 }
4612 
4613 #endif
4614 
4615 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4616 struct ust_marker_data;
4617 static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx *ctx,
4618  struct traceframe *tframe);
4619 #endif
4620 
4621 /* Create a trace frame for the hit of the given tracepoint in the
4622  given thread. */
4623 
4624 static void
4626  struct tracepoint *tpoint)
4627 {
4628  struct traceframe *tframe;
4629  int acti;
4630 
4631  /* Only count it as a hit when we actually collect data. */
4632  tpoint->hit_count++;
4633 
4634  /* If we've exceeded a defined pass count, record the event for
4635  later, and finish the collection for this hit. This test is only
4636  for nonstepping tracepoints, stepping tracepoints test at the end
4637  of their while-stepping loop. */
4638  if (tpoint->pass_count > 0
4639  && tpoint->hit_count >= tpoint->pass_count
4640  && tpoint->step_count == 0
4641  && stopping_tracepoint == NULL)
4642  stopping_tracepoint = tpoint;
4643 
4644  trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %" PRIu64,
4645  tpoint->number, paddress (tpoint->address), tpoint->hit_count);
4646 
4647  tframe = add_traceframe (tpoint);
4648 
4649  if (tframe)
4650  {
4651  for (acti = 0; acti < tpoint->numactions; ++acti)
4652  {
4653 #ifndef IN_PROCESS_AGENT
4654  trace_debug ("Tracepoint %d at 0x%s about to do action '%s'",
4655  tpoint->number, paddress (tpoint->address),
4656  tpoint->actions_str[acti]);
4657 #endif
4658 
4659  do_action_at_tracepoint (ctx, stop_pc, tpoint, tframe,
4660  tpoint->actions[acti]);
4661  }
4662 
4663  finish_traceframe (tframe);
4664  }
4665 
4666  if (tframe == NULL && tracing)
4667  trace_buffer_is_full = 1;
4668 }
4669 
4670 #ifndef IN_PROCESS_AGENT
4671 
4672 static void
4674  CORE_ADDR stop_pc,
4675  struct tracepoint *tpoint, int current_step)
4676 {
4677  struct traceframe *tframe;
4678  int acti;
4679 
4680  trace_debug ("Making new step traceframe for "
4681  "tracepoint %d at 0x%s, step %d of %" PRIu64 ", hit %" PRIu64,
4682  tpoint->number, paddress (tpoint->address),
4683  current_step, tpoint->step_count,
4684  tpoint->hit_count);
4685 
4686  tframe = add_traceframe (tpoint);
4687 
4688  if (tframe)
4689  {
4690  for (acti = 0; acti < tpoint->num_step_actions; ++acti)
4691  {
4692  trace_debug ("Tracepoint %d at 0x%s about to do step action '%s'",
4693  tpoint->number, paddress (tpoint->address),
4694  tpoint->step_actions_str[acti]);
4695 
4696  do_action_at_tracepoint (ctx, stop_pc, tpoint, tframe,
4697  tpoint->step_actions[acti]);
4698  }
4699 
4700  finish_traceframe (tframe);
4701  }
4702 
4703  if (tframe == NULL && tracing)
4704  trace_buffer_is_full = 1;
4705 }
4706 
4707 #endif
4708 
4709 #ifdef IN_PROCESS_AGENT
4710 /* The target description used by the IPA. Given that the IPA library
4711  is built for a specific architecture that is loaded into the
4712  inferior, there only needs to be one such description per
4713  build. */
4714 const struct target_desc *ipa_tdesc;
4715 #endif
4716 
4717 static struct regcache *
4719 {
4720  struct regcache *regcache = NULL;
4721 
4722 #ifdef IN_PROCESS_AGENT
4723  if (ctx->type == fast_tracepoint)
4724  {
4725  struct fast_tracepoint_ctx *fctx = (struct fast_tracepoint_ctx *) ctx;
4726  if (!fctx->regcache_initted)
4727  {
4728  fctx->regcache_initted = 1;
4729  init_register_cache (&fctx->regcache, ipa_tdesc, fctx->regspace);
4730  supply_regblock (&fctx->regcache, NULL);
4731  supply_fast_tracepoint_registers (&fctx->regcache, fctx->regs);
4732  }
4733  regcache = &fctx->regcache;
4734  }
4735 #ifdef HAVE_UST
4736  if (ctx->type == static_tracepoint)
4737  {
4738  struct static_tracepoint_ctx *sctx
4739  = (struct static_tracepoint_ctx *) ctx;
4740 
4741  if (!sctx->regcache_initted)
4742  {
4743  sctx->regcache_initted = 1;
4744  init_register_cache (&sctx->regcache, ipa_tdesc, sctx->regspace);
4745  supply_regblock (&sctx->regcache, NULL);
4746  /* Pass down the tracepoint address, because REGS doesn't
4747  include the PC, but we know what it must have been. */
4748  supply_static_tracepoint_registers (&sctx->regcache,
4749  (const unsigned char *)
4750  sctx->regs,
4751  sctx->tpoint->address);
4752  }
4753  regcache = &sctx->regcache;
4754  }
4755 #endif
4756 #else
4757  if (ctx->type == trap_tracepoint)
4758  {
4759  struct trap_tracepoint_ctx *tctx = (struct trap_tracepoint_ctx *) ctx;
4760  regcache = tctx->regcache;
4761  }
4762 #endif
4763 
4764  gdb_assert (regcache != NULL);
4765 
4766  return regcache;
4767 }
4768 
4769 static void
4771  CORE_ADDR stop_pc,
4772  struct tracepoint *tpoint,
4773  struct traceframe *tframe,
4774  struct tracepoint_action *taction)
4775 {
4776  enum eval_result_type err;
4777 
4778  switch (taction->type)
4779  {
4780  case 'M':
4781  {
4782  struct collect_memory_action *maction;
4783  struct eval_agent_expr_context ax_ctx;
4784 
4785  maction = (struct collect_memory_action *) taction;
4786  ax_ctx.regcache = NULL;
4787  ax_ctx.tframe = tframe;
4788  ax_ctx.tpoint = tpoint;
4789 
4790  trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
4791  pulongest (maction->len),
4792  paddress (maction->addr), maction->basereg);
4793  /* (should use basereg) */
4794  agent_mem_read (&ax_ctx, NULL, (CORE_ADDR) maction->addr,
4795  maction->len);
4796  break;
4797  }
4798  case 'R':
4799  {
4800  unsigned char *regspace;
4801  struct regcache tregcache;
4802  struct regcache *context_regcache;
4803  int regcache_size;
4804 
4805  trace_debug ("Want to collect registers");
4806 
4807  context_regcache = get_context_regcache (ctx);
4808  regcache_size = register_cache_size (context_regcache->tdesc);
4809 
4810  /* Collect all registers for now. */
4811  regspace = add_traceframe_block (tframe, tpoint, 1 + regcache_size);
4812  if (regspace == NULL)
4813  {
4814  trace_debug ("Trace buffer block allocation failed, skipping");
4815  break;
4816  }
4817  /* Identify a register block. */
4818  *regspace = 'R';
4819 
4820  /* Wrap the regblock in a register cache (in the stack, we
4821  don't want to malloc here). */
4822  init_register_cache (&tregcache, context_regcache->tdesc,
4823  regspace + 1);
4824 
4825  /* Copy the register data to the regblock. */
4826  regcache_cpy (&tregcache, context_regcache);
4827 
4828 #ifndef IN_PROCESS_AGENT
4829  /* On some platforms, trap-based tracepoints will have the PC
4830  pointing to the next instruction after the trap, but we
4831  don't want the user or GDB trying to guess whether the
4832  saved PC needs adjusting; so always record the adjusted
4833  stop_pc. Note that we can't use tpoint->address instead,
4834  since it will be wrong for while-stepping actions. This
4835  adjustment is a nop for fast tracepoints collected from the
4836  in-process lib (but not if GDBserver is collecting one
4837  preemptively), since the PC had already been adjusted to
4838  contain the tracepoint's address by the jump pad. */
4839  trace_debug ("Storing stop pc (0x%s) in regblock",
4840  paddress (stop_pc));
4841 
4842  /* This changes the regblock, not the thread's
4843  regcache. */
4844  regcache_write_pc (&tregcache, stop_pc);
4845 #endif
4846  }
4847  break;
4848  case 'X':
4849  {
4850  struct eval_expr_action *eaction;
4851  struct eval_agent_expr_context ax_ctx;
4852 
4853  eaction = (struct eval_expr_action *) taction;
4854  ax_ctx.regcache = get_context_regcache (ctx);
4855  ax_ctx.tframe = tframe;
4856  ax_ctx.tpoint = tpoint;
4857 
4858  trace_debug ("Want to evaluate expression");
4859 
4860  err = gdb_eval_agent_expr (&ax_ctx, eaction->expr, NULL);
4861 
4862  if (err != expr_eval_no_error)
4863  {
4864  record_tracepoint_error (tpoint, "action expression", err);
4865  return;
4866  }
4867  }
4868  break;
4869  case 'L':
4870  {
4871 #if defined IN_PROCESS_AGENT && defined HAVE_UST
4872  trace_debug ("Want to collect static trace data");
4873  collect_ust_data_at_tracepoint (ctx, tframe);
4874 #else
4875  trace_debug ("warning: collecting static trace data, "
4876  "but static tracepoints are not supported");
4877 #endif
4878  }
4879  break;
4880  default:
4881  trace_debug ("unknown trace action '%c', ignoring", taction->type);
4882  break;
4883  }
4884 }
4885 
4886 static int
4888  struct tracepoint *tpoint)
4889 {
4890  ULONGEST value = 0;
4891  enum eval_result_type err;
4892 
4893  /* Presently, gdbserver doesn't run compiled conditions, only the
4894  IPA does. If the program stops at a fast tracepoint's address
4895  (e.g., due to a breakpoint, trap tracepoint, or stepping),
4896  gdbserver preemptively collect the fast tracepoint. Later, on
4897  resume, gdbserver steps over the fast tracepoint like it steps
4898  over breakpoints, so that the IPA doesn't see that fast
4899  tracepoint. This avoids double collects of fast tracepoints in
4900  that stopping scenario. Having gdbserver itself handle the fast
4901  tracepoint gives the user a consistent view of when fast or trap
4902  tracepoints are collected, compared to an alternative where only
4903  trap tracepoints are collected on stop, and fast tracepoints on
4904  resume. When a fast tracepoint is being processed by gdbserver,
4905  it is always the non-compiled condition expression that is
4906  used. */
4907 #ifdef IN_PROCESS_AGENT
4908  if (tpoint->compiled_cond)
4909  err = ((condfn) (uintptr_t) (tpoint->compiled_cond)) (ctx, &value);
4910  else
4911 #endif
4912  {
4913  struct eval_agent_expr_context ax_ctx;
4914 
4915  ax_ctx.regcache = get_context_regcache (ctx);
4916  ax_ctx.tframe = NULL;
4917  ax_ctx.tpoint = tpoint;
4918 
4919  err = gdb_eval_agent_expr (&ax_ctx, tpoint->cond, &value);
4920  }
4921  if (err != expr_eval_no_error)
4922  {
4923  record_tracepoint_error (tpoint, "condition", err);
4924  /* The error case must return false. */
4925  return 0;
4926  }
4927 
4928  trace_debug ("Tracepoint %d at 0x%s condition evals to %s",
4929  tpoint->number, paddress (tpoint->address),
4930  pulongest (value));
4931  return (value ? 1 : 0);
4932 }
4933 
4934 /* Do memory copies for bytecodes. */
4935 /* Do the recording of memory blocks for actions and bytecodes. */
4936 
4937 int
4939  unsigned char *to, CORE_ADDR from, ULONGEST len)
4940 {
4941  unsigned char *mspace;
4942  ULONGEST remaining = len;
4943  unsigned short blocklen;
4944 
4945  /* If a 'to' buffer is specified, use it. */
4946  if (to != NULL)
4947  {
4948  read_inferior_memory (from, to, len);
4949  return 0;
4950  }
4951 
4952  /* Otherwise, create a new memory block in the trace buffer. */
4953  while (remaining > 0)
4954  {
4955  size_t sp;
4956 
4957  blocklen = (remaining > 65535 ? 65535 : remaining);
4958  sp = 1 + sizeof (from) + sizeof (blocklen) + blocklen;
4959  mspace = add_traceframe_block (ctx->tframe, ctx->tpoint, sp);
4960  if (mspace == NULL)
4961  return 1;
4962  /* Identify block as a memory block. */
4963  *mspace = 'M';
4964  ++mspace;
4965  /* Record address and size. */
4966  memcpy (mspace, &from, sizeof (from));
4967  mspace += sizeof (from);
4968  memcpy (mspace, &blocklen, sizeof (blocklen));
4969  mspace += sizeof (blocklen);
4970  /* Record the memory block proper. */
4971  read_inferior_memory (from, mspace, blocklen);
4972  trace_debug ("%d bytes recorded", blocklen);
4973  remaining -= blocklen;
4974  from += blocklen;
4975  }
4976  return 0;
4977 }
4978 
4979 int
4981  unsigned char *to, CORE_ADDR from, ULONGEST len)
4982 {
4983  unsigned char *buf, *mspace;
4984  ULONGEST remaining = len;
4985  unsigned short blocklen, i;
4986 
4987  /* To save a bit of space, block lengths are 16-bit, so break large
4988  requests into multiple blocks. Bordering on overkill for strings,
4989  but it could happen that someone specifies a large max length. */
4990  while (remaining > 0)
4991  {
4992  size_t sp;
4993 
4994  blocklen = (remaining > 65535 ? 65535 : remaining);
4995  /* We want working space to accumulate nonzero bytes, since
4996  traceframes must have a predecided size (otherwise it gets
4997  harder to wrap correctly for the circular case, etc). */
4998  buf = (unsigned char *) xmalloc (blocklen + 1);
4999  for (i = 0; i < blocklen; ++i)
5000  {
5001  /* Read the string one byte at a time, in case the string is
5002  at the end of a valid memory area - we don't want a
5003  correctly-terminated string to engender segvio
5004  complaints. */
5005  read_inferior_memory (from + i, buf + i, 1);
5006 
5007  if (buf[i] == '\0')
5008  {
5009  blocklen = i + 1;
5010  /* Make sure outer loop stops now too. */
5011  remaining = blocklen;
5012  break;
5013  }
5014  }
5015  sp = 1 + sizeof (from) + sizeof (blocklen) + blocklen;
5016  mspace = add_traceframe_block (ctx->tframe, ctx->tpoint, sp);
5017  if (mspace == NULL)
5018  {
5019  xfree (buf);
5020  return 1;
5021  }
5022  /* Identify block as a memory block. */
5023  *mspace = 'M';
5024  ++mspace;
5025  /* Record address and size. */
5026  memcpy ((void *) mspace, (void *) &from, sizeof (from));
5027  mspace += sizeof (from);
5028  memcpy ((void *) mspace, (void *) &blocklen, sizeof (blocklen));
5029  mspace += sizeof (blocklen);
5030  /* Copy the string contents. */
5031  memcpy ((void *) mspace, (void *) buf, blocklen);
5032  remaining -= blocklen;
5033  from += blocklen;
5034  xfree (buf);
5035  }
5036  return 0;
5037 }
5038 
5039 /* Record the value of a trace state variable. */
5040 
5041 int
5043 {
5044  unsigned char *vspace;
5045  LONGEST val;
5046 
5047  vspace = add_traceframe_block (ctx->tframe, ctx->tpoint,
5048  1 + sizeof (n) + sizeof (LONGEST));
5049  if (vspace == NULL)
5050  return 1;
5051  /* Identify block as a variable. */
5052  *vspace = 'V';
5053  /* Record variable's number and value. */
5054  memcpy (vspace + 1, &n, sizeof (n));
5056  memcpy (vspace + 1 + sizeof (n), &val, sizeof (val));
5057  trace_debug ("Variable %d recorded", n);
5058  return 0;
5059 }
5060 
5061 #ifndef IN_PROCESS_AGENT
5062 
5063 /* Callback for traceframe_walk_blocks, used to find a given block
5064  type in a traceframe. */
5065 
5066 static int
5067 match_blocktype (char blocktype, unsigned char *dataptr, void *data)
5068 {
5069  char *wantedp = data;
5070 
5071  if (*wantedp == blocktype)
5072  return 1;
5073 
5074  return 0;
5075 }
5076 
5077 /* Walk over all traceframe blocks of the traceframe buffer starting
5078  at DATABASE, of DATASIZE bytes long, and call CALLBACK for each
5079  block found, passing in DATA unmodified. If CALLBACK returns true,
5080  this returns a pointer to where the block is found. Returns NULL
5081  if no callback call returned true, indicating that all blocks have
5082  been walked. */
5083 
5084 static unsigned char *
5085 traceframe_walk_blocks (unsigned char *database, unsigned int datasize,
5086  int tfnum,
5087  int (*callback) (char blocktype,
5088  unsigned char *dataptr,
5089  void *data),
5090  void *data)
5091 {
5092  unsigned char *dataptr;
5093 
5094  if (datasize == 0)
5095  {
5096  trace_debug ("traceframe %d has no data", tfnum);
5097  return NULL;
5098  }
5099 
5100  /* Iterate through a traceframe's blocks, looking for a block of the
5101  requested type. */
5102  for (dataptr = database;
5103  dataptr < database + datasize;
5104  /* nothing */)
5105  {
5106  char blocktype;
5107  unsigned short mlen;
5108 
5109  if (dataptr == trace_buffer_wrap)
5110  {
5111  /* Adjust to reflect wrapping part of the frame around to
5112  the beginning. */
5113  datasize = dataptr - database;
5114  dataptr = database = trace_buffer_lo;
5115  }
5116 
5117  blocktype = *dataptr++;
5118 
5119  if ((*callback) (blocktype, dataptr, data))
5120  return dataptr;
5121 
5122  switch (blocktype)
5123  {
5124  case 'R':
5125  /* Skip over the registers block. */
5126  dataptr += current_target_desc ()->registers_size;
5127  break;
5128  case 'M':
5129  /* Skip over the memory block. */
5130  dataptr += sizeof (CORE_ADDR);
5131  memcpy (&mlen, dataptr, sizeof (mlen));
5132  dataptr += (sizeof (mlen) + mlen);
5133  break;
5134  case 'V':
5135  /* Skip over the TSV block. */
5136  dataptr += (sizeof (int) + sizeof (LONGEST));
5137  break;
5138  case 'S':
5139  /* Skip over the static trace data block. */
5140  memcpy (&mlen, dataptr, sizeof (mlen));
5141  dataptr += (sizeof (mlen) + mlen);
5142  break;
5143  default:
5144  trace_debug ("traceframe %d has unknown block type 0x%x",
5145  tfnum, blocktype);
5146  return NULL;
5147  }
5148  }
5149 
5150  return NULL;
5151 }
5152 
5153 /* Look for the block of type TYPE_WANTED in the trameframe starting
5154  at DATABASE of DATASIZE bytes long. TFNUM is the traceframe
5155  number. */
5156 
5157 static unsigned char *
5158 traceframe_find_block_type (unsigned char *database, unsigned int datasize,
5159  int tfnum, char type_wanted)
5160 {
5161  return traceframe_walk_blocks (database, datasize, tfnum,
5162  match_blocktype, &type_wanted);
5163 }
5164 
5165 static unsigned char *
5166 traceframe_find_regblock (struct traceframe *tframe, int tfnum)
5167 {
5168  unsigned char *regblock;
5169 
5170  regblock = traceframe_find_block_type (tframe->data,
5171  tframe->data_size,
5172  tfnum, 'R');
5173 
5174  if (regblock == NULL)
5175  trace_debug ("traceframe %d has no register data", tfnum);
5176 
5177  return regblock;
5178 }
5179 
5180 /* Get registers from a traceframe. */
5181 
5182 int
5184 {
5185  unsigned char *dataptr;
5186  struct tracepoint *tpoint;
5187  struct traceframe *tframe;
5188 
5189  tframe = find_traceframe (tfnum);
5190 
5191  if (tframe == NULL)
5192  {
5193  trace_debug ("traceframe %d not found", tfnum);
5194  return 1;
5195  }
5196 
5197  dataptr = traceframe_find_regblock (tframe, tfnum);
5198  if (dataptr == NULL)
5199  {
5200  /* Mark registers unavailable. */
5201  supply_regblock (regcache, NULL);
5202 
5203  /* We can generally guess at a PC, although this will be
5204  misleading for while-stepping frames and multi-location
5205  tracepoints. */
5206  tpoint = find_next_tracepoint_by_number (NULL, tframe->tpnum);
5207  if (tpoint != NULL)
5208  regcache_write_pc (regcache, tpoint->address);
5209  }
5210  else
5211  supply_regblock (regcache, dataptr);
5212 
5213  return 0;
5214 }
5215 
5216 static CORE_ADDR
5218 {
5219  struct regcache regcache;
5220  unsigned char *dataptr;
5221  const struct target_desc *tdesc = current_target_desc ();
5222 
5223  dataptr = traceframe_find_regblock (tframe, -1);
5224  if (dataptr == NULL)
5225  return 0;
5226 
5227  init_register_cache (&regcache, tdesc, dataptr);
5228  return regcache_read_pc (&regcache);
5229 }
5230 
5231 /* Read a requested block of memory from a trace frame. */
5232 
5233 int
5235  unsigned char *buf, ULONGEST length,
5236  ULONGEST *nbytes)
5237 {
5238  struct traceframe *tframe;
5239  unsigned char *database, *dataptr;
5240  unsigned int datasize;
5241  CORE_ADDR maddr;
5242  unsigned short mlen;
5243 
5244  trace_debug ("traceframe_read_mem");
5245 
5246  tframe = find_traceframe (tfnum);
5247 
5248  if (!tframe)
5249  {
5250  trace_debug ("traceframe %d not found", tfnum);
5251  return 1;
5252  }
5253 
5254  datasize = tframe->data_size;
5255  database = dataptr = &tframe->data[0];
5256 
5257  /* Iterate through a traceframe's blocks, looking for memory. */
5258  while ((dataptr = traceframe_find_block_type (dataptr,
5259  datasize
5260  - (dataptr - database),
5261  tfnum, 'M')) != NULL)
5262  {
5263  memcpy (&maddr, dataptr, sizeof (maddr));
5264  dataptr += sizeof (maddr);
5265  memcpy (&mlen, dataptr, sizeof (mlen));
5266  dataptr += sizeof (mlen);
5267  trace_debug ("traceframe %d has %d bytes at %s",
5268  tfnum, mlen, paddress (maddr));
5269 
5270  /* If the block includes the first part of the desired range,
5271  return as much it has; GDB will re-request the remainder,
5272  which might be in a different block of this trace frame. */
5273  if (maddr <= addr && addr < (maddr + mlen))
5274  {
5275  ULONGEST amt = (maddr + mlen) - addr;
5276  if (amt > length)
5277  amt = length;
5278 
5279  memcpy (buf, dataptr + (addr - maddr), amt);
5280  *nbytes = amt;
5281  return 0;
5282  }
5283 
5284  /* Skip over this block. */
5285  dataptr += mlen;
5286  }
5287 
5288  trace_debug ("traceframe %d has no memory data for the desired region",
5289  tfnum);
5290 
5291  *nbytes = 0;
5292  return 0;
5293 }
5294 
5295 static int
5296 traceframe_read_tsv (int tsvnum, LONGEST *val)
5297 {
5298  int tfnum;
5299  struct traceframe *tframe;
5300  unsigned char *database, *dataptr;
5301  unsigned int datasize;
5302  int vnum;
5303  int found = 0;
5304 
5305  trace_debug ("traceframe_read_tsv");
5306 
5307  tfnum = current_traceframe;
5308 
5309  if (tfnum < 0)
5310  {
5311  trace_debug ("no current traceframe");
5312  return 1;
5313  }
5314 
5315  tframe = find_traceframe (tfnum);
5316 
5317  if (tframe == NULL)
5318  {
5319  trace_debug ("traceframe %d not found", tfnum);
5320  return 1;
5321  }
5322 
5323  datasize = tframe->data_size;
5324  database = dataptr = &tframe->data[0];
5325 
5326  /* Iterate through a traceframe's blocks, looking for the last
5327  matched tsv. */
5328  while ((dataptr = traceframe_find_block_type (dataptr,
5329  datasize
5330  - (dataptr - database),
5331  tfnum, 'V')) != NULL)
5332  {
5333  memcpy (&vnum, dataptr, sizeof (vnum));
5334  dataptr += sizeof (vnum);
5335 
5336  trace_debug ("traceframe %d has variable %d", tfnum, vnum);
5337 
5338  /* Check that this is the variable we want. */
5339  if (tsvnum == vnum)
5340  {
5341  memcpy (val, dataptr, sizeof (*val));
5342  found = 1;
5343  }
5344 
5345  /* Skip over this block. */
5346  dataptr += sizeof (LONGEST);
5347  }
5348 
5349  if (!found)
5350  trace_debug ("traceframe %d has no data for variable %d",
5351  tfnum, tsvnum);
5352  return !found;
5353 }
5354 
5355 /* Read a requested block of static tracepoint data from a trace
5356  frame. */
5357 
5358 int
5360  unsigned char *buf, ULONGEST length,
5361  ULONGEST *nbytes)
5362 {
5363  struct traceframe *tframe;
5364  unsigned char *database, *dataptr;
5365  unsigned int datasize;
5366  unsigned short mlen;
5367 
5368  trace_debug ("traceframe_read_sdata");
5369 
5370  tframe = find_traceframe (tfnum);
5371 
5372  if (!tframe)
5373  {
5374  trace_debug ("traceframe %d not found", tfnum);
5375  return 1;
5376  }
5377 
5378  datasize = tframe->data_size;
5379  database = &tframe->data[0];
5380 
5381  /* Iterate through a traceframe's blocks, looking for static
5382  tracepoint data. */
5383  dataptr = traceframe_find_block_type (database, datasize,
5384  tfnum, 'S');
5385  if (dataptr != NULL)
5386  {
5387  memcpy (&mlen, dataptr, sizeof (mlen));
5388  dataptr += sizeof (mlen);
5389  if (offset < mlen)
5390  {
5391  if (offset + length > mlen)
5392  length = mlen - offset;
5393 
5394  memcpy (buf, dataptr, length);
5395  *nbytes = length;
5396  }
5397  else
5398  *nbytes = 0;
5399  return 0;
5400  }
5401 
5402  trace_debug ("traceframe %d has no static trace data", tfnum);
5403 
5404  *nbytes = 0;
5405  return 0;
5406 }
5407 
5408 /* Callback for traceframe_walk_blocks. Builds a traceframe-info
5409  object. DATA is pointer to a struct buffer holding the
5410  traceframe-info object being built. */
5411 
5412 static int
5413 build_traceframe_info_xml (char blocktype, unsigned char *dataptr, void *data)
5414 {
5415  struct buffer *buffer = data;
5416 
5417  switch (blocktype)
5418  {
5419  case 'M':
5420  {
5421  unsigned short mlen;
5422  CORE_ADDR maddr;
5423 
5424  memcpy (&maddr, dataptr, sizeof (maddr));
5425  dataptr += sizeof (maddr);
5426  memcpy (&mlen, dataptr, sizeof (mlen));
5427  dataptr += sizeof (mlen);
5428  buffer_xml_printf (buffer,
5429  "<memory start=\"0x%s\" length=\"0x%s\"/>\n",
5430  paddress (maddr), phex_nz (mlen, sizeof (mlen)));
5431  break;
5432  }
5433  case 'V':
5434  {
5435  int vnum;
5436 
5437  memcpy (&vnum, dataptr, sizeof (vnum));
5438  buffer_xml_printf (buffer, "<tvar id=\"%d\"/>\n", vnum);
5439  break;
5440  }
5441  case 'R':
5442  case 'S':
5443  {
5444  break;
5445  }
5446  default:
5447  warning ("Unhandled trace block type (%d) '%c ' "
5448  "while building trace frame info.",
5449  blocktype, blocktype);
5450  break;
5451  }
5452 
5453  return 0;
5454 }
5455 
5456 /* Build a traceframe-info object for traceframe number TFNUM into
5457  BUFFER. */
5458 
5459 int
5460 traceframe_read_info (int tfnum, struct buffer *buffer)
5461 {
5462  struct traceframe *tframe;
5463 
5464  trace_debug ("traceframe_read_info");
5465 
5466  tframe = find_traceframe (tfnum);
5467 
5468  if (!tframe)
5469  {
5470  trace_debug ("traceframe %d not found", tfnum);
5471  return 1;
5472  }
5473 
5474  buffer_grow_str (buffer, "<traceframe-info>\n");
5475  traceframe_walk_blocks (tframe->data, tframe->data_size,
5476  tfnum, build_traceframe_info_xml, buffer);
5477  buffer_grow_str0 (buffer, "</traceframe-info>\n");
5478  return 0;
5479 }
5480 
5481 /* Return the first fast tracepoint whose jump pad contains PC. */
5482 
5483 static struct tracepoint *
5485 {
5486  struct tracepoint *tpoint;
5487 
5488  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
5489  if (tpoint->type == fast_tracepoint)
5490  if (tpoint->jump_pad <= pc && pc < tpoint->jump_pad_end)
5491  return tpoint;
5492 
5493  return NULL;
5494 }
5495 
5496 /* Return the first fast tracepoint whose trampoline contains PC. */
5497 
5498 static struct tracepoint *
5500 {
5501  struct tracepoint *tpoint;
5502 
5503  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
5504  {
5505  if (tpoint->type == fast_tracepoint
5506  && tpoint->trampoline <= pc && pc < tpoint->trampoline_end)
5507  return tpoint;
5508  }
5509 
5510  return NULL;
5511 }
5512 
5513 /* Return GDBserver's tracepoint that matches the IP Agent's
5514  tracepoint object that lives at IPA_TPOINT_OBJ in the IP Agent's
5515  address space. */
5516 
5517 static struct tracepoint *
5519 {
5520  struct tracepoint *tpoint;
5521 
5522  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
5523  if (tpoint->type == fast_tracepoint)
5524  if (tpoint->obj_addr_on_target == ipa_tpoint_obj)
5525  return tpoint;
5526 
5527  return NULL;
5528 }
5529 
5530 #endif
5531 
5532 /* The type of the object that is used to synchronize fast tracepoint
5533  collection. */
5534 
5535 typedef struct collecting_t
5536 {
5537  /* The fast tracepoint number currently collecting. */
5538  uintptr_t tpoint;
5539 
5540  /* A number that GDBserver can use to identify the thread that is
5541  presently holding the collect lock. This need not (and usually
5542  is not) the thread id, as getting the current thread ID usually
5543  requires a system call, which we want to avoid like the plague.
5544  Usually this is thread's TCB, found in the TLS (pseudo-)
5545  register, which is readable with a single insn on several
5546  architectures. */
5547  uintptr_t thread_area;
5548 } collecting_t;
5549 
5550 #ifndef IN_PROCESS_AGENT
5551 
5552 void
5554 {
5556 }
5557 
5558 /* Check if the thread identified by THREAD_AREA which is stopped at
5559  STOP_PC, is presently locking the fast tracepoint collection, and
5560  if so, gather some status of said collection. Returns 0 if the
5561  thread isn't collecting or in the jump pad at all. 1, if in the
5562  jump pad (or within gdb_collect) and hasn't executed the adjusted
5563  original insn yet (can set a breakpoint there and run to it). 2,
5564  if presently executing the adjusted original insn --- in which
5565  case, if we want to move the thread out of the jump pad, we need to
5566  single-step it until this function returns 0. */
5567 
5568 int
5570  CORE_ADDR stop_pc,
5571  struct fast_tpoint_collect_status *status)
5572 {
5573  CORE_ADDR ipa_collecting;
5574  CORE_ADDR ipa_gdb_jump_pad_buffer, ipa_gdb_jump_pad_buffer_end;
5575  CORE_ADDR ipa_gdb_trampoline_buffer;
5576  CORE_ADDR ipa_gdb_trampoline_buffer_end;
5577  struct tracepoint *tpoint;
5578  int needs_breakpoint;
5579 
5580  /* The thread THREAD_AREA is either:
5581 
5582  0. not collecting at all, not within the jump pad, or within
5583  gdb_collect or one of its callees.
5584 
5585  1. in the jump pad and haven't reached gdb_collect
5586 
5587  2. within gdb_collect (out of the jump pad) (collect is set)
5588 
5589  3. we're in the jump pad, after gdb_collect having returned,
5590  possibly executing the adjusted insns.
5591 
5592  For cases 1 and 3, `collecting' may or not be set. The jump pad
5593  doesn't have any complicated jump logic, so we can tell if the
5594  thread is executing the adjust original insn or not by just
5595  matching STOP_PC with known jump pad addresses. If we it isn't
5596  yet executing the original insn, set a breakpoint there, and let
5597  the thread run to it, so to quickly step over a possible (many
5598  insns) gdb_collect call. Otherwise, or when the breakpoint is
5599  hit, only a few (small number of) insns are left to be executed
5600  in the jump pad. Single-step the thread until it leaves the
5601  jump pad. */
5602 
5603  again:
5604  tpoint = NULL;
5605  needs_breakpoint = 0;
5606  trace_debug ("fast_tracepoint_collecting");
5607 
5609  &ipa_gdb_jump_pad_buffer))
5610  {
5611  internal_error (__FILE__, __LINE__,
5612  "error extracting `gdb_jump_pad_buffer'");
5613  }
5615  &ipa_gdb_jump_pad_buffer_end))
5616  {
5617  internal_error (__FILE__, __LINE__,
5618  "error extracting `gdb_jump_pad_buffer_end'");
5619  }
5620 
5622  &ipa_gdb_trampoline_buffer))
5623  {
5624  internal_error (__FILE__, __LINE__,
5625  "error extracting `gdb_trampoline_buffer'");
5626  }
5628  &ipa_gdb_trampoline_buffer_end))
5629  {
5630  internal_error (__FILE__, __LINE__,
5631  "error extracting `gdb_trampoline_buffer_end'");
5632  }
5633 
5634  if (ipa_gdb_jump_pad_buffer <= stop_pc
5635  && stop_pc < ipa_gdb_jump_pad_buffer_end)
5636  {
5637  /* We can tell which tracepoint(s) the thread is collecting by
5638  matching the jump pad address back to the tracepoint. */
5639  tpoint = fast_tracepoint_from_jump_pad_address (stop_pc);
5640  if (tpoint == NULL)
5641  {
5642  warning ("in jump pad, but no matching tpoint?");
5643  return 0;
5644  }
5645  else
5646  {
5647  trace_debug ("in jump pad of tpoint (%d, %s); jump_pad(%s, %s); "
5648  "adj_insn(%s, %s)",
5649  tpoint->number, paddress (tpoint->address),
5650  paddress (tpoint->jump_pad),
5651  paddress (tpoint->jump_pad_end),
5652  paddress (tpoint->adjusted_insn_addr),
5653  paddress (tpoint->adjusted_insn_addr_end));
5654  }
5655 
5656  /* Definitely in the jump pad. May or may not need
5657  fast-exit-jump-pad breakpoint. */
5658  if (tpoint->jump_pad <= stop_pc
5659  && stop_pc < tpoint->adjusted_insn_addr)
5660  needs_breakpoint = 1;
5661  }
5662  else if (ipa_gdb_trampoline_buffer <= stop_pc
5663  && stop_pc < ipa_gdb_trampoline_buffer_end)
5664  {
5665  /* We can tell which tracepoint(s) the thread is collecting by
5666  matching the trampoline address back to the tracepoint. */
5667  tpoint = fast_tracepoint_from_trampoline_address (stop_pc);
5668  if (tpoint == NULL)
5669  {
5670  warning ("in trampoline, but no matching tpoint?");
5671  return 0;
5672  }
5673  else
5674  {
5675  trace_debug ("in trampoline of tpoint (%d, %s); trampoline(%s, %s)",
5676  tpoint->number, paddress (tpoint->address),
5677  paddress (tpoint->trampoline),
5678  paddress (tpoint->trampoline_end));
5679  }
5680 
5681  /* Have not reached jump pad yet, but treat the trampoline as a
5682  part of the jump pad that is before the adjusted original
5683  instruction. */
5684  needs_breakpoint = 1;
5685  }
5686  else
5687  {
5688  collecting_t ipa_collecting_obj;
5689 
5690  /* If `collecting' is set/locked, then the THREAD_AREA thread
5691  may or not be the one holding the lock. We have to read the
5692  lock to find out. */
5693 
5695  &ipa_collecting))
5696  {
5697  trace_debug ("fast_tracepoint_collecting:"
5698  " failed reading 'collecting' in the inferior");
5699  return 0;
5700  }
5701 
5702  if (!ipa_collecting)
5703  {
5704  trace_debug ("fast_tracepoint_collecting: not collecting"
5705  " (and nobody is).");
5706  return 0;
5707  }
5708 
5709  /* Some thread is collecting. Check which. */
5710  if (read_inferior_memory (ipa_collecting,
5711  (unsigned char *) &ipa_collecting_obj,
5712  sizeof (ipa_collecting_obj)) != 0)
5713  goto again;
5714 
5715  if (ipa_collecting_obj.thread_area != thread_area)
5716  {
5717  trace_debug ("fast_tracepoint_collecting: not collecting "
5718  "(another thread is)");
5719  return 0;
5720  }
5721 
5722  tpoint
5723  = fast_tracepoint_from_ipa_tpoint_address (ipa_collecting_obj.tpoint);
5724  if (tpoint == NULL)
5725  {
5726  warning ("fast_tracepoint_collecting: collecting, "
5727  "but tpoint %s not found?",
5728  paddress ((CORE_ADDR) ipa_collecting_obj.tpoint));
5729  return 0;
5730  }
5731 
5732  /* The thread is within `gdb_collect', skip over the rest of
5733  fast tracepoint collection quickly using a breakpoint. */
5734  needs_breakpoint = 1;
5735  }
5736 
5737  /* The caller wants a bit of status detail. */
5738  if (status != NULL)
5739  {
5740  status->tpoint_num = tpoint->number;
5741  status->tpoint_addr = tpoint->address;
5742  status->adjusted_insn_addr = tpoint->adjusted_insn_addr;
5744  }
5745 
5746  if (needs_breakpoint)
5747  {
5748  /* Hasn't executed the original instruction yet. Set breakpoint
5749  there, and wait till it's hit, then single-step until exiting
5750  the jump pad. */
5751 
5752  trace_debug ("\
5753 fast_tracepoint_collecting, returning continue-until-break at %s",
5754  paddress (tpoint->adjusted_insn_addr));
5755 
5756  return 1; /* continue */
5757  }
5758  else
5759  {
5760  /* Just single-step until exiting the jump pad. */
5761 
5762  trace_debug ("fast_tracepoint_collecting, returning "
5763  "need-single-step (%s-%s)",
5764  paddress (tpoint->adjusted_insn_addr),
5765  paddress (tpoint->adjusted_insn_addr_end));
5766 
5767  return 2; /* single-step */
5768  }
5769 }
5770 
5771 #endif
5772 
5773 #ifdef IN_PROCESS_AGENT
5774 
5775 /* The global fast tracepoint collect lock. Points to a collecting_t
5776  object built on the stack by the jump pad, if presently locked;
5777  NULL if it isn't locked. Note that this lock *must* be set while
5778  executing any *function other than the jump pad. See
5779  fast_tracepoint_collecting. */
5781 IP_AGENT_EXPORT_VAR collecting_t *collecting;
5783 
5784 /* This routine, called from the jump pad (in asm) is designed to be
5785  called from the jump pads of fast tracepoints, thus it is on the
5786  critical path. */
5787 
5789 gdb_collect (struct tracepoint *tpoint, unsigned char *regs)
5790 {
5791  struct fast_tracepoint_ctx ctx;
5792 
5793  /* Don't do anything until the trace run is completely set up. */
5794  if (!tracing)
5795  return;
5796 
5797  ctx.base.type = fast_tracepoint;
5798  ctx.regs = regs;
5799  ctx.regcache_initted = 0;
5800  /* Wrap the regblock in a register cache (in the stack, we don't
5801  want to malloc here). */
5802  ctx.regspace = alloca (ipa_tdesc->registers_size);
5803  if (ctx.regspace == NULL)
5804  {
5805  trace_debug ("Trace buffer block allocation failed, skipping");
5806  return;
5807  }
5808 
5809  for (ctx.tpoint = tpoint;
5810  ctx.tpoint != NULL && ctx.tpoint->address == tpoint->address;
5811  ctx.tpoint = ctx.tpoint->next)
5812  {
5813  if (!ctx.tpoint->enabled)
5814  continue;
5815 
5816  /* Multiple tracepoints of different types, such as fast tracepoint and
5817  static tracepoint, can be set at the same address. */
5818  if (ctx.tpoint->type != tpoint->type)
5819  continue;
5820 
5821  /* Test the condition if present, and collect if true. */
5822  if (ctx.tpoint->cond == NULL
5824  ctx.tpoint))
5825  {
5827  ctx.tpoint->address, ctx.tpoint);
5828 
5829  /* Note that this will cause original insns to be written back
5830  to where we jumped from, but that's OK because we're jumping
5831  back to the next whole instruction. This will go badly if
5832  instruction restoration is not atomic though. */
5833  if (stopping_tracepoint
5834  || trace_buffer_is_full
5835  || expr_eval_result != expr_eval_no_error)
5836  {
5837  stop_tracing ();
5838  break;
5839  }
5840  }
5841  else
5842  {
5843  /* If there was a condition and it evaluated to false, the only
5844  way we would stop tracing is if there was an error during
5845  condition expression evaluation. */
5846  if (expr_eval_result != expr_eval_no_error)
5847  {
5848  stop_tracing ();
5849  break;
5850  }
5851  }
5852  }
5853 }
5854 
5855 #endif
5856 
5857 #ifndef IN_PROCESS_AGENT
5858 
5859 CORE_ADDR
5861 {
5863 }
5864 
5865 CORE_ADDR
5867 {
5869 }
5870 
5871 CORE_ADDR
5873 {
5875 }
5876 
5877 static void
5879  CORE_ADDR *jump_entry)
5880 {
5881  CORE_ADDR entry_point = *jump_entry;
5882  enum eval_result_type err;
5883 
5884  trace_debug ("Starting condition compilation for tracepoint %d\n",
5885  tpoint->number);
5886 
5887  /* Initialize the global pointer to the code being built. */
5888  current_insn_ptr = *jump_entry;
5889 
5890  emit_prologue ();
5891 
5892  err = compile_bytecodes (tpoint->cond);
5893 
5894  if (err == expr_eval_no_error)
5895  {
5896  emit_epilogue ();
5897 
5898  /* Record the beginning of the compiled code. */
5899  tpoint->compiled_cond = entry_point;
5900 
5901  trace_debug ("Condition compilation for tracepoint %d complete\n",
5902  tpoint->number);
5903  }
5904  else
5905  {
5906  /* Leave the unfinished code in situ, but don't point to it. */
5907 
5908  tpoint->compiled_cond = 0;
5909 
5910  trace_debug ("Condition compilation for tracepoint %d failed, "
5911  "error code %d",
5912  tpoint->number, err);
5913  }
5914 
5915  /* Update the code pointer passed in. Note that we do this even if
5916  the compile fails, so that we can look at the partial results
5917  instead of letting them be overwritten. */
5918  *jump_entry = current_insn_ptr;
5919 
5920  /* Leave a gap, to aid dump decipherment. */
5921  *jump_entry += 16;
5922 }
5923 
5924 /* We'll need to adjust these when we consider bi-arch setups, and big
5925  endian machines. */
5926 
5927 static int
5929 {
5930  return write_inferior_memory (where,
5931  (unsigned char *) &ptr, sizeof (void *));
5932 }
5933 
5934 /* The base pointer of the IPA's heap. This is the only memory the
5935  IPA is allowed to use. The IPA should _not_ call the inferior's
5936  `malloc' during operation. That'd be slow, and, most importantly,
5937  it may not be safe. We may be collecting a tracepoint in a signal
5938  handler, for example. */
5940 
5941 /* Allocate at least SIZE bytes of memory from the IPA heap, aligned
5942  to 8 bytes. */
5943 
5944 static CORE_ADDR
5946 {
5947  CORE_ADDR ptr;
5948 
5949  if (target_tp_heap == 0)
5950  {
5951  /* We have the pointer *address*, need what it points to. */
5953  &target_tp_heap))
5954  {
5955  internal_error (__FILE__, __LINE__,
5956  "couldn't get target heap head pointer");
5957  }
5958  }
5959 
5960  ptr = target_tp_heap;
5961  target_tp_heap += size;
5962 
5963  /* Pad to 8-byte alignment. */
5964  target_tp_heap = ((target_tp_heap + 7) & ~0x7);
5965 
5966  return ptr;
5967 }
5968 
5969 static CORE_ADDR
5971 {
5972  CORE_ADDR expr_addr;
5973  CORE_ADDR expr_bytes;
5974 
5975  expr_addr = target_malloc (sizeof (*expr));
5976  write_inferior_memory (expr_addr, (unsigned char *) expr, sizeof (*expr));
5977 
5978  expr_bytes = target_malloc (expr->length);
5979  write_inferior_data_ptr (expr_addr + offsetof (struct agent_expr, bytes),
5980  expr_bytes);
5981  write_inferior_memory (expr_bytes, expr->bytes, expr->length);
5982 
5983  return expr_addr;
5984 }
5985 
5986 /* Align V up to N bits. */
5987 #define UALIGN(V, N) (((V) + ((N) - 1)) & ~((N) - 1))
5988 
5989 /* Sync tracepoint with IPA, but leave maintenance of linked list to caller. */
5990 
5991 static void
5993 {
5994  struct tracepoint target_tracepoint;
5995  CORE_ADDR tpptr = 0;
5996 
5997  gdb_assert (tpoint->type == fast_tracepoint
5998  || tpoint->type == static_tracepoint);
5999 
6000  if (tpoint->cond != NULL && target_emit_ops () != NULL)
6001  {
6002  CORE_ADDR jentry, jump_entry;
6003 
6004  jentry = jump_entry = get_jump_space_head ();
6005 
6006  if (tpoint->cond != NULL)
6007  {
6008  /* Pad to 8-byte alignment. (needed?) */
6009  /* Actually this should be left for the target to
6010  decide. */
6011  jentry = UALIGN (jentry, 8);
6012 
6013  compile_tracepoint_condition (tpoint, &jentry);
6014  }
6015 
6016  /* Pad to 8-byte alignment. */
6017  jentry = UALIGN (jentry, 8);
6018  claim_jump_space (jentry - jump_entry);
6019  }
6020 
6021  target_tracepoint = *tpoint;
6022 
6023  tpptr = target_malloc (sizeof (*tpoint));
6024  tpoint->obj_addr_on_target = tpptr;
6025 
6026  /* Write the whole object. We'll fix up its pointers in a bit.
6027  Assume no next for now. This is fixed up above on the next
6028  iteration, if there's any. */
6029  target_tracepoint.next = NULL;
6030  /* Need to clear this here too, since we're downloading the
6031  tracepoints before clearing our own copy. */
6032  target_tracepoint.hit_count = 0;
6033 
6034  write_inferior_memory (tpptr, (unsigned char *) &target_tracepoint,
6035  sizeof (target_tracepoint));
6036 
6037  if (tpoint->cond)
6038  write_inferior_data_ptr (tpptr + offsetof (struct tracepoint,
6039  cond),
6040  download_agent_expr (tpoint->cond));
6041 
6042  if (tpoint->numactions)
6043  {
6044  int i;
6045  CORE_ADDR actions_array;
6046 
6047  /* The pointers array. */
6048  actions_array
6049  = target_malloc (sizeof (*tpoint->actions) * tpoint->numactions);
6050  write_inferior_data_ptr (tpptr + offsetof (struct tracepoint,
6051  actions),
6052  actions_array);
6053 
6054  /* Now for each pointer, download the action. */
6055  for (i = 0; i < tpoint->numactions; i++)
6056  {
6057  struct tracepoint_action *action = tpoint->actions[i];
6058  CORE_ADDR ipa_action = action->ops->download (action);
6059 
6060  if (ipa_action != 0)
6062  (actions_array + i * sizeof (*tpoint->actions),
6063  ipa_action);
6064  }
6065  }
6066 }
6067 
6068 #define IPA_PROTO_FAST_TRACE_FLAG 0
6069 #define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET 2
6070 #define IPA_PROTO_FAST_TRACE_JUMP_PAD 10
6071 #define IPA_PROTO_FAST_TRACE_FJUMP_SIZE 18
6072 #define IPA_PROTO_FAST_TRACE_FJUMP_INSN 22
6073 
6074 /* Send a command to agent to download and install tracepoint TPOINT. */
6075 
6076 static int
6078 {
6079  char buf[IPA_CMD_BUF_SIZE];
6080  char *p;
6081  int i, ret;
6082 
6083  p = buf;
6084  strcpy (p, "FastTrace:");
6085  p += 10;
6086 
6087  COPY_FIELD_TO_BUF (p, tpoint, number);
6088  COPY_FIELD_TO_BUF (p, tpoint, address);
6089  COPY_FIELD_TO_BUF (p, tpoint, type);
6090  COPY_FIELD_TO_BUF (p, tpoint, enabled);
6091  COPY_FIELD_TO_BUF (p, tpoint, step_count);
6092  COPY_FIELD_TO_BUF (p, tpoint, pass_count);
6093  COPY_FIELD_TO_BUF (p, tpoint, numactions);
6094  COPY_FIELD_TO_BUF (p, tpoint, hit_count);
6095  COPY_FIELD_TO_BUF (p, tpoint, traceframe_usage);
6096  COPY_FIELD_TO_BUF (p, tpoint, compiled_cond);
6097  COPY_FIELD_TO_BUF (p, tpoint, orig_size);
6098 
6099  /* condition */
6100  p = agent_expr_send (p, tpoint->cond);
6101 
6102  /* tracepoint_action */
6103  for (i = 0; i < tpoint->numactions; i++)
6104  {
6105  struct tracepoint_action *action = tpoint->actions[i];
6106 
6107  p[0] = action->type;
6108  p = action->ops->send (&p[1], action);
6109  }
6110 
6112  /* Copy the value of GDB_JUMP_PAD_HEAD to command buffer, so that
6113  agent can use jump pad from it. */
6114  if (tpoint->type == fast_tracepoint)
6115  {
6116  memcpy (p, &gdb_jump_pad_head, 8);
6117  p += 8;
6118  }
6119 
6120  ret = run_inferior_command (buf, (int) (ptrdiff_t) (p - buf));
6121  if (ret)
6122  return ret;
6123 
6124  if (!startswith (buf, "OK"))
6125  return 1;
6126 
6127  /* The value of tracepoint's target address is stored in BUF. */
6128  memcpy (&tpoint->obj_addr_on_target,
6130 
6131  if (tpoint->type == fast_tracepoint)
6132  {
6133  unsigned char *insn
6134  = (unsigned char *) &buf[IPA_PROTO_FAST_TRACE_FJUMP_INSN];
6135  int fjump_size;
6136 
6137  trace_debug ("agent: read from cmd_buf 0x%x 0x%x\n",
6138  (unsigned int) tpoint->obj_addr_on_target,
6139  (unsigned int) gdb_jump_pad_head);
6140 
6141  memcpy (&gdb_jump_pad_head, &buf[IPA_PROTO_FAST_TRACE_JUMP_PAD], 8);
6142 
6143  /* This has been done in agent. We should also set up record for it. */
6144  memcpy (&fjump_size, &buf[IPA_PROTO_FAST_TRACE_FJUMP_SIZE], 4);
6145  /* Wire it in. */
6146  tpoint->handle
6147  = set_fast_tracepoint_jump (tpoint->address, insn, fjump_size);
6148  }
6149 
6150  return 0;
6151 }
6152 
6153 static void
6155 {
6156  struct tracepoint *tp, *tp_prev;
6157 
6158  if (tpoint->type != fast_tracepoint
6159  && tpoint->type != static_tracepoint)
6160  return;
6161 
6162  download_tracepoint_1 (tpoint);
6163 
6164  /* Find the previous entry of TPOINT, which is fast tracepoint or
6165  static tracepoint. */
6166  tp_prev = NULL;
6167  for (tp = tracepoints; tp != tpoint; tp = tp->next)
6168  {
6169  if (tp->type == fast_tracepoint || tp->type == static_tracepoint)
6170  tp_prev = tp;
6171  }
6172 
6173  if (tp_prev)
6174  {
6175  CORE_ADDR tp_prev_target_next_addr;
6176 
6177  /* Insert TPOINT after TP_PREV in IPA. */
6179  + offsetof (struct tracepoint, next),
6180  &tp_prev_target_next_addr))
6181  {
6182  internal_error (__FILE__, __LINE__,
6183  "error reading `tp_prev->next'");
6184  }
6185 
6186  /* tpoint->next = tp_prev->next */
6188  + offsetof (struct tracepoint, next),
6189  tp_prev_target_next_addr);
6190  /* tp_prev->next = tpoint */
6192  + offsetof (struct tracepoint, next),
6193  tpoint->obj_addr_on_target);
6194  }
6195  else
6196  /* First object in list, set the head pointer in the
6197  inferior. */
6199  tpoint->obj_addr_on_target);
6200 
6201 }
6202 
6203 static void
6205 {
6206  CORE_ADDR ptr = 0, prev_ptr = 0;
6207  struct trace_state_variable *tsv;
6208 
6209  /* Start out empty. */
6211 
6212  for (tsv = trace_state_variables; tsv != NULL; tsv = tsv->next)
6213  {
6214  struct trace_state_variable target_tsv;
6215 
6216  /* TSV's with a getter have been initialized equally in both the
6217  inferior and GDBserver. Skip them. */
6218  if (tsv->getter != NULL)
6219  continue;
6220 
6221  target_tsv = *tsv;
6222 
6223  prev_ptr = ptr;
6224  ptr = target_malloc (sizeof (*tsv));
6225 
6226  if (tsv == trace_state_variables)
6227  {
6228  /* First object in list, set the head pointer in the
6229  inferior. */
6230 
6232  ptr);
6233  }
6234  else
6235  {
6236  write_inferior_data_ptr (prev_ptr
6237  + offsetof (struct trace_state_variable,
6238  next),
6239  ptr);
6240  }
6241 
6242  /* Write the whole object. We'll fix up its pointers in a bit.
6243  Assume no next, fixup when needed. */
6244  target_tsv.next = NULL;
6245 
6246  write_inferior_memory (ptr, (unsigned char *) &target_tsv,
6247  sizeof (target_tsv));
6248 
6249  if (tsv->name != NULL)
6250  {
6251  size_t size = strlen (tsv->name) + 1;
6252  CORE_ADDR name_addr = target_malloc (size);
6253  write_inferior_memory (name_addr,
6254  (unsigned char *) tsv->name, size);
6256  + offsetof (struct trace_state_variable,
6257  name),
6258  name_addr);
6259  }
6260 
6261  gdb_assert (tsv->getter == NULL);
6262  }
6263 
6264  if (prev_ptr != 0)
6265  {
6266  /* Fixup the next pointer in the last item in the list. */
6267  write_inferior_data_ptr (prev_ptr
6268  + offsetof (struct trace_state_variable,
6269  next), 0);
6270  }
6271 }
6272 
6273 /* Upload complete trace frames out of the IP Agent's trace buffer
6274  into GDBserver's trace buffer. This always uploads either all or
6275  no trace frames. This is the counter part of
6276  `trace_alloc_trace_buffer'. See its description of the atomic
6277  synching mechanism. */
6278 
6279 static void
6281 {
6282  unsigned int ipa_traceframe_read_count, ipa_traceframe_write_count;
6283  unsigned int ipa_traceframe_read_count_racy, ipa_traceframe_write_count_racy;
6284  CORE_ADDR tf;
6285  struct ipa_trace_buffer_control ipa_trace_buffer_ctrl;
6286  unsigned int curr_tbctrl_idx;
6287  unsigned int ipa_trace_buffer_ctrl_curr;
6288  unsigned int ipa_trace_buffer_ctrl_curr_old;
6289  CORE_ADDR ipa_trace_buffer_ctrl_addr;
6290  struct breakpoint *about_to_request_buffer_space_bkpt;
6291  CORE_ADDR ipa_trace_buffer_lo;
6292  CORE_ADDR ipa_trace_buffer_hi;
6293 
6295  &ipa_traceframe_read_count_racy))
6296  {
6297  /* This will happen in most targets if the current thread is
6298  running. */
6299  return;
6300  }
6301 
6303  &ipa_traceframe_write_count_racy))
6304  return;
6305 
6306  trace_debug ("ipa_traceframe_count (racy area): %d (w=%d, r=%d)",
6307  ipa_traceframe_write_count_racy
6308  - ipa_traceframe_read_count_racy,
6309  ipa_traceframe_write_count_racy,
6310  ipa_traceframe_read_count_racy);
6311 
6312  if (ipa_traceframe_write_count_racy == ipa_traceframe_read_count_racy)
6313  return;
6314 
6315  about_to_request_buffer_space_bkpt
6317  NULL);
6318 
6320  &ipa_trace_buffer_ctrl_curr))
6321  return;
6322 
6323  ipa_trace_buffer_ctrl_curr_old = ipa_trace_buffer_ctrl_curr;
6324 
6325  curr_tbctrl_idx = ipa_trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK;
6326 
6327  {
6328  unsigned int prev, counter;
6329 
6330  /* Update the token, with new counters, and the GDBserver stamp
6331  bit. Alway reuse the current TBC index. */
6332  prev = ipa_trace_buffer_ctrl_curr & GDBSERVER_FLUSH_COUNT_MASK_CURR;
6333  counter = (prev + 0x100) & GDBSERVER_FLUSH_COUNT_MASK_CURR;
6334 
6335  ipa_trace_buffer_ctrl_curr = (GDBSERVER_UPDATED_FLUSH_COUNT_BIT
6336  | (prev << 12)
6337  | counter
6338  | curr_tbctrl_idx);
6339  }
6340 
6342  ipa_trace_buffer_ctrl_curr))
6343  return;
6344 
6345  trace_debug ("Lib: Committed %08x -> %08x",
6346  ipa_trace_buffer_ctrl_curr_old,
6347  ipa_trace_buffer_ctrl_curr);
6348 
6349  /* Re-read these, now that we've installed the
6350  `about_to_request_buffer_space' breakpoint/lock. A thread could
6351  have finished a traceframe between the last read of these
6352  counters and setting the breakpoint above. If we start
6353  uploading, we never want to leave this function with
6354  traceframe_read_count != 0, otherwise, GDBserver could end up
6355  incrementing the counter tokens more than once (due to event loop
6356  nesting), which would break the IP agent's "effective" detection
6357  (see trace_alloc_trace_buffer). */
6359  &ipa_traceframe_read_count))
6360  return;
6362  &ipa_traceframe_write_count))
6363  return;
6364 
6365  if (debug_threads)
6366  {
6367  trace_debug ("ipa_traceframe_count (blocked area): %d (w=%d, r=%d)",
6368  ipa_traceframe_write_count - ipa_traceframe_read_count,
6369  ipa_traceframe_write_count, ipa_traceframe_read_count);
6370 
6371  if (ipa_traceframe_write_count != ipa_traceframe_write_count_racy
6372  || ipa_traceframe_read_count != ipa_traceframe_read_count_racy)
6373  trace_debug ("note that ipa_traceframe_count's parts changed");
6374  }
6375 
6376  /* Get the address of the current TBC object (the IP agent has an
6377  array of 3 such objects). The index is stored in the TBC
6378  token. */
6379  ipa_trace_buffer_ctrl_addr = ipa_sym_addrs.addr_trace_buffer_ctrl;
6380  ipa_trace_buffer_ctrl_addr
6381  += sizeof (struct ipa_trace_buffer_control) * curr_tbctrl_idx;
6382 
6383  if (read_inferior_memory (ipa_trace_buffer_ctrl_addr,
6384  (unsigned char *) &ipa_trace_buffer_ctrl,
6385  sizeof (struct ipa_trace_buffer_control)))
6386  return;
6387 
6389  &ipa_trace_buffer_lo))
6390  return;
6392  &ipa_trace_buffer_hi))
6393  return;
6394 
6395  /* Offsets are easier to grok for debugging than raw addresses,
6396  especially for the small trace buffer sizes that are useful for
6397  testing. */
6398  trace_debug ("Lib: Trace buffer [%d] start=%d free=%d "
6399  "endfree=%d wrap=%d hi=%d",
6400  curr_tbctrl_idx,
6401  (int) (ipa_trace_buffer_ctrl.start - ipa_trace_buffer_lo),
6402  (int) (ipa_trace_buffer_ctrl.free - ipa_trace_buffer_lo),
6403  (int) (ipa_trace_buffer_ctrl.end_free - ipa_trace_buffer_lo),
6404  (int) (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo),
6405  (int) (ipa_trace_buffer_hi - ipa_trace_buffer_lo));
6406 
6407  /* Note that the IPA's buffer is always circular. */
6408 
6409 #define IPA_FIRST_TRACEFRAME() (ipa_trace_buffer_ctrl.start)
6410 
6411 #define IPA_NEXT_TRACEFRAME_1(TF, TFOBJ) \
6412  ((TF) + sizeof (struct traceframe) + (TFOBJ)->data_size)
6413 
6414 #define IPA_NEXT_TRACEFRAME(TF, TFOBJ) \
6415  (IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) \
6416  - ((IPA_NEXT_TRACEFRAME_1 (TF, TFOBJ) >= ipa_trace_buffer_ctrl.wrap) \
6417  ? (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo) \
6418  : 0))
6419 
6420  tf = IPA_FIRST_TRACEFRAME ();
6421 
6422  while (ipa_traceframe_write_count - ipa_traceframe_read_count)
6423  {
6424  struct tracepoint *tpoint;
6425  struct traceframe *tframe;
6426  unsigned char *block;
6427  struct traceframe ipa_tframe;
6428 
6429  if (read_inferior_memory (tf, (unsigned char *) &ipa_tframe,
6430  offsetof (struct traceframe, data)))
6431  error ("Uploading: couldn't read traceframe at %s\n", paddress (tf));
6432 
6433  if (ipa_tframe.tpnum == 0)
6434  {
6435  internal_error (__FILE__, __LINE__,
6436  "Uploading: No (more) fast traceframes, but"
6437  " ipa_traceframe_count == %u??\n",
6438  ipa_traceframe_write_count
6439  - ipa_traceframe_read_count);
6440  }
6441 
6442  /* Note that this will be incorrect for multi-location
6443  tracepoints... */
6444  tpoint = find_next_tracepoint_by_number (NULL, ipa_tframe.tpnum);
6445 
6446  tframe = add_traceframe (tpoint);
6447  if (tframe == NULL)
6448  {
6449  trace_buffer_is_full = 1;
6450  trace_debug ("Uploading: trace buffer is full");
6451  }
6452  else
6453  {
6454  /* Copy the whole set of blocks in one go for now. FIXME:
6455  split this in smaller blocks. */
6456  block = add_traceframe_block (tframe, tpoint,
6457  ipa_tframe.data_size);
6458  if (block != NULL)
6459  {
6460  if (read_inferior_memory (tf
6461  + offsetof (struct traceframe, data),
6462  block, ipa_tframe.data_size))
6463  error ("Uploading: Couldn't read traceframe data at %s\n",
6464  paddress (tf + offsetof (struct traceframe, data)));
6465  }
6466 
6467  trace_debug ("Uploading: traceframe didn't fit");
6468  finish_traceframe (tframe);
6469  }
6470 
6471  tf = IPA_NEXT_TRACEFRAME (tf, &ipa_tframe);
6472 
6473  /* If we freed the traceframe that wrapped around, go back
6474  to the non-wrap case. */
6475  if (tf < ipa_trace_buffer_ctrl.start)
6476  {
6477  trace_debug ("Lib: Discarding past the wraparound");
6478  ipa_trace_buffer_ctrl.wrap = ipa_trace_buffer_hi;
6479  }
6480  ipa_trace_buffer_ctrl.start = tf;
6481  ipa_trace_buffer_ctrl.end_free = ipa_trace_buffer_ctrl.start;
6482  ++ipa_traceframe_read_count;
6483 
6484  if (ipa_trace_buffer_ctrl.start == ipa_trace_buffer_ctrl.free
6485  && ipa_trace_buffer_ctrl.start == ipa_trace_buffer_ctrl.end_free)
6486  {
6487  trace_debug ("Lib: buffer is fully empty. "
6488  "Trace buffer [%d] start=%d free=%d endfree=%d",
6489  curr_tbctrl_idx,
6490  (int) (ipa_trace_buffer_ctrl.start
6491  - ipa_trace_buffer_lo),
6492  (int) (ipa_trace_buffer_ctrl.free
6493  - ipa_trace_buffer_lo),
6494  (int) (ipa_trace_buffer_ctrl.end_free
6495  - ipa_trace_buffer_lo));
6496 
6497  ipa_trace_buffer_ctrl.start = ipa_trace_buffer_lo;
6498  ipa_trace_buffer_ctrl.free = ipa_trace_buffer_lo;
6499  ipa_trace_buffer_ctrl.end_free = ipa_trace_buffer_hi;
6500  ipa_trace_buffer_ctrl.wrap = ipa_trace_buffer_hi;
6501  }
6502 
6503  trace_debug ("Uploaded a traceframe\n"
6504  "Lib: Trace buffer [%d] start=%d free=%d "
6505  "endfree=%d wrap=%d hi=%d",
6506  curr_tbctrl_idx,
6507  (int) (ipa_trace_buffer_ctrl.start - ipa_trace_buffer_lo),
6508  (int) (ipa_trace_buffer_ctrl.free - ipa_trace_buffer_lo),
6509  (int) (ipa_trace_buffer_ctrl.end_free
6510  - ipa_trace_buffer_lo),
6511  (int) (ipa_trace_buffer_ctrl.wrap - ipa_trace_buffer_lo),
6512  (int) (ipa_trace_buffer_hi - ipa_trace_buffer_lo));
6513  }
6514 
6515  if (write_inferior_memory (ipa_trace_buffer_ctrl_addr,
6516  (unsigned char *) &ipa_trace_buffer_ctrl,
6517  sizeof (struct ipa_trace_buffer_control)))
6518  return;
6519 
6521  ipa_traceframe_read_count);
6522 
6523  trace_debug ("Done uploading traceframes [%d]\n", curr_tbctrl_idx);
6524 
6525  pause_all (1);
6526 
6527  delete_breakpoint (about_to_request_buffer_space_bkpt);
6528  about_to_request_buffer_space_bkpt = NULL;
6529 
6530  unpause_all (1);
6531 
6532  if (trace_buffer_is_full)
6533  stop_tracing ();
6534 }
6535 #endif
6536 
6537 #ifdef IN_PROCESS_AGENT
6538 
6539 IP_AGENT_EXPORT_VAR int ust_loaded;
6541 
6542 #ifdef HAVE_UST
6543 
6544 /* Static tracepoints. */
6545 
6546 /* UST puts a "struct tracepoint" in the global namespace, which
6547  conflicts with our tracepoint. Arguably, being a library, it
6548  shouldn't take ownership of such a generic name. We work around it
6549  here. */
6550 #define tracepoint ust_tracepoint
6551 #include <ust/ust.h>
6552 #undef tracepoint
6553 
6554 extern int serialize_to_text (char *outbuf, int bufsize,
6555  const char *fmt, va_list ap);
6556 
6557 #define GDB_PROBE_NAME "gdb"
6558 
6559 /* We dynamically search for the UST symbols instead of linking them
6560  in. This lets the user decide if the application uses static
6561  tracepoints, instead of always pulling libust.so in. This vector
6562  holds pointers to all functions we care about. */
6563 
6564 static struct
6565 {
6566  int (*serialize_to_text) (char *outbuf, int bufsize,
6567  const char *fmt, va_list ap);
6568 
6569  int (*ltt_probe_register) (struct ltt_available_probe *pdata);
6570  int (*ltt_probe_unregister) (struct ltt_available_probe *pdata);
6571 
6572  int (*ltt_marker_connect) (const char *channel, const char *mname,
6573  const char *pname);
6574  int (*ltt_marker_disconnect) (const char *channel, const char *mname,
6575  const char *pname);
6576 
6577  void (*marker_iter_start) (struct marker_iter *iter);
6578  void (*marker_iter_next) (struct marker_iter *iter);
6579  void (*marker_iter_stop) (struct marker_iter *iter);
6580  void (*marker_iter_reset) (struct marker_iter *iter);
6581 } ust_ops;
6582 
6583 #include <dlfcn.h>
6584 
6585 /* Cast through typeof to catch incompatible API changes. Since UST
6586  only builds with gcc, we can freely use gcc extensions here
6587  too. */
6588 #define GET_UST_SYM(SYM) \
6589  do \
6590  { \
6591  if (ust_ops.SYM == NULL) \
6592  ust_ops.SYM = (typeof (&SYM)) dlsym (RTLD_DEFAULT, #SYM); \
6593  if (ust_ops.SYM == NULL) \
6594  return 0; \
6595  } while (0)
6596 
6597 #define USTF(SYM) ust_ops.SYM
6598 
6599 /* Get pointers to all libust.so functions we care about. */
6600 
6601 static int
6602 dlsym_ust (void)
6603 {
6604  GET_UST_SYM (serialize_to_text);
6605 
6606  GET_UST_SYM (ltt_probe_register);
6607  GET_UST_SYM (ltt_probe_unregister);
6608  GET_UST_SYM (ltt_marker_connect);
6609  GET_UST_SYM (ltt_marker_disconnect);
6610 
6611  GET_UST_SYM (marker_iter_start);
6612  GET_UST_SYM (marker_iter_next);
6613  GET_UST_SYM (marker_iter_stop);
6614  GET_UST_SYM (marker_iter_reset);
6615 
6616  ust_loaded = 1;
6617  return 1;
6618 }
6619 
6620 /* Given an UST marker, return the matching gdb static tracepoint.
6621  The match is done by address. */
6622 
6623 static struct tracepoint *
6624 ust_marker_to_static_tracepoint (const struct marker *mdata)
6625 {
6626  struct tracepoint *tpoint;
6627 
6628  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
6629  {
6630  if (tpoint->type != static_tracepoint)
6631  continue;
6632 
6633  if (tpoint->address == (uintptr_t) mdata->location)
6634  return tpoint;
6635  }
6636 
6637  return NULL;
6638 }
6639 
6640 /* The probe function we install on lttng/ust markers. Whenever a
6641  probed ust marker is hit, this function is called. This is similar
6642  to gdb_collect, only for static tracepoints, instead of fast
6643  tracepoints. */
6644 
6645 static void
6646 gdb_probe (const struct marker *mdata, void *probe_private,
6647  struct registers *regs, void *call_private,
6648  const char *fmt, va_list *args)
6649 {
6650  struct tracepoint *tpoint;
6651  struct static_tracepoint_ctx ctx;
6652 
6653  /* Don't do anything until the trace run is completely set up. */
6654  if (!tracing)
6655  {
6656  trace_debug ("gdb_probe: not tracing\n");
6657  return;
6658  }
6659 
6660  ctx.base.type = static_tracepoint;
6661  ctx.regcache_initted = 0;
6662  ctx.regs = regs;
6663  ctx.fmt = fmt;
6664  ctx.args = args;
6665 
6666  /* Wrap the regblock in a register cache (in the stack, we don't
6667  want to malloc here). */
6668  ctx.regspace = alloca (ipa_tdesc->registers_size);
6669  if (ctx.regspace == NULL)
6670  {
6671  trace_debug ("Trace buffer block allocation failed, skipping");
6672  return;
6673  }
6674 
6675  tpoint = ust_marker_to_static_tracepoint (mdata);
6676  if (tpoint == NULL)
6677  {
6678  trace_debug ("gdb_probe: marker not known: "
6679  "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6680  mdata->location, mdata->channel,
6681  mdata->name, mdata->format);
6682  return;
6683  }
6684 
6685  if (!tpoint->enabled)
6686  {
6687  trace_debug ("gdb_probe: tracepoint disabled");
6688  return;
6689  }
6690 
6691  ctx.tpoint = tpoint;
6692 
6693  trace_debug ("gdb_probe: collecting marker: "
6694  "loc:0x%p, ch:\"%s\",n:\"%s\",f:\"%s\"",
6695  mdata->location, mdata->channel,
6696  mdata->name, mdata->format);
6697 
6698  /* Test the condition if present, and collect if true. */
6699  if (tpoint->cond == NULL
6701  tpoint))
6702  {
6704  tpoint->address, tpoint);
6705 
6706  if (stopping_tracepoint
6707  || trace_buffer_is_full
6708  || expr_eval_result != expr_eval_no_error)
6709  stop_tracing ();
6710  }
6711  else
6712  {
6713  /* If there was a condition and it evaluated to false, the only
6714  way we would stop tracing is if there was an error during
6715  condition expression evaluation. */
6716  if (expr_eval_result != expr_eval_no_error)
6717  stop_tracing ();
6718  }
6719 }
6720 
6721 /* Called if the gdb static tracepoint requested collecting "$_sdata",
6722  static tracepoint string data. This is a string passed to the
6723  tracing library by the user, at the time of the tracepoint marker
6724  call. E.g., in the UST marker call:
6725 
6726  trace_mark (ust, bar33, "str %s", "FOOBAZ");
6727 
6728  the collected data is "str FOOBAZ".
6729 */
6730 
6731 static void
6732 collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx *ctx,
6733  struct traceframe *tframe)
6734 {
6735  struct static_tracepoint_ctx *umd = (struct static_tracepoint_ctx *) ctx;
6736  unsigned char *bufspace;
6737  int size;
6738  va_list copy;
6739  unsigned short blocklen;
6740 
6741  if (umd == NULL)
6742  {
6743  trace_debug ("Wanted to collect static trace data, "
6744  "but there's no static trace data");
6745  return;
6746  }
6747 
6748  va_copy (copy, *umd->args);
6749  size = USTF(serialize_to_text) (NULL, 0, umd->fmt, copy);
6750  va_end (copy);
6751 
6752  trace_debug ("Want to collect ust data");
6753 
6754  /* 'S' + size + string */
6755  bufspace = add_traceframe_block (tframe, umd->tpoint,
6756  1 + sizeof (blocklen) + size + 1);
6757  if (bufspace == NULL)
6758  {
6759  trace_debug ("Trace buffer block allocation failed, skipping");
6760  return;
6761  }
6762 
6763  /* Identify a static trace data block. */
6764  *bufspace = 'S';
6765 
6766  blocklen = size + 1;
6767  memcpy (bufspace + 1, &blocklen, sizeof (blocklen));
6768 
6769  va_copy (copy, *umd->args);
6770  USTF(serialize_to_text) ((char *) bufspace + 1 + sizeof (blocklen),
6771  size + 1, umd->fmt, copy);
6772  va_end (copy);
6773 
6774  trace_debug ("Storing static tracepoint data in regblock: %s",
6775  bufspace + 1 + sizeof (blocklen));
6776 }
6777 
6778 /* The probe to register with lttng/ust. */
6779 static struct ltt_available_probe gdb_ust_probe =
6780  {
6781  GDB_PROBE_NAME,
6782  NULL,
6783  gdb_probe,
6784  };
6785 
6786 #endif /* HAVE_UST */
6787 #endif /* IN_PROCESS_AGENT */
6788 
6789 #ifndef IN_PROCESS_AGENT
6790 
6791 /* Ask the in-process agent to run a command. Since we don't want to
6792  have to handle the IPA hitting breakpoints while running the
6793  command, we pause all threads, remove all breakpoints, and then set
6794  the helper thread re-running. We communicate with the helper
6795  thread by means of direct memory xfering, and a socket for
6796  synchronization. */
6797 
6798 static int
6799 run_inferior_command (char *cmd, int len)
6800 {
6801  int err = -1;
6802  int pid = ptid_get_pid (current_ptid);
6803 
6804  trace_debug ("run_inferior_command: running: %s", cmd);
6805 
6806  pause_all (0);
6808 
6809  err = agent_run_command (pid, (const char *) cmd, len);
6810 
6812  unpause_all (0);
6813 
6814  return err;
6815 }
6816 
6817 #else /* !IN_PROCESS_AGENT */
6818 
6819 #include <sys/socket.h>
6820 #include <sys/un.h>
6821 
6822 #ifndef UNIX_PATH_MAX
6823 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
6824 #endif
6825 
6826 /* Where we put the socked used for synchronization. */
6827 #define SOCK_DIR P_tmpdir
6828 
6829 /* Thread ID of the helper thread. GDBserver reads this to know which
6830  is the help thread. This is an LWP id on Linux. */
6834 
6835 static int
6836 init_named_socket (const char *name)
6837 {
6838  int result, fd;
6839  struct sockaddr_un addr;
6840 
6841  result = fd = socket (PF_UNIX, SOCK_STREAM, 0);
6842  if (result == -1)
6843  {
6844  warning ("socket creation failed: %s", strerror (errno));
6845  return -1;
6846  }
6847 
6848  addr.sun_family = AF_UNIX;
6849 
6850  strncpy (addr.sun_path, name, UNIX_PATH_MAX);
6851  addr.sun_path[UNIX_PATH_MAX - 1] = '\0';
6852 
6853  result = access (name, F_OK);
6854  if (result == 0)
6855  {
6856  /* File exists. */
6857  result = unlink (name);
6858  if (result == -1)
6859  {
6860  warning ("unlink failed: %s", strerror (errno));
6861  close (fd);
6862  return -1;
6863  }
6864  warning ("socket %s already exists; overwriting", name);
6865  }
6866 
6867  result = bind (fd, (struct sockaddr *) &addr, sizeof (addr));
6868  if (result == -1)
6869  {
6870  warning ("bind failed: %s", strerror (errno));
6871  close (fd);
6872  return -1;
6873  }
6874 
6875  result = listen (fd, 1);
6876  if (result == -1)
6877  {
6878  warning ("listen: %s", strerror (errno));
6879  close (fd);
6880  return -1;
6881  }
6882 
6883  return fd;
6884 }
6885 
6886 static char agent_socket_name[UNIX_PATH_MAX];
6887 
6888 static int
6889 gdb_agent_socket_init (void)
6890 {
6891  int result, fd;
6892 
6893  result = xsnprintf (agent_socket_name, UNIX_PATH_MAX, "%s/gdb_ust%d",
6894  SOCK_DIR, getpid ());
6895  if (result >= UNIX_PATH_MAX)
6896  {
6897  trace_debug ("string overflow allocating socket name");
6898  return -1;
6899  }
6900 
6901  fd = init_named_socket (agent_socket_name);
6902  if (fd < 0)
6903  warning ("Error initializing named socket (%s) for communication with the "
6904  "ust helper thread. Check that directory exists and that it "
6905  "is writable.", agent_socket_name);
6906 
6907  return fd;
6908 }
6909 
6910 #ifdef HAVE_UST
6911 
6912 /* The next marker to be returned on a qTsSTM command. */
6913 static const struct marker *next_st;
6914 
6915 /* Returns the first known marker. */
6916 
6917 struct marker *
6918 first_marker (void)
6919 {
6920  struct marker_iter iter;
6921 
6922  USTF(marker_iter_reset) (&iter);
6923  USTF(marker_iter_start) (&iter);
6924 
6925  return iter.marker;
6926 }
6927 
6928 /* Returns the marker following M. */
6929 
6930 const struct marker *
6931 next_marker (const struct marker *m)
6932 {
6933  struct marker_iter iter;
6934 
6935  USTF(marker_iter_reset) (&iter);
6936  USTF(marker_iter_start) (&iter);
6937 
6938  for (; iter.marker != NULL; USTF(marker_iter_next) (&iter))
6939  {
6940  if (iter.marker == m)
6941  {
6942  USTF(marker_iter_next) (&iter);
6943  return iter.marker;
6944  }
6945  }
6946 
6947  return NULL;
6948 }
6949 
6950 /* Return an hexstr version of the STR C string, fit for sending to
6951  GDB. */
6952 
6953 static char *
6954 cstr_to_hexstr (const char *str)
6955 {
6956  int len = strlen (str);
6957  char *hexstr = xmalloc (len * 2 + 1);
6958  bin2hex ((gdb_byte *) str, hexstr, len);
6959  return hexstr;
6960 }
6961 
6962 /* Compose packet that is the response to the qTsSTM/qTfSTM/qTSTMat
6963  packets. */
6964 
6965 static void
6966 response_ust_marker (char *packet, const struct marker *st)
6967 {
6968  char *strid, *format, *tmp;
6969 
6970  next_st = next_marker (st);
6971 
6972  tmp = xmalloc (strlen (st->channel) + 1 +
6973  strlen (st->name) + 1);
6974  sprintf (tmp, "%s/%s", st->channel, st->name);
6975 
6976  strid = cstr_to_hexstr (tmp);
6977  free (tmp);
6978 
6979  format = cstr_to_hexstr (st->format);
6980 
6981  sprintf (packet, "m%s:%s:%s",
6982  paddress ((uintptr_t) st->location),
6983  strid,
6984  format);
6985 
6986  free (strid);
6987  free (format);
6988 }
6989 
6990 /* Return the first static tracepoint, and initialize the state
6991  machine that will iterate through all the static tracepoints. */
6992 
6993 static void
6994 cmd_qtfstm (char *packet)
6995 {
6996  trace_debug ("Returning first trace state variable definition");
6997 
6998  if (first_marker ())
6999  response_ust_marker (packet, first_marker ());
7000  else
7001  strcpy (packet, "l");
7002 }
7003 
7004 /* Return additional trace state variable definitions. */
7005 
7006 static void
7007 cmd_qtsstm (char *packet)
7008 {
7009  trace_debug ("Returning static tracepoint");
7010 
7011  if (next_st)
7012  response_ust_marker (packet, next_st);
7013  else
7014  strcpy (packet, "l");
7015 }
7016 
7017 /* Disconnect the GDB probe from a marker at a given address. */
7018 
7019 static void
7020 unprobe_marker_at (char *packet)
7021 {
7022  char *p = packet;
7023  ULONGEST address;
7024  struct marker_iter iter;
7025 
7026  p += sizeof ("unprobe_marker_at:") - 1;
7027 
7028  p = unpack_varlen_hex (p, &address);
7029 
7030  USTF(marker_iter_reset) (&iter);
7031  USTF(marker_iter_start) (&iter);
7032  for (; iter.marker != NULL; USTF(marker_iter_next) (&iter))
7033  if ((uintptr_t ) iter.marker->location == address)
7034  {
7035  int result;
7036 
7037  result = USTF(ltt_marker_disconnect) (iter.marker->channel,
7038  iter.marker->name,
7039  GDB_PROBE_NAME);
7040  if (result < 0)
7041  warning ("could not disable marker %s/%s",
7042  iter.marker->channel, iter.marker->name);
7043  break;
7044  }
7045 }
7046 
7047 /* Connect the GDB probe to a marker at a given address. */
7048 
7049 static int
7050 probe_marker_at (char *packet)
7051 {
7052  char *p = packet;
7053  ULONGEST address;
7054  struct marker_iter iter;
7055  struct marker *m;
7056 
7057  p += sizeof ("probe_marker_at:") - 1;
7058 
7059  p = unpack_varlen_hex (p, &address);
7060 
7061  USTF(marker_iter_reset) (&iter);
7062 
7063  for (USTF(marker_iter_start) (&iter), m = iter.marker;
7064  m != NULL;
7065  USTF(marker_iter_next) (&iter), m = iter.marker)
7066  if ((uintptr_t ) m->location == address)
7067  {
7068  int result;
7069 
7070  trace_debug ("found marker for address. "
7071  "ltt_marker_connect (marker = %s/%s)",
7072  m->channel, m->name);
7073 
7074  result = USTF(ltt_marker_connect) (m->channel, m->name,
7075  GDB_PROBE_NAME);
7076  if (result && result != -EEXIST)
7077  trace_debug ("ltt_marker_connect (marker = %s/%s, errno = %d)",
7078  m->channel, m->name, -result);
7079 
7080  if (result < 0)
7081  {
7082  sprintf (packet, "E.could not connect marker: channel=%s, name=%s",
7083  m->channel, m->name);
7084  return -1;
7085  }
7086 
7087  strcpy (packet, "OK");
7088  return 0;
7089  }
7090 
7091  sprintf (packet, "E.no marker found at 0x%s", paddress (address));
7092  return -1;
7093 }
7094 
7095 static int
7096 cmd_qtstmat (char *packet)
7097 {
7098  char *p = packet;
7099  ULONGEST address;
7100  struct marker_iter iter;
7101  struct marker *m;
7102 
7103  p += sizeof ("qTSTMat:") - 1;
7104 
7105  p = unpack_varlen_hex (p, &address);
7106 
7107  USTF(marker_iter_reset) (&iter);
7108 
7109  for (USTF(marker_iter_start) (&iter), m = iter.marker;
7110  m != NULL;
7111  USTF(marker_iter_next) (&iter), m = iter.marker)
7112  if ((uintptr_t ) m->location == address)
7113  {
7114  response_ust_marker (packet, m);
7115  return 0;
7116  }
7117 
7118  strcpy (packet, "l");
7119  return -1;
7120 }
7121 
7122 static void
7123 gdb_ust_init (void)
7124 {
7125  if (!dlsym_ust ())
7126  return;
7127 
7128  USTF(ltt_probe_register) (&gdb_ust_probe);
7129 }
7130 
7131 #endif /* HAVE_UST */
7132 
7133 #include <sys/syscall.h>
7134 
7135 static void
7136 gdb_agent_remove_socket (void)
7137 {
7138  unlink (agent_socket_name);
7139 }
7140 
7141 /* Helper thread of agent. */
7142 
7143 static void *
7144 gdb_agent_helper_thread (void *arg)
7145 {
7146  int listen_fd;
7147 
7148  atexit (gdb_agent_remove_socket);
7149 
7150  while (1)
7151  {
7152  listen_fd = gdb_agent_socket_init ();
7153 
7154  if (helper_thread_id == 0)
7155  helper_thread_id = syscall (SYS_gettid);
7156 
7157  if (listen_fd == -1)
7158  {
7159  warning ("could not create sync socket\n");
7160  break;
7161  }
7162 
7163  while (1)
7164  {
7165  socklen_t tmp;
7166  struct sockaddr_un sockaddr;
7167  int fd;
7168  char buf[1];
7169  int ret;
7170  int stop_loop = 0;
7171 
7172  tmp = sizeof (sockaddr);
7173 
7174  do
7175  {
7176  fd = accept (listen_fd, (struct sockaddr *) &sockaddr, &tmp);
7177  }
7178  /* It seems an ERESTARTSYS can escape out of accept. */
7179  while (fd == -512 || (fd == -1 && errno == EINTR));
7180 
7181  if (fd < 0)
7182  {
7183  warning ("Accept returned %d, error: %s\n",
7184  fd, strerror (errno));
7185  break;
7186  }
7187 
7188  do
7189  {
7190  ret = read (fd, buf, 1);
7191  } while (ret == -1 && errno == EINTR);
7192 
7193  if (ret == -1)
7194  {
7195  warning ("reading socket (fd=%d) failed with %s",
7196  fd, strerror (errno));
7197  close (fd);
7198  break;
7199  }
7200 
7201  if (cmd_buf[0])
7202  {
7203  if (startswith (cmd_buf, "close"))
7204  {
7205  stop_loop = 1;
7206  }
7207 #ifdef HAVE_UST
7208  else if (strcmp ("qTfSTM", cmd_buf) == 0)
7209  {
7210  cmd_qtfstm (cmd_buf);
7211  }
7212  else if (strcmp ("qTsSTM", cmd_buf) == 0)
7213  {
7214  cmd_qtsstm (cmd_buf);
7215  }
7216  else if (startswith (cmd_buf, "unprobe_marker_at:"))
7217  {
7218  unprobe_marker_at (cmd_buf);
7219  }
7220  else if (startswith (cmd_buf, "probe_marker_at:"))
7221  {
7222  probe_marker_at (cmd_buf);
7223  }
7224  else if (startswith (cmd_buf, "qTSTMat:"))
7225  {
7226  cmd_qtstmat (cmd_buf);
7227  }
7228 #endif /* HAVE_UST */
7229  }
7230 
7231  /* Fix compiler's warning: ignoring return value of 'write'. */
7232  ret = write (fd, buf, 1);
7233  close (fd);
7234 
7235  if (stop_loop)
7236  {
7237  close (listen_fd);
7238  unlink (agent_socket_name);
7239 
7240  /* Sleep endlessly to wait the whole inferior stops. This
7241  thread can not exit because GDB or GDBserver may still need
7242  'current_thread' (representing this thread) to access
7243  inferior memory. Otherwise, this thread exits earlier than
7244  other threads, and 'current_thread' is set to NULL. */
7245  while (1)
7246  sleep (10);
7247  }
7248  }
7249  }
7250 
7251  return NULL;
7252 }
7253 
7254 #include <signal.h>
7255 #include <pthread.h>
7256 
7258 IP_AGENT_EXPORT_VAR int gdb_agent_capability = AGENT_CAPA_STATIC_TRACE;
7260 
7261 static void
7262 gdb_agent_init (void)
7263 {
7264  int res;
7265  pthread_t thread;
7266  sigset_t new_mask;
7267  sigset_t orig_mask;
7268 
7269  /* We want the helper thread to be as transparent as possible, so
7270  have it inherit an all-signals-blocked mask. */
7271 
7272  sigfillset (&new_mask);
7273  res = pthread_sigmask (SIG_SETMASK, &new_mask, &orig_mask);
7274  if (res)
7275  perror_with_name ("pthread_sigmask (1)");
7276 
7277  res = pthread_create (&thread,
7278  NULL,
7279  gdb_agent_helper_thread,
7280  NULL);
7281 
7282  res = pthread_sigmask (SIG_SETMASK, &orig_mask, NULL);
7283  if (res)
7284  perror_with_name ("pthread_sigmask (2)");
7285 
7286  while (helper_thread_id == 0)
7287  usleep (1);
7288 
7289 #ifdef HAVE_UST
7290  gdb_ust_init ();
7291 #endif
7292 }
7293 
7294 #include <sys/mman.h>
7295 #include <fcntl.h>
7296 
7297 IP_AGENT_EXPORT_VAR char *gdb_tp_heap_buffer;
7298 IP_AGENT_EXPORT_VAR char *gdb_jump_pad_buffer;
7299 IP_AGENT_EXPORT_VAR char *gdb_jump_pad_buffer_end;
7300 IP_AGENT_EXPORT_VAR char *gdb_trampoline_buffer;
7301 IP_AGENT_EXPORT_VAR char *gdb_trampoline_buffer_end;
7302 IP_AGENT_EXPORT_VAR char *gdb_trampoline_buffer_error;
7303 
7304 /* Record the result of getting buffer space for fast tracepoint
7305  trampolines. Any error message is copied, since caller may not be
7306  using persistent storage. */
7307 
7308 void
7309 set_trampoline_buffer_space (CORE_ADDR begin, CORE_ADDR end, char *errmsg)
7310 {
7311  gdb_trampoline_buffer = (char *) (uintptr_t) begin;
7312  gdb_trampoline_buffer_end = (char *) (uintptr_t) end;
7313  if (errmsg)
7314  strncpy (gdb_trampoline_buffer_error, errmsg, 99);
7315  else
7316  strcpy (gdb_trampoline_buffer_error, "no buffer passed");
7317 }
7318 
7319 static void __attribute__ ((constructor))
7320 initialize_tracepoint_ftlib (void)
7321 {
7323 
7324  gdb_agent_init ();
7325 }
7326 
7327 #endif /* IN_PROCESS_AGENT */
7328 
7329 /* Return a timestamp, expressed as microseconds of the usual Unix
7330  time. (As the result is a 64-bit number, it will not overflow any
7331  time soon.) */
7332 
7333 static LONGEST
7335 {
7336  struct timeval tv;
7337 
7338  if (gettimeofday (&tv, 0) != 0)
7339  return -1;
7340  else
7341  return (LONGEST) tv.tv_sec * 1000000 + tv.tv_usec;
7342 }
7343 
7344 void
7346 {
7347  /* Start with the default size. */
7349 
7350  /* Wire trace state variable 1 to be the timestamp. This will be
7351  uploaded to GDB upon connection and become one of its trace state
7352  variables. (In case you're wondering, if GDB already has a trace
7353  variable numbered 1, it will be renumbered.) */
7355  set_trace_state_variable_name (1, "trace_timestamp");
7357 
7358 #ifdef IN_PROCESS_AGENT
7359  {
7360  uintptr_t addr;
7361  int pagesize;
7362 
7363  pagesize = sysconf (_SC_PAGE_SIZE);
7364  if (pagesize == -1)
7365  perror_with_name ("sysconf");
7366 
7367  gdb_tp_heap_buffer = xmalloc (5 * 1024 * 1024);
7368 
7369 #define SCRATCH_BUFFER_NPAGES 20
7370 
7371  /* Allocate scratch buffer aligned on a page boundary, at a low
7372  address (close to the main executable's code). */
7373  for (addr = pagesize; addr != 0; addr += pagesize)
7374  {
7375  gdb_jump_pad_buffer = mmap ((void *) addr, pagesize * SCRATCH_BUFFER_NPAGES,
7376  PROT_READ | PROT_WRITE | PROT_EXEC,
7377  MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
7378  -1, 0);
7379  if (gdb_jump_pad_buffer != MAP_FAILED)
7380  break;
7381  }
7382 
7383  if (addr == 0)
7384  perror_with_name ("mmap");
7385 
7386  gdb_jump_pad_buffer_end = gdb_jump_pad_buffer + pagesize * SCRATCH_BUFFER_NPAGES;
7387  }
7388 
7389  gdb_trampoline_buffer = gdb_trampoline_buffer_end = 0;
7390 
7391  /* It's not a fatal error for something to go wrong with trampoline
7392  buffer setup, but it can be mysterious, so create a channel to
7393  report back on what went wrong, using a fixed size since we may
7394  not be able to allocate space later when the problem occurs. */
7395  gdb_trampoline_buffer_error = xmalloc (IPA_BUFSIZ);
7396 
7397  strcpy (gdb_trampoline_buffer_error, "No errors reported");
7398 
7400 #endif
7401 }
int debug_threads
Definition: debug.c:24
CORE_ADDR compiled_cond
Definition: tracepoint.c:753
static CORE_ADDR get_jump_space_head(void)
Definition: tracepoint.c:2925
const struct target_desc * tdesc
Definition: regcache.h:41
int handle_tracepoint_query(char *packet)
Definition: tracepoint.c:4235
static const struct tracepoint_action_ops r_tracepoint_action_ops
Definition: tracepoint.c:574
#define IPA_PROTO_FAST_TRACE_FJUMP_INSN
Definition: tracepoint.c:6072
#define IPA_CMD_BUF_SIZE
Definition: agent.h:35
LONGEST agent_get_trace_state_variable_value(int num)
Definition: tracepoint.c:2153
CORE_ADDR get_set_tsv_func_addr(void)
Definition: tracepoint.c:5872
static struct source_string * cur_source_string
Definition: tracepoint.c:3729
static int tracing_stop_tpnum
Definition: tracepoint.c:1264
static int tracepoint_handler(CORE_ADDR address)
Definition: tracepoint.c:387
struct thread_info * current_thread
Definition: inferiors.c:28
struct regcache * regcache
Definition: tracepoint.c:1351
static void cmd_qtminftpilen(char *packet)
Definition: tracepoint.c:3986
struct source_string * source_strings
Definition: tracepoint.c:766
static void cmd_qtfstm(char *packet)
Definition: tracepoint.c:3921
#define IP_AGENT_EXPORT_FUNC
Definition: tracepoint.h:65
static struct tracepoint * fast_tracepoint_from_ipa_tpoint_address(CORE_ADDR)
Definition: tracepoint.c:5518
static struct trace_state_variable * create_trace_state_variable(int num, int gdb)
Definition: tracepoint.c:2080
CORE_ADDR addr_gdb_jump_pad_buffer_end
Definition: tracepoint.c:147
IP_AGENT_EXPORT_VAR unsigned int traceframe_write_count
Definition: tracepoint.c:1209
CORE_ADDR addr_get_raw_reg
Definition: tracepoint.c:170
CORE_ADDR addr_tracepoints
Definition: tracepoint.c:160
static unsigned char * traceframe_find_block_type(unsigned char *database, unsigned int datasize, int tfnum, char type_wanted)
Definition: tracepoint.c:5158
int fetch_traceframe_registers(int tfnum, struct regcache *regcache, int regnum)
Definition: tracepoint.c:5183
#define target_get_min_fast_tracepoint_insn_len()
Definition: target.h:510
static struct traceframe * find_next_traceframe_by_tracepoint(int num, int *tfnump)
Definition: tracepoint.c:2325
#define install_fast_tracepoint_jump_pad(tpoint, tpaddr,collector, lockaddr,orig_size,jump_entry,trampoline, trampoline_size, jjump_pad_insn,jjump_pad_insn_size,adjusted_insn_addr,adjusted_insn_addr_end, err)
Definition: target.h:538
EXTERN_C_PUSH IP_AGENT_EXPORT_VAR struct tracepoint * tracepoints
Definition: tracepoint.c:840
static void cmd_qtframe(char *own_buf)
Definition: tracepoint.c:3543
struct collecting_t collecting_t
int agent_look_up_symbols(void *arg)
Definition: agent.c:87
IP_AGENT_EXPORT_VAR unsigned int traceframe_read_count
Definition: tracepoint.c:1210
unsigned char data[0]
Definition: tracepoint.c:973
CORE_ADDR address
Definition: tracepoint.c:722
static void write_e_ust_not_loaded(char *buffer)
Definition: tracepoint.c:260
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define target_emit_ops()
Definition: target.h:559
#define IPA_FIRST_TRACEFRAME()
static int traceframe_read_tsv(int num, LONGEST *val)
Definition: tracepoint.c:5296
static struct trace_state_variable * get_trace_state_variable(int num)
Definition: tracepoint.c:2058
#define cmpxchg(mem, oldval, newval)
Definition: tracepoint.c:1406
static struct readonly_region * readonly_regions
Definition: tracepoint.c:1244
#define unpause_all(unfreeze)
Definition: target.h:524
static void cmd_qtv(char *own_buf)
Definition: tracepoint.c:2818
LONGEST(* getter)(void)
Definition: tracepoint.c:903
int socklen_t
Definition: remote-utils.c:70
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:439
struct trace_state_variable * next
Definition: tracepoint.c:906
void warning(const char *fmt,...)
Definition: errors.c:26
uint64_t pass_count
Definition: tracepoint.c:736
CORE_ADDR addr_traceframe_write_count
Definition: tracepoint.c:167
static CORE_ADDR get_traceframe_address(struct traceframe *tframe)
Definition: tracepoint.c:2271
static const struct tracepoint_action_ops l_tracepoint_action_ops
Definition: tracepoint.c:657
static void cmd_qtnotes(char *own_buf)
Definition: tracepoint.c:4098
CORE_ADDR addr_trace_buffer_is_full
Definition: tracepoint.c:156
static int read_inferior_data_pointer(CORE_ADDR symaddr, CORE_ADDR *val)
Definition: tracepoint.c:425
char ** step_actions_str
Definition: tracepoint.c:799
static int same_process_p(struct inferior_list_entry *entry, void *data)
Definition: tracepoint.c:3950
static unsigned int cur_action
Definition: tracepoint.c:3727
static struct tracepoint * fast_tracepoint_from_trampoline_address(CORE_ADDR pc)
Definition: tracepoint.c:5499
struct tracepoint_action base
Definition: tracepoint.c:494
static void cmd_qtdisconnected(char *own_buf)
Definition: tracepoint.c:3528
void * handle
Definition: tracepoint.c:804
int bin2hex(const gdb_byte *bin, char *hex, int count)
Definition: rsp-low.c:136
const struct tracepoint_action_ops * ops
Definition: tracepoint.c:486
static unsigned char * traceframe_find_regblock(struct traceframe *tframe, int tfnum)
Definition: tracepoint.c:5166
static void write_e_ipa_not_loaded(char *buffer)
Definition: tracepoint.c:249
uintptr_t tpoint
Definition: tracepoint.c:5538
static CORE_ADDR target_tp_heap
Definition: tracepoint.c:5939
CORE_ADDR addr_trace_buffer_hi
Definition: tracepoint.c:165
#define IP_AGENT_EXPORT_VAR
Definition: tracepoint.h:66
CORE_ADDR adjusted_insn_addr_end
Definition: tracepoint.h:115
void initialize_tracepoint(void)
Definition: tracepoint.c:7345
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
IP_AGENT_EXPORT_FUNC LONGEST get_trace_state_variable_value(int num)
Definition: tracepoint.c:2111
static void cmd_qtsv(char *packet)
Definition: tracepoint.c:3900
int agent_mem_read(struct eval_agent_expr_context *ctx, unsigned char *to, CORE_ADDR from, ULONGEST len)
Definition: tracepoint.c:4938
enum eval_result_type compile_bytecodes(struct agent_expr *aexpr)
Definition: ax.c:400
CORE_ADDR adjusted_insn_addr
Definition: tracepoint.c:779
#define UALIGN(V, N)
Definition: tracepoint.c:5987
static void record_tracepoint_error(struct tracepoint *tpoint, const char *which, enum eval_result_type rtype)
Definition: tracepoint.c:1412
static void do_action_at_tracepoint(struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc, struct tracepoint *tpoint, struct traceframe *tframe, struct tracepoint_action *taction)
Definition: tracepoint.c:4770
static void cmd_qtsp(char *packet)
Definition: tracepoint.c:3817
#define DEFAULT_TRACE_BUFFER_SIZE
Definition: tracepoint.c:33
char * paddress(CORE_ADDR addr)
Definition: utils.c:124
Definition: ax.h:47
CORE_ADDR addr_traceframe_read_count
Definition: tracepoint.c:166
struct tracepoint_action base
Definition: tracepoint.c:505
CORE_ADDR start
Definition: tracepoint.c:1235
ptid_t id
Definition: inferiors.h:31
const char * name
Definition: tracepoint.c:178
#define NEXT_TRACEFRAME(TF)
Definition: tracepoint.c:1199
IP_AGENT_EXPORT_VAR enum eval_result_type expr_eval_result
Definition: tracepoint.c:852
static void clear_trace_buffer(void)
Definition: tracepoint.c:1435
#define trace_buffer_end_free
Definition: tracepoint.c:1183
regnum
struct wstep_state * while_stepping
Definition: gdbthread.h:67
static void init_trace_buffer(LONGEST bufsize)
Definition: tracepoint.c:1488
void agent_set_trace_state_variable_value(int num, LONGEST val)
Definition: tracepoint.c:2159
struct readonly_region * next
Definition: tracepoint.c:1238
static void clear_readonly_regions(void)
Definition: tracepoint.c:2854
IP_AGENT_EXPORT_VAR struct tracepoint * stopping_tracepoint
Definition: tracepoint.c:844
static int tracepoint_send_agent(struct tracepoint *tpoint)
Definition: tracepoint.c:6077
static char * agent_expr_send(char *p, const struct agent_expr *aexpr)
Definition: tracepoint.c:604
static char * m_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
Definition: tracepoint.c:537
CORE_ADDR addr_set_trace_state_variable_value
Definition: tracepoint.c:172
void uninsert_all_breakpoints(void)
Definition: mem-break.c:1483
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:453
static char * x_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
Definition: tracepoint.c:625
void reinsert_all_breakpoints(void)
Definition: mem-break.c:1540
#define GDBSERVER_UPDATED_FLUSH_COUNT_BIT
Definition: tracepoint.c:1160
void emit_prologue(void)
Definition: ax.c:154
enum eval_result_type(* condfn)(struct tracepoint_hit_ctx *, ULONGEST *)
Definition: tracepoint.c:699
char *(* send)(char *buffer, const struct tracepoint_action *action)
Definition: tracepoint.c:478
struct inferior_list_entry entry
Definition: gdbthread.h:30
static struct @5 symbol_list[]
static int circular_trace_buffer
Definition: tracepoint.c:991
#define memory_barrier()
Definition: tracepoint.c:1400
uint32_t orig_size
Definition: tracepoint.c:771
#define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD)
Definition: tracepoint.c:458
#define IPA_PROTO_FAST_TRACE_FJUMP_SIZE
Definition: tracepoint.c:6071
int tracepoint_was_hit(struct thread_info *tinfo, CORE_ADDR stop_pc)
Definition: tracepoint.c:4556
static int write_inferior_data_pointer(CORE_ADDR symaddr, CORE_ADDR val)
Definition: tracepoint.c:436
int agent_run_command(int pid, const char *cmd, int len)
Definition: agent.c:189
CORE_ADDR addr_tracing
Definition: tracepoint.c:161
static int probe_marker_at(CORE_ADDR address, char *errout)
Definition: tracepoint.c:3036
CORE_ADDR addr_ust_loaded
Definition: tracepoint.c:173
struct tracepoint_action base
Definition: tracepoint.c:520
char * tracing_notes
Definition: tracepoint.c:1280
void emit_epilogue(void)
Definition: ax.c:160
static void download_tracepoint_1(struct tracepoint *tpoint)
Definition: tracepoint.c:5992
int agent_tsv_read(struct eval_agent_expr_context *ctx, int n)
Definition: tracepoint.c:5042
static const struct tracepoint_action_ops m_tracepoint_action_ops
Definition: tracepoint.c:549
CORE_ADDR addr_stopping_tracepoint
Definition: tracepoint.c:157
struct pt_watch_regs __attribute__
int handle_tracepoint_bkpts(struct thread_info *tinfo, CORE_ADDR stop_pc)
Definition: tracepoint.c:4474
struct tracepoint * next
Definition: tracepoint.c:756
static struct tracepoint * find_next_tracepoint_by_number(struct tracepoint *prev_tp, int num)
Definition: tracepoint.c:1898
static CORE_ADDR gdb_jump_pad_head
Definition: tracepoint.c:2920
int agent_mem_read_string(struct eval_agent_expr_context *ctx, unsigned char *to, CORE_ADDR from, ULONGEST len)
Definition: tracepoint.c:4980
CORE_ADDR tp_address
Definition: tracepoint.c:826
uintptr_t thread_area
Definition: tracepoint.c:5547
static void claim_jump_space(ULONGEST used)
Definition: tracepoint.c:2943
#define trace_buffer_start
Definition: tracepoint.c:1181
static int match_blocktype(char blocktype, unsigned char *dataptr, void *data)
Definition: tracepoint.c:5067
int fast_tracepoint_collecting(CORE_ADDR thread_area, CORE_ADDR stop_pc, struct fast_tpoint_collect_status *status)
Definition: tracepoint.c:5569
CORE_ADDR addr_gdb_trampoline_buffer_end
Definition: tracepoint.c:149
static const struct tracepoint_action_ops x_tracepoint_action_ops
Definition: tracepoint.c:632
static CORE_ADDR trampoline_buffer_tail
Definition: tracepoint.c:2951
void release_while_stepping_state_list(struct thread_info *tinfo)
Definition: tracepoint.c:4351
static LONGEST get_timestamp(void)
Definition: tracepoint.c:7334
struct tracepoint_hit_ctx base
Definition: tracepoint.c:1349
static int write_inferior_integer(CORE_ADDR symaddr, int val)
Definition: tracepoint.c:444
static void finish_traceframe(struct traceframe *tframe)
Definition: tracepoint.c:2241
void buffer_xml_printf(struct buffer *buffer, const char *format,...)
Definition: buffer.c:76
CORE_ADDR current_insn_ptr
Definition: ax.c:139
char ** actions_str
Definition: tracepoint.c:761
int length
Definition: ax.h:49
IP_AGENT_EXPORT_FUNC void set_trace_state_variable_value(int num, LONGEST val)
Definition: tracepoint.c:2137
static void * trace_buffer_alloc(size_t amt)
Definition: tracepoint.c:1521
static int maybe_write_ipa_ust_not_loaded(char *buffer)
Definition: tracepoint.c:290
CORE_ADDR addr_gdb_tp_heap_buffer
Definition: tracepoint.c:145
int in_readonly_region(CORE_ADDR addr, ULONGEST length)
Definition: tracepoint.c:2906
static void collect_data_at_tracepoint(struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc, struct tracepoint *tpoint)
Definition: tracepoint.c:4625
IP_AGENT_EXPORT_VAR int traceframes_created
Definition: tracepoint.c:1220
CORE_ADDR addr_trace_buffer_ctrl
Definition: tracepoint.c:162
uint64_t step_count
Definition: tracepoint.c:732
int offset
Definition: tracepoint.c:179
static uint32_t helper_thread_id
Definition: agent.c:60
struct callback_event * last
Definition: event-loop.c:142
int read_inferior_memory(CORE_ADDR memaddr, unsigned char *myaddr, int len)
Definition: target.c:43
static void clear_inferior_trace_buffer(void)
Definition: tracepoint.c:1451
#define IPA_SYM(SYM)
Definition: agent.h:27
void stop_tracing(void)
Definition: tracepoint.c:3403
CORE_ADDR addr_gdb_collect
Definition: tracepoint.c:152
CORE_ADDR addr_gdb_jump_pad_buffer
Definition: tracepoint.c:146
static void set_trace_state_variable_name(int num, const char *name)
Definition: tracepoint.c:2165
static void cmd_qtfv(char *packet)
Definition: tracepoint.c:3885
static int flush_trace_buffer_handler(CORE_ADDR)
Definition: tracepoint.c:3514
#define IPA_BUFSIZ
Definition: tracepoint.h:24
static void add_tracepoint_action(struct tracepoint *tpoint, char *packet)
Definition: tracepoint.c:1918
unsigned int data_size
Definition: tracepoint.c:970
CORE_ADDR(* download)(const struct tracepoint_action *action)
Definition: tracepoint.c:474
struct tracepoint * tpoint
Definition: ax.h:81
static void cmd_qtdpsrc(char *own_buf)
Definition: tracepoint.c:2658
void write_ok(char *buf)
int handle_tracepoint_general_set(char *packet)
Definition: tracepoint.c:4158
#define current_ptid
Definition: gdbthread.h:83
static unsigned int cur_step_action
Definition: tracepoint.c:3728
int agent_loaded_p(void)
Definition: agent.c:78
int look_up_one_symbol(const char *name, CORE_ADDR *addrp, int may_ask_gdb)
#define EXTERN_C_PUSH
Definition: common-defs.h:59
CORE_ADDR jump_pad
Definition: tracepoint.c:785
static CORE_ADDR trampoline_buffer_head
Definition: tracepoint.c:2950
#define done_accessing_memory()
Definition: target.h:622
CORE_ADDR addr_expr_eval_result
Definition: tracepoint.c:158
EXTERN_C_PUSH IP_AGENT_EXPORT_VAR struct tracepoint * error_tracepoint
Definition: tracepoint.c:880
static EXTERN_C_POP struct tracepoint * last_tracepoint
Definition: tracepoint.c:861
int required
Definition: tracepoint.c:180
void tracepoint_look_up_symbols(void)
Definition: tracepoint.c:312
static void response_action(char *packet, struct tracepoint *tpoint, char *taction, int step)
Definition: tracepoint.c:3765
int traceframe_read_info(int tfnum, struct buffer *buffer)
Definition: tracepoint.c:5460
static int condition_true_at_tracepoint(struct tracepoint_hit_ctx *ctx, struct tracepoint *tpoint)
Definition: tracepoint.c:4887
static int free_space(void)
Definition: tracepoint.c:1782
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void regcache_cpy(struct regcache *dst, struct regcache *src)
Definition: regcache.c:185
int num_step_actions
Definition: tracepoint.c:796
static void clone_fast_tracepoint(struct tracepoint *to, const struct tracepoint *from)
Definition: tracepoint.c:3057
struct source_string * next
Definition: tracepoint.c:681
static CORE_ADDR download_agent_expr(struct agent_expr *expr)
Definition: tracepoint.c:5970
static void cmd_qtsstm(char *packet)
Definition: tracepoint.c:3930
static void compile_tracepoint_condition(struct tracepoint *tpoint, CORE_ADDR *jump_entry)
Definition: tracepoint.c:5878
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
int register_cache_size(const struct target_desc *tdesc)
Definition: regcache.c:308
struct trace_buffer_control trace_buffer_ctrl[1]
Definition: tracepoint.c:1175
enum eval_result_type gdb_eval_agent_expr(struct eval_agent_expr_context *ctx, struct agent_expr *aexpr, ULONGEST *rslt)
Definition: ax.c:928
#define GDBSERVER_FLUSH_COUNT_MASK_PREV
Definition: tracepoint.c:1155
static void cmd_qtstatus(char *packet)
Definition: tracepoint.c:3613
static void cmd_qtro(char *own_buf)
Definition: tracepoint.c:2871
CORE_ADDR obj_addr_on_target
Definition: tracepoint.c:774
static struct tracepoint * fast_tracepoint_from_jump_pad_address(CORE_ADDR pc)
Definition: tracepoint.c:5484
char * tracing_stop_note
Definition: tracepoint.c:1285
CORE_ADDR addr_gdb_trampoline_buffer_error
Definition: tracepoint.c:150
static void set_trace_state_variable_getter(int num, LONGEST(*getter)(void))
Definition: tracepoint.c:2181
static void release_while_stepping_state(struct wstep_state *wstep)
Definition: tracepoint.c:4342
static int maybe_write_ipa_not_loaded(char *buffer)
Definition: tracepoint.c:275
CORE_ADDR addr_traceframes_created
Definition: tracepoint.c:168
char * tracing_user_name
Definition: tracepoint.c:1275
int disconnected_tracing
Definition: tracepoint.c:1256
static struct tracepoint * find_tracepoint(int id, CORE_ADDR addr)
Definition: tracepoint.c:1859
char * unpack_varlen_hex(char *buff, ULONGEST *result)
Definition: rsp-low.c:96
struct breakpoint * flush_trace_buffer_bkpt
Definition: tracepoint.c:399
static struct tracepoint * cur_tpoint
Definition: tracepoint.c:3726
struct tracepoint_action ** actions
Definition: tracepoint.c:744
struct traceframe * tframe
Definition: ax.h:79
static void cmd_qtstop(char *packet)
Definition: tracepoint.c:3521
struct breakpoint * stop_tracing_bkpt
Definition: tracepoint.c:395
tracepoint_type
Definition: tracepoint.c:684
#define GDBSERVER_FLUSH_COUNT_MASK
Definition: tracepoint.c:1150
static void cmd_qtinit(char *packet)
Definition: tracepoint.c:2356
#define TRACEFRAME_EOB_MARKER_SIZE
Definition: tracepoint.c:979
#define buffer_grow_str(BUFFER, STRING)
Definition: buffer.h:54
struct inferior_list all_threads
Definition: inferiors.c:26
struct tracepoint_action base
Definition: tracepoint.c:512
static LONGEST trace_buffer_size
Definition: tracepoint.c:996
#define prepare_to_access_memory()
Definition: target.h:617
static void remove_tracepoint(struct tracepoint *tpoint)
Definition: tracepoint.c:1873
static CORE_ADDR target_malloc(ULONGEST size)
Definition: tracepoint.c:5945
struct fast_tracepoint_jump * set_fast_tracepoint_jump(CORE_ADDR where, unsigned char *insn, ULONGEST length)
Definition: mem-break.c:568
unsigned char * bytes
Definition: ax.h:51
static void cmd_qtbuffer(char *own_buf)
Definition: tracepoint.c:4003
#define ATTR_PACKED
Definition: tracepoint.c:948
int have_fast_tracepoint_trampoline_buffer(char *buf)
Definition: tracepoint.c:3001
int registers_size
Definition: tdesc.h:37
#define errno
Definition: wincecompat.h:24
int agent_capability_check(enum agent_capa agent_capa)
Definition: agent.c:263
static void cmd_qtstmat(char *packet)
Definition: tracepoint.c:3940
static void clear_installed_tracepoints(void)
Definition: tracepoint.c:2427
static int seen_step_action_flag
Definition: tracepoint.c:1794
struct agent_expr * gdb_parse_agent_expr(char **actparm)
Definition: ax.c:96
static unsigned char * traceframe_walk_blocks(unsigned char *database, unsigned int datasize, int tfnum, int(*callback)(char blocktype, unsigned char *dataptr, void *data), void *data)
Definition: tracepoint.c:5085
#define stabilize_threads()
Definition: target.h:531
int write_inferior_memory(CORE_ADDR memaddr, const unsigned char *myaddr, int len)
Definition: target.c:68
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
static void ATTRIBUTE_PRINTF(1, 2)
Definition: agent.c:31
int use_agent
Definition: agent.c:46
LONGEST tracing_start_time
Definition: tracepoint.c:1269
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
static struct traceframe * find_traceframe(int num)
Definition: tracepoint.c:2253
static struct traceframe * find_next_traceframe_in_range(CORE_ADDR lo, CORE_ADDR hi, int inside_p, int *tfnump)
Definition: tracepoint.c:2291
IP_AGENT_EXPORT_VAR int trace_buffer_is_full
Definition: tracepoint.c:848
static CORE_ADDR x_tracepoint_action_download(const struct tracepoint_action *action)
Definition: tracepoint.c:583
struct regcache * init_register_cache(struct regcache *regcache, const struct target_desc *tdesc, unsigned char *regbuf)
Definition: regcache.c:122
#define buffer_grow_str0(BUFFER, STRING)
Definition: buffer.h:56
bfd_byte gdb_byte
Definition: common-types.h:38
unsigned char * wrap
Definition: tracepoint.c:1039
void xfree(void *ptr)
Definition: common-utils.c:97
#define F_OK
Definition: unistd.h:543
CORE_ADDR addr_gdb_trampoline_buffer
Definition: tracepoint.c:148
#define EXTERN_C_POP
Definition: common-defs.h:60
CORE_ADDR addr_trace_buffer_lo
Definition: tracepoint.c:164
#define trace_buffer_free
Definition: tracepoint.c:1182
int claim_trampoline_space(ULONGEST used, CORE_ADDR *trampoline)
Definition: tracepoint.c:2958
#define pause_all(freeze)
Definition: target.h:517
int8_t enabled
Definition: tracepoint.c:728
static void cmd_qtdv(char *own_buf)
Definition: tracepoint.c:2719
void force_unlock_trace_buffer(void)
Definition: tracepoint.c:5553
static void cmd_qtenable_disable(char *own_buf, int enable)
Definition: tracepoint.c:2751
uint64_t traceframe_usage
Definition: tracepoint.c:751
struct wstep_state * next
Definition: tracepoint.c:821
const struct target_desc * current_target_desc(void)
Definition: tdesc.c:57
int tracepoint_finished_step(struct thread_info *tinfo, CORE_ADDR stop_pc)
Definition: tracepoint.c:4369
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
CORE_ADDR addr_flush_trace_buffer
Definition: tracepoint.c:154
void * alloca(size_t)
unsigned char * start
Definition: tracepoint.c:1022
static void cmd_bigqtbuffer_size(char *own_buf)
Definition: tracepoint.c:4067
static CORE_ADDR l_tracepoint_action_download(const struct tracepoint_action *action)
Definition: tracepoint.c:639
CORE_ADDR get_raw_reg_func_addr(void)
Definition: tracepoint.c:5860
unsigned char * free
Definition: tracepoint.c:1027
const char * target_pid_to_str(ptid_t ptid)
Definition: target.c:193
eval_result_type
Definition: ax.h:34
static char * own_buf
Definition: server.c:111
static void cmd_qtp(char *own_buf)
Definition: tracepoint.c:3698
Definition: buffer.h:23
uint64_t hit_count
Definition: tracepoint.c:748
CORE_ADDR trampoline_end
Definition: tracepoint.c:792
static void response_source(char *packet, struct tracepoint *tpoint, struct source_string *src)
Definition: tracepoint.c:3777
static int read_inferior_uinteger(CORE_ADDR symaddr, unsigned int *val)
Definition: tracepoint.c:418
unsigned char * end_free
Definition: tracepoint.c:1034
static struct regcache * get_context_regcache(struct tracepoint_hit_ctx *ctx)
Definition: tracepoint.c:4718
static void install_tracepoint(struct tracepoint *, char *own_buf)
Definition: tracepoint.c:3139
static void cmd_qtstart(char *packet)
Definition: tracepoint.c:3196
static int read_inferior_integer(CORE_ADDR symaddr, int *val)
Definition: tracepoint.c:408
static struct tracepoint * add_tracepoint(int num, CORE_ADDR addr)
Definition: tracepoint.c:1800
struct regcache * get_thread_regcache(struct thread_info *thread, int fetch)
Definition: regcache.c:27
void initialize_low_tracepoint(void)
static void response_tsv(char *packet, struct trace_state_variable *tsv)
Definition: tracepoint.c:3865
IP_AGENT_EXPORT_VAR int tracing
Definition: tracepoint.c:1250
#define PROG
Definition: server.h:54
static void response_tracepoint(char *packet, struct tracepoint *tpoint)
Definition: tracepoint.c:3736
void perror_with_name(const char *string)
Definition: utils.c:57
static unsigned char * add_traceframe_block(struct traceframe *tframe, struct tracepoint *tpoint, int amt)
Definition: tracepoint.c:2217
static int build_traceframe_info_xml(char blocktype, unsigned char *dataptr, void *data)
Definition: tracepoint.c:5413
int delete_fast_tracepoint_jump(struct fast_tracepoint_jump *todel)
Definition: mem-break.c:500
uint32_t numactions
Definition: tracepoint.c:743
static void unprobe_marker_at(CORE_ADDR address)
Definition: tracepoint.c:2414
struct tracepoint_action ** step_actions
Definition: tracepoint.c:797
static void cmd_bigqtbuffer_circular(char *own_buf)
Definition: tracepoint.c:4052
static CORE_ADDR traceframe_get_pc(struct traceframe *tframe)
Definition: tracepoint.c:5217
CORE_ADDR addr_about_to_request_buffer_space
Definition: tracepoint.c:155
#define trace_debug(FMT, args...)
Definition: tracepoint.c:97
IP_AGENT_EXPORT_VAR unsigned char * trace_buffer_hi
Definition: tracepoint.c:1007
CORE_ADDR trampoline
Definition: tracepoint.c:791
unsigned long long ULONGEST
Definition: common-types.h:53
PTR xmalloc(size_t size)
Definition: common-utils.c:34
static void download_trace_state_variables(void)
Definition: tracepoint.c:6204
char * gdb_unparse_agent_expr(struct agent_expr *aexpr)
Definition: ax.c:128
EXTERN_C_PUSH IP_AGENT_EXPORT_VAR unsigned char * trace_buffer_lo
Definition: tracepoint.c:1002
char * savestring(const char *ptr, size_t len)
Definition: common-utils.c:148
CORE_ADDR adjusted_insn_addr_end
Definition: tracepoint.c:780
CORE_ADDR addr_get_trace_state_variable_value
Definition: tracepoint.c:171
static struct traceframe * add_traceframe(struct tracepoint *tpoint)
Definition: tracepoint.c:2199
struct breakpoint * set_breakpoint_at(CORE_ADDR where, int(*handler)(CORE_ADDR))
Definition: mem-break.c:773
IP_AGENT_EXPORT_VAR struct trace_state_variable * trace_state_variables
Definition: tracepoint.c:915
struct agent_expr * expr
Definition: tracepoint.c:514
void inc_ref_fast_tracepoint_jump(struct fast_tracepoint_jump *jp)
Definition: mem-break.c:562
Definition: inferiors.h:29
#define MAX_JUMP_SIZE
Definition: tracepoint.c:3071
static int install_fast_tracepoint(struct tracepoint *, char *errbuf)
Definition: tracepoint.c:3077
int hex2bin(const char *hex, gdb_byte *bin, int count)
Definition: rsp-low.c:115
int gdb_connected(void)
Definition: remote-utils.c:126
#define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET
Definition: tracepoint.c:6069
#define trace_buffer_wrap
Definition: tracepoint.c:1185
#define GDBSERVER_FLUSH_COUNT_MASK_CURR
Definition: tracepoint.c:1156
CORE_ADDR get_get_tsv_func_addr(void)
Definition: tracepoint.c:5866
static int write_inferior_uinteger(CORE_ADDR symaddr, unsigned int val)
Definition: tracepoint.c:450
static char * r_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
Definition: tracepoint.c:569
#define IPA_PROTO_FAST_TRACE_JUMP_PAD
Definition: tracepoint.c:6070
void gdb_agent_about_to_close(int pid)
Definition: tracepoint.c:3960
struct agent_expr * cond
Definition: tracepoint.c:740
static void cmd_qtdp(char *own_buf)
Definition: tracepoint.c:2481
void debug_printf(const char *fmt,...)
Definition: common-debug.c:30
CORE_ADDR end
Definition: tracepoint.c:1235
static void collect_data_at_step(struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc, struct tracepoint *tpoint, int current_step)
Definition: tracepoint.c:4673
#define PBUFSIZ
Definition: server.h:129
CORE_ADDR addr_stop_tracing
Definition: tracepoint.c:153
enum tracepoint_type type
Definition: tracepoint.c:1295
#define IPA_NEXT_TRACEFRAME(TF, TFOBJ)
CORE_ADDR addr_error_tracepoint
Definition: tracepoint.c:159
int traceframe_read_sdata(int tfnum, ULONGEST offset, unsigned char *buf, ULONGEST length, ULONGEST *nbytes)
Definition: tracepoint.c:5359
uint32_t number
Definition: tracepoint.c:718
long current_step
Definition: tracepoint.c:830
static void download_tracepoint(struct tracepoint *)
Definition: tracepoint.c:6154
static void add_while_stepping_state(struct thread_info *tinfo, int tp_number, CORE_ADDR tp_address)
Definition: tracepoint.c:4324
CORE_ADDR jump_pad_end
Definition: tracepoint.c:786
static void cmd_qtfp(char *packet)
Definition: tracepoint.c:3797
static int run_inferior_command(char *cmd, int len)
Definition: tracepoint.c:6799
static struct trace_state_variable * cur_tsv
Definition: tracepoint.c:3730
int current_traceframe
Definition: tracepoint.c:984
static char * l_tracepoint_action_send(char *buffer, const struct tracepoint_action *action)
Definition: tracepoint.c:652
#define traceframe_count
Definition: tracepoint.c:1214
static CORE_ADDR m_tracepoint_action_download(const struct tracepoint_action *action)
Definition: tracepoint.c:525
struct regcache * regcache
Definition: ax.h:77
static void upload_fast_traceframes(void)
Definition: tracepoint.c:6280
static int stop_tracing_handler(CORE_ADDR)
Definition: tracepoint.c:3502
CORE_ADDR addr_trace_buffer_ctrl_curr
Definition: tracepoint.c:163
void error(const char *fmt,...)
Definition: errors.c:38
int delete_breakpoint(struct breakpoint *todel)
Definition: mem-break.c:888
int traceframe_read_mem(int tfnum, CORE_ADDR addr, unsigned char *buf, ULONGEST length, ULONGEST *nbytes)
Definition: tracepoint.c:5234
void supply_fast_tracepoint_registers(struct regcache *regcache, const unsigned char *buf)
static struct ipa_sym_addresses ipa_sym_addrs
Definition: tracepoint.c:213
static CORE_ADDR r_tracepoint_action_download(const struct tracepoint_action *action)
Definition: tracepoint.c:556
long long LONGEST
Definition: common-types.h:52
CORE_ADDR addr_collecting
Definition: tracepoint.c:151
char * strerror(int)
void write_enn(char *buf)
void supply_regblock(struct regcache *regcache, const void *buf)
Definition: regcache.c:370
struct inferior_list_entry * find_inferior(struct inferior_list *list, int(*func)(struct inferior_list_entry *, void *), void *arg)
Definition: inferiors.c:188
enum tracepoint_type type
Definition: tracepoint.c:725
#define FIRST_TRACEFRAME()
Definition: tracepoint.c:1190
static int in_process_agent_supports_ust(void)
Definition: tracepoint.c:222
static int write_inferior_data_ptr(CORE_ADDR where, CORE_ADDR ptr)
Definition: tracepoint.c:5928
LONGEST tracing_stop_time
Definition: tracepoint.c:1270
CORE_ADDR addr_trace_state_variables
Definition: tracepoint.c:169