1 /* DTrace probe support for GDB.
3 Copyright (C) 2014-2016 Free Software Foundation, Inc.
5 Contributed by Oracle, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
29 #include "complaints.h"
34 #include "parser-defs.h"
37 /* The type of the ELF sections where we will find the DOF programs
38 with information about probes. */
41 # define SHT_SUNW_dof 0x6ffffff4
44 /* Forward declaration. */
46 extern const struct probe_ops dtrace_probe_ops
;
48 /* The following structure represents a single argument for the
51 struct dtrace_probe_arg
53 /* The type of the probe argument. */
56 /* A string describing the type. */
59 /* The argument converted to an internal GDB expression. */
60 struct expression
*expr
;
63 typedef struct dtrace_probe_arg dtrace_probe_arg_s
;
64 DEF_VEC_O (dtrace_probe_arg_s
);
66 /* The following structure represents an enabler for a probe. */
68 struct dtrace_probe_enabler
70 /* Program counter where the is-enabled probe is installed. The
71 contents (nops, whatever...) stored at this address are
72 architecture dependent. */
76 typedef struct dtrace_probe_enabler dtrace_probe_enabler_s
;
77 DEF_VEC_O (dtrace_probe_enabler_s
);
79 /* The following structure represents a dtrace probe. */
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. */
88 /* A probe can have zero or more arguments. */
90 VEC (dtrace_probe_arg_s
) *args
;
92 /* A probe can have zero or more "enablers" associated with it. */
93 VEC (dtrace_probe_enabler_s
) *enablers
;
95 /* Whether the expressions for the arguments have been built. */
96 unsigned int args_expr_built
: 1;
99 /* Implementation of the probe_is_linespec method. */
102 dtrace_probe_is_linespec (const char **linespecp
)
104 static const char *const keywords
[] = { "-pdtrace", "-probe-dtrace", NULL
};
106 return probe_is_linespec_by_keyword (linespecp
, keywords
);
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.
114 See linux/dtrace/dof_defines.h for a complete list of section types
115 along with their values. */
117 enum dtrace_dof_sect_type
120 DTRACE_DOF_SECT_TYPE_NONE
= 0,
121 /* A dof_ecbdesc_t. */
122 DTRACE_DOF_SECT_TYPE_ECBDESC
= 3,
123 /* A string table. */
124 DTRACE_DOF_SECT_TYPE_STRTAB
= 8,
125 /* A dof_provider_t */
126 DTRACE_DOF_SECT_TYPE_PROVIDER
= 15,
127 /* Array of dof_probe_t */
128 DTRACE_DOF_SECT_TYPE_PROBES
= 16,
129 /* An array of probe arg mappings. */
130 DTRACE_DOF_SECT_TYPE_PRARGS
= 17,
131 /* An array of probe arg offsets. */
132 DTRACE_DOF_SECT_TYPE_PROFFS
= 18,
133 /* An array of probe is-enabled offsets. */
134 DTRACE_DOF_SECT_TYPE_PRENOFFS
= 26
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.
141 See linux/dtrace/dof.h header for a complete list of data
144 /* Offsets to index the dofh_ident[] array defined below. */
146 enum dtrace_dof_ident
148 /* First byte of the magic number. */
149 DTRACE_DOF_ID_MAG0
= 0,
150 /* Second byte of the magic number. */
151 DTRACE_DOF_ID_MAG1
= 1,
152 /* Third byte of the magic number. */
153 DTRACE_DOF_ID_MAG2
= 2,
154 /* Fourth byte of the magic number. */
155 DTRACE_DOF_ID_MAG3
= 3,
156 /* An enum_dof_encoding value. */
157 DTRACE_DOF_ID_ENCODING
= 5
160 /* Possible values for dofh_ident[DOF_ID_ENCODING]. */
162 enum dtrace_dof_encoding
164 /* The DOF program is little-endian. */
165 DTRACE_DOF_ENCODE_LSB
= 1,
166 /* The DOF program is big-endian. */
167 DTRACE_DOF_ENCODE_MSB
= 2
170 /* A DOF header, which describes the contents of a DOF program: number
171 of sections, size, etc. */
173 struct dtrace_dof_hdr
175 /* Identification bytes (see above). */
176 uint8_t dofh_ident
[16];
177 /* File attribute flags (if any). */
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. */
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. */
199 struct dtrace_dof_sect
201 /* Section type (see the define above). */
203 /* Section data memory alignment. */
205 /* Section flags (if any). */
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. */
215 /* A DOF provider, which is the provider of a probe. */
217 struct dtrace_dof_provider
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. */
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
;
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. */
249 struct dtrace_dof_probe
251 /* Probe base address or offset. */
253 /* Probe function string. */
255 /* Probe name string. */
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. */
267 /* Translated argument count. */
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. */
277 /* Reserved for future use. */
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
286 #define DOF_UINT(dof, field) \
287 extract_unsigned_integer ((gdb_byte *) &(field), \
289 (((dof)->dofh_ident[DTRACE_DOF_ID_ENCODING] \
290 == DTRACE_DOF_ENCODE_MSB) \
291 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE))
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
297 #define DTRACE_DOF_PTR(dof, offset) (&((char *) (dof))[(offset)])
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. */
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))))
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. */
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
,
319 struct dtrace_dof_provider
*provider
,
320 char *strtab
, char *offtab
, char *eofftab
,
321 char *argtab
, uint64_t strtab_size
)
323 int i
, j
, num_probes
, num_enablers
;
324 struct cleanup
*cleanup
;
325 VEC (dtrace_probe_enabler_s
) *enablers
;
328 /* Each probe section can define zero or more probes of two
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].
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].
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:
344 - Our probes are always DTrace regular probes.
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
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'
356 - Probes having an empty list of enablers are always enabled.
357 The `Enabled' column in the output of `info probes' will
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. */
364 num_probes
= DOF_UINT (dof
, probe
->dofpr_noffs
);
368 /* Build the list of enablers for the probes defined in this Probe
372 = make_cleanup (VEC_cleanup (dtrace_probe_enabler_s
), &enablers
);
373 num_enablers
= DOF_UINT (dof
, probe
->dofpr_nenoffs
);
374 for (i
= 0; i
< num_enablers
; i
++)
376 struct dtrace_probe_enabler enabler
;
377 uint32_t enabler_offset
378 = ((uint32_t *) eofftab
)[DOF_UINT (dof
, probe
->dofpr_enoffidx
) + i
];
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
);
385 for (i
= 0; i
< num_probes
; i
++)
387 uint32_t probe_offset
388 = ((uint32_t *) offtab
)[DOF_UINT (dof
, probe
->dofpr_offidx
) + i
];
389 struct dtrace_probe
*ret
=
390 XOBNEW (&objfile
->per_bfd
->storage_obstack
, struct dtrace_probe
);
392 ret
->p
.pops
= &dtrace_probe_ops
;
393 ret
->p
.arch
= gdbarch
;
394 ret
->args_expr_built
= 0;
396 /* Set the provider and the name of the probe. */
398 = xstrdup (strtab
+ DOF_UINT (dof
, provider
->dofpv_name
));
399 ret
->p
.name
= xstrdup (strtab
+ DOF_UINT (dof
, probe
->dofpr_name
));
401 /* The probe address. */
403 = DOF_UINT (dof
, probe
->dofpr_addr
) + DOF_UINT (dof
, probe_offset
);
405 /* Number of arguments in the probe. */
406 ret
->probe_argc
= DOF_UINT (dof
, probe
->dofpr_nargc
);
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'. */
412 p
= strtab
+ DOF_UINT (dof
, probe
->dofpr_nargv
);
413 for (j
= 0; j
< ret
->probe_argc
; j
++)
415 struct dtrace_probe_arg arg
;
418 /* Set arg.expr to ensure all fields in expr are initialized and
419 the compiler will not warn when arg is used. */
421 arg
.type_str
= xstrdup (p
);
423 /* Use strtab_size as a sentinel. */
424 while (*p
++ != '\0' && p
- strtab
< strtab_size
);
426 /* Try to parse a type expression from the type string. If
427 this does not work then we set the type to `long
429 arg
.type
= builtin_type (gdbarch
)->builtin_long
;
433 expr
= parse_expression_with_language (arg
.type_str
, language_c
);
435 CATCH (ex
, RETURN_MASK_ERROR
)
440 if (expr
!= NULL
&& expr
->elts
[0].opcode
== OP_TYPE
)
441 arg
.type
= expr
->elts
[1].type
;
443 VEC_safe_push (dtrace_probe_arg_s
, ret
->args
, &arg
);
446 /* Add the vector of enablers to this probe, if any. */
447 ret
->enablers
= VEC_copy (dtrace_probe_enabler_s
, enablers
);
449 /* Successfully created probe. */
450 VEC_safe_push (probe_p
, *probesp
, (struct probe
*) ret
);
453 do_cleanups (cleanup
);
456 /* Helper function to collect the probes described in the DOF program
457 whose header is pointed by DOF and add them to the PROBESP vector.
458 SECT is the ELF section containing the DOF program and OBJFILE is
459 its containing object file. */
462 dtrace_process_dof (asection
*sect
, struct objfile
*objfile
,
463 VEC (probe_p
) **probesp
, struct dtrace_dof_hdr
*dof
)
465 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
466 struct dtrace_dof_sect
*section
;
469 /* The first step is to check for the DOF magic number. If no valid
470 DOF data is found in the section then a complaint is issued to
471 the user and the section skipped. */
472 if (dof
->dofh_ident
[DTRACE_DOF_ID_MAG0
] != 0x7F
473 || dof
->dofh_ident
[DTRACE_DOF_ID_MAG1
] != 'D'
474 || dof
->dofh_ident
[DTRACE_DOF_ID_MAG2
] != 'O'
475 || dof
->dofh_ident
[DTRACE_DOF_ID_MAG3
] != 'F')
476 goto invalid_dof_data
;
478 /* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
479 DTRACE_DOF_ENCODE_MSB. */
480 if (dof
->dofh_ident
[DTRACE_DOF_ID_ENCODING
] != DTRACE_DOF_ENCODE_LSB
481 && dof
->dofh_ident
[DTRACE_DOF_ID_ENCODING
] != DTRACE_DOF_ENCODE_MSB
)
482 goto invalid_dof_data
;
484 /* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
485 Description sections. */
486 section
= (struct dtrace_dof_sect
*) DTRACE_DOF_PTR (dof
,
487 DOF_UINT (dof
, dof
->dofh_secoff
));
488 for (i
= 0; i
< DOF_UINT (dof
, dof
->dofh_secnum
); i
++, section
++)
489 if (section
->dofs_type
== DTRACE_DOF_SECT_TYPE_ECBDESC
)
492 /* Iterate over any section of type Provider and extract the probe
493 information from them. If there are no "provider" sections on
494 the DOF then we just return. */
495 section
= (struct dtrace_dof_sect
*) DTRACE_DOF_PTR (dof
,
496 DOF_UINT (dof
, dof
->dofh_secoff
));
497 for (i
= 0; i
< DOF_UINT (dof
, dof
->dofh_secnum
); i
++, section
++)
498 if (DOF_UINT (dof
, section
->dofs_type
) == DTRACE_DOF_SECT_TYPE_PROVIDER
)
500 struct dtrace_dof_provider
*provider
= (struct dtrace_dof_provider
*)
501 DTRACE_DOF_PTR (dof
, DOF_UINT (dof
, section
->dofs_offset
));
502 struct dtrace_dof_sect
*strtab_s
503 = DTRACE_DOF_SECT (dof
, DOF_UINT (dof
, provider
->dofpv_strtab
));
504 struct dtrace_dof_sect
*probes_s
505 = DTRACE_DOF_SECT (dof
, DOF_UINT (dof
, provider
->dofpv_probes
));
506 struct dtrace_dof_sect
*args_s
507 = DTRACE_DOF_SECT (dof
, DOF_UINT (dof
, provider
->dofpv_prargs
));
508 struct dtrace_dof_sect
*offsets_s
509 = DTRACE_DOF_SECT (dof
, DOF_UINT (dof
, provider
->dofpv_proffs
));
510 struct dtrace_dof_sect
*eoffsets_s
511 = DTRACE_DOF_SECT (dof
, DOF_UINT (dof
, provider
->dofpv_prenoffs
));
512 char *strtab
= DTRACE_DOF_PTR (dof
, DOF_UINT (dof
, strtab_s
->dofs_offset
));
513 char *offtab
= DTRACE_DOF_PTR (dof
, DOF_UINT (dof
, offsets_s
->dofs_offset
));
514 char *eofftab
= DTRACE_DOF_PTR (dof
, DOF_UINT (dof
, eoffsets_s
->dofs_offset
));
515 char *argtab
= DTRACE_DOF_PTR (dof
, DOF_UINT (dof
, args_s
->dofs_offset
));
516 unsigned int entsize
= DOF_UINT (dof
, probes_s
->dofs_entsize
);
519 if (DOF_UINT (dof
, section
->dofs_size
)
520 < sizeof (struct dtrace_dof_provider
))
522 /* The section is smaller than expected, so do not use it.
523 This has been observed on x86-solaris 10. */
524 goto invalid_dof_data
;
527 /* Very, unlikely, but could crash gdb if not handled
530 goto invalid_dof_data
;
532 num_probes
= DOF_UINT (dof
, probes_s
->dofs_size
) / entsize
;
534 for (i
= 0; i
< num_probes
; i
++)
536 struct dtrace_dof_probe
*probe
= (struct dtrace_dof_probe
*)
537 DTRACE_DOF_PTR (dof
, DOF_UINT (dof
, probes_s
->dofs_offset
)
538 + (i
* DOF_UINT (dof
, probes_s
->dofs_entsize
)));
540 dtrace_process_dof_probe (objfile
,
543 provider
, strtab
, offtab
, eofftab
, argtab
,
544 DOF_UINT (dof
, strtab_s
->dofs_size
));
551 complaint (&symfile_complaints
,
552 _("skipping section '%s' which does not contain valid DOF data."),
556 /* Helper function to build the GDB internal expressiosn that, once
557 evaluated, will calculate the values of the arguments of a given
561 dtrace_build_arg_exprs (struct dtrace_probe
*probe
,
562 struct gdbarch
*gdbarch
)
564 struct parser_state pstate
;
565 struct dtrace_probe_arg
*arg
;
568 probe
->args_expr_built
= 1;
570 /* Iterate over the arguments in the probe and build the
571 corresponding GDB internal expression that will generate the
572 value of the argument when executed at the PC of the probe. */
573 for (i
= 0; i
< probe
->probe_argc
; i
++)
575 struct cleanup
*back_to
;
577 arg
= VEC_index (dtrace_probe_arg_s
, probe
->args
, i
);
579 /* Initialize the expression buffer in the parser state. The
580 language does not matter, since we are using our own
582 initialize_expout (&pstate
, 10, current_language
, gdbarch
);
583 back_to
= make_cleanup (free_current_contents
, &pstate
.expout
);
585 /* The argument value, which is ABI dependent and casted to
587 gdbarch_dtrace_parse_probe_argument (gdbarch
, &pstate
, i
);
589 discard_cleanups (back_to
);
591 /* Casting to the expected type, but only if the type was
592 recognized at probe load time. Otherwise the argument will
593 be evaluated as the long integer passed to the probe. */
594 if (arg
->type
!= NULL
)
596 write_exp_elt_opcode (&pstate
, UNOP_CAST
);
597 write_exp_elt_type (&pstate
, arg
->type
);
598 write_exp_elt_opcode (&pstate
, UNOP_CAST
);
601 reallocate_expout (&pstate
);
602 arg
->expr
= pstate
.expout
;
603 prefixify_expression (arg
->expr
);
607 /* Helper function to return the Nth argument of a given PROBE. */
609 static struct dtrace_probe_arg
*
610 dtrace_get_arg (struct dtrace_probe
*probe
, unsigned n
,
611 struct gdbarch
*gdbarch
)
613 if (!probe
->args_expr_built
)
614 dtrace_build_arg_exprs (probe
, gdbarch
);
616 return VEC_index (dtrace_probe_arg_s
, probe
->args
, n
);
619 /* Implementation of the get_probes method. */
622 dtrace_get_probes (VEC (probe_p
) **probesp
, struct objfile
*objfile
)
624 bfd
*abfd
= objfile
->obfd
;
625 asection
*sect
= NULL
;
627 /* Do nothing in case this is a .debug file, instead of the objfile
629 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
632 /* Iterate over the sections in OBJFILE looking for DTrace
634 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
636 if (elf_section_data (sect
)->this_hdr
.sh_type
== SHT_SUNW_dof
)
640 /* Read the contents of the DOF section and then process it to
641 extract the information of any probe defined into it. */
642 if (!bfd_malloc_and_get_section (abfd
, sect
, &dof
))
643 complaint (&symfile_complaints
,
644 _("could not obtain the contents of"
645 "section '%s' in objfile `%s'."),
646 sect
->name
, abfd
->filename
);
648 dtrace_process_dof (sect
, objfile
, probesp
,
649 (struct dtrace_dof_hdr
*) dof
);
655 /* Helper function to determine whether a given probe is "enabled" or
656 "disabled". A disabled probe is a probe in which one or more
657 enablers are disabled. */
660 dtrace_probe_is_enabled (struct dtrace_probe
*probe
)
663 struct gdbarch
*gdbarch
= probe
->p
.arch
;
664 struct dtrace_probe_enabler
*enabler
;
667 VEC_iterate (dtrace_probe_enabler_s
, probe
->enablers
, i
, enabler
);
669 if (!gdbarch_dtrace_probe_is_enabled (gdbarch
, enabler
->address
))
675 /* Implementation of the get_probe_address method. */
678 dtrace_get_probe_address (struct probe
*probe
, struct objfile
*objfile
)
680 gdb_assert (probe
->pops
== &dtrace_probe_ops
);
681 return probe
->address
+ ANOFFSET (objfile
->section_offsets
,
682 SECT_OFF_DATA (objfile
));
685 /* Implementation of the get_probe_argument_count method. */
688 dtrace_get_probe_argument_count (struct probe
*probe_generic
,
689 struct frame_info
*frame
)
691 struct dtrace_probe
*dtrace_probe
= (struct dtrace_probe
*) probe_generic
;
693 gdb_assert (probe_generic
->pops
== &dtrace_probe_ops
);
695 return dtrace_probe
->probe_argc
;
698 /* Implementation of the can_evaluate_probe_arguments method. */
701 dtrace_can_evaluate_probe_arguments (struct probe
*probe_generic
)
703 struct gdbarch
*gdbarch
= probe_generic
->arch
;
705 gdb_assert (probe_generic
->pops
== &dtrace_probe_ops
);
706 return gdbarch_dtrace_parse_probe_argument_p (gdbarch
);
709 /* Implementation of the evaluate_probe_argument method. */
711 static struct value
*
712 dtrace_evaluate_probe_argument (struct probe
*probe_generic
, unsigned n
,
713 struct frame_info
*frame
)
715 struct gdbarch
*gdbarch
= probe_generic
->arch
;
716 struct dtrace_probe
*dtrace_probe
= (struct dtrace_probe
*) probe_generic
;
717 struct dtrace_probe_arg
*arg
;
720 gdb_assert (probe_generic
->pops
== &dtrace_probe_ops
);
722 arg
= dtrace_get_arg (dtrace_probe
, n
, gdbarch
);
723 return evaluate_subexp_standard (arg
->type
, arg
->expr
, &pos
, EVAL_NORMAL
);
726 /* Implementation of the compile_to_ax method. */
729 dtrace_compile_to_ax (struct probe
*probe_generic
, struct agent_expr
*expr
,
730 struct axs_value
*value
, unsigned n
)
732 struct dtrace_probe
*dtrace_probe
= (struct dtrace_probe
*) probe_generic
;
733 struct dtrace_probe_arg
*arg
;
734 union exp_element
*pc
;
736 gdb_assert (probe_generic
->pops
== &dtrace_probe_ops
);
738 arg
= dtrace_get_arg (dtrace_probe
, n
, expr
->gdbarch
);
740 pc
= arg
->expr
->elts
;
741 gen_expr (arg
->expr
, &pc
, expr
, value
);
743 require_rvalue (expr
, value
);
744 value
->type
= arg
->type
;
747 /* Implementation of the probe_destroy method. */
750 dtrace_probe_destroy (struct probe
*probe_generic
)
752 struct dtrace_probe
*probe
= (struct dtrace_probe
*) probe_generic
;
753 struct dtrace_probe_arg
*arg
;
756 gdb_assert (probe_generic
->pops
== &dtrace_probe_ops
);
758 for (i
= 0; VEC_iterate (dtrace_probe_arg_s
, probe
->args
, i
, arg
); i
++)
760 xfree (arg
->type_str
);
764 VEC_free (dtrace_probe_enabler_s
, probe
->enablers
);
765 VEC_free (dtrace_probe_arg_s
, probe
->args
);
768 /* Implementation of the type_name method. */
771 dtrace_type_name (struct probe
*probe_generic
)
773 gdb_assert (probe_generic
->pops
== &dtrace_probe_ops
);
777 /* Implementation of the gen_info_probes_table_header method. */
780 dtrace_gen_info_probes_table_header (VEC (info_probe_column_s
) **heads
)
782 info_probe_column_s dtrace_probe_column
;
784 dtrace_probe_column
.field_name
= "enabled";
785 dtrace_probe_column
.print_name
= _("Enabled");
787 VEC_safe_push (info_probe_column_s
, *heads
, &dtrace_probe_column
);
790 /* Implementation of the gen_info_probes_table_values method. */
793 dtrace_gen_info_probes_table_values (struct probe
*probe_generic
,
794 VEC (const_char_ptr
) **ret
)
796 struct dtrace_probe
*probe
= (struct dtrace_probe
*) probe_generic
;
797 const char *val
= NULL
;
799 gdb_assert (probe_generic
->pops
== &dtrace_probe_ops
);
801 if (VEC_empty (dtrace_probe_enabler_s
, probe
->enablers
))
803 else if (!gdbarch_dtrace_probe_is_enabled_p (probe_generic
->arch
))
805 else if (dtrace_probe_is_enabled (probe
))
810 VEC_safe_push (const_char_ptr
, *ret
, val
);
813 /* Implementation of the enable_probe method. */
816 dtrace_enable_probe (struct probe
*probe
)
818 struct gdbarch
*gdbarch
= probe
->arch
;
819 struct dtrace_probe
*dtrace_probe
= (struct dtrace_probe
*) probe
;
820 struct dtrace_probe_enabler
*enabler
;
823 gdb_assert (probe
->pops
== &dtrace_probe_ops
);
825 /* Enabling a dtrace probe implies patching the text section of the
826 running process, so make sure the inferior is indeed running. */
827 if (ptid_equal (inferior_ptid
, null_ptid
))
828 error (_("No inferior running"));
831 if (dtrace_probe_is_enabled (dtrace_probe
))
834 /* Iterate over all defined enabler in the given probe and enable
835 them all using the corresponding gdbarch hook. */
838 VEC_iterate (dtrace_probe_enabler_s
, dtrace_probe
->enablers
, i
, enabler
);
840 if (gdbarch_dtrace_enable_probe_p (gdbarch
))
841 gdbarch_dtrace_enable_probe (gdbarch
, enabler
->address
);
845 /* Implementation of the disable_probe method. */
848 dtrace_disable_probe (struct probe
*probe
)
850 struct gdbarch
*gdbarch
= probe
->arch
;
851 struct dtrace_probe
*dtrace_probe
= (struct dtrace_probe
*) probe
;
852 struct dtrace_probe_enabler
*enabler
;
855 gdb_assert (probe
->pops
== &dtrace_probe_ops
);
857 /* Disabling a dtrace probe implies patching the text section of the
858 running process, so make sure the inferior is indeed running. */
859 if (ptid_equal (inferior_ptid
, null_ptid
))
860 error (_("No inferior running"));
863 if (!dtrace_probe_is_enabled (dtrace_probe
))
866 /* Are we trying to disable a probe that does not have any enabler
868 if (VEC_empty (dtrace_probe_enabler_s
, dtrace_probe
->enablers
))
869 error (_("Probe %s:%s cannot be disabled: no enablers."), probe
->provider
, probe
->name
);
871 /* Iterate over all defined enabler in the given probe and disable
872 them all using the corresponding gdbarch hook. */
875 VEC_iterate (dtrace_probe_enabler_s
, dtrace_probe
->enablers
, i
, enabler
);
877 if (gdbarch_dtrace_disable_probe_p (gdbarch
))
878 gdbarch_dtrace_disable_probe (gdbarch
, enabler
->address
);
881 /* DTrace probe_ops. */
883 const struct probe_ops dtrace_probe_ops
=
885 dtrace_probe_is_linespec
,
887 dtrace_get_probe_address
,
888 dtrace_get_probe_argument_count
,
889 dtrace_can_evaluate_probe_arguments
,
890 dtrace_evaluate_probe_argument
,
891 dtrace_compile_to_ax
,
892 NULL
, /* set_semaphore */
893 NULL
, /* clear_semaphore */
894 dtrace_probe_destroy
,
896 dtrace_gen_info_probes_table_header
,
897 dtrace_gen_info_probes_table_values
,
902 /* Implementation of the `info probes dtrace' command. */
905 info_probes_dtrace_command (char *arg
, int from_tty
)
907 info_probes_for_ops (arg
, from_tty
, &dtrace_probe_ops
);
910 void _initialize_dtrace_probe (void);
913 _initialize_dtrace_probe (void)
915 VEC_safe_push (probe_ops_cp
, all_probe_ops
, &dtrace_probe_ops
);
917 add_cmd ("dtrace", class_info
, info_probes_dtrace_command
,
919 Show information about DTrace static probes.\n\
920 Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
921 Each argument is a regular expression, used to select probes.\n\
922 PROVIDER matches probe provider names.\n\
923 NAME matches the probe names.\n\
924 OBJECT matches the executable or shared library name."),
925 info_probes_cmdlist_get ());