GDB (xrefs)
/tmp/gdb-7.10/gdb/dtrace-probe.c
Go to the documentation of this file.
1 /* DTrace probe support for GDB.
2 
3  Copyright (C) 2014-2015 Free Software Foundation, Inc.
4 
5  Contributed by Oracle, Inc.
6 
7  This file is part of GDB.
8 
9  This program is free software; you can redistribute it and/or modify
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation; either version 3 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 
22 #include "defs.h"
23 #include "probe.h"
24 #include "vec.h"
25 #include "elf-bfd.h"
26 #include "gdbtypes.h"
27 #include "obstack.h"
28 #include "objfiles.h"
29 #include "complaints.h"
30 #include "value.h"
31 #include "ax.h"
32 #include "ax-gdb.h"
33 #include "language.h"
34 #include "parser-defs.h"
35 #include "inferior.h"
36 
37 /* The type of the ELF sections where we will find the DOF programs
38  with information about probes. */
39 
40 #ifndef SHT_SUNW_dof
41 # define SHT_SUNW_dof 0x6ffffff4
42 #endif
43 
44 /* Forward declaration. */
45 
46 extern const struct probe_ops dtrace_probe_ops;
47 
48 /* The following structure represents a single argument for the
49  probe. */
50 
52 {
53  /* The type of the probe argument. */
54  struct type *type;
55 
56  /* A string describing the type. */
57  char *type_str;
58 
59  /* The argument converted to an internal GDB expression. */
60  struct expression *expr;
61 };
62 
65 
66 /* The following structure represents an enabler for a probe. */
67 
69 {
70  /* Program counter where the is-enabled probe is installed. The
71  contents (nops, whatever...) stored at this address are
72  architecture dependent. */
74 };
75 
78 
79 /* The following structure represents a dtrace probe. */
80 
82 {
83  /* Generic information about the probe. This must be the first
84  element of this struct, in order to maintain binary compatibility
85  with the `struct probe' and be able to fully abstract it. */
86  struct probe p;
87 
88  /* A probe can have zero or more arguments. */
90  VEC (dtrace_probe_arg_s) *args;
91 
92  /* A probe can have zero or more "enablers" associated with it. */
93  VEC (dtrace_probe_enabler_s) *enablers;
94 
95  /* Whether the expressions for the arguments have been built. */
96  unsigned int args_expr_built : 1;
97 };
98 
99 /* Implementation of the probe_is_linespec method. */
100 
101 static int
102 dtrace_probe_is_linespec (const char **linespecp)
103 {
104  static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
105 
106  return probe_is_linespec_by_keyword (linespecp, keywords);
107 }
108 
109 /* DOF programs can contain an arbitrary number of sections of 26
110  different types. In order to support DTrace USDT probes we only
111  need to handle a subset of these section types, fortunately. These
112  section types are defined in the following enumeration.
113 
114  See linux/dtrace/dof_defines.h for a complete list of section types
115  along with their values. */
116 
118 {
119  /* Null section. */
121  /* A dof_ecbdesc_t. */
123  /* A string table. */
125  /* A dof_provider_t */
127  /* Array of dof_probe_t */
129  /* An array of probe arg mappings. */
131  /* An array of probe arg offsets. */
133  /* An array of probe is-enabled offsets. */
135 };
136 
137 /* The following collection of data structures map the structure of
138  DOF entities. Again, we only cover the subset of DOF used to
139  implement USDT probes.
140 
141  See linux/dtrace/dof.h header for a complete list of data
142  structures. */
143 
144 /* Offsets to index the dofh_ident[] array defined below. */
145 
147 {
148  /* First byte of the magic number. */
150  /* Second byte of the magic number. */
152  /* Third byte of the magic number. */
154  /* Fourth byte of the magic number. */
156  /* An enum_dof_encoding value. */
158 };
159 
160 /* Possible values for dofh_ident[DOF_ID_ENCODING]. */
161 
163 {
164  /* The DOF program is little-endian. */
166  /* The DOF program is big-endian. */
168 };
169 
170 /* A DOF header, which describes the contents of a DOF program: number
171  of sections, size, etc. */
172 
174 {
175  /* Identification bytes (see above). */
176  uint8_t dofh_ident[16];
177  /* File attribute flags (if any). */
178  uint32_t dofh_flags;
179  /* Size of file header in bytes. */
180  uint32_t dofh_hdrsize;
181  /* Size of section header in bytes. */
182  uint32_t dofh_secsize;
183  /* Number of section headers. */
184  uint32_t dofh_secnum;
185  /* File offset of section headers. */
186  uint64_t dofh_secoff;
187  /* File size of loadable portion. */
188  uint64_t dofh_loadsz;
189  /* File size of entire DOF file. */
190  uint64_t dofh_filesz;
191  /* Reserved for future use. */
192  uint64_t dofh_pad;
193 };
194 
195 /* A DOF section, whose contents depend on its type. The several
196  supported section types are described in the enum
197  dtrace_dof_sect_type above. */
198 
200 {
201  /* Section type (see the define above). */
202  uint32_t dofs_type;
203  /* Section data memory alignment. */
204  uint32_t dofs_align;
205  /* Section flags (if any). */
206  uint32_t dofs_flags;
207  /* Size of section entry (if table). */
208  uint32_t dofs_entsize;
209  /* DOF + offset points to the section data. */
210  uint64_t dofs_offset;
211  /* Size of section data in bytes. */
212  uint64_t dofs_size;
213 };
214 
215 /* A DOF provider, which is the provider of a probe. */
216 
218 {
219  /* Link to a DTRACE_DOF_SECT_TYPE_STRTAB section. */
220  uint32_t dofpv_strtab;
221  /* Link to a DTRACE_DOF_SECT_TYPE_PROBES section. */
222  uint32_t dofpv_probes;
223  /* Link to a DTRACE_DOF_SECT_TYPE_PRARGS section. */
224  uint32_t dofpv_prargs;
225  /* Link to a DTRACE_DOF_SECT_TYPE_PROFFS section. */
226  uint32_t dofpv_proffs;
227  /* Provider name string. */
228  uint32_t dofpv_name;
229  /* Provider attributes. */
230  uint32_t dofpv_provattr;
231  /* Module attributes. */
232  uint32_t dofpv_modattr;
233  /* Function attributes. */
234  uint32_t dofpv_funcattr;
235  /* Name attributes. */
236  uint32_t dofpv_nameattr;
237  /* Args attributes. */
238  uint32_t dofpv_argsattr;
239  /* Link to a DTRACE_DOF_SECT_PRENOFFS section. */
240  uint32_t dofpv_prenoffs;
241 };
242 
243 /* A set of DOF probes and is-enabled probes sharing a base address
244  and several attributes. The particular locations and attributes of
245  each probe are maintained in arrays in several other DOF sections.
246  See the comment in dtrace_process_dof_probe for details on how
247  these attributes are stored. */
248 
250 {
251  /* Probe base address or offset. */
252  uint64_t dofpr_addr;
253  /* Probe function string. */
254  uint32_t dofpr_func;
255  /* Probe name string. */
256  uint32_t dofpr_name;
257  /* Native argument type strings. */
258  uint32_t dofpr_nargv;
259  /* Translated argument type strings. */
260  uint32_t dofpr_xargv;
261  /* Index of first argument mapping. */
262  uint32_t dofpr_argidx;
263  /* Index of first offset entry. */
264  uint32_t dofpr_offidx;
265  /* Native argument count. */
266  uint8_t dofpr_nargc;
267  /* Translated argument count. */
268  uint8_t dofpr_xargc;
269  /* Number of offset entries for probe. */
270  uint16_t dofpr_noffs;
271  /* Index of first is-enabled offset. */
272  uint32_t dofpr_enoffidx;
273  /* Number of is-enabled offsets. */
274  uint16_t dofpr_nenoffs;
275  /* Reserved for future use. */
276  uint16_t dofpr_pad1;
277  /* Reserved for future use. */
278  uint32_t dofpr_pad2;
279 };
280 
281 /* DOF supports two different encodings: MSB (big-endian) and LSB
282  (little-endian). The encoding is itself encoded in the DOF header.
283  The following function returns an unsigned value in the host
284  endianness. */
285 
286 #define DOF_UINT(dof, field) \
287  extract_unsigned_integer ((gdb_byte *) &(field), \
288  sizeof ((field)), \
289  (((dof)->dofh_ident[DTRACE_DOF_ID_ENCODING] \
290  == DTRACE_DOF_ENCODE_MSB) \
291  ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE))
292 
293 /* The following macro applies a given byte offset to a DOF (a pointer
294  to a dtrace_dof_hdr structure) and returns the resulting
295  address. */
296 
297 #define DTRACE_DOF_PTR(dof, offset) (&((char *) (dof))[(offset)])
298 
299 /* The following macro returns a pointer to the beginning of a given
300  section in a DOF object. The section is referred to by its index
301  in the sections array. */
302 
303 #define DTRACE_DOF_SECT(dof, idx) \
304  ((struct dtrace_dof_sect *) \
305  DTRACE_DOF_PTR ((dof), \
306  DOF_UINT ((dof), (dof)->dofh_secoff) \
307  + ((idx) * DOF_UINT ((dof), (dof)->dofh_secsize))))
308 
309 /* Helper function to examine the probe described by the given PROBE
310  and PROVIDER data structures and add it to the PROBESP vector.
311  STRTAB, OFFTAB, EOFFTAB and ARGTAB are pointers to tables in the
312  DOF program containing the attributes for the probe. */
313 
314 static void
315 dtrace_process_dof_probe (struct objfile *objfile,
316  struct gdbarch *gdbarch, VEC (probe_p) **probesp,
317  struct dtrace_dof_hdr *dof,
318  struct dtrace_dof_probe *probe,
320  char *strtab, char *offtab, char *eofftab,
321  char *argtab, uint64_t strtab_size)
322 {
323  int i, j, num_probes, num_enablers;
324  struct cleanup *cleanup;
325  VEC (dtrace_probe_enabler_s) *enablers;
326  char *p;
327 
328  /* Each probe section can define zero or more probes of two
329  different types:
330 
331  - probe->dofpr_noffs regular probes whose program counters are
332  stored in 32bit words starting at probe->dofpr_addr +
333  offtab[probe->dofpr_offidx].
334 
335  - probe->dofpr_nenoffs is-enabled probes whose program counters
336  are stored in 32bit words starting at probe->dofpr_addr +
337  eofftab[probe->dofpr_enoffidx].
338 
339  However is-enabled probes are not probes per-se, but an
340  optimization hack that is implemented in the kernel in a very
341  similar way than normal probes. This is how we support
342  is-enabled probes on GDB:
343 
344  - Our probes are always DTrace regular probes.
345 
346  - Our probes can be associated with zero or more "enablers". The
347  list of enablers is built from the is-enabled probes defined in
348  the Probe section.
349 
350  - Probes having a non-empty list of enablers can be enabled or
351  disabled using the `enable probe' and `disable probe' commands
352  respectively. The `Enabled' column in the output of `info
353  probes' will read `yes' if the enablers are activated, `no'
354  otherwise.
355 
356  - Probes having an empty list of enablers are always enabled.
357  The `Enabled' column in the output of `info probes' will
358  read `always'.
359 
360  It follows that if there are DTrace is-enabled probes defined for
361  some provider/name but no DTrace regular probes defined then the
362  GDB user wont be able to enable/disable these conditionals. */
363 
364  num_probes = DOF_UINT (dof, probe->dofpr_noffs);
365  if (num_probes == 0)
366  return;
367 
368  /* Build the list of enablers for the probes defined in this Probe
369  DOF section. */
370  enablers = NULL;
371  cleanup
373  num_enablers = DOF_UINT (dof, probe->dofpr_nenoffs);
374  for (i = 0; i < num_enablers; i++)
375  {
376  struct dtrace_probe_enabler enabler;
377  uint32_t enabler_offset
378  = ((uint32_t *) eofftab)[DOF_UINT (dof, probe->dofpr_enoffidx) + i];
379 
380  enabler.address = DOF_UINT (dof, probe->dofpr_addr)
381  + DOF_UINT (dof, enabler_offset);
382  VEC_safe_push (dtrace_probe_enabler_s, enablers, &enabler);
383  }
384 
385  for (i = 0; i < num_probes; i++)
386  {
387  uint32_t probe_offset
388  = ((uint32_t *) offtab)[DOF_UINT (dof, probe->dofpr_offidx) + i];
389  struct dtrace_probe *ret
390  = obstack_alloc (&objfile->per_bfd->storage_obstack, sizeof (*ret));
391 
392  ret->p.pops = &dtrace_probe_ops;
393  ret->p.arch = gdbarch;
394  ret->args_expr_built = 0;
395 
396  /* Set the provider and the name of the probe. */
397  ret->p.provider
398  = xstrdup (strtab + DOF_UINT (dof, provider->dofpv_name));
399  ret->p.name = xstrdup (strtab + DOF_UINT (dof, probe->dofpr_name));
400 
401  /* The probe address. */
402  ret->p.address
403  = DOF_UINT (dof, probe->dofpr_addr) + DOF_UINT (dof, probe_offset);
404 
405  /* Number of arguments in the probe. */
406  ret->probe_argc = DOF_UINT (dof, probe->dofpr_nargc);
407 
408  /* Store argument type descriptions. A description of the type
409  of the argument is in the (J+1)th null-terminated string
410  starting at 'strtab' + 'probe->dofpr_nargv'. */
411  ret->args = NULL;
412  p = strtab + DOF_UINT (dof, probe->dofpr_nargv);
413  for (j = 0; j < ret->probe_argc; j++)
414  {
415  struct dtrace_probe_arg arg;
416  struct expression *expr = NULL;
417 
418  /* Set arg.expr to ensure all fields in expr are initialized and
419  the compiler will not warn when arg is used. */
420  arg.expr = NULL;
421  arg.type_str = xstrdup (p);
422 
423  /* Use strtab_size as a sentinel. */
424  while (*p++ != '\0' && p - strtab < strtab_size);
425 
426  /* Try to parse a type expression from the type string. If
427  this does not work then we set the type to `long
428  int'. */
429  arg.type = builtin_type (gdbarch)->builtin_long;
430 
431  TRY
432  {
434  }
436  {
437  expr = NULL;
438  }
439  END_CATCH
440 
441  if (expr != NULL && expr->elts[0].opcode == OP_TYPE)
442  arg.type = expr->elts[1].type;
443 
444  VEC_safe_push (dtrace_probe_arg_s, ret->args, &arg);
445  }
446 
447  /* Add the vector of enablers to this probe, if any. */
448  ret->enablers = VEC_copy (dtrace_probe_enabler_s, enablers);
449 
450  /* Successfully created probe. */
451  VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
452  }
453 
454  do_cleanups (cleanup);
455 }
456 
457 /* Helper function to collect the probes described in the DOF program
458  whose header is pointed by DOF and add them to the PROBESP vector.
459  SECT is the ELF section containing the DOF program and OBJFILE is
460  its containing object file. */
461 
462 static void
463 dtrace_process_dof (asection *sect, struct objfile *objfile,
464  VEC (probe_p) **probesp, struct dtrace_dof_hdr *dof)
465 {
466  bfd *abfd = objfile->obfd;
467  int size = bfd_get_arch_size (abfd) / 8;
468  struct gdbarch *gdbarch = get_objfile_arch (objfile);
469  struct dtrace_dof_sect *section;
470  int i;
471 
472  /* The first step is to check for the DOF magic number. If no valid
473  DOF data is found in the section then a complaint is issued to
474  the user and the section skipped. */
475  if (dof->dofh_ident[DTRACE_DOF_ID_MAG0] != 0x7F
476  || dof->dofh_ident[DTRACE_DOF_ID_MAG1] != 'D'
477  || dof->dofh_ident[DTRACE_DOF_ID_MAG2] != 'O'
478  || dof->dofh_ident[DTRACE_DOF_ID_MAG3] != 'F')
479  goto invalid_dof_data;
480 
481  /* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
482  DTRACE_DOF_ENCODE_MSB. */
485  goto invalid_dof_data;
486 
487  /* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
488  Description sections. */
489  section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
490  DOF_UINT (dof, dof->dofh_secoff));
491  for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
492  if (section->dofs_type == DTRACE_DOF_SECT_TYPE_ECBDESC)
493  return;
494 
495  /* Iterate over any section of type Provider and extract the probe
496  information from them. If there are no "provider" sections on
497  the DOF then we just return. */
498  section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
499  DOF_UINT (dof, dof->dofh_secoff));
500  for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
501  if (DOF_UINT (dof, section->dofs_type) == DTRACE_DOF_SECT_TYPE_PROVIDER)
502  {
504  DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
505  struct dtrace_dof_sect *strtab_s
506  = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_strtab));
507  struct dtrace_dof_sect *probes_s
508  = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_probes));
509  struct dtrace_dof_sect *args_s
510  = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prargs));
511  struct dtrace_dof_sect *offsets_s
512  = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_proffs));
513  struct dtrace_dof_sect *eoffsets_s
514  = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prenoffs));
515  char *strtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, strtab_s->dofs_offset));
516  char *offtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, offsets_s->dofs_offset));
517  char *eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
518  char *argtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, args_s->dofs_offset));
519  unsigned int entsize = DOF_UINT (dof, probes_s->dofs_entsize);
520  int num_probes;
521 
522  /* Very, unlikely, but could crash gdb if not handled
523  properly. */
524  if (entsize == 0)
525  goto invalid_dof_data;
526 
527  num_probes = DOF_UINT (dof, probes_s->dofs_size) / entsize;
528 
529  for (i = 0; i < num_probes; i++)
530  {
531  struct dtrace_dof_probe *probe = (struct dtrace_dof_probe *)
532  DTRACE_DOF_PTR (dof, DOF_UINT (dof, probes_s->dofs_offset)
533  + (i * DOF_UINT (dof, probes_s->dofs_entsize)));
534 
535  dtrace_process_dof_probe (objfile,
536  gdbarch, probesp,
537  dof, probe,
538  provider, strtab, offtab, eofftab, argtab,
539  DOF_UINT (dof, strtab_s->dofs_size));
540  }
541  }
542 
543  return;
544 
545  invalid_dof_data:
547  _("skipping section '%s' which does not contain valid DOF data."),
548  sect->name);
549 }
550 
551 /* Helper function to build the GDB internal expressiosn that, once
552  evaluated, will calculate the values of the arguments of a given
553  PROBE. */
554 
555 static void
557  struct gdbarch *gdbarch)
558 {
559  struct parser_state pstate;
560  struct dtrace_probe_arg *arg;
561  int i;
562 
563  probe->args_expr_built = 1;
564 
565  /* Iterate over the arguments in the probe and build the
566  corresponding GDB internal expression that will generate the
567  value of the argument when executed at the PC of the probe. */
568  for (i = 0; i < probe->probe_argc; i++)
569  {
570  struct cleanup *back_to;
571 
572  arg = VEC_index (dtrace_probe_arg_s, probe->args, i);
573 
574  /* Initialize the expression buffer in the parser state. The
575  language does not matter, since we are using our own
576  parser. */
577  initialize_expout (&pstate, 10, current_language, gdbarch);
578  back_to = make_cleanup (free_current_contents, &pstate.expout);
579 
580  /* The argument value, which is ABI dependent and casted to
581  `long int'. */
582  gdbarch_dtrace_parse_probe_argument (gdbarch, &pstate, i);
583 
584  discard_cleanups (back_to);
585 
586  /* Casting to the expected type, but only if the type was
587  recognized at probe load time. Otherwise the argument will
588  be evaluated as the long integer passed to the probe. */
589  if (arg->type != NULL)
590  {
591  write_exp_elt_opcode (&pstate, UNOP_CAST);
592  write_exp_elt_type (&pstate, arg->type);
593  write_exp_elt_opcode (&pstate, UNOP_CAST);
594  }
595 
596  reallocate_expout (&pstate);
597  arg->expr = pstate.expout;
598  prefixify_expression (arg->expr);
599  }
600 }
601 
602 /* Helper function to return the Nth argument of a given PROBE. */
603 
604 static struct dtrace_probe_arg *
605 dtrace_get_arg (struct dtrace_probe *probe, unsigned n,
606  struct gdbarch *gdbarch)
607 {
608  if (!probe->args_expr_built)
609  dtrace_build_arg_exprs (probe, gdbarch);
610 
611  return VEC_index (dtrace_probe_arg_s, probe->args, n);
612 }
613 
614 /* Implementation of the get_probes method. */
615 
616 static void
617 dtrace_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
618 {
619  bfd *abfd = objfile->obfd;
620  asection *sect = NULL;
621 
622  /* Do nothing in case this is a .debug file, instead of the objfile
623  itself. */
624  if (objfile->separate_debug_objfile_backlink != NULL)
625  return;
626 
627  /* Iterate over the sections in OBJFILE looking for DTrace
628  information. */
629  for (sect = abfd->sections; sect != NULL; sect = sect->next)
630  {
631  if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
632  {
633  bfd_byte *dof;
634 
635  /* Read the contents of the DOF section and then process it to
636  extract the information of any probe defined into it. */
637  if (!bfd_malloc_and_get_section (abfd, sect, &dof))
639  _("could not obtain the contents of"
640  "section '%s' in objfile `%s'."),
641  sect->name, abfd->filename);
642 
643  dtrace_process_dof (sect, objfile, probesp,
644  (struct dtrace_dof_hdr *) dof);
645  xfree (dof);
646  }
647  }
648 }
649 
650 /* Helper function to determine whether a given probe is "enabled" or
651  "disabled". A disabled probe is a probe in which one or more
652  enablers are disabled. */
653 
654 static int
656 {
657  int i;
658  struct gdbarch *gdbarch = probe->p.arch;
659  struct dtrace_probe_enabler *enabler;
660 
661  for (i = 0;
662  VEC_iterate (dtrace_probe_enabler_s, probe->enablers, i, enabler);
663  i++)
664  if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler->address))
665  return 0;
666 
667  return 1;
668 }
669 
670 /* Implementation of the get_probe_address method. */
671 
672 static CORE_ADDR
673 dtrace_get_probe_address (struct probe *probe, struct objfile *objfile)
674 {
675  gdb_assert (probe->pops == &dtrace_probe_ops);
676  return probe->address + ANOFFSET (objfile->section_offsets,
677  SECT_OFF_DATA (objfile));
678 }
679 
680 /* Implementation of the get_probe_argument_count method. */
681 
682 static unsigned
683 dtrace_get_probe_argument_count (struct probe *probe_generic,
684  struct frame_info *frame)
685 {
686  struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
687 
688  gdb_assert (probe_generic->pops == &dtrace_probe_ops);
689 
690  return dtrace_probe->probe_argc;
691 }
692 
693 /* Implementation of the can_evaluate_probe_arguments method. */
694 
695 static int
697 {
698  struct gdbarch *gdbarch = probe_generic->arch;
699 
700  gdb_assert (probe_generic->pops == &dtrace_probe_ops);
701  return gdbarch_dtrace_parse_probe_argument_p (gdbarch);
702 }
703 
704 /* Implementation of the evaluate_probe_argument method. */
705 
706 static struct value *
707 dtrace_evaluate_probe_argument (struct probe *probe_generic, unsigned n,
708  struct frame_info *frame)
709 {
710  struct gdbarch *gdbarch = probe_generic->arch;
711  struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
712  struct dtrace_probe_arg *arg;
713  int pos = 0;
714 
715  gdb_assert (probe_generic->pops == &dtrace_probe_ops);
716 
717  arg = dtrace_get_arg (dtrace_probe, n, gdbarch);
718  return evaluate_subexp_standard (arg->type, arg->expr, &pos, EVAL_NORMAL);
719 }
720 
721 /* Implementation of the compile_to_ax method. */
722 
723 static void
724 dtrace_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr,
725  struct axs_value *value, unsigned n)
726 {
727  struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
728  struct dtrace_probe_arg *arg;
729  union exp_element *pc;
730 
731  gdb_assert (probe_generic->pops == &dtrace_probe_ops);
732 
733  arg = dtrace_get_arg (dtrace_probe, n, expr->gdbarch);
734 
735  pc = arg->expr->elts;
736  gen_expr (arg->expr, &pc, expr, value);
737 
738  require_rvalue (expr, value);
739  value->type = arg->type;
740 }
741 
742 /* Implementation of the probe_destroy method. */
743 
744 static void
745 dtrace_probe_destroy (struct probe *probe_generic)
746 {
747  struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
748  struct dtrace_probe_arg *arg;
749  int i;
750 
751  gdb_assert (probe_generic->pops == &dtrace_probe_ops);
752 
753  for (i = 0; VEC_iterate (dtrace_probe_arg_s, probe->args, i, arg); i++)
754  {
755  xfree (arg->type_str);
756  xfree (arg->expr);
757  }
758 
759  VEC_free (dtrace_probe_enabler_s, probe->enablers);
760  VEC_free (dtrace_probe_arg_s, probe->args);
761 }
762 
763 /* Implementation of the type_name method. */
764 
765 static const char *
766 dtrace_type_name (struct probe *probe_generic)
767 {
768  gdb_assert (probe_generic->pops == &dtrace_probe_ops);
769  return "dtrace";
770 }
771 
772 /* Implementation of the gen_info_probes_table_header method. */
773 
774 static void
776 {
777  info_probe_column_s dtrace_probe_column;
778 
779  dtrace_probe_column.field_name = "enabled";
780  dtrace_probe_column.print_name = _("Enabled");
781 
782  VEC_safe_push (info_probe_column_s, *heads, &dtrace_probe_column);
783 }
784 
785 /* Implementation of the gen_info_probes_table_values method. */
786 
787 static void
789  VEC (const_char_ptr) **ret)
790 {
791  struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
792  const char *val = NULL;
793 
794  gdb_assert (probe_generic->pops == &dtrace_probe_ops);
795 
796  if (VEC_empty (dtrace_probe_enabler_s, probe->enablers))
797  val = "always";
798  else if (!gdbarch_dtrace_probe_is_enabled_p (probe_generic->arch))
799  val = "unknown";
800  else if (dtrace_probe_is_enabled (probe))
801  val = "yes";
802  else
803  val = "no";
804 
805  VEC_safe_push (const_char_ptr, *ret, val);
806 }
807 
808 /* Implementation of the enable_probe method. */
809 
810 static void
812 {
813  struct gdbarch *gdbarch = probe->arch;
814  struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
815  struct dtrace_probe_enabler *enabler;
816  int i;
817 
818  gdb_assert (probe->pops == &dtrace_probe_ops);
819 
820  /* Enabling a dtrace probe implies patching the text section of the
821  running process, so make sure the inferior is indeed running. */
823  error (_("No inferior running"));
824 
825  /* Fast path. */
826  if (dtrace_probe_is_enabled (dtrace_probe))
827  return;
828 
829  /* Iterate over all defined enabler in the given probe and enable
830  them all using the corresponding gdbarch hook. */
831 
832  for (i = 0;
833  VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
834  i++)
835  if (gdbarch_dtrace_enable_probe_p (gdbarch))
836  gdbarch_dtrace_enable_probe (gdbarch, enabler->address);
837 }
838 
839 
840 /* Implementation of the disable_probe method. */
841 
842 static void
844 {
845  struct gdbarch *gdbarch = probe->arch;
846  struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
847  struct dtrace_probe_enabler *enabler;
848  int i;
849 
850  gdb_assert (probe->pops == &dtrace_probe_ops);
851 
852  /* Disabling a dtrace probe implies patching the text section of the
853  running process, so make sure the inferior is indeed running. */
855  error (_("No inferior running"));
856 
857  /* Fast path. */
858  if (!dtrace_probe_is_enabled (dtrace_probe))
859  return;
860 
861  /* Are we trying to disable a probe that does not have any enabler
862  associated? */
863  if (VEC_empty (dtrace_probe_enabler_s, dtrace_probe->enablers))
864  error (_("Probe %s:%s cannot be disabled: no enablers."), probe->provider, probe->name);
865 
866  /* Iterate over all defined enabler in the given probe and disable
867  them all using the corresponding gdbarch hook. */
868 
869  for (i = 0;
870  VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
871  i++)
872  if (gdbarch_dtrace_disable_probe_p (gdbarch))
873  gdbarch_dtrace_disable_probe (gdbarch, enabler->address);
874 }
875 
876 /* DTrace probe_ops. */
877 
878 const struct probe_ops dtrace_probe_ops =
879 {
887  NULL, /* set_semaphore */
888  NULL, /* clear_semaphore */
895 };
896 
897 /* Implementation of the `info probes dtrace' command. */
898 
899 static void
900 info_probes_dtrace_command (char *arg, int from_tty)
901 {
902  info_probes_for_ops (arg, from_tty, &dtrace_probe_ops);
903 }
904 
905 void _initialize_dtrace_probe (void);
906 
907 void
909 {
910  VEC_safe_push (probe_ops_cp, all_probe_ops, &dtrace_probe_ops);
911 
913  _("\
914 Show information about DTrace static probes.\n\
915 Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
916 Each argument is a regular expression, used to select probes.\n\
917 PROVIDER matches probe provider names.\n\
918 NAME matches the probe names.\n\
919 OBJECT matches the executable or shared library name."),
921 }
static void dtrace_compile_to_ax(struct probe *probe_generic, struct agent_expr *expr, struct axs_value *value, unsigned n)
Definition: dtrace-probe.c:724
int gdbarch_dtrace_probe_is_enabled_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4274
union exp_element elts[1]
Definition: expression.h:85
uint32_t dofs_entsize
Definition: dtrace-probe.c:208
void initialize_expout(struct parser_state *ps, size_t initial_size, const struct language_defn *lang, struct gdbarch *gdbarch)
Definition: parse.c:186
uint64_t dofs_offset
Definition: dtrace-probe.c:210
uint32_t dofs_type
Definition: dtrace-probe.c:202
bfd * obfd
Definition: objfiles.h:313
struct obstack storage_obstack
Definition: objfiles.h:177
enum exp_opcode opcode
Definition: expression.h:65
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
#define DTRACE_DOF_PTR(dof, offset)
Definition: dtrace-probe.c:297
bfd_vma CORE_ADDR
Definition: common-types.h:41
static int dtrace_can_evaluate_probe_arguments(struct probe *probe_generic)
Definition: dtrace-probe.c:696
int gdbarch_dtrace_parse_probe_argument_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4250
void xfree(void *)
Definition: common-utils.c:97
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
int gdbarch_dtrace_probe_is_enabled(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4281
uint64_t dofh_secoff
Definition: dtrace-probe.c:186
#define DTRACE_DOF_SECT(dof, idx)
Definition: dtrace-probe.c:303
uint32_t dofpr_func
Definition: dtrace-probe.c:254
void gdbarch_dtrace_enable_probe(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4305
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
uint16_t dofpr_nenoffs
Definition: dtrace-probe.c:274
struct cmd_list_element ** info_probes_cmdlist_get(void)
Definition: probe.c:909
static void info_probes_dtrace_command(char *arg, int from_tty)
Definition: dtrace-probe.c:900
struct expression * expr
Definition: dtrace-probe.c:60
static void dtrace_get_probes(VEC(probe_p)**probesp, struct objfile *objfile)
Definition: dtrace-probe.c:617
Definition: ax.h:95
uint32_t dofh_secsize
Definition: dtrace-probe.c:182
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
#define VEC(T)
Definition: vec.h:398
struct gdbarch * gdbarch
Definition: ax.h:107
#define SHT_SUNW_dof
Definition: dtrace-probe.c:41
#define _(String)
Definition: gdb_locale.h:40
static struct value * dtrace_evaluate_probe_argument(struct probe *probe_generic, unsigned n, struct frame_info *frame)
Definition: dtrace-probe.c:707
#define END_CATCH
struct type * type
Definition: ax-gdb.h:82
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:318
struct type * type
Definition: dtrace-probe.c:54
int gdbarch_dtrace_disable_probe_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4322
static void dtrace_process_dof(asection *sect, struct objfile *objfile, VEC(probe_p)**probesp, struct dtrace_dof_hdr *dof)
Definition: dtrace-probe.c:463
struct type * type
Definition: expression.h:73
uint64_t dofh_filesz
Definition: dtrace-probe.c:190
const char * name
Definition: probe.h:194
#define TRY
int probe_is_linespec_by_keyword(const char **linespecp, const char *const *keywords)
Definition: probe.c:860
dtrace_dof_ident
Definition: dtrace-probe.c:146
dtrace_dof_sect_type
Definition: dtrace-probe.c:117
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
uint32_t dofs_flags
Definition: dtrace-probe.c:206
CORE_ADDR address
Definition: probe.h:202
uint32_t dofh_hdrsize
Definition: dtrace-probe.c:180
#define CATCH(EXCEPTION, MASK)
uint16_t dofpr_noffs
Definition: dtrace-probe.c:270
uint32_t dofpr_name
Definition: dtrace-probe.c:256
uint32_t dofh_flags
Definition: dtrace-probe.c:178
uint32_t dofs_align
Definition: dtrace-probe.c:204
int prefixify_expression(struct expression *expr)
Definition: parse.c:811
const char * const_char_ptr
Definition: gdb_vecs.h:26
static void dtrace_disable_probe(struct probe *probe)
Definition: dtrace-probe.c:843
DEF_VEC_O(dtrace_probe_arg_s)
void gdbarch_dtrace_disable_probe(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4329
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
#define SECT_OFF_DATA(objfile)
Definition: objfiles.h:671
void free_current_contents(void *ptr)
Definition: utils.c:476
struct expression * parse_expression_with_language(const char *string, enum language lang)
Definition: parse.c:1275
static int dtrace_probe_is_linespec(const char **linespecp)
Definition: dtrace-probe.c:102
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
Definition: gdbtypes.h:749
#define VEC_index(T, V, I)
Definition: vec.h:151
const char * field_name
Definition: probe.h:40
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static const char * dtrace_type_name(struct probe *probe_generic)
Definition: dtrace-probe.c:766
const char * print_name
Definition: probe.h:44
struct type * builtin_long
Definition: gdbtypes.h:1484
uint8_t dofh_ident[16]
Definition: dtrace-probe.c:176
uint64_t dofh_loadsz
Definition: dtrace-probe.c:188
static void dtrace_gen_info_probes_table_values(struct probe *probe_generic, VEC(const_char_ptr)**ret)
Definition: dtrace-probe.c:788
struct expression * expout
Definition: parser-defs.h:43
static void dtrace_probe_destroy(struct probe *probe_generic)
Definition: dtrace-probe.c:745
struct probe p
Definition: dtrace-probe.c:86
const char * provider
Definition: probe.h:198
Definition: probe.h:185
void _initialize_dtrace_probe(void)
Definition: dtrace-probe.c:908
struct gdbarch * arch
Definition: probe.h:191
uint32_t dofpr_nargv
Definition: dtrace-probe.c:258
void gen_expr(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1776
const char * provider
Definition: probe.h:243
uint64_t dofs_size
Definition: dtrace-probe.c:212
#define VEC_empty(T, V)
Definition: vec.h:132
Definition: value.c:172
int gdbarch_dtrace_enable_probe_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4298
dtrace_dof_encoding
Definition: dtrace-probe.c:162
uint32_t dofpr_enoffidx
Definition: dtrace-probe.c:272
void write_exp_elt_opcode(struct parser_state *ps, enum exp_opcode expelt)
Definition: parse.c:236
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
static int dtrace_probe_is_enabled(struct dtrace_probe *probe)
Definition: dtrace-probe.c:655
const struct language_defn * current_language
Definition: language.c:85
ptid_t null_ptid
Definition: ptid.c:25
uint16_t dofpr_pad1
Definition: dtrace-probe.c:276
static CORE_ADDR dtrace_get_probe_address(struct probe *probe, struct objfile *objfile)
Definition: dtrace-probe.c:673
static struct dtrace_probe_arg * dtrace_get_arg(struct dtrace_probe *probe, unsigned n, struct gdbarch *gdbarch)
Definition: dtrace-probe.c:605
#define VEC_copy(T, V)
Definition: vec.h:206
ptid_t inferior_ptid
Definition: infcmd.c:124
struct complaints * symfile_complaints
Definition: complaints.c:105
void info_probes_for_ops(const char *arg, int from_tty, const struct probe_ops *pops)
Definition: probe.c:551
uint32_t dofpr_xargv
Definition: dtrace-probe.c:260
static unsigned dtrace_get_probe_argument_count(struct probe *probe_generic, struct frame_info *frame)
Definition: dtrace-probe.c:683
#define VEC_free(T, V)
Definition: vec.h:180
static void dtrace_enable_probe(struct probe *probe)
Definition: dtrace-probe.c:811
uint32_t dofpr_argidx
Definition: dtrace-probe.c:262
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:764
struct value * evaluate_subexp_standard(struct type *expect_type, struct expression *exp, int *pos, enum noside noside)
Definition: eval.c:699
static void dtrace_process_dof_probe(struct objfile *objfile, struct gdbarch *gdbarch, VEC(probe_p)**probesp, struct dtrace_dof_hdr *dof, struct dtrace_dof_probe *probe, struct dtrace_dof_provider *provider, char *strtab, char *offtab, char *eofftab, char *argtab, uint64_t strtab_size)
Definition: dtrace-probe.c:315
const struct probe_ops * pops
Definition: probe.h:188
uint32_t dofpr_pad2
Definition: dtrace-probe.c:278
static void dtrace_build_arg_exprs(struct dtrace_probe *probe, struct gdbarch *gdbarch)
Definition: dtrace-probe.c:556
#define VEC_cleanup(T)
Definition: vec.h:187
#define DOF_UINT(dof, field)
Definition: dtrace-probe.c:286
void gdbarch_dtrace_parse_probe_argument(struct gdbarch *gdbarch, struct parser_state *pstate, int narg)
Definition: gdbarch.c:4257
struct section_offsets * section_offsets
Definition: objfiles.h:362
void reallocate_expout(struct parser_state *ps)
Definition: parse.c:201
uint64_t dofh_pad
Definition: dtrace-probe.c:192
void write_exp_elt_type(struct parser_state *ps, struct type *expelt)
Definition: parse.c:308
const struct probe_ops dtrace_probe_ops
Definition: dtrace-probe.c:878
void error(const char *fmt,...)
Definition: errors.c:38
uint64_t dofpr_addr
Definition: dtrace-probe.c:252
size_t size
Definition: go32-nat.c:242
uint32_t dofh_secnum
Definition: dtrace-probe.c:184
static void dtrace_gen_info_probes_table_header(VEC(info_probe_column_s)**heads)
Definition: dtrace-probe.c:775
uint32_t dofpr_offidx
Definition: dtrace-probe.c:264
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175